v56-0012-Fixed-the-stale-xid64-problem-at-the-heapam_tupl.patch
text/x-patch
Filename: v56-0012-Fixed-the-stale-xid64-problem-at-the-heapam_tupl.patch
Type: text/x-patch
Part: 11
Patch
Same data as JSON:
GET /api/v1/attachments/:id/patch
the parsed metadata as JSON — format, series position, per-file stats; never the diff bytes.
API reference →
Format: format-patch
Series: patch v56-0012
Subject: Fixed the stale xid64 problem at the heapam_tuple_satisfies_snapshot function.
| File | + | − |
|---|---|---|
| baloo/conf.json | 25 | 0 |
| baloo/dev/devcfgli.sh | 433 | 0 |
| baloo/dev/.gitignore | 3 | 0 |
| baloo/dev/patch_ripper.pl | 78 | 0 |
| baloo/patches/func/0001-Use-64-bit-XIDs.patch | 16707 | 0 |
| baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0001-Use-64-bit-format-output-for-multixact-offsets.patch | 203 | 0 |
| baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0002-Use-64-bit-multixact-offsets.patch | 342 | 0 |
| baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0003-Make-pg_upgrade-convert-multixact-offsets.patch | 486 | 0 |
| baloo/patches/func/pg18xid64v56/0020-GUC64-v1-0001-Support-64-bit-integer-GUCs.patch | 1110 | 0 |
| baloo/patches/func/pg18xid64v56/0030-XID64-v56-0001-Use-64-bit-format-to-output-XIDs.patch | 3156 | 0 |
| baloo/patches/func/pg18xid64v56/0030-XID64-v56-0002-Use-64-bit-FullTransactionId-instead-of-Epoch-xi.patch | 463 | 0 |
| baloo/patches/func/pg18xid64v56/0030-XID64-v56-0003-Use-64-bit-SLRU-pages-in-callers.patch | 97 | 0 |
| baloo/patches/func/pg18xid64v56/0030-XID64-v56-0005-README.XID64.patch | 161 | 0 |
| baloo/patches/func/pg18xid64v56/0030-XID64-v56-0006-Use-64-bit-XIDs.patch | 17993 | 0 |
| baloo/patches/func/xid64.patch | 16689 | 0 |
| src/backend/access/heap/heapam_handler.c | 8 | 0 |
From d955c939aea2b0177c434c07532f2733c490e3b9 Mon Sep 17 00:00:00 2001
From: Evgeny Voropaev <evorop@gmail.com>
Date: Sun, 8 Dec 2024 23:47:31 +0800
Subject: [PATCH v56 12/12] Fixed the stale xid64 problem at the
heapam_tuple_satisfies_snapshot function.
This issue mostly appeared in practice as the "missing chunk" error during operations on TOASTS of the pg_statistic table.
Author: Ivan Kushnarenko <ivan.kush@tantorlabs.com>
Author: Evgeny Voropaev <evorop@gmail.com> <evgeny.voropaev@tantorlabs.ru>
---
baloo/conf.json | 25 +
baloo/dev/.gitignore | 3 +
baloo/dev/devcfgli.sh | 433 +
baloo/dev/patch_ripper.pl | 78 +
baloo/patches/func/0001-Use-64-bit-XIDs.patch | 16707 ++++++++++++++
...-format-output-for-multixact-offsets.patch | 203 +
...v4-0002-Use-64-bit-multixact-offsets.patch | 342 +
...pg_upgrade-convert-multixact-offsets.patch | 486 +
...-v1-0001-Support-64-bit-integer-GUCs.patch | 1110 +
...001-Use-64-bit-format-to-output-XIDs.patch | 3156 +++
...ullTransactionId-instead-of-Epoch-xi.patch | 463 +
...003-Use-64-bit-SLRU-pages-in-callers.patch | 97 +
.../0030-XID64-v56-0005-README.XID64.patch | 161 +
.../0030-XID64-v56-0006-Use-64-bit-XIDs.patch | 17993 ++++++++++++++++
baloo/patches/func/xid64.patch | 16689 ++++++++++++++
src/backend/access/heap/heapam_handler.c | 8 +
16 files changed, 57954 insertions(+)
create mode 100644 baloo/conf.json
create mode 100644 baloo/dev/.gitignore
create mode 100644 baloo/dev/devcfgli.sh
create mode 100755 baloo/dev/patch_ripper.pl
create mode 100644 baloo/patches/func/0001-Use-64-bit-XIDs.patch
create mode 100644 baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0001-Use-64-bit-format-output-for-multixact-offsets.patch
create mode 100644 baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0002-Use-64-bit-multixact-offsets.patch
create mode 100644 baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0003-Make-pg_upgrade-convert-multixact-offsets.patch
create mode 100644 baloo/patches/func/pg18xid64v56/0020-GUC64-v1-0001-Support-64-bit-integer-GUCs.patch
create mode 100644 baloo/patches/func/pg18xid64v56/0030-XID64-v56-0001-Use-64-bit-format-to-output-XIDs.patch
create mode 100644 baloo/patches/func/pg18xid64v56/0030-XID64-v56-0002-Use-64-bit-FullTransactionId-instead-of-Epoch-xi.patch
create mode 100644 baloo/patches/func/pg18xid64v56/0030-XID64-v56-0003-Use-64-bit-SLRU-pages-in-callers.patch
create mode 100644 baloo/patches/func/pg18xid64v56/0030-XID64-v56-0005-README.XID64.patch
create mode 100644 baloo/patches/func/pg18xid64v56/0030-XID64-v56-0006-Use-64-bit-XIDs.patch
create mode 100644 baloo/patches/func/xid64.patch
diff --git a/baloo/conf.json b/baloo/conf.json
new file mode 100644
index 00000000000..4bb7ec4b531
--- /dev/null
+++ b/baloo/conf.json
@@ -0,0 +1,25 @@
+{
+ "editions": {
+ "comm": {
+ "id": "1",
+ "prog_name": "community",
+ "short_name": "comm",
+ "name": "PostgreSQL 16.4 Original Community Edition",
+ "product_name_in_doc": "PostgreSQL Comm",
+ "patches": [
+ ],
+ "description": "PostgreSQL 16.4 original community edition (aka Vanilla)."
+ },
+ "pg18xid64": {
+ "id": "1",
+ "prog_name": "pg18xid64",
+ "short_name": "pg18xid64v56",
+ "name": "PostgreSQL 18 Xid64 Edition",
+ "product_name_in_doc": "Tantor SE",
+ "patches": [
+ "func/pg18xid64v56"
+ ],
+ "description": "PostgreSQL 18 edition upgraded by the xid64 patch"
+ }
+ }
+}
diff --git a/baloo/dev/.gitignore b/baloo/dev/.gitignore
new file mode 100644
index 00000000000..02279213fed
--- /dev/null
+++ b/baloo/dev/.gitignore
@@ -0,0 +1,3 @@
+cache/*
+logs/*
+inst/*
diff --git a/baloo/dev/devcfgli.sh b/baloo/dev/devcfgli.sh
new file mode 100644
index 00000000000..fb1370b70b3
--- /dev/null
+++ b/baloo/dev/devcfgli.sh
@@ -0,0 +1,433 @@
+#!/usr/bin/bash
+# File: devcfgcli.sh
+# Created: 06.09.2024
+# Author: Evgeny Voropaev
+
+# ==============================================================================
+# Examples of usage:
+#
+# # Being in the top directory of the project, include helpers into your current terminal session:
+# source baloo/dev/devcfgcli.sh
+#
+# # Generate a script that comprises a sequence of applying patches:
+# bl_create_patching_file <edition_name>
+# # Example: create_patching_file se
+#
+# # If a patch from the sequence has been successfully applied, you will see commits added
+# # to the current branch, and the local git state will be clean (except for files in the baloo directory).
+#
+# # You can also clear local changes by using the function:
+# bl_clear_project_dir
+#
+# # Split a patch into mini-patches, each for a single file, and create a script to apply them:
+# bl_split_patch <patch_file>
+# # Example: bl_split_patch baloo/patches/fix/common/my_patch.patch
+#
+# # Clean up all mini-patches and related scripts:
+# bl_clean_patch_cache
+# ==============================================================================
+
+# Calculate the project directory relative to the script location
+DBG_PROJ_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.."; pwd)"
+DBG_BALOO_DIR="${DBG_PROJ_DIR}/baloo"
+DBG_PATCH_DIR="${DBG_BALOO_DIR}/patches"
+DBG_PATCH_CACHE_DIR=${DBG_BALOO_DIR}/dev/cache/patches
+DBG_INST_DIR=${DBG_PROJ_DIR}/baloo/dev/inst
+DBG_COPT="-Werror"
+
+# Function to apply patches, stage changes, and commit
+dbg_apply_patch() {
+ local patch="$1"
+
+ # Extract relative path for commit message
+ local relative_patch_path="${patch#${DBG_PROJ_DIR}/}"
+
+ set +x
+ echo "========================================================="
+ echo "STARTED APPLYING THE ${patch}"
+ echo "========================================================="
+ set -x
+
+ git apply -v "${patch}"
+
+ set +x
+ echo "-------------------------------------------------------------"
+ echo "The patch ${patch} has been SUCCESSFULLY APPLIED."
+ echo "-------------------------------------------------------------"
+ set -x
+
+ git add . ':!baloo'
+ git commit -m "Applied the ${relative_patch_path}."
+
+ set +x
+ echo "-------------------------------------------------------------"
+ echo "CREATED THE COMMIT COMPRISING FILES MODIFIED BY THE ${relative_patch_path} PATCH."
+ echo "-------------------------------------------------------------"
+ set -x
+}
+
+dbg_am_patch() {
+ local patch="$1"
+
+ # Extract relative path for commit message
+ local relative_patch_path="${patch#${DBG_PROJ_DIR}/}"
+
+ set +x
+ echo "========================================================="
+ echo "STARTED APPLYING THE ${patch}"
+ echo "========================================================="
+ set -x
+
+ git am "${patch}"
+
+ set +x
+ echo "-------------------------------------------------------------"
+ echo "The patch ${patch} has been SUCCESSFULLY APPLIED and COMMITED."
+ echo "-------------------------------------------------------------"
+ set -x
+}
+
+# Function to clear the project directory, restoring to the last commit and removing untracked files, excluding the 'baloo' directory
+dbg_clean_project_dir() {
+ git restore --source=HEAD --worktree -- ":(exclude)${DBG_BALOO_DIR}/*" ':(exclude).gitlab-ci.yml'
+ git clean -fdx -- ":(exclude)${DBG_BALOO_DIR}/*"
+}
+
+# Function to clean up all mini-patches and related scripts
+dbg_clean_patch_cache() {
+ echo "Cleaning up patch cache..."
+ rm -rf "${DBG_PATCH_CACHE_DIR}"
+ echo "Cleanup complete."
+}
+
+# Function to create a patch from local changes
+dbg_retrieve_diff_from_local_changes() {
+ local base_commit="$1"
+
+ git add . ':!.gitlab-ci.yml' ':!baloo'
+ mkdir -p ${DBG_BALOO_DIR}/dev/cache/patches
+
+ if [ -z "$base_commit" ]; then
+ base_commit="HEAD"
+ fi
+
+ git diff --staged --patch --stat $base_commit -- ':!.gitlab-ci.yml' ':!baloo' > ${DBG_PATCH_CACHE_DIR}/diff_from_local_changes.patch
+
+ git restore --staged -- '*'
+}
+
+# Function to split a patch into mini-patches, each containing changes for a single file
+dbg_split_patch() {
+ local patch_file="$1"
+ local patch_name=$(basename "$patch_file" .patch)
+ local output_dir="${DBG_PATCH_CACHE_DIR}/mini/${patch_name}"
+ local apply_script="${DBG_PATCH_CACHE_DIR}/mini/apply_${patch_name}_minis.sh"
+ local devcfgli_script="$(cd $(dirname ${BASH_SOURCE}); pwd)/$(basename ${BASH_SOURCE})"
+
+ # Check if the patch file exists, and if not, try to locate it in DBG_PATCH_DIR
+ if [[ ! -f "$patch_file" ]]; then
+ patch_file="${DBG_PATCH_DIR}/${patch_file}"
+ if [[ ! -f "$patch_file" ]]; then
+ echo "Error: Patch file ${patch_file} not found."
+ return 1
+ fi
+ fi
+
+ mkdir -p "$output_dir"
+
+ # Get the absolute path of the output directory
+ local abs_output_dir=$(cd "$output_dir"; pwd)
+
+ # Split the patch file into mini-patches, one per file with 4-digit numbering
+ local mini_patch_num=1
+ awk '
+ /^diff --git/ {
+ if (f) close(f)
+ f=sprintf("'"$abs_output_dir"'/mini%04d-%s.patch", mini_patch_num++, "'"$patch_name"'")
+ }
+ { if (f) print > f }
+ END { if (mini_patch_num == 1) exit 1 }
+ ' "$patch_file"
+
+ if [[ $? -ne 0 ]]; then
+ echo "Error: No valid diffs found in the patch file."
+ return 1
+ fi
+
+ echo "Split patch created in ${abs_output_dir}"
+
+
+ # Generate the script to apply the mini-patches
+
+ cat > "$apply_script" << EOL
+#!/usr/bin/bash
+# Automatically generated script for applying mini-patches for ${patch_name}
+
+MINI_PATCH_DIR="${abs_output_dir}"
+PATCH_NAME="${patch_name}"
+DEVCFGCLI_SCRIPT="${devcfgli_script}"
+
+# Enhanced PS4 with timestamp and source info for debugging
+PS4='\[\e[1;33m\]+ \[\e[1;32m\]\$(date "+%Y%m%d:%H%M%S.%N") \[\e[1;34m\]\$(basename \${BASH_SOURCE})\[\e[1;35m\]:\[\e[1;31m\]\${LINENO}\[\e[0m\]: '
+
+# Set shell options: -e (exit on error), -x (trace commands), -u (unset variables as an error), -o pipefail (pipe status)
+set -exu -o pipefail
+
+# Logfile setup
+LOGFILE="\${MINI_PATCH_DIR}/apply_\${PATCH_NAME}_minis.log"
+exec &> >(tee -a "\${LOGFILE}")
+
+source "\${DEVCFGCLI_SCRIPT}"
+
+EOL
+
+ for mini_patch in "$abs_output_dir"/*.patch; do
+ local mini_patch_name=$(basename "$mini_patch")
+ echo "dbg_apply_patch \"\${MINI_PATCH_DIR}/${mini_patch_name}\" " >> "$apply_script"
+ done
+
+ chmod +x "$apply_script"
+ echo "Script $apply_script has been created."
+}
+
+# Function to validate the edition name and create a corresponding apply patch file
+dbg_create_patching_script_for_edition() {
+ local edition_name="$1"
+
+ local config_file="${DBG_BALOO_DIR}/conf.json"
+ local patches_dir="${DBG_BALOO_DIR}/patches"
+ local output_script_dir="${DBG_PATCH_CACHE_DIR}"
+ local edition_cfg=$(jq -r ".editions.${edition_name}" "$config_file")
+
+ if [[ ! $edition_cfg || "null" == "$edition_cfg" ]]; then
+ echo "Error: Invalid edition name '${edition_name}'. There is no this edition in the configuration (conf.json)."
+ return 1
+ fi
+
+ local edition_full_name=$(jq -r ".editions.${edition_name}.name" "$config_file")
+
+
+ mkdir -p "$output_script_dir"
+
+ local patch_group=$(jq -r ".editions.${edition_name}.patches[]" "$config_file")
+
+ local output_script="${output_script_dir}/apply_${edition_name}.sh"
+
+ if [ -f "$output_script" ]; then
+ local backup_num=1
+ local backup_file="${output_script}.${backup_num}"
+ while [ -f "$backup_file" ]; do
+ backup_num=$((backup_num + 1))
+ backup_file="${output_script}.${backup_num}"
+ done
+ mv "$output_script" "$backup_file"
+ echo "Existing script backed up as $backup_file"
+ fi
+
+ local devcfgli_script="$(cd $(dirname ${BASH_SOURCE}); pwd)/$(basename ${BASH_SOURCE})"
+
+ cat > ${output_script} << EOL
+#!/usr/bin/bash
+# Automatically generated script for applying patches groups for the ${edition_name} edition of the customized PostgreSQL project (Baloo)
+# Created by the function 'dbg_create_patching_file' from the script ${devcfgli_script}
+
+# Set shell options: -e (exit on error), -x (trace commands), -u (unset variables as an error), -o pipefail (pipe status)
+set -exu -o pipefail
+
+# Determine the directory where the script is located
+SCRIPT_DIR=\$(cd "\$(dirname "\${BASH_SOURCE}")"; pwd)
+
+DEVCFGCLI_SCRIPT="${devcfgli_script}"
+
+source "\${DEVCFGCLI_SCRIPT}"
+
+# Enhanced PS4 with timestamp and source info for debugging
+PS4='\[\e[1;33m\]+ \[\e[1;32m\]\$(date "+%Y%m%d:%H%M%S.%N") \[\e[1;34m\]\$(basename \${BASH_SOURCE})\[\e[1;35m\]:\[\e[1;31m\]\${LINENO}\[\e[0m\]: '
+
+# Logfile setup
+LOGFILE="\${SCRIPT_DIR}/applying_patches_${edition_name}.log"
+exec &> >(tee -a "\${LOGFILE}")
+
+EOL
+
+ cat >> ${output_script} << EOL
+ # Alternative approach for applying patches.
+EOL
+
+ for patch in $patch_group; do
+ local patch_files=$(find "${DBG_PATCH_DIR}/${patch}" -type f -name "*.patch" | sort)
+ for file in $patch_files; do
+ local relative_path="${file#${DBG_PATCH_DIR}/}"
+ echo "dbg_apply_patch \"\${DBG_PATCH_DIR}/${relative_path}\"" >> "$output_script"
+ done
+ done
+
+ cat >> ${output_script} << EOL
+ # Alternative approach for applying patches.
+EOL
+
+ for patch in $patch_group; do
+ local patch_files=$(find "${DBG_PATCH_DIR}/${patch}" -type f -name "*.patch" | sort)
+ for file in $patch_files; do
+ local relative_path="${file#${DBG_PATCH_DIR}/}"
+ echo "# dbg_am_patch \"\${DBG_PATCH_DIR}/${relative_path}\"" >> "$output_script"
+ done
+ done
+
+ chmod +x "$output_script"
+ echo "Script $output_script has been created."
+}
+
+dbg_configure() {
+ local CFLAGS="-O0 -g3 -pipe -Wno-missing-braces"
+ # local CFLAGS="-O0 -g3 -pipe -Werror -Wno-missing-braces"
+ echo "========================================================="
+ echo "BALOO: STARTED CONFIGURING =============================>"
+ echo "========================================================="
+ set -x
+ ./configure --prefix="${DBG_INST_DIR}" \
+ CFLAGS="$CFLAGS" \
+ --with-icu \
+ --enable-tap-tests \
+ --enable-debug \
+ --enable-cassert \
+ --enable-depend \
+ --enable-injection-points
+ set +x
+ echo "========================================================="
+ echo "BALOO: FINISHED CONFIGURING"
+ echo "========================================================="
+}
+
+dbg_build_core() {
+ echo "========================================================="
+ echo "BALOO: STARTED BUILDING CORE =========>"
+ echo "========================================================="
+
+ cd "${DBG_PROJ_DIR}"
+ make COPT='${DBG_COPT}' -j5
+ cd -
+
+ echo "========================================================="
+ echo "BALOO: FINISHED BUILDING CORE "
+ echo "========================================================="
+}
+
+dbg_build_contribs() {
+ echo "========================================================="
+ echo "BALOO: STARTED BUILDING CONTRIBS =========>"
+ echo "========================================================="
+
+ cd "${DBG_PROJ_DIR}/contrib"
+ make COPT='${DBG_COPT}' -j5
+ cd -
+
+ echo "========================================================="
+ echo "BALOO: FINISHED BUILDING CONTRIBS "
+ echo "========================================================="
+}
+
+dbg_install() {
+ echo "========================================================="
+ echo "BALOO: STARTED INSTALLING =============================>"
+ echo "========================================================="
+ set -x
+ cd "${DBG_PROJ_DIR}"
+ make install
+ cd -
+ set +x
+
+ echo "---------------------------------------------------------"
+ echo "CREATING INSTALLATION HELPERS in ${DBG_INST_DIR}/instcfgcli.sh"
+ echo "---------------------------------------------------------"
+
+ local installation_cli_configurator="${DBG_INST_DIR}/instcfgcli.sh"
+ cat >"${installation_cli_configurator}" << EOF
+#!/usr/bin/bash
+export PGINSTDIR="${DBG_INST_DIR}"
+export PGDATA="${DBG_INST_DIR}/data"
+export PGPORT="5888"
+export PGUSER="$(whoami)"
+export PGDATABASE="postgres"
+export PGHOST="localhost"
+export PATH="${DBG_INST_DIR}/bin:\$PATH"
+LD_LIBRARY_PATH=\${LD_LIBRARY_PATH:-''}
+export LD_LIBRARY_PATH="\${PGINSTDIR}/lib:\${LD_LIBRARY_PATH}"
+export PSQLRC="${DBG_INST_DIR}/.psqlrc"
+
+inst_init() {
+ initdb -D \$PGDATA
+ echo "port=\$PGPORT" >> \$PGDATA/postgresql.conf #Change it to substitution with SED
+ #echo "shared_preload_libraries='online_analyze,plantuner,dbcopies_decoding'" >> \$PGDATA/postgresql.conf
+ echo "unix_socket_directories='/tmp'" >> \$PGDATA/postgresql.conf
+}
+
+inst_start() {
+ pg_ctl -D \$PGDATA -l \$PGDATA/logfile start
+}
+
+inst_stop() {
+ pg_ctl -D \$PGDATA stop
+}
+EOF
+ echo "========================================================="
+ echo "FINISHED INSTALLING"
+ echo "========================================================="
+}
+
+dbg_install_contribs() {
+ echo "========================================================="
+ echo "BALOO: STARTED INSTALLING CONTRIBS =========>"
+ echo "========================================================="
+
+ cd "${DBG_PROJ_DIR}/contrib"
+ make install
+ cd -
+
+ echo "========================================================="
+ echo "BALOO: FINISHED INSTALLING CONTRIBS "
+ echo "========================================================="
+}
+
+
+dbg_generate_support_of_tantor_installation(){
+ local TT_VER="16"
+ local TT_ED="se-1c"
+ cat > ttinstcfgcli.sh << EOF
+#!/usr/bin/bash
+export PGINSTDIR="/opt/tantor/db/${TT_VER}"
+export PATH="\${PGINSTDIR}/bin:\$PATH"
+export PGDATA="/var/lib/postgresql/tantor-${TT_ED}-${TT_VER}/data"
+EOF
+}
+
+dbg_generate_debug_config_for_vscode(){
+ mkdir -p "$DBG_PROJ_DIR/.vscode"
+ cat > "$DBG_PROJ_DIR/.vscode/launch.json" << EOF
+{
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "name": "(gdb) Attach",
+ "type": "cppdbg",
+ "request": "attach",
+ "program": "${DBG_INST_DIR}/bin/postgres",
+ "MIMode": "gdb",
+ "setupCommands": [
+ {
+ "description": "Enable pretty-printing for gdb",
+ "text": "-enable-pretty-printing",
+ "ignoreFailures": true
+ },
+ {
+ "description": "Set Disassembly Flavor to Intel",
+ "text": "-gdb-set disassembly-flavor intel",
+ "ignoreFailures": true
+ }
+ ]
+ }
+ ]
+}
+
+EOF
+}
\ No newline at end of file
diff --git a/baloo/dev/patch_ripper.pl b/baloo/dev/patch_ripper.pl
new file mode 100755
index 00000000000..dde526ee541
--- /dev/null
+++ b/baloo/dev/patch_ripper.pl
@@ -0,0 +1,78 @@
+#!/usr/bin/perl
+# File name: patch_ripper.pl
+# Creation date: 18.11.2024
+# Author: Evgeny Voropaev <evorop@gmail.com>
+
+use strict;
+use warnings;
+use File::Basename;
+use File::Spec;
+use Cwd 'abs_path';
+
+# Set strict error handling
+use autodie;
+
+# Calculate the project directory relative to the script location
+my $script_dir = dirname(__FILE__);
+my $PROJ_DIR = File::Spec->catdir($script_dir, '../../..');
+my $BALOO_DIR = File::Spec->catdir($PROJ_DIR, 'baloo');
+
+# Check if correct number of arguments is provided
+if (@ARGV != 1) {
+ die "Input patch is not defined. Usage: $0 <input_patch>\n";
+}
+
+my $input_patch_name = $ARGV[0];
+my $input_patch_dir = dirname($input_patch_name);
+
+# Check if input patch exists
+unless (-e $input_patch_name) {
+ die "Error: Patch file '$input_patch_name' does not exist.\n";
+}
+
+open(my $in, '<', $input_patch_name);
+
+my $output_patch_dir = $input_patch_dir . "/ripped/";
+mkdir($output_patch_dir);
+my $output_patch_name = $output_patch_dir . "patchheader.txt";
+open(my $out, '>', $output_patch_name);
+
+my $patched_file_name;
+while (my $line = <$in>) {
+ if ( $line =~ /^diff --git/ ) {
+ ($patched_file_name) = ($line =~ /(?<=b\/)(.*)$/);
+ $output_patch_name = $output_patch_dir . get_output_patch_name($patched_file_name);
+ close $out;
+ open($out, '>>', $output_patch_name);
+ }
+ print $out "$line";
+}
+
+sub get_output_patch_name {
+ my ($patched_file_name) = @_;
+ my @units = (
+ ["transam", "src/backend/access/transam", "src/include/access/transam"],
+ ["heap", "src/backend/access/heap", "src/include/access/heap"],
+ ["access", "src/backend/access/", "src/include/access/"],
+ ["buffer", "src/backend/storage/buffer", "src/include/storage/buf"],
+ ["storage", "src/backend/storage", "src/include/storage"],
+ ["utils", "src/backend/utils", "src/include/utils"],
+ ["backend", "src/backend/"],
+ ["bin", "src/bin/"],
+ ["common", "src/common/"],
+ ["test", "src/test/"],
+ ["src", "src/"],
+ ["contrib", "contrib/"],
+ ["doc", "doc/"],
+ );
+
+ for my $u ( 0 .. $#units ) {
+ for my $p ( 1 .. $units[$u]->$#* ) {
+ if ( $patched_file_name =~ /^$units[$u][$p]/ ) {
+ return $units[$u][0] . ".patch";
+ }
+ }
+ }
+
+ return "other.patch";
+}
\ No newline at end of file
diff --git a/baloo/patches/func/0001-Use-64-bit-XIDs.patch b/baloo/patches/func/0001-Use-64-bit-XIDs.patch
new file mode 100644
index 00000000000..2d3229063ef
--- /dev/null
+++ b/baloo/patches/func/0001-Use-64-bit-XIDs.patch
@@ -0,0 +1,16707 @@
+From fa679002517e0b0081c5afb60740366af8f692ab Mon Sep 17 00:00:00 2001
+From: Evgeny Voropaev <evorop@gmail.com>
+Date: Wed, 4 Dec 2024 20:51:29 +0800
+Subject: [PATCH] Use 64-bit XIDs
+
+- change TransactionId to 64bit
+- disk tuple format (HeapTupleHeader) is (almost) unchanged: xmin and xmax remains 32bit
+ -- now 32bit xid is named ShortTransactionId
+- heap page format is changed to contain xid and multixact base value, tuple's
+ xmin and xmax are offsets from.
+ -- xid_base and multi_base are stored as a page special data. PageHeader remains unmodified.
+- in-memory tuple (HeapTuple) were enriched with precalculated 64bit xmin/xmax.
+
+Authors:
+- Alexander Korotkov <aekorotkov@gmail.com>
+- Teodor Sigaev <teodor@sigaev.ru>
+- Nikita Glukhov <n.gluhov@postgrespro.ru>
+- Maxim Orlov <orlovmg@gmail.com>
+- Pavel Borisov <pashkin.elfe@gmail.com>
+- Yura Sokolov <y.sokolov@postgrespro.ru> <funny.falcon@gmail.com>
+- Aleksander Alekseev <aleksander@timescale.com>
+- Evgeny Voropaev <evorop@gmail.com> <evgeny.voropaev@tantorlabs.ru>
+
+Discussion: https://www.postgresql.org/message-id/flat/CACG%3DezZe1NQSCnfHOr78AtAZxJZeCvxrts0ygrxYwe%3DpyyjVWA%40mail.gmail.com
+---
+ contrib/amcheck/verify_heapam.c | 119 +--
+ contrib/amcheck/verify_nbtree.c | 2 +-
+ contrib/hstore/hstore_io.c | 2 +
+ contrib/pageinspect/Makefile | 3 +-
+ contrib/pageinspect/btreefuncs.c | 18 +-
+ contrib/pageinspect/expected/btree.out | 4 +-
+ contrib/pageinspect/expected/hash_1.out | 166 +++
+ .../pageinspect/expected/oldextversions.out | 10 +-
+ contrib/pageinspect/expected/page.out | 28 +-
+ contrib/pageinspect/heapfuncs.c | 10 +-
+ .../pageinspect/pageinspect--1.12--1.13.sql | 145 +++
+ contrib/pageinspect/pageinspect--1.5.sql | 2 +
+ contrib/pageinspect/rawpage.c | 35 +-
+ contrib/pageinspect/sql/btree.sql | 3 +-
+ contrib/pg_surgery/heap_surgery.c | 17 +-
+ contrib/pg_visibility/pg_visibility.c | 7 +-
+ contrib/pgrowlocks/pgrowlocks.c | 2 +-
+ contrib/pgstattuple/pgstatapprox.c | 4 +
+ contrib/pgstattuple/pgstatindex.c | 2 +-
+ .../postgres_fdw/expected/postgres_fdw.out | 55 +-
+ contrib/postgres_fdw/postgres_fdw.c | 9 +-
+ contrib/postgres_fdw/sql/postgres_fdw.sql | 15 +-
+ src/backend/access/common/heaptuple.c | 10 +-
+ src/backend/access/heap/heapam.c | 999 +++++++++++++++---
+ src/backend/access/heap/heapam_handler.c | 62 +-
+ src/backend/access/heap/heapam_visibility.c | 173 +--
+ src/backend/access/heap/heapam_xlog.c | 161 ++-
+ src/backend/access/heap/heaptoast.c | 3 +
+ src/backend/access/heap/hio.c | 36 +-
+ src/backend/access/heap/pruneheap.c | 131 ++-
+ src/backend/access/heap/rewriteheap.c | 101 +-
+ src/backend/access/heap/vacuumlazy.c | 144 +--
+ src/backend/access/nbtree/nbtpage.c | 2 +
+ src/backend/access/nbtree/nbtsplitloc.c | 16 +-
+ src/backend/access/rmgrdesc/gistdesc.c | 4 +-
+ src/backend/access/rmgrdesc/heapdesc.c | 34 +-
+ src/backend/access/rmgrdesc/nbtdesc.c | 4 +-
+ src/backend/access/rmgrdesc/xactdesc.c | 6 +-
+ src/backend/access/rmgrdesc/xlogdesc.c | 2 +-
+ src/backend/access/transam/clog.c | 19 +-
+ src/backend/access/transam/commit_ts.c | 19 -
+ src/backend/access/transam/multixact.c | 52 +-
+ src/backend/access/transam/slru.c | 11 +-
+ src/backend/access/transam/subtrans.c | 13 +-
+ src/backend/access/transam/transam.c | 18 +-
+ src/backend/access/transam/twophase.c | 55 +-
+ src/backend/access/transam/varsup.c | 177 +---
+ src/backend/access/transam/xact.c | 35 +-
+ src/backend/access/transam/xlog.c | 9 +-
+ src/backend/access/transam/xloginsert.c | 7 +
+ src/backend/access/transam/xlogreader.c | 34 -
+ src/backend/bootstrap/bootstrap.c | 2 +-
+ src/backend/catalog/heap.c | 8 +-
+ src/backend/catalog/pg_inherits.c | 2 +-
+ src/backend/commands/async.c | 2 +-
+ src/backend/commands/dbcommands.c | 9 +-
+ src/backend/commands/indexcmds.c | 6 +-
+ src/backend/commands/sequence.c | 30 +-
+ src/backend/commands/vacuum.c | 20 +-
+ src/backend/executor/execExprInterp.c | 1 +
+ src/backend/executor/execTuples.c | 4 +-
+ src/backend/executor/execUtils.c | 1 +
+ src/backend/executor/nodeModifyTable.c | 1 +
+ src/backend/executor/spi.c | 1 +
+ src/backend/nodes/gen_node_support.pl | 6 +-
+ src/backend/optimizer/util/plancat.c | 2 +-
+ src/backend/postmaster/autovacuum.c | 64 +-
+ src/backend/replication/logical/conflict.c | 20 +-
+ src/backend/replication/logical/decode.c | 24 +-
+ src/backend/replication/logical/proto.c | 50 +-
+ .../replication/logical/reorderbuffer.c | 17 +-
+ src/backend/replication/logical/slotsync.c | 2 +-
+ src/backend/replication/logical/snapbuild.c | 4 +-
+ src/backend/replication/logical/worker.c | 2 +-
+ src/backend/replication/walreceiver.c | 28 +-
+ src/backend/replication/walsender.c | 73 +-
+ src/backend/statistics/extended_stats.c | 1 +
+ src/backend/storage/buffer/Makefile | 3 +-
+ src/backend/storage/buffer/bufmgr.c | 123 +++
+ src/backend/storage/buffer/heap_convert.c | 549 ++++++++++
+ src/backend/storage/buffer/meson.build | 1 +
+ src/backend/storage/ipc/procarray.c | 186 ++--
+ src/backend/storage/ipc/standby.c | 4 +-
+ src/backend/storage/lmgr/lmgr.c | 14 +-
+ src/backend/storage/lmgr/lock.c | 4 +-
+ src/backend/storage/lmgr/predicate.c | 31 +-
+ src/backend/storage/lmgr/proc.c | 12 +-
+ src/backend/storage/page/bufpage.c | 254 ++++-
+ src/backend/utils/adt/enum.c | 2 +-
+ src/backend/utils/adt/jsonfuncs.c | 2 +
+ src/backend/utils/adt/lockfuncs.c | 9 +-
+ src/backend/utils/adt/pgstatfuncs.c | 1 +
+ src/backend/utils/adt/rowtypes.c | 12 +
+ src/backend/utils/adt/xid.c | 37 +-
+ src/backend/utils/adt/xid8funcs.c | 89 +-
+ src/backend/utils/cache/catcache.c | 1 +
+ src/backend/utils/cache/relcache.c | 3 +-
+ src/backend/utils/fmgr/fmgr.c | 4 +-
+ src/backend/utils/misc/guc_tables.c | 164 +--
+ src/backend/utils/misc/help_config.c | 8 +-
+ src/backend/utils/misc/pg_controldata.c | 2 +-
+ src/backend/utils/misc/postgresql.conf.sample | 2 +-
+ src/backend/utils/sort/tuplesortvariants.c | 14 +-
+ src/backend/utils/time/combocid.c | 20 +-
+ src/backend/utils/time/snapmgr.c | 24 +-
+ src/bin/pg_amcheck/t/004_verify_heapam.pl | 185 +++-
+ src/bin/pg_controldata/pg_controldata.c | 2 +-
+ src/bin/pg_dump/pg_dump.c | 27 +-
+ src/bin/pg_dump/pg_dump.h | 8 +-
+ src/bin/pg_resetwal/pg_resetwal.c | 53 +-
+ src/bin/pg_resetwal/t/001_basic.pl | 18 +-
+ src/bin/pg_upgrade/check.c | 149 ++-
+ src/bin/pg_upgrade/controldata.c | 17 +-
+ src/bin/pg_upgrade/file.c | 99 +-
+ src/bin/pg_upgrade/pg_upgrade.c | 104 +-
+ src/bin/pg_upgrade/pg_upgrade.h | 31 +-
+ src/bin/pg_upgrade/relfilenumber.c | 34 +-
+ src/bin/pg_upgrade/segresize.c | 70 ++
+ src/bin/pg_upgrade/t/002_pg_upgrade.pl | 18 +
+ src/bin/pg_upgrade/version.c | 106 +-
+ src/bin/pg_waldump/pg_waldump.c | 2 +-
+ src/bin/pg_waldump/t/001_basic.pl | 3 +-
+ src/include/access/ginblock.h | 11 +-
+ src/include/access/gist.h | 2 +-
+ src/include/access/heapam.h | 56 +-
+ src/include/access/heapam_xlog.h | 29 +-
+ src/include/access/heaptoast.h | 11 +-
+ src/include/access/htup.h | 19 +-
+ src/include/access/htup_details.h | 306 +++++-
+ src/include/access/multixact.h | 8 +-
+ src/include/access/nbtree.h | 10 +
+ src/include/access/reloptions.h | 2 +-
+ src/include/access/rewriteheap.h | 4 +-
+ src/include/access/rmgrlist.h | 1 +
+ src/include/access/slru.h | 10 +-
+ src/include/access/tableam.h | 2 +-
+ src/include/access/transam.h | 92 +-
+ src/include/access/tupmacs.h | 3 +-
+ src/include/access/xact.h | 13 +-
+ src/include/access/xloginsert.h | 1 +
+ src/include/access/xlogreader.h | 4 -
+ src/include/access/xlogrecord.h | 5 +-
+ src/include/c.h | 21 +-
+ src/include/catalog/catversion.h | 3 +-
+ src/include/catalog/pg_operator.dat | 8 +-
+ src/include/catalog/pg_proc.dat | 12 +-
+ src/include/catalog/pg_type.dat | 4 +-
+ src/include/catalog/pg_type.h | 5 +
+ src/include/commands/vacuum.h | 22 +-
+ src/include/fmgr.h | 2 +
+ src/include/nodes/pg_list.h | 4 +
+ src/include/pg_config.h.in | 3 +
+ src/include/port/pg_lfind.h | 62 ++
+ src/include/postgres.h | 9 +-
+ src/include/postmaster/autovacuum.h | 4 +-
+ src/include/storage/buf_internals.h | 5 +-
+ src/include/storage/bufmgr.h | 6 +
+ src/include/storage/bufpage.h | 232 +++-
+ src/include/storage/itemid.h | 2 +
+ src/include/storage/lock.h | 14 +-
+ src/include/storage/proc.h | 7 +-
+ src/include/utils/combocid.h | 2 +-
+ src/include/utils/xid8.h | 4 +-
+ src/pl/plperl/plperl.c | 4 +-
+ src/pl/plpgsql/src/pl_comp.c | 4 +-
+ src/pl/plpgsql/src/pl_exec.c | 2 +
+ src/pl/plpython/plpy_procedure.c | 4 +-
+ src/pl/tcl/pltcl.c | 4 +-
+ src/test/Makefile | 3 +-
+ src/test/meson.build | 1 +
+ src/test/modules/test_lfind/test_lfind.c | 30 +-
+ .../perl/PostgreSQL/Test/AdjustUpgrade.pm | 4 +
+ src/test/recovery/t/003_recovery_targets.pl | 2 +-
+ src/test/recovery/t/039_end_of_wal.pl | 24 +-
+ src/test/regress/expected/indirect_toast.out | 8 +
+ src/test/regress/expected/insert.out | 16 +-
+ src/test/regress/expected/opr_sanity.out | 6 +-
+ src/test/regress/expected/select_views.out | 86 +-
+ src/test/regress/expected/txid.out | 8 +-
+ src/test/regress/expected/type_sanity.out | 5 +-
+ src/test/regress/expected/xid.out | 22 +-
+ src/test/regress/expected/xid64.out | 92 ++
+ src/test/regress/parallel_schedule | 2 +-
+ src/test/regress/regress.c | 298 ++++++
+ src/test/regress/sql/indirect_toast.sql | 11 +
+ src/test/regress/sql/insert.sql | 17 +-
+ src/test/regress/sql/select_views.sql | 2 +-
+ src/test/regress/sql/type_sanity.sql | 5 +-
+ src/test/regress/sql/xid.sql | 2 +-
+ src/test/regress/sql/xid64.sql | 84 ++
+ src/test/xid-64/.gitignore | 8 +
+ src/test/xid-64/Makefile | 22 +
+ src/test/xid-64/README | 16 +
+ src/test/xid-64/meson.build | 16 +
+ src/test/xid-64/t/002_test_gucs.pl | 79 ++
+ src/test/xid-64/t/003_test_integrity.pl | 58 +
+ src/test/xid-64/t/004_test_relminmxid.pl | 90 ++
+ src/test/xid-64/t/005_stream_subxact.pl | 100 ++
+ src/test/xid-64/t/006_zeropage.pl | 33 +
+ src/test/xid-64/t/007_first_multi.pl | 83 ++
+ src/tools/pgindent/typedefs.list | 4 +-
+ 201 files changed, 6196 insertions(+), 1955 deletions(-)
+ create mode 100644 contrib/pageinspect/expected/hash_1.out
+ create mode 100644 contrib/pageinspect/pageinspect--1.12--1.13.sql
+ create mode 100644 src/backend/storage/buffer/heap_convert.c
+ create mode 100644 src/test/regress/expected/xid64.out
+ create mode 100644 src/test/regress/sql/xid64.sql
+ create mode 100644 src/test/xid-64/.gitignore
+ create mode 100644 src/test/xid-64/Makefile
+ create mode 100644 src/test/xid-64/README
+ create mode 100644 src/test/xid-64/meson.build
+ create mode 100644 src/test/xid-64/t/002_test_gucs.pl
+ create mode 100644 src/test/xid-64/t/003_test_integrity.pl
+ create mode 100644 src/test/xid-64/t/004_test_relminmxid.pl
+ create mode 100644 src/test/xid-64/t/005_stream_subxact.pl
+ create mode 100644 src/test/xid-64/t/006_zeropage.pl
+ create mode 100644 src/test/xid-64/t/007_first_multi.pl
+
+diff --git a/contrib/amcheck/verify_heapam.c b/contrib/amcheck/verify_heapam.c
+index 1ce244fab1b..c8960116835 100644
+--- a/contrib/amcheck/verify_heapam.c
++++ b/contrib/amcheck/verify_heapam.c
+@@ -19,6 +19,7 @@
+ #include "access/toast_internals.h"
+ #include "access/visibilitymap.h"
+ #include "access/xact.h"
++#include "catalog/catalog.h"
+ #include "catalog/pg_am.h"
+ #include "catalog/pg_class.h"
+ #include "funcapi.h"
+@@ -89,7 +90,7 @@ typedef struct HeapCheckContext
+ * them.
+ */
+ FullTransactionId next_fxid; /* TransamVariables->nextXid */
+- TransactionId next_xid; /* 32-bit version of next_fxid */
++ TransactionId next_xid; /* 64-bit version of next_fxid */
+ TransactionId oldest_xid; /* TransamVariables->oldestXid */
+ FullTransactionId oldest_fxid; /* 64-bit version of oldest_xid, computed
+ * relative to next_fxid */
+@@ -130,6 +131,7 @@ typedef struct HeapCheckContext
+ uint16 lp_len;
+ uint16 lp_off;
+ HeapTupleHeader tuphdr;
++ HeapTupleData tuple;
+ int natts;
+
+ /* Values for iterating over attributes within the tuple */
+@@ -173,8 +175,6 @@ static bool check_tuple_visibility(HeapCheckContext *ctx,
+ static void report_corruption(HeapCheckContext *ctx, char *msg);
+ static void report_toast_corruption(HeapCheckContext *ctx,
+ ToastedAttribute *ta, char *msg);
+-static FullTransactionId FullTransactionIdFromXidAndCtx(TransactionId xid,
+- const HeapCheckContext *ctx);
+ static void update_cached_xid_range(HeapCheckContext *ctx);
+ static void update_cached_mxid_range(HeapCheckContext *ctx);
+ static XidBoundsViolation check_mxid_in_range(MultiXactId mxid,
+@@ -398,7 +398,7 @@ verify_heapam(PG_FUNCTION_ARGS)
+ update_cached_xid_range(&ctx);
+ update_cached_mxid_range(&ctx);
+ ctx.relfrozenxid = ctx.rel->rd_rel->relfrozenxid;
+- ctx.relfrozenfxid = FullTransactionIdFromXidAndCtx(ctx.relfrozenxid, &ctx);
++ ctx.relfrozenfxid = FullTransactionIdFromXid(ctx.relfrozenxid);
+ ctx.relminmxid = ctx.rel->rd_rel->relminmxid;
+
+ if (TransactionIdIsNormal(ctx.relfrozenxid))
+@@ -559,6 +559,12 @@ verify_heapam(PG_FUNCTION_ARGS)
+ ctx.tuphdr = (HeapTupleHeader) PageGetItem(ctx.page, ctx.itemid);
+ ctx.natts = HeapTupleHeaderGetNatts(ctx.tuphdr);
+
++ ctx.tuple.t_data = ctx.tuphdr;
++ ctx.tuple.t_len = ItemIdGetLength(ctx.itemid);
++ ctx.tuple.t_tableOid = RelationGetRelid(ctx.rel);
++ HeapTupleCopyXidsFromPage(ctx.buffer, &ctx.tuple, ctx.page,
++ IsToastRelation(ctx.rel));
++
+ /* Ok, ready to check this next tuple */
+ check_tuple(&ctx,
+ &xmin_commit_status_ok[ctx.offnum],
+@@ -592,6 +598,8 @@ verify_heapam(PG_FUNCTION_ARGS)
+ TransactionId curr_xmax;
+ TransactionId next_xmin;
+ OffsetNumber nextoffnum = successor[ctx.offnum];
++ HeapTupleData curr_tup;
++ HeapTupleData next_tup;
+
+ /*
+ * The current line pointer may not have a successor, either
+@@ -654,9 +662,13 @@ verify_heapam(PG_FUNCTION_ARGS)
+ if (ItemIdIsRedirected(next_lp))
+ continue;
+ curr_htup = (HeapTupleHeader) PageGetItem(ctx.page, curr_lp);
+- curr_xmax = HeapTupleHeaderGetUpdateXid(curr_htup);
++ curr_tup.t_data = curr_htup;
++ HeapTupleCopyXidsFromPage(ctx.buffer, &curr_tup, ctx.page, false);
++ curr_xmax = HeapTupleGetUpdateXidAny(&curr_tup);
+ next_htup = (HeapTupleHeader) PageGetItem(ctx.page, next_lp);
+- next_xmin = HeapTupleHeaderGetXmin(next_htup);
++ next_tup.t_data = next_htup;
++ HeapTupleCopyXidsFromPage(ctx.buffer, &next_tup, ctx.page, false);
++ next_xmin = HeapTupleGetXmin(&next_tup);
+ if (!TransactionIdIsValid(curr_xmax) ||
+ !TransactionIdEquals(curr_xmax, next_xmin))
+ continue;
+@@ -710,7 +722,7 @@ verify_heapam(PG_FUNCTION_ARGS)
+ * xmin. This should be safe because the xmin itself can't have
+ * changed, only its commit status.
+ */
+- curr_xmin = HeapTupleHeaderGetXmin(curr_htup);
++ curr_xmin = HeapTupleGetXmin(&curr_tup);
+ if (xmin_commit_status_ok[ctx.offnum] &&
+ xmin_commit_status[ctx.offnum] == XID_IN_PROGRESS &&
+ xmin_commit_status_ok[nextoffnum] &&
+@@ -908,7 +920,7 @@ check_tuple_header(HeapCheckContext *ctx)
+ {
+ HeapTupleHeader tuphdr = ctx->tuphdr;
+ uint16 infomask = tuphdr->t_infomask;
+- TransactionId curr_xmax = HeapTupleHeaderGetUpdateXid(tuphdr);
++ TransactionId curr_xmax = HeapTupleGetUpdateXidAny(&ctx->tuple);
+ bool result = true;
+ unsigned expected_hoff;
+
+@@ -1026,13 +1038,14 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ XidCommitStatus xmin_status;
+ XidCommitStatus xvac_status;
+ XidCommitStatus xmax_status;
++ HeapTuple tuple = &ctx->tuple;
+ HeapTupleHeader tuphdr = ctx->tuphdr;
+
+ ctx->tuple_could_be_pruned = true; /* have not yet proven otherwise */
+ *xmin_commit_status_ok = false; /* have not yet proven otherwise */
+
+ /* If xmin is normal, it should be within valid range */
+- xmin = HeapTupleHeaderGetXmin(tuphdr);
++ xmin = HeapTupleGetXmin(tuple);
+ switch (get_xid_status(xmin, ctx, &xmin_status))
+ {
+ case XID_INVALID:
+@@ -1046,19 +1059,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("xmin %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmin,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("xmin %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmin,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("xmin %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmin,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ }
+
+@@ -1084,19 +1097,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes relation freeze threshold %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes oldest valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1150,19 +1163,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes relation freeze threshold %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes oldest valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1239,7 +1252,7 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ * HEAP_XMAX_IS_LOCKED_ONLY is true, but for now we err on the side of
+ * avoiding possibly-bogus complaints about missing TOAST entries.
+ */
+- xmax = HeapTupleHeaderGetRawXmax(tuphdr);
++ xmax = HeapTupleGetRawXmax(tuple);
+ switch (check_mxid_valid_in_rel(xmax, ctx))
+ {
+ case XID_INVALID:
+@@ -1298,7 +1311,7 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ * We already checked above that this multixact is within limits for
+ * this table. Now check the update xid from this multixact.
+ */
+- xmax = HeapTupleGetUpdateXid(tuphdr);
++ xmax = HeapTupleGetUpdateXid(tuple);
+ switch (get_xid_status(xmax, ctx, &xmax_status))
+ {
+ case XID_INVALID:
+@@ -1310,19 +1323,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("update xid %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return true;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("update xid %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return true;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("update xid %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return true;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1362,7 +1375,7 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ }
+
+ /* xmax is an XID, not a MXID. Sanity check it. */
+- xmax = HeapTupleHeaderGetRawXmax(tuphdr);
++ xmax = HeapTupleGetRawXmax(tuple);
+ switch (get_xid_status(xmax, ctx, &xmax_status))
+ {
+ case XID_INVALID:
+@@ -1372,19 +1385,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("xmax %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("xmax %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("xmax %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false; /* corrupt */
+ case XID_BOUNDS_OK:
+ break;
+@@ -1863,50 +1876,6 @@ check_tuple(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ ctx->attnum = -1;
+ }
+
+-/*
+- * Convert a TransactionId into a FullTransactionId using our cached values of
+- * the valid transaction ID range. It is the caller's responsibility to have
+- * already updated the cached values, if necessary.
+- */
+-static FullTransactionId
+-FullTransactionIdFromXidAndCtx(TransactionId xid, const HeapCheckContext *ctx)
+-{
+- uint64 nextfxid_i;
+- int32 diff;
+- FullTransactionId fxid;
+-
+- Assert(TransactionIdIsNormal(ctx->next_xid));
+- Assert(FullTransactionIdIsNormal(ctx->next_fxid));
+- Assert(XidFromFullTransactionId(ctx->next_fxid) == ctx->next_xid);
+-
+- if (!TransactionIdIsNormal(xid))
+- return FullTransactionIdFromEpochAndXid(0, xid);
+-
+- nextfxid_i = U64FromFullTransactionId(ctx->next_fxid);
+-
+- /* compute the 32bit modulo difference */
+- diff = (int32) (ctx->next_xid - xid);
+-
+- /*
+- * In cases of corruption we might see a 32bit xid that is before epoch 0.
+- * We can't represent that as a 64bit xid, due to 64bit xids being
+- * unsigned integers, without the modulo arithmetic of 32bit xid. There's
+- * no really nice way to deal with that, but it works ok enough to use
+- * FirstNormalFullTransactionId in that case, as a freshly initdb'd
+- * cluster already has a newer horizon.
+- */
+- if (diff > 0 && (nextfxid_i - FirstNormalTransactionId) < (int64) diff)
+- {
+- Assert(EpochFromFullTransactionId(ctx->next_fxid) == 0);
+- fxid = FirstNormalFullTransactionId;
+- }
+- else
+- fxid = FullTransactionIdFromU64(nextfxid_i - diff);
+-
+- Assert(FullTransactionIdIsNormal(fxid));
+- return fxid;
+-}
+-
+ /*
+ * Update our cached range of valid transaction IDs.
+ */
+@@ -1920,8 +1889,8 @@ update_cached_xid_range(HeapCheckContext *ctx)
+ LWLockRelease(XidGenLock);
+
+ /* And compute alternate versions of the same */
++ ctx->oldest_fxid = FullTransactionIdFromXid(ctx->oldest_xid);
+ ctx->next_xid = XidFromFullTransactionId(ctx->next_fxid);
+- ctx->oldest_fxid = FullTransactionIdFromXidAndCtx(ctx->oldest_xid, ctx);
+ }
+
+ /*
+@@ -2020,7 +1989,7 @@ get_xid_status(TransactionId xid, HeapCheckContext *ctx,
+ }
+
+ /* Check if the xid is within bounds */
+- fxid = FullTransactionIdFromXidAndCtx(xid, ctx);
++ fxid = FullTransactionIdFromXid(xid);
+ if (!fxid_in_cached_range(fxid, ctx))
+ {
+ /*
+@@ -2029,7 +1998,6 @@ get_xid_status(TransactionId xid, HeapCheckContext *ctx,
+ * performed the full xid conversion, reconvert.
+ */
+ update_cached_xid_range(ctx);
+- fxid = FullTransactionIdFromXidAndCtx(xid, ctx);
+ }
+
+ if (FullTransactionIdPrecedesOrEquals(ctx->next_fxid, fxid))
+@@ -2053,8 +2021,7 @@ get_xid_status(TransactionId xid, HeapCheckContext *ctx,
+ *status = XID_COMMITTED;
+ LWLockAcquire(XactTruncationLock, LW_SHARED);
+ clog_horizon =
+- FullTransactionIdFromXidAndCtx(TransamVariables->oldestClogXid,
+- ctx);
++ FullTransactionIdFromXid(TransamVariables->oldestClogXid);
+ if (FullTransactionIdPrecedesOrEquals(clog_horizon, fxid))
+ {
+ if (TransactionIdIsCurrentTransactionId(xid))
+diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
+index ffe4f721672..8d8a134f302 100644
+--- a/contrib/amcheck/verify_nbtree.c
++++ b/contrib/amcheck/verify_nbtree.c
+@@ -581,7 +581,7 @@ bt_check_every_level(Relation rel, Relation heaprel, bool heapkeyspace,
+ * avoid this.
+ */
+ if (IsolationUsesXactSnapshot() && rel->rd_index->indcheckxmin &&
+- !TransactionIdPrecedes(HeapTupleHeaderGetXmin(rel->rd_indextuple->t_data),
++ !TransactionIdPrecedes(HeapTupleGetXmin(rel->rd_indextuple),
+ snapshot->xmin))
+ ereport(ERROR,
+ (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
+diff --git a/contrib/hstore/hstore_io.c b/contrib/hstore/hstore_io.c
+index 2125436e40c..9fe4254e72e 100644
+--- a/contrib/hstore/hstore_io.c
++++ b/contrib/hstore/hstore_io.c
+@@ -914,6 +914,7 @@ hstore_from_record(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = rec;
++ HeapTupleSetZeroXids(&tuple);
+
+ values = (Datum *) palloc(ncolumns * sizeof(Datum));
+ nulls = (bool *) palloc(ncolumns * sizeof(bool));
+@@ -1067,6 +1068,7 @@ hstore_populate_record(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = rec;
++ HeapTupleSetZeroXids(&tuple);
+ }
+
+ /*
+diff --git a/contrib/pageinspect/Makefile b/contrib/pageinspect/Makefile
+index 95e030b3969..446721018e4 100644
+--- a/contrib/pageinspect/Makefile
++++ b/contrib/pageinspect/Makefile
+@@ -13,7 +13,8 @@ OBJS = \
+ rawpage.o
+
+ EXTENSION = pageinspect
+-DATA = pageinspect--1.11--1.12.sql pageinspect--1.10--1.11.sql \
++DATA = pageinspect--1.12--1.13.sql \
++ pageinspect--1.11--1.12.sql pageinspect--1.10--1.11.sql \
+ pageinspect--1.9--1.10.sql pageinspect--1.8--1.9.sql \
+ pageinspect--1.7--1.8.sql pageinspect--1.6--1.7.sql \
+ pageinspect--1.5.sql pageinspect--1.5--1.6.sql \
+diff --git a/contrib/pageinspect/btreefuncs.c b/contrib/pageinspect/btreefuncs.c
+index afa1947fad6..a810be45308 100644
+--- a/contrib/pageinspect/btreefuncs.c
++++ b/contrib/pageinspect/btreefuncs.c
+@@ -122,6 +122,9 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+
+ stat->page_size = PageGetPageSize(page);
+
++ stat->btpo_prev = opaque->btpo_prev;
++ stat->btpo_level = opaque->btpo_level;
++
+ /* page type (flags) */
+ if (P_ISDELETED(opaque))
+ {
+@@ -143,11 +146,18 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+ FullTransactionId safexid = BTPageGetDeleteXid(page);
+
+ elog(DEBUG2, "deleted page from block %u has safexid %llu",
+- blkno, (unsigned long long) U64FromFullTransactionId(safexid));
++ blkno, (unsigned long long) XidFromFullTransactionId(safexid));
+ }
+ else
+- elog(DEBUG2, "deleted page from block %u has safexid %llu",
+- blkno, (unsigned long long) opaque->btpo_level);
++ {
++ ShortTransactionId safexid = BTP_GET_XACT(opaque);
++
++ stat->btpo_prev = 0;
++ stat->btpo_level = 0;
++
++ elog(DEBUG2, "deleted page from block %u has safexid %u",
++ blkno, safexid);
++ }
+
+ /* Don't interpret BTDeletedPageData as index tuples */
+ maxoff = InvalidOffsetNumber;
+@@ -162,9 +172,7 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+ stat->type = 'i';
+
+ /* btpage opaque data */
+- stat->btpo_prev = opaque->btpo_prev;
+ stat->btpo_next = opaque->btpo_next;
+- stat->btpo_level = opaque->btpo_level;
+ stat->btpo_flags = opaque->btpo_flags;
+ stat->btpo_cycleid = opaque->btpo_cycleid;
+
+diff --git a/contrib/pageinspect/expected/btree.out b/contrib/pageinspect/expected/btree.out
+index 0aa5d73322f..f5b05dbc063 100644
+--- a/contrib/pageinspect/expected/btree.out
++++ b/contrib/pageinspect/expected/btree.out
+@@ -207,8 +207,8 @@ SELECT bt_page_items('aaa'::bytea);
+ ERROR: invalid page size
+ -- invalid special area size
+ CREATE INDEX test1_a_brin ON test1 USING brin(a);
+-SELECT bt_page_items(get_raw_page('test1', 0));
+-ERROR: input page is not a valid btree page
++-- XXX: false positive in 64xids due to equal sizes of BTPageOpaque and HeapPageSpecialData
++-- SELECT bt_page_items(get_raw_page('test1', 0));
+ SELECT bt_page_items(get_raw_page('test1_a_brin', 0));
+ ERROR: input page is not a valid btree page
+ \set VERBOSITY default
+diff --git a/contrib/pageinspect/expected/hash_1.out b/contrib/pageinspect/expected/hash_1.out
+new file mode 100644
+index 00000000000..5e64eb92602
+--- /dev/null
++++ b/contrib/pageinspect/expected/hash_1.out
+@@ -0,0 +1,166 @@
++CREATE TABLE test_hash (a int, b text);
++INSERT INTO test_hash VALUES (1, 'one');
++CREATE INDEX test_hash_a_idx ON test_hash USING hash (a);
++\x
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 0));
++-[ RECORD 1 ]--+---------
++hash_page_type | metapage
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 1));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 2));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 3));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 4));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 5));
++-[ RECORD 1 ]--+-------
++hash_page_type | bitmap
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 6));
++ERROR: block number 6 is out of range for relation "test_hash_a_idx"
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', -1);
++ERROR: invalid block number
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 0);
++ERROR: invalid overflow block number 0
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 1);
++ERROR: invalid overflow block number 1
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 2);
++ERROR: invalid overflow block number 2
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 3);
++ERROR: invalid overflow block number 3
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 4);
++ERROR: invalid overflow block number 4
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 5);
++ERROR: invalid overflow block number 5
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 6);
++ERROR: block number 6 is out of range for relation "test_hash_a_idx"
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 0));
++-[ RECORD 1 ]--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
++magic | 105121344
++version | 4
++ntuples | 1
++bsize | 8156
++bmsize | 4096
++bmshift | 15
++maxbucket | 3
++highmask | 7
++lowmask | 3
++ovflpoint | 2
++firstfree | 0
++nmaps | 1
++procid | 450
++spares | {0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
++mapp | {5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
++
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 1));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 2));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 3));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 4));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 5));
++ERROR: page is not a hash meta page
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 0));
++ERROR: page is not a hash bucket or overflow page
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 1));
++-[ RECORD 1 ]---+-----------
++live_items | 0
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 0
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 2));
++-[ RECORD 1 ]---+-----------
++live_items | 0
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 1
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 3));
++-[ RECORD 1 ]---+-----------
++live_items | 1
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 2
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 4));
++-[ RECORD 1 ]---+-----------
++live_items | 0
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 3
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 5));
++ERROR: page is not a hash bucket or overflow page
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 0));
++ERROR: page is not a hash bucket or overflow page
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 1));
++(0 rows)
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 2));
++(0 rows)
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 3));
++-[ RECORD 1 ]----------
++itemoffset | 1
++ctid | (0,1)
++data | 2389907270
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 4));
++(0 rows)
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 5));
++ERROR: page is not a hash bucket or overflow page
++DROP TABLE test_hash;
+diff --git a/contrib/pageinspect/expected/oldextversions.out b/contrib/pageinspect/expected/oldextversions.out
+index f5c4b61bd79..00323d392d6 100644
+--- a/contrib/pageinspect/expected/oldextversions.out
++++ b/contrib/pageinspect/expected/oldextversions.out
+@@ -40,16 +40,16 @@ SELECT * FROM bt_page_items('test1_a_idx', 1);
+ -- pagesize in pageinspect >= 1.10.
+ ALTER EXTENSION pageinspect UPDATE TO '1.9';
+ \df page_header
+- List of functions
+- Schema | Name | Result data type | Argument data types | Type
+---------+-------------+------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------
+- public | page_header | record | page bytea, OUT lsn pg_lsn, OUT checksum smallint, OUT flags smallint, OUT lower smallint, OUT upper smallint, OUT special smallint, OUT pagesize smallint, OUT version smallint, OUT prune_xid xid | func
++ List of functions
++ Schema | Name | Result data type | Argument data types | Type
++--------+-------------+------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------
++ public | page_header | record | page bytea, OUT lsn pg_lsn, OUT checksum smallint, OUT flags smallint, OUT lower smallint, OUT upper smallint, OUT special smallint, OUT pagesize smallint, OUT version smallint, OUT xid_base xid, OUT multi_base xid, OUT prune_xid xid | func
+ (1 row)
+
+ SELECT pagesize, version FROM page_header(get_raw_page('test1', 0));
+ pagesize | version
+ ----------+---------
+- 8192 | 4
++ 8192 | 5
+ (1 row)
+
+ DROP TABLE test1;
+diff --git a/contrib/pageinspect/expected/page.out b/contrib/pageinspect/expected/page.out
+index 3fd3869c82a..be612aeb0a0 100644
+--- a/contrib/pageinspect/expected/page.out
++++ b/contrib/pageinspect/expected/page.out
+@@ -49,7 +49,7 @@ SELECT get_raw_page('test1', 0) = get_raw_page('test1', 'main', 0);
+ SELECT pagesize, version FROM page_header(get_raw_page('test1', 0));
+ pagesize | version
+ ----------+---------
+- 8192 | 4
++ 8192 | 5
+ (1 row)
+
+ SELECT page_checksum(get_raw_page('test1', 0), 0) IS NOT NULL AS silly_checksum_test;
+@@ -70,19 +70,19 @@ SELECT tuple_data_split('test1'::regclass, t_data, t_infomask, t_infomask2, t_bi
+ SELECT * FROM fsm_page_contents(get_raw_page('test1', 'fsm', 0));
+ fsm_page_contents
+ -------------------
+- 0: 254 +
+- 1: 254 +
+- 3: 254 +
+- 7: 254 +
+- 15: 254 +
+- 31: 254 +
+- 63: 254 +
+- 127: 254 +
+- 255: 254 +
+- 511: 254 +
+- 1023: 254 +
+- 2047: 254 +
+- 4095: 254 +
++ 0: 253 +
++ 1: 253 +
++ 3: 253 +
++ 7: 253 +
++ 15: 253 +
++ 31: 253 +
++ 63: 253 +
++ 127: 253 +
++ 255: 253 +
++ 511: 253 +
++ 1023: 253 +
++ 2047: 253 +
++ 4095: 253 +
+ fp_next_slot: 0 +
+
+ (1 row)
+diff --git a/contrib/pageinspect/heapfuncs.c b/contrib/pageinspect/heapfuncs.c
+index 3dc705e43f7..aee72915218 100644
+--- a/contrib/pageinspect/heapfuncs.c
++++ b/contrib/pageinspect/heapfuncs.c
+@@ -32,6 +32,7 @@
+ #include "funcapi.h"
+ #include "mb/pg_wchar.h"
+ #include "miscadmin.h"
++#include "pageinspect.h"
+ #include "port/pg_bitutils.h"
+ #include "utils/array.h"
+ #include "utils/builtins.h"
+@@ -162,7 +163,7 @@ heap_page_items(PG_FUNCTION_ARGS)
+ inter_call_data->tupd = tupdesc;
+
+ inter_call_data->offset = FirstOffsetNumber;
+- inter_call_data->page = VARDATA(raw_page);
++ inter_call_data->page = get_page_from_raw(raw_page);
+
+ fctx->max_calls = PageGetMaxOffsetNumber(inter_call_data->page);
+ fctx->user_fctx = inter_call_data;
+@@ -210,6 +211,7 @@ heap_page_items(PG_FUNCTION_ARGS)
+ lp_offset == MAXALIGN(lp_offset) &&
+ lp_offset + lp_len <= raw_page_size)
+ {
++ HeapTupleData tup;
+ HeapTupleHeader tuphdr;
+ bytea *tuple_data_bytea;
+ int tuple_data_len;
+@@ -217,9 +219,11 @@ heap_page_items(PG_FUNCTION_ARGS)
+ /* Extract information from the tuple header */
+
+ tuphdr = (HeapTupleHeader) PageGetItem(page, id);
++ tup.t_data = tuphdr;
++ HeapTupleCopyXidsFromPage(InvalidBuffer, &tup, page, false);
+
+- values[4] = UInt32GetDatum(HeapTupleHeaderGetRawXmin(tuphdr));
+- values[5] = UInt32GetDatum(HeapTupleHeaderGetRawXmax(tuphdr));
++ values[4] = TransactionIdGetDatum(HeapTupleGetXmin(&tup));
++ values[5] = TransactionIdGetDatum(HeapTupleGetRawXmax(&tup));
+ /* shared with xvac */
+ values[6] = UInt32GetDatum(HeapTupleHeaderGetRawCommandId(tuphdr));
+ values[7] = PointerGetDatum(&tuphdr->t_ctid);
+diff --git a/contrib/pageinspect/pageinspect--1.12--1.13.sql b/contrib/pageinspect/pageinspect--1.12--1.13.sql
+new file mode 100644
+index 00000000000..a2e0232a103
+--- /dev/null
++++ b/contrib/pageinspect/pageinspect--1.12--1.13.sql
+@@ -0,0 +1,145 @@
++/* contrib/pageinspect/pageinspect--1.12--1.13.sql */
++
++-- complain if script is sourced in psql, rather than via ALTER EXTENSION
++\echo Use "ALTER EXTENSION pageinspect UPDATE TO '1.13'" to load this file. \quit
++
++--
++-- gist_page_opaque_info()
++--
++DROP FUNCTION gist_page_opaque_info(bytea);
++CREATE FUNCTION gist_page_opaque_info(IN page bytea,
++ OUT lsn pg_lsn,
++ OUT nsn pg_lsn,
++ OUT rightlink bigint,
++ OUT flags text[])
++AS 'MODULE_PATHNAME', 'gist_page_opaque_info'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++
++--
++-- gist_page_items_bytea()
++--
++DROP FUNCTION gist_page_items_bytea(bytea);
++CREATE FUNCTION gist_page_items_bytea(IN page bytea,
++ OUT itemoffset smallint,
++ OUT ctid tid,
++ OUT itemlen smallint,
++ OUT dead boolean,
++ OUT key_data bytea)
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'gist_page_items_bytea'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- gist_page_items()
++--
++DROP FUNCTION gist_page_items(bytea, regclass);
++CREATE FUNCTION gist_page_items(IN page bytea,
++ IN index_oid regclass,
++ OUT itemoffset smallint,
++ OUT ctid tid,
++ OUT itemlen smallint,
++ OUT dead boolean,
++ OUT keys text)
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'gist_page_items'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- get_raw_page()
++--
++DROP FUNCTION get_raw_page(text, int8);
++DROP FUNCTION IF EXISTS get_raw_page(text, int4);
++CREATE FUNCTION get_raw_page(text, int8)
++RETURNS bytea
++AS 'MODULE_PATHNAME', 'get_raw_page_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++DROP FUNCTION get_raw_page(text, text, int8);
++DROP FUNCTION IF EXISTS get_raw_page(text, text, int4);
++CREATE FUNCTION get_raw_page(text, text, int8)
++RETURNS bytea
++AS 'MODULE_PATHNAME', 'get_raw_page_fork_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- page_checksum()
++--
++DROP FUNCTION page_checksum(IN page bytea, IN blkno int8);
++DROP FUNCTION IF EXISTS page_checksum(IN page bytea, IN blkno int4);
++CREATE FUNCTION page_checksum(IN page bytea, IN blkno int8)
++RETURNS smallint
++AS 'MODULE_PATHNAME', 'page_checksum_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- bt_metap()
++--
++DROP FUNCTION bt_metap(text);
++CREATE FUNCTION bt_metap(IN relname text,
++ OUT magic int4,
++ OUT version int4,
++ OUT root int8,
++ OUT level int8,
++ OUT fastroot int8,
++ OUT fastlevel int8,
++ OUT last_cleanup_num_delpages int8,
++ OUT last_cleanup_num_tuples float8,
++ OUT allequalimage boolean)
++AS 'MODULE_PATHNAME', 'bt_metap'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- bt_page_stats()
++--
++DROP FUNCTION bt_page_stats(text, int8);
++DROP FUNCTION IF EXISTS bt_page_stats(text, int4);
++CREATE FUNCTION bt_page_stats(IN relname text, IN blkno int8,
++ OUT blkno int8,
++ OUT type "char",
++ OUT live_items int4,
++ OUT dead_items int4,
++ OUT avg_item_size int4,
++ OUT page_size int4,
++ OUT free_size int4,
++ OUT btpo_prev int8,
++ OUT btpo_next int8,
++ OUT btpo_level int8,
++ OUT btpo_flags int4)
++AS 'MODULE_PATHNAME', 'bt_page_stats_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- bt_page_items()
++--
++DROP FUNCTION bt_page_items(text, int8);
++DROP FUNCTION IF EXISTS bt_page_items(text, int4);
++CREATE FUNCTION bt_page_items(IN relname text, IN blkno int8,
++ OUT itemoffset smallint,
++ OUT ctid tid,
++ OUT itemlen smallint,
++ OUT nulls bool,
++ OUT vars bool,
++ OUT data text,
++ OUT dead boolean,
++ OUT htid tid,
++ OUT tids tid[])
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'bt_page_items_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- brin_page_items()
++--
++DROP FUNCTION brin_page_items(IN page bytea, IN index_oid regclass);
++CREATE FUNCTION brin_page_items(IN page bytea, IN index_oid regclass,
++ OUT itemoffset int,
++ OUT blknum int8,
++ OUT attnum int,
++ OUT allnulls bool,
++ OUT hasnulls bool,
++ OUT placeholder bool,
++ OUT value text)
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'brin_page_items'
++LANGUAGE C STRICT PARALLEL SAFE;
+diff --git a/contrib/pageinspect/pageinspect--1.5.sql b/contrib/pageinspect/pageinspect--1.5.sql
+index 1e40c3c97e2..fdbd2995a22 100644
+--- a/contrib/pageinspect/pageinspect--1.5.sql
++++ b/contrib/pageinspect/pageinspect--1.5.sql
+@@ -28,6 +28,8 @@ CREATE FUNCTION page_header(IN page bytea,
+ OUT special smallint,
+ OUT pagesize smallint,
+ OUT version smallint,
++ OUT xid_base xid,
++ OUT multi_base xid,
+ OUT prune_xid xid)
+ AS 'MODULE_PATHNAME', 'page_header'
+ LANGUAGE C STRICT PARALLEL SAFE;
+diff --git a/contrib/pageinspect/rawpage.c b/contrib/pageinspect/rawpage.c
+index 2800ebd62f5..a359b04e585 100644
+--- a/contrib/pageinspect/rawpage.c
++++ b/contrib/pageinspect/rawpage.c
+@@ -17,6 +17,7 @@
+
+ #include "access/htup_details.h"
+ #include "access/relation.h"
++#include "commands/sequence.h"
+ #include "catalog/namespace.h"
+ #include "catalog/pg_type.h"
+ #include "funcapi.h"
+@@ -251,8 +252,9 @@ page_header(PG_FUNCTION_ARGS)
+
+ Datum result;
+ HeapTuple tuple;
+- Datum values[9];
+- bool nulls[9];
++ Datum values[11];
++ bool nulls[11];
++ bool is_toast;
+
+ Page page;
+ PageHeader pageheader;
+@@ -314,12 +316,37 @@ page_header(PG_FUNCTION_ARGS)
+ }
+
+ values[7] = UInt16GetDatum(PageGetPageLayoutVersion(page));
+- values[8] = TransactionIdGetDatum(pageheader->pd_prune_xid);
++ is_toast = PageGetSpecialSize(page) ==
++ MAXALIGN(sizeof(ToastPageSpecialData));
++ values[8] = TransactionIdGetDatum(HeapPageGetPruneXidNoAssert((Page) page,
++ is_toast));
+
+ /* Build and return the tuple. */
+-
+ memset(nulls, 0, sizeof(nulls));
+
++ if (PageGetSpecialSize(page) == MAXALIGN(sizeof(HeapPageSpecialData)))
++ {
++ /* Heap page */
++ HeapPageSpecial pageSpecial = HeapPageGetSpecial((Page) page);
++
++ values[9] = TransactionIdGetDatum(pageSpecial->pd_xid_base);
++ values[10] = TransactionIdGetDatum(pageSpecial->pd_multi_base);
++ }
++ else if (PageGetSpecialSize(page) == MAXALIGN(sizeof(ToastPageSpecialData)))
++ {
++ /* TOAST page */
++ ToastPageSpecial pageSpecial = ToastPageGetSpecial((Page) page);
++
++ values[9] = TransactionIdGetDatum(pageSpecial->pd_xid_base);
++ nulls[10] = true;
++ }
++ else
++ {
++ /* Double xmax page */
++ nulls[9] = true;
++ nulls[10] = true;
++ }
++
+ tuple = heap_form_tuple(tupdesc, values, nulls);
+ result = HeapTupleGetDatum(tuple);
+
+diff --git a/contrib/pageinspect/sql/btree.sql b/contrib/pageinspect/sql/btree.sql
+index 102ebdefe3c..87f202fb9f4 100644
+--- a/contrib/pageinspect/sql/btree.sql
++++ b/contrib/pageinspect/sql/btree.sql
+@@ -51,7 +51,8 @@ SELECT bt_page_items(get_raw_page('test1_b_gist', 0));
+ SELECT bt_page_items('aaa'::bytea);
+ -- invalid special area size
+ CREATE INDEX test1_a_brin ON test1 USING brin(a);
+-SELECT bt_page_items(get_raw_page('test1', 0));
++-- XXX: false positive in 64xids due to equal sizes of BTPageOpaque and HeapPageSpecialData
++-- SELECT bt_page_items(get_raw_page('test1', 0));
+ SELECT bt_page_items(get_raw_page('test1_a_brin', 0));
+ \set VERBOSITY default
+
+diff --git a/contrib/pg_surgery/heap_surgery.c b/contrib/pg_surgery/heap_surgery.c
+index 1513d76e4b5..5469ae4c407 100644
+--- a/contrib/pg_surgery/heap_surgery.c
++++ b/contrib/pg_surgery/heap_surgery.c
+@@ -16,6 +16,7 @@
+ #include "access/relation.h"
+ #include "access/visibilitymap.h"
+ #include "access/xloginsert.h"
++#include "catalog/catalog.h"
+ #include "catalog/pg_am_d.h"
+ #include "miscadmin.h"
+ #include "storage/bufmgr.h"
+@@ -272,11 +273,20 @@ heap_force_common(FunctionCallInfo fcinfo, HeapTupleForceOption heap_force_opt)
+ else
+ {
+ HeapTupleHeader htup;
++ HeapTupleData tuple;
++ bool is_toast;
+
+ Assert(heap_force_opt == HEAP_FORCE_FREEZE);
+
++ is_toast = IsToastRelation(rel);
++
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
+
++ tuple.t_data = htup;
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, is_toast);
++
+ /*
+ * Reset all visibility-related fields of the tuple. This
+ * logic should mimic heap_execute_freeze_tuple(), but we
+@@ -284,8 +294,11 @@ heap_force_common(FunctionCallInfo fcinfo, HeapTupleForceOption heap_force_opt)
+ * potentially-garbled data is left behind.
+ */
+ ItemPointerSet(&htup->t_ctid, blkno, curoff);
+- HeapTupleHeaderSetXmin(htup, FrozenTransactionId);
+- HeapTupleHeaderSetXmax(htup, InvalidTransactionId);
++ HeapTupleAndHeaderSetXmin(page, &tuple, FrozenTransactionId,
++ is_toast);
++ HeapTupleAndHeaderSetXmax(page, &tuple, InvalidTransactionId,
++ is_toast);
++
+ if (htup->t_infomask & HEAP_MOVED)
+ {
+ if (htup->t_infomask & HEAP_MOVED_OFF)
+diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
+index 5d0deaba61e..227bde0a168 100644
+--- a/contrib/pg_visibility/pg_visibility.c
++++ b/contrib/pg_visibility/pg_visibility.c
+@@ -14,6 +14,7 @@
+ #include "access/htup_details.h"
+ #include "access/visibilitymap.h"
+ #include "access/xloginsert.h"
++#include "catalog/catalog.h"
+ #include "catalog/pg_type.h"
+ #include "catalog/storage_xlog.h"
+ #include "funcapi.h"
+@@ -794,6 +795,8 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = relid;
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page,
++ IsToastRelation(rel));
+
+ /*
+ * If we're checking whether the page is all-visible, we expect
+@@ -837,7 +840,7 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
+ */
+ if (check_frozen)
+ {
+- if (heap_tuple_needs_eventual_freeze(tuple.t_data))
++ if (heap_tuple_needs_eventual_freeze(&tuple))
+ record_corrupt_item(items, &tuple.t_self);
+ }
+ }
+@@ -903,7 +906,7 @@ tuple_all_visible(HeapTuple tup, TransactionId OldestXmin, Buffer buffer)
+ * be set here. So just check the xmin.
+ */
+
+- xmin = HeapTupleHeaderGetXmin(tup->t_data);
++ xmin = HeapTupleGetXmin(tup);
+ if (!TransactionIdPrecedes(xmin, OldestXmin))
+ return false; /* xmin not old enough for all to see */
+
+diff --git a/contrib/pgrowlocks/pgrowlocks.c b/contrib/pgrowlocks/pgrowlocks.c
+index b11b8750c32..5470d61e250 100644
+--- a/contrib/pgrowlocks/pgrowlocks.c
++++ b/contrib/pgrowlocks/pgrowlocks.c
+@@ -130,7 +130,7 @@ pgrowlocks(PG_FUNCTION_ARGS)
+ htsu = HeapTupleSatisfiesUpdate(tuple,
+ GetCurrentCommandId(false),
+ hscan->rs_cbuf);
+- xmax = HeapTupleHeaderGetRawXmax(tuple->t_data);
++ xmax = HeapTupleGetRawXmax(tuple);
+ infomask = tuple->t_data->t_infomask;
+
+ /*
+diff --git a/contrib/pgstattuple/pgstatapprox.c b/contrib/pgstattuple/pgstatapprox.c
+index 3a5aad30ae2..d122b00bab6 100644
+--- a/contrib/pgstattuple/pgstatapprox.c
++++ b/contrib/pgstattuple/pgstatapprox.c
+@@ -16,6 +16,9 @@
+ #include "access/htup_details.h"
+ #include "access/relation.h"
+ #include "access/visibilitymap.h"
++#include "access/xact.h"
++#include "catalog/catalog.h"
++#include "catalog/namespace.h"
+ #include "catalog/pg_am_d.h"
+ #include "commands/vacuum.h"
+ #include "funcapi.h"
+@@ -140,6 +143,7 @@ statapprox_heap(Relation rel, output_type *stat)
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, IsToastRelation(rel));
+
+ /*
+ * We follow VACUUM's lead in counting INSERT_IN_PROGRESS tuples
+diff --git a/contrib/pgstattuple/pgstatindex.c b/contrib/pgstattuple/pgstatindex.c
+index 4b9d76ec4e4..bcb612f3d90 100644
+--- a/contrib/pgstattuple/pgstatindex.c
++++ b/contrib/pgstattuple/pgstatindex.c
+@@ -627,7 +627,7 @@ pgstathashindex(PG_FUNCTION_ARGS)
+ metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
+ metap = HashPageGetMeta(BufferGetPage(metabuf));
+ stats.version = metap->hashm_version;
+- stats.space_per_page = metap->hashm_bsize;
++ stats.space_per_page = BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(HashPageOpaqueData));
+ _hash_relbuf(rel, metabuf);
+
+ /* Get the current relation length */
+diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
+index f2bcd6aa98c..18eb21d0147 100644
+--- a/contrib/postgres_fdw/expected/postgres_fdw.out
++++ b/contrib/postgres_fdw/expected/postgres_fdw.out
+@@ -4995,16 +4995,24 @@ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *; -- can be pushed down
+- QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------------------
+- Update on public.ft2
+- Output: c1, c2, c3, c4, c5, c6, c7, c8
+- -> Foreign Update on public.ft2
+- Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7') WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+-(4 rows)
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1; -- can be pushed down
++ QUERY PLAN
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------
++ Sort
++ Output: t.c1, t.c2, t.c3, t.c4, t.c5, t.c6, t.c7, t.c8
++ Sort Key: t.c1
++ CTE t
++ -> Update on public.ft2
++ Output: ft2.c1, ft2.c2, ft2.c3, ft2.c4, ft2.c5, ft2.c6, ft2.c7, ft2.c8
++ -> Foreign Update on public.ft2
++ Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7') WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
++ -> CTE Scan on t
++ Output: t.c1, t.c2, t.c3, t.c4, t.c5, t.c6, t.c7, t.c8
++(10 rows)
+
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+ c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8
+ ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
+ 7 | 407 | 00007_update7 | Thu Jan 08 00:00:00 1970 PST | Thu Jan 08 00:00:00 1970 | 7 | 7 | foo
+@@ -5124,16 +5132,24 @@ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
+ EXPLAIN (verbose, costs off)
+- DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4; -- can be pushed down
+- QUERY PLAN
+---------------------------------------------------------------------------------------------
+- Delete on public.ft2
+- Output: c1, c4
+- -> Foreign Delete on public.ft2
+- Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
+-(4 rows)
++ WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++ SELECT * FROM t ORDER BY c1; -- can be pushed down
++ QUERY PLAN
++----------------------------------------------------------------------------------------------------
++ Sort
++ Output: t.c1, t.c4
++ Sort Key: t.c1
++ CTE t
++ -> Delete on public.ft2
++ Output: ft2.c1, ft2.c4
++ -> Foreign Delete on public.ft2
++ Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
++ -> CTE Scan on t
++ Output: t.c1, t.c4
++(10 rows)
+
+-DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
++WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++SELECT * FROM t ORDER BY c1;
+ c1 | c4
+ ------+------------------------------
+ 5 | Tue Jan 06 00:00:00 1970 PST
+@@ -6394,7 +6410,8 @@ INSERT INTO ft2 (c1,c2,c3,c6) VALUES (1218, 818, 'ggg', '(--;') RETURNING *;
+ 1218 | 818 | ggg_trig_update | | | (--; | ft2 |
+ (1 row)
+
+-UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+ c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8
+ ------+-----+------------------------+------------------------------+--------------------------+----+------------+-----
+ 8 | 608 | 00008_trig_update | Fri Jan 09 00:00:00 1970 PST | Fri Jan 09 00:00:00 1970 | 8 | 8 | foo
+diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
+index c0810fbd7c8..e1db0d3a284 100644
+--- a/contrib/postgres_fdw/postgres_fdw.c
++++ b/contrib/postgres_fdw/postgres_fdw.c
+@@ -4838,8 +4838,8 @@ apply_returning_filter(PgFdwDirectModifyState *dmstate,
+ * Note: no need to care about tableoid here because it will be
+ * initialized in ExecProcessReturning().
+ */
+- HeapTupleHeaderSetXmin(resultTup->t_data, InvalidTransactionId);
+- HeapTupleHeaderSetXmax(resultTup->t_data, InvalidTransactionId);
++ HeapTupleSetXmin(resultTup, InvalidTransactionId);
++ HeapTupleSetXmax(resultTup, InvalidTransactionId);
+ HeapTupleHeaderSetCmin(resultTup->t_data, InvalidTransactionId);
+ }
+
+@@ -7695,6 +7695,7 @@ make_tuple_from_result_row(PGresult *res,
+ */
+ if (ctid)
+ tuple->t_self = tuple->t_data->t_ctid = *ctid;
++ HeapTupleSetZeroXids(tuple);
+
+ /*
+ * Stomp on the xmin, xmax, and cmin fields from the tuple created by
+@@ -7704,8 +7705,8 @@ make_tuple_from_result_row(PGresult *res,
+ * assumption. If we don't do this then, for example, the tuple length
+ * ends up in the xmin field, which isn't what we want.
+ */
+- HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId);
+- HeapTupleHeaderSetXmin(tuple->t_data, InvalidTransactionId);
++ HeapTupleSetXmax(tuple, InvalidTransactionId);
++ HeapTupleSetXmin(tuple, InvalidTransactionId);
+ HeapTupleHeaderSetCmin(tuple->t_data, InvalidTransactionId);
+
+ /* Clean up */
+diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql
+index 372fe6dad15..7f7f214f6d4 100644
+--- a/contrib/postgres_fdw/sql/postgres_fdw.sql
++++ b/contrib/postgres_fdw/sql/postgres_fdw.sql
+@@ -1475,16 +1475,20 @@ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3; -- can be pushed down
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *; -- can be pushed down
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1; -- can be pushed down
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9; -- can be pushed down
+ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
+ EXPLAIN (verbose, costs off)
+- DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4; -- can be pushed down
+-DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
++ WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++ SELECT * FROM t ORDER BY c1; -- can be pushed down
++WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++SELECT * FROM t ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2; -- can be pushed down
+ DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
+@@ -1591,7 +1595,8 @@ CREATE TRIGGER t1_br_insert BEFORE INSERT OR UPDATE
+
+ INSERT INTO ft2 (c1,c2,c3) VALUES (1208, 818, 'fff') RETURNING *;
+ INSERT INTO ft2 (c1,c2,c3,c6) VALUES (1218, 818, 'ggg', '(--;') RETURNING *;
+-UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+
+ -- Test errors thrown on remote side during update
+ ALTER TABLE "S 1"."T 1" ADD CONSTRAINT c2positive CHECK (c2 >= 0);
+diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
+index 9e3407bf987..7a9b09dfeda 100644
+--- a/src/backend/access/common/heaptuple.c
++++ b/src/backend/access/common/heaptuple.c
+@@ -736,10 +736,10 @@ heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
+ result = PointerGetDatum(&(tup->t_self));
+ break;
+ case MinTransactionIdAttributeNumber:
+- result = TransactionIdGetDatum(HeapTupleHeaderGetRawXmin(tup->t_data));
++ result = TransactionIdGetDatum(HeapTupleGetRawXmin(tup));
+ break;
+ case MaxTransactionIdAttributeNumber:
+- result = TransactionIdGetDatum(HeapTupleHeaderGetRawXmax(tup->t_data));
++ result = TransactionIdGetDatum(HeapTupleGetRawXmax(tup));
+ break;
+ case MinCommandIdAttributeNumber:
+ case MaxCommandIdAttributeNumber:
+@@ -784,6 +784,7 @@ heap_copytuple(HeapTuple tuple)
+ newTuple->t_len = tuple->t_len;
+ newTuple->t_self = tuple->t_self;
+ newTuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(newTuple, tuple);
+ newTuple->t_data = (HeapTupleHeader) ((char *) newTuple + HEAPTUPLESIZE);
+ memcpy((char *) newTuple->t_data, (char *) tuple->t_data, tuple->t_len);
+ return newTuple;
+@@ -810,6 +811,7 @@ heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest)
+ dest->t_len = src->t_len;
+ dest->t_self = src->t_self;
+ dest->t_tableOid = src->t_tableOid;
++ HeapTupleCopyXids(dest, src);
+ dest->t_data = (HeapTupleHeader) palloc(src->t_len);
+ memcpy((char *) dest->t_data, (char *) src->t_data, src->t_len);
+ }
+@@ -1173,6 +1175,7 @@ heap_form_tuple(TupleDesc tupleDescriptor,
+ tuple->t_len = len;
+ ItemPointerSetInvalid(&(tuple->t_self));
+ tuple->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tuple);
+
+ HeapTupleHeaderSetDatumLength(td, len);
+ HeapTupleHeaderSetTypeId(td, tupleDescriptor->tdtypeid);
+@@ -1257,6 +1260,7 @@ heap_modify_tuple(HeapTuple tuple,
+ newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
+ newTuple->t_self = tuple->t_self;
+ newTuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(newTuple, tuple);
+
+ return newTuple;
+ }
+@@ -1320,6 +1324,7 @@ heap_modify_tuple_by_cols(HeapTuple tuple,
+ newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
+ newTuple->t_self = tuple->t_self;
+ newTuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(newTuple, tuple);
+
+ return newTuple;
+ }
+@@ -1560,6 +1565,7 @@ heap_tuple_from_minimal_tuple(MinimalTuple mtup)
+ result->t_len = len;
+ ItemPointerSetInvalid(&(result->t_self));
+ result->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(result);
+ result->t_data = (HeapTupleHeader) ((char *) result + HEAPTUPLESIZE);
+ memcpy((char *) result->t_data + MINIMAL_TUPLE_OFFSET, mtup, mtup->t_len);
+ memset(result->t_data, 0, offsetof(HeapTupleHeaderData, t_infomask2));
+diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
+index b76dca4ef41..10e8ae02c24 100644
+--- a/src/backend/access/heap/heapam.c
++++ b/src/backend/access/heap/heapam.c
+@@ -42,9 +42,13 @@
+ #include "access/xloginsert.h"
+ #include "catalog/pg_database.h"
+ #include "catalog/pg_database_d.h"
++#include "access/xlogutils.h"
++#include "catalog/index.h"
++#include "catalog/namespace.h"
+ #include "commands/vacuum.h"
+ #include "pgstat.h"
+ #include "port/pg_bitutils.h"
++#include "storage/buf_internals.h"
+ #include "storage/lmgr.h"
+ #include "storage/predicate.h"
+ #include "storage/procarray.h"
+@@ -52,9 +56,8 @@
+ #include "utils/inval.h"
+ #include "utils/spccache.h"
+
+-
+ static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup,
+- TransactionId xid, CommandId cid, int options);
++ CommandId cid, int options);
+ static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf,
+ Buffer newbuf, HeapTuple oldtup,
+ HeapTuple newtup, HeapTuple old_key_tuple,
+@@ -102,6 +105,8 @@ static int bottomup_sort_and_shrink(TM_IndexDeleteOp *delstate);
+ static XLogRecPtr log_heap_new_cid(Relation relation, HeapTuple tup);
+ static HeapTuple ExtractReplicaIdentity(Relation relation, HeapTuple tp, bool key_required,
+ bool *copy);
++static bool heap_page_prepare_for_xid(Relation relation, Buffer buffer,
++ TransactionId xid, bool multi);
+
+
+ /*
+@@ -452,6 +457,8 @@ page_collect_tuples(HeapScanDesc scan, Snapshot snapshot,
+ loctup.t_data = (HeapTupleHeader) PageGetItem(page, lpp);
+ loctup.t_len = ItemIdGetLength(lpp);
+ loctup.t_tableOid = RelationGetRelid(scan->rs_base.rs_rd);
++ HeapTupleCopyRawXidsFromPage(buffer, &loctup, page,
++ IsToastRelation(scan->rs_base.rs_rd));
+ ItemPointerSet(&(loctup.t_self), block, lineoff);
+
+ if (all_visible)
+@@ -466,6 +473,12 @@ page_collect_tuples(HeapScanDesc scan, Snapshot snapshot,
+ if (valid)
+ {
+ scan->rs_vistuples[ntup] = lineoff;
++ /*
++ * Since there is no lock futher and xmin or xmax may be
++ * changed while base shift, copy them here.
++ */
++ scan->rs_xmin[ntup] = loctup.t_xmin;
++ scan->rs_xmax[ntup] = loctup.t_xmax;
+ ntup++;
+ }
+ }
+@@ -879,6 +892,8 @@ continue_page:
+
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
+ tuple->t_len = ItemIdGetLength(lpp);
++ HeapTupleCopyXidsFromPage(scan->rs_cbuf, tuple, page,
++ IsToastRelation(scan->rs_base.rs_rd));
+ ItemPointerSet(&(tuple->t_self), scan->rs_cblock, lineoff);
+
+ visible = HeapTupleSatisfiesVisibility(tuple,
+@@ -958,6 +973,9 @@ heapgettup_pagemode(HeapScanDesc scan,
+ linesleft = scan->rs_cindex;
+ /* lineindex now references the next or previous visible tid */
+
++ tuple->t_xmin = scan->rs_xmin[scan->rs_cindex];
++ tuple->t_xmax = scan->rs_xmax[scan->rs_cindex];
++
+ goto continue_page;
+ }
+
+@@ -995,6 +1013,8 @@ continue_page:
+
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
+ tuple->t_len = ItemIdGetLength(lpp);
++ tuple->t_xmin = scan->rs_xmin[lineindex];
++ tuple->t_xmax = scan->rs_xmax[lineindex];
+ ItemPointerSet(&(tuple->t_self), scan->rs_cblock, lineoff);
+
+ /* skip any tuples that don't match the scan key */
+@@ -1560,6 +1580,7 @@ heap_fetch(Relation relation,
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tuple->t_len = ItemIdGetLength(lp);
+ tuple->t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, tuple, page, IsToastRelation(relation));
+
+ /*
+ * check tuple visibility, then release lock
+@@ -1568,7 +1589,7 @@ heap_fetch(Relation relation,
+
+ if (valid)
+ PredicateLockTID(relation, &(tuple->t_self), snapshot,
+- HeapTupleHeaderGetXmin(tuple->t_data));
++ HeapTupleGetXmin(tuple));
+
+ HeapCheckForSerializableConflictOut(valid, relation, tuple, buffer, snapshot);
+
+@@ -1645,6 +1666,8 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ Assert(TransactionIdIsValid(RecentXmin));
+ Assert(BufferGetBlockNumber(buffer) == blkno);
+
++ heapTuple->t_self = *tid;
++
+ /* Scan through possible multiple members of HOT-chain */
+ for (;;)
+ {
+@@ -1680,6 +1703,8 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ heapTuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ heapTuple->t_len = ItemIdGetLength(lp);
+ heapTuple->t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, heapTuple, page,
++ IsToastRelation(relation));
+ ItemPointerSet(&heapTuple->t_self, blkno, offnum);
+
+ /*
+@@ -1694,7 +1719,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ */
+ if (TransactionIdIsValid(prev_xmax) &&
+ !TransactionIdEquals(prev_xmax,
+- HeapTupleHeaderGetXmin(heapTuple->t_data)))
++ HeapTupleGetXmin(heapTuple)))
+ break;
+
+ /*
+@@ -1715,7 +1740,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ {
+ ItemPointerSetOffsetNumber(tid, offnum);
+ PredicateLockTID(relation, &heapTuple->t_self, snapshot,
+- HeapTupleHeaderGetXmin(heapTuple->t_data));
++ HeapTupleGetXmin(heapTuple));
+ if (all_dead)
+ *all_dead = false;
+ return true;
+@@ -1750,7 +1775,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ blkno);
+ offnum = ItemPointerGetOffsetNumber(&heapTuple->t_data->t_ctid);
+ at_chain_start = false;
+- prev_xmax = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
++ prev_xmax = HeapTupleGetUpdateXidAny(heapTuple);
+ }
+ else
+ break; /* end of chain */
+@@ -1836,13 +1861,14 @@ heap_get_latest_tid(TableScanDesc sscan,
+ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tp.t_len = ItemIdGetLength(lp);
+ tp.t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
+
+ /*
+ * After following a t_ctid link, we might arrive at an unrelated
+ * tuple. Check for XMIN match.
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(tp.t_data)))
++ !TransactionIdEquals(priorXmax, HeapTupleGetXmin(&tp)))
+ {
+ UnlockReleaseBuffer(buffer);
+ break;
+@@ -1861,7 +1887,7 @@ heap_get_latest_tid(TableScanDesc sscan,
+ * If there's a valid t_ctid link, follow it, else we're done.
+ */
+ if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
+- HeapTupleHeaderIsOnlyLocked(tp.t_data) ||
++ HeapTupleIsOnlyLocked(&tp) ||
+ HeapTupleHeaderIndicatesMovedPartitions(tp.t_data) ||
+ ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid))
+ {
+@@ -1870,7 +1896,7 @@ heap_get_latest_tid(TableScanDesc sscan,
+ }
+
+ ctid = tp.t_data->t_ctid;
+- priorXmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
++ priorXmax = HeapTupleGetUpdateXidAny(&tp);
+ UnlockReleaseBuffer(buffer);
+ } /* end of loop */
+ }
+@@ -1895,7 +1921,7 @@ heap_get_latest_tid(TableScanDesc sscan,
+ static void
+ UpdateXmaxHintBits(HeapTupleHeader tuple, Buffer buffer, TransactionId xid)
+ {
+- Assert(TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple), xid));
++ Assert(TransactionIdEquals(HeapTupleHeaderGetRawXmax(BufferGetPage(buffer), tuple), xid));
+ Assert(!(tuple->t_infomask & HEAP_XMAX_IS_MULTI));
+
+ if (!(tuple->t_infomask & (HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID)))
+@@ -1962,6 +1988,31 @@ ReleaseBulkInsertStatePin(BulkInsertState bistate)
+ bistate->last_free = InvalidBlockNumber;
+ }
+
++/*
++ * Add xid_base and multi base to the WAL record.
++ *
++ * WAL record must being constructed.
++ */
++static inline void
++xlog_register_base(Page page, bool is_toast, TransactionId *xid_base,
++ TransactionId *multi_base)
++{
++ if (is_toast)
++ {
++ *xid_base = ToastPageGetSpecial(page)->pd_xid_base;
++ *multi_base = InvalidTransactionId;
++ }
++ else
++ {
++ HeapPageSpecial special = HeapPageGetSpecial(page);
++
++ *xid_base = special->pd_xid_base;
++ *multi_base = special->pd_multi_base;
++ }
++
++ XLogRegisterData((char *) xid_base, sizeof(*xid_base));
++ XLogRegisterData((char *) multi_base, sizeof(*multi_base));
++}
+
+ /*
+ * heap_insert - insert tuple into a heap
+@@ -2001,7 +2052,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ * Note: below this point, heaptup is the data we actually intend to store
+ * into the relation; tup is the caller's original untoasted data.
+ */
+- heaptup = heap_prepare_insert(relation, tup, xid, cid, options);
++ heaptup = heap_prepare_insert(relation, tup, cid, options);
+
+ /*
+ * Find buffer to insert this tuple into. If the page is all visible,
+@@ -2029,6 +2080,9 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ */
+ CheckForSerializableConflictIn(relation, NULL, InvalidBlockNumber);
+
++ heap_page_prepare_for_xid(relation, buffer, xid, false);
++ HeapTupleSetXmin(heaptup, xid);
++
+ /* NO EREPORT(ERROR) from here till changes are logged */
+ START_CRIT_SECTION();
+
+@@ -2066,6 +2120,8 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ Page page = BufferGetPage(buffer);
+ uint8 info = XLOG_HEAP_INSERT;
+ int bufflags = 0;
++ TransactionId xid_base,
++ multi_base;
+
+ /*
+ * If this is a catalog, we need to transmit combo CIDs to properly
+@@ -2104,12 +2160,17 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ {
+ xlrec.flags |= XLH_INSERT_CONTAINS_NEW_TUPLE;
+ bufflags |= REGBUF_KEEP_DATA;
+-
+- if (IsToastRelation(relation))
+- xlrec.flags |= XLH_INSERT_ON_TOAST_RELATION;
+ }
+
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_INSERT_ON_TOAST_RELATION;
++
+ XLogBeginInsert();
++
++ if (info & XLOG_HEAP_INIT_PAGE)
++ xlog_register_base(page, IsToastRelation(relation), &xid_base,
++ &multi_base);
++
+ XLogRegisterData((char *) &xlrec, SizeOfHeapInsert);
+
+ xlhdr.t_infomask2 = heaptup->t_data->t_infomask2;
+@@ -2171,7 +2232,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ * that in any case, the header fields are also set in the original tuple.
+ */
+ static HeapTuple
+-heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
++heap_prepare_insert(Relation relation, HeapTuple tup,
+ CommandId cid, int options)
+ {
+ /*
+@@ -2188,12 +2249,12 @@ heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
+ tup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
+ tup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);
+ tup->t_data->t_infomask |= HEAP_XMAX_INVALID;
+- HeapTupleHeaderSetXmin(tup->t_data, xid);
++ HeapTupleSetXmin(tup, InvalidTransactionId);
+ if (options & HEAP_INSERT_FROZEN)
+- HeapTupleHeaderSetXminFrozen(tup->t_data);
++ HeapTupleHeaderStoreXminFrozen(tup->t_data);
+
+ HeapTupleHeaderSetCmin(tup->t_data, cid);
+- HeapTupleHeaderSetXmax(tup->t_data, 0); /* for cleanliness */
++ HeapTupleSetXmax(tup, 0); /* for cleanliness */
+ tup->t_tableOid = RelationGetRelid(relation);
+
+ /*
+@@ -2285,8 +2346,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ tuple = ExecFetchSlotHeapTuple(slots[i], true, NULL);
+ slots[i]->tts_tableOid = RelationGetRelid(relation);
+ tuple->t_tableOid = slots[i]->tts_tableOid;
+- heaptuples[i] = heap_prepare_insert(relation, tuple, xid, cid,
+- options);
++ heaptuples[i] = heap_prepare_insert(relation, tuple, cid, options);
+ }
+
+ /*
+@@ -2361,6 +2421,8 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ if (starting_with_empty_page && (options & HEAP_INSERT_FROZEN))
+ all_frozen_set = true;
+
++ heap_page_prepare_for_xid(relation, buffer, xid, false);
++
+ /* NO EREPORT(ERROR) from here till changes are logged */
+ START_CRIT_SECTION();
+
+@@ -2368,6 +2430,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ * RelationGetBufferForTuple has ensured that the first tuple fits.
+ * Put that on the page, and then as many other tuples as fit.
+ */
++ HeapTupleSetXmin(heaptuples[ndone], xid);
+ RelationPutHeapTuple(relation, buffer, heaptuples[ndone], false);
+
+ /*
+@@ -2384,6 +2447,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ if (PageGetHeapFreeSpace(page) < MAXALIGN(heaptup->t_len) + saveFreeSpace)
+ break;
+
++ HeapTupleSetXmin(heaptup, xid);
+ RelationPutHeapTuple(relation, buffer, heaptup, false);
+
+ /*
+@@ -2429,6 +2493,8 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ char *scratchptr = scratch.data;
+ bool init;
+ int bufflags = 0;
++ TransactionId xid_base,
++ multi_base;
+
+ /*
+ * If the page was previously empty, we can reinit the page
+@@ -2519,6 +2585,11 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ bufflags |= REGBUF_KEEP_DATA;
+
+ XLogBeginInsert();
++
++ if (info & XLOG_HEAP_INIT_PAGE)
++ xlog_register_base(page, IsToastRelation(relation), &xid_base,
++ &multi_base);
++
+ XLogRegisterData((char *) xlrec, tupledata - scratch.data);
+ XLogRegisterBuffer(0, buffer, REGBUF_STANDARD | bufflags);
+
+@@ -2726,6 +2797,7 @@ heap_delete(Relation relation, ItemPointer tid,
+ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tp.t_len = ItemIdGetLength(lp);
+ tp.t_self = *tid;
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
+
+ l1:
+
+@@ -2757,7 +2829,7 @@ l1:
+ uint16 infomask;
+
+ /* must copy state data before unlocking buffer */
+- xwait = HeapTupleHeaderGetRawXmax(tp.t_data);
++ xwait = HeapTupleGetRawXmax(&tp);
+ infomask = tp.t_data->t_infomask;
+
+ /*
+@@ -2796,6 +2868,10 @@ l1:
+ NULL);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+
++ /* Copy possibly updated xid base after relocking */
++ HeapTupleCopyXidsFromPage(buffer, &tp, page,
++ IsToastRelation(relation));
++
+ /*
+ * If xwait had just locked the tuple then some other xact
+ * could update this tuple before we get to this point. Check
+@@ -2806,7 +2882,7 @@ l1:
+ */
+ if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
+ xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tp.t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(&tp),
+ xwait))
+ goto l1;
+ }
+@@ -2833,6 +2909,10 @@ l1:
+ XactLockTableWait(xwait, relation, &(tp.t_self), XLTW_Delete);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+
++ /* Copy possibly updated xid base after relocking */
++ HeapTupleCopyXidsFromPage(buffer, &tp, page,
++ IsToastRelation(relation));
++
+ /*
+ * xwait is done, but if xwait had just locked the tuple then some
+ * other xact could update this tuple before we get to this point.
+@@ -2843,7 +2923,7 @@ l1:
+ */
+ if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
+ xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tp.t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(&tp),
+ xwait))
+ goto l1;
+
+@@ -2857,7 +2937,7 @@ l1:
+ */
+ if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
+ HEAP_XMAX_IS_LOCKED_ONLY(tp.t_data->t_infomask) ||
+- HeapTupleHeaderIsOnlyLocked(tp.t_data))
++ HeapTupleIsOnlyLocked(&tp))
+ result = TM_Ok;
+ else if (!ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid))
+ result = TM_Updated;
+@@ -2887,9 +2967,9 @@ l1:
+ if (result != TM_Ok)
+ {
+ tmfd->ctid = tp.t_data->t_ctid;
+- tmfd->xmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
++ tmfd->xmax = HeapTupleGetUpdateXidAny(&tp);
+ if (result == TM_SelfModified)
+- tmfd->cmax = HeapTupleHeaderGetCmax(tp.t_data);
++ tmfd->cmax = HeapTupleGetCmax(&tp);
+ else
+ tmfd->cmax = InvalidCommandId;
+ UnlockReleaseBuffer(buffer);
+@@ -2912,7 +2992,7 @@ l1:
+ CheckForSerializableConflictIn(relation, tid, BufferGetBlockNumber(buffer));
+
+ /* replace cid with a combo CID if necessary */
+- HeapTupleHeaderAdjustCmax(tp.t_data, &cid, &iscombo);
++ HeapTupleAdjustCmax(&tp, &cid, &iscombo);
+
+ /*
+ * Compute replica identity tuple before entering the critical section so
+@@ -2930,11 +3010,20 @@ l1:
+ */
+ MultiXactIdSetOldestMember();
+
+- compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(tp.t_data),
++ compute_new_xmax_infomask(HeapTupleGetRawXmax(&tp),
+ tp.t_data->t_infomask, tp.t_data->t_infomask2,
+ xid, LockTupleExclusive, true,
+ &new_xmax, &new_infomask, &new_infomask2);
+
++#ifdef USE_ASSERT_CHECKING
++ if (IsToastRelation(relation))
++ Assert((new_infomask & HEAP_XMAX_IS_MULTI) == 0);
++#endif
++
++ heap_page_prepare_for_xid(relation, buffer, new_xmax,
++ (new_infomask & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
++
+ START_CRIT_SECTION();
+
+ /*
+@@ -2944,7 +3033,7 @@ l1:
+ * the subsequent page pruning will be a no-op and the hint will be
+ * cleared.
+ */
+- PageSetPrunable(page, xid);
++ PageSetPrunable(page, xid, IsToastRelation(relation));
+
+ if (PageIsAllVisible(page))
+ {
+@@ -2960,7 +3049,7 @@ l1:
+ tp.t_data->t_infomask |= new_infomask;
+ tp.t_data->t_infomask2 |= new_infomask2;
+ HeapTupleHeaderClearHotUpdated(tp.t_data);
+- HeapTupleHeaderSetXmax(tp.t_data, new_xmax);
++ HeapTupleAndHeaderSetXmax(page, &tp, new_xmax, IsToastRelation(relation));
+ HeapTupleHeaderSetCmax(tp.t_data, cid, iscombo);
+ /* Make sure there is no forward chain link in t_ctid */
+ tp.t_data->t_ctid = tp.t_self;
+@@ -2999,6 +3088,8 @@ l1:
+ tp.t_data->t_infomask2);
+ xlrec.offnum = ItemPointerGetOffsetNumber(&tp.t_self);
+ xlrec.xmax = new_xmax;
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_DELETE_PAGE_ON_TOAST_RELATION;
+
+ if (old_key_tuple != NULL)
+ {
+@@ -3156,7 +3247,8 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
+ HeapTuple heaptup;
+ HeapTuple old_key_tuple = NULL;
+ bool old_key_copied = false;
+- Page page;
++ Page page,
++ newpage;
+ BlockNumber block;
+ MultiXactStatus mxact_status;
+ Buffer buffer,
+@@ -3183,6 +3275,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
+ infomask_new_tuple,
+ infomask2_new_tuple;
+
++ Assert(!IsToastRelation(relation));
+ Assert(ItemPointerIsValid(otid));
+
+ /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
+@@ -3258,6 +3351,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
+ oldtup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ oldtup.t_len = ItemIdGetLength(lp);
+ oldtup.t_self = *otid;
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+
+ /* the new tuple is ready, except for this: */
+ newtup->t_tableOid = RelationGetRelid(relation);
+@@ -3351,7 +3445,7 @@ l2:
+ */
+
+ /* must copy state data before unlocking buffer */
+- xwait = HeapTupleHeaderGetRawXmax(oldtup.t_data);
++ xwait = HeapTupleGetRawXmax(&oldtup);
+ infomask = oldtup.t_data->t_infomask;
+
+ /*
+@@ -3402,6 +3496,7 @@ l2:
+ checked_lockers = true;
+ locker_remains = remain != 0;
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+
+ /*
+ * If xwait had just locked the tuple then some other xact
+@@ -3410,7 +3505,7 @@ l2:
+ */
+ if (xmax_infomask_changed(oldtup.t_data->t_infomask,
+ infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(oldtup.t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(&oldtup),
+ xwait))
+ goto l2;
+ }
+@@ -3436,7 +3531,7 @@ l2:
+ * subxact aborts.
+ */
+ if (!HEAP_XMAX_IS_LOCKED_ONLY(oldtup.t_data->t_infomask))
+- update_xact = HeapTupleGetUpdateXid(oldtup.t_data);
++ update_xact = HeapTupleGetUpdateXid(&oldtup);
+ else
+ update_xact = InvalidTransactionId;
+
+@@ -3483,7 +3578,7 @@ l2:
+ XLTW_Update);
+ checked_lockers = true;
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+-
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+ /*
+ * xwait is done, but if xwait had just locked the tuple then some
+ * other xact could update this tuple before we get to this point.
+@@ -3491,7 +3586,7 @@ l2:
+ */
+ if (xmax_infomask_changed(oldtup.t_data->t_infomask, infomask) ||
+ !TransactionIdEquals(xwait,
+- HeapTupleHeaderGetRawXmax(oldtup.t_data)))
++ HeapTupleGetRawXmax(&oldtup)))
+ goto l2;
+
+ /* Otherwise check if it committed or aborted */
+@@ -3530,9 +3625,9 @@ l2:
+ if (result != TM_Ok)
+ {
+ tmfd->ctid = oldtup.t_data->t_ctid;
+- tmfd->xmax = HeapTupleHeaderGetUpdateXid(oldtup.t_data);
++ tmfd->xmax = HeapTupleGetUpdateXidAny(&oldtup);
+ if (result == TM_SelfModified)
+- tmfd->cmax = HeapTupleHeaderGetCmax(oldtup.t_data);
++ tmfd->cmax = HeapTupleGetCmax(&oldtup);
+ else
+ tmfd->cmax = InvalidCommandId;
+ UnlockReleaseBuffer(buffer);
+@@ -3565,6 +3660,7 @@ l2:
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ visibilitymap_pin(relation, block, &vmbuffer);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+ goto l2;
+ }
+
+@@ -3574,7 +3670,7 @@ l2:
+ * If the tuple we're updating is locked, we need to preserve the locking
+ * info in the old tuple's Xmax. Prepare a new Xmax value for this.
+ */
+- compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
++ compute_new_xmax_infomask(HeapTupleGetRawXmax(&oldtup),
+ oldtup.t_data->t_infomask,
+ oldtup.t_data->t_infomask2,
+ xid, *lockmode, true,
+@@ -3593,7 +3689,7 @@ l2:
+ (checked_lockers && !locker_remains))
+ xmax_new_tuple = InvalidTransactionId;
+ else
+- xmax_new_tuple = HeapTupleHeaderGetRawXmax(oldtup.t_data);
++ xmax_new_tuple = HeapTupleGetRawXmax(&oldtup);
+
+ if (!TransactionIdIsValid(xmax_new_tuple))
+ {
+@@ -3626,17 +3722,15 @@ l2:
+ */
+ newtup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
+ newtup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);
+- HeapTupleHeaderSetXmin(newtup->t_data, xid);
+ HeapTupleHeaderSetCmin(newtup->t_data, cid);
+ newtup->t_data->t_infomask |= HEAP_UPDATED | infomask_new_tuple;
+ newtup->t_data->t_infomask2 |= infomask2_new_tuple;
+- HeapTupleHeaderSetXmax(newtup->t_data, xmax_new_tuple);
+
+ /*
+ * Replace cid with a combo CID if necessary. Note that we already put
+ * the plain cid into the new tuple.
+ */
+- HeapTupleHeaderAdjustCmax(oldtup.t_data, &cid, &iscombo);
++ HeapTupleAdjustCmax(&oldtup, &cid, &iscombo);
+
+ /*
+ * If the toaster needs to be activated, OR if the new tuple will not fit
+@@ -3666,7 +3760,7 @@ l2:
+
+ newtupsize = MAXALIGN(newtup->t_len);
+
+- if (need_toast || newtupsize > pagefree)
++ if (need_toast || newtupsize > pagefree || HeapPageIsDoubleXmax(page))
+ {
+ TransactionId xmax_lock_old_tuple;
+ uint16 infomask_lock_old_tuple,
+@@ -3691,7 +3785,7 @@ l2:
+ * updating, because the potentially created multixact would otherwise
+ * be wrong.
+ */
+- compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
++ compute_new_xmax_infomask(HeapTupleGetRawXmax(&oldtup),
+ oldtup.t_data->t_infomask,
+ oldtup.t_data->t_infomask2,
+ xid, *lockmode, false,
+@@ -3700,6 +3794,10 @@ l2:
+
+ Assert(HEAP_XMAX_IS_LOCKED_ONLY(infomask_lock_old_tuple));
+
++ heap_page_prepare_for_xid(relation, buffer, xmax_lock_old_tuple,
++ (infomask_lock_old_tuple & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
++
+ START_CRIT_SECTION();
+
+ /* Clear obsolete visibility flags ... */
+@@ -3708,9 +3806,9 @@ l2:
+ HeapTupleClearHotUpdated(&oldtup);
+ /* ... and store info about transaction updating this tuple */
+ Assert(TransactionIdIsValid(xmax_lock_old_tuple));
+- HeapTupleHeaderSetXmax(oldtup.t_data, xmax_lock_old_tuple);
+ oldtup.t_data->t_infomask |= infomask_lock_old_tuple;
+ oldtup.t_data->t_infomask2 |= infomask2_lock_old_tuple;
++ HeapTupleAndHeaderSetXmax(page, &oldtup, xmax_lock_old_tuple, false);
+ HeapTupleHeaderSetCmax(oldtup.t_data, cid, iscombo);
+
+ /* temporarily make it look not-updated, but locked */
+@@ -3793,7 +3891,11 @@ l2:
+ */
+ for (;;)
+ {
+- if (newtupsize > pagefree)
++ /*
++ * We can't fit new tuple to "double xmax" page, since it's
++ * impossible to set xmin there.
++ */
++ if (newtupsize > pagefree || HeapPageIsDoubleXmax(page))
+ {
+ /* It doesn't fit, must use RelationGetBufferForTuple. */
+ newbuf = RelationGetBufferForTuple(relation, heaptup->t_len,
+@@ -3827,6 +3929,9 @@ l2:
+ break;
+ }
+ }
++
++ /* Copy possibly updated xid base to old tuple after relocking */
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+ }
+ else
+ {
+@@ -3898,6 +4003,33 @@ l2:
+ id_has_external,
+ &old_key_copied);
+
++ newpage = BufferGetPage(newbuf);
++
++ /*
++ * Prepare pages for the current xid, that witten to the new tuple's Xmax
++ * and old page's pd_prune_xid.
++ */
++ heap_page_prepare_for_xid(relation, buffer, xid, false);
++ if (newbuf != buffer)
++ heap_page_prepare_for_xid(relation, newbuf, xid, false);
++
++ /* Prepare pages for tuple's Xmax */
++ heap_page_prepare_for_xid(relation, buffer, xmax_old_tuple,
++ (infomask_old_tuple & HEAP_XMAX_IS_MULTI) != 0);
++ heap_page_prepare_for_xid(relation, newbuf, xmax_new_tuple,
++ (heaptup->t_data->t_infomask & HEAP_XMAX_IS_MULTI) != 0);
++
++ /* Copy possibly updated Xid bases to the both tuples. */
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
++
++ /*
++ * Set new tuple's Xmin/Xmax, old tuple's Xmin/Xmax were already shifted.
++ */
++ HeapTupleAndHeaderSetXmin(newpage, heaptup, xid,
++ IsToastRelation(relation));
++ HeapTupleAndHeaderSetXmax(newpage, heaptup, xmax_new_tuple,
++ IsToastRelation(relation));
++
+ /* NO EREPORT(ERROR) from here till changes are logged */
+ START_CRIT_SECTION();
+
+@@ -3913,7 +4045,7 @@ l2:
+ * not to optimize for aborts. Note that heap_xlog_update must be kept in
+ * sync if this decision changes.
+ */
+- PageSetPrunable(page, xid);
++ PageSetPrunable(page, xid, false);
+
+ if (use_hot_update)
+ {
+@@ -3940,10 +4072,11 @@ l2:
+ oldtup.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+ /* ... and store info about transaction updating this tuple */
+ Assert(TransactionIdIsValid(xmax_old_tuple));
+- HeapTupleHeaderSetXmax(oldtup.t_data, xmax_old_tuple);
+ oldtup.t_data->t_infomask |= infomask_old_tuple;
+ oldtup.t_data->t_infomask2 |= infomask2_old_tuple;
++ HeapTupleAndHeaderSetXmax(page, &oldtup, xmax_old_tuple, false);
+ HeapTupleHeaderSetCmax(oldtup.t_data, cid, iscombo);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+
+ /* record address of new tuple in t_ctid of old one */
+ oldtup.t_data->t_ctid = heaptup->t_self;
+@@ -3997,6 +4130,18 @@ l2:
+
+ END_CRIT_SECTION();
+
++ if (newtup != heaptup)
++ {
++ /*
++ * Set new tuple's Xmin/Xmax only after both xid base preparations.
++ * Old tuple's Xmin/Xmax were already shifted because old tuple is on
++ * the page.
++ */
++ Assert(!IsToastRelation(relation));
++ HeapTupleAndHeaderSetXmin(newpage, heaptup, xid, false);
++ HeapTupleAndHeaderSetXmax(newpage, newtup, xmax_new_tuple, false);
++ }
++
+ if (newbuf != buffer)
+ LockBuffer(newbuf, BUFFER_LOCK_UNLOCK);
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+@@ -4466,6 +4611,7 @@ heap_lock_tuple(Relation relation, HeapTuple tuple,
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tuple->t_len = ItemIdGetLength(lp);
+ tuple->t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ l3:
+ result = HeapTupleSatisfiesUpdate(tuple, cid, *buffer);
+@@ -4492,7 +4638,7 @@ l3:
+ ItemPointerData t_ctid;
+
+ /* must copy state data before unlocking buffer */
+- xwait = HeapTupleHeaderGetRawXmax(tuple->t_data);
++ xwait = HeapTupleGetRawXmax(tuple);
+ infomask = tuple->t_data->t_infomask;
+ infomask2 = tuple->t_data->t_infomask2;
+ ItemPointerCopy(&tuple->t_data->t_ctid, &t_ctid);
+@@ -4650,11 +4796,13 @@ l3:
+ result = res;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+ }
+
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /*
+ * Make sure it's still an appropriate lock, else start over.
+@@ -4663,7 +4811,7 @@ l3:
+ * now need to follow the update chain to lock the new
+ * versions.
+ */
+- if (!HeapTupleHeaderIsOnlyLocked(tuple->t_data) &&
++ if (!HeapTupleIsOnlyLocked(tuple) &&
+ ((tuple->t_data->t_infomask2 & HEAP_KEYS_UPDATED) ||
+ !updated))
+ goto l3;
+@@ -4690,6 +4838,7 @@ l3:
+ !HEAP_XMAX_IS_EXCL_LOCKED(infomask))
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /*
+ * Make sure it's still an appropriate lock, else start over.
+@@ -4718,8 +4867,10 @@ l3:
+ * meantime, start over.
+ */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
++
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+
+@@ -4730,10 +4881,11 @@ l3:
+ else if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask))
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /* if the xmax changed in the meantime, start over */
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+ /* otherwise, we're good */
+@@ -4758,8 +4910,10 @@ l3:
+ {
+ /* ... but if the xmax changed in the meantime, start over */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
++
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+ Assert(HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask));
+@@ -4780,6 +4934,7 @@ l3:
+ if (require_sleep && (result == TM_Updated || result == TM_Deleted))
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+ else if (require_sleep)
+@@ -4805,6 +4960,7 @@ l3:
+ result = TM_WouldBlock;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+
+@@ -4831,6 +4987,8 @@ l3:
+ result = TM_WouldBlock;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page,
++ false);
+ goto failed;
+ }
+ break;
+@@ -4871,6 +5029,8 @@ l3:
+ result = TM_WouldBlock;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page,
++ false);
+ goto failed;
+ }
+ break;
+@@ -4897,11 +5057,13 @@ l3:
+ result = res;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+ }
+
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /*
+ * xwait is done, but if xwait had just locked the tuple then some
+@@ -4909,7 +5071,7 @@ l3:
+ * Check for xmax change, and start over if so.
+ */
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+
+@@ -4937,7 +5099,7 @@ l3:
+ if (!require_sleep ||
+ (tuple->t_data->t_infomask & HEAP_XMAX_INVALID) ||
+ HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask) ||
+- HeapTupleHeaderIsOnlyLocked(tuple->t_data))
++ HeapTupleIsOnlyLocked(tuple))
+ result = TM_Ok;
+ else if (!ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid))
+ result = TM_Updated;
+@@ -4963,9 +5125,9 @@ failed:
+ Assert(result != TM_Updated ||
+ !ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid));
+ tmfd->ctid = tuple->t_data->t_ctid;
+- tmfd->xmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
++ tmfd->xmax = HeapTupleGetUpdateXidAny(tuple);
+ if (result == TM_SelfModified)
+- tmfd->cmax = HeapTupleHeaderGetCmax(tuple->t_data);
++ tmfd->cmax = HeapTupleGetCmax(tuple);
+ else
+ tmfd->cmax = InvalidCommandId;
+ goto out_locked;
+@@ -4985,10 +5147,11 @@ failed:
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
+ visibilitymap_pin(relation, block, &vmbuffer);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto l3;
+ }
+
+- xmax = HeapTupleHeaderGetRawXmax(tuple->t_data);
++ xmax = HeapTupleGetRawXmax(tuple);
+ old_infomask = tuple->t_data->t_infomask;
+
+ /*
+@@ -5010,6 +5173,10 @@ failed:
+ GetCurrentTransactionId(), mode, false,
+ &xid, &new_infomask, &new_infomask2);
+
++ heap_page_prepare_for_xid(relation, *buffer, xid,
++ (new_infomask & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
++
+ START_CRIT_SECTION();
+
+ /*
+@@ -5028,7 +5195,8 @@ failed:
+ tuple->t_data->t_infomask2 |= new_infomask2;
+ if (HEAP_XMAX_IS_LOCKED_ONLY(new_infomask))
+ HeapTupleHeaderClearHotUpdated(tuple->t_data);
+- HeapTupleHeaderSetXmax(tuple->t_data, xid);
++ Assert(!IsToastRelation(relation));
++ HeapTupleAndHeaderSetXmax(page, tuple, xid, false);
+
+ /*
+ * Make sure there is no forward chain link in t_ctid. Note that in the
+@@ -5622,12 +5790,19 @@ l4:
+ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+ }
+
++ /*
++ * Copy xid base after buffer relocking, it could have changed since
++ * heap_fetch().
++ */
++ HeapTupleCopyXidsFromPage(buf, &mytup, BufferGetPage(buf),
++ IsToastRelation(rel));
++
+ /*
+ * Check the tuple XMIN against prior XMAX, if any. If we reached the
+ * end of the chain, we're done, so return success.
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(HeapTupleHeaderGetXmin(mytup.t_data),
++ !TransactionIdEquals(HeapTupleGetXmin(&mytup),
+ priorXmax))
+ {
+ result = TM_Ok;
+@@ -5639,7 +5814,7 @@ l4:
+ * (sub)transaction, then we already locked the last live one in the
+ * chain, thus we're done, so return success.
+ */
+- if (TransactionIdDidAbort(HeapTupleHeaderGetXmin(mytup.t_data)))
++ if (TransactionIdDidAbort(HeapTupleGetXmin(&mytup)))
+ {
+ result = TM_Ok;
+ goto out_locked;
+@@ -5647,7 +5822,7 @@ l4:
+
+ old_infomask = mytup.t_data->t_infomask;
+ old_infomask2 = mytup.t_data->t_infomask2;
+- xmax = HeapTupleHeaderGetRawXmax(mytup.t_data);
++ xmax = HeapTupleGetRawXmax(&mytup);
+
+ /*
+ * If this tuple version has been updated or locked by some concurrent
+@@ -5660,7 +5835,7 @@ l4:
+ TransactionId rawxmax;
+ bool needwait;
+
+- rawxmax = HeapTupleHeaderGetRawXmax(mytup.t_data);
++ rawxmax = HeapTupleGetRawXmax(&mytup);
+ if (old_infomask & HEAP_XMAX_IS_MULTI)
+ {
+ int nmembers;
+@@ -5801,14 +5976,25 @@ l4:
+ VISIBILITYMAP_ALL_FROZEN))
+ cleared_all_frozen = true;
+
++#ifdef USE_ASSERT_CHECKING
++ if (IsToastRelation(rel))
++ Assert((new_infomask & HEAP_XMAX_IS_MULTI) == 0);
++#endif
++
++ heap_page_prepare_for_xid(rel, buf, new_xmax,
++ (new_infomask & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(buf, &mytup, BufferGetPage(buf),
++ IsToastRelation(rel));
++
+ START_CRIT_SECTION();
+
+ /* ... and set them */
+- HeapTupleHeaderSetXmax(mytup.t_data, new_xmax);
+ mytup.t_data->t_infomask &= ~HEAP_XMAX_BITS;
+ mytup.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+ mytup.t_data->t_infomask |= new_infomask;
+ mytup.t_data->t_infomask2 |= new_infomask2;
++ Assert(!IsToastRelation(rel));
++ HeapTupleAndHeaderSetXmax(BufferGetPage(buf), &mytup, new_xmax, false);
+
+ MarkBufferDirty(buf);
+
+@@ -5842,14 +6028,14 @@ next:
+ if (mytup.t_data->t_infomask & HEAP_XMAX_INVALID ||
+ HeapTupleHeaderIndicatesMovedPartitions(mytup.t_data) ||
+ ItemPointerEquals(&mytup.t_self, &mytup.t_data->t_ctid) ||
+- HeapTupleHeaderIsOnlyLocked(mytup.t_data))
++ HeapTupleIsOnlyLocked(&mytup))
+ {
+ result = TM_Ok;
+ goto out_locked;
+ }
+
+ /* tail recursion */
+- priorXmax = HeapTupleHeaderGetUpdateXid(mytup.t_data);
++ priorXmax = HeapTupleGetUpdateXidAny(&mytup);
+ ItemPointerCopy(&(mytup.t_data->t_ctid), &tupid);
+ UnlockReleaseBuffer(buf);
+ }
+@@ -6051,12 +6237,13 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tp.t_len = ItemIdGetLength(lp);
+ tp.t_self = *tid;
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
+
+ /*
+ * Sanity check that the tuple really is a speculatively inserted tuple,
+ * inserted by us.
+ */
+- if (tp.t_data->t_choice.t_heap.t_xmin != xid)
++ if (HeapTupleGetRawXmin(&tp) != xid)
+ elog(ERROR, "attempted to kill a tuple inserted by another transaction");
+ if (!(IsToastRelation(relation) || HeapTupleHeaderIsSpeculative(tp.t_data)))
+ elog(ERROR, "attempted to kill a non-speculative tuple");
+@@ -6089,7 +6276,9 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ prune_xid = relfrozenxid;
+ else
+ prune_xid = TransactionXmin;
+- PageSetPrunable(page, prune_xid);
++ Assert(TransactionIdIsValid(prune_xid));
++ heap_page_prepare_for_xid(relation, buffer, prune_xid, false);
++ PageSetPrunable(page, prune_xid, IsToastRelation(relation));
+ }
+
+ /* store transaction information of xact deleting the tuple */
+@@ -6099,9 +6288,12 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ /*
+ * Set the tuple header xmin to InvalidTransactionId. This makes the
+ * tuple immediately invisible everyone. (In particular, to any
+- * transactions waiting on the speculative token, woken up later.)
++ * transactions waiting on the speculative token, woken up later.) Don't
++ * need to reload xid base from page because InvalidTransactionId doesn't
++ * require xid base to be valid.
+ */
+- HeapTupleHeaderSetXmin(tp.t_data, InvalidTransactionId);
++ HeapTupleAndHeaderSetXmin(page, &tp, InvalidTransactionId,
++ IsToastRelation(relation));
+
+ /* Clear the speculative insertion token too */
+ tp.t_data->t_ctid = tp.t_self;
+@@ -6120,6 +6312,8 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ XLogRecPtr recptr;
+
+ xlrec.flags = XLH_DELETE_IS_SUPER;
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_DELETE_PAGE_ON_TOAST_RELATION;
+ xlrec.infobits_set = compute_infobits(tp.t_data->t_infomask,
+ tp.t_data->t_infomask2);
+ xlrec.offnum = ItemPointerGetOffsetNumber(&tp.t_self);
+@@ -6207,6 +6401,7 @@ heap_inplace_lock(Relation relation,
+ HeapTupleData oldtup = *oldtup_ptr; /* minimize diff vs. heap_update() */
+ TM_Result result;
+ bool ret;
++ Page page;
+
+ #ifdef USE_ASSERT_CHECKING
+ if (RelationGetRelid(relation) == RelationRelationId)
+@@ -6228,6 +6423,8 @@ heap_inplace_lock(Relation relation,
+
+ LockTuple(relation, &oldtup.t_self, InplaceUpdateTupleLock);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
++ page = (Page) BufferGetPage(buffer);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, IsToastRelation(relation));
+
+ /*----------
+ * Interpret HeapTupleSatisfiesUpdate() like heap_update() does, except:
+@@ -6265,7 +6462,7 @@ heap_inplace_lock(Relation relation,
+ TransactionId xwait;
+ uint16 infomask;
+
+- xwait = HeapTupleHeaderGetRawXmax(oldtup.t_data);
++ xwait = HeapTupleGetRawXmax(&oldtup);
+ infomask = oldtup.t_data->t_infomask;
+
+ if (infomask & HEAP_XMAX_IS_MULTI)
+@@ -6616,7 +6813,7 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ * been pruned away instead, since updater XID is < OldestXmin).
+ * Just remove xmax.
+ */
+- if (TransactionIdDidCommit(update_xact))
++ if (!TransactionIdDidAbort(update_xact))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg_internal("multixact %llu contains non-aborted update XID %llu from before removable cutoff %llu",
+@@ -6714,7 +6911,7 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ * even member XIDs >= OldestXmin often won't be kept by second pass.
+ */
+ nnewmembers = 0;
+- newmembers = palloc(sizeof(MultiXactMember) * nmembers);
++ newmembers = palloc0(sizeof(MultiXactMember) * nmembers);
+ has_lockers = false;
+ update_xid = InvalidTransactionId;
+ update_committed = false;
+@@ -6900,7 +7097,7 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ * then caller had better have an exclusive lock on it already.
+ */
+ bool
+-heap_prepare_freeze_tuple(HeapTupleHeader tuple,
++heap_prepare_freeze_tuple(HeapTuple htup,
+ const struct VacuumCutoffs *cutoffs,
+ HeapPageFreeze *pagefrz,
+ HeapTupleFreeze *frz, bool *totally_frozen)
+@@ -6912,8 +7109,9 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ replace_xmax = false,
+ freeze_xmax = false;
+ TransactionId xid;
++ HeapTupleHeader tuple = htup->t_data;
+
+- frz->xmax = HeapTupleHeaderGetRawXmax(tuple);
++ frz->xmax = HeapTupleGetRawXmax(htup);
+ frz->t_infomask2 = tuple->t_infomask2;
+ frz->t_infomask = tuple->t_infomask;
+ frz->frzflags = 0;
+@@ -6924,7 +7122,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ * will become frozen iff our freeze plan is executed by caller (could be
+ * neither).
+ */
+- xid = HeapTupleHeaderGetXmin(tuple);
++ xid = HeapTupleGetXmin(htup);
+ if (!TransactionIdIsNormal(xid))
+ xmin_already_frozen = true;
+ else
+@@ -7066,6 +7264,15 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ /* MultiXactId processing forces freezing (barring FRM_NOOP case) */
+ Assert(pagefrz->freeze_required || (!freeze_xmax && !replace_xmax));
+ }
++ else if ((tuple->t_infomask & HEAP_XMAX_INVALID) &&
++ TransactionIdIsNormal(xid))
++ {
++ /*
++ * To reset xmax without reading clog.
++ * This prevent excess growth of xmax.
++ */
++ freeze_xmax = true;
++ }
+ else if (TransactionIdIsNormal(xid))
+ {
+ /* Raw xmax is normal XID */
+@@ -7087,7 +7294,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ if (freeze_xmax && !HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ frz->checkflags |= HEAP_FREEZE_CHECK_XMAX_ABORTED;
+ }
+- else if (!TransactionIdIsValid(xid))
++ else if (!TransactionIdIsValid(HeapTupleGetRawXmax(htup)))
+ {
+ /* Raw xmax is InvalidTransactionId XID */
+ Assert((tuple->t_infomask & HEAP_XMAX_IS_MULTI) == 0);
+@@ -7157,7 +7364,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ * Does this tuple force caller to freeze the entire page?
+ */
+ pagefrz->freeze_required =
+- heap_tuple_should_freeze(tuple, cutoffs,
++ heap_tuple_should_freeze(htup, cutoffs,
+ &pagefrz->NoFreezePageRelfrozenXid,
+ &pagefrz->NoFreezePageRelminMxid);
+ }
+@@ -7175,7 +7382,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ * successive VACUUMs that each decide against freezing the same page.
+ */
+ void
+-heap_pre_freeze_checks(Buffer buffer,
++heap_pre_freeze_checks(Relation rel, Buffer buffer,
+ HeapTupleFreeze *tuples, int ntuples)
+ {
+ Page page = BufferGetPage(buffer);
+@@ -7184,34 +7391,31 @@ heap_pre_freeze_checks(Buffer buffer,
+ {
+ HeapTupleFreeze *frz = tuples + i;
+ ItemId itemid = PageGetItemId(page, frz->offset);
+- HeapTupleHeader htup;
++ HeapTupleData tuple;
+
+- htup = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page, IsToastRelation(rel));
+
+ /* Deliberately avoid relying on tuple hint bits here */
+ if (frz->checkflags & HEAP_FREEZE_CHECK_XMIN_COMMITTED)
+ {
+- TransactionId xmin = HeapTupleHeaderGetRawXmin(htup);
++ TransactionId xmin = HeapTupleGetXmin(&tuple);
+
+- Assert(!HeapTupleHeaderXminFrozen(htup));
++ Assert(!HeapTupleHeaderXminFrozen(tuple.t_data));
+ if (unlikely(!TransactionIdDidCommit(xmin)))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg_internal("uncommitted xmin %llu needs to be frozen",
+ (unsigned long long) xmin)));
+ }
+-
+- /*
+- * TransactionIdDidAbort won't work reliably in the presence of XIDs
+- * left behind by transactions that were in progress during a crash,
+- * so we can only check that xmax didn't commit
+- */
+ if (frz->checkflags & HEAP_FREEZE_CHECK_XMAX_ABORTED)
+ {
+- TransactionId xmax = HeapTupleHeaderGetRawXmax(htup);
++ TransactionId xmax = HeapTupleGetRawXmax(&tuple);
+
+ Assert(TransactionIdIsNormal(xmax));
+- if (unlikely(TransactionIdDidCommit(xmax)))
++ if (unlikely(!TransactionIdDidAbort(xmax)))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg_internal("cannot freeze non-aborted xmax %llu",
+@@ -7228,7 +7432,7 @@ heap_pre_freeze_checks(Buffer buffer,
+ * if needed, emits WAL.
+ */
+ void
+-heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
++heap_freeze_prepared_tuples(Relation rel, Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
+ {
+ Page page = BufferGetPage(buffer);
+
+@@ -7239,7 +7443,9 @@ heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
+ HeapTupleHeader htup;
+
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
+- heap_execute_freeze_tuple(htup, frz);
++ heap_execute_freeze_tuple_page(page, htup, frz,
++ IsToastRelation(rel));
++
+ }
+ }
+
+@@ -7250,7 +7456,7 @@ heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
+ * Useful for callers like CLUSTER that perform their own WAL logging.
+ */
+ bool
+-heap_freeze_tuple(HeapTupleHeader tuple,
++heap_freeze_tuple(HeapTuple tuple,
+ TransactionId relfrozenxid, TransactionId relminmxid,
+ TransactionId FreezeLimit, TransactionId MultiXactCutoff)
+ {
+@@ -7427,10 +7633,10 @@ MultiXactIdGetUpdateXid(TransactionId xmax, uint16 t_infomask)
+ * checking the hint bits.
+ */
+ TransactionId
+-HeapTupleGetUpdateXid(HeapTupleHeader tuple)
++HeapTupleGetUpdateXid(HeapTuple tuple)
+ {
+- return MultiXactIdGetUpdateXid(HeapTupleHeaderGetRawXmax(tuple),
+- tuple->t_infomask);
++ return MultiXactIdGetUpdateXid(HeapTupleGetRawXmax(tuple),
++ tuple->t_data->t_infomask);
+ }
+
+ /*
+@@ -7656,15 +7862,18 @@ ConditionalMultiXactIdWait(MultiXactId multi, MultiXactStatus status,
+ * will eventually require freezing (if tuple isn't removed by pruning first).
+ */
+ bool
+-heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
++heap_tuple_needs_eventual_freeze(HeapTuple htup)
+ {
+ TransactionId xid;
++ HeapTupleHeader tuple;
++
++ tuple = htup->t_data;
+
+ /*
+ * If xmin is a normal transaction ID, this tuple is definitely not
+ * frozen.
+ */
+- xid = HeapTupleHeaderGetXmin(tuple);
++ xid = HeapTupleGetXmin(htup);
+ if (TransactionIdIsNormal(xid))
+ return true;
+
+@@ -7675,13 +7884,13 @@ heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
+ {
+ MultiXactId multi;
+
+- multi = HeapTupleHeaderGetRawXmax(tuple);
++ multi = HeapTupleGetRawXmax(htup);
+ if (MultiXactIdIsValid(multi))
+ return true;
+ }
+ else
+ {
+- xid = HeapTupleHeaderGetRawXmax(tuple);
++ xid = HeapTupleGetRawXmax(htup);
+ if (TransactionIdIsNormal(xid))
+ return true;
+ }
+@@ -7711,17 +7920,18 @@ heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
+ * point that it fully commits to not freezing the tuple/page in question.
+ */
+ bool
+-heap_tuple_should_freeze(HeapTupleHeader tuple,
++heap_tuple_should_freeze(HeapTuple htup,
+ const struct VacuumCutoffs *cutoffs,
+ TransactionId *NoFreezePageRelfrozenXid,
+ MultiXactId *NoFreezePageRelminMxid)
+ {
+ TransactionId xid;
+ MultiXactId multi;
++ HeapTupleHeader tuple = htup->t_data;
+ bool freeze = false;
+
+ /* First deal with xmin */
+- xid = HeapTupleHeaderGetXmin(tuple);
++ xid = HeapTupleGetXmin(htup);
+ if (TransactionIdIsNormal(xid))
+ {
+ Assert(TransactionIdPrecedesOrEquals(cutoffs->relfrozenxid, xid));
+@@ -7735,9 +7945,9 @@ heap_tuple_should_freeze(HeapTupleHeader tuple,
+ xid = InvalidTransactionId;
+ multi = InvalidMultiXactId;
+ if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
+- multi = HeapTupleHeaderGetRawXmax(tuple);
++ multi = HeapTupleGetRawXmax(htup);
+ else
+- xid = HeapTupleHeaderGetRawXmax(tuple);
++ xid = HeapTupleGetRawXmax(htup);
+
+ if (TransactionIdIsNormal(xid))
+ {
+@@ -7748,6 +7958,14 @@ heap_tuple_should_freeze(HeapTupleHeader tuple,
+ if (TransactionIdPrecedes(xid, cutoffs->FreezeLimit))
+ freeze = true;
+ }
++ else if ((tuple->t_infomask & HEAP_XMAX_INVALID) &&
++ TransactionIdIsNormal(xid))
++ {
++ /*
++ * To reset xmax without reading clog.
++ */
++ freeze = true;
++ }
+ else if (!MultiXactIdIsValid(multi))
+ {
+ /* xmax is a permanent XID or invalid MultiXactId/XID */
+@@ -7819,14 +8037,14 @@ heap_tuple_should_freeze(HeapTupleHeader tuple,
+ * caller's WAL record) by REDO routine when it replays caller's operation.
+ */
+ void
+-HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
++HeapTupleHeaderAdvanceConflictHorizon(HeapTuple tuple,
+ TransactionId *snapshotConflictHorizon)
+ {
+- TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
+- TransactionId xmax = HeapTupleHeaderGetUpdateXid(tuple);
+- TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
++ TransactionId xmin = HeapTupleGetXmin(tuple);
++ TransactionId xmax = HeapTupleGetUpdateXidAny(tuple);
++ TransactionId xvac = HeapTupleHeaderGetXvac(tuple->t_data);
+
+- if (tuple->t_infomask & HEAP_MOVED)
++ if (tuple->t_data->t_infomask & HEAP_MOVED)
+ {
+ if (TransactionIdPrecedes(*snapshotConflictHorizon, xvac))
+ *snapshotConflictHorizon = xvac;
+@@ -7838,8 +8056,8 @@ HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
+ *
+ * Look for a committed hint bit, or if no xmin bit is set, check clog.
+ */
+- if (HeapTupleHeaderXminCommitted(tuple) ||
+- (!HeapTupleHeaderXminInvalid(tuple) && TransactionIdDidCommit(xmin)))
++ if (HeapTupleHeaderXminCommitted(tuple->t_data) ||
++ (!HeapTupleHeaderXminInvalid(tuple->t_data) && TransactionIdDidCommit(xmin)))
+ {
+ if (xmax != xmin &&
+ TransactionIdFollows(xmax, *snapshotConflictHorizon))
+@@ -8187,7 +8405,7 @@ heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
+ for (;;)
+ {
+ ItemId lp;
+- HeapTupleHeader htup;
++ HeapTupleData htup;
+
+ /* Sanity check (pure paranoia) */
+ if (offnum < FirstOffsetNumber)
+@@ -8224,16 +8442,18 @@ heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
+ if (!ItemIdIsNormal(lp))
+ break;
+
+- htup = (HeapTupleHeader) PageGetItem(page, lp);
++ htup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
++ htup.t_len = ItemIdGetLength(lp);
++ HeapTupleCopyXidsFromPage(buf, &htup, page, IsToastRelation(rel));
+
+ /*
+ * Check the tuple XMIN against prior XMAX, if any
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(HeapTupleHeaderGetXmin(htup), priorXmax))
++ !TransactionIdEquals(HeapTupleGetXmin(&htup), priorXmax))
+ break;
+
+- HeapTupleHeaderAdvanceConflictHorizon(htup,
++ HeapTupleHeaderAdvanceConflictHorizon(&htup,
+ &snapshotConflictHorizon);
+
+ /*
+@@ -8242,13 +8462,13 @@ heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
+ * chain (they get their own index entries) -- just move on to
+ * next htid from index AM caller.
+ */
+- if (!HeapTupleHeaderIsHotUpdated(htup))
++ if (!HeapTupleHeaderIsHotUpdated(htup.t_data))
+ break;
+
+ /* Advance to next HOT chain member */
+- Assert(ItemPointerGetBlockNumber(&htup->t_ctid) == blkno);
+- offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ Assert(ItemPointerGetBlockNumber(&htup.t_data->t_ctid) == blkno);
++ offnum = ItemPointerGetOffsetNumber(&htup.t_data->t_ctid);
++ priorXmax = HeapTupleGetUpdateXidAny(&htup);
+ }
+
+ /* Enable further/final shrinking of deltids for caller */
+@@ -8690,6 +8910,8 @@ log_heap_update(Relation reln, Buffer oldbuf,
+ bool all_visible_cleared, bool new_all_visible_cleared)
+ {
+ xl_heap_update xlrec;
++ TransactionId xid_base,
++ multi_base;
+ xl_heap_header xlhdr;
+ xl_heap_header xlhdr_idx;
+ uint8 info;
+@@ -8798,13 +9020,13 @@ log_heap_update(Relation reln, Buffer oldbuf,
+
+ /* Prepare WAL data for the old page */
+ xlrec.old_offnum = ItemPointerGetOffsetNumber(&oldtup->t_self);
+- xlrec.old_xmax = HeapTupleHeaderGetRawXmax(oldtup->t_data);
++ xlrec.old_xmax = HeapTupleGetRawXmax(oldtup);
+ xlrec.old_infobits_set = compute_infobits(oldtup->t_data->t_infomask,
+ oldtup->t_data->t_infomask2);
+
+ /* Prepare WAL data for the new page */
+ xlrec.new_offnum = ItemPointerGetOffsetNumber(&newtup->t_self);
+- xlrec.new_xmax = HeapTupleHeaderGetRawXmax(newtup->t_data);
++ xlrec.new_xmax = HeapTupleGetRawXmax(newtup);
+
+ bufflags = REGBUF_STANDARD;
+ if (init)
+@@ -8816,6 +9038,17 @@ log_heap_update(Relation reln, Buffer oldbuf,
+ if (oldbuf != newbuf)
+ XLogRegisterBuffer(1, oldbuf, REGBUF_STANDARD);
+
++ if (info & XLOG_HEAP_INIT_PAGE)
++ {
++ HeapPageSpecial special = HeapPageGetSpecial(page);
++
++ Assert(!IsToastRelation(reln));
++ xid_base = special->pd_xid_base;
++ multi_base = special->pd_multi_base;
++ XLogRegisterData((char *) &xid_base, sizeof(xid_base));
++ XLogRegisterData((char *) &multi_base, sizeof(multi_base));
++ }
++
+ XLogRegisterData((char *) &xlrec, SizeOfHeapUpdate);
+
+ /*
+@@ -8928,8 +9161,8 @@ log_heap_new_cid(Relation relation, HeapTuple tup)
+ {
+ Assert(!(hdr->t_infomask & HEAP_XMAX_INVALID));
+ Assert(!HeapTupleHeaderXminInvalid(hdr));
+- xlrec.cmin = HeapTupleHeaderGetCmin(hdr);
+- xlrec.cmax = HeapTupleHeaderGetCmax(hdr);
++ xlrec.cmin = HeapTupleGetCmin(tup);
++ xlrec.cmax = HeapTupleGetCmax(tup);
+ xlrec.combocid = HeapTupleHeaderGetRawCommandId(hdr);
+ }
+ /* No combo CID, so only cmin or cmax can be set by this TX */
+@@ -9118,14 +9351,14 @@ HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+ case HEAPTUPLE_LIVE:
+ if (visible)
+ return;
+- xid = HeapTupleHeaderGetXmin(tuple->t_data);
++ xid = HeapTupleGetXmin(tuple);
+ break;
+ case HEAPTUPLE_RECENTLY_DEAD:
+ case HEAPTUPLE_DELETE_IN_PROGRESS:
+ if (visible)
+- xid = HeapTupleHeaderGetUpdateXid(tuple->t_data);
++ xid = HeapTupleGetUpdateXidAny(tuple);
+ else
+- xid = HeapTupleHeaderGetXmin(tuple->t_data);
++ xid = HeapTupleGetXmin(tuple);
+
+ if (TransactionIdPrecedes(xid, TransactionXmin))
+ {
+@@ -9135,7 +9368,7 @@ HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+ }
+ break;
+ case HEAPTUPLE_INSERT_IN_PROGRESS:
+- xid = HeapTupleHeaderGetXmin(tuple->t_data);
++ xid = HeapTupleGetXmin(tuple);
+ break;
+ case HEAPTUPLE_DEAD:
+ Assert(!visible);
+@@ -9173,3 +9406,511 @@ HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+
+ CheckForSerializableConflictOut(relation, xid, snapshot);
+ }
++
++static void
++xid_min_max(ShortTransactionId *min, ShortTransactionId *max,
++ ShortTransactionId xid,
++ bool *found)
++{
++ Assert(TransactionIdIsNormal(xid));
++ Assert(xid <= MaxShortTransactionId);
++
++ if (!*found)
++ {
++ *min = *max = xid;
++ *found = true;
++ }
++ else
++ {
++ *min = Min(*min, xid);
++ *max = Max(*max, xid);
++ }
++}
++
++/*
++ * Find minimum and maximum short transaction ids which occurs in the page.
++ *
++ * Works for multi and non multi transaction. Which is defined by "multi"
++ * argument.
++ */
++static bool
++heap_page_xid_min_max(Page page, bool multi,
++ ShortTransactionId *min, ShortTransactionId *max,
++ bool is_toast)
++{
++ bool found;
++ OffsetNumber offnum,
++ maxoff;
++ ItemId itemid;
++ HeapTupleHeader htup;
++
++ maxoff = PageGetMaxOffsetNumber(page);
++ found = false;
++
++ Assert(!multi || !is_toast);
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++
++ if (!multi)
++ {
++ /*
++ * For non multi transactions we should see inside the tuple for
++ * update transaction.
++ */
++ Assert(!is_toast || !(htup->t_infomask & HEAP_XMAX_IS_MULTI));
++
++ if (TransactionIdIsNormal(htup->t_choice.t_heap.t_xmin) &&
++ !HeapTupleHeaderXminFrozen(htup))
++ {
++ xid_min_max(min, max, htup->t_choice.t_heap.t_xmin, &found);
++ }
++
++ if ((htup->t_infomask & HEAP_XMAX_IS_MULTI) &&
++ (!(htup->t_infomask & HEAP_XMAX_LOCK_ONLY)))
++ {
++ TransactionId update_xid;
++ ShortTransactionId xid;
++
++ Assert(!is_toast);
++ update_xid = MultiXactIdGetUpdateXid(HeapTupleHeaderGetRawXmax(page, htup),
++ htup->t_infomask);
++ xid = NormalTransactionIdToShort(HeapPageGetSpecial(page)->pd_xid_base,
++ update_xid);
++
++ xid_min_max(min, max, xid, &found);
++ }
++ }
++
++ if (!TransactionIdIsNormal(htup->t_choice.t_heap.t_xmax))
++ continue;
++
++ if (multi != ((htup->t_infomask & HEAP_XMAX_IS_MULTI) != 0))
++ continue;
++
++ xid_min_max(min, max, htup->t_choice.t_heap.t_xmax, &found);
++ }
++
++ Assert(!found || (*min > InvalidTransactionId && *max <= MaxShortTransactionId));
++
++ return found;
++}
++
++/*
++ * Shift xid base in the page. WAL-logged if buffer is specified.
++ */
++static void
++heap_page_shift_base(Relation relation, Buffer buffer, Page page,
++ bool multi, int64 delta, bool is_toast)
++{
++ TransactionId *xid_base,
++ *multi_base;
++ OffsetNumber offnum,
++ maxoff;
++ ItemId itemid;
++ HeapTupleHeader htup;
++
++ Assert(IsBufferLockedExclusive(buffer));
++
++ START_CRIT_SECTION();
++
++ if (is_toast)
++ {
++ Assert(!multi);
++ xid_base = &ToastPageGetSpecial(page)->pd_xid_base;
++ multi_base = NULL;
++ }
++ else
++ {
++ HeapPageSpecial special = HeapPageGetSpecial(page);
++
++ xid_base = &special->pd_xid_base;
++ multi_base = &special->pd_multi_base;
++ }
++
++ /* Iterate over page items */
++ maxoff = PageGetMaxOffsetNumber(page);
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++
++ /* Apply xid shift to heap tuple */
++ if (!multi)
++ {
++ /* shift xmin */
++ if (TransactionIdIsNormal(htup->t_choice.t_heap.t_xmin) &&
++ !HeapTupleHeaderXminFrozen(htup))
++ {
++ Assert(htup->t_choice.t_heap.t_xmin - delta >= FirstNormalTransactionId);
++ Assert(htup->t_choice.t_heap.t_xmin - delta <= MaxShortTransactionId);
++ htup->t_choice.t_heap.t_xmin -= delta;
++ }
++ }
++
++ /* shift xmax */
++ if (!TransactionIdIsNormal(htup->t_choice.t_heap.t_xmax))
++ continue;
++
++ if (multi != (bool) (htup->t_infomask & HEAP_XMAX_IS_MULTI))
++ continue;
++
++ Assert(htup->t_choice.t_heap.t_xmax - delta >= FirstNormalTransactionId);
++ Assert(htup->t_choice.t_heap.t_xmax - delta <= MaxShortTransactionId);
++ htup->t_choice.t_heap.t_xmax -= delta;
++ }
++
++ /* Apply xid shift to base as well */
++ if (!multi)
++ *xid_base += delta;
++ else
++ *multi_base += delta;
++
++ if (BufferIsValid(buffer))
++ MarkBufferDirty(buffer);
++
++ /* Write WAL record if needed */
++ if (relation && RelationNeedsWAL(relation) && maxoff != 0)
++ {
++ XLogRecPtr recptr;
++ xl_heap_base_shift xlrec;
++
++ xlrec.delta = delta;
++ xlrec.multi = multi;
++ xlrec.flags = 0;
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_BASE_SHIFT_ON_TOAST_RELATION;
++
++ XLogBeginInsert();
++ XLogRegisterData((char *) &xlrec, SizeOfHeapBaseShift);
++ XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
++
++ recptr = XLogInsert(RM_HEAP3_ID, XLOG_HEAP3_BASE_SHIFT);
++
++ PageSetLSN(page, recptr);
++ }
++
++ END_CRIT_SECTION();
++}
++
++/*
++ * Freeze xids in the single heap page. Useful when we can't fit new xid even
++ * with base shift.
++ */
++static void
++freeze_single_heap_page(Relation relation, Buffer buffer)
++{
++ OffsetNumber offnum;
++ GlobalVisState *vistest;
++ VacuumParams params = {0};
++ struct VacuumCutoffs cutoffs = {0};
++ TransactionId new_relfrozen_xid;
++ MultiXactId new_relmin_mxid;
++ PruneFreezeResult presult;
++
++ vacuum_get_cutoffs(relation, ¶ms, &cutoffs);
++ new_relfrozen_xid = cutoffs.FreezeLimit;
++ new_relmin_mxid = cutoffs.MultiXactCutoff;
++
++ vistest = GlobalVisTestFor(relation);
++ heap_page_prune_and_freeze(relation, buffer, vistest, HEAP_PAGE_PRUNE_FREEZE,
++ NULL, &presult, PRUNE_ON_ACCESS, &offnum, &new_relfrozen_xid, &new_relmin_mxid, false);
++
++ if (presult.ndeleted > presult.nnewlpdead)
++ pgstat_update_heap_dead_tuples(relation,
++ presult.ndeleted - presult.nnewlpdead);
++}
++
++/*
++ * Check if xid still fits on a page with given base and delta.
++ */
++static inline bool
++is_delta_fits_heap_page(TransactionId xid, TransactionId base, int64 delta)
++{
++ return xid >= base + delta + FirstNormalTransactionId &&
++ xid <= base + delta + MaxShortTransactionId;
++}
++
++/*
++ * Check if xid fits on a page with given base.
++ */
++static inline bool
++is_xid_fits_heap_page(TransactionId xid, TransactionId base)
++{
++ return xid >= base + FirstNormalTransactionId &&
++ xid <= base + MaxShortTransactionId;
++}
++
++/*
++ * Check if delta fits on a page.
++ *
++ * If delta does not fits, never return.
++ */
++static void
++heap_page_check_delta(Buffer buffer,
++ TransactionId xid, TransactionId base,
++ ShortTransactionId min, ShortTransactionId max,
++ int64 delta, int64 *freeDelta, int64 *requiredDelta)
++{
++ BufferDesc *buf;
++ char *path;
++ ProcNumber backend;
++
++ Assert((freeDelta == NULL) == (requiredDelta == NULL));
++
++ /*
++ * If delta fits the page, we good to go ...
++ */
++ if (is_delta_fits_heap_page(xid, base, delta))
++ return;
++
++ /*
++ * ... otherwise handle the error.
++ */
++ if (buffer == InvalidBuffer)
++ return;
++
++ if (BufferIsLocal(buffer))
++ {
++ buf = GetLocalBufferDescriptor(-buffer - 1);
++ backend = MyProcNumber;
++ }
++ else
++ {
++ buf = GetBufferDescriptor(buffer - 1);
++ backend = INVALID_PROC_NUMBER;
++ }
++
++ path = relpathbackend(BufTagGetRelFileLocator(&buf->tag), backend,
++ buf->tag.forkNum);
++
++ if (freeDelta == NULL)
++ elog(FATAL, "Fatal xid base calculation error: xid = %llu, base = %llu, min = %u, max = %u, delta = %lld (rel=%s, blockNum=%u)",
++ (unsigned long long) xid, (unsigned long long) base,
++ min, max,
++ (long long) delta,
++ path, buf->tag.blockNum);
++
++ elog(FATAL, "Fatal xid base calculation error: xid = %llu, base = %llu, min = %u, max = %u, freeDelta = %lld, requiredDelta = %lld, delta = %lld (rel=%s, blockNum=%u)",
++ (unsigned long long) xid, (unsigned long long) base,
++ min, max,
++ (long long) *freeDelta, (long long) *requiredDelta,
++ (long long) delta,
++ path, buf->tag.blockNum);
++}
++
++/*
++ * Shift page base.
++ */
++static void
++heap_page_apply_delta(Relation relation, Buffer buffer, Page page,
++ TransactionId xid, bool multi,
++ TransactionId base, int64 delta, bool is_toast)
++{
++ Assert(is_delta_fits_heap_page(xid, base, delta));
++
++ heap_page_shift_base(relation, buffer, page, multi, delta, is_toast);
++
++#ifdef USE_ASSERT_CHECKING
++ if (is_toast)
++ {
++ Assert(!multi);
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ }
++ else
++ base = multi ? HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ Assert(is_xid_fits_heap_page(xid, base));
++#endif /* USE_ASSERT_CHECKING */
++}
++
++/*
++ * Try to fit xid on a page.
++ */
++static int
++heap_page_try_prepare_for_xid(Relation relation, Buffer buffer, Page page,
++ TransactionId xid, bool multi, bool is_toast)
++{
++ TransactionId base;
++ ShortTransactionId min = InvalidTransactionId,
++ max = InvalidTransactionId;
++ int64 delta,
++ freeDelta,
++ requiredDelta;
++
++ if (is_toast)
++ {
++ Assert(!multi);
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ }
++ else
++ base = multi ? HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ /* If xid fits the page no action needed. */
++ if (is_xid_fits_heap_page(xid, base))
++ return 0;
++
++ /* No items on the page? */
++ if (!heap_page_xid_min_max(page, multi, &min, &max, is_toast))
++ {
++ delta = (int64) (xid - FirstNormalTransactionId) - (int64) base;
++ heap_page_check_delta(buffer, xid, base, min, max, delta, NULL, NULL);
++ heap_page_apply_delta(relation, buffer, page, xid, multi, base, delta,
++ is_toast);
++ return 0;
++ }
++
++ /* Can we just shift base on the page? */
++ if (xid < base + FirstNormalTransactionId)
++ {
++ freeDelta = MaxShortTransactionId - max;
++ requiredDelta = (base + FirstNormalTransactionId) - xid;
++ /* Shouldn't consider setting base less than 0 */
++ freeDelta = Min(freeDelta, base);
++
++ if (requiredDelta > freeDelta)
++ return -1;
++
++ delta = -(freeDelta + requiredDelta) / 2;
++ }
++ else
++ {
++ freeDelta = min - FirstNormalTransactionId;
++ requiredDelta = xid - (base + MaxShortTransactionId);
++
++ if (requiredDelta > freeDelta)
++ return -1;
++
++ delta = (freeDelta + requiredDelta) / 2;
++ }
++
++ heap_page_check_delta(buffer, xid, base, min, max,
++ delta, &freeDelta, &requiredDelta);
++ heap_page_apply_delta(relation, buffer, page, xid, multi, base,
++ delta, is_toast);
++
++ return 0;
++}
++
++static void
++heap_xlog_base_shift(XLogReaderState *record)
++{
++ XLogRecPtr lsn = record->EndRecPtr;
++ xl_heap_base_shift *xlrec = (xl_heap_base_shift *) XLogRecGetData(record);
++ Buffer buffer;
++ Page page;
++ BlockNumber blkno;
++ RelFileLocator target_node;
++
++ XLogRecGetBlockTag(record, 0, &target_node, NULL, &blkno);
++
++ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
++ {
++ page = BufferGetPage(buffer);
++ heap_page_shift_base(NULL, InvalidBuffer, page, xlrec->multi,
++ xlrec->delta,
++ xlrec->flags & XLH_BASE_SHIFT_ON_TOAST_RELATION);
++ PageSetLSN(page, lsn);
++ MarkBufferDirty(buffer);
++ }
++
++ if (BufferIsValid(buffer))
++ UnlockReleaseBuffer(buffer);
++}
++
++/*
++ * Ensure that given xid fits base of given page.
++ */
++static bool
++heap_page_prepare_for_xid(Relation relation, Buffer buffer,
++ TransactionId xid, bool multi)
++{
++ Page page = BufferGetPage(buffer);
++ int res;
++
++ /* "Double xmax" page format doesn't require any preparation */
++ if (HeapPageIsDoubleXmax(page))
++ return false;
++
++ if (!TransactionIdIsNormal(xid))
++ return false;
++
++ res = heap_page_try_prepare_for_xid(relation, buffer, page, xid, multi,
++ IsToastRelation(relation));
++ if (res != -1)
++ return res == 1;
++
++ /* Have to try freeing the page... */
++ freeze_single_heap_page(relation, buffer);
++
++ res = heap_page_try_prepare_for_xid(relation, buffer, page, xid, multi,
++ IsToastRelation(relation));
++ if (res != -1)
++ return res == 1;
++
++ elog(ERROR, "could not fit xid into page");
++
++ return false;
++}
++
++/*
++ * Ensure that given xid fits base of given page.
++ */
++void
++rewrite_page_prepare_for_xid(Page page, HeapTuple tup, bool is_toast)
++{
++ TransactionId xid;
++ int res;
++
++ /* xmin */
++ xid = HeapTupleGetXmin(tup);
++ if (TransactionIdIsNormal(xid))
++ {
++ res = heap_page_try_prepare_for_xid(NULL, InvalidBuffer, page, xid,
++ false, is_toast);
++ if (res == -1)
++ elog(ERROR, "could not fit xid into page");
++ }
++
++ /* xmax */
++ xid = HeapTupleGetRawXmax(tup);
++ if (TransactionIdIsNormal(xid))
++ {
++ res = heap_page_try_prepare_for_xid(NULL, InvalidBuffer, page, xid,
++ tup->t_data->t_infomask & HEAP_XMAX_IS_MULTI,
++ is_toast);
++ if (res == -1)
++ elog(ERROR, "could not fit xid into page");
++ }
++}
++
++void
++heap3_redo(XLogReaderState *record)
++{
++ uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
++
++ switch (info & XLOG_HEAP_OPMASK)
++ {
++ case XLOG_HEAP3_BASE_SHIFT:
++ heap_xlog_base_shift(record);
++ break;
++ default:
++ elog(PANIC, "heap3_redo: unknown op code %u", info);
++ }
++}
+diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
+index 765e0d48c42..8de5dfa4fc6 100644
+--- a/src/backend/access/heap/heapam_handler.c
++++ b/src/backend/access/heap/heapam_handler.c
+@@ -423,7 +423,7 @@ tuple_lock_retry:
+ * changes in an existing tuple, except to invalid or
+ * frozen, and neither of those can match priorXmax.)
+ */
+- if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
++ if (!TransactionIdEquals(HeapTupleGetXmin(tuple),
+ priorXmax))
+ {
+ ReleaseBuffer(buffer);
+@@ -483,7 +483,7 @@ tuple_lock_retry:
+ * variable instead of doing HeapTupleHeaderGetXmin again.
+ */
+ if (TransactionIdIsCurrentTransactionId(priorXmax) &&
+- HeapTupleHeaderGetCmin(tuple->t_data) >= cid)
++ HeapTupleGetCmin(tuple) >= cid)
+ {
+ tmfd->xmax = priorXmax;
+
+@@ -491,7 +491,7 @@ tuple_lock_retry:
+ * Cmin is the problematic value, so store that. See
+ * above.
+ */
+- tmfd->cmax = HeapTupleHeaderGetCmin(tuple->t_data);
++ tmfd->cmax = HeapTupleGetCmin(tuple);
+ ReleaseBuffer(buffer);
+ return TM_SelfModified;
+ }
+@@ -517,7 +517,7 @@ tuple_lock_retry:
+ /*
+ * As above, if xmin isn't what we're expecting, do nothing.
+ */
+- if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
++ if (!TransactionIdEquals(HeapTupleGetXmin(tuple),
+ priorXmax))
+ {
+ ReleaseBuffer(buffer);
+@@ -548,7 +548,7 @@ tuple_lock_retry:
+ /* updated, so look at the updated row */
+ *tid = tuple->t_data->t_ctid;
+ /* updated row should have xmin matching this xmax */
+- priorXmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
++ priorXmax = HeapTupleGetUpdateXidAny(tuple);
+ ReleaseBuffer(buffer);
+ /* loop back to fetch next in chain */
+ }
+@@ -859,7 +859,7 @@ heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap,
+ * case we had better copy it.
+ */
+ if (!is_system_catalog &&
+- !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tuple->t_data)))
++ !TransactionIdIsCurrentTransactionId(HeapTupleGetXmin(tuple)))
+ elog(WARNING, "concurrent insert in progress within table \"%s\"",
+ RelationGetRelationName(OldHeap));
+ /* treat as live */
+@@ -871,7 +871,7 @@ heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap,
+ * Similar situation to INSERT_IN_PROGRESS case.
+ */
+ if (!is_system_catalog &&
+- !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple->t_data)))
++ !TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(tuple)))
+ elog(WARNING, "concurrent delete in progress within table \"%s\"",
+ RelationGetRelationName(OldHeap));
+ /* treat as recently dead */
+@@ -1064,6 +1064,8 @@ heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin,
+ targtuple->t_tableOid = RelationGetRelid(scan->rs_rd);
+ targtuple->t_data = (HeapTupleHeader) PageGetItem(targpage, itemid);
+ targtuple->t_len = ItemIdGetLength(itemid);
++ HeapTupleCopyXidsFromPage(hscan->rs_cbuf, targtuple, targpage,
++ IsToastRelation(scan->rs_rd));
+
+ switch (HeapTupleSatisfiesVacuum(targtuple, OldestXmin,
+ hscan->rs_cbuf))
+@@ -1099,7 +1101,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin,
+ * numbers we report to the cumulative stats system to make
+ * this come out right.)
+ */
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(targtuple->t_data)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetXmin(targtuple)))
+ {
+ sample_it = true;
+ *liverows += 1;
+@@ -1130,7 +1132,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin,
+ * but not the post-image. We also get sane results if the
+ * concurrent transaction never commits.
+ */
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(targtuple->t_data)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(targtuple)))
+ *deadrows += 1;
+ else
+ {
+@@ -1379,7 +1381,8 @@ heapam_index_build_range_scan(Relation heapRelation,
+ Page page = BufferGetPage(hscan->rs_cbuf);
+
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
+- heap_get_root_tuples(page, root_offsets);
++ heap_get_root_tuples(heapRelation, hscan->rs_cbuf, page,
++ root_offsets);
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+
+ root_blkno = hscan->rs_cblock;
+@@ -1472,7 +1475,7 @@ heapam_index_build_range_scan(Relation heapRelation,
+ * before commit there. Give a warning if neither case
+ * applies.
+ */
+- xwait = HeapTupleHeaderGetXmin(heapTuple->t_data);
++ xwait = HeapTupleGetXmin(heapTuple);
+ if (!TransactionIdIsCurrentTransactionId(xwait))
+ {
+ if (!is_system_catalog)
+@@ -1531,7 +1534,7 @@ heapam_index_build_range_scan(Relation heapRelation,
+ break;
+ }
+
+- xwait = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
++ xwait = HeapTupleGetUpdateXidAny(heapTuple);
+ if (!TransactionIdIsCurrentTransactionId(xwait))
+ {
+ if (!is_system_catalog)
+@@ -1676,7 +1679,8 @@ heapam_index_build_range_scan(Relation heapRelation,
+ Page page = BufferGetPage(hscan->rs_cbuf);
+
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
+- heap_get_root_tuples(page, root_offsets);
++ heap_get_root_tuples(heapRelation, hscan->rs_cbuf, page,
++ root_offsets);
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+ }
+
+@@ -1842,7 +1846,8 @@ heapam_index_validate_scan(Relation heapRelation,
+ Page page = BufferGetPage(hscan->rs_cbuf);
+
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
+- heap_get_root_tuples(page, root_offsets);
++ heap_get_root_tuples(heapRelation, hscan->rs_cbuf, page,
++ root_offsets);
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+
+ memset(in_index, 0, sizeof(in_index));
+@@ -2223,7 +2228,12 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
+ ItemPointerSet(&tid, block, offnum);
+ if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot,
+ &heapTuple, NULL, true))
+- hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
++ {
++ hscan->rs_vistuples[ntup] = ItemPointerGetOffsetNumber(&tid);
++ hscan->rs_xmin[ntup] = heapTuple.t_xmin;
++ hscan->rs_xmax[ntup] = heapTuple.t_xmax;
++ ++ntup;
++ }
+ }
+ }
+ else
+@@ -2248,13 +2258,18 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
+ loctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ loctup.t_len = ItemIdGetLength(lp);
+ loctup.t_tableOid = scan->rs_rd->rd_id;
++ HeapTupleCopyXidsFromPage(hscan->rs_cbuf, &loctup, page,
++ IsToastRelation(scan->rs_rd));
+ ItemPointerSet(&loctup.t_self, block, offnum);
+ valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
+ if (valid)
+ {
+- hscan->rs_vistuples[ntup++] = offnum;
++ hscan->rs_vistuples[ntup] = offnum;
++ hscan->rs_xmin[ntup] = loctup.t_xmin;
++ hscan->rs_xmax[ntup] = loctup.t_xmax;
++ ++ntup;
+ PredicateLockTID(scan->rs_rd, &loctup.t_self, snapshot,
+- HeapTupleHeaderGetXmin(loctup.t_data));
++ HeapTupleGetXmin(&loctup));
+ }
+ HeapCheckForSerializableConflictOut(valid, scan->rs_rd, &loctup,
+ buffer, snapshot);
+@@ -2314,6 +2329,8 @@ heapam_scan_bitmap_next_tuple(TableScanDesc scan,
+ hscan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ hscan->rs_ctup.t_len = ItemIdGetLength(lp);
+ hscan->rs_ctup.t_tableOid = scan->rs_rd->rd_id;
++ hscan->rs_ctup.t_xmin = hscan->rs_xmin[hscan->rs_cindex];
++ hscan->rs_ctup.t_xmax = hscan->rs_xmax[hscan->rs_cindex];
+ ItemPointerSet(&hscan->rs_ctup.t_self, hscan->rs_cblock, targoffset);
+
+ pgstat_count_heap_fetch(scan->rs_rd);
+@@ -2470,8 +2487,17 @@ heapam_scan_sample_next_tuple(TableScanDesc scan, SampleScanState *scanstate,
+
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple->t_len = ItemIdGetLength(itemid);
+- ItemPointerSet(&(tuple->t_self), blockno, tupoffset);
+
++ if (pagemode)
++ {
++ tuple->t_xmin = InvalidTransactionId;
++ tuple->t_xmax = InvalidTransactionId;
++ }
++ else
++ HeapTupleCopyXidsFromPage(hscan->rs_cbuf, tuple, page,
++ IsToastRelation(scan->rs_rd));
++
++ ItemPointerSet(&(tuple->t_self), blockno, tupoffset);
+
+ if (all_visible)
+ visible = true;
+diff --git a/src/backend/access/heap/heapam_visibility.c b/src/backend/access/heap/heapam_visibility.c
+index 9243feed01f..23ad2665fe5 100644
+--- a/src/backend/access/heap/heapam_visibility.c
++++ b/src/backend/access/heap/heapam_visibility.c
+@@ -218,7 +218,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return true;
+@@ -230,7 +230,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -242,7 +242,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ return false;
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -252,11 +252,11 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+
+ return false;
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ return false;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -285,7 +285,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -300,17 +300,17 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ return true;
+ }
+
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+ return false;
+ }
+
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return true;
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -328,7 +328,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ }
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ return false;
+ }
+
+@@ -417,7 +417,7 @@ HeapTupleSatisfiesToast(HeapTuple htup, Snapshot snapshot,
+ * is canceled by super-deleting the tuple. This also applies to
+ * TOAST tuples created during speculative insertion.
+ */
+- else if (!TransactionIdIsValid(HeapTupleHeaderGetXmin(tuple)))
++ else if (!TransactionIdIsValid(HeapTupleGetXmin(htup)))
+ return false;
+ }
+
+@@ -507,9 +507,9 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+- if (HeapTupleHeaderGetCmin(tuple) >= curcid)
++ if (HeapTupleGetCmin(htup) >= curcid)
+ return TM_Invisible; /* inserted after scan started */
+
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+@@ -519,7 +519,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleHeaderGetRawXmax(tuple);
++ xmax = HeapTupleGetRawXmax(htup);
+
+ /*
+ * Careful here: even though this tuple was created by our own
+@@ -550,7 +550,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -558,21 +558,21 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ /* deleting subtransaction must have aborted */
+ if (!TransactionIdIsCurrentTransactionId(xmax))
+ {
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple),
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup),
+ false))
+ return TM_BeingModified;
+ return TM_Ok;
+ }
+ else
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -580,16 +580,16 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ return TM_Ok;
+ }
+
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ return TM_Invisible;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -623,17 +623,17 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ {
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), true))
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), true))
+ return TM_BeingModified;
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
+ return TM_Ok;
+ }
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+ if (!TransactionIdIsValid(xmax))
+ {
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ return TM_BeingModified;
+ }
+
+@@ -642,13 +642,13 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+
+ if (TransactionIdIsCurrentTransactionId(xmax))
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ return TM_BeingModified;
+
+ if (TransactionIdDidCommit(xmax))
+@@ -664,7 +664,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ * what about the other members?
+ */
+
+- if (!MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ if (!MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ {
+ /*
+ * There's no member, even just a locker, alive anymore, so we can
+@@ -681,20 +681,20 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ }
+ }
+
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return TM_BeingModified;
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return TM_BeingModified;
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -712,7 +712,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ }
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ if (!ItemPointerEquals(&htup->t_self, &tuple->t_ctid))
+ return TM_Updated; /* updated by other */
+ else
+@@ -795,7 +795,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return true;
+@@ -807,7 +807,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -819,7 +819,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ return false;
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -829,7 +829,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+
+ return false;
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ {
+ /*
+ * Return the speculative token to caller. Caller can worry about
+@@ -845,13 +845,13 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ Assert(snapshot->speculativeToken != 0);
+ }
+
+- snapshot->xmin = HeapTupleHeaderGetRawXmin(tuple);
++ snapshot->xmin = HeapTupleGetRawXmin(htup);
+ /* XXX shouldn't we fall through to look at xmax? */
+ return true; /* in insertion by other */
+ }
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -880,7 +880,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -898,21 +898,21 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ return true;
+ }
+
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+ return false;
+ }
+
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ {
+ if (!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+- snapshot->xmax = HeapTupleHeaderGetRawXmax(tuple);
++ snapshot->xmax = HeapTupleGetRawXmax(htup);
+ return true;
+ }
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -930,7 +930,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ }
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ return false; /* updated by other */
+ }
+
+@@ -1009,9 +1009,9 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+- if (HeapTupleHeaderGetCmin(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmin(htup) >= snapshot->curcid)
+ return false; /* inserted after scan started */
+
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+@@ -1024,7 +1024,7 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -1032,13 +1032,13 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ /* updating subtransaction must have aborted */
+ if (!TransactionIdIsCurrentTransactionId(xmax))
+ return true;
+- else if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ else if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* updated after scan started */
+ else
+ return false; /* updated before scan started */
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -1046,16 +1046,16 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ return true;
+ }
+
+- if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* deleted after scan started */
+ else
+ return false; /* deleted before scan started */
+ }
+- else if (XidInMVCCSnapshot(HeapTupleHeaderGetRawXmin(tuple), snapshot))
++ else if (XidInMVCCSnapshot(HeapTupleGetRawXmin(htup), snapshot))
+ return false;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -1068,7 +1068,7 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ {
+ /* xmin is committed, but maybe not according to our snapshot */
+ if (!HeapTupleHeaderXminFrozen(tuple) &&
+- XidInMVCCSnapshot(HeapTupleHeaderGetRawXmin(tuple), snapshot))
++ XidInMVCCSnapshot(HeapTupleGetRawXmin(htup), snapshot))
+ return false; /* treat as still in progress */
+ }
+
+@@ -1087,14 +1087,14 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ /* already checked above */
+ Assert(!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask));
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+
+ if (TransactionIdIsCurrentTransactionId(xmax))
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* deleted after scan started */
+ else
+ return false; /* deleted before scan started */
+@@ -1109,18 +1109,18 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+
+ if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
+ {
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* deleted after scan started */
+ else
+ return false; /* deleted before scan started */
+ }
+
+- if (XidInMVCCSnapshot(HeapTupleHeaderGetRawXmax(tuple), snapshot))
++ if (XidInMVCCSnapshot(HeapTupleGetRawXmax(htup), snapshot))
+ return true;
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -1130,12 +1130,12 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+
+ /* xmax transaction committed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ }
+ else
+ {
+ /* xmax is committed, but maybe not according to our snapshot */
+- if (XidInMVCCSnapshot(HeapTupleHeaderGetRawXmax(tuple), snapshot))
++ if (XidInMVCCSnapshot(HeapTupleGetRawXmax(htup), snapshot))
+ return true; /* treat as still in progress */
+ }
+
+@@ -1250,21 +1250,21 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ return HEAPTUPLE_DEAD;
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ /* only locked? run infomask-only check first, for performance */
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask) ||
+- HeapTupleHeaderIsOnlyLocked(tuple))
++ HeapTupleIsOnlyLocked(htup))
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ /* inserted and then deleted by same xact */
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(htup)))
+ return HEAPTUPLE_DELETE_IN_PROGRESS;
+ /* deleting subtransaction must have aborted */
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ {
+ /*
+ * It'd be possible to discern between INSERT/DELETE in progress
+@@ -1276,9 +1276,9 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ */
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ }
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /*
+@@ -1320,14 +1320,14 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ * possibly be running; otherwise have to check.
+ */
+ if (!HEAP_LOCKED_UPGRADED(tuple->t_infomask) &&
+- MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple),
++ MultiXactIdIsRunning(HeapTupleGetRawXmax(htup),
+ true))
+ return HEAPTUPLE_LIVE;
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
+ }
+ else
+ {
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return HEAPTUPLE_LIVE;
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+ InvalidTransactionId);
+@@ -1345,7 +1345,7 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+
+ if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
+ {
+- TransactionId xmax = HeapTupleGetUpdateXid(tuple);
++ TransactionId xmax = HeapTupleGetUpdateXid(htup);
+
+ /* already checked above */
+ Assert(!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask));
+@@ -1368,7 +1368,7 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ *dead_after = xmax;
+ return HEAPTUPLE_RECENTLY_DEAD;
+ }
+- else if (!MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ else if (!MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ {
+ /*
+ * Not in Progress, Not Committed, so either Aborted or crashed.
+@@ -1382,11 +1382,11 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+
+ if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
+ {
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return HEAPTUPLE_DELETE_IN_PROGRESS;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ else
+ {
+ /*
+@@ -1408,7 +1408,7 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ * Deleter committed, allow caller to check if it was recent enough that
+ * some open transactions could still see the tuple.
+ */
+- *dead_after = HeapTupleHeaderGetRawXmax(tuple);
++ *dead_after = HeapTupleGetRawXmax(htup);
+ return HEAPTUPLE_RECENTLY_DEAD;
+ }
+
+@@ -1504,7 +1504,7 @@ HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
+
+ /* Deleter committed, so tuple is dead if the XID is old enough. */
+ return GlobalVisTestIsRemovableXid(vistest,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ }
+
+ /*
+@@ -1517,8 +1517,9 @@ HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
+ * at the top of this file.
+ */
+ bool
+-HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
++HeapTupleIsOnlyLocked(HeapTuple htup)
+ {
++ HeapTupleHeader tuple = htup->t_data;
+ TransactionId xmax;
+
+ /* if there's no valid Xmax, then there's obviously no update either */
+@@ -1529,7 +1530,7 @@ HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
+ return true;
+
+ /* invalid xmax means no update */
+- if (!TransactionIdIsValid(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsValid(HeapTupleGetRawXmax(htup)))
+ return true;
+
+ /*
+@@ -1540,7 +1541,7 @@ HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
+ return false;
+
+ /* ... but if it's a multi, then perhaps the updating Xid aborted. */
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -1588,8 +1589,8 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
+ Buffer buffer)
+ {
+ HeapTupleHeader tuple = htup->t_data;
+- TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
+- TransactionId xmax = HeapTupleHeaderGetRawXmax(tuple);
++ TransactionId xmin = HeapTupleGetXmin(htup);
++ TransactionId xmax = HeapTupleGetRawXmax(htup);
+
+ Assert(ItemPointerIsValid(&htup->t_self));
+ Assert(htup->t_tableOid != InvalidOid);
+@@ -1689,7 +1690,7 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
+ */
+ else if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
+ {
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+ }
+
+ /* check if it's one of our txids, toplevel is also in there */
+diff --git a/src/backend/access/heap/heapam_xlog.c b/src/backend/access/heap/heapam_xlog.c
+index c5208f3df61..b1ace89bfc6 100644
+--- a/src/backend/access/heap/heapam_xlog.c
++++ b/src/backend/access/heap/heapam_xlog.c
+@@ -106,7 +106,10 @@ heap_xlog_prune_freeze(XLogReaderState *record)
+ (xlrec.flags & XLHP_CLEANUP_LOCK) == 0,
+ redirected, nredirected,
+ nowdead, ndead,
+- nowunused, nunused);
++ nowunused, nunused,
++ (xlrec.flags & XLHP_REPAIR_FRAGMENTATION) != 0,
++ (xlrec.flags & XLHP_ON_TOAST_RELATION) != 0);
++
+
+ /* Freeze tuples */
+ for (int p = 0; p < nplans; p++)
+@@ -127,11 +130,14 @@ heap_xlog_prune_freeze(XLogReaderState *record)
+ {
+ OffsetNumber offset = *(frz_offsets++);
+ ItemId lp;
+- HeapTupleHeader tuple;
++ HeapTupleData tp;
+
+ lp = PageGetItemId(page, offset);
+- tuple = (HeapTupleHeader) PageGetItem(page, lp);
+- heap_execute_freeze_tuple(tuple, &frz);
++ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
++ tp.t_len = ItemIdGetLength(lp);
++ HeapTupleCopyXidsFromPage(buffer, &tp, page,
++ (xlrec.flags & XLHP_ON_TOAST_RELATION) != 0);
++ heap_execute_freeze_tuple(&tp, &frz);
+ }
+ }
+
+@@ -371,6 +377,8 @@ heap_xlog_delete(XLogReaderState *record)
+
+ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = BufferGetPage(buffer);
+
+ if (PageGetMaxOffsetNumber(page) >= xlrec->offnum)
+@@ -386,14 +394,19 @@ heap_xlog_delete(XLogReaderState *record)
+ HeapTupleHeaderClearHotUpdated(htup);
+ fix_infomask_from_infobits(xlrec->infobits_set,
+ &htup->t_infomask, &htup->t_infomask2);
++ tuple.t_data = htup;
+ if (!(xlrec->flags & XLH_DELETE_IS_SUPER))
+- HeapTupleHeaderSetXmax(htup, xlrec->xmax);
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->xmax,
++ (xlrec->flags & XLH_DELETE_PAGE_ON_TOAST_RELATION) != 0);
+ else
+- HeapTupleHeaderSetXmin(htup, InvalidTransactionId);
++ HeapTupleAndHeaderSetXmin(page, &tuple, InvalidTransactionId,
++ (xlrec->flags & XLH_DELETE_PAGE_ON_TOAST_RELATION) != 0);
++
+ HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
+
+ /* Mark the page as a candidate for pruning */
+- PageSetPrunable(page, XLogRecGetXid(record));
++ PageSetPrunable(page, XLogRecGetXid(record),
++ (xlrec->flags & XLH_DELETE_PAGE_ON_TOAST_RELATION) != 0);
+
+ if (xlrec->flags & XLH_DELETE_ALL_VISIBLE_CLEARED)
+ PageClearAllVisible(page);
+@@ -417,7 +430,7 @@ static void
+ heap_xlog_insert(XLogReaderState *record)
+ {
+ XLogRecPtr lsn = record->EndRecPtr;
+- xl_heap_insert *xlrec = (xl_heap_insert *) XLogRecGetData(record);
++ xl_heap_insert *xlrec;
+ Buffer buffer;
+ Page page;
+ union
+@@ -433,6 +446,20 @@ heap_xlog_insert(XLogReaderState *record)
+ BlockNumber blkno;
+ ItemPointerData target_tid;
+ XLogRedoAction action;
++ bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(record);
++ TransactionId xid_base = InvalidTransactionId;
++ TransactionId multi_base = InvalidTransactionId;
++
++ if (isinit)
++ {
++ xid_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ multi_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ }
++
++ xlrec = (xl_heap_insert *) rec_data;
+
+ XLogRecGetBlockTag(record, 0, &target_locator, NULL, &blkno);
+ ItemPointerSetBlockNumber(&target_tid, blkno);
+@@ -457,11 +484,28 @@ heap_xlog_insert(XLogReaderState *record)
+ * If we inserted the first and only tuple on the page, re-initialize the
+ * page from scratch.
+ */
+- if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
++ if (isinit)
+ {
+ buffer = XLogInitBufferForRedo(record, 0);
+ page = BufferGetPage(buffer);
+- PageInit(page, BufferGetPageSize(buffer), 0);
++
++ if (xlrec->flags & XLH_INSERT_ON_TOAST_RELATION)
++ {
++ PageInit(page, BufferGetPageSize(buffer),
++ sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ PageInit(page, BufferGetPageSize(buffer),
++ sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
++ }
++
+ action = BLK_NEEDS_REDO;
+ }
+ else
+@@ -470,6 +514,7 @@ heap_xlog_insert(XLogReaderState *record)
+ {
+ Size datalen;
+ char *data;
++ HeapTupleData tuple;
+
+ page = BufferGetPage(buffer);
+
+@@ -493,7 +538,9 @@ heap_xlog_insert(XLogReaderState *record)
+ htup->t_infomask2 = xlhdr.t_infomask2;
+ htup->t_infomask = xlhdr.t_infomask;
+ htup->t_hoff = xlhdr.t_hoff;
+- HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmin(page, &tuple, XLogRecGetXid(record),
++ (xlrec->flags & XLH_INSERT_ON_TOAST_RELATION) != 0);
+ HeapTupleHeaderSetCmin(htup, FirstCommandId);
+ htup->t_ctid = target_tid;
+
+@@ -553,12 +600,22 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ int i;
+ bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
+ XLogRedoAction action;
++ TransactionId xid_base = InvalidTransactionId,
++ multi_base = InvalidTransactionId;
++ Pointer rec_data = (Pointer) XLogRecGetData(record);
+
+ /*
+ * Insertion doesn't overwrite MVCC data, so no conflict processing is
+ * required.
+ */
+- xlrec = (xl_heap_multi_insert *) XLogRecGetData(record);
++ if (isinit)
++ {
++ xid_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ multi_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ }
++ xlrec = (xl_heap_multi_insert *) rec_data;
+
+ XLogRecGetBlockTag(record, 0, &rlocator, NULL, &blkno);
+
+@@ -585,7 +642,22 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ {
+ buffer = XLogInitBufferForRedo(record, 0);
+ page = BufferGetPage(buffer);
+- PageInit(page, BufferGetPageSize(buffer), 0);
++
++ if ((xlrec->flags & XLH_INSERT_ON_TOAST_RELATION) != 0)
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ PageInit(page, BufferGetPageSize(buffer), sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
++ }
++
+ action = BLK_NEEDS_REDO;
+ }
+ else
+@@ -606,6 +678,7 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ {
+ OffsetNumber offnum;
+ xl_multi_insert_tuple *xlhdr;
++ HeapTupleData tuple;
+
+ /*
+ * If we're reinitializing the page, the tuples are stored in
+@@ -636,7 +709,9 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ htup->t_infomask2 = xlhdr->t_infomask2;
+ htup->t_infomask = xlhdr->t_infomask;
+ htup->t_hoff = xlhdr->t_hoff;
+- HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmin(page, &tuple, XLogRecGetXid(record),
++ false);
+ HeapTupleHeaderSetCmin(htup, FirstCommandId);
+ ItemPointerSetBlockNumber(&htup->t_ctid, blkno);
+ ItemPointerSetOffsetNumber(&htup->t_ctid, offnum);
+@@ -684,8 +759,8 @@ static void
+ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ {
+ XLogRecPtr lsn = record->EndRecPtr;
+- xl_heap_update *xlrec = (xl_heap_update *) XLogRecGetData(record);
+ RelFileLocator rlocator;
++ xl_heap_update *xlrec;
+ BlockNumber oldblk;
+ BlockNumber newblk;
+ ItemPointerData newtid;
+@@ -709,6 +784,20 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ Size freespace = 0;
+ XLogRedoAction oldaction;
+ XLogRedoAction newaction;
++ bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(record);
++ TransactionId xid_base = InvalidTransactionId,
++ multi_base = InvalidTransactionId;
++
++ if (isinit)
++ {
++ xid_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ multi_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ }
++
++ xlrec = (xl_heap_update *) rec_data;
+
+ /* initialize to keep the compiler quiet */
+ oldtup.t_data = NULL;
+@@ -755,6 +844,8 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ &obuffer);
+ if (oldaction == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = BufferGetPage(obuffer);
+ offnum = xlrec->old_offnum;
+ if (PageGetMaxOffsetNumber(page) >= offnum)
+@@ -767,6 +858,8 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+
+ oldtup.t_data = htup;
+ oldtup.t_len = ItemIdGetLength(lp);
++ /* Toast tuples are never updated. */
++ HeapTupleCopyXidsFromPage(obuffer, &oldtup, page, false);
+
+ htup->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
+ htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+@@ -776,13 +869,15 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ HeapTupleHeaderClearHotUpdated(htup);
+ fix_infomask_from_infobits(xlrec->old_infobits_set, &htup->t_infomask,
+ &htup->t_infomask2);
+- HeapTupleHeaderSetXmax(htup, xlrec->old_xmax);
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->old_xmax, false);
+ HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
+ /* Set forward chain link in t_ctid */
+ htup->t_ctid = newtid;
+
+ /* Mark the page as a candidate for pruning */
+- PageSetPrunable(page, XLogRecGetXid(record));
++ /* Toast tuples are never updated. */
++ PageSetPrunable(page, XLogRecGetXid(record), false);
+
+ if (xlrec->flags & XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED)
+ PageClearAllVisible(page);
+@@ -799,11 +894,18 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ nbuffer = obuffer;
+ newaction = oldaction;
+ }
+- else if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
++ else if (isinit)
+ {
++ HeapPageSpecial special;
++
+ nbuffer = XLogInitBufferForRedo(record, 0);
+ page = (Page) BufferGetPage(nbuffer);
+- PageInit(page, BufferGetPageSize(nbuffer), 0);
++
++ /* Toast tuples are never updated. */
++ PageInit(page, BufferGetPageSize(nbuffer), sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
+ newaction = BLK_NEEDS_REDO;
+ }
+ else
+@@ -831,6 +933,7 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ char *recdata_end;
+ Size datalen;
+ Size tuplen;
++ HeapTupleData tuple;
+
+ recdata = XLogRecGetBlockData(record, 0, &datalen);
+ recdata_end = recdata + datalen;
+@@ -909,9 +1012,10 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ htup->t_infomask = xlhdr.t_infomask;
+ htup->t_hoff = xlhdr.t_hoff;
+
+- HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmin(page, &tuple, XLogRecGetXid(record), false);
+ HeapTupleHeaderSetCmin(htup, FirstCommandId);
+- HeapTupleHeaderSetXmax(htup, xlrec->new_xmax);
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->new_xmax, false);
+ /* Make sure there is no forward chain link in t_ctid */
+ htup->t_ctid = newtid;
+
+@@ -1028,6 +1132,8 @@ heap_xlog_lock(XLogReaderState *record)
+
+ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = (Page) BufferGetPage(buffer);
+
+ offnum = xlrec->offnum;
+@@ -1056,7 +1162,9 @@ heap_xlog_lock(XLogReaderState *record)
+ BufferGetBlockNumber(buffer),
+ offnum);
+ }
+- HeapTupleHeaderSetXmax(htup, xlrec->xmax);
++
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->xmax, false);
+ HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
+ PageSetLSN(page, lsn);
+ MarkBufferDirty(buffer);
+@@ -1104,6 +1212,8 @@ heap_xlog_lock_updated(XLogReaderState *record)
+
+ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = BufferGetPage(buffer);
+
+ offnum = xlrec->offnum;
+@@ -1119,7 +1229,8 @@ heap_xlog_lock_updated(XLogReaderState *record)
+ htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+ fix_infomask_from_infobits(xlrec->infobits_set, &htup->t_infomask,
+ &htup->t_infomask2);
+- HeapTupleHeaderSetXmax(htup, xlrec->xmax);
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->xmax, false);
+
+ PageSetLSN(page, lsn);
+ MarkBufferDirty(buffer);
+@@ -1272,6 +1383,10 @@ heap_mask(char *pagedata, BlockNumber blkno)
+ mask_page_lsn_and_checksum(page);
+
+ mask_page_hint_bits(page);
++
++ /* Ignore prune_xid (it's like a hint-bit) */
++ HeapPageSetPruneXid(page, InvalidTransactionId, false);
++
+ mask_unused_space(page);
+
+ for (off = 1; off <= PageGetMaxOffsetNumber(page); off++)
+diff --git a/src/backend/access/heap/heaptoast.c b/src/backend/access/heap/heaptoast.c
+index a420e165304..75def55a8f1 100644
+--- a/src/backend/access/heap/heaptoast.c
++++ b/src/backend/access/heap/heaptoast.c
+@@ -307,6 +307,7 @@ heap_toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup,
+ result_tuple->t_len = new_tuple_len;
+ result_tuple->t_self = newtup->t_self;
+ result_tuple->t_tableOid = newtup->t_tableOid;
++ HeapTupleCopyXids(result_tuple, newtup);
+ new_data = (HeapTupleHeader) ((char *) result_tuple + HEAPTUPLESIZE);
+ result_tuple->t_data = new_data;
+
+@@ -395,6 +396,7 @@ toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)
+ */
+ new_tuple->t_self = tup->t_self;
+ new_tuple->t_tableOid = tup->t_tableOid;
++ HeapTupleCopyXids(new_tuple, tup);
+
+ new_tuple->t_data->t_choice = tup->t_data->t_choice;
+ new_tuple->t_data->t_ctid = tup->t_data->t_ctid;
+@@ -467,6 +469,7 @@ toast_flatten_tuple_to_datum(HeapTupleHeader tup,
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
+ tmptup.t_data = tup;
++ HeapTupleSetZeroXids(&tmptup);
+
+ /*
+ * Break down the tuple into fields.
+diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c
+index 7c662cdf46e..e0a248b6c27 100644
+--- a/src/backend/access/heap/hio.c
++++ b/src/backend/access/heap/hio.c
+@@ -19,6 +19,7 @@
+ #include "access/hio.h"
+ #include "access/htup_details.h"
+ #include "access/visibilitymap.h"
++#include "catalog/catalog.h"
+ #include "storage/bufmgr.h"
+ #include "storage/freespace.h"
+ #include "storage/lmgr.h"
+@@ -58,6 +59,9 @@ RelationPutHeapTuple(Relation relation,
+ /* Add the tuple to the page */
+ pageHeader = BufferGetPage(buffer);
+
++ HeapTupleHeaderStoreXmin(pageHeader, tuple, IsToastRelation(relation));
++ HeapTupleHeaderStoreXmax(pageHeader, tuple, IsToastRelation(relation));
++
+ offnum = PageAddItem(pageHeader, (Item) tuple->t_data,
+ tuple->t_len, InvalidOffsetNumber, false, true);
+
+@@ -360,7 +364,17 @@ RelationAddBlocks(Relation relation, BulkInsertState bistate,
+ first_block,
+ RelationGetRelationName(relation));
+
+- PageInit(page, BufferGetPageSize(buffer), 0);
++ if (IsToastRelation(relation))
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++ else
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(HeapPageSpecialData));
++ HeapPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++
+ MarkBufferDirty(buffer);
+
+ /*
+@@ -393,7 +407,7 @@ RelationAddBlocks(Relation relation, BulkInsertState bistate,
+ if (use_fsm && i >= not_in_fsm_pages)
+ {
+ Size freespace = BufferGetPageSize(victim_buffers[i]) -
+- SizeOfPageHeaderData;
++ SizeOfPageHeaderData - MAXALIGN(sizeof(HeapPageSpecialData));
+
+ RecordPageWithFreeSpace(relation, curBlock, freespace);
+ }
+@@ -684,6 +698,9 @@ loop:
+ /*
+ * Now we can check to see if there's enough free space here. If so,
+ * we're done.
++ *
++ * "Double xmax" page is not suitable for any new tuple, since xmin
++ * can't be set there.
+ */
+ page = BufferGetPage(buffer);
+
+@@ -695,12 +712,23 @@ loop:
+ */
+ if (PageIsNew(page))
+ {
+- PageInit(page, BufferGetPageSize(buffer), 0);
++ if (IsToastRelation(relation))
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++ else
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(HeapPageSpecialData));
++ HeapPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++
+ MarkBufferDirty(buffer);
+ }
+
+ pageFreeSpace = PageGetHeapFreeSpace(page);
+- if (targetFreeSpace <= pageFreeSpace)
++ if (targetFreeSpace <= pageFreeSpace &&
++ !HeapPageIsDoubleXmax(page))
+ {
+ /* use this page as future insert target, too */
+ RelationSetTargetBlock(relation, targetBlock);
+diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c
+index 869d82ad667..4683d0a9ce2 100644
+--- a/src/backend/access/heap/pruneheap.c
++++ b/src/backend/access/heap/pruneheap.c
+@@ -157,7 +157,7 @@ static HTSV_Result heap_prune_satisfies_vacuum(PruneState *prstate,
+ HeapTuple tup,
+ Buffer buffer);
+ static inline HTSV_Result htsv_get_valid_status(int status);
+-static void heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
++static void heap_prune_chain(Relation relation, Buffer buffer, Page page, BlockNumber blockno, OffsetNumber maxoff,
+ OffsetNumber rootoffnum, PruneState *prstate);
+ static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid);
+ static void heap_prune_record_redirect(PruneState *prstate,
+@@ -170,12 +170,23 @@ static void heap_prune_record_dead_or_unused(PruneState *prstate, OffsetNumber o
+ static void heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal);
+
+ static void heap_prune_record_unchanged_lp_unused(Page page, PruneState *prstate, OffsetNumber offnum);
+-static void heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumber offnum);
++static void heap_prune_record_unchanged_lp_normal(Relation relation, Buffer buffer, Page page, PruneState *prstate, OffsetNumber offnum);
+ static void heap_prune_record_unchanged_lp_dead(Page page, PruneState *prstate, OffsetNumber offnum);
+ static void heap_prune_record_unchanged_lp_redirect(PruneState *prstate, OffsetNumber offnum);
+
+ static void page_verify_redirects(Page page);
+
++static inline bool
++XidFitsPage(Page page, TransactionId xid, bool is_toast)
++{
++ TransactionId base;
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ return xid >= base + FirstNormalTransactionId &&
++ xid <= base + MaxShortTransactionId;
++}
+
+ /*
+ * Optionally prune and repair fragmentation in the specified page.
+@@ -210,7 +221,8 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
+ * determining the appropriate horizon is a waste if there's no prune_xid
+ * (i.e. no updates/deletes left potentially dead tuples around).
+ */
+- prune_xid = ((PageHeader) page)->pd_prune_xid;
++ prune_xid = HeapPageGetPruneXidNoAssert(page, IsToastRelation(relation));
++
+ if (!TransactionIdIsValid(prune_xid))
+ return;
+
+@@ -261,7 +273,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
+ * that during on-access pruning with the current implementation.
+ */
+ heap_page_prune_and_freeze(relation, buffer, vistest, 0,
+- NULL, &presult, PRUNE_ON_ACCESS, &dummy_off_loc, NULL, NULL);
++ NULL, &presult, PRUNE_ON_ACCESS, &dummy_off_loc, NULL, NULL, false);
+
+ /*
+ * Report the number of tuples reclaimed to pgstats. This is
+@@ -355,7 +367,8 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ PruneReason reason,
+ OffsetNumber *off_loc,
+ TransactionId *new_relfrozen_xid,
+- MultiXactId *new_relmin_mxid)
++ MultiXactId *new_relmin_mxid,
++ bool repairFragmentation)
+ {
+ Page page = BufferGetPage(buffer);
+ BlockNumber blockno = BufferGetBlockNumber(buffer);
+@@ -540,6 +553,8 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
+ tup.t_data = htup;
+ tup.t_len = ItemIdGetLength(itemid);
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+ ItemPointerSet(&tup.t_self, blockno, offnum);
+
+ prstate.htsv[offnum] = heap_prune_satisfies_vacuum(&prstate, &tup,
+@@ -580,7 +595,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ *off_loc = offnum;
+
+ /* Process this item or chain of items */
+- heap_prune_chain(page, blockno, maxoff, offnum, &prstate);
++ heap_prune_chain(relation, buffer, page, blockno, maxoff, offnum, &prstate);
+ }
+
+ /*
+@@ -614,10 +629,15 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ {
+ ItemId itemid = PageGetItemId(page, offnum);
+ HeapTupleHeader htup = (HeapTupleHeader) PageGetItem(page, itemid);
++ tup.t_data = htup;
++ tup.t_len = ItemIdGetLength(itemid);
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
++ ItemPointerSet(&tup.t_self, blockno, offnum);
+
+ if (likely(!HeapTupleHeaderIsHotUpdated(htup)))
+ {
+- HeapTupleHeaderAdvanceConflictHorizon(htup,
++ HeapTupleHeaderAdvanceConflictHorizon(&tup,
+ &prstate.latest_xid_removed);
+ heap_prune_record_unused(&prstate, offnum, true);
+ }
+@@ -636,7 +656,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ }
+ }
+ else
+- heap_prune_record_unchanged_lp_normal(page, &prstate, offnum);
++ heap_prune_record_unchanged_lp_normal(relation, buffer, page, &prstate, offnum);
+ }
+
+ /* We should now have processed every tuple exactly once */
+@@ -663,7 +683,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ * pd_prune_xid field or the page was marked full, we will update the hint
+ * bit.
+ */
+- do_hint = ((PageHeader) page)->pd_prune_xid != prstate.new_prune_xid ||
++ do_hint = HeapPageGetPruneXid(page, IsToastRelation(relation)) != prstate.new_prune_xid ||
+ PageIsFull(page);
+
+ /*
+@@ -727,7 +747,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ * Validate the tuples we will be freezing before entering the
+ * critical section.
+ */
+- heap_pre_freeze_checks(buffer, prstate.frozen, prstate.nfrozen);
++ heap_pre_freeze_checks(relation, buffer, prstate.frozen, prstate.nfrozen);
+ }
+ else if (prstate.nfrozen > 0)
+ {
+@@ -759,7 +779,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ * Update the page's pd_prune_xid field to either zero, or the lowest
+ * XID of any soon-prunable tuple.
+ */
+- ((PageHeader) page)->pd_prune_xid = prstate.new_prune_xid;
++ HeapPageSetPruneXid(page, prstate.new_prune_xid, IsToastRelation(relation));
+
+ /*
+ * Also clear the "page is full" flag, since there's no point in
+@@ -785,11 +805,13 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ heap_page_prune_execute(buffer, false,
+ prstate.redirected, prstate.nredirected,
+ prstate.nowdead, prstate.ndead,
+- prstate.nowunused, prstate.nunused);
++ prstate.nowunused, prstate.nunused,
++ repairFragmentation,
++ IsToastRelation(relation));
+ }
+
+ if (do_freeze)
+- heap_freeze_prepared_tuples(buffer, prstate.frozen, prstate.nfrozen);
++ heap_freeze_prepared_tuples(relation, buffer, prstate.frozen, prstate.nfrozen);
+
+ MarkBufferDirty(buffer);
+
+@@ -840,7 +862,8 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ prstate.frozen, prstate.nfrozen,
+ prstate.redirected, prstate.nredirected,
+ prstate.nowdead, prstate.ndead,
+- prstate.nowunused, prstate.nunused);
++ prstate.nowunused, prstate.nunused,
++ repairFragmentation);
+ }
+ }
+
+@@ -996,7 +1019,7 @@ htsv_get_valid_status(int status)
+ * based on that outcome.
+ */
+ static void
+-heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
++heap_prune_chain(Relation relation, Buffer buffer, Page page, BlockNumber blockno, OffsetNumber maxoff,
+ OffsetNumber rootoffnum, PruneState *prstate)
+ {
+ TransactionId priorXmax = InvalidTransactionId;
+@@ -1010,6 +1033,9 @@ heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
+ */
+ int ndeadchain = 0,
+ nchain = 0;
++ HeapTupleData tup;
++
++ tup.t_tableOid = RelationGetRelid(relation);
+
+ rootlp = PageGetItemId(page, rootoffnum);
+
+@@ -1065,11 +1091,17 @@ heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
+
+ htup = (HeapTupleHeader) PageGetItem(page, lp);
+
++ tup.t_data = htup;
++ tup.t_len = ItemIdGetLength(lp);
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
++ ItemPointerSet(&(tup.t_self), BufferGetBlockNumber(buffer), offnum);
++
+ /*
+ * Check the tuple XMIN against prior XMAX, if any
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(HeapTupleHeaderGetXmin(htup), priorXmax))
++ !TransactionIdEquals(HeapTupleGetXmin(&tup), priorXmax))
+ break;
+
+ /*
+@@ -1083,7 +1115,7 @@ heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
+
+ /* Remember the last DEAD tuple seen */
+ ndeadchain = nchain;
+- HeapTupleHeaderAdvanceConflictHorizon(htup,
++ HeapTupleHeaderAdvanceConflictHorizon(&tup,
+ &prstate->latest_xid_removed);
+ /* Advance to next chain member */
+ break;
+@@ -1133,7 +1165,7 @@ heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
+ */
+ Assert(ItemPointerGetBlockNumber(&htup->t_ctid) == blockno);
+ offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ priorXmax = HeapTupleGetUpdateXidAny(&tup);
+ }
+
+ if (ItemIdIsRedirected(rootlp) && nchain < 2)
+@@ -1166,7 +1198,7 @@ process_chain:
+ i++;
+ }
+ for (; i < nchain; i++)
+- heap_prune_record_unchanged_lp_normal(page, prstate, chainitems[i]);
++ heap_prune_record_unchanged_lp_normal(relation, buffer, page, prstate, chainitems[i]);
+ }
+ else if (ndeadchain == nchain)
+ {
+@@ -1192,7 +1224,7 @@ process_chain:
+
+ /* the rest of tuples in the chain are normal, unchanged tuples */
+ for (int i = ndeadchain; i < nchain; i++)
+- heap_prune_record_unchanged_lp_normal(page, prstate, chainitems[i]);
++ heap_prune_record_unchanged_lp_normal(relation, buffer, page, prstate, chainitems[i]);
+ }
+ }
+
+@@ -1327,9 +1359,9 @@ heap_prune_record_unchanged_lp_unused(Page page, PruneState *prstate, OffsetNumb
+ * update bookkeeping of tuple counts and page visibility.
+ */
+ static void
+-heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumber offnum)
++heap_prune_record_unchanged_lp_normal(Relation relation, Buffer buffer, Page page, PruneState *prstate, OffsetNumber offnum)
+ {
+- HeapTupleHeader htup;
++ HeapTupleData tup;
+
+ Assert(!prstate->processed[offnum]);
+ prstate->processed[offnum] = true;
+@@ -1356,7 +1388,9 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * will violate this optimistic assumption, but the overall impact of that
+ * should be negligible.)
+ */
+- htup = (HeapTupleHeader) PageGetItem(page, PageGetItemId(page, offnum));
++ tup.t_data = (HeapTupleHeader) PageGetItem(page, PageGetItemId(page, offnum));
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+
+ switch (prstate->htsv[offnum])
+ {
+@@ -1378,9 +1412,7 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ */
+ if (prstate->all_visible)
+ {
+- TransactionId xmin;
+-
+- if (!HeapTupleHeaderXminCommitted(htup))
++ if (!HeapTupleHeaderXminCommitted(tup.t_data))
+ {
+ prstate->all_visible = false;
+ break;
+@@ -1393,7 +1425,6 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * there is a snapshot that considers this xid to still be
+ * running, and if so, we don't consider the page all-visible.
+ */
+- xmin = HeapTupleHeaderGetXmin(htup);
+
+ /*
+ * For now always use prstate->cutoffs for this test, because
+@@ -1402,16 +1433,16 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * non-freezing caller wanted to set the VM bit.
+ */
+ Assert(prstate->cutoffs);
+- if (!TransactionIdPrecedes(xmin, prstate->cutoffs->OldestXmin))
++ if (!TransactionIdPrecedes(tup.t_xmin, prstate->cutoffs->OldestXmin))
+ {
+ prstate->all_visible = false;
+ break;
+ }
+
+ /* Track newest xmin on page. */
+- if (TransactionIdFollows(xmin, prstate->visibility_cutoff_xid) &&
+- TransactionIdIsNormal(xmin))
+- prstate->visibility_cutoff_xid = xmin;
++ if (TransactionIdFollows(tup.t_xmin, prstate->visibility_cutoff_xid) &&
++ TransactionIdIsNormal(tup.t_xmin))
++ prstate->visibility_cutoff_xid = tup.t_xmin;
+ }
+ break;
+
+@@ -1424,7 +1455,7 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * that the page is reconsidered for pruning in future.
+ */
+ heap_prune_record_prunable(prstate,
+- HeapTupleHeaderGetUpdateXid(htup));
++ HeapTupleGetUpdateXidAny(&tup));
+ break;
+
+ case HEAPTUPLE_INSERT_IN_PROGRESS:
+@@ -1461,7 +1492,7 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * the page is reconsidered for pruning in future.
+ */
+ heap_prune_record_prunable(prstate,
+- HeapTupleHeaderGetUpdateXid(htup));
++ HeapTupleGetUpdateXidAny(&tup));
+ break;
+
+ default:
+@@ -1480,7 +1511,7 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ {
+ bool totally_frozen;
+
+- if ((heap_prepare_freeze_tuple(htup,
++ if ((heap_prepare_freeze_tuple(&tup,
+ prstate->cutoffs,
+ &prstate->pagefrz,
+ &prstate->frozen[prstate->nfrozen],
+@@ -1561,7 +1592,9 @@ void
+ heap_page_prune_execute(Buffer buffer, bool lp_truncate_only,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *nowdead, int ndead,
+- OffsetNumber *nowunused, int nunused)
++ OffsetNumber *nowunused, int nunused,
++ bool repairFragmentation,
++ bool is_toast)
+ {
+ Page page = (Page) BufferGetPage(buffer);
+ OffsetNumber *offnum;
+@@ -1709,7 +1742,8 @@ heap_page_prune_execute(Buffer buffer, bool lp_truncate_only,
+ * Finally, repair any fragmentation, and update the page's hint bit
+ * about whether it has free pointers.
+ */
+- PageRepairFragmentation(page);
++ if (repairFragmentation)
++ PageRepairFragmentation(page, is_toast);
+
+ /*
+ * Now that the page has been modified, assert that redirect items
+@@ -1782,7 +1816,8 @@ page_verify_redirects(Page page)
+ * and reused by a completely unrelated tuple.
+ */
+ void
+-heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
++heap_get_root_tuples(Relation relation, Buffer buffer, Page page,
++ OffsetNumber *root_offsets)
+ {
+ OffsetNumber offnum,
+ maxoff;
+@@ -1797,6 +1832,7 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ HeapTupleHeader htup;
+ OffsetNumber nextoffnum;
+ TransactionId priorXmax;
++ HeapTupleData tup;
+
+ /* skip unused and dead items */
+ if (!ItemIdIsUsed(lp) || ItemIdIsDead(lp))
+@@ -1805,6 +1841,9 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ if (ItemIdIsNormal(lp))
+ {
+ htup = (HeapTupleHeader) PageGetItem(page, lp);
++ tup.t_data = htup;
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+
+ /*
+ * Check if this tuple is part of a HOT-chain rooted at some other
+@@ -1826,7 +1865,7 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+
+ /* Set up to scan the HOT-chain */
+ nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ priorXmax = HeapTupleGetUpdateXidAny(&tup);
+ }
+ else
+ {
+@@ -1865,9 +1904,12 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ break;
+
+ htup = (HeapTupleHeader) PageGetItem(page, lp);
++ tup.t_data = htup;
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(htup)))
++ !TransactionIdEquals(priorXmax, HeapTupleGetXmin(&tup)))
+ break;
+
+ /* Remember the root line pointer for this item */
+@@ -1881,7 +1923,7 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ Assert(!HeapTupleHeaderIndicatesMovedPartitions(htup));
+
+ nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ priorXmax = HeapTupleGetUpdateXidAny(&tup);
+ }
+ }
+ }
+@@ -2057,7 +2099,8 @@ log_heap_prune_and_freeze(Relation relation, Buffer buffer,
+ HeapTupleFreeze *frozen, int nfrozen,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *dead, int ndead,
+- OffsetNumber *unused, int nunused)
++ OffsetNumber *unused, int nunused,
++ bool repairFragmentation)
+ {
+ xl_heap_prune xlrec;
+ XLogRecPtr recptr;
+@@ -2073,6 +2116,12 @@ log_heap_prune_and_freeze(Relation relation, Buffer buffer,
+
+ xlrec.flags = 0;
+
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLHP_ON_TOAST_RELATION;
++
++ if (repairFragmentation)
++ xlrec.flags |= XLHP_REPAIR_FRAGMENTATION;
++
+ /*
+ * Prepare data for the buffer. The arrays are not actually in the
+ * buffer, but we pretend that they are. When XLogInsert stores a full
+diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
+index 09ef2204497..090e1594679 100644
+--- a/src/backend/access/heap/rewriteheap.c
++++ b/src/backend/access/heap/rewriteheap.c
+@@ -359,6 +359,7 @@ rewrite_heap_tuple(RewriteState state,
+ &old_tuple->t_data->t_choice.t_heap,
+ sizeof(HeapTupleFields));
+
++ HeapTupleCopyXids(new_tuple, old_tuple);
+ new_tuple->t_data->t_infomask &= ~HEAP_XACT_MASK;
+ new_tuple->t_data->t_infomask2 &= ~HEAP2_XACT_MASK;
+ new_tuple->t_data->t_infomask |=
+@@ -368,7 +369,7 @@ rewrite_heap_tuple(RewriteState state,
+ * While we have our hands on the tuple, we may as well freeze any
+ * eligible xmin or xmax, so that future VACUUM effort can be saved.
+ */
+- heap_freeze_tuple(new_tuple->t_data,
++ heap_freeze_tuple(new_tuple,
+ state->rs_old_rel->rd_rel->relfrozenxid,
+ state->rs_old_rel->rd_rel->relminmxid,
+ state->rs_freeze_xid,
+@@ -384,7 +385,7 @@ rewrite_heap_tuple(RewriteState state,
+ * If the tuple has been updated, check the old-to-new mapping hash table.
+ */
+ if (!((old_tuple->t_data->t_infomask & HEAP_XMAX_INVALID) ||
+- HeapTupleHeaderIsOnlyLocked(old_tuple->t_data)) &&
++ HeapTupleIsOnlyLocked(old_tuple)) &&
+ !HeapTupleHeaderIndicatesMovedPartitions(old_tuple->t_data) &&
+ !(ItemPointerEquals(&(old_tuple->t_self),
+ &(old_tuple->t_data->t_ctid))))
+@@ -392,7 +393,7 @@ rewrite_heap_tuple(RewriteState state,
+ OldToNewMapping mapping;
+
+ memset(&hashkey, 0, sizeof(hashkey));
+- hashkey.xmin = HeapTupleHeaderGetUpdateXid(old_tuple->t_data);
++ hashkey.xmin = HeapTupleGetUpdateXidAny(old_tuple);
+ hashkey.tid = old_tuple->t_data->t_ctid;
+
+ mapping = (OldToNewMapping)
+@@ -465,7 +466,7 @@ rewrite_heap_tuple(RewriteState state,
+ * RECENTLY_DEAD if and only if the xmin is not before OldestXmin.
+ */
+ if ((new_tuple->t_data->t_infomask & HEAP_UPDATED) &&
+- !TransactionIdPrecedes(HeapTupleHeaderGetXmin(new_tuple->t_data),
++ !TransactionIdPrecedes(HeapTupleGetXmin(new_tuple),
+ state->rs_oldest_xmin))
+ {
+ /*
+@@ -474,7 +475,7 @@ rewrite_heap_tuple(RewriteState state,
+ UnresolvedTup unresolved;
+
+ memset(&hashkey, 0, sizeof(hashkey));
+- hashkey.xmin = HeapTupleHeaderGetXmin(new_tuple->t_data);
++ hashkey.xmin = HeapTupleGetXmin(new_tuple);
+ hashkey.tid = old_tid;
+
+ unresolved = hash_search(state->rs_unresolved_tups, &hashkey,
+@@ -562,7 +563,7 @@ rewrite_heap_dead_tuple(RewriteState state, HeapTuple old_tuple)
+ bool found;
+
+ memset(&hashkey, 0, sizeof(hashkey));
+- hashkey.xmin = HeapTupleHeaderGetXmin(old_tuple->t_data);
++ hashkey.xmin = HeapTupleGetXmin(old_tuple);
+ hashkey.tid = old_tuple->t_self;
+
+ unresolved = hash_search(state->rs_unresolved_tups, &hashkey,
+@@ -598,6 +599,8 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
+ Size len;
+ OffsetNumber newoff;
+ HeapTuple heaptup;
++ TransactionId xmin;
++ bool immutable_tuple;
+
+ /*
+ * If the new tuple is too big for storage or contains already toasted
+@@ -632,9 +635,19 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
+ len = MAXALIGN(heaptup->t_len); /* be conservative */
+
+ /*
+- * If we're gonna fail for oversize tuple, do it right away
++ * Due to update to 64-xid maximum plain tuple size was decreased due to adding
++ * PageSpecial to a heap page. Pages with tuple that became too large to fit,
++ * should remain in Double Xmax format (read only). Inserting plain tuples with
++ * size over new MaxHeapTupleSizs is prohibited anyway, but vaccum full will
++ * transfer this page to a rebuild relation unmodified.
+ */
+- if (len > MaxHeapTupleSize)
++ immutable_tuple = len <= MaxHeapTupleSize_32 && len > MaxHeapTupleSize;
++
++ /*
++ * If we're gonna fail for oversize tuple, do it right away. But allow to process
++ * immutable_tuple (see above).
++ */
++ if (len > MaxHeapTupleSize && !immutable_tuple)
+ ereport(ERROR,
+ (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+ errmsg("row is too big: size %zu, maximum size %zu",
+@@ -669,9 +682,41 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
+ /* Initialize a new empty page */
+ state->rs_buffer = smgr_bulk_get_buf(state->rs_bulkstate);
+ page = (Page) state->rs_buffer;
+- PageInit(page, BLCKSZ, 0);
++ if (immutable_tuple)
++ /* Initialize DoubleXmax page */
++ PageInit(page, BLCKSZ, 0);
++ else
++ {
++ Size special_size;
++
++ special_size = IsToastRelation(state->rs_new_rel) ?
++ sizeof(ToastPageSpecialData) :
++ sizeof(HeapPageSpecialData);
++ PageInit(page, BLCKSZ, special_size);
++ }
+ }
+
++ rewrite_page_prepare_for_xid(page, heaptup,
++ IsToastRelation(state->rs_new_rel));
++
++ /*
++ * Tuple with HEAP_XMIN_FROZEN in t_infomask should have xmin set
++ * to FrozenTransactionId to avoid these tuples be treated like normal.
++ */
++ xmin = HeapTupleGetXmin(heaptup);
++ HeapTupleSetXmin(heaptup, xmin);
++
++ /*
++ * Tuples on DoubleXmax page could not appear modified after they had been
++ * frozen by pg_upgrade. Just check this to be safe.
++ */
++ Assert(!immutable_tuple || xmin == FrozenTransactionId);
++
++ if (!immutable_tuple)
++ HeapTupleAndHeaderSetXmin(page, heaptup, xmin, false);
++
++ HeapTupleHeaderStoreXmax(page, heaptup, false);
++
+ /* And now we can insert the tuple into the page */
+ newoff = PageAddItem(page, (Item) heaptup->t_data, heaptup->t_len,
+ InvalidOffsetNumber, false, true);
+@@ -952,19 +997,24 @@ logical_rewrite_log_mapping(RewriteState state, TransactionId xid,
+ */
+ if (!found)
+ {
+- char path[MAXPGPATH];
+- Oid dboid;
++ char path[MAXPGPATH];
++ Oid dboid;
++ TransactionId current_xid;
+
+ if (state->rs_old_rel->rd_rel->relisshared)
+ dboid = InvalidOid;
+ else
+ dboid = MyDatabaseId;
+
++ current_xid = GetCurrentTransactionId();
+ snprintf(path, MAXPGPATH,
+ "%s/" LOGICAL_REWRITE_FORMAT,
+ PG_LOGICAL_MAPPINGS_DIR, dboid, relid,
+ LSN_FORMAT_ARGS(state->rs_begin_lsn),
+- xid, GetCurrentTransactionId());
++ (uint32) (xid >> 32),
++ (uint32) xid,
++ (uint32) (current_xid >> 32),
++ (uint32) current_xid);
+
+ dclist_init(&src->mappings);
+ src->off = 0;
+@@ -1011,9 +1061,9 @@ logical_rewrite_heap_tuple(RewriteState state, ItemPointerData old_tid,
+ if (!state->rs_logical_rewrite)
+ return;
+
+- xmin = HeapTupleHeaderGetXmin(new_tuple->t_data);
++ xmin = HeapTupleGetXmin(new_tuple);
+ /* use *GetUpdateXid to correctly deal with multixacts */
+- xmax = HeapTupleHeaderGetUpdateXid(new_tuple->t_data);
++ xmax = HeapTupleGetUpdateXidAny(new_tuple);
+
+ /*
+ * Log the mapping iff the tuple has been created recently.
+@@ -1077,14 +1127,19 @@ heap_xlog_logical_rewrite(XLogReaderState *r)
+ xl_heap_rewrite_mapping *xlrec;
+ uint32 len;
+ char *data;
++ TransactionId xid;
+
+ xlrec = (xl_heap_rewrite_mapping *) XLogRecGetData(r);
+
++ xid = XLogRecGetXid(r);
+ snprintf(path, MAXPGPATH,
+ "%s/" LOGICAL_REWRITE_FORMAT,
+ PG_LOGICAL_MAPPINGS_DIR, xlrec->mapped_db, xlrec->mapped_rel,
+ LSN_FORMAT_ARGS(xlrec->start_lsn),
+- xlrec->mapped_xid, XLogRecGetXid(r));
++ (uint32) (xlrec->mapped_xid >> 32),
++ (uint32) xlrec->mapped_xid,
++ (uint32) (xid >> 32),
++ (uint32) xid);
+
+ fd = OpenTransientFile(path,
+ O_CREAT | O_WRONLY | PG_BINARY);
+@@ -1179,10 +1234,12 @@ CheckPointLogicalRewriteHeap(void)
+ Oid dboid;
+ Oid relid;
+ XLogRecPtr lsn;
+- TransactionId rewrite_xid;
+- TransactionId create_xid;
+- uint32 hi,
+- lo;
++ uint32 lsn_hi,
++ lsn_lo,
++ rewrite_xid_hi,
++ rewrite_xid_lo,
++ create_xid_hi,
++ create_xid_lo;
+ PGFileType de_type;
+
+ if (strcmp(mapping_de->d_name, ".") == 0 ||
+@@ -1200,10 +1257,12 @@ CheckPointLogicalRewriteHeap(void)
+ continue;
+
+ if (sscanf(mapping_de->d_name, LOGICAL_REWRITE_FORMAT,
+- &dboid, &relid, &hi, &lo, &rewrite_xid, &create_xid) != 6)
++ &dboid, &relid, &lsn_hi, &lsn_lo,
++ &rewrite_xid_hi, &rewrite_xid_lo,
++ &create_xid_hi, &create_xid_lo) != 8)
+ elog(ERROR, "could not parse filename \"%s\"", mapping_de->d_name);
+
+- lsn = ((uint64) hi) << 32 | lo;
++ lsn = ((uint64) lsn_hi) << 32 | lsn_lo;
+
+ if (lsn < cutoff || cutoff == InvalidXLogRecPtr)
+ {
+diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
+index 7c619a71274..ad7badd454d 100644
+--- a/src/backend/access/heap/vacuumlazy.c
++++ b/src/backend/access/heap/vacuumlazy.c
+@@ -41,6 +41,7 @@
+ #include "access/transam.h"
+ #include "access/visibilitymap.h"
+ #include "access/xloginsert.h"
++#include "catalog/catalog.h"
+ #include "catalog/storage.h"
+ #include "commands/dbcommands.h"
+ #include "commands/progress.h"
+@@ -246,7 +247,6 @@ static void lazy_vacuum_heap_rel(LVRelState *vacrel);
+ static void lazy_vacuum_heap_page(LVRelState *vacrel, BlockNumber blkno,
+ Buffer buffer, OffsetNumber *deadoffsets,
+ int num_offsets, Buffer vmbuffer);
+-static bool lazy_check_wraparound_failsafe(LVRelState *vacrel);
+ static void lazy_cleanup_all_indexes(LVRelState *vacrel);
+ static IndexBulkDeleteResult *lazy_vacuum_one_index(Relation indrel,
+ IndexBulkDeleteResult *istat,
+@@ -485,7 +485,6 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ * ensure that parallel VACUUM won't be attempted at all when relfrozenxid
+ * is already dangerously old.)
+ */
+- lazy_check_wraparound_failsafe(vacrel);
+ dead_items_alloc(vacrel, params->nworkers);
+
+ /*
+@@ -603,7 +602,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ BufferUsage bufferusage;
+ StringInfoData buf;
+ char *msgfmt;
+- int32 diff;
++ int64 diff;
+ double read_rate = 0,
+ write_rate = 0;
+ int64 total_blks_hit;
+@@ -665,16 +664,17 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ orig_rel_pages == 0 ? 100.0 :
+ 100.0 * vacrel->scanned_pages / orig_rel_pages);
+ appendStringInfo(&buf,
+- _("tuples: %lld removed, %lld remain, %lld are dead but not yet removable\n"),
++ _("tuples: %lld removed, %lld remain, %lld are dead but not yet removable, oldest xmin: %llu\n"),
+ (long long) vacrel->tuples_deleted,
+ (long long) vacrel->new_rel_tuples,
+- (long long) vacrel->recently_dead_tuples);
++ (long long) vacrel->recently_dead_tuples,
++ (unsigned long long) vacrel->cutoffs.OldestXmin);
+ if (vacrel->missed_dead_tuples > 0)
+ appendStringInfo(&buf,
+ _("tuples missed: %lld dead from %u pages not removed due to cleanup lock contention\n"),
+ (long long) vacrel->missed_dead_tuples,
+ vacrel->missed_dead_pages);
+- diff = (int32) (ReadNextTransactionId() -
++ diff = (int64) (ReadNextTransactionId() -
+ vacrel->cutoffs.OldestXmin);
+ appendStringInfo(&buf,
+ _("removable cutoff: %llu, which was %lld XIDs old when operation ended\n"),
+@@ -682,7 +682,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ (long long) diff);
+ if (frozenxid_updated)
+ {
+- diff = (int32) (vacrel->NewRelfrozenXid -
++ diff = (int64) (vacrel->NewRelfrozenXid -
+ vacrel->cutoffs.relfrozenxid);
+ appendStringInfo(&buf,
+ _("new relfrozenxid: %llu, which is %lld XIDs ahead of previous value\n"),
+@@ -691,7 +691,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ }
+ if (minmulti_updated)
+ {
+- diff = (int32) (vacrel->NewRelminMxid -
++ diff = (int64) (vacrel->NewRelminMxid -
+ vacrel->cutoffs.relminmxid);
+ appendStringInfo(&buf,
+ _("new relminmxid: %llu, which is %lld MXIDs ahead of previous value\n"),
+@@ -869,18 +869,6 @@ lazy_scan_heap(LVRelState *vacrel)
+
+ vacuum_delay_point();
+
+- /*
+- * Regularly check if wraparound failsafe should trigger.
+- *
+- * There is a similar check inside lazy_vacuum_all_indexes(), but
+- * relfrozenxid might start to look dangerously old before we reach
+- * that point. This check also provides failsafe coverage for the
+- * one-pass strategy, and the two-pass strategy with the index_cleanup
+- * param set to 'off'.
+- */
+- if (vacrel->scanned_pages % FAILSAFE_EVERY_PAGES == 0)
+- lazy_check_wraparound_failsafe(vacrel);
+-
+ /*
+ * Consider if we definitely have enough space to process TIDs on page
+ * already. If we are close to overrunning the available space for
+@@ -1321,7 +1309,14 @@ lazy_scan_new_or_empty(LVRelState *vacrel, Buffer buf, BlockNumber blkno,
+
+ if (GetRecordedFreeSpace(vacrel->rel, blkno) == 0)
+ {
+- freespace = BLCKSZ - SizeOfPageHeaderData;
++ Size special_size;
++
++ special_size = IsToastRelation(vacrel->rel) ?
++ sizeof(ToastPageSpecialData) :
++ sizeof(HeapPageSpecialData);
++ freespace = BufferGetPageSize(buf)
++ - SizeOfPageHeaderData
++ - special_size;
+
+ RecordPageWithFreeSpace(vacrel->rel, blkno, freespace);
+ }
+@@ -1450,7 +1445,8 @@ lazy_scan_prune(LVRelState *vacrel,
+ heap_page_prune_and_freeze(rel, buf, vacrel->vistest, prune_options,
+ &vacrel->cutoffs, &presult, PRUNE_VACUUM_SCAN,
+ &vacrel->offnum,
+- &vacrel->NewRelfrozenXid, &vacrel->NewRelminMxid);
++ &vacrel->NewRelfrozenXid, &vacrel->NewRelminMxid,
++ true);
+
+ Assert(MultiXactIdIsValid(vacrel->NewRelminMxid));
+ Assert(TransactionIdIsValid(vacrel->NewRelfrozenXid));
+@@ -1669,7 +1665,6 @@ lazy_scan_noprune(LVRelState *vacrel,
+ recently_dead_tuples,
+ missed_dead_tuples;
+ bool hastup;
+- HeapTupleHeader tupleheader;
+ TransactionId NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid;
+ MultiXactId NoFreezePageRelminMxid = vacrel->NewRelminMxid;
+ OffsetNumber deadoffsets[MaxHeapTuplesPerPage];
+@@ -1714,8 +1709,13 @@ lazy_scan_noprune(LVRelState *vacrel,
+ }
+
+ hastup = true; /* page prevents rel truncation */
+- tupleheader = (HeapTupleHeader) PageGetItem(page, itemid);
+- if (heap_tuple_should_freeze(tupleheader, &vacrel->cutoffs,
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(vacrel->rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page,
++ IsToastRelation(vacrel->rel));
++ ItemPointerSet(&(tuple.t_self), blkno, offnum);
++ if (heap_tuple_should_freeze(&tuple, &vacrel->cutoffs,
+ &NoFreezePageRelfrozenXid,
+ &NoFreezePageRelminMxid))
+ {
+@@ -1751,6 +1751,8 @@ lazy_scan_noprune(LVRelState *vacrel,
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationGetRelid(vacrel->rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page,
++ IsToastRelation(vacrel->rel));
+
+ switch (HeapTupleSatisfiesVacuum(&tuple, vacrel->cutoffs.OldestXmin,
+ buf))
+@@ -2012,13 +2014,6 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
+ Assert(vacrel->do_index_vacuuming);
+ Assert(vacrel->do_index_cleanup);
+
+- /* Precheck for XID wraparound emergencies */
+- if (lazy_check_wraparound_failsafe(vacrel))
+- {
+- /* Wraparound emergency -- don't even start an index scan */
+- return false;
+- }
+-
+ /*
+ * Report that we are now vacuuming indexes and the number of indexes to
+ * vacuum.
+@@ -2042,12 +2037,6 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
+ pgstat_progress_update_param(PROGRESS_VACUUM_INDEXES_PROCESSED,
+ idx + 1);
+
+- if (lazy_check_wraparound_failsafe(vacrel))
+- {
+- /* Wraparound emergency -- end current index scan */
+- allindexes = false;
+- break;
+- }
+ }
+ }
+ else
+@@ -2055,13 +2044,6 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
+ /* Outsource everything to parallel variant */
+ parallel_vacuum_bulkdel_all_indexes(vacrel->pvs, old_live_tuples,
+ vacrel->num_index_scans);
+-
+- /*
+- * Do a postcheck to consider applying wraparound failsafe now. Note
+- * that parallel VACUUM only gets the precheck and this postcheck.
+- */
+- if (lazy_check_wraparound_failsafe(vacrel))
+- allindexes = false;
+ }
+
+ /*
+@@ -2256,7 +2238,8 @@ lazy_vacuum_heap_page(LVRelState *vacrel, BlockNumber blkno, Buffer buffer,
+ NULL, 0, /* frozen */
+ NULL, 0, /* redirected */
+ NULL, 0, /* dead */
+- unused, nunused);
++ unused, nunused,
++ true); /*repair fragmentation*/
+ }
+
+ /*
+@@ -2294,68 +2277,6 @@ lazy_vacuum_heap_page(LVRelState *vacrel, BlockNumber blkno, Buffer buffer,
+ restore_vacuum_error_info(vacrel, &saved_err_info);
+ }
+
+-/*
+- * Trigger the failsafe to avoid wraparound failure when vacrel table has a
+- * relfrozenxid and/or relminmxid that is dangerously far in the past.
+- * Triggering the failsafe makes the ongoing VACUUM bypass any further index
+- * vacuuming and heap vacuuming. Truncating the heap is also bypassed.
+- *
+- * Any remaining work (work that VACUUM cannot just bypass) is typically sped
+- * up when the failsafe triggers. VACUUM stops applying any cost-based delay
+- * that it started out with.
+- *
+- * Returns true when failsafe has been triggered.
+- */
+-static bool
+-lazy_check_wraparound_failsafe(LVRelState *vacrel)
+-{
+- /* Don't warn more than once per VACUUM */
+- if (VacuumFailsafeActive)
+- return true;
+-
+- if (unlikely(vacuum_xid_failsafe_check(&vacrel->cutoffs)))
+- {
+- const int progress_index[] = {
+- PROGRESS_VACUUM_INDEXES_TOTAL,
+- PROGRESS_VACUUM_INDEXES_PROCESSED
+- };
+- int64 progress_val[2] = {0, 0};
+-
+- VacuumFailsafeActive = true;
+-
+- /*
+- * Abandon use of a buffer access strategy to allow use of all of
+- * shared buffers. We assume the caller who allocated the memory for
+- * the BufferAccessStrategy will free it.
+- */
+- vacrel->bstrategy = NULL;
+-
+- /* Disable index vacuuming, index cleanup, and heap rel truncation */
+- vacrel->do_index_vacuuming = false;
+- vacrel->do_index_cleanup = false;
+- vacrel->do_rel_truncate = false;
+-
+- /* Reset the progress counters */
+- pgstat_progress_update_multi_param(2, progress_index, progress_val);
+-
+- ereport(WARNING,
+- (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans",
+- vacrel->dbname, vacrel->relnamespace, vacrel->relname,
+- vacrel->num_index_scans),
+- errdetail("The table's relfrozenxid or relminmxid is too far in the past."),
+- errhint("Consider increasing configuration parameter \"maintenance_work_mem\" or \"autovacuum_work_mem\".\n"
+- "You might also need to consider other ways for VACUUM to keep up with the allocation of transaction IDs.")));
+-
+- /* Stop applying cost limits from this point on */
+- VacuumCostActive = false;
+- VacuumCostBalance = 0;
+-
+- return true;
+- }
+-
+- return false;
+-}
+-
+ /*
+ * lazy_cleanup_all_indexes() -- cleanup all indexes of relation.
+ */
+@@ -3015,7 +2936,8 @@ heap_page_is_all_visible(LVRelState *vacrel, Buffer buf,
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationGetRelid(vacrel->rel);
+-
++ HeapTupleCopyXidsFromPage(buf, &tuple, page,
++ IsToastRelation(vacrel->rel));
+ switch (HeapTupleSatisfiesVacuum(&tuple, vacrel->cutoffs.OldestXmin,
+ buf))
+ {
+@@ -3035,7 +2957,7 @@ heap_page_is_all_visible(LVRelState *vacrel, Buffer buf,
+ * The inserter definitely committed. But is it old enough
+ * that everyone sees it as committed?
+ */
+- xmin = HeapTupleHeaderGetXmin(tuple.t_data);
++ xmin = HeapTupleGetXmin(&tuple);
+ if (!TransactionIdPrecedes(xmin,
+ vacrel->cutoffs.OldestXmin))
+ {
+@@ -3051,7 +2973,7 @@ heap_page_is_all_visible(LVRelState *vacrel, Buffer buf,
+
+ /* Check whether this tuple is already frozen or not */
+ if (all_visible && *all_frozen &&
+- heap_tuple_needs_eventual_freeze(tuple.t_data))
++ heap_tuple_needs_eventual_freeze(&tuple))
+ *all_frozen = false;
+ }
+ break;
+diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
+index 01bbece6bfd..7c378dc4277 100644
+--- a/src/backend/access/nbtree/nbtpage.c
++++ b/src/backend/access/nbtree/nbtpage.c
+@@ -549,6 +549,7 @@ _bt_getroot(Relation rel, Relation heaprel, int access)
+ rootblkno = rootopaque->btpo_next;
+ }
+
++ /* Note: can't check btpo_level on deleted pages */
+ if (rootopaque->btpo_level != rootlevel)
+ elog(ERROR, "root page %u of index \"%s\" has level %u, expected %u",
+ rootblkno, RelationGetRelationName(rel),
+@@ -652,6 +653,7 @@ _bt_gettrueroot(Relation rel)
+ rootblkno = rootopaque->btpo_next;
+ }
+
++ /* Note: can't check btpo_level on deleted pages */
+ if (rootopaque->btpo_level != rootlevel)
+ elog(ERROR, "root page %u of index \"%s\" has level %u, expected %u",
+ rootblkno, RelationGetRelationName(rel),
+diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
+index 1f40d40263e..600b9f12cdd 100644
+--- a/src/backend/access/nbtree/nbtsplitloc.c
++++ b/src/backend/access/nbtree/nbtsplitloc.c
+@@ -140,6 +140,7 @@ _bt_findsplitloc(Relation rel,
+ olddataitemstoleft,
+ perfectpenalty,
+ leaffillfactor;
++ int maxTupleEnd PG_USED_FOR_ASSERTS_ONLY;
+ FindSplitData state;
+ FindSplitStrat strategy;
+ ItemId itemid;
+@@ -153,6 +154,7 @@ _bt_findsplitloc(Relation rel,
+
+ opaque = BTPageGetOpaque(origpage);
+ maxoff = PageGetMaxOffsetNumber(origpage);
++ maxTupleEnd = ItemIdGetTupleEnd(PageGetItemId(origpage, P_HIKEY));
+
+ /* Total free space available on a btree page, after fixed overhead */
+ leftspace = rightspace =
+@@ -214,6 +216,18 @@ _bt_findsplitloc(Relation rel,
+ itemid = PageGetItemId(origpage, offnum);
+ itemsz = MAXALIGN(ItemIdGetLength(itemid)) + sizeof(ItemIdData);
+
++#ifdef USE_ASSERT_CHECKING
++
++ /*
++ * Ending of rightmost tuple on a page can be shifted relative to left
++ * boundary of BTPageOpaqueData due to conversion from EE96, which
++ * used different BTPageOpaqueData layout. It is only checked in the
++ * assert below.
++ */
++ if (maxTupleEnd < ItemIdGetTupleEnd(itemid))
++ maxTupleEnd = ItemIdGetTupleEnd(itemid);
++#endif
++
+ /*
+ * When item offset number is not newitemoff, neither side of the
+ * split can be newitem. Record a split after the previous data item
+@@ -248,7 +262,7 @@ _bt_findsplitloc(Relation rel,
+ * (Though only when it's possible that newitem will end up alone on new
+ * right page.)
+ */
+- Assert(olddataitemstoleft == olddataitemstotal);
++ Assert(olddataitemstoleft + ((PageHeader) origpage)->pd_special - maxTupleEnd == olddataitemstotal);
+ if (newitemoff > maxoff)
+ _bt_recsplitloc(&state, newitemoff, false, olddataitemstotal, 0);
+
+diff --git a/src/backend/access/rmgrdesc/gistdesc.c b/src/backend/access/rmgrdesc/gistdesc.c
+index b5d72a8e54d..a9f4b528d65 100644
+--- a/src/backend/access/rmgrdesc/gistdesc.c
++++ b/src/backend/access/rmgrdesc/gistdesc.c
+@@ -28,7 +28,7 @@ out_gistxlogPageReuse(StringInfo buf, gistxlogPageReuse *xlrec)
+ appendStringInfo(buf, "rel %u/%u/%u; blk %u; snapshotConflictHorizon %llu, isCatalogRel %c",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber, xlrec->block,
+- (unsigned long long) U64FromFullTransactionId(xlrec->snapshotConflictHorizon),
++ (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
+ xlrec->isCatalogRel ? 'T' : 'F');
+ }
+
+@@ -52,7 +52,7 @@ static void
+ out_gistxlogPageDelete(StringInfo buf, gistxlogPageDelete *xlrec)
+ {
+ appendStringInfo(buf, "deleteXid %llu; downlink %u",
+- (unsigned long long) U64FromFullTransactionId(xlrec->deleteXid),
++ (unsigned long long) XidFromFullTransactionId(xlrec->deleteXid),
+ xlrec->downlinkOffset);
+ }
+
+diff --git a/src/backend/access/rmgrdesc/heapdesc.c b/src/backend/access/rmgrdesc/heapdesc.c
+index 67a80cf5510..dabab6b809e 100644
+--- a/src/backend/access/rmgrdesc/heapdesc.c
++++ b/src/backend/access/rmgrdesc/heapdesc.c
+@@ -285,7 +285,7 @@ heap2_desc(StringInfo buf, XLogReaderState *record)
+ memcpy(&conflict_xid, rec + SizeOfHeapPrune, sizeof(TransactionId));
+
+ /* XXX 64-bit conflict xid? - a.alekseev */
+- appendStringInfo(buf, "snapshotConflictHorizon: %u",
++ appendStringInfo(buf, "snapshotConflictHorizon: %lu",
+ conflict_xid);
+ }
+
+@@ -392,6 +392,23 @@ heap2_desc(StringInfo buf, XLogReaderState *record)
+ }
+ }
+
++void
++heap3_desc(StringInfo buf, XLogReaderState *record)
++{
++ char *rec = XLogRecGetData(record);
++ uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
++
++ info &= XLOG_HEAP_OPMASK;
++ if (info == XLOG_HEAP3_BASE_SHIFT)
++ {
++ xl_heap_base_shift *xlrec = (xl_heap_base_shift *) rec;
++
++ appendStringInfo(buf, "%s delta %lld ",
++ xlrec->multi ? "MultiXactId" : "XactId",
++ (long long) xlrec->delta);
++ }
++}
++
+ const char *
+ heap_identify(uint8 info)
+ {
+@@ -475,3 +492,18 @@ heap2_identify(uint8 info)
+
+ return id;
+ }
++
++const char *
++heap3_identify(uint8 info)
++{
++ const char *id = NULL;
++
++ switch (info & ~XLR_INFO_MASK)
++ {
++ case XLOG_HEAP3_BASE_SHIFT:
++ id = "BASE_SHIFT";
++ break;
++ }
++
++ return id;
++}
+diff --git a/src/backend/access/rmgrdesc/nbtdesc.c b/src/backend/access/rmgrdesc/nbtdesc.c
+index 3c2f38df94a..2e553017a24 100644
+--- a/src/backend/access/rmgrdesc/nbtdesc.c
++++ b/src/backend/access/rmgrdesc/nbtdesc.c
+@@ -96,7 +96,7 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+
+ appendStringInfo(buf, "left: %u, right: %u, level: %u, safexid: %llu, ",
+ xlrec->leftsib, xlrec->rightsib, xlrec->level,
+- (unsigned long long) U64FromFullTransactionId(xlrec->safexid));
++ (unsigned long long) XidFromFullTransactionId(xlrec->safexid));
+ appendStringInfo(buf, "leafleft: %u, leafright: %u, leaftopparent: %u",
+ xlrec->leafleftsib, xlrec->leafrightsib,
+ xlrec->leaftopparent);
+@@ -116,7 +116,7 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+ appendStringInfo(buf, "rel: %u/%u/%u, snapshotConflictHorizon: %llu, isCatalogRel: %c",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber,
+- (unsigned long long) U64FromFullTransactionId(xlrec->snapshotConflictHorizon),
++ (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
+ xlrec->isCatalogRel ? 'T' : 'F');
+ break;
+ }
+diff --git a/src/backend/access/rmgrdesc/xactdesc.c b/src/backend/access/rmgrdesc/xactdesc.c
+index d8ff6be3908..0f2b417a3ea 100644
+--- a/src/backend/access/rmgrdesc/xactdesc.c
++++ b/src/backend/access/rmgrdesc/xactdesc.c
+@@ -110,7 +110,8 @@ ParseCommitRecord(uint8 info, xl_xact_commit *xlrec, xl_xact_parsed_commit *pars
+ {
+ xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
+
+- parsed->twophase_xid = xl_twophase->xid;
++ parsed->twophase_xid =
++ ((uint64) xl_twophase->xid_hi << 32) | xl_twophase->xid_lo;
+
+ data += sizeof(xl_xact_twophase);
+
+@@ -205,7 +206,8 @@ ParseAbortRecord(uint8 info, xl_xact_abort *xlrec, xl_xact_parsed_abort *parsed)
+ {
+ xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
+
+- parsed->twophase_xid = xl_twophase->xid;
++ parsed->twophase_xid =
++ ((uint64) xl_twophase->xid_hi << 32) | xl_twophase->xid_lo;
+
+ data += sizeof(xl_xact_twophase);
+
+diff --git a/src/backend/access/rmgrdesc/xlogdesc.c b/src/backend/access/rmgrdesc/xlogdesc.c
+index a6e8e3dd230..ee42d95c6bf 100644
+--- a/src/backend/access/rmgrdesc/xlogdesc.c
++++ b/src/backend/access/rmgrdesc/xlogdesc.c
+@@ -75,7 +75,7 @@ xlog_desc(StringInfo buf, XLogReaderState *record)
+ checkpoint->PrevTimeLineID,
+ checkpoint->fullPageWrites ? "true" : "false",
+ get_wal_level_string(checkpoint->wal_level),
+- (unsigned long long) U64FromFullTransactionId(checkpoint->nextXid),
++ (unsigned long long) XidFromFullTransactionId(checkpoint->nextXid),
+ checkpoint->nextOid,
+ (unsigned long long) checkpoint->nextMulti,
+ (unsigned long long) checkpoint->nextMultiOffset,
+diff --git a/src/backend/access/transam/clog.c b/src/backend/access/transam/clog.c
+index db5a86116f9..c5062e24fbd 100644
+--- a/src/backend/access/transam/clog.c
++++ b/src/backend/access/transam/clog.c
+@@ -318,7 +318,7 @@ TransactionIdSetPageStatus(TransactionId xid, int nsubxids,
+ * sub-XIDs and all of the XIDs for which we're adjusting clog should be
+ * on the same page. Check those conditions, too.
+ */
+- if (all_xact_same_page && xid == MyProc->xid &&
++ if (all_xact_same_page && xid == pg_atomic_read_u64(&MyProc->xid) &&
+ nsubxids <= THRESHOLD_SUBTRANS_CLOG_OPT &&
+ nsubxids == MyProc->subxidStatus.count &&
+ (nsubxids == 0 ||
+@@ -1032,24 +1032,11 @@ TruncateCLOG(TransactionId oldestXact, Oid oldestxid_datoid)
+ SimpleLruTruncate(XactCtl, cutoffPage);
+ }
+
+-
+ /*
+ * Decide whether a CLOG page number is "older" for truncation purposes.
+ *
+- * We need to use comparison of TransactionIds here in order to do the right
+- * thing with wraparound XID arithmetic. However, TransactionIdPrecedes()
+- * would get weird about permanent xact IDs. So, offset both such that xid1,
+- * xid2, and xid2 + CLOG_XACTS_PER_PAGE - 1 are all normal XIDs; this offset
+- * is relevant to page 0 and to the page preceding page 0.
+- *
+- * The page containing oldestXact-2^31 is the important edge case. The
+- * portion of that page equaling or following oldestXact-2^31 is expendable,
+- * but the portion preceding oldestXact-2^31 is not. When oldestXact-2^31 is
+- * the first XID of a page and segment, the entire page and segment is
+- * expendable, and we could truncate the segment. Recognizing that case would
+- * require making oldestXact, not just the page containing oldestXact,
+- * available to this callback. The benefit would be rare and small, so we
+- * don't optimize that edge case.
++ * With 64xid this function is just "<", but we left it as a function in order
++ * for its calls remain "vanilla" like.
+ */
+ static bool
+ CLOGPagePrecedes(int64 page1, int64 page2)
+diff --git a/src/backend/access/transam/commit_ts.c b/src/backend/access/transam/commit_ts.c
+index a46602f91f9..aac738aea63 100644
+--- a/src/backend/access/transam/commit_ts.c
++++ b/src/backend/access/transam/commit_ts.c
+@@ -947,25 +947,6 @@ AdvanceOldestCommitTsXid(TransactionId oldestXact)
+ /*
+ * Decide whether a commitTS page number is "older" for truncation purposes.
+ * Analogous to CLOGPagePrecedes().
+- *
+- * At default BLCKSZ, (1 << 31) % COMMIT_TS_XACTS_PER_PAGE == 128. This
+- * introduces differences compared to CLOG and the other SLRUs having (1 <<
+- * 31) % per_page == 0. This function never tests exactly
+- * TransactionIdPrecedes(x-2^31, x). When the system reaches xidStopLimit,
+- * there are two possible counts of page boundaries between oldestXact and the
+- * latest XID assigned, depending on whether oldestXact is within the first
+- * 128 entries of its page. Since this function doesn't know the location of
+- * oldestXact within page2, it returns false for one page that actually is
+- * expendable. This is a wider (yet still negligible) version of the
+- * truncation opportunity that CLOGPagePrecedes() cannot recognize.
+- *
+- * For the sake of a worked example, number entries with decimal values such
+- * that page1==1 entries range from 1.0 to 1.999. Let N+0.15 be the number of
+- * pages that 2^31 entries will span (N is an integer). If oldestXact=N+2.1,
+- * then the final safe XID assignment leaves newestXact=1.95. We keep page 2,
+- * because entry=2.85 is the border that toggles whether entries precede the
+- * last entry of the oldestXact page. While page 2 is expendable at
+- * oldestXact=N+2.1, it would be precious at oldestXact=N+2.9.
+ */
+ static bool
+ CommitTsPagePrecedes(int64 page1, int64 page2)
+diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
+index 573702dd671..8add80f60f3 100644
+--- a/src/backend/access/transam/multixact.c
++++ b/src/backend/access/transam/multixact.c
+@@ -436,6 +436,9 @@ MultiXactIdCreate(TransactionId xid1, MultiXactStatus status1,
+ /* MultiXactIdSetOldestMember() must have been called already. */
+ Assert(MultiXactIdIsValid(OldestMemberMXactId[MyProcNumber]));
+
++ /* memset members array because with 64-bit xids it has a padding hole */
++ MemSet(members, 0, sizeof(members));
++
+ /*
+ * Note: unlike MultiXactIdExpand, we don't bother to check that both XIDs
+ * are still running. In typical usage, xid2 will be our own XID and the
+@@ -551,7 +554,7 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
+ * end of the loop.
+ */
+ newMembers = (MultiXactMember *)
+- palloc(sizeof(MultiXactMember) * (nmembers + 1));
++ palloc0(sizeof(MultiXactMember) * (nmembers + 1));
+
+ for (i = 0, j = 0; i < nmembers; i++)
+ {
+@@ -955,8 +958,8 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
+ for (i = 0; i < nmembers; i++, offset++)
+ {
+ TransactionId *memberptr;
+- uint32 *flagsptr;
+- uint32 flagsval;
++ uint64 *flagsptr;
++ uint64 flagsval;
+ int bshift;
+ int flagsoff;
+ int memberoff;
+@@ -993,12 +996,12 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
+
+ *memberptr = members[i].xid;
+
+- flagsptr = (uint32 *)
++ flagsptr = (uint64 *)
+ (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
+
+ flagsval = *flagsptr;
+- flagsval &= ~(((1 << MXACT_MEMBER_BITS_PER_XACT) - 1) << bshift);
+- flagsval |= (members[i].status << bshift);
++ flagsval &= ~((uint64) ((1ULL << MXACT_MEMBER_BITS_PER_XACT) - 1) << bshift);
++ flagsval |= ((uint64) members[i].status << bshift);
+ *flagsptr = flagsval;
+
+ MultiXactMemberCtl->shared->page_dirty[slotno] = true;
+@@ -1117,8 +1120,8 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+ /* complain even if that DB has disappeared */
+ if (oldest_datname)
+ ereport(WARNING,
+- (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
+- "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
++ (errmsg_plural("database \"%s\" must be vacuumed before %lu more MultiXactId is used",
++ "database \"%s\" must be vacuumed before %lu more MultiXactIds are used",
+ multiWrapLimit - result,
+ oldest_datname,
+ multiWrapLimit - result),
+@@ -1126,8 +1129,8 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+ "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+ else
+ ereport(WARNING,
+- (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",
+- "database with OID %u must be vacuumed before %u more MultiXactIds are used",
++ (errmsg_plural("database with OID %u must be vacuumed before %lu more MultiXactId is used",
++ "database with OID %u must be vacuumed before %lu more MultiXactIds are used",
+ multiWrapLimit - result,
+ oldest_datoid,
+ multiWrapLimit - result),
+@@ -1357,7 +1360,10 @@ retry:
+ offptr += entryno;
+ offset = *offptr;
+
+- Assert(offset != 0);
++ if (offset == 0)
++ ereport(ERROR,
++ (errmsg("found invalid zero offset in multixact %llu",
++ (unsigned long long) multi)));
+
+ /*
+ * Use the same increment rule as GetNewMultiXactId(), that is, don't
+@@ -1432,14 +1438,14 @@ retry:
+ if (slept)
+ ConditionVariableCancelSleep();
+
+- ptr = (MultiXactMember *) palloc(length * sizeof(MultiXactMember));
++ ptr = (MultiXactMember *) palloc0(length * sizeof(MultiXactMember));
+
+ truelength = 0;
+ prev_pageno = -1;
+ for (int i = 0; i < length; i++, offset++)
+ {
+ TransactionId *xactptr;
+- uint32 *flagsptr;
++ uint64 *flagsptr;
+ int flagsoff;
+ int bshift;
+ int memberoff;
+@@ -1481,7 +1487,7 @@ retry:
+
+ flagsoff = MXOffsetToFlagsOffset(offset);
+ bshift = MXOffsetToFlagsBitShift(offset);
+- flagsptr = (uint32 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
++ flagsptr = (uint64 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
+
+ ptr[truelength].xid = *xactptr;
+ ptr[truelength].status = (*flagsptr >> bshift) & MXACT_MEMBER_XACT_BITMASK;
+@@ -2363,7 +2369,7 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
+
+ /* Log the info */
+ ereport(DEBUG1,
+- (errmsg_internal("MultiXactId wrap limit is %u, limited by database with OID %u",
++ (errmsg_internal("MultiXactId wrap limit is %lu, limited by database with OID %u",
+ multiWrapLimit, oldest_datoid)));
+
+ /*
+@@ -2413,8 +2419,8 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
+
+ if (oldest_datname)
+ ereport(WARNING,
+- (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
+- "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
++ (errmsg_plural("database \"%s\" must be vacuumed before %lu more MultiXactId is used",
++ "database \"%s\" must be vacuumed before %lu more MultiXactIds are used",
+ multiWrapLimit - curMulti,
+ oldest_datname,
+ multiWrapLimit - curMulti),
+@@ -2422,8 +2428,8 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
+ "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+ else
+ ereport(WARNING,
+- (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",
+- "database with OID %u must be vacuumed before %u more MultiXactIds are used",
++ (errmsg_plural("database with OID %u must be vacuumed before %lu more MultiXactId is used",
++ "database with OID %u must be vacuumed before %lu more MultiXactIds are used",
+ multiWrapLimit - curMulti,
+ oldest_datoid,
+ multiWrapLimit - curMulti),
+@@ -2529,7 +2535,7 @@ ExtendMultiXactMember(MultiXactOffset offset, int nmembers)
+ {
+ int flagsoff;
+ int flagsbit;
+- uint32 difference;
++ uint64 difference;
+
+ /*
+ * Only zero when at first entry of a page.
+@@ -3058,7 +3064,7 @@ MultiXactOffsetPagePrecedes(int64 page1, int64 page2)
+
+ /*
+ * Decide whether a MultiXactMember page number is "older" for truncation
+- * purposes. There is no "invalid offset number" so use the numbers verbatim.
++ * purposes. There is no "invalid offset number" so use the numbers verbatim.
+ */
+ static bool
+ MultiXactMemberPagePrecedes(int64 page1, int64 page2)
+@@ -3083,7 +3089,7 @@ MultiXactMemberPagePrecedes(int64 page1, int64 page2)
+ bool
+ MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
+ {
+- int32 diff = (int32) (multi1 - multi2);
++ int64 diff = (int64) (multi1 - multi2);
+
+ return (diff < 0);
+ }
+@@ -3097,7 +3103,7 @@ MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
+ bool
+ MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
+ {
+- int32 diff = (int32) (multi1 - multi2);
++ int64 diff = (int64) (multi1 - multi2);
+
+ return (diff <= 0);
+ }
+diff --git a/src/backend/access/transam/slru.c b/src/backend/access/transam/slru.c
+index 35a930810b1..915bba1bb34 100644
+--- a/src/backend/access/transam/slru.c
++++ b/src/backend/access/transam/slru.c
+@@ -1637,7 +1637,7 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ * must not assign.
+ */
+ lhs = per_page + offset; /* skip first page to avoid non-normal XIDs */
+- rhs = lhs + (1U << 31);
++ rhs = lhs + (1ULL << 63);
+ Assert(TransactionIdPrecedes(lhs, rhs));
+ Assert(TransactionIdPrecedes(rhs, lhs));
+ Assert(!TransactionIdPrecedes(lhs - 1, rhs));
+@@ -1653,13 +1653,14 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ Assert(ctl->PagePrecedes(rhs / per_page, (lhs - 3 * per_page) / per_page));
+ Assert(ctl->PagePrecedes(rhs / per_page, (lhs - 2 * per_page) / per_page));
+ Assert(ctl->PagePrecedes(rhs / per_page, (lhs - 1 * per_page) / per_page)
+- || (1U << 31) % per_page != 0); /* See CommitTsPagePrecedes() */
++ || (1ULL << 63) % per_page != 0); /* See CommitTsPagePrecedes() */
+ Assert(ctl->PagePrecedes((lhs + 1 * per_page) / per_page, rhs / per_page)
+- || (1U << 31) % per_page != 0);
++ || (1ULL << 63) % per_page != 0);
+ Assert(ctl->PagePrecedes((lhs + 2 * per_page) / per_page, rhs / per_page));
+ Assert(ctl->PagePrecedes((lhs + 3 * per_page) / per_page, rhs / per_page));
+ Assert(!ctl->PagePrecedes(rhs / per_page, (lhs + per_page) / per_page));
+
++
+ /*
+ * GetNewTransactionId() has assigned the last XID it can safely use, and
+ * that XID is in the *LAST* page of the second segment. We must not
+@@ -1669,7 +1670,7 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ newestXact = newestPage * per_page + offset;
+ Assert(newestXact / per_page == newestPage);
+ oldestXact = newestXact + 1;
+- oldestXact -= 1U << 31;
++ oldestXact -= 1ULL << 63;
+ oldestPage = oldestXact / per_page;
+ Assert(!SlruMayDeleteSegment(ctl,
+ (newestPage -
+@@ -1685,7 +1686,7 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ newestXact = newestPage * per_page + offset;
+ Assert(newestXact / per_page == newestPage);
+ oldestXact = newestXact + 1;
+- oldestXact -= 1U << 31;
++ oldestXact -= 1ULL << 63;
+ oldestPage = oldestXact / per_page;
+ Assert(!SlruMayDeleteSegment(ctl,
+ (newestPage -
+diff --git a/src/backend/access/transam/subtrans.c b/src/backend/access/transam/subtrans.c
+index 9d762b75c2b..c7bb406fa16 100644
+--- a/src/backend/access/transam/subtrans.c
++++ b/src/backend/access/transam/subtrans.c
+@@ -271,12 +271,17 @@ void
+ BootStrapSUBTRANS(void)
+ {
+ int slotno;
+- LWLock *lock = SimpleLruGetBankLock(SubTransCtl, 0);
++ int64 pageno;
++ LWLock *lock;
++
++ pageno = TransactionIdToPage(XidFromFullTransactionId(TransamVariables->nextXid));
++
++ lock = SimpleLruGetBankLock(SubTransCtl, 0);
+
+ LWLockAcquire(lock, LW_EXCLUSIVE);
+
+ /* Create and zero the first page of the subtrans log */
+- slotno = ZeroSUBTRANSPage(0);
++ slotno = ZeroSUBTRANSPage(pageno);
+
+ /* Make sure it's written out */
+ SimpleLruWritePage(SubTransCtl, slotno);
+@@ -341,9 +346,6 @@ StartupSUBTRANS(TransactionId oldestActiveXID)
+ break;
+
+ startPage++;
+- /* must account for wraparound */
+- if (startPage > TransactionIdToPage(MaxTransactionId))
+- startPage = 0;
+ }
+
+ LWLockRelease(lock);
+@@ -421,6 +423,7 @@ TruncateSUBTRANS(TransactionId oldestXact)
+ * a page and oldestXact == next XID. In that case, if we didn't subtract
+ * one, we'd trigger SimpleLruTruncate's wraparound detection.
+ */
++
+ TransactionIdRetreat(oldestXact);
+ cutoffPage = TransactionIdToPage(oldestXact);
+
+diff --git a/src/backend/access/transam/transam.c b/src/backend/access/transam/transam.c
+index bf3e5ac3272..63e06177146 100644
+--- a/src/backend/access/transam/transam.c
++++ b/src/backend/access/transam/transam.c
+@@ -281,14 +281,14 @@ TransactionIdPrecedes(TransactionId id1, TransactionId id2)
+ {
+ /*
+ * If either ID is a permanent XID then we can just do unsigned
+- * comparison. If both are normal, do a modulo-2^32 comparison.
++ * comparison. If both are normal, do a modulo-2^64 comparison.
+ */
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 < id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff < 0);
+ }
+
+@@ -298,12 +298,12 @@ TransactionIdPrecedes(TransactionId id1, TransactionId id2)
+ bool
+ TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
+ {
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 <= id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff <= 0);
+ }
+
+@@ -313,12 +313,12 @@ TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
+ bool
+ TransactionIdFollows(TransactionId id1, TransactionId id2)
+ {
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 > id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff > 0);
+ }
+
+@@ -328,12 +328,12 @@ TransactionIdFollows(TransactionId id1, TransactionId id2)
+ bool
+ TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
+ {
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 >= id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff >= 0);
+ }
+
+diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
+index 020ed6072d9..578eff7aac2 100644
+--- a/src/backend/access/transam/twophase.c
++++ b/src/backend/access/transam/twophase.c
+@@ -458,8 +458,8 @@ MarkAsPreparingGuts(GlobalTransaction gxact, TransactionId xid, const char *gid,
+ proc->vxid.lxid = xid;
+ proc->vxid.procNumber = INVALID_PROC_NUMBER;
+ }
+- proc->xid = xid;
+- Assert(proc->xmin == InvalidTransactionId);
++ pg_atomic_write_u64(&proc->xid, xid);
++ Assert(pg_atomic_read_u64(&proc->xmin) == InvalidTransactionId);
+ proc->delayChkptFlags = 0;
+ proc->statusFlags = 0;
+ proc->pid = 0;
+@@ -774,7 +774,7 @@ pg_prepared_xact(PG_FUNCTION_ARGS)
+ * Form tuple with appropriate data.
+ */
+
+- values[0] = TransactionIdGetDatum(proc->xid);
++ values[0] = TransactionIdGetDatum(pg_atomic_read_u64(&proc->xid));
+ values[1] = CStringGetTextDatum(gxact->gid);
+ values[2] = TimestampTzGetDatum(gxact->prepared_at);
+ values[3] = ObjectIdGetDatum(gxact->owner);
+@@ -927,46 +927,8 @@ TwoPhaseGetDummyProc(TransactionId xid, bool lock_held)
+ /* State file support */
+ /************************************************************************/
+
+-/*
+- * Compute the FullTransactionId for the given TransactionId.
+- *
+- * The wrap logic is safe here because the span of active xids cannot exceed one
+- * epoch at any given time.
+- */
+-static inline FullTransactionId
+-AdjustToFullTransactionId(TransactionId xid)
+-{
+- FullTransactionId nextFullXid;
+- TransactionId nextXid;
+- uint32 epoch;
+-
+- Assert(TransactionIdIsValid(xid));
+-
+- LWLockAcquire(XidGenLock, LW_SHARED);
+- nextFullXid = TransamVariables->nextXid;
+- LWLockRelease(XidGenLock);
+-
+- nextXid = XidFromFullTransactionId(nextFullXid);
+- epoch = EpochFromFullTransactionId(nextFullXid);
+- if (unlikely(xid > nextXid))
+- {
+- /* Wraparound occurred, must be from a prev epoch. */
+- Assert(epoch > 0);
+- epoch--;
+- }
+-
+- return FullTransactionIdFromEpochAndXid(epoch, xid);
+-}
+-
+-static inline int
+-TwoPhaseFilePath(char *path, TransactionId xid)
+-{
+- FullTransactionId fxid = AdjustToFullTransactionId(xid);
+-
+- return snprintf(path, MAXPGPATH, TWOPHASE_DIR "/%08X%08X",
+- EpochFromFullTransactionId(fxid),
+- XidFromFullTransactionId(fxid));
+-}
++#define TwoPhaseFilePath(path, xid) \
++ snprintf(path, MAXPGPATH, TWOPHASE_DIR "/%016llX", (unsigned long long) xid)
+
+ /*
+ * 2PC state file format:
+@@ -1915,11 +1877,9 @@ restoreTwoPhaseData(void)
+ strspn(clde->d_name, "0123456789ABCDEF") == 16)
+ {
+ TransactionId xid;
+- FullTransactionId fxid;
+ char *buf;
+
+- fxid = FullTransactionIdFromU64(strtou64(clde->d_name, NULL, 16));
+- xid = XidFromFullTransactionId(fxid);
++ xid = (TransactionId) strtou64(clde->d_name, NULL, 16);
+
+ buf = ProcessTwoPhaseBuffer(xid, InvalidXLogRecPtr,
+ true, false, false);
+@@ -2250,7 +2210,6 @@ ProcessTwoPhaseBuffer(TransactionId xid,
+
+ if (fromdisk)
+ {
+- /* Read and validate file */
+ buf = ReadTwoPhaseFile(xid, false);
+ }
+ else
+@@ -2725,7 +2684,7 @@ IsTwoPhaseTransactionGidForSubid(Oid subid, char *gid)
+ char gid_tmp[GIDSIZE];
+
+ /* Extract the subid and xid from the given GID */
+- ret = sscanf(gid, "pg_gid_%u_%u", &subid_from_gid, &xid_from_gid);
++ ret = sscanf(gid, "pg_gid_%u_%lu", &subid_from_gid, &xid_from_gid);
+
+ /*
+ * Check that the given GID has expected format, and at least the subid
+diff --git a/src/backend/access/transam/varsup.c b/src/backend/access/transam/varsup.c
+index e595eb1ad9f..9eb88888732 100644
+--- a/src/backend/access/transam/varsup.c
++++ b/src/backend/access/transam/varsup.c
+@@ -93,9 +93,9 @@ GetNewTransactionId(bool isSubXact)
+ if (IsBootstrapProcessingMode())
+ {
+ Assert(!isSubXact);
+- MyProc->xid = BootstrapTransactionId;
+- ProcGlobal->xids[MyProc->pgxactoff] = BootstrapTransactionId;
+- return FullTransactionIdFromEpochAndXid(0, BootstrapTransactionId);
++ pg_atomic_write_u64(&MyProc->xid, BootstrapTransactionId);
++ pg_atomic_write_u64(&ProcGlobal->xids[MyProc->pgxactoff], BootstrapTransactionId);
++ return FullTransactionIdFromXid(BootstrapTransactionId);
+ }
+
+ /* safety check, we should never get this far in a HS standby */
+@@ -107,19 +107,6 @@ GetNewTransactionId(bool isSubXact)
+ full_xid = TransamVariables->nextXid;
+ xid = XidFromFullTransactionId(full_xid);
+
+- /*----------
+- * Check to see if it's safe to assign another XID. This protects against
+- * catastrophic data loss due to XID wraparound. The basic rules are:
+- *
+- * If we're past xidVacLimit, start trying to force autovacuum cycles.
+- * If we're past xidWarnLimit, start issuing warnings.
+- * If we're past xidStopLimit, refuse to execute transactions, unless
+- * we are running in single-user mode (which gives an escape hatch
+- * to the DBA who somehow got past the earlier defenses).
+- *
+- * Note that this coding also appears in GetNewMultiXactId.
+- *----------
+- */
+ if (TransactionIdFollowsOrEquals(xid, TransamVariables->xidVacLimit))
+ {
+ /*
+@@ -129,11 +116,6 @@ GetNewTransactionId(bool isSubXact)
+ * possibility of deadlock while doing get_database_name(). First,
+ * copy all the shared values we'll need in this path.
+ */
+- TransactionId xidWarnLimit = TransamVariables->xidWarnLimit;
+- TransactionId xidStopLimit = TransamVariables->xidStopLimit;
+- TransactionId xidWrapLimit = TransamVariables->xidWrapLimit;
+- Oid oldest_datoid = TransamVariables->oldestXidDB;
+-
+ LWLockRelease(XidGenLock);
+
+ /*
+@@ -144,48 +126,6 @@ GetNewTransactionId(bool isSubXact)
+ if (IsUnderPostmaster && (xid % 65536) == 0)
+ SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+
+- if (IsUnderPostmaster &&
+- TransactionIdFollowsOrEquals(xid, xidStopLimit))
+- {
+- char *oldest_datname = get_database_name(oldest_datoid);
+-
+- /* complain even if that DB has disappeared */
+- if (oldest_datname)
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("database is not accepting commands that assign new transaction IDs to avoid wraparound data loss in database \"%s\"",
+- oldest_datname),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("database is not accepting commands that assign new transaction IDs to avoid wraparound data loss in database with OID %u",
+- oldest_datoid),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+- else if (TransactionIdFollowsOrEquals(xid, xidWarnLimit))
+- {
+- char *oldest_datname = get_database_name(oldest_datoid);
+-
+- /* complain even if that DB has disappeared */
+- if (oldest_datname)
+- ereport(WARNING,
+- (errmsg("database \"%s\" must be vacuumed within %llu transactions",
+- oldest_datname,
+- (unsigned long long) xidWrapLimit - xid),
+- errhint("To avoid transaction ID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(WARNING,
+- (errmsg("database with OID %u must be vacuumed within %llu transactions",
+- oldest_datoid,
+- (unsigned long long) xidWrapLimit - xid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+-
+ /* Re-acquire lock and start over */
+ LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
+ full_xid = TransamVariables->nextXid;
+@@ -255,8 +195,8 @@ GetNewTransactionId(bool isSubXact)
+ Assert(!MyProc->subxidStatus.overflowed);
+
+ /* LWLockRelease acts as barrier */
+- MyProc->xid = xid;
+- ProcGlobal->xids[MyProc->pgxactoff] = xid;
++ pg_atomic_write_u64(&MyProc->xid, xid);
++ pg_atomic_write_u64(&ProcGlobal->xids[MyProc->pgxactoff], xid);
+ }
+ else
+ {
+@@ -297,7 +237,7 @@ ReadNextFullTransactionId(void)
+ }
+
+ /*
+- * Advance nextXid to the value after a given xid. The epoch is inferred.
++ * Advance nextXid to the value after a given xid.
+ * This must only be called during recovery or from two-phase start-up code.
+ */
+ void
+@@ -305,7 +245,6 @@ AdvanceNextFullTransactionIdPastXid(TransactionId xid)
+ {
+ FullTransactionId newNextFullXid;
+ TransactionId next_xid;
+- uint32 epoch;
+
+ /*
+ * It is safe to read nextXid without a lock, because this is only called
+@@ -319,19 +258,9 @@ AdvanceNextFullTransactionIdPastXid(TransactionId xid)
+ if (!TransactionIdFollowsOrEquals(xid, next_xid))
+ return;
+
+- /*
+- * Compute the FullTransactionId that comes after the given xid. To do
+- * this, we preserve the existing epoch, but detect when we've wrapped
+- * into a new epoch. This is necessary because WAL records and 2PC state
+- * currently contain 32 bit xids. The wrap logic is safe in those cases
+- * because the span of active xids cannot exceed one epoch at any given
+- * point in the WAL stream.
+- */
++ /* Compute the FullTransactionId that comes after the given xid. */
+ TransactionIdAdvance(xid);
+- epoch = EpochFromFullTransactionId(TransamVariables->nextXid);
+- if (unlikely(xid < next_xid))
+- ++epoch;
+- newNextFullXid = FullTransactionIdFromEpochAndXid(epoch, xid);
++ newNextFullXid = FullTransactionIdFromXid(xid);
+
+ /*
+ * We still need to take a lock to modify the value when there are
+@@ -372,61 +301,14 @@ void
+ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+ {
+ TransactionId xidVacLimit;
+- TransactionId xidWarnLimit;
+- TransactionId xidStopLimit;
+- TransactionId xidWrapLimit;
+ TransactionId curXid;
+
+ Assert(TransactionIdIsNormal(oldest_datfrozenxid));
+
+- /*
+- * The place where we actually get into deep trouble is halfway around
+- * from the oldest potentially-existing XID. (This calculation is
+- * probably off by one or two counts, because the special XIDs reduce the
+- * size of the loop a little bit. But we throw in plenty of slop below,
+- * so it doesn't matter.)
+- */
+- xidWrapLimit = oldest_datfrozenxid + (MaxTransactionId >> 1);
+- if (xidWrapLimit < FirstNormalTransactionId)
+- xidWrapLimit += FirstNormalTransactionId;
+-
+- /*
+- * We'll refuse to continue assigning XIDs in interactive mode once we get
+- * within 3M transactions of data loss. This leaves lots of room for the
+- * DBA to fool around fixing things in a standalone backend, while not
+- * being significant compared to total XID space. (VACUUM requires an XID
+- * if it truncates at wal_level!=minimal. "VACUUM (ANALYZE)", which a DBA
+- * might do by reflex, assigns an XID. Hence, we had better be sure
+- * there's lots of XIDs left...) Also, at default BLCKSZ, this leaves two
+- * completely-idle segments. In the event of edge-case bugs involving
+- * page or segment arithmetic, idle segments render the bugs unreachable
+- * outside of single-user mode.
+- */
+- xidStopLimit = xidWrapLimit - 3000000;
+- if (xidStopLimit < FirstNormalTransactionId)
+- xidStopLimit -= FirstNormalTransactionId;
+-
+- /*
+- * We'll start complaining loudly when we get within 40M transactions of
+- * data loss. This is kind of arbitrary, but if you let your gas gauge
+- * get down to 2% of full, would you be looking for the next gas station?
+- * We need to be fairly liberal about this number because there are lots
+- * of scenarios where most transactions are done by automatic clients that
+- * won't pay attention to warnings. (No, we're not gonna make this
+- * configurable. If you know enough to configure it, you know enough to
+- * not get in this kind of trouble in the first place.)
+- */
+- xidWarnLimit = xidWrapLimit - 40000000;
+- if (xidWarnLimit < FirstNormalTransactionId)
+- xidWarnLimit -= FirstNormalTransactionId;
+-
+ /*
+ * We'll start trying to force autovacuums when oldest_datfrozenxid gets
+ * to be more than autovacuum_freeze_max_age transactions old.
+ *
+- * Note: guc.c ensures that autovacuum_freeze_max_age is in a sane range,
+- * so that xidVacLimit will be well before xidWarnLimit.
+- *
+ * Note: autovacuum_freeze_max_age is a PGC_POSTMASTER parameter so that
+ * we don't have to worry about dealing with on-the-fly changes in its
+ * value. It doesn't look practical to update shared state from a GUC
+@@ -443,18 +325,10 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+ LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
+ TransamVariables->oldestXid = oldest_datfrozenxid;
+ TransamVariables->xidVacLimit = xidVacLimit;
+- TransamVariables->xidWarnLimit = xidWarnLimit;
+- TransamVariables->xidStopLimit = xidStopLimit;
+- TransamVariables->xidWrapLimit = xidWrapLimit;
+ TransamVariables->oldestXidDB = oldest_datoid;
+ curXid = XidFromFullTransactionId(TransamVariables->nextXid);
+ LWLockRelease(XidGenLock);
+
+- /* Log the info */
+- ereport(DEBUG1,
+- (errmsg_internal("transaction ID wrap limit is %llu, limited by database with OID %u",
+- (unsigned long long) xidWrapLimit, oldest_datoid)));
+-
+ /*
+ * If past the autovacuum force point, immediately signal an autovac
+ * request. The reason for this is that autovac only processes one
+@@ -465,41 +339,6 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+ if (TransactionIdFollowsOrEquals(curXid, xidVacLimit) &&
+ IsUnderPostmaster && !InRecovery)
+ SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+-
+- /* Give an immediate warning if past the wrap warn point */
+- if (TransactionIdFollowsOrEquals(curXid, xidWarnLimit) && !InRecovery)
+- {
+- char *oldest_datname;
+-
+- /*
+- * We can be called when not inside a transaction, for example during
+- * StartupXLOG(). In such a case we cannot do database access, so we
+- * must just report the oldest DB's OID.
+- *
+- * Note: it's also possible that get_database_name fails and returns
+- * NULL, for example because the database just got dropped. We'll
+- * still warn, even though the warning might now be unnecessary.
+- */
+- if (IsTransactionState())
+- oldest_datname = get_database_name(oldest_datoid);
+- else
+- oldest_datname = NULL;
+-
+- if (oldest_datname)
+- ereport(WARNING,
+- (errmsg("database \"%s\" must be vacuumed within %llu transactions",
+- oldest_datname,
+- (unsigned long long) xidWrapLimit - curXid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(WARNING,
+- (errmsg("database with OID %u must be vacuumed within %llu transactions",
+- oldest_datoid,
+- (unsigned long long) xidWrapLimit - curXid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+ }
+
+
+diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
+index 984324bdd3e..c2a879cc2ca 100644
+--- a/src/backend/access/transam/xact.c
++++ b/src/backend/access/transam/xact.c
+@@ -5866,6 +5866,17 @@ XactLogCommitRecord(TimestampTz commit_time,
+ xl_subxacts.nsubxacts = nsubxacts;
+ }
+
++ if (TransactionIdIsValid(twophase_xid))
++ {
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
++ xl_twophase.xid_lo = (uint32) (twophase_xid & 0xFFFFFFFF);
++ xl_twophase.xid_hi = (uint32) (twophase_xid >> 32);
++ Assert(twophase_gid != NULL);
++
++ if (XLogLogicalInfoActive())
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
++ }
++
+ if (nrels > 0)
+ {
+ xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
+@@ -5885,16 +5896,6 @@ XactLogCommitRecord(TimestampTz commit_time,
+ xl_invals.nmsgs = nmsgs;
+ }
+
+- if (TransactionIdIsValid(twophase_xid))
+- {
+- xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
+- xl_twophase.xid = twophase_xid;
+- Assert(twophase_gid != NULL);
+-
+- if (XLogLogicalInfoActive())
+- xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
+- }
+-
+ /* dump transaction origin information */
+ if (replorigin_session_origin != InvalidRepOriginId)
+ {
+@@ -6015,6 +6016,17 @@ XactLogAbortRecord(TimestampTz abort_time,
+ xl_subxacts.nsubxacts = nsubxacts;
+ }
+
++ if (TransactionIdIsValid(twophase_xid))
++ {
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
++ xl_twophase.xid_lo = (uint32) (twophase_xid & 0xFFFFFFFF);
++ xl_twophase.xid_hi = (uint32) (twophase_xid >> 32);
++ Assert(twophase_gid != NULL);
++
++ if (XLogLogicalInfoActive())
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
++ }
++
+ if (nrels > 0)
+ {
+ xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
+@@ -6031,7 +6043,8 @@ XactLogAbortRecord(TimestampTz abort_time,
+ if (TransactionIdIsValid(twophase_xid))
+ {
+ xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
+- xl_twophase.xid = twophase_xid;
++ xl_twophase.xid_lo = (uint32) (twophase_xid & 0xFFFFFFFF);
++ xl_twophase.xid_hi = (uint32) (twophase_xid >> 32);
+ Assert(twophase_gid != NULL);
+
+ if (XLogLogicalInfoActive())
+diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
+index 6f58412bcab..51cc3bd62aa 100644
+--- a/src/backend/access/transam/xlog.c
++++ b/src/backend/access/transam/xlog.c
+@@ -5079,8 +5079,7 @@ BootStrapXLOG(uint32 data_checksum_version)
+ checkPoint.PrevTimeLineID = BootstrapTimeLineID;
+ checkPoint.fullPageWrites = fullPageWrites;
+ checkPoint.wal_level = wal_level;
+- checkPoint.nextXid =
+- FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
++ checkPoint.nextXid = FullTransactionIdFromXid(FirstNormalTransactionId);
+ checkPoint.nextOid = FirstGenbkiObjectId;
+ checkPoint.nextMulti = FirstMultiXactId;
+ checkPoint.nextMultiOffset = 0;
+@@ -7268,7 +7267,7 @@ CreateCheckPoint(int flags)
+ UpdateControlFile();
+ LWLockRelease(ControlFileLock);
+
+- /* Update shared-memory copy of checkpoint XID/epoch */
++ /* Update shared-memory copy of checkpoint XID/base */
+ SpinLockAcquire(&XLogCtl->info_lck);
+ XLogCtl->ckptFullXid = checkPoint.nextXid;
+ SpinLockRelease(&XLogCtl->info_lck);
+@@ -8342,7 +8341,7 @@ xlog_redo(XLogReaderState *record)
+ ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
+ LWLockRelease(ControlFileLock);
+
+- /* Update shared-memory copy of checkpoint XID/epoch */
++ /* Update shared-memory copy of checkpoint XID/base */
+ SpinLockAcquire(&XLogCtl->info_lck);
+ XLogCtl->ckptFullXid = checkPoint.nextXid;
+ SpinLockRelease(&XLogCtl->info_lck);
+@@ -8403,7 +8402,7 @@ xlog_redo(XLogReaderState *record)
+ ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
+ LWLockRelease(ControlFileLock);
+
+- /* Update shared-memory copy of checkpoint XID/epoch */
++ /* Update shared-memory copy of checkpoint XID/base */
+ SpinLockAcquire(&XLogCtl->info_lck);
+ XLogCtl->ckptFullXid = checkPoint.nextXid;
+ SpinLockRelease(&XLogCtl->info_lck);
+diff --git a/src/backend/access/transam/xloginsert.c b/src/backend/access/transam/xloginsert.c
+index f92d0626082..0625e420724 100644
+--- a/src/backend/access/transam/xloginsert.c
++++ b/src/backend/access/transam/xloginsert.c
+@@ -273,6 +273,11 @@ XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
+ BufferGetTag(buffer, ®buf->rlocator, ®buf->forkno, ®buf->block);
+ regbuf->page = BufferGetPage(buffer);
+ regbuf->flags = flags;
++ if (IsBufferConverted(buffer))
++ {
++ regbuf->flags |= REGBUF_CONVERTED;
++ MarkBufferConverted(buffer, false);
++ }
+ regbuf->rdata_tail = (XLogRecData *) ®buf->rdata_head;
+ regbuf->rdata_len = 0;
+
+@@ -606,6 +611,8 @@ XLogRecordAssemble(RmgrId rmid, uint8 info,
+ needs_backup = true;
+ else if (regbuf->flags & REGBUF_NO_IMAGE)
+ needs_backup = false;
++ else if (regbuf->flags & REGBUF_CONVERTED)
++ needs_backup = true;
+ else if (!doPageWrites)
+ needs_backup = false;
+ else
+diff --git a/src/backend/access/transam/xlogreader.c b/src/backend/access/transam/xlogreader.c
+index 0c5e040a946..556e815655e 100644
+--- a/src/backend/access/transam/xlogreader.c
++++ b/src/backend/access/transam/xlogreader.c
+@@ -2157,37 +2157,3 @@ RestoreBlockImage(XLogReaderState *record, uint8 block_id, char *page)
+
+ return true;
+ }
+-
+-#ifndef FRONTEND
+-
+-/*
+- * Extract the FullTransactionId from a WAL record.
+- */
+-FullTransactionId
+-XLogRecGetFullXid(XLogReaderState *record)
+-{
+- TransactionId xid,
+- next_xid;
+- uint32 epoch;
+-
+- /*
+- * This function is only safe during replay, because it depends on the
+- * replay state. See AdvanceNextFullTransactionIdPastXid() for more.
+- */
+- Assert(AmStartupProcess() || !IsUnderPostmaster);
+-
+- xid = XLogRecGetXid(record);
+- next_xid = XidFromFullTransactionId(TransamVariables->nextXid);
+- epoch = EpochFromFullTransactionId(TransamVariables->nextXid);
+-
+- /*
+- * If xid is numerically greater than next_xid, it has to be from the last
+- * epoch.
+- */
+- if (unlikely(xid > next_xid))
+- --epoch;
+-
+- return FullTransactionIdFromEpochAndXid(epoch, xid);
+-}
+-
+-#endif
+diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c
+index d31a67599c9..1c7a0c9b3e6 100644
+--- a/src/backend/bootstrap/bootstrap.c
++++ b/src/backend/bootstrap/bootstrap.c
+@@ -115,7 +115,7 @@ static const struct typinfo TypInfo[] = {
+ F_OIDIN, F_OIDOUT},
+ {"tid", TIDOID, 0, 6, false, TYPALIGN_SHORT, TYPSTORAGE_PLAIN, InvalidOid,
+ F_TIDIN, F_TIDOUT},
+- {"xid", XIDOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
++ {"xid", XIDOID, 0, 8, FLOAT8PASSBYVAL, TYPALIGN_XID, TYPSTORAGE_PLAIN, InvalidOid,
+ F_XIDIN, F_XIDOUT},
+ {"cid", CIDOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
+ F_CIDIN, F_CIDOUT},
+diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
+index d7b88b61dcc..466e2544e0e 100644
+--- a/src/backend/catalog/heap.c
++++ b/src/backend/catalog/heap.c
+@@ -160,8 +160,8 @@ static const FormData_pg_attribute a2 = {
+ .attnum = MinTransactionIdAttributeNumber,
+ .attcacheoff = -1,
+ .atttypmod = -1,
+- .attbyval = true,
+- .attalign = TYPALIGN_INT,
++ .attbyval = FLOAT8PASSBYVAL,
++ .attalign = TYPALIGN_XID,
+ .attstorage = TYPSTORAGE_PLAIN,
+ .attnotnull = true,
+ .attislocal = true,
+@@ -188,8 +188,8 @@ static const FormData_pg_attribute a4 = {
+ .attnum = MaxTransactionIdAttributeNumber,
+ .attcacheoff = -1,
+ .atttypmod = -1,
+- .attbyval = true,
+- .attalign = TYPALIGN_INT,
++ .attbyval = FLOAT8PASSBYVAL,
++ .attalign = TYPALIGN_XID,
+ .attstorage = TYPSTORAGE_PLAIN,
+ .attnotnull = true,
+ .attislocal = true,
+diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
+index 836b4bfd894..03756402272 100644
+--- a/src/backend/catalog/pg_inherits.c
++++ b/src/backend/catalog/pg_inherits.c
+@@ -145,7 +145,7 @@ find_inheritance_children_extended(Oid parentrelId, bool omit_detached,
+ TransactionId xmin;
+ Snapshot snap;
+
+- xmin = HeapTupleHeaderGetXmin(inheritsTuple->t_data);
++ xmin = HeapTupleGetXmin(inheritsTuple);
+ snap = GetActiveSnapshot();
+
+ if (!XidInMVCCSnapshot(xmin, snap))
+diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
+index 8ed503e1c1b..029fbed1c12 100644
+--- a/src/backend/commands/async.c
++++ b/src/backend/commands/async.c
+@@ -184,7 +184,7 @@ typedef struct AsyncQueueEntry
+ } AsyncQueueEntry;
+
+ /* Currently, no field of AsyncQueueEntry requires more than int alignment */
+-#define QUEUEALIGN(len) INTALIGN(len)
++#define QUEUEALIGN(len) TYPEALIGN(8, len)
+
+ #define AsyncQueueEntryEmptySize (offsetof(AsyncQueueEntry, data) + 2)
+
+diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c
+index aa91a396967..6ebc8b7483c 100644
+--- a/src/backend/commands/dbcommands.c
++++ b/src/backend/commands/dbcommands.c
+@@ -129,7 +129,8 @@ static void CreateDatabaseUsingWalLog(Oid src_dboid, Oid dst_dboid, Oid src_tsid
+ static List *ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath);
+ static List *ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid,
+ Oid dbid, char *srcpath,
+- List *rlocatorlist, Snapshot snapshot);
++ List *rlocatorlist, Snapshot snapshot,
++ bool is_toast);
+ static CreateDBRelInfo *ScanSourceDatabasePgClassTuple(HeapTupleData *tuple,
+ Oid tbid, Oid dbid,
+ char *srcpath);
+@@ -307,9 +308,10 @@ ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath)
+ }
+
+ /* Append relevant pg_class tuples for current page to rlocatorlist. */
++ /* No toast is expected in sys tables */
+ rlocatorlist = ScanSourceDatabasePgClassPage(page, buf, tbid, dbid,
+ srcpath, rlocatorlist,
+- snapshot);
++ snapshot, false);
+
+ UnlockReleaseBuffer(buf);
+ }
+@@ -327,7 +329,7 @@ ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath)
+ static List *
+ ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid, Oid dbid,
+ char *srcpath, List *rlocatorlist,
+- Snapshot snapshot)
++ Snapshot snapshot, bool is_toast)
+ {
+ BlockNumber blkno = BufferGetBlockNumber(buf);
+ OffsetNumber offnum;
+@@ -357,6 +359,7 @@ ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid, Oid dbid,
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationRelationId;
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, is_toast);
+
+ /* Skip tuples that are not visible to this snapshot. */
+ if (HeapTupleSatisfiesVisibility(&tuple, snapshot, buf))
+diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
+index 4049ce1a10f..0c1d634348f 100644
+--- a/src/backend/commands/indexcmds.c
++++ b/src/backend/commands/indexcmds.c
+@@ -1758,7 +1758,7 @@ DefineIndex(Oid tableId,
+ set_indexsafe_procflags();
+
+ /* We should now definitely not be advertising any xmin. */
+- Assert(MyProc->xmin == InvalidTransactionId);
++ Assert(pg_atomic_read_u64(&MyProc->xmin) == InvalidTransactionId);
+
+ /*
+ * The index is now valid in the sense that it contains all currently
+@@ -4593,8 +4593,8 @@ set_indexsafe_procflags(void)
+ * This should only be called before installing xid or xmin in MyProc;
+ * otherwise, concurrent processes could see an Xmin that moves backwards.
+ */
+- Assert(MyProc->xid == InvalidTransactionId &&
+- MyProc->xmin == InvalidTransactionId);
++ Assert(pg_atomic_read_u64(&MyProc->xid) == InvalidTransactionId &&
++ pg_atomic_read_u64(&MyProc->xmin) == InvalidTransactionId);
+
+ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
+ MyProc->statusFlags |= PROC_IN_SAFE_IC;
+diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
+index 0188e8bbd5b..1855b2ef4ef 100644
+--- a/src/backend/commands/sequence.c
++++ b/src/backend/commands/sequence.c
+@@ -49,6 +49,25 @@
+ #include "utils/syscache.h"
+ #include "utils/varlena.h"
+
++static inline void
++SeqTupleSetXmin(HeapTuple htup, TransactionId xid)
++{
++ htup->t_xmin = xid;
++ htup->t_data->t_choice.t_heap.t_xmin = xid;
++}
++
++static inline void
++SeqTupleSetXmax(HeapTuple htup, TransactionId xid)
++{
++ htup->t_xmin = xid;
++ htup->t_data->t_choice.t_heap.t_xmax = xid;
++}
++
++static inline TransactionId
++SeqTupleHeaderGetRawXmax(HeapTupleHeader htup)
++{
++ return htup->t_choice.t_heap.t_xmax;
++}
+
+ /*
+ * We don't want to log each fetching of a value from a sequence,
+@@ -384,10 +403,10 @@ fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNumber forkNum)
+ * because if the current transaction aborts, no other xact will ever
+ * examine the sequence tuple anyway.
+ */
+- HeapTupleHeaderSetXmin(tuple->t_data, FrozenTransactionId);
+- HeapTupleHeaderSetXminFrozen(tuple->t_data);
++ SeqTupleSetXmin(tuple, FrozenTransactionId);
++ HeapTupleHeaderStoreXminFrozen(tuple->t_data);
+ HeapTupleHeaderSetCmin(tuple->t_data, FirstCommandId);
+- HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId);
++ SeqTupleSetXmax(tuple, InvalidTransactionId);
+ tuple->t_data->t_infomask |= HEAP_XMAX_INVALID;
+ ItemPointerSet(&tuple->t_data->t_ctid, 0, FirstOffsetNumber);
+
+@@ -1210,6 +1229,7 @@ read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple)
+ /* Note we currently only bother to set these two fields of *seqdatatuple */
+ seqdatatuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ seqdatatuple->t_len = ItemIdGetLength(lp);
++ HeapTupleCopyHeaderXids(seqdatatuple);
+
+ /*
+ * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE on
+@@ -1220,9 +1240,9 @@ read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple)
+ * this again if the update gets lost.
+ */
+ Assert(!(seqdatatuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI));
+- if (HeapTupleHeaderGetRawXmax(seqdatatuple->t_data) != InvalidTransactionId)
++ if (SeqTupleHeaderGetRawXmax(seqdatatuple->t_data) != InvalidTransactionId)
+ {
+- HeapTupleHeaderSetXmax(seqdatatuple->t_data, InvalidTransactionId);
++ SeqTupleSetXmax(seqdatatuple, InvalidTransactionId);
+ seqdatatuple->t_data->t_infomask &= ~HEAP_XMAX_COMMITTED;
+ seqdatatuple->t_data->t_infomask |= HEAP_XMAX_INVALID;
+ MarkBufferDirtyHint(*buf, true);
+diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
+index 42c3db546c7..5a72bd1a8ad 100644
+--- a/src/backend/commands/vacuum.c
++++ b/src/backend/commands/vacuum.c
+@@ -63,12 +63,12 @@
+ /*
+ * GUC parameters
+ */
+-int vacuum_freeze_min_age;
+-int vacuum_freeze_table_age;
+-int vacuum_multixact_freeze_min_age;
+-int vacuum_multixact_freeze_table_age;
+-int vacuum_failsafe_age;
+-int vacuum_multixact_failsafe_age;
++int64 vacuum_freeze_min_age;
++int64 vacuum_freeze_table_age;
++int64 vacuum_multixact_freeze_min_age;
++int64 vacuum_multixact_freeze_table_age;
++int64 vacuum_failsafe_age;
++int64 vacuum_multixact_failsafe_age;
+
+ /*
+ * Variables for cost-based vacuum delay. The defaults differ between
+@@ -1084,7 +1084,7 @@ bool
+ vacuum_get_cutoffs(Relation rel, const VacuumParams *params,
+ struct VacuumCutoffs *cutoffs)
+ {
+- int freeze_min_age,
++ int64 freeze_min_age,
+ multixact_freeze_min_age,
+ freeze_table_age,
+ multixact_freeze_table_age,
+@@ -1500,6 +1500,9 @@ vac_update_relstats(Relation relation,
+ futurexid = false;
+ if (frozenxid_updated)
+ *frozenxid_updated = false;
++
++ Assert(TransactionIdPrecedesOrEquals(frozenxid, ReadNextTransactionId()));
++
+ if (TransactionIdIsNormal(frozenxid) && oldfrozenxid != frozenxid)
+ {
+ bool update = false;
+@@ -1523,6 +1526,9 @@ vac_update_relstats(Relation relation,
+ futuremxid = false;
+ if (minmulti_updated)
+ *minmulti_updated = false;
++
++ Assert(MultiXactIdPrecedesOrEquals(minmulti, ReadNextMultiXactId()));
++
+ if (MultiXactIdIsValid(minmulti) && oldminmulti != minmulti)
+ {
+ bool update = false;
+diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
+index bad7b195bfb..e81d7bd4cd9 100644
+--- a/src/backend/executor/execExprInterp.c
++++ b/src/backend/executor/execExprInterp.c
+@@ -3456,6 +3456,7 @@ ExecEvalFieldStoreDeForm(ExprState *state, ExprEvalStep *op, ExprContext *econte
+ tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tmptup);
+ tmptup.t_data = tuphdr;
+
+ /*
+diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
+index 00dc3396156..101c6bc6013 100644
+--- a/src/backend/executor/execTuples.c
++++ b/src/backend/executor/execTuples.c
+@@ -389,7 +389,7 @@ tts_heap_is_current_xact_tuple(TupleTableSlot *slot)
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("don't have a storage tuple in this context")));
+
+- xmin = HeapTupleHeaderGetRawXmin(hslot->tuple->t_data);
++ xmin = HeapTupleGetRawXmin(hslot->tuple);
+
+ return TransactionIdIsCurrentTransactionId(xmin);
+ }
+@@ -793,7 +793,7 @@ tts_buffer_is_current_xact_tuple(TupleTableSlot *slot)
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("don't have a storage tuple in this context")));
+
+- xmin = HeapTupleHeaderGetRawXmin(bslot->base.tuple->t_data);
++ xmin = HeapTupleGetRawXmin(bslot->base.tuple);
+
+ return TransactionIdIsCurrentTransactionId(xmin);
+ }
+diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
+index 740e8fb1486..47a6bea20ea 100644
+--- a/src/backend/executor/execUtils.c
++++ b/src/backend/executor/execUtils.c
+@@ -1044,6 +1044,7 @@ GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)
+ tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tmptup);
+ tmptup.t_data = tuple;
+
+ result = heap_getattr(&tmptup,
+diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
+index 1161520f76b..58452cdc801 100644
+--- a/src/backend/executor/nodeModifyTable.c
++++ b/src/backend/executor/nodeModifyTable.c
+@@ -4110,6 +4110,7 @@ ExecModifyTable(PlanState *pstate)
+ HeapTupleHeaderGetDatumLength(oldtupdata.t_data);
+ ItemPointerSetInvalid(&(oldtupdata.t_self));
+ /* Historically, view triggers see invalid t_tableOid. */
++ HeapTupleCopyHeaderXids(&oldtupdata);
+ oldtupdata.t_tableOid =
+ (relkind == RELKIND_VIEW) ? InvalidOid :
+ RelationGetRelid(resultRelInfo->ri_RelationDesc);
+diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c
+index 2fb2e73604e..b9495e78e12 100644
+--- a/src/backend/executor/spi.c
++++ b/src/backend/executor/spi.c
+@@ -1156,6 +1156,7 @@ SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum,
+ mtuple->t_data->t_ctid = tuple->t_data->t_ctid;
+ mtuple->t_self = tuple->t_self;
+ mtuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(mtuple, tuple);
+ }
+ else
+ {
+diff --git a/src/backend/nodes/gen_node_support.pl b/src/backend/nodes/gen_node_support.pl
+index 81df3bdf95f..0e5d432b17a 100644
+--- a/src/backend/nodes/gen_node_support.pl
++++ b/src/backend/nodes/gen_node_support.pl
+@@ -1027,14 +1027,14 @@ _read${n}(void)
+ elsif ($t eq 'uint32'
+ || $t eq 'bits32'
+ || $t eq 'BlockNumber'
+- || $t eq 'Index'
+- || $t eq 'SubTransactionId')
++ || $t eq 'Index')
+ {
+ print $off "\tWRITE_UINT_FIELD($f);\n";
+ print $rff "\tREAD_UINT_FIELD($f);\n" unless $no_read;
+ }
+ elsif ($t eq 'uint64'
+- || $t eq 'AclMode')
++ || $t eq 'AclMode'
++ || $t eq 'SubTransactionId')
+ {
+ print $off "\tWRITE_UINT64_FIELD($f);\n";
+ print $rff "\tREAD_UINT64_FIELD($f);\n" unless $no_read;
+diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
+index 37b0ca2e439..12198f56042 100644
+--- a/src/backend/optimizer/util/plancat.c
++++ b/src/backend/optimizer/util/plancat.c
+@@ -272,7 +272,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
+ * src/backend/access/heap/README.HOT for discussion.
+ */
+ if (index->indcheckxmin &&
+- !TransactionIdPrecedes(HeapTupleHeaderGetXmin(indexRelation->rd_indextuple->t_data),
++ !TransactionIdPrecedes(HeapTupleGetXmin(indexRelation->rd_indextuple),
+ TransactionXmin))
+ {
+ root->glob->transientPlan = true;
+diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
+index 180bb7e96ed..8e91c1ac984 100644
+--- a/src/backend/postmaster/autovacuum.c
++++ b/src/backend/postmaster/autovacuum.c
+@@ -124,8 +124,8 @@ int autovacuum_vac_ins_thresh;
+ double autovacuum_vac_ins_scale;
+ int autovacuum_anl_thresh;
+ double autovacuum_anl_scale;
+-int autovacuum_freeze_max_age;
+-int autovacuum_multixact_freeze_max_age;
++int64 autovacuum_freeze_max_age;
++int64 autovacuum_multixact_freeze_max_age;
+
+ double autovacuum_vac_cost_delay;
+ int autovacuum_vac_cost_limit;
+@@ -156,10 +156,10 @@ static TransactionId recentXid;
+ static MultiXactId recentMulti;
+
+ /* Default freeze ages to use for autovacuum (varies by database) */
+-static int default_freeze_min_age;
+-static int default_freeze_table_age;
+-static int default_multixact_freeze_min_age;
+-static int default_multixact_freeze_table_age;
++static int64 default_freeze_min_age;
++static int64 default_freeze_table_age;
++static int64 default_multixact_freeze_min_age;
++static int64 default_multixact_freeze_table_age;
+
+ /* Memory context for long-lived data */
+ static MemoryContext AutovacMemCxt;
+@@ -329,15 +329,15 @@ static void FreeWorkerInfo(int code, Datum arg);
+
+ static autovac_table *table_recheck_autovac(Oid relid, HTAB *table_toast_map,
+ TupleDesc pg_class_desc,
+- int effective_multixact_freeze_max_age);
++ int64 effective_multixact_freeze_max_age);
+ static void recheck_relation_needs_vacanalyze(Oid relid, AutoVacOpts *avopts,
+ Form_pg_class classForm,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ bool *dovacuum, bool *doanalyze, bool *wraparound);
+ static void relation_needs_vacanalyze(Oid relid, AutoVacOpts *relopts,
+ Form_pg_class classForm,
+ PgStat_StatTabEntry *tabentry,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ bool *dovacuum, bool *doanalyze, bool *wraparound);
+
+ static void autovacuum_do_vac_analyze(autovac_table *tab,
+@@ -1114,11 +1114,10 @@ do_start_worker(void)
+ * particular tables, but not loosened.)
+ */
+ recentXid = ReadNextTransactionId();
+- xidForceLimit = recentXid - autovacuum_freeze_max_age;
+- /* ensure it's a "normal" XID, else TransactionIdPrecedes misbehaves */
+- /* this can cause the limit to go backwards by 3, but that's OK */
+- if (xidForceLimit < FirstNormalTransactionId)
+- xidForceLimit -= FirstNormalTransactionId;
++ if (recentXid > FirstNormalTransactionId + autovacuum_freeze_max_age)
++ xidForceLimit = recentXid - autovacuum_freeze_max_age;
++ else
++ xidForceLimit = FirstNormalTransactionId;
+
+ /* Also determine the oldest datminmxid we will consider. */
+ recentMulti = ReadNextMultiXactId();
+@@ -1886,7 +1885,7 @@ do_autovacuum(void)
+ BufferAccessStrategy bstrategy;
+ ScanKeyData key;
+ TupleDesc pg_class_desc;
+- int effective_multixact_freeze_max_age;
++ int64 effective_multixact_freeze_max_age;
+ bool did_vacuum = false;
+ bool found_concurrent_worker = false;
+ int i;
+@@ -2711,7 +2710,7 @@ extract_autovac_opts(HeapTuple tup, TupleDesc pg_class_desc)
+ static autovac_table *
+ table_recheck_autovac(Oid relid, HTAB *table_toast_map,
+ TupleDesc pg_class_desc,
+- int effective_multixact_freeze_max_age)
++ int64 effective_multixact_freeze_max_age)
+ {
+ Form_pg_class classForm;
+ HeapTuple classTup;
+@@ -2750,10 +2749,10 @@ table_recheck_autovac(Oid relid, HTAB *table_toast_map,
+ /* OK, it needs something done */
+ if (doanalyze || dovacuum)
+ {
+- int freeze_min_age;
+- int freeze_table_age;
+- int multixact_freeze_min_age;
+- int multixact_freeze_table_age;
++ int64 freeze_min_age;
++ int64 freeze_table_age;
++ int64 multixact_freeze_min_age;
++ int64 multixact_freeze_table_age;
+ int log_min_duration;
+
+ /*
+@@ -2852,7 +2851,7 @@ static void
+ recheck_relation_needs_vacanalyze(Oid relid,
+ AutoVacOpts *avopts,
+ Form_pg_class classForm,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ bool *dovacuum,
+ bool *doanalyze,
+ bool *wraparound)
+@@ -2914,7 +2913,7 @@ relation_needs_vacanalyze(Oid relid,
+ AutoVacOpts *relopts,
+ Form_pg_class classForm,
+ PgStat_StatTabEntry *tabentry,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ /* output params below */
+ bool *dovacuum,
+ bool *doanalyze,
+@@ -2943,8 +2942,8 @@ relation_needs_vacanalyze(Oid relid,
+ anltuples;
+
+ /* freeze parameters */
+- int freeze_max_age;
+- int multixact_freeze_max_age;
++ int64 freeze_max_age;
++ int64 multixact_freeze_max_age;
+ TransactionId xidForceLimit;
+ TransactionId relfrozenxid;
+ MultiXactId multiForceLimit;
+@@ -2995,9 +2994,12 @@ relation_needs_vacanalyze(Oid relid,
+ av_enabled = (relopts ? relopts->enabled : true);
+
+ /* Force vacuum if table is at risk of wraparound */
+- xidForceLimit = recentXid - freeze_max_age;
+- if (xidForceLimit < FirstNormalTransactionId)
+- xidForceLimit -= FirstNormalTransactionId;
++
++ if (recentXid > FirstNormalTransactionId + freeze_max_age)
++ xidForceLimit = recentXid - freeze_max_age;
++ else
++ xidForceLimit = FirstNormalTransactionId;
++
+ relfrozenxid = classForm->relfrozenxid;
+ force_vacuum = (TransactionIdIsNormal(relfrozenxid) &&
+ TransactionIdPrecedes(relfrozenxid, xidForceLimit));
+@@ -3005,9 +3007,11 @@ relation_needs_vacanalyze(Oid relid,
+ {
+ MultiXactId relminmxid = classForm->relminmxid;
+
+- multiForceLimit = recentMulti - multixact_freeze_max_age;
+- if (multiForceLimit < FirstMultiXactId)
+- multiForceLimit -= FirstMultiXactId;
++ if (recentMulti > FirstMultiXactId + multixact_freeze_max_age)
++ multiForceLimit = recentMulti - multixact_freeze_max_age;
++ else
++ multiForceLimit = FirstMultiXactId;
++
+ force_vacuum = MultiXactIdIsValid(relminmxid) &&
+ MultiXactIdPrecedes(relminmxid, multiForceLimit);
+ }
+diff --git a/src/backend/replication/logical/conflict.c b/src/backend/replication/logical/conflict.c
+index 5d9ff626bde..2e58d4c728a 100644
+--- a/src/backend/replication/logical/conflict.c
++++ b/src/backend/replication/logical/conflict.c
+@@ -214,11 +214,11 @@ errdetail_apply_conflict(EState *estate, ResultRelInfo *relinfo,
+ if (localts)
+ {
+ if (localorigin == InvalidRepOriginId)
+- appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified locally in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified locally in transaction %lu at %s."),
+ get_rel_name(indexoid),
+ localxmin, timestamptz_to_str(localts));
+ else if (replorigin_by_oid(localorigin, true, &origin_name))
+- appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified by origin \"%s\" in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified by origin \"%s\" in transaction %lu at %s."),
+ get_rel_name(indexoid), origin_name,
+ localxmin, timestamptz_to_str(localts));
+
+@@ -230,27 +230,27 @@ errdetail_apply_conflict(EState *estate, ResultRelInfo *relinfo,
+ * manually dropped by the user.
+ */
+ else
+- appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified by a non-existent origin in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified by a non-existent origin in transaction %lu at %s."),
+ get_rel_name(indexoid),
+ localxmin, timestamptz_to_str(localts));
+ }
+ else
+- appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified in transaction %u."),
++ appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified in transaction %lu."),
+ get_rel_name(indexoid), localxmin);
+
+ break;
+
+ case CT_UPDATE_ORIGIN_DIFFERS:
+ if (localorigin == InvalidRepOriginId)
+- appendStringInfo(&err_detail, _("Updating the row that was modified locally in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Updating the row that was modified locally in transaction %lu at %s."),
+ localxmin, timestamptz_to_str(localts));
+ else if (replorigin_by_oid(localorigin, true, &origin_name))
+- appendStringInfo(&err_detail, _("Updating the row that was modified by a different origin \"%s\" in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Updating the row that was modified by a different origin \"%s\" in transaction %lu at %s."),
+ origin_name, localxmin, timestamptz_to_str(localts));
+
+ /* The origin that modified this row has been removed. */
+ else
+- appendStringInfo(&err_detail, _("Updating the row that was modified by a non-existent origin in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Updating the row that was modified by a non-existent origin in transaction %lu at %s."),
+ localxmin, timestamptz_to_str(localts));
+
+ break;
+@@ -261,15 +261,15 @@ errdetail_apply_conflict(EState *estate, ResultRelInfo *relinfo,
+
+ case CT_DELETE_ORIGIN_DIFFERS:
+ if (localorigin == InvalidRepOriginId)
+- appendStringInfo(&err_detail, _("Deleting the row that was modified locally in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Deleting the row that was modified locally in transaction %lu at %s."),
+ localxmin, timestamptz_to_str(localts));
+ else if (replorigin_by_oid(localorigin, true, &origin_name))
+- appendStringInfo(&err_detail, _("Deleting the row that was modified by a different origin \"%s\" in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Deleting the row that was modified by a different origin \"%s\" in transaction %lu at %s."),
+ origin_name, localxmin, timestamptz_to_str(localts));
+
+ /* The origin that modified this row has been removed. */
+ else
+- appendStringInfo(&err_detail, _("Deleting the row that was modified by a non-existent origin in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Deleting the row that was modified by a non-existent origin in transaction %lu at %s."),
+ localxmin, timestamptz_to_str(localts));
+
+ break;
+diff --git a/src/backend/replication/logical/decode.c b/src/backend/replication/logical/decode.c
+index e73576ad12f..317618e4e24 100644
+--- a/src/backend/replication/logical/decode.c
++++ b/src/backend/replication/logical/decode.c
+@@ -896,8 +896,14 @@ DecodeInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ xl_heap_insert *xlrec;
+ ReorderBufferChange *change;
+ RelFileLocator target_locator;
++ bool isinit = (XLogRecGetInfo(r) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(r);
+
+- xlrec = (xl_heap_insert *) XLogRecGetData(r);
++ /* Bypass pd_xid_base and pd_multi_base */
++ if (isinit)
++ rec_data += sizeof(TransactionId) * 2;
++
++ xlrec = (xl_heap_insert *) rec_data;
+
+ /*
+ * Ignore insert records without new tuples (this does happen when
+@@ -953,8 +959,13 @@ DecodeUpdate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ ReorderBufferChange *change;
+ char *data;
+ RelFileLocator target_locator;
++ bool isinit = (XLogRecGetInfo(r) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(r);
+
+- xlrec = (xl_heap_update *) XLogRecGetData(r);
++ /* Bypass pd_xid_base and pd_multi_base */
++ if (isinit)
++ rec_data += sizeof(TransactionId) * 2;
++ xlrec = (xl_heap_update *) rec_data;
+
+ /* only interested in our database */
+ XLogRecGetBlockTag(r, 0, &target_locator, NULL, NULL);
+@@ -1114,8 +1125,13 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ char *tupledata;
+ Size tuplelen;
+ RelFileLocator rlocator;
++ bool isinit = (XLogRecGetInfo(r) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(r);
+
+- xlrec = (xl_heap_multi_insert *) XLogRecGetData(r);
++ /* Bypass pd_xid_base and pd_multi_base */
++ if (isinit)
++ rec_data += sizeof(TransactionId) * 2;
++ xlrec = (xl_heap_multi_insert *) rec_data;
+
+ /*
+ * Ignore insert records without new tuples. This happens when a
+@@ -1172,6 +1188,7 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ * We can only figure this out after reassembling the transactions.
+ */
+ tuple->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tuple);
+
+ tuple->t_len = datalen + SizeofHeapTupleHeader;
+
+@@ -1263,6 +1280,7 @@ DecodeXLogTuple(char *data, Size len, HeapTuple tuple)
+
+ /* we can only figure this out after reassembling the transactions */
+ tuple->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tuple);
+
+ /* data is not stored aligned, copy to aligned storage */
+ memcpy((char *) &xlhdr,
+diff --git a/src/backend/replication/logical/proto.c b/src/backend/replication/logical/proto.c
+index 2c2085b2f98..39975adba0d 100644
+--- a/src/backend/replication/logical/proto.c
++++ b/src/backend/replication/logical/proto.c
+@@ -52,7 +52,7 @@ logicalrep_write_begin(StringInfo out, ReorderBufferTXN *txn)
+ /* fixed fields */
+ pq_sendint64(out, txn->final_lsn);
+ pq_sendint64(out, txn->xact_time.commit_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+ }
+
+ /*
+@@ -66,7 +66,7 @@ logicalrep_read_begin(StringInfo in, LogicalRepBeginData *begin_data)
+ if (begin_data->final_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "final_lsn not set in begin message");
+ begin_data->committime = pq_getmsgint64(in);
+- begin_data->xid = pq_getmsgint(in, 4);
++ begin_data->xid = pq_getmsgint64(in);
+ }
+
+
+@@ -120,7 +120,7 @@ logicalrep_write_begin_prepare(StringInfo out, ReorderBufferTXN *txn)
+ pq_sendint64(out, txn->final_lsn);
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, txn->xact_time.prepare_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -140,7 +140,7 @@ logicalrep_read_begin_prepare(StringInfo in, LogicalRepPreparedTxnData *begin_da
+ if (begin_data->end_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "end_lsn not set in begin prepare message");
+ begin_data->prepare_time = pq_getmsgint64(in);
+- begin_data->xid = pq_getmsgint(in, 4);
++ begin_data->xid = pq_getmsgint64(in);
+
+ /* read gid (copy it into a pre-allocated buffer) */
+ strlcpy(begin_data->gid, pq_getmsgstring(in), sizeof(begin_data->gid));
+@@ -173,7 +173,7 @@ logicalrep_write_prepare_common(StringInfo out, LogicalRepMsgType type,
+ pq_sendint64(out, prepare_lsn);
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, txn->xact_time.prepare_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -212,7 +212,7 @@ logicalrep_read_prepare_common(StringInfo in, char *msgtype,
+ if (prepare_data->end_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "end_lsn is not set in %s message", msgtype);
+ prepare_data->prepare_time = pq_getmsgint64(in);
+- prepare_data->xid = pq_getmsgint(in, 4);
++ prepare_data->xid = pq_getmsgint64(in);
+ if (prepare_data->xid == InvalidTransactionId)
+ elog(ERROR, "invalid two-phase transaction ID in %s message", msgtype);
+
+@@ -253,7 +253,7 @@ logicalrep_write_commit_prepared(StringInfo out, ReorderBufferTXN *txn,
+ pq_sendint64(out, commit_lsn);
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, txn->xact_time.commit_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -279,7 +279,7 @@ logicalrep_read_commit_prepared(StringInfo in, LogicalRepCommitPreparedTxnData *
+ if (prepare_data->end_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "end_lsn is not set in commit prepared message");
+ prepare_data->commit_time = pq_getmsgint64(in);
+- prepare_data->xid = pq_getmsgint(in, 4);
++ prepare_data->xid = pq_getmsgint64(in);
+
+ /* read gid (copy it into a pre-allocated buffer) */
+ strlcpy(prepare_data->gid, pq_getmsgstring(in), sizeof(prepare_data->gid));
+@@ -311,7 +311,7 @@ logicalrep_write_rollback_prepared(StringInfo out, ReorderBufferTXN *txn,
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, prepare_time);
+ pq_sendint64(out, txn->xact_time.commit_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -339,7 +339,7 @@ logicalrep_read_rollback_prepared(StringInfo in,
+ elog(ERROR, "rollback_end_lsn is not set in rollback prepared message");
+ rollback_data->prepare_time = pq_getmsgint64(in);
+ rollback_data->rollback_time = pq_getmsgint64(in);
+- rollback_data->xid = pq_getmsgint(in, 4);
++ rollback_data->xid = pq_getmsgint64(in);
+
+ /* read gid (copy it into a pre-allocated buffer) */
+ strlcpy(rollback_data->gid, pq_getmsgstring(in), sizeof(rollback_data->gid));
+@@ -407,7 +407,7 @@ logicalrep_write_insert(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -456,7 +456,7 @@ logicalrep_write_update(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -532,7 +532,7 @@ logicalrep_write_delete(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -586,7 +586,7 @@ logicalrep_write_truncate(StringInfo out,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ pq_sendint32(out, nrelids);
+
+@@ -644,7 +644,7 @@ logicalrep_write_message(StringInfo out, TransactionId xid, XLogRecPtr lsn,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ pq_sendint8(out, flags);
+ pq_sendint64(out, lsn);
+@@ -666,7 +666,7 @@ logicalrep_write_rel(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -722,7 +722,7 @@ logicalrep_write_typ(StringInfo out, TransactionId xid, Oid typoid)
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(basetypoid));
+ if (!HeapTupleIsValid(tup))
+@@ -1053,7 +1053,7 @@ logicalrep_write_stream_start(StringInfo out,
+ Assert(TransactionIdIsValid(xid));
+
+ /* transaction ID (we're starting to stream, so must be valid) */
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* 1 if this is the first streaming segment for this xid */
+ pq_sendbyte(out, first_segment ? 1 : 0);
+@@ -1069,7 +1069,7 @@ logicalrep_read_stream_start(StringInfo in, bool *first_segment)
+
+ Assert(first_segment);
+
+- xid = pq_getmsgint(in, 4);
++ xid = pq_getmsgint64(in);
+ *first_segment = (pq_getmsgbyte(in) == 1);
+
+ return xid;
+@@ -1098,7 +1098,7 @@ logicalrep_write_stream_commit(StringInfo out, ReorderBufferTXN *txn,
+ Assert(TransactionIdIsValid(txn->xid));
+
+ /* transaction ID */
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send the flags field (unused for now) */
+ pq_sendbyte(out, flags);
+@@ -1118,7 +1118,7 @@ logicalrep_read_stream_commit(StringInfo in, LogicalRepCommitData *commit_data)
+ TransactionId xid;
+ uint8 flags;
+
+- xid = pq_getmsgint(in, 4);
++ xid = pq_getmsgint64(in);
+
+ /* read flags (unused for now) */
+ flags = pq_getmsgbyte(in);
+@@ -1151,8 +1151,8 @@ logicalrep_write_stream_abort(StringInfo out, TransactionId xid,
+ Assert(TransactionIdIsValid(xid) && TransactionIdIsValid(subxid));
+
+ /* transaction ID */
+- pq_sendint32(out, xid);
+- pq_sendint32(out, subxid);
++ pq_sendint64(out, xid);
++ pq_sendint64(out, subxid);
+
+ if (write_abort_info)
+ {
+@@ -1174,8 +1174,8 @@ logicalrep_read_stream_abort(StringInfo in,
+ {
+ Assert(abort_data);
+
+- abort_data->xid = pq_getmsgint(in, 4);
+- abort_data->subxid = pq_getmsgint(in, 4);
++ abort_data->xid = pq_getmsgint64(in);
++ abort_data->subxid = pq_getmsgint64(in);
+
+ if (read_abort_info)
+ {
+diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
+index 2f6e0d41729..7dec6bf4f08 100644
+--- a/src/backend/replication/logical/reorderbuffer.c
++++ b/src/backend/replication/logical/reorderbuffer.c
+@@ -5211,8 +5211,12 @@ UpdateLogicalMappings(HTAB *tuplecid_data, Oid relid, Snapshot snapshot)
+ TransactionId f_mapped_xid;
+ TransactionId f_create_xid;
+ XLogRecPtr f_lsn;
+- uint32 f_hi,
+- f_lo;
++ uint32 f_lsn_hi,
++ f_lsn_lo,
++ f_mapped_xid_hi,
++ f_mapped_xid_lo,
++ f_create_xid_hi,
++ f_create_xid_lo;
+ RewriteMappingFile *f;
+
+ if (strcmp(mapping_de->d_name, ".") == 0 ||
+@@ -5224,11 +5228,14 @@ UpdateLogicalMappings(HTAB *tuplecid_data, Oid relid, Snapshot snapshot)
+ continue;
+
+ if (sscanf(mapping_de->d_name, LOGICAL_REWRITE_FORMAT,
+- &f_dboid, &f_relid, &f_hi, &f_lo,
+- &f_mapped_xid, &f_create_xid) != 6)
++ &f_dboid, &f_relid, &f_lsn_hi, &f_lsn_lo,
++ &f_mapped_xid_hi, &f_mapped_xid_lo,
++ &f_create_xid_hi, &f_create_xid_lo) != 8)
+ elog(ERROR, "could not parse filename \"%s\"", mapping_de->d_name);
+
+- f_lsn = ((uint64) f_hi) << 32 | f_lo;
++ f_lsn = ((uint64) f_lsn_hi) << 32 | f_lsn_lo;
++ f_mapped_xid = ((uint64) f_mapped_xid_hi) << 32 | f_mapped_xid_lo;
++ f_create_xid = ((uint64) f_create_xid_hi) << 32 | f_create_xid_lo;
+
+ /* mapping for another database */
+ if (f_dboid != dboid)
+diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
+index f4f80b23129..81367155847 100644
+--- a/src/backend/replication/logical/slotsync.c
++++ b/src/backend/replication/logical/slotsync.c
+@@ -212,7 +212,7 @@ update_local_synced_slot(RemoteSlot *remote_slot, Oid remote_dbid,
+ ereport(slot->data.persistency == RS_TEMPORARY ? LOG : DEBUG1,
+ errmsg("could not synchronize replication slot \"%s\" because remote slot precedes local slot",
+ remote_slot->name),
+- errdetail("The remote slot has LSN %X/%X and catalog xmin %u, but the local slot has LSN %X/%X and catalog xmin %u.",
++ errdetail("The remote slot has LSN %X/%X and catalog xmin %lu, but the local slot has LSN %X/%X and catalog xmin %lu.",
+ LSN_FORMAT_ARGS(remote_slot->restart_lsn),
+ remote_slot->catalog_xmin,
+ LSN_FORMAT_ARGS(slot->data.restart_lsn),
+diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c
+index 9ea9273b0f6..f474c172025 100644
+--- a/src/backend/replication/logical/snapbuild.c
++++ b/src/backend/replication/logical/snapbuild.c
+@@ -461,7 +461,7 @@ SnapBuildInitialSnapshot(SnapBuild *builder)
+ elog(ERROR, "cannot build an initial slot snapshot, not all transactions are monitored anymore");
+
+ /* so we don't overwrite the existing value */
+- if (TransactionIdIsValid(MyProc->xmin))
++ if (TransactionIdIsValid(pg_atomic_read_u64(&MyProc->xmin)))
+ elog(ERROR, "cannot build an initial slot snapshot when MyProc->xmin already is valid");
+
+ snap = SnapBuildBuildSnapshot(builder);
+@@ -483,7 +483,7 @@ SnapBuildInitialSnapshot(SnapBuild *builder)
+ elog(ERROR, "cannot build an initial slot snapshot as oldest safe xid %llu follows snapshot's xmin %llu",
+ (unsigned long long) safeXid, (unsigned long long) snap->xmin);
+
+- MyProc->xmin = snap->xmin;
++ pg_atomic_write_u64(&MyProc->xmin, snap->xmin);
+
+ /* allocate in transaction context */
+ newxip = (TransactionId *)
+diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c
+index aeab7eccd5e..c6245395ffd 100644
+--- a/src/backend/replication/logical/worker.c
++++ b/src/backend/replication/logical/worker.c
+@@ -581,7 +581,7 @@ handle_streamed_transaction(LogicalRepMsgType action, StringInfo s)
+ * We should have received XID of the subxact as the first part of the
+ * message, so extract it.
+ */
+- current_xid = pq_getmsgint(s, 4);
++ current_xid = pq_getmsgint64(s);
+
+ if (!TransactionIdIsValid(current_xid))
+ ereport(ERROR,
+diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
+index 4e694e06d77..0a967e03b37 100644
+--- a/src/backend/replication/walreceiver.c
++++ b/src/backend/replication/walreceiver.c
+@@ -1170,10 +1170,6 @@ static void
+ XLogWalRcvSendHSFeedback(bool immed)
+ {
+ TimestampTz now;
+- FullTransactionId nextFullXid;
+- TransactionId nextXid;
+- uint32 xmin_epoch,
+- catalog_xmin_epoch;
+ TransactionId xmin,
+ catalog_xmin;
+
+@@ -1225,31 +1221,15 @@ XLogWalRcvSendHSFeedback(bool immed)
+ catalog_xmin = InvalidTransactionId;
+ }
+
+- /*
+- * Get epoch and adjust if nextXid and oldestXmin are different sides of
+- * the epoch boundary.
+- */
+- nextFullXid = ReadNextFullTransactionId();
+- nextXid = XidFromFullTransactionId(nextFullXid);
+- xmin_epoch = EpochFromFullTransactionId(nextFullXid);
+- catalog_xmin_epoch = xmin_epoch;
+- if (nextXid < xmin)
+- xmin_epoch--;
+- if (nextXid < catalog_xmin)
+- catalog_xmin_epoch--;
+-
+- elog(DEBUG2, "sending hot standby feedback xmin %llu epoch %u catalog_xmin %llu catalog_xmin_epoch %u",
+- (unsigned long long) xmin, xmin_epoch,
+- (unsigned long long) catalog_xmin, catalog_xmin_epoch);
++ elog(DEBUG2, "sending hot standby feedback xmin %llu catalog_xmin %llu",
++ (unsigned long long) xmin, (unsigned long long) catalog_xmin);
+
+ /* Construct the message and send it. */
+ resetStringInfo(&reply_message);
+ pq_sendbyte(&reply_message, 'h');
+ pq_sendint64(&reply_message, GetCurrentTimestamp());
+- pq_sendint32(&reply_message, xmin);
+- pq_sendint32(&reply_message, xmin_epoch);
+- pq_sendint32(&reply_message, catalog_xmin);
+- pq_sendint32(&reply_message, catalog_xmin_epoch);
++ pq_sendint64(&reply_message, xmin);
++ pq_sendint64(&reply_message, catalog_xmin);
+ walrcv_send(wrconn, reply_message.data, reply_message.len);
+ if (TransactionIdIsValid(xmin) || TransactionIdIsValid(catalog_xmin))
+ primary_has_standby_xmin = true;
+diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
+index ab8991ec2d8..509bf9fecfc 100644
+--- a/src/backend/replication/walsender.c
++++ b/src/backend/replication/walsender.c
+@@ -267,7 +267,6 @@ static void WalSndUpdateProgress(LogicalDecodingContext *ctx, XLogRecPtr lsn, Tr
+ static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+ static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+ static TimeOffset LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
+-static bool TransactionIdInRecentPast(TransactionId xid, uint32 epoch);
+
+ static void WalSndSegmentOpen(XLogReaderState *state, XLogSegNo nextSegNo,
+ TimeLineID *tli_p);
+@@ -303,7 +302,7 @@ InitWalSender(void)
+ */
+ if (MyDatabaseId == InvalidOid)
+ {
+- Assert(MyProc->xmin == InvalidTransactionId);
++ Assert(pg_atomic_read_u64(&MyProc->xmin) == InvalidTransactionId);
+ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
+ MyProc->statusFlags |= PROC_AFFECTS_ALL_HORIZONS;
+ ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
+@@ -2470,7 +2469,7 @@ PhysicalReplicationSlotNewXmin(TransactionId feedbackXmin, TransactionId feedbac
+ ReplicationSlot *slot = MyReplicationSlot;
+
+ SpinLockAcquire(&slot->mutex);
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&MyProc->xmin, InvalidTransactionId);
+
+ /*
+ * For physical replication we don't need the interlock provided by xmin
+@@ -2502,44 +2501,6 @@ PhysicalReplicationSlotNewXmin(TransactionId feedbackXmin, TransactionId feedbac
+ }
+ }
+
+-/*
+- * Check that the provided xmin/epoch are sane, that is, not in the future
+- * and not so far back as to be already wrapped around.
+- *
+- * Epoch of nextXid should be same as standby, or if the counter has
+- * wrapped, then one greater than standby.
+- *
+- * This check doesn't care about whether clog exists for these xids
+- * at all.
+- */
+-static bool
+-TransactionIdInRecentPast(TransactionId xid, uint32 epoch)
+-{
+- FullTransactionId nextFullXid;
+- TransactionId nextXid;
+- uint32 nextEpoch;
+-
+- nextFullXid = ReadNextFullTransactionId();
+- nextXid = XidFromFullTransactionId(nextFullXid);
+- nextEpoch = EpochFromFullTransactionId(nextFullXid);
+-
+- if (xid <= nextXid)
+- {
+- if (epoch != nextEpoch)
+- return false;
+- }
+- else
+- {
+- if (epoch + 1 != nextEpoch)
+- return false;
+- }
+-
+- if (!TransactionIdPrecedesOrEquals(xid, nextXid))
+- return false; /* epoch OK, but it's wrapped around */
+-
+- return true;
+-}
+-
+ /*
+ * Hot Standby feedback
+ */
+@@ -2547,9 +2508,7 @@ static void
+ ProcessStandbyHSFeedbackMessage(void)
+ {
+ TransactionId feedbackXmin;
+- uint32 feedbackEpoch;
+ TransactionId feedbackCatalogXmin;
+- uint32 feedbackCatalogEpoch;
+ TimestampTz replyTime;
+
+ /*
+@@ -2558,10 +2517,8 @@ ProcessStandbyHSFeedbackMessage(void)
+ * of this message.
+ */
+ replyTime = pq_getmsgint64(&reply_message);
+- feedbackXmin = pq_getmsgint(&reply_message, 4);
+- feedbackEpoch = pq_getmsgint(&reply_message, 4);
+- feedbackCatalogXmin = pq_getmsgint(&reply_message, 4);
+- feedbackCatalogEpoch = pq_getmsgint(&reply_message, 4);
++ feedbackXmin = pq_getmsgint64(&reply_message);
++ feedbackCatalogXmin = pq_getmsgint64(&reply_message);
+
+ if (message_level_is_interesting(DEBUG2))
+ {
+@@ -2570,11 +2527,9 @@ ProcessStandbyHSFeedbackMessage(void)
+ /* Copy because timestamptz_to_str returns a static buffer */
+ replyTimeStr = pstrdup(timestamptz_to_str(replyTime));
+
+- elog(DEBUG2, "hot standby feedback xmin %llu epoch %u, catalog_xmin %llu epoch %u reply_time %s",
++ elog(DEBUG2, "hot standby feedback xmin %llu, catalog_xmin %llu reply_time %s",
+ (unsigned long long) feedbackXmin,
+- feedbackEpoch,
+ (unsigned long long) feedbackCatalogXmin,
+- feedbackCatalogEpoch,
+ replyTimeStr);
+
+ pfree(replyTimeStr);
+@@ -2599,24 +2554,12 @@ ProcessStandbyHSFeedbackMessage(void)
+ if (!TransactionIdIsNormal(feedbackXmin)
+ && !TransactionIdIsNormal(feedbackCatalogXmin))
+ {
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&MyProc->xmin, InvalidTransactionId);
+ if (MyReplicationSlot != NULL)
+ PhysicalReplicationSlotNewXmin(feedbackXmin, feedbackCatalogXmin);
+ return;
+ }
+
+- /*
+- * Check that the provided xmin/epoch are sane, that is, not in the future
+- * and not so far back as to be already wrapped around. Ignore if not.
+- */
+- if (TransactionIdIsNormal(feedbackXmin) &&
+- !TransactionIdInRecentPast(feedbackXmin, feedbackEpoch))
+- return;
+-
+- if (TransactionIdIsNormal(feedbackCatalogXmin) &&
+- !TransactionIdInRecentPast(feedbackCatalogXmin, feedbackCatalogEpoch))
+- return;
+-
+ /*
+ * Set the WalSender's xmin equal to the standby's requested xmin, so that
+ * the xmin will be taken into account by GetSnapshotData() /
+@@ -2654,9 +2597,9 @@ ProcessStandbyHSFeedbackMessage(void)
+ {
+ if (TransactionIdIsNormal(feedbackCatalogXmin)
+ && TransactionIdPrecedes(feedbackCatalogXmin, feedbackXmin))
+- MyProc->xmin = feedbackCatalogXmin;
++ pg_atomic_write_u64(&MyProc->xmin, feedbackCatalogXmin);
+ else
+- MyProc->xmin = feedbackXmin;
++ pg_atomic_write_u64(&MyProc->xmin, feedbackXmin);
+ }
+ }
+
+diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c
+index 99fdf208dba..abbe717aebe 100644
+--- a/src/backend/statistics/extended_stats.c
++++ b/src/backend/statistics/extended_stats.c
+@@ -2455,6 +2455,7 @@ statext_expressions_load(Oid stxoid, bool inh, int idx)
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
+ tmptup.t_data = td;
++ HeapTupleCopyHeaderXids(&tmptup);
+
+ tup = heap_copytuple(&tmptup);
+
+diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
+index fd7c40dcb08..ffcc0fc290e 100644
+--- a/src/backend/storage/buffer/Makefile
++++ b/src/backend/storage/buffer/Makefile
+@@ -17,6 +17,7 @@ OBJS = \
+ buf_table.o \
+ bufmgr.o \
+ freelist.o \
+- localbuf.o
++ localbuf.o \
++ heap_convert.o
+
+ include $(top_srcdir)/src/backend/common.mk
+diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
+index cc9782b7132..c572f7b5f65 100644
+--- a/src/backend/storage/buffer/bufmgr.c
++++ b/src/backend/storage/buffer/bufmgr.c
+@@ -1555,6 +1555,30 @@ WaitReadBuffers(ReadBuffersOperation *operation)
+ relpath(operation->smgr->smgr_rlocator, forknum))));
+ }
+
++ if (PageGetPageLayoutVersion(bufBlock) != PG_PAGE_LAYOUT_VERSION &&
++ !PageIsNew((Page) bufBlock))
++ {
++ Buffer buf = BufferDescriptorGetBuffer(bufHdr);
++
++ /*
++ * All the forks but MAIN_FORKNUM should be converted to the
++ * actual page layout version in pg_upgrade.
++ */
++ if (forknum != MAIN_FORKNUM)
++ ereport(ERROR,
++ (errcode(ERRCODE_DATA_CORRUPTED),
++ errmsg("invalid fork type (%d) in block %u of relation %s",
++ forknum, blocknum,
++ relpath(operation->smgr->smgr_rlocator, forknum))));
++
++ LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_EXCLUSIVE);
++ /* Check for no concurrent changes */
++ if (PageGetPageLayoutVersion(bufBlock) != PG_PAGE_LAYOUT_VERSION)
++ convert_page(operation->rel, bufBlock, buf, blocknum);
++
++ LWLockRelease(BufferDescriptorGetContentLock(bufHdr));
++ }
++
+ /* Terminate I/O and set BM_VALID. */
+ if (persistence == RELPERSISTENCE_TEMP)
+ {
+@@ -5117,6 +5141,64 @@ MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
+ }
+ }
+
++/*
++ * Mark buffer as converted - ie its format is changed without logical changes.
++ *
++ * It will override `full_page_write` GUC setting in XLogRecordAssemble.
++ */
++void
++MarkBufferConverted(Buffer buffer, bool converted)
++{
++ BufferDesc *bufHdr;
++ uint32 buf_state;
++ bool has_mark;
++
++ if (!BufferIsValid(buffer))
++ elog(ERROR, "bad buffer ID: %d", buffer);
++
++ Assert(!BufferIsLocal(buffer));
++
++ bufHdr = GetBufferDescriptor(buffer - 1);
++
++ Assert(GetPrivateRefCount(buffer) > 0);
++ if (converted)
++ {
++ /* here, either share or exclusive lock is OK */
++ Assert(LWLockHeldByMe(BufferDescriptorGetContentLock(bufHdr)));
++ }
++
++ buf_state = pg_atomic_read_u32(&bufHdr->state);
++ has_mark = (buf_state & BM_CONVERTED) != 0;
++ if (converted == has_mark)
++ return;
++
++ buf_state = LockBufHdr(bufHdr);
++ buf_state &= ~BM_CONVERTED;
++ if (converted)
++ buf_state |= BM_CONVERTED;
++ UnlockBufHdr(bufHdr, buf_state);
++}
++
++bool
++IsBufferConverted(Buffer buffer)
++{
++
++ BufferDesc *bufHdr;
++ uint32 buf_state;
++
++ if (!BufferIsValid(buffer))
++ elog(ERROR, "bad buffer ID: %d", buffer);
++
++ Assert(!BufferIsLocal(buffer));
++
++ bufHdr = GetBufferDescriptor(buffer - 1);
++
++ Assert(GetPrivateRefCount(buffer) > 0);
++
++ buf_state = pg_atomic_read_u32(&bufHdr->state);
++ return (buf_state & BM_CONVERTED) != 0;
++}
++
+ /*
+ * Release buffer content locks for shared buffers.
+ *
+@@ -5151,6 +5233,47 @@ UnlockBuffers(void)
+ }
+ }
+
++/*
++ * Is shared buffer is locked?
++ */
++bool
++IsBufferLocked(Buffer buffer)
++{
++ BufferDesc *buf;
++
++ if (buffer == InvalidBuffer)
++ return true;
++
++ Assert(BufferIsPinned(buffer));
++ if (BufferIsLocal(buffer))
++ return true; /* local buffers need no lock */
++
++ buf = GetBufferDescriptor(buffer - 1);
++
++ return LWLockHeldByMe(BufferDescriptorGetContentLock(buf));
++}
++
++/*
++ * Is shared buffer is locked exclusive?
++ */
++bool
++IsBufferLockedExclusive(Buffer buffer)
++{
++ BufferDesc *buf;
++
++ if (buffer == InvalidBuffer)
++ return true;
++
++ Assert(BufferIsPinned(buffer));
++ if (BufferIsLocal(buffer))
++ return true; /* local buffers need no lock */
++
++ buf = GetBufferDescriptor(buffer - 1);
++
++ return LWLockHeldByMeInMode(BufferDescriptorGetContentLock(buf),
++ LW_EXCLUSIVE);
++}
++
+ /*
+ * Acquire or release the content_lock for the buffer.
+ */
+diff --git a/src/backend/storage/buffer/heap_convert.c b/src/backend/storage/buffer/heap_convert.c
+new file mode 100644
+index 00000000000..2609f110721
+--- /dev/null
++++ b/src/backend/storage/buffer/heap_convert.c
+@@ -0,0 +1,549 @@
++/*-------------------------------------------------------------------------
++ *
++ * heap_convert.c
++ * Heap page converter from 32bit to 64bit xid format
++ *
++ * Copyright (c) 2015-2022, Postgres Professional
++ *
++ * IDENTIFICATION
++ * src/backend/storage/buffer/heap_convert.c
++ *
++ *-------------------------------------------------------------------------
++ */
++
++#include "postgres.h"
++
++#include "access/generic_xlog.h"
++#include "access/heapam.h"
++#include "access/multixact.h"
++#include "catalog/catalog.h"
++#include "storage/bufmgr.h"
++#include "storage/checksum.h"
++
++static void repack_heap_tuples(Relation rel, Page page, Buffer buf,
++ BlockNumber blkno, bool double_xmax);
++
++/*
++ * itemoffcompare
++ * Sorting support for repack_tuples()
++ */
++int
++itemoffcompare(const void *item1, const void *item2)
++{
++ /* Sort in decreasing itemoff order */
++ return ((ItemIdCompactData *) item2)->itemoff -
++ ((ItemIdCompactData *) item1)->itemoff;
++}
++
++/*
++ * Lazy page conversion from 32-bit to 64-bit XID at first read.
++ */
++void
++convert_page(Relation rel, Page page, Buffer buf, BlockNumber blkno)
++{
++ static unsigned logcnt = 0;
++ bool logit;
++ PageHeader hdr = (PageHeader) page;
++ GenericXLogState *state = NULL;
++ uint16 checksum;
++ bool try_double_xmax;
++
++ /* Not during XLog replaying */
++ Assert(rel != NULL);
++
++ /* Verify checksum */
++ if (hdr->pd_checksum)
++ {
++ checksum = pg_checksum_page((char *) page, blkno);
++ if (checksum != hdr->pd_checksum)
++ ereport(ERROR,
++ (errcode(ERRCODE_INDEX_CORRUPTED),
++ errmsg("page verification failed, calculated checksum %u but expected %u",
++ checksum, hdr->pd_checksum)));
++ }
++
++ /*
++ * We occasionally force logging of page conversion, so never-changed
++ * pages are converted in the end. FORCE_LOG_EVERY is chosen arbitrarily
++ * to log neither too much nor too little.
++ */
++#define FORCE_LOG_EVERY 128
++ logit = !RecoveryInProgress() && XLogIsNeeded() && RelationNeedsWAL(rel);
++ logit = logit && (++logcnt % FORCE_LOG_EVERY) == 0;
++ if (logit)
++ {
++ state = GenericXLogStart(rel);
++ page = GenericXLogRegisterBuffer(state, buf,
++ GENERIC_XLOG_FULL_IMAGE);
++ hdr = (PageHeader) page;
++ }
++#ifdef USE_ASSERT_CHECKING
++ else
++ {
++ /* Not already converted */
++ Assert(PageGetPageLayoutVersion(page) != PG_PAGE_LAYOUT_VERSION);
++ /* Page in 32-bit xid format should not have PageSpecial. */
++ Assert(PageGetSpecialSize(page) == 0);
++ }
++#endif
++
++ switch (rel->rd_rel->relkind)
++ {
++ case 't':
++ try_double_xmax = hdr->pd_upper - hdr->pd_lower <
++ MAXALIGN(sizeof(ToastPageSpecialData));
++ repack_heap_tuples(rel, page, buf, blkno, try_double_xmax);
++ break;
++ case 'r':
++ case 'p':
++ case 'm':
++ try_double_xmax = hdr->pd_upper - hdr->pd_lower <
++ MAXALIGN(sizeof(HeapPageSpecialData));
++ repack_heap_tuples(rel, page, buf, blkno, try_double_xmax);
++ break;
++ case 'i':
++ /* no need to convert index */
++ case 'S':
++ /* no real need to convert sequences */
++ break;
++ default:
++ ereport(ERROR,
++ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
++ errmsg("conversion for relation \"%s\" cannot be done",
++ RelationGetRelationName(rel)),
++ errdetail_relkind_not_supported(rel->rd_rel->relkind)));
++ }
++
++ hdr->pd_checksum = pg_checksum_page((char *) page, blkno);
++
++ PageSetPageSizeAndVersion(page, PageGetPageSize(page),
++ PG_PAGE_LAYOUT_VERSION);
++
++ if (logit)
++ {
++ /*
++ * Finish logging buffer conversion and mark buffer as dirty.
++ */
++ Assert(state != NULL);
++ MarkBufferDirty(buf);
++ GenericXLogFinish(state);
++ }
++ else
++ {
++ /*
++ * Otherwise, it will be logged with full-page-write record on first
++ * actual change.
++ */
++ MarkBufferConverted(buf, true);
++ }
++}
++
++/*
++ * Convert xmin and xmax in a tuple.
++ * This also considers special cases: "double xmax" page format and multixact
++ * in xmax.
++ */
++static void
++convert_heap_tuple_xids(HeapTupleHeader tuple, TransactionId xid_base,
++ MultiXactId multi_base, bool double_xmax)
++{
++ /* Convert xmin */
++ if (double_xmax)
++ {
++ /* Prepare tuple for "double xmax" page format */
++ tuple->t_infomask |= HEAP_XMIN_FROZEN;
++ tuple->t_choice.t_heap.t_xmin = 0;
++ }
++ else
++ {
++ TransactionId xmin = tuple->t_choice.t_heap.t_xmin;
++
++ if (TransactionIdIsNormal(xmin))
++ {
++ if (HeapTupleHeaderXminFrozen(tuple))
++ tuple->t_choice.t_heap.t_xmin = FrozenTransactionId;
++ else if (HeapTupleHeaderXminInvalid(tuple))
++ tuple->t_choice.t_heap.t_xmin = InvalidTransactionId;
++ else
++ {
++ Assert(xmin >= xid_base + FirstNormalTransactionId);
++ /* Subtract xid_base from normal xmin */
++ tuple->t_choice.t_heap.t_xmin = xmin - xid_base;
++ }
++ }
++ }
++
++ /* If tuple has multixact flag, handle mxid wraparound */
++ if ((tuple->t_infomask & HEAP_XMAX_IS_MULTI) &&
++ !(tuple->t_infomask & HEAP_XMAX_INVALID))
++ {
++ MultiXactId mxid = tuple->t_choice.t_heap.t_xmax;
++
++ /* Handle mxid wraparound */
++ if (mxid < multi_base)
++ {
++ mxid += ((MultiXactId) 1 << 32) - FirstMultiXactId;
++ Assert(mxid >= multi_base);
++ }
++
++ if (double_xmax)
++ {
++ /* Save converted mxid into "double xmax" format */
++ HeapTupleHeaderSetDoubleXmax(tuple, mxid);
++ }
++ else
++ {
++ /*
++ * Save converted mxid offset relative to (minmxid - 1), which
++ * will be page's mxid base.
++ */
++ Assert(mxid - multi_base + FirstMultiXactId <= PG_UINT32_MAX);
++ tuple->t_choice.t_heap.t_xmax =
++ (uint32) (mxid - multi_base + FirstMultiXactId);
++ }
++ }
++ /* Convert xmax */
++ else if (!(tuple->t_infomask & HEAP_XMAX_INVALID))
++ {
++ TransactionId xmax = tuple->t_choice.t_heap.t_xmax;
++
++ if (double_xmax)
++ {
++ /* Save converted xmax into "double xmax" format */
++ HeapTupleHeaderSetDoubleXmax(tuple, xmax);
++ }
++ else if (TransactionIdIsNormal(xmax))
++ {
++ /* Subtract xid_base from normal xmax */
++ Assert(xmax >= xid_base + FirstNormalTransactionId);
++ tuple->t_choice.t_heap.t_xmax = xmax - xid_base;
++ }
++ }
++ else
++ {
++ if (double_xmax)
++ HeapTupleHeaderSetDoubleXmax(tuple, InvalidTransactionId);
++ else
++ tuple->t_choice.t_heap.t_xmax = InvalidTransactionId;
++ }
++}
++
++/*
++ * Correct page xmin/xmax based on tuple xmin/xmax values.
++ */
++static void
++compute_xid_min_max(HeapTuple tuple, MultiXactId multi_base,
++ TransactionId *xid_min, TransactionId *xid_max,
++ MultiXactId *multi_min, MultiXactId *multi_max)
++{
++ /* xmin */
++ if (!HeapTupleHeaderXminInvalid(tuple->t_data) &&
++ !HeapTupleHeaderXminFrozen(tuple->t_data))
++ {
++ TransactionId xid = HeapTupleGetRawXmin(tuple);
++
++ if (TransactionIdIsNormal(xid))
++ {
++ *xid_max = Max(*xid_max, xid);
++ *xid_min = Min(*xid_min, xid);
++ }
++ }
++
++ /* xmax */
++ if (!(tuple->t_data->t_infomask & HEAP_XMAX_INVALID))
++ {
++ TransactionId xid;
++
++ if (tuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI)
++ {
++ MultiXactId mxid = HeapTupleGetRawXmax(tuple);
++
++ Assert(MultiXactIdIsValid(mxid));
++
++ /* Handle mxid wraparound */
++ if (mxid < multi_base)
++ {
++ mxid += ((MultiXactId) 1 << 32) - FirstMultiXactId;
++ Assert(mxid >= multi_base);
++ }
++
++ *multi_max = Max(*multi_max, mxid);
++ *multi_min = Min(*multi_min, mxid);
++
++ /*
++ * Also take into account hidden update xid, which can be
++ * extracted by the vacuum.
++ */
++ if (tuple->t_data->t_infomask & HEAP_XMAX_LOCK_ONLY)
++ xid = InvalidTransactionId;
++ else
++ xid = HeapTupleGetUpdateXid(tuple);
++ }
++ else
++ {
++ xid = HeapTupleGetRawXmax(tuple);
++ }
++
++ if (TransactionIdIsNormal(xid))
++ {
++ *xid_max = Max(*xid_max, xid);
++ *xid_min = Min(*xid_min, xid);
++ }
++ }
++}
++
++/*
++ * Returns true if both:
++ * - xid_max: an uppper boundary of xmin's and xmax'es of all tuples on a page
++ * - xid_min: a lower boundary of xmin's and xmax'es of all tuples on a page
++ * can be expressed by 32-bit number relative to page's xid_base/multi_base
++ * or invalid.
++ *
++ * True value effectively means that these tuples can be directly put on one
++ * page in 64-xid format.
++ */
++static inline bool
++xids_fit_page(TransactionId xid_min, TransactionId xid_max,
++ MultiXactId multi_min, MultiXactId multi_max)
++{
++ bool xid_max_fits = false;
++ bool multi_max_fits = false;
++
++ if (xid_max == InvalidTransactionId)
++ xid_max_fits = true;
++
++ if (xid_max - xid_min <= MaxShortTransactionId - FirstNormalTransactionId)
++ xid_max_fits = true;
++
++ if (multi_max == InvalidMultiXactId)
++ multi_max_fits = true;
++
++ if (multi_max - multi_min <= MaxShortTransactionId - FirstMultiXactId)
++ multi_max_fits = true;
++
++ return xid_max_fits && multi_max_fits;
++}
++
++/*
++ * Set "base" for page in 64-bit XID format.
++ *
++ * This should not be called for double xmax pages. They do not have place for
++ * page special.
++ */
++static inline void
++heap_page_set_base(Page page,
++ TransactionId xid_min, TransactionId xid_max,
++ MultiXactId multi_min, MultiXactId multi_max,
++ TransactionId *xid_base, MultiXactId *multi_base,
++ bool is_toast)
++{
++ PageHeader hdr = (PageHeader) page;
++
++ if (xid_max != InvalidTransactionId)
++ *xid_base = xid_min - FirstNormalTransactionId;
++ else
++ *xid_base = InvalidTransactionId;
++
++ if (multi_max != InvalidMultiXactId)
++ *multi_base = multi_min - FirstMultiXactId;
++ else
++ *multi_base = InvalidMultiXactId;
++
++ if (is_toast)
++ {
++ ToastPageSpecial special;
++
++ hdr->pd_special = BLCKSZ - MAXALIGN(sizeof(ToastPageSpecialData));
++ special = ToastPageGetSpecial(page);
++ special->pd_xid_base = *xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ hdr->pd_special = BLCKSZ - MAXALIGN(sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = *xid_base;
++ special->pd_multi_base = *multi_base;
++ }
++}
++
++/*
++ * repack_heap_tuples
++ * Convert heap page format reusing space of dead tuples
++ */
++static void
++repack_heap_tuples(Relation rel, Page page, Buffer buf, BlockNumber blkno,
++ bool try_double_xmax)
++{
++ ItemIdCompactData items[MaxHeapTuplesPerPage];
++ ItemIdCompact itemPtr = items;
++ int nitems = 0,
++ maxoff = PageGetMaxOffsetNumber(page),
++ idx,
++ occupied_space = 0;
++ Offset upper;
++ bool double_xmax,
++ special_fits,
++ toast;
++ PageHeader hdr = (PageHeader) page,
++ new_hdr;
++ PGAlignedBlock zerobuf = {0};
++ Page new_page;
++ MultiXactId multi_base = rel->rd_rel->relminmxid,
++ multi_min = MaxMultiXactId,
++ multi_max = InvalidMultiXactId;
++ TransactionId xid_base = rel->rd_rel->relfrozenxid,
++ xid_min = MaxTransactionId,
++ xid_max = InvalidTransactionId;
++
++ toast = IsToastRelation(rel);
++
++ if (TransactionIdIsNormal(hdr->pd_prune_xid))
++ xid_min = xid_max = hdr->pd_prune_xid;
++
++ for (idx = 0; idx < maxoff; idx++)
++ {
++ HeapTupleData tuple;
++ ItemId lp;
++
++ lp = PageGetItemId(page, idx + 1);
++
++ /* Skip redirects and items without storage */
++ if (!ItemIdHasStorage(lp))
++ continue;
++
++ /* Build in-memory tuple representation */
++ tuple.t_tableOid = 1; /* doesn't matter in this case */
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, lp);
++ HeapTupleCopyHeaderXids(&tuple);
++ tuple.t_len = ItemIdGetLength(lp);
++ ItemPointerSet(&(tuple.t_self), blkno, ItemIdGetOffset(lp));
++
++ /*
++ * This is only needed to determine whether tuple is HEAPTUPLE_DEAD or
++ * HEAPTUPLE_RECENTLY_DEAD. And since this is the first time we read
++ * page after pg_upgrade, it cannot be HEAPTUPLE_RECENTLY_DEAD. See
++ * HeapTupleSatisfiesVacuum() for details
++ */
++ if (try_double_xmax &&
++ HeapTupleSatisfiesVacuum(&tuple,
++ (TransactionId) 1 << 32, buf) == HEAPTUPLE_DEAD)
++ {
++ ItemIdSetDead(lp);
++ }
++
++ if (ItemIdIsNormal(lp) && ItemIdHasStorage(lp))
++ {
++ itemPtr->offsetindex = idx;
++ itemPtr->itemoff = ItemIdGetOffset(lp);
++ if (unlikely(itemPtr->itemoff < hdr->pd_upper ||
++ itemPtr->itemoff >= hdr->pd_special))
++ {
++ ereport(ERROR,
++ (errcode(ERRCODE_DATA_CORRUPTED),
++ errmsg("corrupted item pointer: %u",
++ itemPtr->itemoff)));
++ }
++
++ itemPtr->alignedlen = MAXALIGN(ItemIdGetLength(lp));
++ occupied_space += itemPtr->alignedlen;
++ nitems++;
++ itemPtr++;
++ if (try_double_xmax)
++ {
++ HeapTupleSetXmin(&tuple, FrozenTransactionId);
++ HeapTupleHeaderStoreXminFrozen(tuple.t_data);
++ }
++
++ compute_xid_min_max(&tuple, multi_base,
++ &xid_min, &xid_max,
++ &multi_min, &multi_max);
++ }
++ }
++
++ new_page = (Page) zerobuf.data;
++ MemSet(new_page, 0, BLCKSZ);
++ /* Write new header */
++ new_hdr = (PageHeader) new_page;
++ *new_hdr = *hdr;
++ new_hdr->pd_lower = SizeOfPageHeaderData + maxoff * sizeof(ItemIdData);
++
++ if (toast)
++ special_fits = BLCKSZ - new_hdr->pd_lower - occupied_space >=
++ sizeof(ToastPageSpecialData);
++ else
++ special_fits = BLCKSZ - new_hdr->pd_lower - occupied_space >=
++ sizeof(HeapPageSpecialData);
++
++ double_xmax = !special_fits ||
++ !xids_fit_page(xid_min, xid_max, multi_min, multi_max);
++
++ if (!double_xmax)
++ {
++ Assert(xid_max == InvalidTransactionId || xid_max >= xid_min);
++ Assert(multi_max == InvalidMultiXactId || multi_max >= multi_min);
++
++ heap_page_set_base(new_page,
++ xid_min, xid_max,
++ multi_min, multi_max,
++ &xid_base, &multi_base,
++ toast);
++
++ HeapPageSetPruneXid(new_page, new_hdr->pd_prune_xid, toast);
++ }
++ else
++ {
++ /* No space for special area, switch to "double xmax" format */
++ elog(DEBUG2, "convert heap page %u of relation \"%s\" to double xmax format",
++ blkno, RelationGetRelationName(rel));
++
++ if (try_double_xmax)
++ {
++ xid_base = InvalidTransactionId;
++ multi_base = InvalidMultiXactId;
++ }
++ else
++ {
++ repack_heap_tuples(rel, page, buf, blkno, true);
++ return;
++ }
++ }
++
++ /* Copy ItemIds with an offset */
++ memcpy((char *) new_page + SizeOfPageHeaderData,
++ (char *) page + SizeOfPageHeaderData,
++ hdr->pd_lower - SizeOfPageHeaderData);
++
++ /* Move live tuples */
++ upper = new_hdr->pd_special;
++ for (idx = 0; idx < nitems; idx++)
++ {
++ HeapTupleHeader tuple;
++ ItemId lp;
++
++ itemPtr = &items[idx];
++ lp = PageGetItemId(new_page, itemPtr->offsetindex + 1);
++ upper -= itemPtr->alignedlen;
++ occupied_space -= itemPtr->alignedlen;
++
++ memcpy((char *) new_page + upper,
++ (char *) page + itemPtr->itemoff,
++ itemPtr->alignedlen);
++
++ tuple = (HeapTupleHeader) (((char *) new_page) + upper);
++
++ convert_heap_tuple_xids(tuple, xid_base, multi_base, double_xmax);
++
++ lp->lp_off = upper;
++ }
++
++ Assert(occupied_space == 0);
++
++ new_hdr->pd_upper = upper;
++ if (new_hdr->pd_lower > new_hdr->pd_upper)
++ elog(ERROR, "cannot convert block %u of relation \"%s\"",
++ blkno, RelationGetRelationName(rel));
++
++ memcpy(page, new_page, BLCKSZ);
++}
+diff --git a/src/backend/storage/buffer/meson.build b/src/backend/storage/buffer/meson.build
+index f152dbb0702..260e628af2a 100644
+--- a/src/backend/storage/buffer/meson.build
++++ b/src/backend/storage/buffer/meson.build
+@@ -5,5 +5,6 @@ backend_sources += files(
+ 'buf_table.c',
+ 'bufmgr.c',
+ 'freelist.c',
++ 'heap_convert.c',
+ 'localbuf.c',
+ )
+diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
+index 016ead28257..c1aa0bfcbe1 100644
+--- a/src/backend/storage/ipc/procarray.c
++++ b/src/backend/storage/ipc/procarray.c
+@@ -65,7 +65,7 @@
+ #include "utils/rel.h"
+ #include "utils/snapmgr.h"
+
+-#define UINT32_ACCESS_ONCE(var) ((uint32)(*((volatile uint32 *)&(var))))
++#define UINT64_ACCESS_ONCE(var) ((uint64)(*((volatile uint64 *)&(var))))
+
+ /* Our shared memory area */
+ typedef struct ProcArrayStruct
+@@ -365,8 +365,6 @@ static void ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid);
+ static void MaintainLatestCompletedXid(TransactionId latestXid);
+ static void MaintainLatestCompletedXidRecovery(TransactionId latestXid);
+
+-static inline FullTransactionId FullXidRelativeTo(FullTransactionId rel,
+- TransactionId xid);
+ static void GlobalVisUpdateApply(ComputeXidHorizonsResult *horizons);
+
+ /*
+@@ -525,7 +523,8 @@ ProcArrayAdd(PGPROC *proc)
+
+ arrayP->pgprocnos[index] = GetNumberFromPGProc(proc);
+ proc->pgxactoff = index;
+- ProcGlobal->xids[index] = proc->xid;
++ pg_atomic_write_u64(&ProcGlobal->xids[index],
++ pg_atomic_read_u64(&proc->xid));
+ ProcGlobal->subxidStates[index] = proc->subxidStatus;
+ ProcGlobal->statusFlags[index] = proc->statusFlags;
+
+@@ -585,7 +584,7 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
+
+ if (TransactionIdIsValid(latestXid))
+ {
+- Assert(TransactionIdIsValid(ProcGlobal->xids[myoff]));
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&ProcGlobal->xids[myoff])));
+
+ /* Advance global latestCompletedXid while holding the lock */
+ MaintainLatestCompletedXid(latestXid);
+@@ -593,17 +592,17 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
+ /* Same with xactCompletionCount */
+ TransamVariables->xactCompletionCount++;
+
+- ProcGlobal->xids[myoff] = InvalidTransactionId;
++ pg_atomic_write_u64(&ProcGlobal->xids[myoff], InvalidTransactionId);
+ ProcGlobal->subxidStates[myoff].overflowed = false;
+ ProcGlobal->subxidStates[myoff].count = 0;
+ }
+ else
+ {
+ /* Shouldn't be trying to remove a live transaction here */
+- Assert(!TransactionIdIsValid(ProcGlobal->xids[myoff]));
++ Assert(!TransactionIdIsValid(pg_atomic_read_u64(&(ProcGlobal->xids[myoff]))));
+ }
+
+- Assert(!TransactionIdIsValid(ProcGlobal->xids[myoff]));
++ Assert(!TransactionIdIsValid(pg_atomic_read_u64(&(ProcGlobal->xids[myoff]))));
+ Assert(ProcGlobal->subxidStates[myoff].count == 0);
+ Assert(ProcGlobal->subxidStates[myoff].overflowed == false);
+
+@@ -649,7 +648,6 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
+ LWLockRelease(ProcArrayLock);
+ }
+
+-
+ /*
+ * ProcArrayEndTransaction -- mark a transaction as no longer running
+ *
+@@ -674,7 +672,7 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid)
+ * else is taking a snapshot. See discussion in
+ * src/backend/access/transam/README.
+ */
+- Assert(TransactionIdIsValid(proc->xid));
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&proc->xid)));
+
+ /*
+ * If we can immediately acquire ProcArrayLock, we clear our own XID
+@@ -696,12 +694,12 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid)
+ * anyone else's calculation of a snapshot. We might change their
+ * estimate of global xmin, but that's OK.
+ */
+- Assert(!TransactionIdIsValid(proc->xid));
++ Assert(!TransactionIdIsValid(pg_atomic_read_u64(&proc->xid)));
+ Assert(proc->subxidStatus.count == 0);
+ Assert(!proc->subxidStatus.overflowed);
+
+ proc->vxid.lxid = InvalidLocalTransactionId;
+- proc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&proc->xmin, InvalidTransactionId);
+
+ /* be sure this is cleared in abort */
+ proc->delayChkptFlags = 0;
+@@ -737,13 +735,14 @@ ProcArrayEndTransactionInternal(PGPROC *proc, TransactionId latestXid)
+ * processes' PGPROC entries.
+ */
+ Assert(LWLockHeldByMeInMode(ProcArrayLock, LW_EXCLUSIVE));
+- Assert(TransactionIdIsValid(ProcGlobal->xids[pgxactoff]));
+- Assert(ProcGlobal->xids[pgxactoff] == proc->xid);
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&ProcGlobal->xids[pgxactoff])));
++ Assert(pg_atomic_read_u64(&ProcGlobal->xids[pgxactoff]) ==
++ pg_atomic_read_u64(&proc->xid));
+
+- ProcGlobal->xids[pgxactoff] = InvalidTransactionId;
+- proc->xid = InvalidTransactionId;
++ pg_atomic_write_u64(&ProcGlobal->xids[pgxactoff], InvalidTransactionId);
++ pg_atomic_write_u64(&proc->xid, InvalidTransactionId);
+ proc->vxid.lxid = InvalidLocalTransactionId;
+- proc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&proc->xmin, InvalidTransactionId);
+
+ /* be sure this is cleared in abort */
+ proc->delayChkptFlags = 0;
+@@ -797,7 +796,7 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
+ uint32 wakeidx;
+
+ /* We should definitely have an XID to clear. */
+- Assert(TransactionIdIsValid(proc->xid));
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&proc->xid)));
+
+ /* Add ourselves to the list of processes needing a group XID clear. */
+ proc->procArrayGroupMember = true;
+@@ -926,11 +925,11 @@ ProcArrayClearTransaction(PGPROC *proc)
+
+ pgxactoff = proc->pgxactoff;
+
+- ProcGlobal->xids[pgxactoff] = InvalidTransactionId;
+- proc->xid = InvalidTransactionId;
++ pg_atomic_write_u64(&ProcGlobal->xids[pgxactoff], InvalidTransactionId);
++ pg_atomic_write_u64(&proc->xid, InvalidTransactionId);
+
+ proc->vxid.lxid = InvalidLocalTransactionId;
+- proc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&proc->xmin, InvalidTransactionId);
+ proc->recoveryConflictPending = false;
+
+ Assert(!(proc->statusFlags & PROC_VACUUM_STATE_MASK));
+@@ -974,8 +973,7 @@ MaintainLatestCompletedXid(TransactionId latestXid)
+
+ if (TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
+ {
+- TransamVariables->latestCompletedXid =
+- FullXidRelativeTo(cur_latest, latestXid);
++ TransamVariables->latestCompletedXid = FullTransactionIdFromXid(latestXid);
+ }
+
+ Assert(IsBootstrapProcessingMode() ||
+@@ -989,7 +987,6 @@ static void
+ MaintainLatestCompletedXidRecovery(TransactionId latestXid)
+ {
+ FullTransactionId cur_latest = TransamVariables->latestCompletedXid;
+- FullTransactionId rel;
+
+ Assert(AmStartupProcess() || !IsUnderPostmaster);
+ Assert(LWLockHeldByMe(ProcArrayLock));
+@@ -999,14 +996,12 @@ MaintainLatestCompletedXidRecovery(TransactionId latestXid)
+ * latestCompletedXid to be initialized in recovery. But in recovery it's
+ * safe to access nextXid without a lock for the startup process.
+ */
+- rel = TransamVariables->nextXid;
+ Assert(FullTransactionIdIsValid(TransamVariables->nextXid));
+
+ if (!FullTransactionIdIsValid(cur_latest) ||
+ TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
+ {
+- TransamVariables->latestCompletedXid =
+- FullXidRelativeTo(rel, latestXid);
++ TransamVariables->latestCompletedXid = FullTransactionIdFromXid(latestXid);
+ }
+
+ Assert(FullTransactionIdIsNormal(TransamVariables->latestCompletedXid));
+@@ -1402,7 +1397,7 @@ bool
+ TransactionIdIsInProgress(TransactionId xid)
+ {
+ static TransactionId *xids = NULL;
+- static TransactionId *other_xids;
++ static pg_atomic_uint64 *other_xids;
+ XidCacheStatus *other_subxidstates;
+ int nxids = 0;
+ ProcArrayStruct *arrayP = procArray;
+@@ -1498,7 +1493,7 @@ TransactionIdIsInProgress(TransactionId xid)
+ continue;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- pxid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]);
++ pxid = pg_atomic_read_u64(&(other_xids[pgxactoff]));
+
+ if (!TransactionIdIsValid(pxid))
+ continue;
+@@ -1530,7 +1525,7 @@ TransactionIdIsInProgress(TransactionId xid)
+ for (j = pxids - 1; j >= 0; j--)
+ {
+ /* Fetch xid just once - see GetNewTransactionId */
+- TransactionId cxid = UINT32_ACCESS_ONCE(proc->subxids.xids[j]);
++ TransactionId cxid = UINT64_ACCESS_ONCE(proc->subxids.xids[j]);
+
+ if (TransactionIdEquals(cxid, xid))
+ {
+@@ -1615,7 +1610,7 @@ TransactionIdIsInProgress(TransactionId xid)
+ topxid = SubTransGetTopmostTransaction(xid);
+ Assert(TransactionIdIsValid(topxid));
+ if (!TransactionIdEquals(topxid, xid) &&
+- pg_lfind32(topxid, xids, nxids))
++ pg_lfind64(topxid, xids, nxids))
+ return true;
+
+ cachedXidIsNotInProgress = xid;
+@@ -1635,7 +1630,7 @@ TransactionIdIsActive(TransactionId xid)
+ {
+ bool result = false;
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ int i;
+
+ /*
+@@ -1654,7 +1649,7 @@ TransactionIdIsActive(TransactionId xid)
+ TransactionId pxid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- pxid = UINT32_ACCESS_ONCE(other_xids[i]);
++ pxid = pg_atomic_read_u64(&(other_xids[i]));
+
+ if (!TransactionIdIsValid(pxid))
+ continue;
+@@ -1737,7 +1732,7 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ ProcArrayStruct *arrayP = procArray;
+ TransactionId kaxmin;
+ bool in_recovery = RecoveryInProgress();
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+
+ /* inferred after ProcArrayLock is released */
+ h->catalog_oldest_nonremovable = InvalidTransactionId;
+@@ -1753,7 +1748,8 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ * additions.
+ */
+ {
+- TransactionId initial;
++ TransactionId initial,
++ xid;
+
+ initial = XidFromFullTransactionId(h->latest_completed);
+ Assert(TransactionIdIsValid(initial));
+@@ -1775,8 +1771,9 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ * definition, can't be any newer changes in the temp table than
+ * latestCompletedXid.
+ */
+- if (TransactionIdIsValid(MyProc->xid))
+- h->temp_oldest_nonremovable = MyProc->xid;
++ xid = pg_atomic_read_u64(&MyProc->xid);
++ if (TransactionIdIsValid(xid))
++ h->temp_oldest_nonremovable = xid;
+ else
+ h->temp_oldest_nonremovable = initial;
+ }
+@@ -1798,8 +1795,8 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ TransactionId xmin;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
+- xmin = UINT32_ACCESS_ONCE(proc->xmin);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
++ xmin = pg_atomic_read_u64(&proc->xmin);
+
+ /*
+ * Consider both the transaction's Xmin, and its Xid.
+@@ -2125,8 +2122,8 @@ GetSnapshotDataReuse(Snapshot snapshot)
+ * requirement that concurrent GetSnapshotData() calls yield the same
+ * xmin.
+ */
+- if (!TransactionIdIsValid(MyProc->xmin))
+- MyProc->xmin = TransactionXmin = snapshot->xmin;
++ if (!TransactionIdIsValid(pg_atomic_read_u64(&MyProc->xmin)))
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = snapshot->xmin);
+
+ RecentXmin = snapshot->xmin;
+ Assert(TransactionIdPrecedesOrEquals(TransactionXmin, RecentXmin));
+@@ -2177,7 +2174,7 @@ Snapshot
+ GetSnapshotData(Snapshot snapshot)
+ {
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ TransactionId xmin;
+ TransactionId xmax;
+ int count = 0;
+@@ -2240,8 +2237,8 @@ GetSnapshotData(Snapshot snapshot)
+
+ latest_completed = TransamVariables->latestCompletedXid;
+ mypgxactoff = MyProc->pgxactoff;
+- myxid = other_xids[mypgxactoff];
+- Assert(myxid == MyProc->xid);
++ myxid = pg_atomic_read_u64(&other_xids[mypgxactoff]);
++ Assert(myxid == pg_atomic_read_u64(&MyProc->xid));
+
+ oldestxid = TransamVariables->oldestXid;
+ curXactCompletionCount = TransamVariables->xactCompletionCount;
+@@ -2275,7 +2272,7 @@ GetSnapshotData(Snapshot snapshot)
+ for (int pgxactoff = 0; pgxactoff < numProcs; pgxactoff++)
+ {
+ /* Fetch xid just once - see GetNewTransactionId */
+- TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]);
++ TransactionId xid = pg_atomic_read_u64(&(other_xids[pgxactoff]));
+ uint8 statusFlags;
+
+ Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff);
+@@ -2412,8 +2409,8 @@ GetSnapshotData(Snapshot snapshot)
+ replication_slot_xmin = procArray->replication_slot_xmin;
+ replication_slot_catalog_xmin = procArray->replication_slot_catalog_xmin;
+
+- if (!TransactionIdIsValid(MyProc->xmin))
+- MyProc->xmin = TransactionXmin = xmin;
++ if (!TransactionIdIsValid(pg_atomic_read_u64(&MyProc->xmin)))
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = xmin);
+
+ LWLockRelease(ProcArrayLock);
+
+@@ -2425,12 +2422,7 @@ GetSnapshotData(Snapshot snapshot)
+ FullTransactionId def_vis_fxid_data;
+ FullTransactionId oldestfxid;
+
+- /*
+- * Converting oldestXid is only safe when xid horizon cannot advance,
+- * i.e. holding locks. While we don't hold the lock anymore, all the
+- * necessary data has been gathered with lock held.
+- */
+- oldestfxid = FullXidRelativeTo(latest_completed, oldestxid);
++ oldestfxid = FullTransactionIdFromXid(oldestxid);
+
+ /* Check whether there's a replication slot requiring an older xmin. */
+ def_vis_xid_data =
+@@ -2449,8 +2441,8 @@ GetSnapshotData(Snapshot snapshot)
+ def_vis_xid =
+ TransactionIdOlder(replication_slot_catalog_xmin, def_vis_xid);
+
+- def_vis_fxid = FullXidRelativeTo(latest_completed, def_vis_xid);
+- def_vis_fxid_data = FullXidRelativeTo(latest_completed, def_vis_xid_data);
++ def_vis_fxid = FullTransactionIdFromXid(def_vis_xid);
++ def_vis_fxid_data = FullTransactionIdFromXid(def_vis_xid_data);
+
+ /*
+ * Check if we can increase upper bound. As a previous
+@@ -2469,7 +2461,7 @@ GetSnapshotData(Snapshot snapshot)
+ /* See temp_oldest_nonremovable computation in ComputeXidHorizons() */
+ if (TransactionIdIsNormal(myxid))
+ GlobalVisTempRels.definitely_needed =
+- FullXidRelativeTo(latest_completed, myxid);
++ FullTransactionIdFromXid(myxid);
+ else
+ {
+ GlobalVisTempRels.definitely_needed = latest_completed;
+@@ -2581,7 +2573,7 @@ ProcArrayInstallImportedXmin(TransactionId xmin,
+ /*
+ * Likewise, let's just make real sure its xmin does cover us.
+ */
+- xid = UINT32_ACCESS_ONCE(proc->xmin);
++ xid = pg_atomic_read_u64(&proc->xmin);
+ if (!TransactionIdIsNormal(xid) ||
+ !TransactionIdPrecedesOrEquals(xid, xmin))
+ continue;
+@@ -2592,7 +2584,7 @@ ProcArrayInstallImportedXmin(TransactionId xmin,
+ * GetSnapshotData first, we'll be overwriting a valid xmin here, so
+ * we don't check that.)
+ */
+- MyProc->xmin = TransactionXmin = xmin;
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = xmin);
+
+ result = true;
+ break;
+@@ -2636,7 +2628,7 @@ ProcArrayInstallRestoredXmin(TransactionId xmin, PGPROC *proc)
+ * can't go backwards. Also, make sure it's running in the same database,
+ * so that the per-database xmin cannot go backwards.
+ */
+- xid = UINT32_ACCESS_ONCE(proc->xmin);
++ xid = pg_atomic_read_u64(&proc->xmin);
+ if (proc->databaseId == MyDatabaseId &&
+ TransactionIdIsNormal(xid) &&
+ TransactionIdPrecedesOrEquals(xid, xmin))
+@@ -2645,7 +2637,7 @@ ProcArrayInstallRestoredXmin(TransactionId xmin, PGPROC *proc)
+ * Install xmin and propagate the statusFlags that affect how the
+ * value is interpreted by vacuum.
+ */
+- MyProc->xmin = TransactionXmin = xmin;
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = xmin);
+ MyProc->statusFlags = (MyProc->statusFlags & ~PROC_XMIN_FLAGS) |
+ (proc->statusFlags & PROC_XMIN_FLAGS);
+ ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
+@@ -2696,7 +2688,7 @@ GetRunningTransactionData(void)
+ static RunningTransactionsData CurrentRunningXactsData;
+
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ RunningTransactions CurrentRunningXacts = &CurrentRunningXactsData;
+ TransactionId latestCompletedXid;
+ TransactionId oldestRunningXid;
+@@ -2756,7 +2748,7 @@ GetRunningTransactionData(void)
+ TransactionId xid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
+
+ /*
+ * We don't need to store transactions that don't have a TransactionId
+@@ -2884,7 +2876,7 @@ TransactionId
+ GetOldestActiveTransactionId(void)
+ {
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ TransactionId oldestRunningXid;
+ int index;
+
+@@ -2910,7 +2902,7 @@ GetOldestActiveTransactionId(void)
+ TransactionId xid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
+
+ if (!TransactionIdIsNormal(xid))
+ continue;
+@@ -2998,7 +2990,7 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly)
+ */
+ if (!recovery_in_progress)
+ {
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+
+ /*
+ * Spin over procArray collecting min(ProcGlobal->xids[i])
+@@ -3008,7 +3000,7 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly)
+ TransactionId xid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
+
+ if (!TransactionIdIsNormal(xid))
+ continue;
+@@ -3180,8 +3172,8 @@ ProcNumberGetTransactionIds(ProcNumber procNumber, TransactionId *xid,
+
+ if (proc->pid != 0)
+ {
+- *xid = proc->xid;
+- *xmin = proc->xmin;
++ *xid = pg_atomic_read_u64(&proc->xid);
++ *xmin = pg_atomic_read_u64(&proc->xmin);
+ *nsubxid = proc->subxidStatus.count;
+ *overflowed = proc->subxidStatus.overflowed;
+ }
+@@ -3261,7 +3253,7 @@ BackendXidGetPid(TransactionId xid)
+ {
+ int result = 0;
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ int index;
+
+ if (xid == InvalidTransactionId) /* never match invalid xid */
+@@ -3271,7 +3263,7 @@ BackendXidGetPid(TransactionId xid)
+
+ for (index = 0; index < arrayP->numProcs; index++)
+ {
+- if (other_xids[index] == xid)
++ if (pg_atomic_read_u64(&other_xids[index]) == xid)
+ {
+ int pgprocno = arrayP->pgprocnos[index];
+ PGPROC *proc = &allProcs[pgprocno];
+@@ -3355,7 +3347,7 @@ GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0,
+ if (allDbs || proc->databaseId == MyDatabaseId)
+ {
+ /* Fetch xmin just once - might change on us */
+- TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin);
++ TransactionId pxmin = pg_atomic_read_u64(&proc->xmin);
+
+ if (excludeXmin0 && !TransactionIdIsValid(pxmin))
+ continue;
+@@ -3455,7 +3447,7 @@ GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid)
+ proc->databaseId == dbOid)
+ {
+ /* Fetch xmin just once - can't change on us, but good coding */
+- TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin);
++ TransactionId pxmin = pg_atomic_read_u64(&proc->xmin);
+
+ /*
+ * We ignore an invalid pxmin because this means that backend has
+@@ -3582,7 +3574,7 @@ MinimumActiveBackends(int min)
+ continue; /* do not count deleted entries */
+ if (proc == MyProc)
+ continue; /* do not count myself */
+- if (proc->xid == InvalidTransactionId)
++ if (pg_atomic_read_u64(&proc->xid) == InvalidTransactionId)
+ continue; /* do not count if no XID assigned */
+ if (proc->pid == 0)
+ continue; /* do not count prepared xacts */
+@@ -4172,17 +4164,13 @@ static void
+ GlobalVisUpdateApply(ComputeXidHorizonsResult *horizons)
+ {
+ GlobalVisSharedRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->shared_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->shared_oldest_nonremovable);
+ GlobalVisCatalogRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->catalog_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->catalog_oldest_nonremovable);
+ GlobalVisDataRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->data_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->data_oldest_nonremovable);
+ GlobalVisTempRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->temp_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->temp_oldest_nonremovable);
+
+ /*
+ * In longer running transactions it's possible that transactions we
+@@ -4271,15 +4259,7 @@ GlobalVisTestIsRemovableXid(GlobalVisState *state, TransactionId xid)
+ {
+ FullTransactionId fxid;
+
+- /*
+- * Convert 32 bit argument to FullTransactionId. We can do so safely
+- * because we know the xid has to, at the very least, be between
+- * [oldestXid, nextXid), i.e. within 2 billion of xid. To avoid taking a
+- * lock to determine either, we can just compare with
+- * state->definitely_needed, which was based on those value at the time
+- * the current snapshot was built.
+- */
+- fxid = FullXidRelativeTo(state->definitely_needed, xid);
++ fxid = FullTransactionIdFromXid(xid);
+
+ return GlobalVisTestIsRemovableFullXid(state, fxid);
+ }
+@@ -4312,32 +4292,6 @@ GlobalVisCheckRemovableXid(Relation rel, TransactionId xid)
+ return GlobalVisTestIsRemovableXid(state, xid);
+ }
+
+-/*
+- * Convert a 32 bit transaction id into 64 bit transaction id, by assuming it
+- * is within MaxTransactionId / 2 of XidFromFullTransactionId(rel).
+- *
+- * Be very careful about when to use this function. It can only safely be used
+- * when there is a guarantee that xid is within MaxTransactionId / 2 xids of
+- * rel. That e.g. can be guaranteed if the caller assures a snapshot is
+- * held by the backend and xid is from a table (where vacuum/freezing ensures
+- * the xid has to be within that range), or if xid is from the procarray and
+- * prevents xid wraparound that way.
+- */
+-static inline FullTransactionId
+-FullXidRelativeTo(FullTransactionId rel, TransactionId xid)
+-{
+- TransactionId rel_xid = XidFromFullTransactionId(rel);
+-
+- Assert(TransactionIdIsValid(xid));
+- Assert(TransactionIdIsValid(rel_xid));
+-
+- /* not guaranteed to find issues, but likely to catch mistakes */
+- AssertTransactionIdInAllowableRange(xid);
+-
+- return FullTransactionIdFromU64(U64FromFullTransactionId(rel)
+- + (int32) (xid - rel_xid));
+-}
+-
+
+ /* ----------------------------------------------
+ * KnownAssignedTransactionIds sub-module
+diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c
+index 57821c172d8..6aaea1fa349 100644
+--- a/src/backend/storage/ipc/standby.c
++++ b/src/backend/storage/ipc/standby.c
+@@ -521,8 +521,8 @@ ResolveRecoveryConflictWithSnapshotFullXid(FullTransactionId snapshotConflictHor
+ FullTransactionId nextXid = ReadNextFullTransactionId();
+ uint64 diff;
+
+- diff = U64FromFullTransactionId(nextXid) -
+- U64FromFullTransactionId(snapshotConflictHorizon);
++ diff = XidFromFullTransactionId(nextXid) -
++ XidFromFullTransactionId(snapshotConflictHorizon);
+ if (diff < MaxTransactionId / 2)
+ {
+ TransactionId truncated;
+diff --git a/src/backend/storage/lmgr/lmgr.c b/src/backend/storage/lmgr/lmgr.c
+index 9f43620e472..b16e1fb0748 100644
+--- a/src/backend/storage/lmgr/lmgr.c
++++ b/src/backend/storage/lmgr/lmgr.c
+@@ -1266,10 +1266,16 @@ DescribeLockTag(StringInfo buf, const LOCKTAG *tag)
+ tag->locktag_field1);
+ break;
+ case LOCKTAG_TRANSACTION:
+- appendStringInfo(buf,
+- _("transaction %u"),
+- tag->locktag_field1);
+- break;
++ {
++ TransactionId xid;
++
++ xid = (TransactionId) tag->locktag_field2 << 32;
++ xid += tag->locktag_field1;
++
++ appendStringInfo(buf, _("transaction %llu"),
++ (unsigned long long) xid);
++ break;
++ }
+ case LOCKTAG_VIRTUALTRANSACTION:
+ appendStringInfo(buf,
+ _("virtual transaction %d/%u"),
+diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c
+index edc5020c6ae..0bf06eaf037 100644
+--- a/src/backend/storage/lmgr/lock.c
++++ b/src/backend/storage/lmgr/lock.c
+@@ -4120,7 +4120,7 @@ GetRunningTransactionLocks(int *nlocks)
+ {
+ PGPROC *proc = proclock->tag.myProc;
+ LOCK *lock = proclock->tag.myLock;
+- TransactionId xid = proc->xid;
++ TransactionId xid = pg_atomic_read_u64(&proc->xid);
+
+ /*
+ * Don't record locks for transactions if we know they have
+@@ -4740,7 +4740,7 @@ VirtualXactLock(VirtualTransactionId vxid, bool wait)
+ * so we won't save an XID of a different VXID. It doesn't matter whether
+ * we save this before or after setting up the primary lock table entry.
+ */
+- xid = proc->xid;
++ xid = pg_atomic_read_u64(&proc->xid);
+
+ /* Done with proc->fpLockBits */
+ LWLockRelease(&proc->fpInfoLock);
+diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
+index 0e147f7501a..6dad5710277 100644
+--- a/src/backend/storage/lmgr/predicate.c
++++ b/src/backend/storage/lmgr/predicate.c
+@@ -338,9 +338,9 @@ static SlruCtlData SerialSlruCtlData;
+
+ #define SerialValue(slotno, xid) (*((SerCommitSeqNo *) \
+ (SerialSlruCtl->shared->page_buffer[slotno] + \
+- ((((uint32) (xid)) % SERIAL_ENTRIESPERPAGE) * SERIAL_ENTRYSIZE))))
++ ((((uint64) (xid)) % SERIAL_ENTRIESPERPAGE) * SERIAL_ENTRYSIZE))))
+
+-#define SerialPage(xid) (((uint32) (xid)) / SERIAL_ENTRIESPERPAGE)
++#define SerialPage(xid) ((int64) (((uint64) (xid)) / SERIAL_ENTRIESPERPAGE))
+
+ typedef struct SerialControlData
+ {
+@@ -1077,31 +1077,6 @@ CheckPointPredicate(void)
+ /*----------
+ * The SLRU is no longer needed. Truncate to head before we set head
+ * invalid.
+- *
+- * XXX: It's possible that the SLRU is not needed again until XID
+- * wrap-around has happened, so that the segment containing headPage
+- * that we leave behind will appear to be new again. In that case it
+- * won't be removed until XID horizon advances enough to make it
+- * current again.
+- *
+- * XXX: This should happen in vac_truncate_clog(), not in checkpoints.
+- * Consider this scenario, starting from a system with no in-progress
+- * transactions and VACUUM FREEZE having maximized oldestXact:
+- * - Start a SERIALIZABLE transaction.
+- * - Start, finish, and summarize a SERIALIZABLE transaction, creating
+- * one SLRU page.
+- * - Consume XIDs to reach xidStopLimit.
+- * - Finish all transactions. Due to the long-running SERIALIZABLE
+- * transaction, earlier checkpoints did not touch headPage. The
+- * next checkpoint will change it, but that checkpoint happens after
+- * the end of the scenario.
+- * - VACUUM to advance XID limits.
+- * - Consume ~2M XIDs, crossing the former xidWrapLimit.
+- * - Start, finish, and summarize a SERIALIZABLE transaction.
+- * SerialAdd() declines to create the targetPage, because headPage
+- * is not regarded as in the past relative to that targetPage. The
+- * transaction instigating the summarize fails in
+- * SimpleLruReadPage().
+ */
+ truncateCutoffPage = serialControl->headPage;
+ serialControl->headPage = -1;
+@@ -3974,7 +3949,7 @@ XidIsConcurrent(TransactionId xid)
+ if (TransactionIdFollowsOrEquals(xid, snap->xmax))
+ return true;
+
+- return pg_lfind32(xid, snap->xip, snap->xcnt);
++ return pg_lfind64(xid, snap->xip, snap->xcnt);
+ }
+
+ bool
+diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
+index 720ef99ee83..512616dce37 100644
+--- a/src/backend/storage/lmgr/proc.c
++++ b/src/backend/storage/lmgr/proc.c
+@@ -217,7 +217,7 @@ InitProcGlobal(void)
+ * how hotly they are accessed.
+ */
+ ProcGlobal->xids =
+- (TransactionId *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->xids));
++ (pg_atomic_uint64 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->xids));
+ MemSet(ProcGlobal->xids, 0, TotalProcs * sizeof(*ProcGlobal->xids));
+ ProcGlobal->subxidStates = (XidCacheStatus *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->subxidStates));
+ MemSet(ProcGlobal->subxidStates, 0, TotalProcs * sizeof(*ProcGlobal->subxidStates));
+@@ -244,6 +244,8 @@ InitProcGlobal(void)
+
+ /* Common initialization for all PGPROCs, regardless of type. */
+
++ pg_atomic_init_u64(&ProcGlobal->xids[i], 0);
++
+ /*
+ * Set the fast-path lock arrays, and move the pointer. We interleave
+ * the two arrays, to (hopefully) get some locality for each backend.
+@@ -418,8 +420,8 @@ InitProcess(void)
+ MyProc->waitStatus = PROC_WAIT_STATUS_OK;
+ MyProc->fpVXIDLock = false;
+ MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
+- MyProc->xid = InvalidTransactionId;
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_init_u64(&MyProc->xid, InvalidTransactionId);
++ pg_atomic_init_u64(&MyProc->xmin, InvalidTransactionId);
+ MyProc->pid = MyProcPid;
+ MyProc->vxid.procNumber = MyProcNumber;
+ MyProc->vxid.lxid = InvalidLocalTransactionId;
+@@ -619,8 +621,8 @@ InitAuxiliaryProcess(void)
+ MyProc->waitStatus = PROC_WAIT_STATUS_OK;
+ MyProc->fpVXIDLock = false;
+ MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
+- MyProc->xid = InvalidTransactionId;
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_init_u64(&MyProc->xid, InvalidTransactionId);
++ pg_atomic_init_u64(&MyProc->xmin, InvalidTransactionId);
+ MyProc->vxid.procNumber = INVALID_PROC_NUMBER;
+ MyProc->vxid.lxid = InvalidLocalTransactionId;
+ MyProc->databaseId = InvalidOid;
+diff --git a/src/backend/storage/page/bufpage.c b/src/backend/storage/page/bufpage.c
+index aa264f61b9c..8528155ee36 100644
+--- a/src/backend/storage/page/bufpage.c
++++ b/src/backend/storage/page/bufpage.c
+@@ -21,11 +21,31 @@
+ #include "storage/checksum.h"
+ #include "utils/memdebug.h"
+ #include "utils/memutils.h"
++#include "utils/snapmgr.h"
+
+
+ /* GUC variable */
+ bool ignore_checksum_failure = false;
+
++/*
++ * HeapPageSpecialData used when pd_special == BLCKSZ. This is special format
++ * used when page with 32-bit xids doesn't fit HeapPageSpecialData. Then
++ * all xmin's are frozen (can do this for all live tuples after pg_upgrade),
++ * while 64-bit xmax is stored in both t_heap.t_xmin and t_heap.t_xmax.
++ * This is so-called "double xmax" format.
++ */
++static HeapPageSpecialData heapDoubleXmaxSpecialData =
++{
++ .pd_xid_base = MaxTransactionId,
++ .pd_multi_base = MaxTransactionId
++};
++HeapPageSpecial heapDoubleXmaxSpecial = &heapDoubleXmaxSpecialData;
++
++static ToastPageSpecialData toastDoubleXmaxSpecialData =
++{
++ .pd_xid_base = MaxTransactionId
++};
++ToastPageSpecial toastDoubleXmaxSpecial = &toastDoubleXmaxSpecialData;
+
+ /* ----------------------------------------------------------------
+ * Page support functions
+@@ -421,15 +441,144 @@ PageRestoreTempPage(Page tempPage, Page oldPage)
+ }
+
+ /*
+- * Tuple defrag support for PageRepairFragmentation and PageIndexMultiDelete
++ * Get minimum and maximum values of xid and multixact on "double xmax" page.
+ */
+-typedef struct itemIdCompactData
++static void
++heap_page_double_xmax_get_min_max(Page page,
++ TransactionId *xid_min,
++ TransactionId *xid_max,
++ MultiXactId *multi_min,
++ MultiXactId *multi_max)
+ {
+- uint16 offsetindex; /* linp array index */
+- int16 itemoff; /* page offset of item data */
+- uint16 alignedlen; /* MAXALIGN(item data len) */
+-} itemIdCompactData;
+-typedef itemIdCompactData *itemIdCompact;
++ bool xid_found = false,
++ multi_found = false;
++ OffsetNumber offnum,
++ maxoff;
++
++ maxoff = PageGetMaxOffsetNumber(page);
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ ItemId itemid;
++ HeapTupleHeader htup;
++ TransactionId xmax;
++
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++
++ xmax = HeapTupleHeaderGetDoubleXmax(htup);
++
++ if (!TransactionIdIsNormal(xmax))
++ continue;
++
++ if (!(htup->t_infomask & HEAP_XMAX_IS_MULTI))
++ {
++ if (!xid_found)
++ {
++ *xid_min = *xid_max = xmax;
++ xid_found = true;
++ }
++ else
++ {
++ *xid_min = Min(*xid_min, xmax);
++ *xid_max = Max(*xid_max, xmax);
++ }
++ }
++ else
++ {
++ if (!multi_found)
++ {
++ *multi_min = *multi_max = xmax;
++ multi_found = true;
++ }
++ else
++ {
++ *multi_min = Min(*multi_min, xmax);
++ *multi_max = Max(*multi_max, xmax);
++ }
++ }
++ }
++}
++
++/*
++ * Add special area to heap page, so convert from "double xmax" to normal
++ * format.
++ */
++static void
++heap_page_add_special_area(ItemIdCompact itemidbase, int nitems, Page page,
++ TransactionId xid_base, MultiXactId multi_base,
++ bool is_toast)
++{
++ char newPage[BLCKSZ];
++ PageHeader phdr = (PageHeader) page;
++ PageHeader new_phdr = (PageHeader) newPage;
++ Offset upper;
++ int i;
++
++ memcpy(newPage, page, phdr->pd_lower);
++
++ /* Add special area */
++ if (is_toast)
++ {
++ ToastPageSpecial special;
++
++ new_phdr->pd_special = PageGetPageSize(newPage) - sizeof(ToastPageSpecialData);
++ special = (ToastPageSpecial) ((Pointer) (newPage) + new_phdr->pd_special);
++ special->pd_xid_base = xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ new_phdr->pd_special = PageGetPageSize(newPage) - sizeof(HeapPageSpecialData);
++ special = (HeapPageSpecial) ((Pointer) (newPage) + new_phdr->pd_special);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
++ }
++
++ /* sort itemIdSortData array into decreasing itemoff order */
++ qsort((char *) itemidbase, nitems, sizeof(ItemIdCompactData),
++ itemoffcompare);
++
++ upper = new_phdr->pd_special;
++ for (i = 0; i < nitems; i++)
++ {
++ ItemIdCompact itemidptr = &itemidbase[i];
++ ItemId lp;
++ HeapTupleHeader old_htup;
++ HeapTupleHeader new_htup;
++ TransactionId xmax;
++
++ lp = PageGetItemId(page, itemidptr->offsetindex + 1);
++ old_htup = (HeapTupleHeader) PageGetItem(page, lp);
++ upper -= itemidptr->alignedlen;
++ memcpy((Pointer) newPage + upper,
++ (Pointer) page + itemidptr->itemoff,
++ itemidptr->alignedlen);
++ lp = PageGetItemId(newPage, itemidptr->offsetindex + 1);
++ lp->lp_off = upper;
++ new_htup = (HeapTupleHeader) PageGetItem(newPage, lp);
++
++ /* Convert xmax value */
++ new_htup->t_choice.t_heap.t_xmin = FrozenTransactionId;
++ xmax = HeapTupleHeaderGetDoubleXmax(old_htup);
++ if (!(new_htup->t_infomask & HEAP_XMAX_IS_MULTI))
++ new_htup->t_choice.t_heap.t_xmax = NormalTransactionIdToShort(xid_base, xmax);
++ else
++ new_htup->t_choice.t_heap.t_xmax = NormalTransactionIdToShort(multi_base, xmax);
++ }
++
++ new_phdr->pd_upper = upper;
++
++ memcpy(page, newPage, PageGetPageSize(newPage));
++ elog(DEBUG2, "convert heap page from double xmax to normal format");
++}
+
+ /*
+ * After removing or marking some line pointers unused, move the tuples to
+@@ -460,21 +609,47 @@ typedef itemIdCompactData *itemIdCompact;
+ * Callers must ensure that nitems is > 0
+ */
+ static void
+-compactify_tuples(itemIdCompact itemidbase, int nitems, Page page, bool presorted)
++compactify_tuples(ItemIdCompact itemidbase, int nitems, Page page,
++ bool presorted, bool addspecial, bool is_toast)
+ {
+ PageHeader phdr = (PageHeader) page;
+ Offset upper;
+ Offset copy_tail;
+ Offset copy_head;
+- itemIdCompact itemidptr;
++ ItemIdCompact itemidptr;
+ int i;
+
+ /* Code within will not work correctly if nitems == 0 */
+ Assert(nitems > 0);
+
+- if (presorted)
++ /* Add special area to the heap page if possible */
++ if (addspecial)
+ {
++ TransactionId xid_min = FirstNormalTransactionId,
++ xid_max = FirstNormalTransactionId;
++ MultiXactId multi_min = FirstNormalTransactionId,
++ multi_max = FirstNormalTransactionId;
+
++ Assert(phdr->pd_special == PageGetPageSize(page));
++
++ heap_page_double_xmax_get_min_max(page, &xid_min, &xid_max,
++ &multi_min, &multi_max);
++
++ if (xid_max - xid_min < (TransactionId) (MaxShortTransactionId - FirstNormalTransactionId) &&
++ multi_max - multi_min < (TransactionId) (MaxShortTransactionId - FirstNormalTransactionId))
++ {
++ Assert(xid_min >= FirstNormalTransactionId);
++ Assert(multi_min >= FirstNormalTransactionId);
++ heap_page_add_special_area(itemidbase, nitems, page,
++ xid_min - FirstNormalTransactionId,
++ multi_min - FirstNormalTransactionId,
++ is_toast);
++ return;
++ }
++ }
++
++ if (presorted)
++ {
+ #ifdef USE_ASSERT_CHECKING
+ {
+ /*
+@@ -685,14 +860,14 @@ compactify_tuples(itemIdCompact itemidbase, int nitems, Page page, bool presorte
+ * the line pointer array following array truncation.
+ */
+ void
+-PageRepairFragmentation(Page page)
++PageRepairFragmentation(Page page, bool is_toast)
+ {
+ Offset pd_lower = ((PageHeader) page)->pd_lower;
+ Offset pd_upper = ((PageHeader) page)->pd_upper;
+ Offset pd_special = ((PageHeader) page)->pd_special;
+ Offset last_offset;
+- itemIdCompactData itemidbase[MaxHeapTuplesPerPage];
+- itemIdCompact itemidptr;
++ ItemIdCompactData itemidbase[MaxHeapTuplesPerPage];
++ ItemIdCompact itemidptr;
+ ItemId lp;
+ int nline,
+ nstorage,
+@@ -766,11 +941,30 @@ PageRepairFragmentation(Page page)
+ nstorage = itemidptr - itemidbase;
+ if (nstorage == 0)
+ {
++ if (pd_special == PageGetPageSize(page))
++ {
++ if (is_toast)
++ {
++ pd_special = PageGetPageSize(page) - sizeof(ToastPageSpecialData);
++ ((PageHeader) page)->pd_special = pd_special;
++ ToastPageGetSpecial(page)->pd_xid_base = 0;
++ }
++ else
++ {
++ pd_special = PageGetPageSize(page) - sizeof(HeapPageSpecialData);
++ ((PageHeader) page)->pd_special = pd_special;
++ HeapPageGetSpecial(page)->pd_xid_base = 0;
++ HeapPageGetSpecial(page)->pd_multi_base = 0;
++ }
++ }
++
+ /* Page is completely empty, so just reset it quickly */
+ ((PageHeader) page)->pd_upper = pd_special;
+ }
+ else
+ {
++ bool addspecial = false;
++
+ /* Need to compact the page the hard way */
+ if (totallen > (Size) (pd_special - pd_lower))
+ ereport(ERROR,
+@@ -778,7 +972,25 @@ PageRepairFragmentation(Page page)
+ errmsg("corrupted item lengths: total %u, available space %u",
+ (unsigned int) totallen, pd_special - pd_lower)));
+
+- compactify_tuples(itemidbase, nstorage, page, presorted);
++ /*
++ * Try to add special area to the heap page if it has enough of free
++ * space.
++ */
++ if (pd_special == PageGetPageSize(page))
++ {
++ Size special_size,
++ actual_size;
++
++ special_size = is_toast ? sizeof(ToastPageSpecialData) :
++ sizeof(HeapPageSpecialData);
++ actual_size = (Size) (pd_special - pd_lower) - totallen;
++
++ if (actual_size >= special_size)
++ addspecial = true;
++ }
++
++ compactify_tuples(itemidbase, nstorage, page, presorted, addspecial,
++ is_toast);
+ }
+
+ if (finalusedlp != nline)
+@@ -981,6 +1193,9 @@ PageGetHeapFreeSpace(Page page)
+ {
+ Size space;
+
++ if (HeapPageIsDoubleXmax(page))
++ return 0;
++
+ space = PageGetFreeSpace(page);
+ if (space > 0)
+ {
+@@ -1154,9 +1369,9 @@ PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)
+ Offset pd_upper = phdr->pd_upper;
+ Offset pd_special = phdr->pd_special;
+ Offset last_offset;
+- itemIdCompactData itemidbase[MaxIndexTuplesPerPage];
++ ItemIdCompactData itemidbase[MaxIndexTuplesPerPage];
+ ItemIdData newitemids[MaxIndexTuplesPerPage];
+- itemIdCompact itemidptr;
++ ItemIdCompact itemidptr;
+ ItemId lp;
+ int nline,
+ nused;
+@@ -1264,7 +1479,12 @@ PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)
+
+ /* and compactify the tuple data */
+ if (nused > 0)
+- compactify_tuples(itemidbase, nused, page, presorted);
++ {
++ bool is_toast;
++
++ is_toast = BLCKSZ - pd_special == sizeof(ToastPageSpecialData);
++ compactify_tuples(itemidbase, nused, page, presorted, false, is_toast);
++ }
+ else
+ phdr->pd_upper = pd_special;
+ }
+diff --git a/src/backend/utils/adt/enum.c b/src/backend/utils/adt/enum.c
+index d4c2aa0e7e9..61c3bca4891 100644
+--- a/src/backend/utils/adt/enum.c
++++ b/src/backend/utils/adt/enum.c
+@@ -76,7 +76,7 @@ check_safe_enum_use(HeapTuple enumval_tup)
+ * Usually, a row would get hinted as committed when it's read or loaded
+ * into syscache; but just in case not, let's check the xmin directly.
+ */
+- xmin = HeapTupleHeaderGetXmin(enumval_tup->t_data);
++ xmin = HeapTupleGetXmin(enumval_tup);
+ if (!TransactionIdIsInProgress(xmin) &&
+ TransactionIdDidCommit(xmin))
+ return;
+diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
+index 68c0a31656e..80b9bc37b80 100644
+--- a/src/backend/utils/adt/jsonfuncs.c
++++ b/src/backend/utils/adt/jsonfuncs.c
+@@ -3565,6 +3565,7 @@ populate_record(TupleDesc tupdesc,
+ tuple.t_len = HeapTupleHeaderGetDatumLength(defaultval);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = defaultval;
+
+ /* Break down the tuple into fields */
+@@ -4027,6 +4028,7 @@ populate_recordset_record(PopulateRecordsetState *state, JsObject *obj)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(tuphead);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = tuphead;
+
+ tuplestore_puttuple(state->tuple_store, &tuple);
+diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c
+index e38cf548243..b07cfbc6bb1 100644
+--- a/src/backend/utils/adt/lockfuncs.c
++++ b/src/backend/utils/adt/lockfuncs.c
+@@ -78,7 +78,7 @@ VXIDGetDatum(ProcNumber procNumber, LocalTransactionId lxid)
+ * decimal respectively. Note that elog.c also knows how to format a
+ * vxid.
+ */
+- char vxidstr[32];
++ char vxidstr[64];
+
+ snprintf(vxidstr, sizeof(vxidstr), "%d/%llu", procNumber, (unsigned long long) lxid);
+
+@@ -291,7 +291,9 @@ pg_lock_status(PG_FUNCTION_ARGS)
+ break;
+ case LOCKTAG_TRANSACTION:
+ values[6] =
+- TransactionIdGetDatum(instance->locktag.locktag_field1);
++ TransactionIdGetDatum(
++ (TransactionId) instance->locktag.locktag_field1 |
++ ((TransactionId) instance->locktag.locktag_field2 << 32));
+ nulls[1] = true;
+ nulls[2] = true;
+ nulls[3] = true;
+@@ -303,7 +305,8 @@ pg_lock_status(PG_FUNCTION_ARGS)
+ break;
+ case LOCKTAG_VIRTUALTRANSACTION:
+ values[5] = VXIDGetDatum(instance->locktag.locktag_field1,
+- instance->locktag.locktag_field2);
++ (TransactionId) instance->locktag.locktag_field2 |
++ ((TransactionId) instance->locktag.locktag_field3 << 32));
+ nulls[1] = true;
+ nulls[2] = true;
+ nulls[3] = true;
+diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c
+index 60a397dc561..44fd9e0a39b 100644
+--- a/src/backend/utils/adt/pgstatfuncs.c
++++ b/src/backend/utils/adt/pgstatfuncs.c
+@@ -15,6 +15,7 @@
+ #include "postgres.h"
+
+ #include "access/htup_details.h"
++#include "access/xact.h"
+ #include "access/xlog.h"
+ #include "access/xlogprefetcher.h"
+ #include "catalog/catalog.h"
+diff --git a/src/backend/utils/adt/rowtypes.c b/src/backend/utils/adt/rowtypes.c
+index 18bbb62e9a1..2b7b855b1af 100644
+--- a/src/backend/utils/adt/rowtypes.c
++++ b/src/backend/utils/adt/rowtypes.c
+@@ -353,6 +353,7 @@ record_out(PG_FUNCTION_ARGS)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = rec;
+
+ /*
+@@ -711,6 +712,7 @@ record_send(PG_FUNCTION_ARGS)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = rec;
+
+ /*
+@@ -861,10 +863,12 @@ record_cmp(FunctionCallInfo fcinfo)
+ tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple1.t_data = record1;
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple2);
+ tuple2.t_data = record2;
+
+ /*
+@@ -1106,10 +1110,12 @@ record_eq(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
+ tuple1.t_data = record1;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
+ tuple2.t_data = record2;
++ HeapTupleSetZeroXids(&tuple2);
+
+ /*
+ * We arrange to look up the needed comparison info just once per series
+@@ -1386,10 +1392,12 @@ record_image_cmp(FunctionCallInfo fcinfo)
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
+ tuple1.t_data = record1;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
+ tuple2.t_data = record2;
++ HeapTupleSetZeroXids(&tuple2);
+
+ /*
+ * We arrange to look up the needed comparison info just once per series
+@@ -1632,10 +1640,12 @@ record_image_eq(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
+ tuple1.t_data = record1;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
+ tuple2.t_data = record2;
++ HeapTupleSetZeroXids(&tuple2);
+
+ /*
+ * We arrange to look up the needed comparison info just once per series
+@@ -1835,6 +1845,7 @@ hash_record(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = record;
++ HeapTupleSetZeroXids(&tuple);
+
+ /*
+ * We arrange to look up the needed hashing info just once per series of
+@@ -1956,6 +1967,7 @@ hash_record_extended(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = record;
++ HeapTupleSetZeroXids(&tuple);
+
+ /*
+ * We arrange to look up the needed hashing info just once per series of
+diff --git a/src/backend/utils/adt/xid.c b/src/backend/utils/adt/xid.c
+index 2f34a5dc1f0..060e0a76cdd 100644
+--- a/src/backend/utils/adt/xid.c
++++ b/src/backend/utils/adt/xid.c
+@@ -35,7 +35,7 @@ xidin(PG_FUNCTION_ARGS)
+ char *str = PG_GETARG_CSTRING(0);
+ TransactionId result;
+
+- result = uint32in_subr(str, NULL, "xid", fcinfo->context);
++ result = uint64in_subr(str, NULL, "xid", fcinfo->context);
+ PG_RETURN_TRANSACTIONID(result);
+ }
+
+@@ -43,9 +43,9 @@ Datum
+ xidout(PG_FUNCTION_ARGS)
+ {
+ TransactionId transactionId = PG_GETARG_TRANSACTIONID(0);
+- char *result = (char *) palloc(16);
++ char *result = (char *) palloc(32);
+
+- snprintf(result, 16, "%lu", (unsigned long) transactionId);
++ snprintf(result, 32, "%llu", (unsigned long long) transactionId);
+ PG_RETURN_CSTRING(result);
+ }
+
+@@ -56,8 +56,13 @@ Datum
+ xidrecv(PG_FUNCTION_ARGS)
+ {
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
++ uint32 lo,
++ hi;
++
++ lo = (uint32) pq_getmsgint(buf, sizeof(TransactionId));
++ hi = (uint32) pq_getmsgint(buf, sizeof(TransactionId));
+
+- PG_RETURN_TRANSACTIONID((TransactionId) pq_getmsgint(buf, sizeof(TransactionId)));
++ PG_RETURN_TRANSACTIONID((uint64) lo + ((uint64) hi << 32));
+ }
+
+ /*
+@@ -68,9 +73,15 @@ xidsend(PG_FUNCTION_ARGS)
+ {
+ TransactionId arg1 = PG_GETARG_TRANSACTIONID(0);
+ StringInfoData buf;
++ uint32 lo,
++ hi;
++
++ lo = (uint32) (arg1 & 0xFFFFFFFF);
++ hi = (uint32) (arg1 >> 32);
+
+ pq_begintypsend(&buf);
+- pq_sendint32(&buf, arg1);
++ pq_sendint(&buf, lo, sizeof(lo));
++ pq_sendint(&buf, hi, sizeof(hi));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
+
+@@ -121,9 +132,9 @@ xid_age(PG_FUNCTION_ARGS)
+
+ /* Permanent XIDs are always infinitely old */
+ if (!TransactionIdIsNormal(xid))
+- PG_RETURN_INT32(INT_MAX);
++ PG_RETURN_INT64(PG_INT8_MAX);
+
+- PG_RETURN_INT32((int32) (now - xid));
++ PG_RETURN_INT64((int64) (now - xid));
+ }
+
+ /*
+@@ -136,9 +147,9 @@ mxid_age(PG_FUNCTION_ARGS)
+ MultiXactId now = ReadNextMultiXactId();
+
+ if (!MultiXactIdIsValid(xid))
+- PG_RETURN_INT32(INT_MAX);
++ PG_RETURN_INT64(PG_INT8_MAX);
+
+- PG_RETURN_INT32((int32) (now - xid));
++ PG_RETURN_INT64((int64) (now - xid));
+ }
+
+ /*
+@@ -198,7 +209,7 @@ xid8in(PG_FUNCTION_ARGS)
+ uint64 result;
+
+ result = uint64in_subr(str, NULL, "xid8", fcinfo->context);
+- PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromU64(result));
++ PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromXid(result));
+ }
+
+ Datum
+@@ -207,7 +218,7 @@ xid8out(PG_FUNCTION_ARGS)
+ FullTransactionId fxid = PG_GETARG_FULLTRANSACTIONID(0);
+ char *result = (char *) palloc(21);
+
+- snprintf(result, 21, UINT64_FORMAT, U64FromFullTransactionId(fxid));
++ snprintf(result, 21, UINT64_FORMAT, XidFromFullTransactionId(fxid));
+ PG_RETURN_CSTRING(result);
+ }
+
+@@ -218,7 +229,7 @@ xid8recv(PG_FUNCTION_ARGS)
+ uint64 value;
+
+ value = (uint64) pq_getmsgint64(buf);
+- PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromU64(value));
++ PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromXid(value));
+ }
+
+ Datum
+@@ -228,7 +239,7 @@ xid8send(PG_FUNCTION_ARGS)
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+- pq_sendint64(&buf, (uint64) U64FromFullTransactionId(arg1));
++ pq_sendint64(&buf, (uint64) XidFromFullTransactionId(arg1));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
+
+diff --git a/src/backend/utils/adt/xid8funcs.c b/src/backend/utils/adt/xid8funcs.c
+index 12d20b72a03..2fe797f7769 100644
+--- a/src/backend/utils/adt/xid8funcs.c
++++ b/src/backend/utils/adt/xid8funcs.c
+@@ -86,8 +86,7 @@ StaticAssertDecl(MAX_BACKENDS * 2 <= PG_SNAPSHOT_MAX_NXIP,
+ * It is an ERROR if the xid is in the future. Otherwise, returns true if
+ * the transaction is still new enough that we can determine whether it
+ * committed and false otherwise. If *extracted_xid is not NULL, it is set
+- * to the low 32 bits of the transaction ID (i.e. the actual XID, without the
+- * epoch).
++ * to the actual transaction ID.
+ *
+ * The caller must hold XactTruncationLock since it's dealing with arbitrary
+ * XIDs, and must continue to hold it until it's done with any clog lookups
+@@ -97,15 +96,13 @@ static bool
+ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
+ {
+ TransactionId xid = XidFromFullTransactionId(fxid);
+- uint32 now_epoch;
+- TransactionId now_epoch_next_xid;
++ TransactionId next_xid;
+ FullTransactionId now_fullxid;
+ TransactionId oldest_xid;
+ FullTransactionId oldest_fxid;
+
+ now_fullxid = ReadNextFullTransactionId();
+- now_epoch_next_xid = XidFromFullTransactionId(now_fullxid);
+- now_epoch = EpochFromFullTransactionId(now_fullxid);
++ next_xid = XidFromFullTransactionId(now_fullxid);
+
+ if (extracted_xid != NULL)
+ *extracted_xid = xid;
+@@ -122,7 +119,7 @@ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("transaction ID %llu is in the future",
+- (unsigned long long) U64FromFullTransactionId(fxid))));
++ (unsigned long long) XidFromFullTransactionId(fxid))));
+
+ /*
+ * TransamVariables->oldestClogXid is protected by XactTruncationLock, but
+@@ -137,52 +134,14 @@ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
+ * If fxid is not older than TransamVariables->oldestClogXid, the relevant
+ * CLOG entry is guaranteed to still exist. Convert
+ * TransamVariables->oldestClogXid into a FullTransactionId to compare it
+- * with fxid. Determine the right epoch knowing that oldest_fxid
+- * shouldn't be more than 2^31 older than now_fullxid.
++ * with fxid.
+ */
+ oldest_xid = TransamVariables->oldestClogXid;
+- Assert(TransactionIdPrecedesOrEquals(oldest_xid, now_epoch_next_xid));
+- if (oldest_xid <= now_epoch_next_xid)
+- {
+- oldest_fxid = FullTransactionIdFromEpochAndXid(now_epoch, oldest_xid);
+- }
+- else
+- {
+- Assert(now_epoch > 0);
+- oldest_fxid = FullTransactionIdFromEpochAndXid(now_epoch - 1, oldest_xid);
+- }
++ oldest_fxid = FullTransactionIdFromXid(oldest_xid);
++ Assert(TransactionIdPrecedesOrEquals(oldest_xid, next_xid));
+ return !FullTransactionIdPrecedes(fxid, oldest_fxid);
+ }
+
+-/*
+- * Convert a TransactionId obtained from a snapshot held by the caller to a
+- * FullTransactionId. Use next_fxid as a reference FullTransactionId, so that
+- * we can compute the high order bits. It must have been obtained by the
+- * caller with ReadNextFullTransactionId() after the snapshot was created.
+- */
+-static FullTransactionId
+-widen_snapshot_xid(TransactionId xid, FullTransactionId next_fxid)
+-{
+- TransactionId next_xid = XidFromFullTransactionId(next_fxid);
+- uint32 epoch = EpochFromFullTransactionId(next_fxid);
+-
+- /* Special transaction ID. */
+- if (!TransactionIdIsNormal(xid))
+- return FullTransactionIdFromEpochAndXid(0, xid);
+-
+- /*
+- * The 64 bit result must be <= next_fxid, since next_fxid hadn't been
+- * issued yet when the snapshot was created. Every TransactionId in the
+- * snapshot must therefore be from the same epoch as next_fxid, or the
+- * epoch before. We know this because next_fxid is never allow to get
+- * more than one epoch ahead of the TransactionIds in any snapshot.
+- */
+- if (xid > next_xid)
+- epoch--;
+-
+- return FullTransactionIdFromEpochAndXid(epoch, xid);
+-}
+-
+ /*
+ * txid comparator for qsort/bsearch
+ */
+@@ -309,12 +268,12 @@ parse_snapshot(const char *str, Node *escontext)
+ char *endp;
+ StringInfo buf;
+
+- xmin = FullTransactionIdFromU64(strtou64(str, &endp, 10));
++ xmin = FullTransactionIdFromXid(strtou64(str, &endp, 10));
+ if (*endp != ':')
+ goto bad_format;
+ str = endp + 1;
+
+- xmax = FullTransactionIdFromU64(strtou64(str, &endp, 10));
++ xmax = FullTransactionIdFromXid(strtou64(str, &endp, 10));
+ if (*endp != ':')
+ goto bad_format;
+ str = endp + 1;
+@@ -332,7 +291,7 @@ parse_snapshot(const char *str, Node *escontext)
+ while (*str != '\0')
+ {
+ /* read next value */
+- val = FullTransactionIdFromU64(strtou64(str, &endp, 10));
++ val = FullTransactionIdFromXid(strtou64(str, &endp, 10));
+ str = endp;
+
+ /* require the input to be in order */
+@@ -410,7 +369,6 @@ pg_current_snapshot(PG_FUNCTION_ARGS)
+ uint32 nxip,
+ i;
+ Snapshot cur;
+- FullTransactionId next_fxid = ReadNextFullTransactionId();
+
+ cur = GetActiveSnapshot();
+ if (cur == NULL)
+@@ -421,11 +379,11 @@ pg_current_snapshot(PG_FUNCTION_ARGS)
+ snap = palloc(PG_SNAPSHOT_SIZE(nxip));
+
+ /* fill */
+- snap->xmin = widen_snapshot_xid(cur->xmin, next_fxid);
+- snap->xmax = widen_snapshot_xid(cur->xmax, next_fxid);
++ snap->xmin = FullTransactionIdFromXid(cur->xmin);
++ snap->xmax = FullTransactionIdFromXid(cur->xmax);
+ snap->nxip = nxip;
+ for (i = 0; i < nxip; i++)
+- snap->xip[i] = widen_snapshot_xid(cur->xip[i], next_fxid);
++ snap->xip[i] = FullTransactionIdFromXid(cur->xip[i]);
+
+ /*
+ * We want them guaranteed to be in ascending order. This also removes
+@@ -473,16 +431,16 @@ pg_snapshot_out(PG_FUNCTION_ARGS)
+ initStringInfo(&str);
+
+ appendStringInfo(&str, UINT64_FORMAT ":",
+- U64FromFullTransactionId(snap->xmin));
++ XidFromFullTransactionId(snap->xmin));
+ appendStringInfo(&str, UINT64_FORMAT ":",
+- U64FromFullTransactionId(snap->xmax));
++ XidFromFullTransactionId(snap->xmax));
+
+ for (i = 0; i < snap->nxip; i++)
+ {
+ if (i > 0)
+ appendStringInfoChar(&str, ',');
+ appendStringInfo(&str, UINT64_FORMAT,
+- U64FromFullTransactionId(snap->xip[i]));
++ XidFromFullTransactionId(snap->xip[i]));
+ }
+
+ PG_RETURN_CSTRING(str.data);
+@@ -511,8 +469,8 @@ pg_snapshot_recv(PG_FUNCTION_ARGS)
+ if (nxip < 0 || nxip > PG_SNAPSHOT_MAX_NXIP)
+ goto bad_format;
+
+- xmin = FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
+- xmax = FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
++ xmin = FullTransactionIdFromXid((uint64) pq_getmsgint64(buf));
++ xmax = FullTransactionIdFromXid((uint64) pq_getmsgint64(buf));
+ if (!FullTransactionIdIsValid(xmin) ||
+ !FullTransactionIdIsValid(xmax) ||
+ FullTransactionIdPrecedes(xmax, xmin))
+@@ -525,7 +483,7 @@ pg_snapshot_recv(PG_FUNCTION_ARGS)
+ for (i = 0; i < nxip; i++)
+ {
+ FullTransactionId cur =
+- FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
++ FullTransactionIdFromXid((uint64) pq_getmsgint64(buf));
+
+ if (FullTransactionIdPrecedes(cur, last) ||
+ FullTransactionIdPrecedes(cur, xmin) ||
+@@ -570,10 +528,10 @@ pg_snapshot_send(PG_FUNCTION_ARGS)
+
+ pq_begintypsend(&buf);
+ pq_sendint32(&buf, snap->nxip);
+- pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xmin));
+- pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xmax));
++ pq_sendint64(&buf, (int64) XidFromFullTransactionId(snap->xmin));
++ pq_sendint64(&buf, (int64) XidFromFullTransactionId(snap->xmax));
+ for (i = 0; i < snap->nxip; i++)
+- pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xip[i]));
++ pq_sendint64(&buf, (int64) XidFromFullTransactionId(snap->xip[i]));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
+
+@@ -661,8 +619,7 @@ pg_snapshot_xip(PG_FUNCTION_ARGS)
+ * Report the status of a recent transaction ID, or null for wrapped,
+ * truncated away or otherwise too old XIDs.
+ *
+- * The passed epoch-qualified xid is treated as a normal xid, not a
+- * multixact id.
++ * The passed xid is treated as a normal xid, not a multixact id.
+ *
+ * If it points to a committed subxact the result is the subxact status even
+ * though the parent xact may still be in progress or may have aborted.
+diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
+index ee303dc501d..3eb918fc006 100644
+--- a/src/backend/utils/cache/catcache.c
++++ b/src/backend/utils/cache/catcache.c
+@@ -2123,6 +2123,7 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, SysScanDesc scandesc,
+ memcpy((char *) ct->tuple.t_data,
+ (const char *) dtp->t_data,
+ dtp->t_len);
++ HeapTupleCopyXids(&ct->tuple, dtp);
+ MemoryContextSwitchTo(oldcxt);
+
+ if (dtp != ntp)
+diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
+index 422509f18d7..ee7cf197a8f 100644
+--- a/src/backend/utils/cache/relcache.c
++++ b/src/backend/utils/cache/relcache.c
+@@ -2325,8 +2325,7 @@ RelationReloadIndexInfo(Relation relation)
+ relation->rd_index->indisreplident = index->indisreplident;
+
+ /* Copy xmin too, as that is needed to make sense of indcheckxmin */
+- HeapTupleHeaderSetXmin(relation->rd_indextuple->t_data,
+- HeapTupleHeaderGetXmin(tuple->t_data));
++ HeapTupleSetXmin(relation->rd_indextuple, HeapTupleGetXmin(tuple));
+
+ ReleaseSysCache(tuple);
+ }
+diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c
+index e48a86be54b..31c52a8b9f4 100644
+--- a/src/backend/utils/fmgr/fmgr.c
++++ b/src/backend/utils/fmgr/fmgr.c
+@@ -526,7 +526,7 @@ lookup_C_func(HeapTuple procedureTuple)
+ NULL);
+ if (entry == NULL)
+ return NULL; /* no such entry */
+- if (entry->fn_xmin == HeapTupleHeaderGetRawXmin(procedureTuple->t_data) &&
++ if (entry->fn_xmin == HeapTupleGetRawXmin(procedureTuple) &&
+ ItemPointerEquals(&entry->fn_tid, &procedureTuple->t_self))
+ return entry; /* OK */
+ return NULL; /* entry is out of date */
+@@ -562,7 +562,7 @@ record_C_func(HeapTuple procedureTuple,
+ HASH_ENTER,
+ &found);
+ /* OID is already filled in */
+- entry->fn_xmin = HeapTupleHeaderGetRawXmin(procedureTuple->t_data);
++ entry->fn_xmin = HeapTupleGetRawXmin(procedureTuple);
+ entry->fn_tid = procedureTuple->t_self;
+ entry->user_fn = user_fn;
+ entry->inforec = inforec;
+diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
+index dd0048fb03e..c353c8800c7 100644
+--- a/src/backend/utils/misc/guc_tables.c
++++ b/src/backend/utils/misc/guc_tables.c
+@@ -2734,65 +2734,6 @@ struct config_int ConfigureNamesInt[] =
+ NULL, NULL, NULL
+ },
+
+- {
+- {"vacuum_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Minimum age at which VACUUM should freeze a table row."),
+- NULL
+- },
+- &vacuum_freeze_min_age,
+- 50000000, 0, 1000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
+- NULL
+- },
+- &vacuum_freeze_table_age,
+- 150000000, 0, 2000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_multixact_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
+- NULL
+- },
+- &vacuum_multixact_freeze_min_age,
+- 5000000, 0, 1000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_multixact_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Multixact age at which VACUUM should scan whole table to freeze tuples."),
+- NULL
+- },
+- &vacuum_multixact_freeze_table_age,
+- 150000000, 0, 2000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
+- NULL
+- },
+- &vacuum_failsafe_age,
+- 1600000000, 0, 2100000000,
+- NULL, NULL, NULL
+- },
+- {
+- {"vacuum_multixact_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Multixact age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
+- NULL
+- },
+- &vacuum_multixact_failsafe_age,
+- 1600000000, 0, 2100000000,
+- NULL, NULL, NULL
+- },
+-
+ /*
+ * See also CheckRequiredParameterValues() if this parameter changes
+ */
+@@ -3444,28 +3385,6 @@ struct config_int ConfigureNamesInt[] =
+ 50, 0, INT_MAX,
+ NULL, NULL, NULL
+ },
+- {
+- /* see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
+- {"autovacuum_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
+- gettext_noop("Age at which to autovacuum a table to prevent transaction ID wraparound."),
+- NULL
+- },
+- &autovacuum_freeze_max_age,
+-
+- /* see vacuum_failsafe_age if you change the upper-limit value. */
+- 200000000, 100000, 2000000000,
+- NULL, NULL, NULL
+- },
+- {
+- /* see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
+- {"autovacuum_multixact_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
+- gettext_noop("Multixact age at which to autovacuum a table to prevent multixact wraparound."),
+- NULL
+- },
+- &autovacuum_multixact_freeze_max_age,
+- 400000000, 10000, 2000000000,
+- NULL, NULL, NULL
+- },
+ {
+ /* see max_connections */
+ {"autovacuum_max_workers", PGC_POSTMASTER, AUTOVACUUM,
+@@ -3733,7 +3652,6 @@ struct config_int ConfigureNamesInt[] =
+ SCRAM_SHA_256_DEFAULT_ITERATIONS, 1, INT_MAX,
+ NULL, NULL, NULL
+ },
+-
+ /* End-of-list marker */
+ {
+ {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
+@@ -3743,6 +3661,87 @@ struct config_int ConfigureNamesInt[] =
+
+ struct config_int64 ConfigureNamesInt64[] =
+ {
++ {
++ {"vacuum_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Minimum age at which VACUUM should freeze a table row."),
++ NULL
++ },
++ &vacuum_freeze_min_age,
++ INT64CONST(50000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
++ NULL
++ },
++ &vacuum_freeze_table_age,
++ INT64CONST(150000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_multixact_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
++ NULL
++ },
++ &vacuum_multixact_freeze_min_age,
++ INT64CONST(5000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_multixact_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Multixact age at which VACUUM should scan whole table to freeze tuples."),
++ NULL
++ },
++ &vacuum_multixact_freeze_table_age,
++ INT64CONST(150000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
++ NULL
++ },
++ &vacuum_failsafe_age,
++ INT64CONST(1600000000), INT64CONST(0), INT64CONST(2100000000),
++ NULL, NULL, NULL
++ },
++ {
++ {"vacuum_multixact_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Multixact age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
++ NULL
++ },
++ &vacuum_multixact_failsafe_age,
++ INT64CONST(1600000000), INT64CONST(0), INT64CONST(2100000000),
++ NULL, NULL, NULL
++ },
++ {
++ /* see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
++ {"autovacuum_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
++ gettext_noop("Age at which to autovacuum a table to prevent transaction ID wraparound."),
++ NULL
++ },
++ &autovacuum_freeze_max_age,
++
++ /* see vacuum_failsafe_age if you change the upper-limit value. */
++ INT64CONST(10000000000), INT64CONST(100000), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++ {
++ /* see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
++ {"autovacuum_multixact_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
++ gettext_noop("Multixact age at which to autovacuum a table to prevent multixact wraparound."),
++ NULL
++ },
++ &autovacuum_multixact_freeze_max_age,
++ INT64CONST(20000000000), INT64CONST(10000), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
+ /* End-of-list marker */
+ {
+ {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
+@@ -3750,6 +3749,7 @@ struct config_int64 ConfigureNamesInt64[] =
+ };
+
+
++
+ struct config_real ConfigureNamesReal[] =
+ {
+ {
+diff --git a/src/backend/utils/misc/help_config.c b/src/backend/utils/misc/help_config.c
+index 4729a19a132..3dce3498ee9 100644
+--- a/src/backend/utils/misc/help_config.c
++++ b/src/backend/utils/misc/help_config.c
+@@ -33,6 +33,7 @@ typedef union
+ struct config_bool _bool;
+ struct config_real real;
+ struct config_int integer;
++ struct config_int64 integer8;
+ struct config_string string;
+ struct config_enum _enum;
+ } mixedStruct;
+@@ -106,7 +107,12 @@ printMixedStruct(mixedStruct *structToPrint)
+ structToPrint->integer.min,
+ structToPrint->integer.max);
+ break;
+-
++ case PGC_INT64:
++ printf("INT64\t%lld\t%lld\t%lld\t",
++ (long long) structToPrint->integer8.reset_val,
++ (long long) structToPrint->integer8.min,
++ (long long) structToPrint->integer8.max);
++ break;
+ case PGC_REAL:
+ printf("REAL\t%g\t%g\t%g\t",
+ structToPrint->real.reset_val,
+diff --git a/src/backend/utils/misc/pg_controldata.c b/src/backend/utils/misc/pg_controldata.c
+index 1cb101fe821..a06f9c80052 100644
+--- a/src/backend/utils/misc/pg_controldata.c
++++ b/src/backend/utils/misc/pg_controldata.c
+@@ -117,7 +117,7 @@ pg_control_checkpoint(PG_FUNCTION_ARGS)
+ nulls[5] = false;
+
+ values[6] = CStringGetTextDatum(psprintf("%llu",
+- (unsigned long long) U64FromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
++ (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
+ nulls[6] = false;
+
+ values[7] = ObjectIdGetDatum(ControlFile->checkPointCopy.nextOid);
+diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
+index a2ac7575ca7..1fedbdf9d44 100644
+--- a/src/backend/utils/misc/postgresql.conf.sample
++++ b/src/backend/utils/misc/postgresql.conf.sample
+@@ -675,7 +675,7 @@
+ #autovacuum_vacuum_insert_scale_factor = 0.2 # fraction of inserts over table
+ # size before insert vacuum
+ #autovacuum_analyze_scale_factor = 0.1 # fraction of table size before analyze
+-#autovacuum_freeze_max_age = 200000000 # maximum XID age before forced vacuum
++#autovacuum_freeze_max_age = 10000000000 # maximum XID age before forced vacuum
+ # (change requires restart)
+ #autovacuum_multixact_freeze_max_age = 400000000 # maximum multixact age
+ # before forced vacuum
+diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
+index e07ba4ea4b1..76ea9ac8c83 100644
+--- a/src/backend/utils/sort/tuplesortvariants.c
++++ b/src/backend/utils/sort/tuplesortvariants.c
+@@ -1342,11 +1342,16 @@ writetup_cluster(Tuplesortstate *state, LogicalTape *tape, SortTuple *stup)
+ {
+ TuplesortPublic *base = TuplesortstateGetPublic(state);
+ HeapTuple tuple = (HeapTuple) stup->tuple;
+- unsigned int tuplen = tuple->t_len + sizeof(ItemPointerData) + sizeof(int);
++ unsigned int tuplen = tuple->t_len +
++ sizeof(ItemPointerData) +
++ 2 * sizeof(TransactionId) + /* tuple xmin, xmax */
++ sizeof(int);
+
+ /* We need to store t_self, but not other fields of HeapTupleData */
+ LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
+ LogicalTapeWrite(tape, &tuple->t_self, sizeof(ItemPointerData));
++ LogicalTapeWrite(tape, &tuple->t_xmin, sizeof(TransactionId));
++ LogicalTapeWrite(tape, &tuple->t_xmax, sizeof(TransactionId));
+ LogicalTapeWrite(tape, tuple->t_data, tuple->t_len);
+ if (base->sortopt & TUPLESORT_RANDOMACCESS) /* need trailing length word? */
+ LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
+@@ -1358,7 +1363,10 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
+ {
+ TuplesortPublic *base = TuplesortstateGetPublic(state);
+ TuplesortClusterArg *arg = (TuplesortClusterArg *) base->arg;
+- unsigned int t_len = tuplen - sizeof(ItemPointerData) - sizeof(int);
++ unsigned int t_len = tuplen -
++ sizeof(ItemPointerData) -
++ 2 * sizeof(TransactionId) - /* tuple xmin, xmax */
++ sizeof(int);
+ HeapTuple tuple = (HeapTuple) tuplesort_readtup_alloc(state,
+ t_len + HEAPTUPLESIZE);
+
+@@ -1366,6 +1374,8 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
+ tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
+ tuple->t_len = t_len;
+ LogicalTapeReadExact(tape, &tuple->t_self, sizeof(ItemPointerData));
++ LogicalTapeReadExact(tape, &tuple->t_xmin, sizeof(TransactionId));
++ LogicalTapeReadExact(tape, &tuple->t_xmax, sizeof(TransactionId));
+ /* We don't currently bother to reconstruct t_tableOid */
+ tuple->t_tableOid = InvalidOid;
+ /* Read in the tuple body */
+diff --git a/src/backend/utils/time/combocid.c b/src/backend/utils/time/combocid.c
+index f85510b74ff..9b040e76bcd 100644
+--- a/src/backend/utils/time/combocid.c
++++ b/src/backend/utils/time/combocid.c
+@@ -101,12 +101,13 @@ static CommandId GetRealCmax(CommandId combocid);
+ */
+
+ CommandId
+-HeapTupleHeaderGetCmin(HeapTupleHeader tup)
++HeapTupleGetCmin(HeapTuple tuple)
+ {
++ HeapTupleHeader tup = tuple->t_data;
+ CommandId cid = HeapTupleHeaderGetRawCommandId(tup);
+
+ Assert(!(tup->t_infomask & HEAP_MOVED));
+- Assert(TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tup)));
++ Assert(TransactionIdIsCurrentTransactionId(HeapTupleGetXmin(tuple)));
+
+ if (tup->t_infomask & HEAP_COMBOCID)
+ return GetRealCmin(cid);
+@@ -115,8 +116,9 @@ HeapTupleHeaderGetCmin(HeapTupleHeader tup)
+ }
+
+ CommandId
+-HeapTupleHeaderGetCmax(HeapTupleHeader tup)
++HeapTupleGetCmax(HeapTuple tuple)
+ {
++ HeapTupleHeader tup = tuple->t_data;
+ CommandId cid = HeapTupleHeaderGetRawCommandId(tup);
+
+ Assert(!(tup->t_infomask & HEAP_MOVED));
+@@ -128,7 +130,7 @@ HeapTupleHeaderGetCmax(HeapTupleHeader tup)
+ * things too much.
+ */
+ Assert(CritSectionCount > 0 ||
+- TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tup)));
++ TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(tuple)));
+
+ if (tup->t_infomask & HEAP_COMBOCID)
+ return GetRealCmax(cid);
+@@ -150,9 +152,7 @@ HeapTupleHeaderGetCmax(HeapTupleHeader tup)
+ * changes the tuple in shared buffers.
+ */
+ void
+-HeapTupleHeaderAdjustCmax(HeapTupleHeader tup,
+- CommandId *cmax,
+- bool *iscombo)
++HeapTupleAdjustCmax(HeapTuple tup, CommandId *cmax, bool *iscombo)
+ {
+ /*
+ * If we're marking a tuple deleted that was inserted by (any
+@@ -160,10 +160,10 @@ HeapTupleHeaderAdjustCmax(HeapTupleHeader tup,
+ * Test for HeapTupleHeaderXminCommitted() first, because it's cheaper
+ * than a TransactionIdIsCurrentTransactionId call.
+ */
+- if (!HeapTupleHeaderXminCommitted(tup) &&
+- TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tup)))
++ if (!HeapTupleHeaderXminCommitted(tup->t_data) &&
++ TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(tup)))
+ {
+- CommandId cmin = HeapTupleHeaderGetCmin(tup);
++ CommandId cmin = HeapTupleGetCmin(tup);
+
+ *cmax = GetComboCommandId(cmin, *cmax);
+ *iscombo = true;
+diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c
+index 09919ec651b..4becbe9197c 100644
+--- a/src/backend/utils/time/snapmgr.c
++++ b/src/backend/utils/time/snapmgr.c
+@@ -920,15 +920,15 @@ SnapshotResetXmin(void)
+
+ if (pairingheap_is_empty(&RegisteredSnapshots))
+ {
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&MyProc->xmin, InvalidTransactionId);
+ return;
+ }
+
+ minSnapshot = pairingheap_container(SnapshotData, ph_node,
+ pairingheap_first(&RegisteredSnapshots));
+
+- if (TransactionIdPrecedes(MyProc->xmin, minSnapshot->xmin))
+- MyProc->xmin = minSnapshot->xmin;
++ if (TransactionIdPrecedes(pg_atomic_read_u64(&MyProc->xmin), minSnapshot->xmin))
++ pg_atomic_write_u64(&MyProc->xmin, minSnapshot->xmin);
+ }
+
+ /*
+@@ -1081,7 +1081,7 @@ AtEOXact_Snapshot(bool isCommit, bool resetXmin)
+ if (resetXmin)
+ SnapshotResetXmin();
+
+- Assert(resetXmin || MyProc->xmin == 0);
++ Assert(resetXmin || pg_atomic_read_u64(&MyProc->xmin) == 0);
+ }
+
+
+@@ -1146,9 +1146,9 @@ ExportSnapshot(Snapshot snapshot)
+ * Generate file path for the snapshot. We start numbering of snapshots
+ * inside the transaction from 1.
+ */
+- snprintf(path, sizeof(path), SNAPSHOT_EXPORT_DIR "/%08X-%08X-%d",
+- MyProc->vxid.procNumber, MyProc->vxid.lxid,
+- list_length(exportedSnapshots) + 1);
++ snprintf(path, sizeof(path), SNAPSHOT_EXPORT_DIR "/%08X-%08X%08X-%d",
++ MyProc->vxid.procNumber, (uint32) (MyProc->vxid.lxid >> 32),
++ (uint32) MyProc->vxid.lxid, list_length(exportedSnapshots) + 1);
+
+ /*
+ * Copy the snapshot into TopTransactionContext, add it to the
+@@ -1323,7 +1323,7 @@ parseXidFromText(const char *prefix, char **s, const char *filename)
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+ ptr += prefixlen;
+- if (sscanf(ptr, "%u", &val) != 1)
++ if (sscanf(ptr, "%" PRIu64 "u", &val) != 1)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+@@ -1348,7 +1348,7 @@ parseVxidFromText(const char *prefix, char **s, const char *filename,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+ ptr += prefixlen;
+- if (sscanf(ptr, "%d/%u", &vxid->procNumber, &vxid->localTransactionId) != 2)
++ if (sscanf(ptr, "%d/%" PRIu64 "u", &vxid->procNumber, &vxid->localTransactionId) != 2)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+@@ -1889,7 +1889,7 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
+ if (!snapshot->suboverflowed)
+ {
+ /* we have full data, so search subxip */
+- if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
++ if (pg_lfind64(xid, snapshot->subxip, snapshot->subxcnt))
+ return true;
+
+ /* not there, fall through to search xip[] */
+@@ -1911,7 +1911,7 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
+ return false;
+ }
+
+- if (pg_lfind32(xid, snapshot->xip, snapshot->xcnt))
++ if (pg_lfind64(xid, snapshot->xip, snapshot->xcnt))
+ return true;
+ }
+ else
+@@ -1945,7 +1945,7 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
+ * indeterminate xid. We don't know whether it's top level or subxact
+ * but it doesn't matter. If it's present, the xid is visible.
+ */
+- if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
++ if (pg_lfind64(xid, snapshot->subxip, snapshot->subxcnt))
+ return true;
+ }
+
+diff --git a/src/bin/pg_amcheck/t/004_verify_heapam.pl b/src/bin/pg_amcheck/t/004_verify_heapam.pl
+index 250a3eb981f..02c3e12b804 100644
+--- a/src/bin/pg_amcheck/t/004_verify_heapam.pl
++++ b/src/bin/pg_amcheck/t/004_verify_heapam.pl
+@@ -8,6 +8,7 @@ use PostgreSQL::Test::Cluster;
+ use PostgreSQL::Test::Utils;
+
+ use Test::More;
++use Data::Dumper;
+
+ # This regression test demonstrates that the pg_amcheck binary correctly
+ # identifies specific kinds of corruption within pages. To test this, we need
+@@ -85,6 +86,65 @@ use Test::More;
+
+ use constant HEAPTUPLE_PACK_CODE => 'LLLSSSSSCCLLCCCCCCCCCCllLL';
+ use constant HEAPTUPLE_PACK_LENGTH => 58; # Total size
++use constant HEAPPAGE_SPECIAL_PACK_CODE => 'QQ';
++use constant HEAPPAGE_SPECIAL_PACK_LENGTH => 16;
++use constant HEAPPAGE_SIZE => 8192;
++
++# Some #define constants from access/htup_details.h for use while corrupting.
++use constant HEAP_HASNULL => 0x0001;
++use constant HEAP_XMAX_LOCK_ONLY => 0x0080;
++use constant HEAP_XMIN_COMMITTED => 0x0100;
++use constant HEAP_XMIN_INVALID => 0x0200;
++use constant HEAP_XMAX_COMMITTED => 0x0400;
++use constant HEAP_XMAX_INVALID => 0x0800;
++use constant HEAP_NATTS_MASK => 0x07FF;
++use constant HEAP_XMAX_IS_MULTI => 0x1000;
++use constant HEAP_KEYS_UPDATED => 0x2000;
++use constant HEAP_HOT_UPDATED => 0x4000;
++use constant HEAP_ONLY_TUPLE => 0x8000;
++use constant HEAP_UPDATED => 0x2000;
++
++use constant FIRST_NORMAL_TRANSACTION_ID => 3;
++
++# Read page special data
++sub read_special_data
++{
++ my ($fh, $offset) = @_;
++ my ($buffer, %special);
++
++ $offset -= $offset % HEAPPAGE_SIZE;
++ $offset += HEAPPAGE_SIZE - HEAPPAGE_SPECIAL_PACK_LENGTH;
++
++ sysseek($fh, $offset, 0)
++ or BAIL_OUT("sysseek failed: $!");
++ defined(sysread($fh, $buffer, HEAPPAGE_SPECIAL_PACK_LENGTH))
++ or BAIL_OUT("sysread failed: $!");
++
++ @_ = unpack(HEAPPAGE_SPECIAL_PACK_CODE, $buffer);
++ %special = (
++ pd_xid_base => shift,
++ pd_multi_base => shift);
++ return \%special;
++}
++
++# Write page special data
++sub write_special_data
++{
++ my ($fh, $offset, $special) = @_;
++
++ $offset -= $offset % HEAPPAGE_SIZE;
++ $offset += HEAPPAGE_SIZE - HEAPPAGE_SPECIAL_PACK_LENGTH;
++
++ my $buffer = pack(
++ HEAPPAGE_SPECIAL_PACK_CODE,
++ $special->{pd_xid_base}, $special->{pd_multi_base});
++
++ sysseek($fh, $offset, 0)
++ or BAIL_OUT("sysseek failed: $!");
++ defined(syswrite($fh, $buffer, HEAPPAGE_SPECIAL_PACK_LENGTH))
++ or BAIL_OUT("syswrite failed: $!");
++ return;
++}
+
+ # Read a tuple of our table from a heap page.
+ #
+@@ -96,8 +156,9 @@ use constant HEAPTUPLE_PACK_LENGTH => 58; # Total size
+ #
+ sub read_tuple
+ {
+- my ($fh, $offset) = @_;
++ my ($fh, $offset, $raw) = @_;
+ my ($buffer, %tup);
++
+ sysseek($fh, $offset, 0)
+ or BAIL_OUT("sysseek failed: $!");
+ defined(sysread($fh, $buffer, HEAPTUPLE_PACK_LENGTH))
+@@ -133,6 +194,18 @@ sub read_tuple
+ c_va_toastrelid => shift);
+ # Stitch together the text for column 'b'
+ $tup{b} = join('', map { chr($tup{"b_body$_"}) } (1 .. 7));
++
++ if (!$raw)
++ {
++ my $special = read_special_data($fh, $offset);
++
++ $tup{t_xmin} += $special->{pd_xid_base};
++ my $is_multi = $tup{t_infomask} & HEAP_XMAX_IS_MULTI;
++ $tup{t_xmax} += !$is_multi ?
++ $special->{pd_xid_base} :
++ $special->{pd_multi_base};
++ }
++
+ return \%tup;
+ }
+
+@@ -148,7 +221,39 @@ sub read_tuple
+ #
+ sub write_tuple
+ {
+- my ($fh, $offset, $tup) = @_;
++ my ($fh, $offset, $tup, $raw) = @_;
++
++ if (!$raw)
++ {
++ my $special = read_special_data($fh, $offset);
++
++ if ($tup->{t_xmin} >= 3)
++ {
++ my $xmin = $tup->{t_xmin} - $special->{pd_xid_base};
++ die "tuple x_min $tup->{t_xmin} is too smal for pd_xid_base $special->{pd_xid_base}"
++ if $xmin < 3;
++ $tup->{t_xmin} = $xmin;
++ }
++
++ if ($tup->{t_xmax} >= 3)
++ {
++ if (($tup->{t_infomask} & HEAP_XMAX_IS_MULTI) == 0)
++ {
++ my $xmax = $tup->{t_xmax} - $special->{pd_xid_base};
++ die "tuple x_max $tup->{t_xmax} is too smal for pd_xid_base $special->{pd_xid_base}"
++ if $xmax < 3;
++ $tup->{t_xmax} = $xmax;
++ }
++ else
++ {
++ my $xmax = $tup->{t_xmax} - $special->{pd_multi_base};
++ die "tuple multi x_max $tup->{t_xmax} is too smal for pd_multi_base $special->{pd_multi_base}"
++ if $xmax < 3;
++ $tup->{t_xmax} = $xmax;
++ }
++ }
++ }
++
+ my $buffer = pack(
+ HEAPTUPLE_PACK_CODE,
+ $tup->{t_xmin}, $tup->{t_xmax},
+@@ -171,6 +276,42 @@ sub write_tuple
+ return;
+ }
+
++# move pd_xid_base and pd_multi_base to more suitable position for tests.
++sub fixup_page
++{
++ my ($fh, $page, $xid_base, $multi_base, $lp_off) = @_;
++ my $offset = $page * HEAPPAGE_SIZE;
++ my $special = read_special_data($fh, $offset);
++
++ die "xid_base $xid_base should be lesser than existed $special->{pd_xid_base}"
++ if ($xid_base > $special->{pd_xid_base});
++ die "multi_base $multi_base should be lesser than existed $special->{pd_multi_base}"
++ if ($multi_base > $special->{pd_multi_base} && $special->{pd_multi_base} != 0);
++ return if ($xid_base == $special->{pd_xid_base} &&
++ $multi_base == $special->{pd_multi_base});
++
++ my $xid_delta = $special->{pd_xid_base} - $xid_base;
++ my $multi_delta = $special->{pd_multi_base} - $multi_base;
++
++ for my $off (@$lp_off)
++ {
++ # change only tuples on this page.
++ next if ($off < $offset && $off > $offset + HEAPPAGE_SIZE);
++ next if ($off == -1);
++
++ my $tup = read_tuple($fh, $off, 1);
++ $tup->{t_xmin} += $xid_delta;
++ my $is_multi = $tup->{t_infomask} & HEAP_XMAX_IS_MULTI;
++ $tup->{t_xmax} += !$is_multi ? $xid_delta : $multi_delta;
++ write_tuple($fh, $off, $tup, 1);
++ }
++
++ $special->{pd_xid_base} = $xid_base;
++ $special->{pd_multi_base} = $multi_base;
++
++ write_special_data($fh, $offset, $special);
++}
++
+ # Set umask so test directories and files are created with default permissions
+ umask(0077);
+
+@@ -320,6 +461,8 @@ my $relfrozenxid = $node->safe_psql('postgres',
+ q(select relfrozenxid from pg_class where relname = 'test'));
+ my $datfrozenxid = $node->safe_psql('postgres',
+ q(select datfrozenxid from pg_database where datname = 'postgres'));
++my $datminmxid = $node->safe_psql('postgres',
++ q(select datminmxid from pg_database where datname = 'postgres'));
+
+ # Sanity check that our 'test' table has a relfrozenxid newer than the
+ # datfrozenxid for the database, and that the datfrozenxid is greater than the
+@@ -378,6 +521,11 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ # Determine endianness of current platform from the 1-byte varlena header
+ $ENDIANNESS = $tup->{b_header} == 0x11 ? "little" : "big";
+ }
++
++# Set 64bit xid bases a bit in the past therefore we can set xmin/xmax a bit
++# in the past
++fixup_page($file, 0, $datfrozenxid - 100, $datminmxid, \@lp_off);
++
+ close($file)
+ or BAIL_OUT("close failed: $!");
+ $node->start;
+@@ -395,20 +543,6 @@ $node->command_ok([ 'pg_amcheck', '-p', $port, 'postgres' ],
+
+ $node->stop;
+
+-# Some #define constants from access/htup_details.h for use while corrupting.
+-use constant HEAP_HASNULL => 0x0001;
+-use constant HEAP_XMAX_LOCK_ONLY => 0x0080;
+-use constant HEAP_XMIN_COMMITTED => 0x0100;
+-use constant HEAP_XMIN_INVALID => 0x0200;
+-use constant HEAP_XMAX_COMMITTED => 0x0400;
+-use constant HEAP_XMAX_INVALID => 0x0800;
+-use constant HEAP_NATTS_MASK => 0x07FF;
+-use constant HEAP_XMAX_IS_MULTI => 0x1000;
+-use constant HEAP_KEYS_UPDATED => 0x2000;
+-use constant HEAP_HOT_UPDATED => 0x4000;
+-use constant HEAP_ONLY_TUPLE => 0x8000;
+-use constant HEAP_UPDATED => 0x2000;
+-
+ # Helper function to generate a regular expression matching the header we
+ # expect verify_heapam() to return given which fields we expect to be non-null.
+ sub header
+@@ -443,6 +577,8 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+
+ # Read tuple, if there is one.
+ my $tup = $offset == -1 ? undef : read_tuple($file, $offset);
++ # Read page special, if there is one.
++ my $special = $offset == -1 ? undef : read_special_data($file, $offset);
+
+ if ($offnum == 1)
+ {
+@@ -459,7 +595,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ elsif ($offnum == 2)
+ {
+ # Corruptly set xmin < datfrozenxid
+- my $xmin = 3;
++ my $xmin = $datfrozenxid - 12;
+ $tup->{t_xmin} = $xmin;
+ $tup->{t_infomask} &= ~HEAP_XMIN_COMMITTED;
+ $tup->{t_infomask} &= ~HEAP_XMIN_INVALID;
+@@ -469,25 +605,24 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ }
+ elsif ($offnum == 3)
+ {
+- # Corruptly set xmin < datfrozenxid, further back, noting circularity
+- # of xid comparison.
+- my $xmin = 4026531839;
++ # Corruptly set xmin > next transaction id.
++ my $xmin = $relfrozenxid + 4026531839;
+ $tup->{t_xmin} = $xmin;
+ $tup->{t_infomask} &= ~HEAP_XMIN_COMMITTED;
+ $tup->{t_infomask} &= ~HEAP_XMIN_INVALID;
+
+ push @expected,
+- qr/${$header}xmin ${xmin} precedes oldest valid transaction ID \d+/;
++ qr/${$header}xmin ${xmin} equals or exceeds next valid transaction ID \d+/;
+ }
+ elsif ($offnum == 4)
+ {
+- # Corruptly set xmax < relminmxid;
+- my $xmax = 4026531839;
++ # Corruptly set xmax > relminmxid;
++ my $xmax = $relfrozenxid + 4026531839;
+ $tup->{t_xmax} = $xmax;
+ $tup->{t_infomask} &= ~HEAP_XMAX_INVALID;
+
+ push @expected,
+- qr/${$header}xmax ${xmax} precedes oldest valid transaction ID \d+/;
++ qr/${$header}xmax ${xmax} equals or exceeds next valid transaction ID \d+/;
+ }
+ elsif ($offnum == 5)
+ {
+@@ -603,7 +738,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ $tup->{t_xmax} = 4000000000;
+
+ push @expected,
+- qr/${header}multitransaction ID 4000000000 precedes relation minimum multitransaction ID threshold 1/;
++ qr/${header}multitransaction ID 4000000000 equals or exceeds next valid multitransaction ID 1/;
+ }
+ elsif ($offnum == 16) # Last offnum must equal ROWCOUNT
+ {
+diff --git a/src/bin/pg_controldata/pg_controldata.c b/src/bin/pg_controldata/pg_controldata.c
+index 5414b921c38..1f99bccf444 100644
+--- a/src/bin/pg_controldata/pg_controldata.c
++++ b/src/bin/pg_controldata/pg_controldata.c
+@@ -247,7 +247,7 @@ main(int argc, char *argv[])
+ printf(_("Latest checkpoint's full_page_writes: %s\n"),
+ ControlFile->checkPointCopy.fullPageWrites ? _("on") : _("off"));
+ printf(_("Latest checkpoint's NextXID: %llu\n"),
+- (unsigned long long) U64FromFullTransactionId(ControlFile->checkPointCopy.nextXid));
++ (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid));
+ printf(_("Latest checkpoint's NextOID: %u\n"),
+ ControlFile->checkPointCopy.nextOid);
+ printf(_("Latest checkpoint's NextMultiXactId: %llu\n"),
+diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
+index 8ed4f3341d6..3fcfadd7a57 100644
+--- a/src/bin/pg_dump/pg_dump.c
++++ b/src/bin/pg_dump/pg_dump.c
+@@ -41,6 +41,7 @@
+ #include "access/attnum.h"
+ #include "access/sysattr.h"
+ #include "access/transam.h"
++#include "c.h"
+ #include "catalog/pg_aggregate_d.h"
+ #include "catalog/pg_am_d.h"
+ #include "catalog/pg_attribute_d.h"
+@@ -3129,7 +3130,7 @@ dumpDatabase(Archive *fout)
+ *datistemplate,
+ *datconnlimit,
+ *tablespace;
+- uint32 frozenxid,
++ uint64 frozenxid,
+ minmxid;
+ char *qdatname;
+
+@@ -3201,8 +3202,8 @@ dumpDatabase(Archive *fout)
+ icurules = PQgetvalue(res, 0, i_daticurules);
+ else
+ icurules = NULL;
+- frozenxid = atooid(PQgetvalue(res, 0, i_frozenxid));
+- minmxid = atooid(PQgetvalue(res, 0, i_minmxid));
++ frozenxid = strtou64(PQgetvalue(res, 0, i_frozenxid), NULL, 0);
++ minmxid = strtou64(PQgetvalue(res, 0, i_minmxid), NULL, 0);
+ dbdacl.acl = PQgetvalue(res, 0, i_datacl);
+ dbdacl.acldefault = PQgetvalue(res, 0, i_acldefault);
+ datistemplate = PQgetvalue(res, 0, i_datistemplate);
+@@ -3511,10 +3512,16 @@ dumpDatabase(Archive *fout)
+ RelFileNumber relfilenumber;
+
+ appendPQExpBuffer(loHorizonQry, "UPDATE pg_catalog.pg_class\n"
+- "SET relfrozenxid = '%u', relminmxid = '%u'\n"
++ "SET relfrozenxid = '%llu', relminmxid = '%llu'\n"
+ "WHERE oid = %u;\n",
+- atooid(PQgetvalue(lo_res, i, ii_relfrozenxid)),
+- atooid(PQgetvalue(lo_res, i, ii_relminmxid)),
++ (unsigned long long) strtou64(PQgetvalue(lo_res,
++ i,
++ ii_relfrozenxid),
++ NULL, 0),
++ (unsigned long long) strtou64(PQgetvalue(lo_res,
++ i,
++ ii_relminmxid),
++ NULL, 0),
+ atooid(PQgetvalue(lo_res, i, ii_oid)));
+
+ oid = atooid(PQgetvalue(lo_res, i, ii_oid));
+@@ -7105,11 +7112,11 @@ getTables(Archive *fout, int *numTables)
+ tblinfo[i].relreplident = *(PQgetvalue(res, i, i_relreplident));
+ tblinfo[i].rowsec = (strcmp(PQgetvalue(res, i, i_relrowsec), "t") == 0);
+ tblinfo[i].forcerowsec = (strcmp(PQgetvalue(res, i, i_relforcerowsec), "t") == 0);
+- tblinfo[i].frozenxid = atooid(PQgetvalue(res, i, i_relfrozenxid));
+- tblinfo[i].toast_frozenxid = atooid(PQgetvalue(res, i, i_toastfrozenxid));
++ tblinfo[i].frozenxid = strtou64(PQgetvalue(res, i, i_relfrozenxid), NULL, 0);
++ tblinfo[i].toast_frozenxid = strtou64(PQgetvalue(res, i, i_toastfrozenxid), NULL, 0);
+ tblinfo[i].toast_oid = atooid(PQgetvalue(res, i, i_toastoid));
+- tblinfo[i].minmxid = atooid(PQgetvalue(res, i, i_relminmxid));
+- tblinfo[i].toast_minmxid = atooid(PQgetvalue(res, i, i_toastminmxid));
++ tblinfo[i].minmxid = strtou64(PQgetvalue(res, i, i_relminmxid), NULL, 0);
++ tblinfo[i].toast_minmxid = strtou64(PQgetvalue(res, i, i_toastminmxid), NULL, 0);
+ tblinfo[i].reloptions = pg_strdup(PQgetvalue(res, i, i_reloptions));
+ if (PQgetisnull(res, i, i_checkoption))
+ tblinfo[i].checkoption = NULL;
+diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
+index 2e55a0e3bbb..be24509f3a0 100644
+--- a/src/bin/pg_dump/pg_dump.h
++++ b/src/bin/pg_dump/pg_dump.h
+@@ -301,11 +301,11 @@ typedef struct _tableInfo
+ bool rowsec; /* is row security enabled? */
+ bool forcerowsec; /* is row security forced? */
+ bool hasoids; /* does it have OIDs? */
+- uint32 frozenxid; /* table's relfrozenxid */
+- uint32 minmxid; /* table's relminmxid */
++ uint64 frozenxid; /* table's relfrozenxid */
++ uint64 minmxid; /* table's relminmxid */
+ Oid toast_oid; /* toast table's OID, or 0 if none */
+- uint32 toast_frozenxid; /* toast table's relfrozenxid, if any */
+- uint32 toast_minmxid; /* toast table's relminmxid */
++ uint64 toast_frozenxid; /* toast table's relfrozenxid, if any */
++ uint64 toast_minmxid; /* toast table's relminmxid */
+ int ncheck; /* # of CHECK expressions */
+ Oid reltype; /* OID of table's composite type, if any */
+ Oid reloftype; /* underlying type for typed table */
+diff --git a/src/bin/pg_resetwal/pg_resetwal.c b/src/bin/pg_resetwal/pg_resetwal.c
+index b2f20263824..dafefe8101b 100644
+--- a/src/bin/pg_resetwal/pg_resetwal.c
++++ b/src/bin/pg_resetwal/pg_resetwal.c
+@@ -63,7 +63,6 @@ static ControlFileData ControlFile; /* pg_control values */
+ static XLogSegNo newXlogSegNo; /* new XLOG segment # */
+ static bool guessed = false; /* T if we had to guess at any values */
+ static const char *progname;
+-static uint32 set_xid_epoch = (uint32) -1;
+ static TransactionId set_oldest_xid = 0;
+ static TransactionId set_xid = 0;
+ static TransactionId set_oldest_commit_ts_xid = 0;
+@@ -96,7 +95,6 @@ main(int argc, char *argv[])
+ static struct option long_options[] = {
+ {"commit-timestamp-ids", required_argument, NULL, 'c'},
+ {"pgdata", required_argument, NULL, 'D'},
+- {"epoch", required_argument, NULL, 'e'},
+ {"force", no_argument, NULL, 'f'},
+ {"next-wal-file", required_argument, NULL, 'l'},
+ {"multixact-ids", required_argument, NULL, 'm'},
+@@ -138,7 +136,7 @@ main(int argc, char *argv[])
+ }
+
+
+- while ((c = getopt_long(argc, argv, "c:D:e:fl:m:no:O:u:x:", long_options, NULL)) != -1)
++ while ((c = getopt_long(argc, argv, "c:D:fl:m:no:O:u:x:", long_options, NULL)) != -1)
+ {
+ switch (c)
+ {
+@@ -154,24 +152,9 @@ main(int argc, char *argv[])
+ noupdate = true;
+ break;
+
+- case 'e':
+- errno = 0;
+- set_xid_epoch = strtoul(optarg, &endptr, 0);
+- if (endptr == optarg || *endptr != '\0' || errno != 0)
+- {
+- /*------
+- translator: the second %s is a command line argument (-e, etc) */
+- pg_log_error("invalid argument for option %s", "-e");
+- pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+- exit(1);
+- }
+- if (set_xid_epoch == -1)
+- pg_fatal("transaction ID epoch (-e) must not be -1");
+- break;
+-
+ case 'u':
+ errno = 0;
+- set_oldest_xid = strtoul(optarg, &endptr, 0);
++ set_oldest_xid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-u");
+@@ -185,7 +168,7 @@ main(int argc, char *argv[])
+
+ case 'x':
+ errno = 0;
+- set_xid = strtoul(optarg, &endptr, 0);
++ set_xid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-x");
+@@ -199,14 +182,14 @@ main(int argc, char *argv[])
+
+ case 'c':
+ errno = 0;
+- set_oldest_commit_ts_xid = strtoul(optarg, &endptr, 0);
++ set_oldest_commit_ts_xid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != ',' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-c");
+ pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+ exit(1);
+ }
+- set_newest_commit_ts_xid = strtoul(endptr + 1, &endptr2, 0);
++ set_newest_commit_ts_xid = strtou64(endptr + 1, &endptr2, 0);
+ if (endptr2 == endptr + 1 || *endptr2 != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-c");
+@@ -242,7 +225,7 @@ main(int argc, char *argv[])
+
+ case 'm':
+ errno = 0;
+- set_mxid = strtoul(optarg, &endptr, 0);
++ set_mxid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != ',' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-m");
+@@ -250,7 +233,7 @@ main(int argc, char *argv[])
+ exit(1);
+ }
+
+- set_oldestmxid = strtoul(endptr + 1, &endptr2, 0);
++ set_oldestmxid = strtou64(endptr + 1, &endptr2, 0);
+ if (endptr2 == endptr + 1 || *endptr2 != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-m");
+@@ -416,11 +399,6 @@ main(int argc, char *argv[])
+ * Adjust fields if required by switches. (Do this now so that printout,
+ * if any, includes these values.)
+ */
+- if (set_xid_epoch != -1)
+- ControlFile.checkPointCopy.nextXid =
+- FullTransactionIdFromEpochAndXid(set_xid_epoch,
+- XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+-
+ if (set_oldest_xid != 0)
+ {
+ ControlFile.checkPointCopy.oldestXid = set_oldest_xid;
+@@ -428,9 +406,7 @@ main(int argc, char *argv[])
+ }
+
+ if (set_xid != 0)
+- ControlFile.checkPointCopy.nextXid =
+- FullTransactionIdFromEpochAndXid(EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid),
+- set_xid);
++ ControlFile.checkPointCopy.nextXid = FullTransactionIdFromXid(set_xid);
+
+ if (set_oldest_commit_ts_xid != 0)
+ ControlFile.checkPointCopy.oldestCommitTsXid = set_oldest_commit_ts_xid;
+@@ -666,7 +642,7 @@ GuessControlValues(void)
+ ControlFile.checkPointCopy.PrevTimeLineID = 1;
+ ControlFile.checkPointCopy.fullPageWrites = false;
+ ControlFile.checkPointCopy.nextXid =
+- FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
++ FullTransactionIdFromXid(FirstNormalTransactionId);
+ ControlFile.checkPointCopy.nextOid = FirstGenbkiObjectId;
+ ControlFile.checkPointCopy.nextMulti = FirstMultiXactId;
+ ControlFile.checkPointCopy.nextMultiOffset = 0;
+@@ -717,6 +693,8 @@ GuessControlValues(void)
+ *
+ * NB: this display should be just those fields that will not be
+ * reset by RewriteControlFile().
++ *
++ * Special macros help to make translatable strings.
+ */
+ static void
+ PrintControlValues(bool guessed)
+@@ -736,8 +714,7 @@ PrintControlValues(bool guessed)
+ ControlFile.checkPointCopy.ThisTimeLineID);
+ printf(_("Latest checkpoint's full_page_writes: %s\n"),
+ ControlFile.checkPointCopy.fullPageWrites ? _("on") : _("off"));
+- printf(_("Latest checkpoint's NextXID: %u:%llu\n"),
+- EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid),
++ printf(_("Latest checkpoint's NextXID: %llu\n"),
+ (unsigned long long) XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+ printf(_("Latest checkpoint's NextOID: %u\n"),
+ ControlFile.checkPointCopy.nextOid);
+@@ -835,12 +812,6 @@ PrintNewControlValues(void)
+ ControlFile.checkPointCopy.oldestXidDB);
+ }
+
+- if (set_xid_epoch != -1)
+- {
+- printf(_("NextXID epoch: %u\n"),
+- EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+- }
+-
+ if (set_oldest_commit_ts_xid != 0)
+ {
+ printf(_("oldestCommitTsXid: %llu\n"),
+diff --git a/src/bin/pg_resetwal/t/001_basic.pl b/src/bin/pg_resetwal/t/001_basic.pl
+index f8a8eef44d1..20a26192cd8 100644
+--- a/src/bin/pg_resetwal/t/001_basic.pl
++++ b/src/bin/pg_resetwal/t/001_basic.pl
+@@ -95,15 +95,6 @@ command_fails_like(
+ [ 'pg_resetwal', '-c', '10,1', $node->data_dir ],
+ qr/greater than/,
+ 'fails with -c value 1 part 2');
+-# -e
+-command_fails_like(
+- [ 'pg_resetwal', '-e', 'foo', $node->data_dir ],
+- qr/error: invalid argument for option -e/,
+- 'fails with incorrect -e option');
+-command_fails_like(
+- [ 'pg_resetwal', '-e', '-1', $node->data_dir ],
+- qr/must not be -1/,
+- 'fails with -e value -1');
+ # -l
+ command_fails_like(
+ [ 'pg_resetwal', '-l', 'foo', $node->data_dir ],
+@@ -181,7 +172,6 @@ my $blcksz = $1;
+ my @cmd = ('pg_resetwal', '-D', $node->data_dir);
+
+ # some not-so-critical hardcoded values
+-push @cmd, '-e', 1;
+ push @cmd, '-l', '00000001000000320000004B';
+ push @cmd, '-o', 100_000;
+ push @cmd, '--wal-segsize', 1;
+@@ -205,8 +195,10 @@ push @cmd,
+ '-c',
+ sprintf("%d,%d", hex($files[0]) == 0 ? 3 : hex($files[0]), hex($files[-1]));
+
++my $A = 2;
++my $B = 1;
+ @files = get_slru_files('pg_multixact/offsets');
+-$mult = 32 * $blcksz / 8;
++$mult = $A * $blcksz / $B;
+ # -m argument is "new,old"
+ push @cmd, '-m',
+ sprintf("%d,%d",
+@@ -214,11 +206,11 @@ push @cmd, '-m',
+ hex($files[0]) == 0 ? 1 : hex($files[0] * $mult));
+
+ @files = get_slru_files('pg_multixact/members');
+-$mult = 32 * int($blcksz / 20) * 4;
++$mult = $A * int($blcksz / 20) * $B;
+ push @cmd, '-O', (hex($files[-1]) + 1) * $mult;
+
+ @files = get_slru_files('pg_xact');
+-$mult = 32 * $blcksz * 4;
++$mult = $A * $blcksz * $B;
+ push @cmd,
+ '-u', (hex($files[0]) == 0 ? 3 : hex($files[0]) * $mult),
+ '-x', ((hex($files[-1]) + 1) * $mult);
+diff --git a/src/bin/pg_upgrade/check.c b/src/bin/pg_upgrade/check.c
+index 94164f04721..b4f45bde190 100644
+--- a/src/bin/pg_upgrade/check.c
++++ b/src/bin/pg_upgrade/check.c
+@@ -29,6 +29,8 @@ static void check_new_cluster_logical_replication_slots(void);
+ static void check_new_cluster_subscription_configuration(void);
+ static void check_old_cluster_for_valid_slots(void);
+ static void check_old_cluster_subscription_state(void);
++static void check_for_32bit_xid_usage(ClusterInfo *cluster);
++static bool is_xid_wraparound(ClusterInfo *cluster);
+
+ /*
+ * DataTypesUsageChecks - definitions of data type checks for the old cluster
+@@ -583,7 +585,7 @@ output_check_banner(void)
+
+
+ void
+-check_and_dump_old_cluster(void)
++check_and_dump_old_cluster(bool *is_wraparound)
+ {
+ /* -- OLD -- */
+
+@@ -677,6 +679,17 @@ check_and_dump_old_cluster(void)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 905)
+ check_for_pg_role_prefix(&old_cluster);
+
++ /* Prepare for 64bit xid */
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER)
++ {
++ /* Check if 32-bit xid type is used in tables */
++ check_for_32bit_xid_usage(&old_cluster);
++ /* Check indexes to be upgraded */
++ invalidate_spgist_indexes(&old_cluster, true);
++ invalidate_gin_indexes(&old_cluster, true);
++ invalidate_external_indexes(&old_cluster, true);
++ }
++
+ /*
+ * While not a check option, we do this now because this is the only time
+ * the old server is running.
+@@ -684,6 +697,8 @@ check_and_dump_old_cluster(void)
+ if (!user_opts.check)
+ generate_old_dump();
+
++ *is_wraparound = is_xid_wraparound(&old_cluster);
++
+ if (!user_opts.live_check)
+ stop_postmaster(false);
+ }
+@@ -759,6 +774,17 @@ issue_warnings_and_set_wal_level(void)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 906)
+ old_9_6_invalidate_hash_indexes(&new_cluster, false);
+
++ /* Raindex for 64bit xid */
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER)
++ {
++ /* Check if 32-bit xid type is used in tables */
++ check_for_32bit_xid_usage(&old_cluster);
++ /* Check indexes to be upgraded */
++ invalidate_spgist_indexes(&old_cluster, true);
++ invalidate_gin_indexes(&old_cluster, true);
++ invalidate_external_indexes(&old_cluster, true);
++ }
++
+ report_extension_updates(&new_cluster);
+
+ stop_postmaster(false);
+@@ -1930,6 +1956,127 @@ check_old_cluster_for_valid_slots(void)
+ check_ok();
+ }
+
++/*
++ * check_for_32bit_xid_usage()
++ *
++ * Current PG version changes xid storage format to 64-bit. Check if
++ * xid type is used in tables.
++ */
++static void
++check_for_32bit_xid_usage(ClusterInfo *cluster)
++{
++ int dbnum;
++ FILE *script = NULL;
++ bool found = false;
++ char output_path[MAXPGPATH];
++
++ prep_status("Checking for incompatible \"xid\" data type");
++
++ snprintf(output_path, sizeof(output_path), "tables_using_xid.txt");
++
++ for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
++ {
++ PGresult *res;
++ bool db_used = false;
++ int ntups;
++ int rowno;
++ int i_nspname,
++ i_relname,
++ i_attname;
++ DbInfo *active_db = &cluster->dbarr.dbs[dbnum];
++ PGconn *conn = connectToServer(cluster, active_db->db_name);
++
++ /*
++ * While several relkinds don't store any data, e.g. views, they can
++ * be used to define data types of other columns, so we check all
++ * relkinds.
++ */
++ res = executeQueryOrDie(conn,
++ "SELECT n.nspname, c.relname, a.attname "
++ "FROM pg_catalog.pg_class c, "
++ " pg_catalog.pg_namespace n, "
++ " pg_catalog.pg_attribute a "
++ "WHERE c.oid = a.attrelid AND "
++ " a.attnum >= 1 AND "
++ " a.atttypid = 'pg_catalog.xid'::pg_catalog.regtype AND "
++ " c.relnamespace = n.oid AND "
++ /* exclude possible orphaned temp tables */
++ " n.nspname !~ '^pg_temp_' AND "
++ " n.nspname NOT IN ('pg_catalog', 'information_schema')");
++
++ ntups = PQntuples(res);
++ i_nspname = PQfnumber(res, "nspname");
++ i_relname = PQfnumber(res, "relname");
++ i_attname = PQfnumber(res, "attname");
++ for (rowno = 0; rowno < ntups; rowno++)
++ {
++ found = true;
++ if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
++ pg_fatal("could not open file \"%s\": %s\n",
++ output_path, strerror(errno));
++ if (!db_used)
++ {
++ fprintf(script, "Database: %s\n", active_db->db_name);
++ db_used = true;
++ }
++ fprintf(script, " %s.%s.%s\n",
++ PQgetvalue(res, rowno, i_nspname),
++ PQgetvalue(res, rowno, i_relname),
++ PQgetvalue(res, rowno, i_attname));
++ }
++
++ PQclear(res);
++
++ PQfinish(conn);
++ }
++
++ if (script)
++ fclose(script);
++
++ if (found)
++ {
++ pg_log(PG_REPORT, "fatal");
++ pg_fatal("Your installation contains the \"xid\" data type in user tables.\n"
++ "The internal format of \"xid\" changed in Postgres Pro Enterprise so this cluster\n"
++ "cannot currently be upgraded. Note that even dropped attributes cause a problem.\n"
++ "You can remove the problem tables and restart the upgrade.\n"
++ "A list of the problem columns is in the file:\n"
++ " %s", output_path);
++ }
++ else
++ check_ok();
++}
++
++/*
++ * is_xid_wraparound()
++ *
++ * Return true if 32-xid cluster had wraparound.
++ */
++static bool
++is_xid_wraparound(ClusterInfo *cluster)
++{
++ PGconn *conn;
++ PGresult *res;
++ bool is_wraparound;
++
++ conn = connectToServer(cluster, "template1");
++
++ /*
++ * txid_current is extended with an "epoch" counter, so to check
++ * wraparound in old 32-xid cluster we cut epoch by casting to int4.
++ */
++ res = executeQueryOrDie(conn,
++ "SELECT 1 "
++ "FROM pg_catalog.pg_database, txid_current() tx "
++ "WHERE (tx %% 4294967295)::bigint <= datfrozenxid::text::bigint "
++ "LIMIT 1");
++ is_wraparound = PQntuples(res) ? true : false;
++ PQclear(res);
++ PQfinish(conn);
++
++ return is_wraparound;
++}
++
+ /*
+ * Callback function for processing results of query for
+ * check_old_cluster_subscription_state()'s UpgradeTask. If the query returned
+diff --git a/src/bin/pg_upgrade/controldata.c b/src/bin/pg_upgrade/controldata.c
+index 2ce8af0b9db..08d1ad638e4 100644
+--- a/src/bin/pg_upgrade/controldata.c
++++ b/src/bin/pg_upgrade/controldata.c
+@@ -287,6 +287,8 @@ get_control_data(ClusterInfo *cluster)
+ xid.value = strtou64(p, NULL, 10);
+
+ /*
++ * Try to read 32-bit XID format 'epoch:xid'.
++ *
+ * Delimiter changed from '/' to ':' in 9.6. We don't test for
+ * the catalog version of the change because the catalog version
+ * is pulled from pg_controldata too, and it isn't worth adding an
+@@ -302,8 +304,7 @@ get_control_data(ClusterInfo *cluster)
+ if (p == NULL)
+ {
+ /* FullTransactionId representation */
+- cluster->controldata.chkpnt_nxtxid = XidFromFullTransactionId(xid);
+- cluster->controldata.chkpnt_nxtepoch = EpochFromFullTransactionId(xid);
++ cluster->controldata.chkpnt_nxtxid = xid.value;
+ }
+ else
+ {
+@@ -312,8 +313,8 @@ get_control_data(ClusterInfo *cluster)
+
+ /* Epoch:Xid representation */
+ p++; /* remove '/' or ':' char */
+- cluster->controldata.chkpnt_nxtxid = str2uint(p);
+- cluster->controldata.chkpnt_nxtepoch = (TransactionId) XidFromFullTransactionId(xid);
++ cluster->controldata.chkpnt_nxtxid = (XidFromFullTransactionId(xid)) << 32 |
++ (TransactionId) str2uint(p);
+ }
+
+ got_xid = true;
+@@ -337,7 +338,7 @@ get_control_data(ClusterInfo *cluster)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_nxtmulti = str2uint(p);
++ cluster->controldata.chkpnt_nxtmulti = strtou64(p, NULL, 10);
+ got_multi = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's oldestXID:")) != NULL)
+@@ -348,7 +349,7 @@ get_control_data(ClusterInfo *cluster)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_oldstxid = str2uint(p);
++ cluster->controldata.chkpnt_oldstxid = strtou64(p, NULL, 10);
+ got_oldestxid = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's oldestMultiXid:")) != NULL)
+@@ -359,7 +360,7 @@ get_control_data(ClusterInfo *cluster)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_oldstMulti = str2uint(p);
++ cluster->controldata.chkpnt_oldstMulti = strtou64(p, NULL, 10);
+ got_oldestmulti = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's NextMultiOffset:")) != NULL)
+@@ -370,7 +371,7 @@ get_control_data(ClusterInfo *cluster)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_nxtmxoff = str2uint(p);
++ cluster->controldata.chkpnt_nxtmxoff = strtou64(p, NULL, 10);
+ got_mxoff = true;
+ }
+ else if ((p = strstr(bufin, "First log segment after reset:")) != NULL)
+diff --git a/src/bin/pg_upgrade/file.c b/src/bin/pg_upgrade/file.c
+index 73932504cae..e23e719e69e 100644
+--- a/src/bin/pg_upgrade/file.c
++++ b/src/bin/pg_upgrade/file.c
+@@ -214,7 +214,8 @@ linkFile(const char *src, const char *dst,
+ */
+ void
+ rewriteVisibilityMap(const char *fromfile, const char *tofile,
+- const char *schemaName, const char *relName)
++ const char *schemaName, const char *relName,
++ bool update_version)
+ {
+ int src_fd;
+ int dst_fd;
+@@ -330,6 +331,11 @@ rewriteVisibilityMap(const char *fromfile, const char *tofile,
+ if (old_lastpart && empty)
+ break;
+
++ if (update_version)
++ PageSetPageSizeAndVersion((Page) new_vmbuf.data,
++ PageGetPageSize((Page) new_vmbuf.data),
++ PG_PAGE_LAYOUT_VERSION);
++
+ /* Set new checksum for visibility map page, if enabled */
+ if (new_cluster.controldata.data_checksum_version != 0)
+ ((PageHeader) new_vmbuf.data)->pd_checksum =
+@@ -356,6 +362,97 @@ rewriteVisibilityMap(const char *fromfile, const char *tofile,
+ close(src_fd);
+ }
+
++/*
++ * updateSegmentVersion()
++ *
++ * Transform a segment file, copying from src to dst.
++ * schemaName/relName are relation's SQL name (used for error messages only).
++ *
++ * Read segment pages one by one and set version to PG_PAGE_LAYOUT_VERSION.
++ *
++ * Although FSM and MV formats does not change while switch to 64-bit XIDs, we
++ * must upgrade pages version in order to avoid lazy conversion on first read.
++ */
++void
++updateSegmentPagesVersion(const char *fromfile, const char *tofile,
++ const char *schemaName, const char *relName)
++{
++ int src_fd;
++ int dst_fd;
++ struct stat statbuf;
++ ssize_t src_filesize;
++ ssize_t totalBytesRead;
++ ssize_t bytesRead;
++ BlockNumber blkno;
++ PGAlignedBlock buf;
++
++ if ((src_fd = open(fromfile, O_RDONLY | PG_BINARY, 0)) < 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not open file \"%s\": %s",
++ schemaName, relName, fromfile, strerror(errno));
++
++ if (fstat(src_fd, &statbuf) != 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not stat file \"%s\": %s",
++ schemaName, relName, fromfile, strerror(errno));
++
++ if ((dst_fd = open(tofile, O_RDWR | O_CREAT | O_EXCL | PG_BINARY,
++ pg_file_create_mode)) < 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not create file \"%s\": %s",
++ schemaName, relName, tofile, strerror(errno));
++
++ /* Save old file size */
++ src_filesize = statbuf.st_size;
++ totalBytesRead = 0;
++ blkno = 0;
++
++ while (totalBytesRead < src_filesize)
++ {
++ errno = 0;
++ if ((bytesRead = read(src_fd, buf.data, BLCKSZ)) != BLCKSZ)
++ {
++ if (bytesRead < 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not read file \"%s\": %s",
++ schemaName, relName, fromfile, strerror(errno));
++ else
++ pg_fatal("error while copying relation \"%s.%s\": partial page found in file \"%s\"",
++ schemaName, relName, fromfile);
++ }
++
++ totalBytesRead += BLCKSZ;
++ PageSetPageSizeAndVersion((Page) buf.data,
++ PageGetPageSize((Page) buf.data),
++ PG_PAGE_LAYOUT_VERSION);
++
++ /* Set new checksum for page, if enabled */
++ if (new_cluster.controldata.data_checksum_version != 0)
++ ((PageHeader) buf.data)->pd_checksum =
++ pg_checksum_page(buf.data, blkno);
++
++ /*
++ * We dealing here only with FSM and VM pages.
++ */
++ if (((PageHeader) buf.data)->pd_lower != SizeOfPageHeaderData ||
++ ((PageHeader) buf.data)->pd_upper != BLCKSZ)
++ pg_fatal("error while copying relation \"%s.%s\": unknown page format found in file \"%s\"",
++ schemaName, relName, fromfile);
++
++ errno = 0;
++ if (write(dst_fd, buf.data, BLCKSZ) != BLCKSZ)
++ {
++ /* if write didn't set errno, assume problem is no disk space */
++ if (errno == 0)
++ errno = ENOSPC;
++ pg_fatal("error while copying relation \"%s.%s\": could not write file \"%s\": %s",
++ schemaName, relName, tofile, strerror(errno));
++ }
++
++ blkno++;
++ }
++
++ /* Clean up */
++ close(dst_fd);
++ close(src_fd);
++}
++
+ void
+ check_file_clone(void)
+ {
+diff --git a/src/bin/pg_upgrade/pg_upgrade.c b/src/bin/pg_upgrade/pg_upgrade.c
+index 4d641732dcc..53c4b130ae1 100644
+--- a/src/bin/pg_upgrade/pg_upgrade.c
++++ b/src/bin/pg_upgrade/pg_upgrade.c
+@@ -40,6 +40,9 @@
+
+ #include <time.h>
+
++#include "access/multixact.h"
++#include "access/transam.h"
++#include "access/xlog_internal.h"
+ #include "catalog/pg_class_d.h"
+ #include "common/file_perm.h"
+ #include "common/logging.h"
+@@ -57,7 +60,7 @@
+ static void set_locale_and_encoding(void);
+ static void prepare_new_cluster(void);
+ static void prepare_new_globals(void);
+-static void create_new_objects(void);
++static void create_new_objects(bool is_wraparound);
+ static void copy_xact_xlog_xid(void);
+ static void set_frozenxids(bool minmxid_only);
+ static void make_outputdirs(char *pgdata);
+@@ -84,6 +87,7 @@ int
+ main(int argc, char **argv)
+ {
+ char *deletion_script_file_name = NULL;
++ bool is_wraparound = false;
+
+ /*
+ * pg_upgrade doesn't currently use common/logging.c, but initialize it
+@@ -129,7 +133,7 @@ main(int argc, char **argv)
+
+ check_cluster_compatibility();
+
+- check_and_dump_old_cluster();
++ check_and_dump_old_cluster(&is_wraparound);
+
+
+ /* -- NEW -- */
+@@ -162,7 +166,7 @@ main(int argc, char **argv)
+
+ prepare_new_globals();
+
+- create_new_objects();
++ create_new_objects(is_wraparound);
+
+ stop_postmaster(false);
+
+@@ -526,7 +530,7 @@ prepare_new_globals(void)
+
+
+ static void
+-create_new_objects(void)
++create_new_objects(bool is_wraparound)
+ {
+ int dbnum;
+ PGconn *conn_new_template1;
+@@ -648,11 +652,23 @@ create_new_objects(void)
+ check_ok();
+
+ /*
+- * We don't have minmxids for databases or relations in pre-9.3 clusters,
+- * so set those after we have restored the schema.
++ * Refix datfrozenxid and datminmxid
+ */
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 902)
+ set_frozenxids(true);
++ else if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ {
++ /*
++ * During upgrade from 32-bit to 64-bit xids save relfrozenxids if
++ * there was no wraparound in old cluster. Otherwise, reset them to
++ * FirstNormalTransactionId value.
++ */
++ if (is_wraparound)
++ set_frozenxids(false);
++ else
++ set_frozenxids(true);
++ }
+
+ /* update new_cluster info now that we have objects in the databases */
+ get_db_rel_and_slot_infos(&new_cluster);
+@@ -706,14 +722,37 @@ copy_subdir_files(const char *old_subdir, const char *new_subdir)
+ static void
+ copy_xact_xlog_xid(void)
+ {
+- /*
+- * Copy old commit logs to new data dir. pg_clog has been renamed to
+- * pg_xact in post-10 clusters.
+- */
+- copy_subdir_files(GET_MAJOR_VERSION(old_cluster.major_version) <= 906 ?
+- "pg_clog" : "pg_xact",
+- GET_MAJOR_VERSION(new_cluster.major_version) <= 906 ?
+- "pg_clog" : "pg_xact");
++ TransactionId next_xid;
++
++#define GetClogDirName(cluster) \
++ GET_MAJOR_VERSION(cluster.major_version) <= 906 ? "pg_clog" : "pg_xact"
++
++ /* Set next xid to 2^32 if we're upgrading from 32 bit postgres */
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ next_xid = ((TransactionId) 1 << 32);
++ else
++ next_xid = old_cluster.controldata.chkpnt_nxtxid;
++
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ {
++ /* Convert commit logs and copy to the new data dir */
++ prep_status("Transforming commit log segments");
++ convert_xact(psprintf("%s/%s", old_cluster.pgdata, GetClogDirName(old_cluster)),
++ psprintf("%s/%s", new_cluster.pgdata, GetClogDirName(new_cluster)));
++ check_ok();
++ }
++ else
++ {
++ /*
++ * Copy old commit logs to new data dir. pg_clog has been renamed to
++ * pg_xact in post-10 clusters.
++ */
++ prep_status("Copying commit log segments");
++ copy_subdir_files(GetClogDirName(old_cluster), GetClogDirName(new_cluster));
++ check_ok();
++ }
+
+ prep_status("Setting oldest XID for new cluster");
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+@@ -727,19 +766,20 @@ copy_xact_xlog_xid(void)
+ prep_status("Setting next transaction ID and epoch for new cluster");
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -x %llu \"%s\"",
+- new_cluster.bindir,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
++ new_cluster.bindir, (unsigned long long) next_xid,
+ new_cluster.pgdata);
++#ifdef NOT_USED
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -e %u \"%s\"",
+ new_cluster.bindir, old_cluster.controldata.chkpnt_nxtepoch,
+ new_cluster.pgdata);
++#endif
+ /* must reset commit timestamp limits also */
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -c %llu,%llu \"%s\"",
+ new_cluster.bindir,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
++ (unsigned long long) next_xid,
++ (unsigned long long) next_xid,
+ new_cluster.pgdata);
+ check_ok();
+
+@@ -752,6 +792,10 @@ copy_xact_xlog_xid(void)
+ if (old_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER &&
+ new_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER)
+ {
++ uint64 oldest_mxid = old_cluster.controldata.chkpnt_oldstMulti;
++ uint64 next_mxid = old_cluster.controldata.chkpnt_nxtmulti;
++ uint64 next_mxoff = old_cluster.controldata.chkpnt_nxtmxoff;
++
+ /*
+ * If the old server is before the MULTIXACTOFFSET_FORMATCHANGE_CAT_VER
+ * it must have 32-bit multixid offsets, thus it should be converted.
+@@ -798,9 +842,9 @@ copy_xact_xlog_xid(void)
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -O %llu -m %llu,%llu \"%s\"",
+ new_cluster.bindir,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmxoff,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti,
+- (unsigned long long) old_cluster.controldata.chkpnt_oldstMulti,
++ (unsigned long long) next_mxoff,
++ (unsigned long long) next_mxid,
++ (unsigned long long) oldest_mxid,
+ new_cluster.pgdata);
+ check_ok();
+ }
+@@ -874,6 +918,8 @@ set_frozenxids(bool minmxid_only)
+ int ntups;
+ int i_datname;
+ int i_datallowconn;
++ TransactionId frozen_xid;
++ MultiXactId minmxid;
+
+ if (!minmxid_only)
+ prep_status("Setting frozenxid and minmxid counters in new cluster");
+@@ -882,18 +928,26 @@ set_frozenxids(bool minmxid_only)
+
+ conn_template1 = connectToServer(&new_cluster, "template1");
+
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ frozen_xid = FirstNormalTransactionId;
++ else
++ frozen_xid = old_cluster.controldata.chkpnt_nxtxid;
++
++ minmxid = old_cluster.controldata.chkpnt_nxtmulti;
++
+ if (!minmxid_only)
+ /* set pg_database.datfrozenxid */
+ PQclear(executeQueryOrDie(conn_template1,
+ "UPDATE pg_catalog.pg_database "
+ "SET datfrozenxid = '%llu'",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid));
++ (unsigned long long) frozen_xid));
+
+ /* set pg_database.datminmxid */
+ PQclear(executeQueryOrDie(conn_template1,
+ "UPDATE pg_catalog.pg_database "
+ "SET datminmxid = '%llu'",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti));
++ (unsigned long long) minmxid));
+
+ /* get database names */
+ dbres = executeQueryOrDie(conn_template1,
+@@ -933,7 +987,7 @@ set_frozenxids(bool minmxid_only)
+ CppAsString2(RELKIND_RELATION) ", "
+ CppAsString2(RELKIND_MATVIEW) ", "
+ CppAsString2(RELKIND_TOASTVALUE) ")",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid));
++ (unsigned long long) frozen_xid));
+
+ /* set pg_class.relminmxid */
+ PQclear(executeQueryOrDie(conn,
+@@ -944,7 +998,7 @@ set_frozenxids(bool minmxid_only)
+ CppAsString2(RELKIND_RELATION) ", "
+ CppAsString2(RELKIND_MATVIEW) ", "
+ CppAsString2(RELKIND_TOASTVALUE) ")",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti));
++ (unsigned long long) minmxid));
+ PQfinish(conn);
+
+ /* Reset datallowconn flag */
+diff --git a/src/bin/pg_upgrade/pg_upgrade.h b/src/bin/pg_upgrade/pg_upgrade.h
+index 2c85ec1e949..5beccedff89 100644
+--- a/src/bin/pg_upgrade/pg_upgrade.h
++++ b/src/bin/pg_upgrade/pg_upgrade.h
+@@ -121,6 +121,11 @@ extern char *output_files[];
+ */
+ #define MULTIXACTOFFSET_FORMATCHANGE_CAT_VER 202409041
+
++/*
++ * xid format changed from 32-bit to 64-bit.
++ */
++#define XID_FORMATCHANGE_CAT_VER 999999999
++
+ /*
+ * large object chunk size added to pg_controldata,
+ * commit 5f93c37805e7485488480916b4585e098d3cc883
+@@ -233,13 +238,13 @@ typedef struct
+ uint32 ctrl_ver;
+ uint32 cat_ver;
+ char nextxlogfile[25];
+- uint32 chkpnt_nxtxid;
+- uint32 chkpnt_nxtepoch;
++ uint64 chkpnt_nxtxid;
++ uint32 chkpnt_nxtepoch; /* for 32bit xids only */
+ uint32 chkpnt_nxtoid;
+- uint32 chkpnt_nxtmulti;
++ uint64 chkpnt_nxtmulti;
+ uint64 chkpnt_nxtmxoff;
+- uint32 chkpnt_oldstMulti;
+- uint32 chkpnt_oldstxid;
++ uint64 chkpnt_oldstMulti;
++ uint64 chkpnt_oldstxid;
+ uint32 align;
+ uint32 blocksz;
+ uint32 largesz;
+@@ -374,7 +379,7 @@ extern OSInfo os_info;
+ /* check.c */
+
+ void output_check_banner(void);
+-void check_and_dump_old_cluster(void);
++void check_and_dump_old_cluster(bool *is_wraparound);
+ void check_new_cluster(void);
+ void report_clusters_compatible(void);
+ void issue_warnings_and_set_wal_level(void);
+@@ -417,7 +422,10 @@ void copyFileByRange(const char *src, const char *dst,
+ void linkFile(const char *src, const char *dst,
+ const char *schemaName, const char *relName);
+ void rewriteVisibilityMap(const char *fromfile, const char *tofile,
+- const char *schemaName, const char *relName);
++ const char *schemaName, const char *relName,
++ bool update_version);
++void updateSegmentPagesVersion(const char *fromfile, const char *tofile,
++ const char *schemaName, const char *relName);
+ void check_file_clone(void);
+ void check_copy_file_range(void);
+ void check_hard_link(void);
+@@ -494,6 +502,10 @@ void old_9_6_invalidate_hash_indexes(ClusterInfo *cluster,
+
+ void report_extension_updates(ClusterInfo *cluster);
+
++void invalidate_spgist_indexes(ClusterInfo *cluster, bool check_mode);
++void invalidate_gin_indexes(ClusterInfo *cluster, bool check_mode);
++void invalidate_external_indexes(ClusterInfo *cluster, bool check_mode);
++
+ /* parallel.c */
+ void parallel_exec_prog(const char *log_file, const char *opt_log_file,
+ const char *fmt,...) pg_attribute_printf(3, 4);
+@@ -502,6 +514,11 @@ void parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr
+ char *old_tablespace);
+ bool reap_child(bool wait_for_child);
+
++/* segresize.c */
++
++uint64 convert_multixact_offsets(void);
++void convert_xact(const char *olddir, const char *newdir);
++
+ /* task.c */
+
+ typedef void (*UpgradeTaskProcessCB) (DbInfo *dbinfo, PGresult *res, void *arg);
+diff --git a/src/bin/pg_upgrade/relfilenumber.c b/src/bin/pg_upgrade/relfilenumber.c
+index 07baa49a025..57c3f40a930 100644
+--- a/src/bin/pg_upgrade/relfilenumber.c
++++ b/src/bin/pg_upgrade/relfilenumber.c
+@@ -14,7 +14,8 @@
+ #include "pg_upgrade.h"
+
+ static void transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace);
+-static void transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_frozenbit);
++static void transfer_relfile(FileNameMap *map, const char *type_suffix,
++ bool vm_must_add_frozenbit, bool update_version);
+
+
+ /*
+@@ -137,6 +138,7 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+ {
+ int mapnum;
+ bool vm_must_add_frozenbit = false;
++ bool update_version = false;
+
+ /*
+ * Do we need to rewrite visibilitymap?
+@@ -145,19 +147,28 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+ new_cluster.controldata.cat_ver >= VISIBILITY_MAP_FROZEN_BIT_CAT_VER)
+ vm_must_add_frozenbit = true;
+
++ /*
++ * Need to update FSM and VM pages version to avoid lazy conversion.
++ */
++ if (old_cluster.controldata.cat_ver < new_cluster.controldata.cat_ver)
++ update_version = true;
++
+ for (mapnum = 0; mapnum < size; mapnum++)
+ {
+ if (old_tablespace == NULL ||
+ strcmp(maps[mapnum].old_tablespace, old_tablespace) == 0)
+ {
+ /* transfer primary file */
+- transfer_relfile(&maps[mapnum], "", vm_must_add_frozenbit);
++ transfer_relfile(&maps[mapnum], "", vm_must_add_frozenbit,
++ update_version);
+
+ /*
+ * Copy/link any fsm and vm files, if they exist
+ */
+- transfer_relfile(&maps[mapnum], "_fsm", vm_must_add_frozenbit);
+- transfer_relfile(&maps[mapnum], "_vm", vm_must_add_frozenbit);
++ transfer_relfile(&maps[mapnum], "_fsm", vm_must_add_frozenbit,
++ update_version);
++ transfer_relfile(&maps[mapnum], "_vm", vm_must_add_frozenbit,
++ update_version);
+ }
+ }
+ }
+@@ -171,7 +182,8 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+ * mode.
+ */
+ static void
+-transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_frozenbit)
++transfer_relfile(FileNameMap *map, const char *type_suffix,
++ bool vm_must_add_frozenbit, bool update_version)
+ {
+ char old_file[MAXPGPATH];
+ char new_file[MAXPGPATH];
+@@ -235,7 +247,17 @@ transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_fro
+ /* Need to rewrite visibility map format */
+ pg_log(PG_VERBOSE, "rewriting \"%s\" to \"%s\"",
+ old_file, new_file);
+- rewriteVisibilityMap(old_file, new_file, map->nspname, map->relname);
++ rewriteVisibilityMap(old_file, new_file, map->nspname,
++ map->relname, update_version);
++ }
++ else if ((update_version && strcmp(type_suffix, "_vm") == 0) ||
++ (update_version && strcmp(type_suffix, "_fsm") == 0))
++ {
++ /* Need to update pages version */
++ pg_log(PG_VERBOSE, "rewriting \"%s\" to \"%s\"",
++ old_file, new_file);
++ updateSegmentPagesVersion(old_file, new_file, map->nspname,
++ map->relname);
+ }
+ else
+ switch (user_opts.transfer_mode)
+diff --git a/src/bin/pg_upgrade/segresize.c b/src/bin/pg_upgrade/segresize.c
+index 73064c77deb..37a4efbec34 100644
+--- a/src/bin/pg_upgrade/segresize.c
++++ b/src/bin/pg_upgrade/segresize.c
+@@ -217,6 +217,76 @@ typedef uint32 MultiXactOffsetOld;
+ #define MULTIXACT_OFFSETS_PER_PAGE_OLD (BLCKSZ / sizeof(MultiXactOffsetOld))
+ #define MULTIXACT_OFFSETS_PER_PAGE_NEW (BLCKSZ / sizeof(MultiXactOffset))
+
++/*
++ * Convert pg_xact segments.
++ */
++void
++convert_xact(const char *old_subdir, const char *new_subdir)
++{
++typedef uint32 TransactionId32;
++#define SLRU_PAGES_PER_SEGMENT_OLD 32
++#define SLRU_PAGES_PER_SEGMENT 32 /* Should be equal to value from slru.h */
++
++#define CLOG_BITS_PER_XACT 2
++#define CLOG_XACTS_PER_BYTE 4
++#define CLOG_XACTS_PER_PAGE (BLCKSZ * CLOG_XACTS_PER_BYTE)
++
++#define MaxTransactionId32 ((TransactionId32) 0xFFFFFFFF)
++
++ SlruSegState oldseg = {0};
++ SlruSegState newseg = {0};
++ TransactionId oldest_xid = old_cluster.controldata.chkpnt_oldstxid;
++ TransactionId next_xid = old_cluster.controldata.chkpnt_nxtxid;
++ TransactionId xid;
++ int64 pageno;
++ char buf[BLCKSZ] = {0};
++
++ oldseg.dir = (char *) old_subdir;
++ newseg.dir = (char *) new_subdir;
++
++ pageno = oldest_xid / CLOG_XACTS_PER_PAGE;
++
++ oldseg.segno = pageno / SLRU_PAGES_PER_SEGMENT_OLD;
++ oldseg.pageno = pageno % SLRU_PAGES_PER_SEGMENT_OLD;
++
++ newseg.segno = pageno / SLRU_PAGES_PER_SEGMENT;
++ newseg.pageno = pageno % SLRU_PAGES_PER_SEGMENT;
++
++ if (next_xid < oldest_xid)
++ next_xid += (TransactionId) 1 << 32; /* wraparound */
++
++ /* Copy xid flags reading only needed segment pages */
++ for (xid = oldest_xid & ~(CLOG_XACTS_PER_PAGE - 1);
++ xid <= ((next_xid - 1) & ~(CLOG_XACTS_PER_PAGE - 1));
++ xid += CLOG_XACTS_PER_PAGE)
++ {
++ bool is_empty;
++
++ /* Handle possible segment wraparound */
++ if (oldseg.segno > MaxTransactionId32 / CLOG_XACTS_PER_PAGE / SLRU_PAGES_PER_SEGMENT_OLD)
++ {
++ pageno = (MaxTransactionId32 + 1) / CLOG_XACTS_PER_PAGE;
++
++ Assert(oldseg.segno == pageno / SLRU_PAGES_PER_SEGMENT_OLD);
++ Assert(!oldseg.pageno);
++ Assert(!oldseg.file);
++ oldseg.segno = 0;
++
++ Assert(newseg.segno == pageno / SLRU_PAGES_PER_SEGMENT);
++ Assert(!newseg.pageno);
++ Assert(!newseg.file);
++ newseg.segno = 0;
++ }
++
++ read_old_segment_page(&oldseg, buf, &is_empty);
++ write_new_segment_page(&newseg, buf);
++ }
++
++ /* Release resources */
++ close_segment(&oldseg);
++ close_segment(&newseg);
++}
++
+ /*
+ * Convert pg_multixact/offsets segments and return oldest multi offset.
+ */
+diff --git a/src/bin/pg_upgrade/t/002_pg_upgrade.pl b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
+index 3b9cb21cbd5..a8841f6ba38 100644
+--- a/src/bin/pg_upgrade/t/002_pg_upgrade.pl
++++ b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
+@@ -315,6 +315,14 @@ if (defined($ENV{oldinstall}))
+ }
+ }
+
++$oldnode->safe_psql('regression',
++ "CREATE TABLE t1 (id SERIAL NOT NULL PRIMARY KEY, plt text, pln NUMERIC(8, 4));
++ INSERT INTO t1 (plt, pln) SELECT md5(random()::text), random() * 9999 FROM generate_series(1, 1000);");
++my $relfrozenxid = $oldnode->safe_psql('regression',
++ "SELECT relfrozenxid FROM pg_class WHERE relname = 't1';");
++my $relminmxid = $oldnode->safe_psql('regression',
++ "SELECT relminmxid FROM pg_class WHERE relname = 't1';");
++
+ # Take a dump before performing the upgrade as a base comparison. Note
+ # that we need to use pg_dumpall from the new node here.
+ my @dump_command = (
+@@ -467,6 +475,16 @@ ok( !-d $newnode->data_dir . "/pg_upgrade_output.d",
+
+ $newnode->start;
+
++my $relfrozenxid_new = $newnode->safe_psql('regression',
++ "SELECT relfrozenxid FROM pg_class WHERE relname = 't1';");
++
++is($relfrozenxid_new, $relfrozenxid, 'old and new relfrozenxid match after pg_upgrade');
++
++my $relminmxid_new = $newnode->safe_psql('regression',
++ "SELECT relminmxid FROM pg_class WHERE relname = 't1';");
++
++is($relminmxid_new, $relminmxid, 'old and new relminmxid match after pg_upgrade');
++
+ # Check if there are any logs coming from pg_upgrade, that would only be
+ # retained on failure.
+ my $log_path = $newnode->data_dir . "/pg_upgrade_output.d";
+diff --git a/src/bin/pg_upgrade/version.c b/src/bin/pg_upgrade/version.c
+index 2a3b6ebb347..3b7d67eeee2 100644
+--- a/src/bin/pg_upgrade/version.c
++++ b/src/bin/pg_upgrade/version.c
+@@ -9,6 +9,7 @@
+
+ #include "postgres_fe.h"
+
++#include "access/transam.h"
+ #include "fe_utils/string_utils.h"
+ #include "pg_upgrade.h"
+
+@@ -29,19 +30,21 @@ jsonb_9_4_check_applicable(ClusterInfo *cluster)
+ }
+
+ /*
+- * old_9_6_invalidate_hash_indexes()
+- * 9.6 -> 10
+- * Hash index binary format has changed from 9.6->10.0
++ * invalidate_indexes()
++ * Invalidates all indexes satisfying given predicate.
+ */
+-void
+-old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
++static void
++invalidate_indexes(ClusterInfo *cluster, bool check_mode,
++ const char *name, const char *pred)
+ {
+ int dbnum;
+ FILE *script = NULL;
+ bool found = false;
+- char *output_path = "reindex_hash.sql";
++ char output_path[MAXPGPATH];
++
++ snprintf(output_path, sizeof(output_path), "reindex_%s.sql", name);
+
+- prep_status("Checking for hash indexes");
++ prep_status("Checking for %s indexes", name);
+
+ for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
+ {
+@@ -54,9 +57,16 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ DbInfo *active_db = &cluster->dbarr.dbs[dbnum];
+ PGconn *conn = connectToServer(cluster, active_db->db_name);
+
+- /* find hash indexes */
+- res = executeQueryOrDie(conn,
+- "SELECT n.nspname, c.relname "
++
++ /*
++ * Find indexes satisfying predicate.
++ *
++ * System indexes (with oids < FirstNormalObjectId) are excluded from
++ * the search as they are recreated in the new cluster during initdb.
++ */
++ res = executeQueryOrDie(
++ conn,
++ "SELECT n.nspname, c.relname, i.indexrelid "
+ "FROM pg_catalog.pg_class c, "
+ " pg_catalog.pg_index i, "
+ " pg_catalog.pg_am a, "
+@@ -64,8 +74,11 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ "WHERE i.indexrelid = c.oid AND "
+ " c.relam = a.oid AND "
+ " c.relnamespace = n.oid AND "
+- " a.amname = 'hash'"
+- );
++ " i.indexrelid >= '%u'::pg_catalog.oid AND "
++ " %s "
++ "ORDER BY i.indexrelid ASC",
++ FirstNormalObjectId,
++ pred);
+
+ ntups = PQntuples(res);
+ i_nspname = PQfnumber(res, "nspname");
+@@ -97,8 +110,14 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+
+ if (!check_mode && db_used)
+ {
+- /* mark hash indexes as invalid */
+- PQclear(executeQueryOrDie(conn,
++ /*
++ * Mark indexes satisfying predicate as invalid.
++ *
++ * System indexes (with oids < FirstNormalObjectId) are excluded
++ * from the search (see above).
++ */
++ PQclear(executeQueryOrDie(
++ conn,
+ "UPDATE pg_catalog.pg_index i "
+ "SET indisvalid = false "
+ "FROM pg_catalog.pg_class c, "
+@@ -107,7 +126,10 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ "WHERE i.indexrelid = c.oid AND "
+ " c.relam = a.oid AND "
+ " c.relnamespace = n.oid AND "
+- " a.amname = 'hash'"));
++ " i.indexrelid >= '%u'::pg_catalog.oid AND "
++ " %s",
++ FirstNormalObjectId,
++ pred));
+ }
+
+ PQfinish(conn);
+@@ -121,24 +143,72 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ report_status(PG_WARNING, "warning");
+ if (check_mode)
+ pg_log(PG_WARNING, "\n"
+- "Your installation contains hash indexes. These indexes have different\n"
++ "Your installation contains %s indexes. These indexes have different\n"
+ "internal formats between your old and new clusters, so they must be\n"
+ "reindexed with the REINDEX command. After upgrading, you will be given\n"
+- "REINDEX instructions.");
++ "REINDEX instructions.",
++ name);
++
+ else
+ pg_log(PG_WARNING, "\n"
+- "Your installation contains hash indexes. These indexes have different\n"
++ "Your installation contains %s indexes. These indexes have different\n"
+ "internal formats between your old and new clusters, so they must be\n"
+ "reindexed with the REINDEX command. The file\n"
+ " %s\n"
+ "when executed by psql by the database superuser will recreate all invalid\n"
+ "indexes; until then, none of these indexes will be used.",
++ name,
+ output_path);
+ }
+ else
+ check_ok();
+ }
+
++/*
++ * old_9_6_invalidate_hash_indexes()
++ * 9.6 -> 10
++ * Hash index binary format has changed from 9.6->10.0
++ */
++void
++old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "hash", "a.amname = 'hash'");
++}
++
++
++/*
++ * invalidate_spgist_indexes()
++ * 32bit -> 64bit
++ * SP-GIST contains xids.
++ */
++void
++invalidate_spgist_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "spgist", "a.amname = 'spgist'");
++}
++
++/*
++ * invalidate_gin_indexes()
++ * 32bit -> 64bit
++ * Gin indexes contains xids in deleted pages.
++ */
++void
++invalidate_gin_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "gin", "a.amname = 'gin'");
++}
++
++/*
++ * invalidate_external_indexes()
++ * Generate script to REINDEX non standard external indexes (like RUM etc)
++ */
++void
++invalidate_external_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "external",
++ "NOT a.amname IN ('btree', 'hash', 'gist', 'gin', 'spgist', 'brin')");
++}
++
+ /*
+ * Callback function for processing results of query for
+ * report_extension_updates()'s UpgradeTask. If the query returned any rows,
+diff --git a/src/bin/pg_waldump/pg_waldump.c b/src/bin/pg_waldump/pg_waldump.c
+index ae6b138cb3d..9679db87718 100644
+--- a/src/bin/pg_waldump/pg_waldump.c
++++ b/src/bin/pg_waldump/pg_waldump.c
+@@ -1050,7 +1050,7 @@ main(int argc, char **argv)
+ config.filter_by_fpw = true;
+ break;
+ case 'x':
+- if (sscanf(optarg, "%u", &config.filter_by_xid) != 1)
++ if (sscanf(optarg, "%" PRIu64 "u", &config.filter_by_xid) != 1)
+ {
+ pg_log_error("invalid transaction ID specification: \"%s\"",
+ optarg);
+diff --git a/src/bin/pg_waldump/t/001_basic.pl b/src/bin/pg_waldump/t/001_basic.pl
+index 578e4731394..6313b4edeae 100644
+--- a/src/bin/pg_waldump/t/001_basic.pl
++++ b/src/bin/pg_waldump/t/001_basic.pl
+@@ -73,7 +73,8 @@ BRIN
+ CommitTs
+ ReplicationOrigin
+ Generic
+-LogicalMessage$/,
++LogicalMessage
++Heap3$/,
+ 'rmgr list');
+
+
+diff --git a/src/include/access/ginblock.h b/src/include/access/ginblock.h
+index b3b7daa049a..1b5e46d264a 100644
+--- a/src/include/access/ginblock.h
++++ b/src/include/access/ginblock.h
+@@ -133,8 +133,15 @@ typedef struct GinMetaPageData
+ * We should reclaim deleted page only once every transaction started before
+ * its deletion is over.
+ */
+-#define GinPageGetDeleteXid(page) ( ((PageHeader) (page))->pd_prune_xid )
+-#define GinPageSetDeleteXid(page, xid) ( ((PageHeader) (page))->pd_prune_xid = xid)
++#define GinPageGetDeleteXid(page) ( \
++ (((PageHeader) (page))->pd_upper == BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId)) ? \
++ *((TransactionId *) ((char *) (page) + BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId))) : \
++ InvalidTransactionId )
++#define GinPageSetDeleteXid(page, xid) \
++ do { \
++ ((PageHeader) (page))->pd_upper = BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId); \
++ *((TransactionId *) ((char *) (page) + BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId))) = xid; \
++ } while (false)
+ extern bool GinPageIsRecyclable(Page page);
+
+ /*
+diff --git a/src/include/access/gist.h b/src/include/access/gist.h
+index 22dd04c1418..9455beb7202 100644
+--- a/src/include/access/gist.h
++++ b/src/include/access/gist.h
+@@ -225,7 +225,7 @@ GistPageGetDeleteXid(Page page)
+ return ((GISTDeletedPageContents *) PageGetContents(page))->deleteXid;
+ }
+ else
+- return FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
++ return FullTransactionIdFromXid(FirstNormalTransactionId);
+ }
+
+ /*
+diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
+index 96cf82f97b7..5f5f9976c60 100644
+--- a/src/include/access/heapam.h
++++ b/src/include/access/heapam.h
+@@ -106,6 +106,8 @@ typedef struct HeapScanDescData
+ int rs_cindex; /* current tuple's index in vistuples */
+ int rs_ntuples; /* number of visible tuples on page */
+ OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]; /* their offsets */
++ TransactionId rs_xmin[MaxHeapTuplesPerPage]; /* their xmins */
++ TransactionId rs_xmax[MaxHeapTuplesPerPage]; /* their xmaxs */
+ } HeapScanDescData;
+ typedef struct HeapScanDescData *HeapScanDesc;
+
+@@ -319,6 +321,8 @@ extern void ReleaseBulkInsertStatePin(BulkInsertState bistate);
+
+ extern void heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ int options, BulkInsertState bistate);
++extern void rewrite_page_prepare_for_xid(Page page, HeapTuple tup,
++ bool is_toast);
+ extern void heap_multi_insert(Relation relation, struct TupleTableSlot **slots,
+ int ntuples, CommandId cid, int options,
+ BulkInsertState bistate);
+@@ -345,23 +349,23 @@ extern void heap_inplace_update_and_unlock(Relation relation,
+ Buffer buffer);
+ extern void heap_inplace_unlock(Relation relation,
+ HeapTuple oldtup, Buffer buffer);
+-extern bool heap_prepare_freeze_tuple(HeapTupleHeader tuple,
++extern bool heap_prepare_freeze_tuple(HeapTuple tuple,
+ const struct VacuumCutoffs *cutoffs,
+ HeapPageFreeze *pagefrz,
+ HeapTupleFreeze *frz, bool *totally_frozen);
+
+-extern void heap_pre_freeze_checks(Buffer buffer,
++extern void heap_pre_freeze_checks(Relation rel, Buffer buffer,
+ HeapTupleFreeze *tuples, int ntuples);
+-extern void heap_freeze_prepared_tuples(Buffer buffer,
++extern void heap_freeze_prepared_tuples(Relation rel, Buffer buffer,
+ HeapTupleFreeze *tuples, int ntuples);
+-extern bool heap_freeze_tuple(HeapTupleHeader tuple,
++extern bool heap_freeze_tuple(HeapTuple tuple,
+ TransactionId relfrozenxid, TransactionId relminmxid,
+ TransactionId FreezeLimit, TransactionId MultiXactCutoff);
+-extern bool heap_tuple_should_freeze(HeapTupleHeader tuple,
++extern bool heap_tuple_should_freeze(HeapTuple tuple,
+ const struct VacuumCutoffs *cutoffs,
+ TransactionId *NoFreezePageRelfrozenXid,
+ MultiXactId *NoFreezePageRelminMxid);
+-extern bool heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple);
++extern bool heap_tuple_needs_eventual_freeze(HeapTuple tuple);
+
+ extern void simple_heap_insert(Relation relation, HeapTuple tup);
+ extern void simple_heap_delete(Relation relation, ItemPointer tid);
+@@ -382,12 +386,19 @@ extern void heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ PruneReason reason,
+ OffsetNumber *off_loc,
+ TransactionId *new_relfrozen_xid,
+- MultiXactId *new_relmin_mxid);
++ MultiXactId *new_relmin_mxid,
++ bool repairFragmentation);
++
+ extern void heap_page_prune_execute(Buffer buffer, bool lp_truncate_only,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *nowdead, int ndead,
+- OffsetNumber *nowunused, int nunused);
+-extern void heap_get_root_tuples(Page page, OffsetNumber *root_offsets);
++ OffsetNumber *nowunused, int nunused,
++ bool repairFragmentation,
++ bool is_toast);
++
++extern void heap_get_root_tuples(Relation relation, Buffer buffer, Page page,
++ OffsetNumber *root_offsets);
++
+ extern void log_heap_prune_and_freeze(Relation relation, Buffer buffer,
+ TransactionId conflict_xid,
+ bool cleanup_lock,
+@@ -395,7 +406,8 @@ extern void log_heap_prune_and_freeze(Relation relation, Buffer buffer,
+ HeapTupleFreeze *frozen, int nfrozen,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *dead, int ndead,
+- OffsetNumber *unused, int nunused);
++ OffsetNumber *unused, int nunused,
++ bool repairFragmentation);
+
+ /* in heap/vacuumlazy.c */
+ struct VacuumParams;
+@@ -413,7 +425,7 @@ extern HTSV_Result HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer
+ TransactionId *dead_after);
+ extern void HeapTupleSetHintBits(HeapTupleHeader tuple, Buffer buffer,
+ uint16 infomask, TransactionId xid);
+-extern bool HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple);
++extern bool HeapTupleIsOnlyLocked(HeapTuple htup);
+ extern bool HeapTupleIsSurelyDead(HeapTuple htup,
+ struct GlobalVisState *vistest);
+
+@@ -440,18 +452,32 @@ extern void HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+ * in private storage (which is what CLUSTER and friends do).
+ */
+ static inline void
+-heap_execute_freeze_tuple(HeapTupleHeader tuple, HeapTupleFreeze *frz)
++heap_execute_freeze_tuple(HeapTuple htup, HeapTupleFreeze *frz)
+ {
+- HeapTupleHeaderSetXmax(tuple, frz->xmax);
++ HeapTupleHeader tuple = htup->t_data;
++
++ tuple->t_infomask = frz->t_infomask;
++ tuple->t_infomask2 = frz->t_infomask2;
++
++ HeapTupleSetXmax(htup, frz->xmax);
+
+ if (frz->frzflags & XLH_FREEZE_XVAC)
+ HeapTupleHeaderSetXvac(tuple, FrozenTransactionId);
+
+ if (frz->frzflags & XLH_INVALID_XVAC)
+ HeapTupleHeaderSetXvac(tuple, InvalidTransactionId);
++}
+
+- tuple->t_infomask = frz->t_infomask;
+- tuple->t_infomask2 = frz->t_infomask2;
++static inline void
++heap_execute_freeze_tuple_page(Page page, HeapTupleHeader htup,
++ HeapTupleFreeze *frz, bool is_toast)
++{
++ HeapTupleData tuple;
++
++ tuple.t_data = htup;
++ heap_execute_freeze_tuple(&tuple, frz);
++
++ HeapTupleHeaderStoreXmax(page, &tuple, is_toast);
+ }
+
+ #endif /* HEAPAM_H */
+diff --git a/src/include/access/heapam_xlog.h b/src/include/access/heapam_xlog.h
+index 4591e9a918f..74648a5fe5d 100644
+--- a/src/include/access/heapam_xlog.h
++++ b/src/include/access/heapam_xlog.h
+@@ -65,6 +65,8 @@
+ #define XLOG_HEAP2_LOCK_UPDATED 0x60
+ #define XLOG_HEAP2_NEW_CID 0x70
+
++#define XLOG_HEAP3_BASE_SHIFT 0x00
++
+ /*
+ * xl_heap_insert/xl_heap_multi_insert flag values, 8 bits are available.
+ */
+@@ -104,6 +106,7 @@
+ #define XLH_DELETE_CONTAINS_OLD_KEY (1<<2)
+ #define XLH_DELETE_IS_SUPER (1<<3)
+ #define XLH_DELETE_IS_PARTITION_MOVE (1<<4)
++#define XLH_DELETE_PAGE_ON_TOAST_RELATION (1<<5)
+
+ /* convenience macro for checking whether any form of old tuple was logged */
+ #define XLH_DELETE_CONTAINS_OLD \
+@@ -282,10 +285,12 @@ typedef struct xl_heap_update
+ * other fields require only 2-byte alignment. This is also the reason that
+ * 'frz_offsets' is stored separately from the xlhp_freeze_plan structs.
+ */
++
+ typedef struct xl_heap_prune
+ {
+ uint8 reason;
+- uint8 flags;
++ uint8 padding;
++ uint16 flags;
+
+ /*
+ * If XLHP_HAS_CONFLICT_HORIZON is set, the conflict horizon XID follows,
+@@ -293,7 +298,7 @@ typedef struct xl_heap_prune
+ */
+ } xl_heap_prune;
+
+-#define SizeOfHeapPrune (offsetof(xl_heap_prune, flags) + sizeof(uint8))
++#define SizeOfHeapPrune (offsetof(xl_heap_prune, flags) + sizeof(((xl_heap_prune*)0)->flags))
+
+ /* to handle recovery conflict during logical decoding on standby */
+ #define XLHP_IS_CATALOG_REL (1 << 1)
+@@ -331,6 +336,9 @@ typedef struct xl_heap_prune
+ #define XLHP_HAS_DEAD_ITEMS (1 << 6)
+ #define XLHP_HAS_NOW_UNUSED_ITEMS (1 << 7)
+
++#define XLHP_ON_TOAST_RELATION (1 << 8)
++#define XLHP_REPAIR_FRAGMENTATION (1 << 9)
++
+ /*
+ * xlhp_freeze_plan describes how to freeze a group of one or more heap tuples
+ * (appears in xl_heap_prune's xlhp_freeze_plans sub-record)
+@@ -480,7 +488,19 @@ typedef struct xl_heap_rewrite_mapping
+ XLogRecPtr start_lsn; /* Insert LSN at begin of rewrite */
+ } xl_heap_rewrite_mapping;
+
+-extern void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
++#define XLH_BASE_SHIFT_ON_TOAST_RELATION 0x01
++
++/* shift the base of xids on heap page */
++typedef struct xl_heap_base_shift
++{
++ int64 delta; /* delta value to shift the base */
++ bool multi; /* true to shift multixact base */
++ uint8 flags;
++} xl_heap_base_shift;
++
++#define SizeOfHeapBaseShift (offsetof(xl_heap_base_shift, flags) + sizeof(uint8))
++
++extern void HeapTupleHeaderAdvanceConflictHorizon(HeapTuple tuple,
+ TransactionId *snapshotConflictHorizon);
+
+ extern void heap_redo(XLogReaderState *record);
+@@ -490,6 +510,9 @@ extern void heap_mask(char *pagedata, BlockNumber blkno);
+ extern void heap2_redo(XLogReaderState *record);
+ extern void heap2_desc(StringInfo buf, XLogReaderState *record);
+ extern const char *heap2_identify(uint8 info);
++extern void heap3_redo(XLogReaderState *record);
++extern void heap3_desc(StringInfo buf, XLogReaderState *record);
++extern const char *heap3_identify(uint8 info);
+ extern void heap_xlog_logical_rewrite(XLogReaderState *r);
+
+ extern XLogRecPtr log_heap_visible(Relation rel, Buffer heap_buffer,
+diff --git a/src/include/access/heaptoast.h b/src/include/access/heaptoast.h
+index c376dff48d7..d605a7149b7 100644
+--- a/src/include/access/heaptoast.h
++++ b/src/include/access/heaptoast.h
+@@ -20,10 +20,19 @@
+ /*
+ * Find the maximum size of a tuple if there are to be N tuples per page.
+ */
++#if MAXIMUM_ALIGNOF == 8
+ #define MaximumBytesPerTuple(tuplesPerPage) \
+ MAXALIGN_DOWN((BLCKSZ - \
+- MAXALIGN(SizeOfPageHeaderData + (tuplesPerPage) * sizeof(ItemIdData))) \
++ MAXALIGN(SizeOfPageHeaderData + (tuplesPerPage) * sizeof(ItemIdData)) - MAXALIGN(sizeof(HeapPageSpecialData))) \
+ / (tuplesPerPage))
++#elif MAXIMUM_ALIGNOF == 4
++#define MaximumBytesPerTuple(tuplesPerPage) \
++ MAXALIGN_DOWN((BLCKSZ - \
++ MAXALIGN(SizeOfPageHeaderData + (tuplesPerPage) * sizeof(ItemIdData)) - MAXALIGN(sizeof(ToastPageSpecialData))) \
++ / (tuplesPerPage))
++#else
++#error "unknown arch bitness"
++#endif
+
+ /*
+ * These symbols control toaster activation. If a tuple is larger than
+diff --git a/src/include/access/htup.h b/src/include/access/htup.h
+index 116cb1bb273..e52e98ddbd0 100644
+--- a/src/include/access/htup.h
++++ b/src/include/access/htup.h
+@@ -54,6 +54,12 @@ typedef MinimalTupleData *MinimalTuple;
+ * this can't be told apart from case #1 by inspection; code setting up
+ * or destroying this representation has to know what it's doing.
+ *
++ * t_xmin and t_xmax are TransactionId values stored in heap tuple header.
++ * Normally they are calculated from ShortTransactionId-sized on-disk tuple
++ * xmin/xmax representation:
++ * t_data->t_choice.t_heap.t_xmin/t_data->t_choice.t_heap.t_xmin
++ * and pd_xid_base and pd_multi_base commmon values for all tuples on a page.
++ *
+ * t_len should always be valid, except in the pointer-to-nothing case.
+ * t_self and t_tableOid should be valid if the HeapTupleData points to
+ * a disk buffer, or if it represents a copy of a tuple on disk. They
+@@ -61,10 +67,12 @@ typedef MinimalTupleData *MinimalTuple;
+ */
+ typedef struct HeapTupleData
+ {
++ TransactionId t_xmin; /* calculated tuple xmin */
++ TransactionId t_xmax; /* calculated tuple xmax */
+ uint32 t_len; /* length of *t_data */
+ ItemPointerData t_self; /* SelfItemPointer */
+ Oid t_tableOid; /* table the tuple came from */
+-#define FIELDNO_HEAPTUPLEDATA_DATA 3
++#define FIELDNO_HEAPTUPLEDATA_DATA 5
+ HeapTupleHeader t_data; /* -> tuple header and data */
+ } HeapTupleData;
+
+@@ -78,12 +86,11 @@ typedef HeapTupleData *HeapTuple;
+ #define HeapTupleIsValid(tuple) PointerIsValid(tuple)
+
+ /* HeapTupleHeader functions implemented in utils/time/combocid.c */
+-extern CommandId HeapTupleHeaderGetCmin(HeapTupleHeader tup);
+-extern CommandId HeapTupleHeaderGetCmax(HeapTupleHeader tup);
+-extern void HeapTupleHeaderAdjustCmax(HeapTupleHeader tup,
+- CommandId *cmax, bool *iscombo);
++extern CommandId HeapTupleGetCmin(HeapTuple tup);
++extern CommandId HeapTupleGetCmax(HeapTuple tup);
++extern void HeapTupleAdjustCmax(HeapTuple tup, CommandId *cmax, bool *iscombo);
+
+ /* Prototype for HeapTupleHeader accessors in heapam.c */
+-extern TransactionId HeapTupleGetUpdateXid(HeapTupleHeader tuple);
++extern TransactionId HeapTupleGetUpdateXid(HeapTuple tuple);
+
+ #endif /* HTUP_H */
+diff --git a/src/include/access/htup_details.h b/src/include/access/htup_details.h
+index 5e38ef86969..426b1f479a6 100644
+--- a/src/include/access/htup_details.h
++++ b/src/include/access/htup_details.h
+@@ -19,6 +19,7 @@
+ #include "access/tupdesc.h"
+ #include "access/tupmacs.h"
+ #include "storage/bufpage.h"
++#include "storage/bufmgr.h"
+ #include "varatt.h"
+
+ /*
+@@ -121,13 +122,13 @@
+
+ typedef struct HeapTupleFields
+ {
+- TransactionId t_xmin; /* inserting xact ID */
+- TransactionId t_xmax; /* deleting or locking xact ID */
++ ShortTransactionId t_xmin; /* inserting xact ID */
++ ShortTransactionId t_xmax; /* deleting or locking xact ID */
+
+ union
+ {
+ CommandId t_cid; /* inserting or deleting command ID, or both */
+- TransactionId t_xvac; /* old-style VACUUM FULL xact ID */
++ ShortTransactionId t_xvac; /* old-style VACUUM FULL xact ID */
+ } t_field3;
+ } HeapTupleFields;
+
+@@ -223,7 +224,7 @@ struct HeapTupleHeaderData
+ * HEAP_XMAX_LOCK_ONLY bit is set; or, for pg_upgrade's sake, if the Xmax is
+ * not a multi and the EXCL_LOCK bit is set.
+ *
+- * See also HeapTupleHeaderIsOnlyLocked, which also checks for a possible
++ * See also HeapTupleIsOnlyLocked, which also checks for a possible
+ * aborted updater transaction.
+ *
+ * Beware of multiple evaluations of the argument.
+@@ -299,29 +300,81 @@ struct HeapTupleHeaderData
+ */
+
+ /*
+- * HeapTupleHeaderGetRawXmin returns the "raw" xmin field, which is the xid
++ * HeapTupleGetRawXmin returns the "raw" xmin field, which is the xid
+ * originally used to insert the tuple. However, the tuple might actually
+- * be frozen (via HeapTupleHeaderSetXminFrozen) in which case the tuple's xmin
++ * be frozen (via HeapTupleHeaderStoreXminFrozen) in which case the tuple's xmin
+ * is visible to every snapshot. Prior to PostgreSQL 9.4, we actually changed
+ * the xmin to FrozenTransactionId, and that value may still be encountered
+ * on disk.
+ */
+-#define HeapTupleHeaderGetRawXmin(tup) \
++#define HeapTupleGetRawXmin(tup) \
+ ( \
+- (tup)->t_choice.t_heap.t_xmin \
++ ((tup)->t_xmin) \
+ )
+
+-#define HeapTupleHeaderGetXmin(tup) \
++#define HeapTupleGetXmin(tup) \
+ ( \
+- HeapTupleHeaderXminFrozen(tup) ? \
+- FrozenTransactionId : HeapTupleHeaderGetRawXmin(tup) \
++ HeapTupleHeaderXminFrozen((tup)->t_data) ? \
++ FrozenTransactionId : HeapTupleGetRawXmin(tup) \
+ )
+
+-#define HeapTupleHeaderSetXmin(tup, xid) \
++#define HeapTupleSetXmin(tup, xid) \
+ ( \
+- (tup)->t_choice.t_heap.t_xmin = (xid) \
++ ((tup)->t_xmin = (xid)) \
+ )
+
++/*
++ * Functions for accessing "double xmax". On pg_upgraded instances, it might
++ * happend that we can't fit new special area to the page. But we still
++ * might neep to write xmax of tuples for updates and deletes. The trick is
++ * that we actually don't need xmin field. After pg_upgrade (wich implies
++ * restart) no insertions went to this page yet (otherwise special area could
++ * fit). So, if tuple is visible (othewise it would be deleted), then it's
++ * visible for everybody. Thus, t_xmin isn't needed. Therefore, we can use
++ * both t_xmin and t_xmax to store 64-bit xmax.
++ *
++ * See heap_convert.c for details.
++ */
++static inline TransactionId
++HeapTupleHeaderGetDoubleXmax(HeapTupleHeader htup)
++{
++ TransactionId xmax;
++
++ xmax = htup->t_choice.t_heap.t_xmin;
++ xmax <<= 32;
++ xmax += htup->t_choice.t_heap.t_xmax;
++
++ return xmax;
++}
++
++static inline void
++HeapTupleHeaderSetDoubleXmax(HeapTupleHeader htup, TransactionId xid)
++{
++ htup->t_choice.t_heap.t_xmax = xid & 0xFFFFFFFF;
++ htup->t_choice.t_heap.t_xmin = (xid >> 32) & 0xFFFFFFFF;
++}
++
++static inline void
++HeapTupleHeaderStoreXmin(Page page, HeapTuple htup, bool is_toast)
++{
++ TransactionId base;
++
++ Assert(!HeapPageIsDoubleXmax(page));
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial((page))->pd_xid_base;
++ htup->t_data->t_choice.t_heap.t_xmin =
++ NormalTransactionIdToShort(base, htup->t_xmin);
++}
++
++static inline void
++HeapTupleAndHeaderSetXmin(Page page, HeapTuple tup, TransactionId xid,
++ bool is_toast)
++{
++ HeapTupleSetXmin(tup, xid);
++ HeapTupleHeaderStoreXmin(page, tup, is_toast);
++}
++
+ #define HeapTupleHeaderXminCommitted(tup) \
+ ( \
+ ((tup)->t_infomask & HEAP_XMIN_COMMITTED) != 0 \
+@@ -338,6 +391,12 @@ struct HeapTupleHeaderData
+ ((tup)->t_infomask & (HEAP_XMIN_FROZEN)) == HEAP_XMIN_FROZEN \
+ )
+
++#define HeapTupleHeaderStoreXminFrozen(tup) \
++( \
++ AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
++ ((tup)->t_infomask |= HEAP_XMIN_FROZEN) \
++)
++
+ #define HeapTupleHeaderSetXminCommitted(tup) \
+ ( \
+ AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
+@@ -363,30 +422,80 @@ struct HeapTupleHeaderData
+ * to resolve the MultiXactId if necessary. This might involve multixact I/O,
+ * so it should only be used if absolutely necessary.
+ */
+-#define HeapTupleHeaderGetUpdateXid(tup) \
++#define HeapTupleGetUpdateXidAny(tup) \
+ ( \
+- (!((tup)->t_infomask & HEAP_XMAX_INVALID) && \
+- ((tup)->t_infomask & HEAP_XMAX_IS_MULTI) && \
+- !((tup)->t_infomask & HEAP_XMAX_LOCK_ONLY)) ? \
++ (!((tup)->t_data->t_infomask & HEAP_XMAX_INVALID) && \
++ ((tup)->t_data->t_infomask & HEAP_XMAX_IS_MULTI) && \
++ !((tup)->t_data->t_infomask & HEAP_XMAX_LOCK_ONLY)) ? \
+ HeapTupleGetUpdateXid(tup) \
+ : \
+- HeapTupleHeaderGetRawXmax(tup) \
++ HeapTupleGetRawXmax(tup) \
+ )
+
+-#define HeapTupleHeaderGetRawXmax(tup) \
+-( \
+- (tup)->t_choice.t_heap.t_xmax \
+-)
++static inline TransactionId
++HeapTupleHeaderGetRawXmax(Page page, HeapTupleHeader htup)
++{
++ TransactionId base;
+
+-#define HeapTupleHeaderSetXmax(tup, xid) \
++ if (HeapPageIsDoubleXmax(page))
++ return HeapTupleHeaderGetDoubleXmax(htup);
++
++ base = (htup->t_infomask & HEAP_XMAX_IS_MULTI) ?
++ HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++ return ShortTransactionIdToNormal(base,
++ htup->t_choice.t_heap.t_xmax);
++}
++
++#define HeapTupleGetRawXmax(tup) \
+ ( \
+- (tup)->t_choice.t_heap.t_xmax = (xid) \
++ ((tup)->t_xmax) \
+ )
+
++#define HeapTupleSetXmax(tup, xid) \
++do { \
++ (tup)->t_xmax = (xid); \
++} while (0)
++
++/*
++ * Set xid as xmax for HeapTupleHeader.
++ */
++static inline void
++HeapTupleHeaderStoreXmax(Page page, HeapTuple htup, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ HeapTupleHeaderSetDoubleXmax(htup->t_data, htup->t_xmax);
++ return;
++ }
++
++ if (is_toast)
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ else
++ base = (htup->t_data->t_infomask & HEAP_XMAX_IS_MULTI) != 0 ?
++ HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++ htup->t_data->t_choice.t_heap.t_xmax =
++ NormalTransactionIdToShort(base, htup->t_xmax);
++}
++
++/*
++ * Set xid as xmax for HeadTuple and HeapTupleHeader.
++ */
++static inline void
++HeapTupleAndHeaderSetXmax(Page page, HeapTuple htup, TransactionId xid,
++ bool is_toast)
++{
++ HeapTupleSetXmax(htup, xid);
++ HeapTupleHeaderStoreXmax(page, htup, is_toast);
++}
++
+ /*
+ * HeapTupleHeaderGetRawCommandId will give you what's in the header whether
+- * it is useful or not. Most code should use HeapTupleHeaderGetCmin or
+- * HeapTupleHeaderGetCmax instead, but note that those Assert that you can
++ * it is useful or not. Most code should use HeapTupleGetCmin or
++ * HeapTupleGetCmax instead, but note that those Assert that you can
+ * get a legitimate result, ie you are in the originating transaction!
+ */
+ #define HeapTupleHeaderGetRawCommandId(tup) \
+@@ -402,7 +511,7 @@ do { \
+ (tup)->t_infomask &= ~HEAP_COMBOCID; \
+ } while (0)
+
+-/* SetCmax must be used after HeapTupleHeaderAdjustCmax; see combocid.c */
++/* SetCmax must be used after HeapTupleAdjustCmax; see combocid.c */
+ #define HeapTupleHeaderSetCmax(tup, cid, iscombo) \
+ do { \
+ Assert(!((tup)->t_infomask & HEAP_MOVED)); \
+@@ -559,8 +668,16 @@ StaticAssertDecl(MaxOffsetNumber < SpecTokenOffsetNumber,
+ * an otherwise-empty page can indeed hold a tuple of this size. Because
+ * ItemIds and tuples have different alignment requirements, don't assume that
+ * you can, say, fit 2 tuples of size MaxHeapTupleSize/2 on the same page.
++ *
++ * On shift to 64-bit XIDs MaxHeapTupleSize decreased by sizeof(HeapPageSpecialData).
++ * Extant tuples with length over new MaxHeapTupleSize are inherited on DoubleXmax
++ * pages. They could be read, but can not be updated unless their length decreases
++ * to fit MaxHeapTupleSize. Vacuum full will also copy these double xmax pages
++ * without change.
+ */
+-#define MaxHeapTupleSize (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))
++
++#define MaxHeapTupleSize (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)) - MAXALIGN(sizeof(HeapPageSpecialData)))
++#define MaxHeapTupleSize_32 (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))
+ #define MinHeapTupleSize MAXALIGN(SizeofHeapTupleHeader)
+
+ /*
+@@ -694,6 +811,139 @@ struct MinimalTupleData
+ #define HeapTupleClearHeapOnly(tuple) \
+ HeapTupleHeaderClearHeapOnly((tuple)->t_data)
+
++/*
++ * Copy base values for xid and multixacts from one heap tuple to heap tuple.
++ * Should be called on tuple copy or making desc tuple on the base on src tuple
++ * saving visibility information.
++ */
++static inline void
++HeapTupleCopyXids(HeapTuple dest, HeapTuple src)
++{
++ dest->t_xmin = src->t_xmin;
++ dest->t_xmax = src->t_xmax;
++}
++
++/*
++ * Set base values for tuple xids/multixacts to zero. Used when visibility
++ * infromation is negligible or will be set later.
++ */
++static inline void
++HeapTupleSetZeroXids(HeapTuple htup)
++{
++ htup->t_xmin = 0;
++ htup->t_xmax = 0;
++}
++
++/*
++ * Copy HeapTupleHeader xmin/xmax in raw way ???
++ */
++static inline void
++HeapTupleCopyHeaderXids(HeapTuple htup) \
++{
++ htup->t_xmin = htup->t_data->t_choice.t_heap.t_xmin;
++ htup->t_xmax = htup->t_data->t_choice.t_heap.t_xmax;
++}
++
++
++static inline void
++HeapTupleCopyRawXminFromPage(HeapTuple tup, Page page, bool is_toast)
++{
++ TransactionId base;
++ ShortTransactionId xmin; /* short xmin from tuple header */
++
++ xmin = tup->t_data->t_choice.t_heap.t_xmin;
++
++ if (!TransactionIdIsNormal(xmin))
++ base = 0;
++ else if (is_toast)
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ else
++ base = HeapPageGetSpecial(page)->pd_xid_base;
++
++ tup->t_xmin = ShortTransactionIdToNormal(base, xmin);
++}
++
++static inline void
++HeapTupleCopyXminFromPage(HeapTuple tup, Page page, bool is_toast)
++{
++ if (HeapTupleHeaderXminFrozen(tup->t_data))
++ {
++ tup->t_xmin = FrozenTransactionId;
++ return;
++ }
++
++ HeapTupleCopyRawXminFromPage(tup, page, is_toast);
++}
++
++static inline void
++HeapTupleCopyXmaxFromPage(HeapTuple tup, Page page, bool is_toast)
++{
++ TransactionId base;
++ ShortTransactionId xmax; /* short xmax from tuple header */
++
++ xmax = tup->t_data->t_choice.t_heap.t_xmax;
++
++ if (!TransactionIdIsNormal(xmax))
++ base = 0;
++ else if (is_toast)
++ /*
++ * Toast page is not expected to have multixacts in chunks and
++ * has shorter special.
++ */
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ else if (tup->t_data->t_infomask & HEAP_XMAX_IS_MULTI)
++ base = HeapPageGetSpecial(page)->pd_multi_base;
++ else
++ base = HeapPageGetSpecial(page)->pd_xid_base;
++
++ tup->t_xmax = ShortTransactionIdToNormal(base, xmax);
++}
++
++static inline void
++HeapTupleCopyRawXidsFromPage(Buffer buffer, HeapTuple tup, Page page,
++ bool is_toast)
++{
++ Assert(IsBufferLocked(buffer));
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ /*
++ * On double xmax pages, xmax is extracted from tuple header.
++ */
++ tup->t_xmin = FrozenTransactionId;
++ tup->t_xmax = HeapTupleHeaderGetDoubleXmax(tup->t_data);
++ return;
++ }
++
++ HeapTupleCopyRawXminFromPage(tup, page, is_toast);
++ HeapTupleCopyXmaxFromPage(tup, page, is_toast);
++}
++
++/*
++ * Copy base values for xid and multixacts from page to heap tuple. Should be
++ * called each time tuple is read from page. Otherwise, it would be impossible
++ * to correctly read tuple xmin and xmax.
++ */
++static inline void
++HeapTupleCopyXidsFromPage(Buffer buffer, HeapTuple tup, Page page,
++ bool is_toast)
++{
++ Assert(IsBufferLocked(buffer));
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ /*
++ * On double xmax pages, xmax is extracted from tuple header.
++ */
++ tup->t_xmin = FrozenTransactionId;
++ tup->t_xmax = HeapTupleHeaderGetDoubleXmax(tup->t_data);
++ return;
++ }
++
++ HeapTupleCopyXminFromPage(tup, page, is_toast);
++ HeapTupleCopyXmaxFromPage(tup, page, is_toast);
++}
++
+ /* prototypes for functions in common/heaptuple.c */
+ extern Size heap_compute_data_size(TupleDesc tupleDesc,
+ const Datum *values, const bool *isnull);
+diff --git a/src/include/access/multixact.h b/src/include/access/multixact.h
+index 5aefbddce3e..02922faf77f 100644
+--- a/src/include/access/multixact.h
++++ b/src/include/access/multixact.h
+@@ -18,12 +18,12 @@
+
+ /*
+ * The first two MultiXactId values are reserved to store the truncation Xid
+- * and epoch of the first segment, so we start assigning multixact values from
++ * and base of the first segment, so we start assigning multixact values from
+ * 2.
+ */
+-#define InvalidMultiXactId ((MultiXactId) 0)
+-#define FirstMultiXactId ((MultiXactId) 1)
+-#define MaxMultiXactId ((MultiXactId) 0xFFFFFFFF)
++#define InvalidMultiXactId UINT64CONST(0)
++#define FirstMultiXactId UINT64CONST(1)
++#define MaxMultiXactId UINT64CONST(0xFFFFFFFFFFFFFFFF)
+
+ #define MultiXactIdIsValid(multi) ((multi) != InvalidMultiXactId)
+
+diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
+index 123fba624db..0c4df130b01 100644
+--- a/src/include/access/nbtree.h
++++ b/src/include/access/nbtree.h
+@@ -62,8 +62,10 @@ typedef uint16 BTCycleId;
+ typedef struct BTPageOpaqueData
+ {
+ BlockNumber btpo_prev; /* left sibling, or P_NONE if leftmost */
++ /* ... or next transaction ID (lower part) */
+ BlockNumber btpo_next; /* right sibling, or P_NONE if rightmost */
+ uint32 btpo_level; /* tree level --- zero for leaf pages */
++ /* ... or next transaction ID (lower part) */
+ uint16 btpo_flags; /* flag bits, see below */
+ BTCycleId btpo_cycleid; /* vacuum cycle ID of latest split */
+ } BTPageOpaqueData;
+@@ -92,6 +94,14 @@ typedef BTPageOpaqueData *BTPageOpaque;
+ */
+ #define MAX_BT_CYCLE_ID 0xFF7F
+
++/* Macros for access xact */
++#define BTP_GET_XACT(opaque) (((uint64) ((BTPageOpaque) opaque)->btpo_prev << 32) | \
++ (uint64) ((BTPageOpaque) opaque)->btpo_level)
++#define BTP_SET_XACT(opaque, xact) \
++do { \
++ ((BTPageOpaque) opaque)->btpo_prev = (uint32) (xact >> 32); \
++ ((BTPageOpaque) opaque)->btpo_level = (uint32) xact; \
++} while (0)
+
+ /*
+ * The Meta page is always the first page in the btree index.
+diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h
+index 309c82ebf4d..bd709d26e8a 100644
+--- a/src/include/access/reloptions.h
++++ b/src/include/access/reloptions.h
+@@ -110,7 +110,7 @@ typedef struct relopt_int64
+ int64 default_val;
+ int64 min;
+ int64 max;
+-} relopt_int64;
++} relopt_int64;
+
+ typedef struct relopt_real
+ {
+diff --git a/src/include/access/rewriteheap.h b/src/include/access/rewriteheap.h
+index 5866a26bddd..e1dba997c2a 100644
+--- a/src/include/access/rewriteheap.h
++++ b/src/include/access/rewriteheap.h
+@@ -51,7 +51,7 @@ typedef struct LogicalRewriteMappingData
+ * 6) xid of the xact performing the mapping
+ * ---
+ */
+-#define LOGICAL_REWRITE_FORMAT "map-%x-%x-%X_%X-%x-%x"
+-extern void CheckPointLogicalRewriteHeap(void);
++#define LOGICAL_REWRITE_FORMAT "map-%x-%x-%X_%X-%x_%x-%x_%x"
++extern void CheckPointLogicalRewriteHeap(void);
+
+ #endif /* REWRITE_HEAP_H */
+diff --git a/src/include/access/rmgrlist.h b/src/include/access/rmgrlist.h
+index 78e6b908c6e..a368d384ffd 100644
+--- a/src/include/access/rmgrlist.h
++++ b/src/include/access/rmgrlist.h
+@@ -47,3 +47,4 @@ PG_RMGR(RM_COMMIT_TS_ID, "CommitTs", commit_ts_redo, commit_ts_desc, commit_ts_i
+ PG_RMGR(RM_REPLORIGIN_ID, "ReplicationOrigin", replorigin_redo, replorigin_desc, replorigin_identify, NULL, NULL, NULL, NULL)
+ PG_RMGR(RM_GENERIC_ID, "Generic", generic_redo, generic_desc, generic_identify, NULL, NULL, generic_mask, NULL)
+ PG_RMGR(RM_LOGICALMSG_ID, "LogicalMessage", logicalmsg_redo, logicalmsg_desc, logicalmsg_identify, NULL, NULL, NULL, logicalmsg_decode)
++PG_RMGR(RM_HEAP3_ID, "Heap3", heap3_redo, heap3_desc, heap3_identify, NULL, NULL, heap_mask, NULL)
+diff --git a/src/include/access/slru.h b/src/include/access/slru.h
+index 97e612cd100..c987e9e59a8 100644
+--- a/src/include/access/slru.h
++++ b/src/include/access/slru.h
+@@ -26,15 +26,7 @@
+ /*
+ * Define SLRU segment size. A page is the same BLCKSZ as is used everywhere
+ * else in Postgres. The segment size can be chosen somewhat arbitrarily;
+- * we make it 32 pages by default, or 256Kb, i.e. 1M transactions for CLOG
+- * or 64K transactions for SUBTRANS.
+- *
+- * Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF,
+- * page numbering also wraps around at 0xFFFFFFFF/xxxx_XACTS_PER_PAGE (where
+- * xxxx is CLOG or SUBTRANS, respectively), and segment numbering at
+- * 0xFFFFFFFF/xxxx_XACTS_PER_PAGE/SLRU_PAGES_PER_SEGMENT. We need
+- * take no explicit notice of that fact in slru.c, except when comparing
+- * segment and page numbers in SimpleLruTruncate (see PagePrecedes()).
++ * we make it 32 pages by default.
+ */
+ #define SLRU_PAGES_PER_SEGMENT 32
+
+diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
+index adb478a93ca..c31092e2fd0 100644
+--- a/src/include/access/tableam.h
++++ b/src/include/access/tableam.h
+@@ -141,7 +141,7 @@ typedef enum TU_UpdateIndexes
+ * cmax is the outdating command's CID, but only when the failure code is
+ * TM_SelfModified (i.e., something in the current transaction outdated the
+ * tuple); otherwise cmax is zero. (We make this restriction because
+- * HeapTupleHeaderGetCmax doesn't work for tuples outdated in other
++ * HeapTupleGetCmax doesn't work for tuples outdated in other
+ * transactions.)
+ */
+ typedef struct TM_FailureData
+diff --git a/src/include/access/transam.h b/src/include/access/transam.h
+index 28a2d287fd5..53d4a907365 100644
+--- a/src/include/access/transam.h
++++ b/src/include/access/transam.h
+@@ -17,6 +17,10 @@
+ #include "access/xlogdefs.h"
+
+
++#ifndef FRONTEND
++#include "utils/elog.h"
++#endif
++
+ /* ----------------
+ * Special transaction ID values
+ *
+@@ -28,11 +32,12 @@
+ * Note: if you need to change it, you must change pg_class.h as well.
+ * ----------------
+ */
+-#define InvalidTransactionId ((TransactionId) 0)
+-#define BootstrapTransactionId ((TransactionId) 1)
+-#define FrozenTransactionId ((TransactionId) 2)
+-#define FirstNormalTransactionId ((TransactionId) 3)
+-#define MaxTransactionId ((TransactionId) 0xFFFFFFFF)
++#define InvalidTransactionId UINT64CONST(0)
++#define BootstrapTransactionId UINT64CONST(1)
++#define FrozenTransactionId UINT64CONST(2)
++#define FirstNormalTransactionId UINT64CONST(3)
++#define MaxTransactionId UINT64CONST(0xFFFFFFFFFFFFFFFF)
++#define MaxShortTransactionId ((TransactionId) 0x7FFFFFFF)
+
+ /* ----------------
+ * transaction ID manipulation macros
+@@ -44,8 +49,40 @@
+ #define TransactionIdStore(xid, dest) (*(dest) = (xid))
+ #define StoreInvalidTransactionId(dest) (*(dest) = InvalidTransactionId)
+
+-#define EpochFromFullTransactionId(x) ((uint32) ((x).value >> 32))
+-#define XidFromFullTransactionId(x) ((uint32) (x).value)
++/*
++ * Convert short xid from/to full xid. Assertion should fail if we full xid
++ * doesn't fit to xid base.
++ */
++static inline TransactionId
++ShortTransactionIdToNormal(TransactionId base, ShortTransactionId xid)
++{
++ if (!TransactionIdIsNormal(xid))
++ return (TransactionId) xid;
++
++#ifndef FRONTEND
++ /* xid + base should not overflow TransactionId */
++ Assert(xid + base >= base);
++#endif
++
++ return (TransactionId) (xid + base);
++}
++
++static inline ShortTransactionId
++NormalTransactionIdToShort(TransactionId base, TransactionId xid)
++{
++ if (!TransactionIdIsNormal(xid))
++ return (ShortTransactionId) (xid);
++
++#ifndef FRONTEND
++ /* xid should fit ShortTransactionId */
++ Assert(xid >= base + FirstNormalTransactionId &&
++ xid <= base + MaxShortTransactionId);
++#endif
++
++ return (ShortTransactionId) (xid - base);
++}
++
++#define XidFromFullTransactionId(x) ((x).value)
+ #define U64FromFullTransactionId(x) ((x).value)
+ #define FullTransactionIdEquals(a, b) ((a).value == (b).value)
+ #define FullTransactionIdPrecedes(a, b) ((a).value < (b).value)
+@@ -53,8 +90,8 @@
+ #define FullTransactionIdFollows(a, b) ((a).value > (b).value)
+ #define FullTransactionIdFollowsOrEquals(a, b) ((a).value >= (b).value)
+ #define FullTransactionIdIsValid(x) TransactionIdIsValid(XidFromFullTransactionId(x))
+-#define InvalidFullTransactionId FullTransactionIdFromEpochAndXid(0, InvalidTransactionId)
+-#define FirstNormalFullTransactionId FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId)
++#define InvalidFullTransactionId FullTransactionIdFromXid(InvalidTransactionId)
++#define FirstNormalFullTransactionId FullTransactionIdFromXid(FirstNormalTransactionId)
+ #define FullTransactionIdIsNormal(x) FullTransactionIdFollowsOrEquals(x, FirstNormalFullTransactionId)
+
+ /*
+@@ -68,21 +105,11 @@ typedef struct FullTransactionId
+ } FullTransactionId;
+
+ static inline FullTransactionId
+-FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)
++FullTransactionIdFromXid(TransactionId xid)
+ {
+ FullTransactionId result;
+
+- result.value = ((uint64) epoch) << 32 | xid;
+-
+- return result;
+-}
+-
+-static inline FullTransactionId
+-FullTransactionIdFromU64(uint64 value)
+-{
+- FullTransactionId result;
+-
+- result.value = value;
++ result.value = xid;
+
+ return result;
+ }
+@@ -91,8 +118,7 @@ FullTransactionIdFromU64(uint64 value)
+ #define TransactionIdAdvance(dest) \
+ do { \
+ (dest)++; \
+- if ((dest) < FirstNormalTransactionId) \
+- (dest) = FirstNormalTransactionId; \
++ Assert(TransactionIdIsNormal(dest)); \
+ } while(0)
+
+ /*
+@@ -140,18 +166,19 @@ FullTransactionIdAdvance(FullTransactionId *dest)
+ /* back up a transaction ID variable, handling wraparound correctly */
+ #define TransactionIdRetreat(dest) \
+ do { \
++ Assert(TransactionIdIsNormal(dest)); \
+ (dest)--; \
+- } while ((dest) < FirstNormalTransactionId)
++ } while(0)
+
+ /* compare two XIDs already known to be normal; this is a macro for speed */
+ #define NormalTransactionIdPrecedes(id1, id2) \
+ (AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
+- (int32) ((id1) - (id2)) < 0)
++ (int64) ((id1) - (id2)) < 0)
+
+ /* compare two XIDs already known to be normal; this is a macro for speed */
+ #define NormalTransactionIdFollows(id1, id2) \
+ (AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
+- (int32) ((id1) - (id2)) > 0)
++ (int64) ((id1) - (id2)) > 0)
+
+ /* ----------
+ * Object ID (OID) zero is InvalidOid.
+@@ -201,10 +228,6 @@ FullTransactionIdAdvance(FullTransactionId *dest)
+ * OID and XID assignment state. For largely historical reasons, there is
+ * just one struct with different fields that are protected by different
+ * LWLocks.
+- *
+- * Note: xidWrapLimit and oldestXidDB are not "active" values, but are
+- * used just to generate useful messages when xidWarnLimit or xidStopLimit
+- * are exceeded.
+ */
+ typedef struct TransamVariablesData
+ {
+@@ -221,9 +244,6 @@ typedef struct TransamVariablesData
+
+ TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
+ TransactionId xidVacLimit; /* start forcing autovacuums here */
+- TransactionId xidWarnLimit; /* start complaining here */
+- TransactionId xidStopLimit; /* refuse to advance nextXid beyond here */
+- TransactionId xidWrapLimit; /* where the world ends */
+ Oid oldestXidDB; /* database with minimum datfrozenxid */
+
+ /*
+@@ -274,10 +294,6 @@ extern bool TransactionIdDidAbort(TransactionId transactionId);
+ extern void TransactionIdCommitTree(TransactionId xid, int nxids, TransactionId *xids);
+ extern void TransactionIdAsyncCommitTree(TransactionId xid, int nxids, TransactionId *xids, XLogRecPtr lsn);
+ extern void TransactionIdAbortTree(TransactionId xid, int nxids, TransactionId *xids);
+-extern bool TransactionIdPrecedes(TransactionId id1, TransactionId id2);
+-extern bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2);
+-extern bool TransactionIdFollows(TransactionId id1, TransactionId id2);
+-extern bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2);
+ extern TransactionId TransactionIdLatest(TransactionId mainxid,
+ int nxids, const TransactionId *xids);
+ extern XLogRecPtr TransactionIdGetCommitLSN(TransactionId xid);
+@@ -319,7 +335,7 @@ ReadNextTransactionId(void)
+
+ /* return transaction ID backed up by amount, handling wraparound correctly */
+ static inline TransactionId
+-TransactionIdRetreatedBy(TransactionId xid, uint32 amount)
++TransactionIdRetreatedBy(TransactionId xid, uint64 amount)
+ {
+ xid -= amount;
+
+diff --git a/src/include/access/tupmacs.h b/src/include/access/tupmacs.h
+index 58b3a58cfd0..a2af9d5e855 100644
+--- a/src/include/access/tupmacs.h
++++ b/src/include/access/tupmacs.h
+@@ -131,10 +131,11 @@ fetch_att(const void *T, bool attbyval, int attlen)
+ ((attalign) == TYPALIGN_INT) ? INTALIGN(cur_offset) : \
+ (((attalign) == TYPALIGN_CHAR) ? (uintptr_t) (cur_offset) : \
+ (((attalign) == TYPALIGN_DOUBLE) ? DOUBLEALIGN(cur_offset) : \
++ (((attalign) == TYPALIGN_XID) ? MAXALIGN(cur_offset) : \
+ ( \
+ AssertMacro((attalign) == TYPALIGN_SHORT), \
+ SHORTALIGN(cur_offset) \
+- ))) \
++ )))) \
+ )
+
+ /*
+diff --git a/src/include/access/xact.h b/src/include/access/xact.h
+index fb64d7413a2..fa93b167ae7 100644
+--- a/src/include/access/xact.h
++++ b/src/include/access/xact.h
+@@ -249,7 +249,7 @@ typedef struct xl_xact_xinfo
+ * Commit records can be large, so copying large portions isn't
+ * attractive.
+ */
+- uint32 xinfo;
++ uint64 xinfo;
+ } xl_xact_xinfo;
+
+ typedef struct xl_xact_dbinfo
+@@ -308,7 +308,12 @@ typedef struct xl_xact_invals
+
+ typedef struct xl_xact_twophase
+ {
+- TransactionId xid;
++ /*
++ * TransactionId is split into 32-bit parts because xl_xact_twophase is
++ * only int-aligned.
++ */
++ uint32 xid_lo;
++ uint32 xid_hi;
+ } xl_xact_twophase;
+
+ typedef struct xl_xact_origin
+@@ -327,7 +332,7 @@ typedef struct xl_xact_commit
+ /* xl_xact_relfilelocators follows if XINFO_HAS_RELFILELOCATORS */
+ /* xl_xact_stats_items follows if XINFO_HAS_DROPPED_STATS */
+ /* xl_xact_invals follows if XINFO_HAS_INVALS */
+- /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE */
++ /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE (xid is int-aligned!) */
+ /* twophase_gid follows if XINFO_HAS_GID. As a null-terminated string. */
+ /* xl_xact_origin follows if XINFO_HAS_ORIGIN, stored unaligned! */
+ } xl_xact_commit;
+@@ -343,7 +348,7 @@ typedef struct xl_xact_abort
+ /* xl_xact_relfilelocators follows if XINFO_HAS_RELFILELOCATORS */
+ /* xl_xact_stats_items follows if XINFO_HAS_DROPPED_STATS */
+ /* No invalidation messages needed. */
+- /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE */
++ /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE (xid is int-aligned!) */
+ /* twophase_gid follows if XINFO_HAS_GID. As a null-terminated string. */
+ /* xl_xact_origin follows if XINFO_HAS_ORIGIN, stored unaligned! */
+ } xl_xact_abort;
+diff --git a/src/include/access/xloginsert.h b/src/include/access/xloginsert.h
+index 652f7bc9bd1..51356879fed 100644
+--- a/src/include/access/xloginsert.h
++++ b/src/include/access/xloginsert.h
+@@ -38,6 +38,7 @@
+ #define REGBUF_KEEP_DATA 0x10 /* include data even if a full-page image
+ * is taken */
+ #define REGBUF_NO_CHANGE 0x20 /* intentionally register clean buffer */
++#define REGBUF_CONVERTED 0x40 /* buffer had format convertion */
+
+ /* prototypes for public functions in xloginsert.c: */
+ extern void XLogBeginInsert(void);
+diff --git a/src/include/access/xlogreader.h b/src/include/access/xlogreader.h
+index b4fa1ef7b5a..81cd5f33ea0 100644
+--- a/src/include/access/xlogreader.h
++++ b/src/include/access/xlogreader.h
+@@ -427,10 +427,6 @@ extern bool DecodeXLogRecord(XLogReaderState *state,
+ #define XLogRecHasBlockData(decoder, block_id) \
+ ((decoder)->record->blocks[block_id].has_data)
+
+-#ifndef FRONTEND
+-extern FullTransactionId XLogRecGetFullXid(XLogReaderState *record);
+-#endif
+-
+ extern bool RestoreBlockImage(XLogReaderState *record, uint8 block_id, char *page);
+ extern char *XLogRecGetBlockData(XLogReaderState *record, uint8 block_id, Size *len);
+ extern void XLogRecGetBlockTag(XLogReaderState *record, uint8 block_id,
+diff --git a/src/include/access/xlogrecord.h b/src/include/access/xlogrecord.h
+index b9e5c59fae3..3a74c9085ae 100644
+--- a/src/include/access/xlogrecord.h
++++ b/src/include/access/xlogrecord.h
+@@ -41,18 +41,17 @@
+ typedef struct XLogRecord
+ {
+ uint32 xl_tot_len; /* total len of entire record */
++ pg_crc32c xl_crc; /* CRC for this record */
+ TransactionId xl_xid; /* xact id */
+ XLogRecPtr xl_prev; /* ptr to previous record in log */
+ uint8 xl_info; /* flag bits, see below */
+ RmgrId xl_rmid; /* resource manager for this record */
+- /* 2 bytes of padding here, initialize to zero */
+- pg_crc32c xl_crc; /* CRC for this record */
+
+ /* XLogRecordBlockHeaders and XLogRecordDataHeader follow, no padding */
+
+ } XLogRecord;
+
+-#define SizeOfXLogRecord (offsetof(XLogRecord, xl_crc) + sizeof(pg_crc32c))
++#define SizeOfXLogRecord (offsetof(XLogRecord, xl_rmid) + sizeof(RmgrId))
+
+ /*
+ * The high 4 bits in xl_info may be used freely by rmgr. The
+diff --git a/src/include/c.h b/src/include/c.h
+index d8dfefb5654..b4289d668be 100644
+--- a/src/include/c.h
++++ b/src/include/c.h
+@@ -597,20 +597,30 @@ typedef double float8;
+ typedef Oid regproc;
+ typedef regproc RegProcedure;
+
+-typedef uint32 TransactionId;
++typedef uint64 TransactionId;
+
+-typedef uint32 LocalTransactionId;
++extern bool TransactionIdPrecedes(TransactionId id1, TransactionId id2);
++extern bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2);
++extern bool TransactionIdFollows(TransactionId id1, TransactionId id2);
++extern bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2);
+
+-typedef uint32 SubTransactionId;
++typedef uint32 ShortTransactionId;
++typedef uint64 LocalTransactionId;
++typedef uint64 SubTransactionId;
+
+-#define InvalidSubTransactionId ((SubTransactionId) 0)
+-#define TopSubTransactionId ((SubTransactionId) 1)
++#define InvalidSubTransactionId ((SubTransactionId) 0)
++#define TopSubTransactionId ((SubTransactionId) 1)
+
+ /* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
+ typedef TransactionId MultiXactId;
+
+ typedef uint64 MultiXactOffset;
+
++#define MAX_START_XID UINT64CONST(0x3FFFFFFFFFFFFFFF) /* 2^62 - 1 */
++#define StartTransactionIdIsValid(xid) ((xid) <= MAX_START_XID)
++#define StartMultiXactIdIsValid(mxid) ((mxid) <= MAX_START_XID)
++#define StartMultiXactOffsetIsValid(mxoff) ((mxoff) <= MAX_START_XID)
++
+ typedef uint32 CommandId;
+
+ #define FirstCommandId ((CommandId) 0)
+@@ -783,7 +793,6 @@ typedef NameData *Name;
+ /* we don't currently need wider versions of the other ALIGN macros */
+ #define MAXALIGN64(LEN) TYPEALIGN64(MAXIMUM_ALIGNOF, (LEN))
+
+-
+ /* ----------------------------------------------------------------
+ * Section 6: assertions
+ * ----------------------------------------------------------------
+diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h
+index 3ca5dbf9e83..53b72224292 100644
+--- a/src/include/catalog/catversion.h
++++ b/src/include/catalog/catversion.h
+@@ -57,6 +57,7 @@
+ */
+
+ /* yyyymmddN */
+-#define CATALOG_VERSION_NO 202412021
++/* XXX: should de changed to actual version on commit */
++#define CATALOG_VERSION_NO 999999999
+
+ #endif
+diff --git a/src/include/catalog/pg_operator.dat b/src/include/catalog/pg_operator.dat
+index 0e7511dde1c..d26405a7b5c 100644
+--- a/src/include/catalog/pg_operator.dat
++++ b/src/include/catalog/pg_operator.dat
+@@ -183,16 +183,16 @@
+ oprresult => 'bool', oprcom => '=(xid,xid)', oprnegate => '<>(xid,xid)',
+ oprcode => 'xideq', oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+ { oid => '353', descr => 'equal',
+- oprname => '=', oprleft => 'xid', oprright => 'int4', oprresult => 'bool',
+- oprnegate => '<>(xid,int4)', oprcode => 'xideqint4', oprrest => 'eqsel',
++ oprname => '=', oprleft => 'xid', oprright => 'int8', oprresult => 'bool',
++ oprnegate => '<>(xid,int8)', oprcode => 'xideqint8', oprrest => 'eqsel',
+ oprjoin => 'eqjoinsel' },
+ { oid => '3315', descr => 'not equal',
+ oprname => '<>', oprleft => 'xid', oprright => 'xid', oprresult => 'bool',
+ oprcom => '<>(xid,xid)', oprnegate => '=(xid,xid)', oprcode => 'xidneq',
+ oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+ { oid => '3316', descr => 'not equal',
+- oprname => '<>', oprleft => 'xid', oprright => 'int4', oprresult => 'bool',
+- oprnegate => '=(xid,int4)', oprcode => 'xidneqint4', oprrest => 'neqsel',
++ oprname => '<>', oprleft => 'xid', oprright => 'int8', oprresult => 'bool',
++ oprnegate => '=(xid,int8)', oprcode => 'xidneqint8', oprrest => 'neqsel',
+ oprjoin => 'neqjoinsel' },
+ { oid => '5068', descr => 'equal',
+ oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'xid8',
+diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
+index 9575524007f..027abc3213b 100644
+--- a/src/include/catalog/pg_proc.dat
++++ b/src/include/catalog/pg_proc.dat
+@@ -2443,10 +2443,10 @@
+ { oid => '1181',
+ descr => 'age of a transaction ID, in transactions before current transaction',
+ proname => 'age', provolatile => 's', proparallel => 'r',
+- prorettype => 'int4', proargtypes => 'xid', prosrc => 'xid_age' },
++ prorettype => 'int8', proargtypes => 'xid', prosrc => 'xid_age' },
+ { oid => '3939',
+ descr => 'age of a multi-transaction ID, in multi-transactions before current multi-transaction',
+- proname => 'mxid_age', provolatile => 's', prorettype => 'int4',
++ proname => 'mxid_age', provolatile => 's', prorettype => 'int8',
+ proargtypes => 'xid', prosrc => 'mxid_age' },
+
+ { oid => '1188',
+@@ -2797,11 +2797,11 @@
+ prosrc => 'bpcharlen' },
+
+ { oid => '1319',
+- proname => 'xideqint4', proleakproof => 't', prorettype => 'bool',
+- proargtypes => 'xid int4', prosrc => 'xideq' },
++ proname => 'xideqint8', proleakproof => 't', prorettype => 'bool',
++ proargtypes => 'xid int8', prosrc => 'xideq' },
+ { oid => '3309',
+- proname => 'xidneqint4', proleakproof => 't', prorettype => 'bool',
+- proargtypes => 'xid int4', prosrc => 'xidneq' },
++ proname => 'xidneqint8', proleakproof => 't', prorettype => 'bool',
++ proargtypes => 'xid int8', prosrc => 'xidneq' },
+
+ { oid => '1326',
+ proname => 'interval_div', prorettype => 'interval',
+diff --git a/src/include/catalog/pg_type.dat b/src/include/catalog/pg_type.dat
+index ceff66ccde1..f8d98c8c85c 100644
+--- a/src/include/catalog/pg_type.dat
++++ b/src/include/catalog/pg_type.dat
+@@ -95,9 +95,9 @@
+ typinput => 'tidin', typoutput => 'tidout', typreceive => 'tidrecv',
+ typsend => 'tidsend', typalign => 's' },
+ { oid => '28', array_type_oid => '1011', descr => 'transaction id',
+- typname => 'xid', typlen => '4', typbyval => 't', typcategory => 'U',
++ typname => 'xid', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typcategory => 'U',
+ typinput => 'xidin', typoutput => 'xidout', typreceive => 'xidrecv',
+- typsend => 'xidsend', typalign => 'i' },
++ typsend => 'xidsend', typalign => 'x' },
+ { oid => '29', array_type_oid => '1012',
+ descr => 'command identifier type, sequence in transaction id',
+ typname => 'cid', typlen => '4', typbyval => 't', typcategory => 'U',
+diff --git a/src/include/catalog/pg_type.h b/src/include/catalog/pg_type.h
+index e9259697321..edd8f13bd15 100644
+--- a/src/include/catalog/pg_type.h
++++ b/src/include/catalog/pg_type.h
+@@ -303,6 +303,11 @@ MAKE_SYSCACHE(TYPENAMENSP, pg_type_typname_nsp_index, 64);
+ #define TYPALIGN_SHORT 's' /* short alignment (typically 2 bytes) */
+ #define TYPALIGN_INT 'i' /* int alignment (typically 4 bytes) */
+ #define TYPALIGN_DOUBLE 'd' /* double alignment (often 8 bytes) */
++/*
++ * We need to use alignment sutable for 8-byte XID values.
++ * On system like AIX double alignment (4 bytes) is not enough.
++ */
++#define TYPALIGN_XID 'x'
+
+ #define TYPSTORAGE_PLAIN 'p' /* type not prepared for toasting */
+ #define TYPSTORAGE_EXTERNAL 'e' /* toastable, don't try to compress */
+diff --git a/src/include/commands/vacuum.h b/src/include/commands/vacuum.h
+index 759f9a87d38..a96bdf0cc04 100644
+--- a/src/include/commands/vacuum.h
++++ b/src/include/commands/vacuum.h
+@@ -216,12 +216,12 @@ typedef enum VacOptValue
+ */
+ typedef struct VacuumParams
+ {
+- bits32 options; /* bitmask of VACOPT_* */
+- int freeze_min_age; /* min freeze age, -1 to use default */
+- int freeze_table_age; /* age at which to scan whole table */
+- int multixact_freeze_min_age; /* min multixact freeze age, -1 to
++ bits32 options; /* bitmask of VacuumOption */
++ int64 freeze_min_age; /* min freeze age, -1 to use default */
++ int64 freeze_table_age; /* age at which to scan whole table */
++ int64 multixact_freeze_min_age; /* min multixact freeze age, -1 to
+ * use default */
+- int multixact_freeze_table_age; /* multixact age at which to scan
++ int64 multixact_freeze_table_age; /* multixact age at which to scan
+ * whole table */
+ bool is_wraparound; /* force a for-wraparound vacuum */
+ int log_min_duration; /* minimum execution threshold in ms at
+@@ -290,12 +290,12 @@ typedef struct VacDeadItemsInfo
+
+ /* GUC parameters */
+ extern PGDLLIMPORT int default_statistics_target; /* PGDLLIMPORT for PostGIS */
+-extern PGDLLIMPORT int vacuum_freeze_min_age;
+-extern PGDLLIMPORT int vacuum_freeze_table_age;
+-extern PGDLLIMPORT int vacuum_multixact_freeze_min_age;
+-extern PGDLLIMPORT int vacuum_multixact_freeze_table_age;
+-extern PGDLLIMPORT int vacuum_failsafe_age;
+-extern PGDLLIMPORT int vacuum_multixact_failsafe_age;
++extern PGDLLIMPORT int64 vacuum_freeze_min_age;
++extern PGDLLIMPORT int64 vacuum_freeze_table_age;
++extern PGDLLIMPORT int64 vacuum_multixact_freeze_min_age;
++extern PGDLLIMPORT int64 vacuum_multixact_freeze_table_age;
++extern PGDLLIMPORT int64 vacuum_failsafe_age;
++extern PGDLLIMPORT int64 vacuum_multixact_failsafe_age;
+
+ /*
+ * Maximum value for default_statistics_target and per-column statistics
+diff --git a/src/include/fmgr.h b/src/include/fmgr.h
+index 1e3795de4a8..206d16b36bf 100644
+--- a/src/include/fmgr.h
++++ b/src/include/fmgr.h
+@@ -281,6 +281,7 @@ extern struct varlena *pg_detoast_datum_packed(struct varlena *datum);
+ #define PG_GETARG_FLOAT4(n) DatumGetFloat4(PG_GETARG_DATUM(n))
+ #define PG_GETARG_FLOAT8(n) DatumGetFloat8(PG_GETARG_DATUM(n))
+ #define PG_GETARG_INT64(n) DatumGetInt64(PG_GETARG_DATUM(n))
++#define PG_GETARG_TRANSACTIONID(n) DatumGetTransactionId(PG_GETARG_DATUM(n))
+ /* use this if you want the raw, possibly-toasted input datum: */
+ #define PG_GETARG_RAW_VARLENA_P(n) ((struct varlena *) PG_GETARG_POINTER(n))
+ /* use this if you want the input datum de-toasted: */
+@@ -367,6 +368,7 @@ extern struct varlena *pg_detoast_datum_packed(struct varlena *datum);
+ #define PG_RETURN_FLOAT8(x) return Float8GetDatum(x)
+ #define PG_RETURN_INT64(x) return Int64GetDatum(x)
+ #define PG_RETURN_UINT64(x) return UInt64GetDatum(x)
++#define PG_RETURN_TRANSACTIONID(x) return TransactionIdGetDatum(x)
+ /* RETURN macros for other pass-by-ref types will typically look like this: */
+ #define PG_RETURN_BYTEA_P(x) PG_RETURN_POINTER(x)
+ #define PG_RETURN_TEXT_P(x) PG_RETURN_POINTER(x)
+diff --git a/src/include/nodes/pg_list.h b/src/include/nodes/pg_list.h
+index d131350e107..9382e655ef9 100644
+--- a/src/include/nodes/pg_list.h
++++ b/src/include/nodes/pg_list.h
+@@ -46,6 +46,7 @@ typedef union ListCell
+ {
+ void *ptr_value;
+ int int_value;
++ int64 int64_value;
+ Oid oid_value;
+ TransactionId xid_value;
+ } ListCell;
+@@ -171,6 +172,7 @@ list_length(const List *l)
+ */
+ #define lfirst(lc) ((lc)->ptr_value)
+ #define lfirst_int(lc) ((lc)->int_value)
++#define lfirst_int64(lc) ((lc)->int64_value)
+ #define lfirst_oid(lc) ((lc)->oid_value)
+ #define lfirst_xid(lc) ((lc)->xid_value)
+ #define lfirst_node(type,lc) castNode(type, lfirst(lc))
+@@ -197,6 +199,7 @@ list_length(const List *l)
+
+ #define llast(l) lfirst(list_last_cell(l))
+ #define llast_int(l) lfirst_int(list_last_cell(l))
++#define llast_int64(l) lfirst_int64(list_last_cell(l))
+ #define llast_oid(l) lfirst_oid(list_last_cell(l))
+ #define llast_xid(l) lfirst_xid(list_last_cell(l))
+ #define llast_node(type,l) castNode(type, llast(l))
+@@ -610,6 +613,7 @@ extern List *list_make5_impl(NodeTag t, ListCell datum1, ListCell datum2,
+
+ extern pg_nodiscard List *lappend(List *list, void *datum);
+ extern pg_nodiscard List *lappend_int(List *list, int datum);
++extern pg_nodiscard List *lappend_int64(List *list, int64 datum);
+ extern pg_nodiscard List *lappend_oid(List *list, Oid datum);
+ extern pg_nodiscard List *lappend_xid(List *list, TransactionId datum);
+
+diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in
+index 07b2f798abd..8d94228ac52 100644
+--- a/src/include/pg_config.h.in
++++ b/src/include/pg_config.h.in
+@@ -730,6 +730,9 @@
+ # endif
+ #endif
+
++/* Postgres Pro use 64bit xids */
++#undef XID_IS_64BIT
++
+ /* Size of a WAL file block. This need have no particular relation to BLCKSZ.
+ XLOG_BLCKSZ must be a power of 2, and if your system supports O_DIRECT I/O,
+ XLOG_BLCKSZ must be a multiple of the alignment requirement for direct-I/O
+diff --git a/src/include/port/pg_lfind.h b/src/include/port/pg_lfind.h
+index 4b1431ed002..a77c0cdcb22 100644
+--- a/src/include/port/pg_lfind.h
++++ b/src/include/port/pg_lfind.h
+@@ -206,4 +206,66 @@ pg_lfind32(uint32 key, const uint32 *base, uint32 nelem)
+ #endif
+ }
+
++/*
++ * pg_lfind64
++ *
++ * Return true if there is an element in 'base' that equals 'key', otherwise
++ * return false.
++ */
++static inline bool
++pg_lfind64(uint64 key, uint64 *base, uint32 nelem)
++{
++ uint32 i,
++ iterations;
++#if defined(USE_ASSERT_CHECKING)
++ bool assert_result = false;
++
++ /* pre-compute the result for assert checking */
++ for (i = 0; i < nelem; ++i)
++ {
++ if (key == base[i])
++ {
++ assert_result = true;
++ break;
++ }
++ }
++#endif
++
++#define UNROLL_FACTOR 8
++ StaticAssertStmt((UNROLL_FACTOR & (UNROLL_FACTOR - 1)) == 0,
++ "Loop unroll factor must be power of 2");
++ iterations = nelem & ~(UNROLL_FACTOR - 1);
++ for (i = 0; i < iterations; i += UNROLL_FACTOR)
++ {
++ if (base[0] == key || base[1] == key || base[2] == key ||
++ base[3] == key || base[4] == key || base[5] == key ||
++ base[6] == key || base[7] == key)
++ {
++#if defined(USE_ASSERT_CHECKING)
++ Assert(assert_result == true);
++#endif
++ return true;
++ }
++ base += UNROLL_FACTOR;
++ }
++
++ /* Process the remaining elements one at a time. */
++ iterations = nelem & (UNROLL_FACTOR - 1);
++ for (i = 0; i < iterations; ++i)
++ {
++ if (key == *base++)
++ {
++#if defined(USE_ASSERT_CHECKING)
++ Assert(assert_result == true);
++#endif
++ return true;
++ }
++ }
++
++#if defined(USE_ASSERT_CHECKING)
++ Assert(assert_result == false);
++#endif
++ return false;
++}
++
+ #endif /* PG_LFIND_H */
+diff --git a/src/include/postgres.h b/src/include/postgres.h
+index 5d5fd7813e8..79187d93e88 100644
+--- a/src/include/postgres.h
++++ b/src/include/postgres.h
+@@ -80,6 +80,9 @@ typedef struct NullableDatum
+
+ #define SIZEOF_DATUM SIZEOF_VOID_P
+
++static uint64 DatumGetUInt64(Datum X);
++static Datum UInt64GetDatum(uint64 X);
++
+ /*
+ * DatumGetBool
+ * Returns boolean value of a datum.
+@@ -261,7 +264,7 @@ ObjectIdGetDatum(Oid X)
+ static inline TransactionId
+ DatumGetTransactionId(Datum X)
+ {
+- return (TransactionId) X;
++ return DatumGetUInt64(X);
+ }
+
+ /*
+@@ -271,7 +274,7 @@ DatumGetTransactionId(Datum X)
+ static inline Datum
+ TransactionIdGetDatum(TransactionId X)
+ {
+- return (Datum) X;
++ return UInt64GetDatum(X);
+ }
+
+ /*
+@@ -281,7 +284,7 @@ TransactionIdGetDatum(TransactionId X)
+ static inline Datum
+ MultiXactIdGetDatum(MultiXactId X)
+ {
+- return (Datum) X;
++ return UInt64GetDatum(X);
+ }
+
+ /*
+diff --git a/src/include/postmaster/autovacuum.h b/src/include/postmaster/autovacuum.h
+index cae1e8b3294..e53bbac3be4 100644
+--- a/src/include/postmaster/autovacuum.h
++++ b/src/include/postmaster/autovacuum.h
+@@ -37,8 +37,8 @@ extern PGDLLIMPORT int autovacuum_vac_ins_thresh;
+ extern PGDLLIMPORT double autovacuum_vac_ins_scale;
+ extern PGDLLIMPORT int autovacuum_anl_thresh;
+ extern PGDLLIMPORT double autovacuum_anl_scale;
+-extern PGDLLIMPORT int autovacuum_freeze_max_age;
+-extern PGDLLIMPORT int autovacuum_multixact_freeze_max_age;
++extern PGDLLIMPORT int64 autovacuum_freeze_max_age;
++extern PGDLLIMPORT int64 autovacuum_multixact_freeze_max_age;
+ extern PGDLLIMPORT double autovacuum_vac_cost_delay;
+ extern PGDLLIMPORT int autovacuum_vac_cost_limit;
+
+diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
+index eda6c699212..ce812043388 100644
+--- a/src/include/storage/buf_internals.h
++++ b/src/include/storage/buf_internals.h
+@@ -41,10 +41,10 @@
+ */
+ #define BUF_REFCOUNT_ONE 1
+ #define BUF_REFCOUNT_MASK ((1U << 18) - 1)
+-#define BUF_USAGECOUNT_MASK 0x003C0000U
++#define BUF_USAGECOUNT_MASK 0x001C0000U
+ #define BUF_USAGECOUNT_ONE (1U << 18)
+ #define BUF_USAGECOUNT_SHIFT 18
+-#define BUF_FLAG_MASK 0xFFC00000U
++#define BUF_FLAG_MASK 0xFFE00000U
+
+ /* Get refcount and usagecount from buffer state */
+ #define BUF_STATE_GET_REFCOUNT(state) ((state) & BUF_REFCOUNT_MASK)
+@@ -56,6 +56,7 @@
+ * Note: BM_TAG_VALID essentially means that there is a buffer hashtable
+ * entry associated with the buffer's tag.
+ */
++#define BM_CONVERTED (1U << 21) /* buffer were converted to 64xid */
+ #define BM_LOCKED (1U << 22) /* buffer header is locked */
+ #define BM_DIRTY (1U << 23) /* data needs writing */
+ #define BM_VALID (1U << 24) /* data is valid */
+diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
+index eb0fba4230b..9db300e509c 100644
+--- a/src/include/storage/bufmgr.h
++++ b/src/include/storage/bufmgr.h
+@@ -283,8 +283,12 @@ extern void BufferGetTag(Buffer buffer, RelFileLocator *rlocator,
+ ForkNumber *forknum, BlockNumber *blknum);
+
+ extern void MarkBufferDirtyHint(Buffer buffer, bool buffer_std);
++extern void MarkBufferConverted(Buffer buffer, bool converted);
++extern bool IsBufferConverted(Buffer buffer);
+
+ extern void UnlockBuffers(void);
++extern bool IsBufferLocked(Buffer buffer);
++extern bool IsBufferLockedExclusive(Buffer buffer);
+ extern void LockBuffer(Buffer buffer, int mode);
+ extern bool ConditionalLockBuffer(Buffer buffer);
+ extern void LockBufferForCleanup(Buffer buffer);
+@@ -316,6 +320,8 @@ extern int GetAccessStrategyPinLimit(BufferAccessStrategy strategy);
+
+ extern void FreeAccessStrategy(BufferAccessStrategy strategy);
+
++/* old tuple format support */
++extern void convert_page(Relation rel, Page orig_page, Buffer buf, BlockNumber blkno);
+
+ /* inline functions */
+
+diff --git a/src/include/storage/bufpage.h b/src/include/storage/bufpage.h
+index 6222d46e535..1c7345c1d09 100644
+--- a/src/include/storage/bufpage.h
++++ b/src/include/storage/bufpage.h
+@@ -14,10 +14,13 @@
+ #ifndef BUFPAGE_H
+ #define BUFPAGE_H
+
++#include "access/transam.h"
+ #include "access/xlogdefs.h"
+ #include "storage/block.h"
+ #include "storage/item.h"
+ #include "storage/off.h"
++#include "postgres.h"
++#include "utils/rel.h"
+
+ /* GUC variable */
+ extern PGDLLIMPORT bool ignore_checksum_failure;
+@@ -166,12 +169,41 @@ typedef struct PageHeaderData
+ LocationIndex pd_upper; /* offset to end of free space */
+ LocationIndex pd_special; /* offset to start of special space */
+ uint16 pd_pagesize_version;
+- TransactionId pd_prune_xid; /* oldest prunable XID, or zero if none */
++ ShortTransactionId pd_prune_xid; /* oldest prunable XID, or zero if
++ * none */
+ ItemIdData pd_linp[FLEXIBLE_ARRAY_MEMBER]; /* line pointer array */
+ } PageHeaderData;
+
+ typedef PageHeaderData *PageHeader;
+
++
++/*
++ * HeapPageSpecialData -- data that stored at the end of each heap page.
++ *
++ * pd_xid_base - base value for transaction IDs on page
++ * pd_multi_base - base value for multixact IDs on page
++ *
++ * pd_xid_base and pd_multi_base are base values for calculation of transaction
++ * identifiers from t_xmin and t_xmax in each heap tuple header on the page.
++ */
++typedef struct HeapPageSpecialData
++{
++ TransactionId pd_xid_base; /* base value for transaction IDs on page */
++ TransactionId pd_multi_base; /* base value for multixact IDs on page */
++} HeapPageSpecialData;
++
++typedef HeapPageSpecialData *HeapPageSpecial;
++
++typedef struct ToastPageSpecialData
++{
++ TransactionId pd_xid_base; /* base value for transaction IDs on page */
++} ToastPageSpecialData;
++
++typedef ToastPageSpecialData *ToastPageSpecial;
++
++extern PGDLLIMPORT HeapPageSpecial heapDoubleXmaxSpecial;
++extern PGDLLIMPORT ToastPageSpecial toastDoubleXmaxSpecial;
++
+ /*
+ * pd_flags contains the following flag bits. Undefined bits are initialized
+ * to zero and may be used in the future.
+@@ -203,7 +235,7 @@ typedef PageHeaderData *PageHeader;
+ * As of Release 9.3, the checksum version must also be considered when
+ * handling pages.
+ */
+-#define PG_PAGE_LAYOUT_VERSION 4
++#define PG_PAGE_LAYOUT_VERSION 5
+ #define PG_DATA_CHECKSUM_VERSION 1
+
+ /* ----------------------------------------------------------------
+@@ -443,18 +475,177 @@ PageClearAllVisible(Page page)
+ }
+
+ /*
+- * These two require "access/transam.h", so left as macros.
++ * Check if page is in "double xmax" format.
+ */
+-#define PageSetPrunable(page, xid) \
+-do { \
+- Assert(TransactionIdIsNormal(xid)); \
+- if (!TransactionIdIsValid(((PageHeader) (page))->pd_prune_xid) || \
+- TransactionIdPrecedes(xid, ((PageHeader) (page))->pd_prune_xid)) \
+- ((PageHeader) (page))->pd_prune_xid = (xid); \
+-} while (0)
+-#define PageClearPrunable(page) \
+- (((PageHeader) (page))->pd_prune_xid = InvalidTransactionId)
++static inline bool
++HeapPageIsDoubleXmax(Page page)
++{
++ return ((PageHeader) (page))->pd_special == BLCKSZ;
++}
+
++/*
++ * Get pointer to HeapPageSpecialData.
++ *
++ * Can be used for non-consistent reads from non-locked pages.
++ *
++ * Return doubleXmaxSpecial when pd_special == BLCKSZ (i.e. "double xmax"
++ * format).
++ */
++static inline HeapPageSpecial
++HeapPageGetSpecialNoAssert(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return heapDoubleXmaxSpecial;
++
++ return (HeapPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Get pointer to ToastPageSpecialData.
++ *
++ * Can be used for non-consistent reads from non-locked pages.
++ *
++ * Return doubleXmaxSpecial when pd_special == BLCKSZ (i.e. "double xmax"
++ * format).
++ */
++static inline ToastPageSpecial
++ToastPageGetSpecialNoAssert(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return toastDoubleXmaxSpecial;
++
++ return (ToastPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Wrapper for HeapPageGetSpecialNoAssert for general use.
++ */
++static inline HeapPageSpecial
++HeapPageGetSpecial(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return heapDoubleXmaxSpecial;
++
++ Assert(((PageHeader) page)->pd_special ==
++ BLCKSZ - MAXALIGN(sizeof(HeapPageSpecialData)));
++
++ return (HeapPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Wrapper for ToastPageGetSpecialNoAssert for general use.
++ */
++static inline ToastPageSpecial
++ToastPageGetSpecial(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return toastDoubleXmaxSpecial;
++
++ Assert(((PageHeader) page)->pd_special ==
++ BLCKSZ - MAXALIGN(sizeof(ToastPageSpecialData)));
++
++ return (ToastPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Set pd_prune_xid.
++ */
++static inline void
++HeapPageSetPruneXid(Page page, TransactionId xid, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return;
++
++ if (!TransactionIdIsNormal(xid))
++ {
++ ((PageHeader) (page))->pd_prune_xid = xid;
++ return;
++ }
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ ((PageHeader) (page))->pd_prune_xid = NormalTransactionIdToShort(base, xid);
++ Assert(((PageHeader) (page))->pd_prune_xid <= MaxShortTransactionId);
++}
++
++static inline void
++ToastPageSetPruneXid(Page page, TransactionId xid)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return;
++
++ if (!TransactionIdIsNormal(xid))
++ {
++ ((PageHeader) (page))->pd_prune_xid = xid;
++ return;
++ }
++
++ ((PageHeader) (page))->pd_prune_xid =
++ NormalTransactionIdToShort(ToastPageGetSpecial(page)->pd_xid_base, (xid));
++
++ Assert(((PageHeader) (page))->pd_prune_xid <= MaxShortTransactionId);
++}
++
++/*
++ * Get pd_prune_xid from locked page.
++ */
++static inline TransactionId
++HeapPageGetPruneXid(Page page, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return ((PageHeader) (page))->pd_prune_xid;
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ return ShortTransactionIdToNormal(base,
++ ((PageHeader) (page))->pd_prune_xid);
++}
++
++static inline void
++PageSetPrunable(Page page, TransactionId xid, bool is_toast)
++{
++ TransactionId prune_xid;
++
++ Assert(TransactionIdIsNormal(xid));
++
++ if (HeapPageIsDoubleXmax(page))
++ return;
++
++ prune_xid = HeapPageGetPruneXid(page, is_toast);
++ if ((!TransactionIdIsValid(prune_xid) ||
++ TransactionIdPrecedes(xid, prune_xid)))
++ {
++ HeapPageSetPruneXid(page, xid, is_toast);
++ }
++}
++
++/*
++ * Get pd_prune_xid from non-locked page. May return invalid value, but doen't
++ * causes assert failures.
++ */
++static inline TransactionId
++HeapPageGetPruneXidNoAssert(Page page, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return ((PageHeader) (page))->pd_prune_xid;
++
++ base = is_toast ? ToastPageGetSpecialNoAssert(page)->pd_xid_base :
++ HeapPageGetSpecialNoAssert(page)->pd_xid_base;
++ return ShortTransactionIdToNormal(base,
++ ((PageHeader) (page))->pd_prune_xid);
++}
+
+ /* ----------------------------------------------------------------
+ * extern declarations
+@@ -488,6 +679,21 @@ do { \
+ StaticAssertDecl(BLCKSZ == ((BLCKSZ / sizeof(size_t)) * sizeof(size_t)),
+ "BLCKSZ has to be a multiple of sizeof(size_t)");
+
++/*
++ * Tuple defrag support for PageRepairFragmentation and PageIndexMultiDelete
++ */
++typedef struct ItemIdCompactData
++{
++ uint16 offsetindex; /* linp array index */
++ int16 itemoff; /* page offset of item data */
++ uint16 alignedlen; /* MAXALIGN(item data len) */
++} ItemIdCompactData;
++
++typedef ItemIdCompactData *ItemIdCompact;
++typedef RelationData *Relation;
++
++extern int itemoffcompare(const void *item1, const void *item2);
++
+ extern void PageInit(Page page, Size pageSize, Size specialSize);
+ extern bool PageIsVerifiedExtended(Page page, BlockNumber blkno, int flags);
+ extern OffsetNumber PageAddItemExtended(Page page, Item item, Size size,
+@@ -496,7 +702,7 @@ extern Page PageGetTempPage(Page page);
+ extern Page PageGetTempPageCopy(Page page);
+ extern Page PageGetTempPageCopySpecial(Page page);
+ extern void PageRestoreTempPage(Page tempPage, Page oldPage);
+-extern void PageRepairFragmentation(Page page);
++extern void PageRepairFragmentation(Page page, bool is_toast);
+ extern void PageTruncateLinePointerArray(Page page);
+ extern Size PageGetFreeSpace(Page page);
+ extern Size PageGetFreeSpaceForMultipleTuples(Page page, int ntups);
+diff --git a/src/include/storage/itemid.h b/src/include/storage/itemid.h
+index 6d29722ec1f..2129728dc49 100644
+--- a/src/include/storage/itemid.h
++++ b/src/include/storage/itemid.h
+@@ -78,6 +78,8 @@ typedef uint16 ItemLength;
+ #define ItemIdGetRedirect(itemId) \
+ ((itemId)->lp_off)
+
++#define ItemIdGetTupleEnd(itemId) \
++ (MAXALIGN(ItemIdGetLength((itemId))) + ItemIdGetOffset((itemId)))
+ /*
+ * ItemIdIsValid
+ * True iff item identifier is valid.
+diff --git a/src/include/storage/lock.h b/src/include/storage/lock.h
+index 787f3db06a9..84f7323f606 100644
+--- a/src/include/storage/lock.h
++++ b/src/include/storage/lock.h
+@@ -224,8 +224,8 @@ typedef struct LOCKTAG
+
+ /* ID info for a transaction is its TransactionId */
+ #define SET_LOCKTAG_TRANSACTION(locktag,xid) \
+- ((locktag).locktag_field1 = (xid), \
+- (locktag).locktag_field2 = 0, \
++ ((locktag).locktag_field1 = (uint32)((xid) & 0xFFFFFFFF), \
++ (locktag).locktag_field2 = (uint32)((xid) >> 32), \
+ (locktag).locktag_field3 = 0, \
+ (locktag).locktag_field4 = 0, \
+ (locktag).locktag_type = LOCKTAG_TRANSACTION, \
+@@ -234,8 +234,8 @@ typedef struct LOCKTAG
+ /* ID info for a virtual transaction is its VirtualTransactionId */
+ #define SET_LOCKTAG_VIRTUALTRANSACTION(locktag,vxid) \
+ ((locktag).locktag_field1 = (vxid).procNumber, \
+- (locktag).locktag_field2 = (vxid).localTransactionId, \
+- (locktag).locktag_field3 = 0, \
++ (locktag).locktag_field2 = (uint32)((vxid).localTransactionId & 0xFFFFFFFF), \
++ (locktag).locktag_field3 = (uint32)((vxid).localTransactionId >> 32), \
+ (locktag).locktag_field4 = 0, \
+ (locktag).locktag_type = LOCKTAG_VIRTUALTRANSACTION, \
+ (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)
+@@ -245,9 +245,9 @@ typedef struct LOCKTAG
+ * its speculative insert counter.
+ */
+ #define SET_LOCKTAG_SPECULATIVE_INSERTION(locktag,xid,token) \
+- ((locktag).locktag_field1 = (xid), \
+- (locktag).locktag_field2 = (token), \
+- (locktag).locktag_field3 = 0, \
++ ((locktag).locktag_field1 = (uint32)((xid) & 0xFFFFFFFF), \
++ (locktag).locktag_field2 = (uint32)((xid) >> 32), \
++ (locktag).locktag_field3 = (token), \
+ (locktag).locktag_field4 = 0, \
+ (locktag).locktag_type = LOCKTAG_SPECULATIVE_TOKEN, \
+ (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)
+diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h
+index 5a3dd5d2d40..2d13925e79a 100644
+--- a/src/include/storage/proc.h
++++ b/src/include/storage/proc.h
+@@ -17,6 +17,7 @@
+ #include "access/clog.h"
+ #include "access/xlogdefs.h"
+ #include "lib/ilist.h"
++#include "port/atomics.h"
+ #include "storage/latch.h"
+ #include "storage/lock.h"
+ #include "storage/pg_sema.h"
+@@ -175,12 +176,12 @@ struct PGPROC
+ Latch procLatch; /* generic latch for process */
+
+
+- TransactionId xid; /* id of top-level transaction currently being
++ pg_atomic_uint64 xid; /* id of top-level transaction currently being
+ * executed by this proc, if running and XID
+ * is assigned; else InvalidTransactionId.
+ * mirrored in ProcGlobal->xids[pgxactoff] */
+
+- TransactionId xmin; /* minimal running XID as it was when we were
++ pg_atomic_uint64 xmin; /* minimal running XID as it was when we were
+ * starting our xact, excluding LAZY VACUUM:
+ * vacuum must not remove tuples deleted by
+ * xid >= xmin ! */
+@@ -390,7 +391,7 @@ typedef struct PROC_HDR
+ PGPROC *allProcs;
+
+ /* Array mirroring PGPROC.xid for each PGPROC currently in the procarray */
+- TransactionId *xids;
++ pg_atomic_uint64 *xids;
+
+ /*
+ * Array mirroring PGPROC.subxidStatus for each PGPROC currently in the
+diff --git a/src/include/utils/combocid.h b/src/include/utils/combocid.h
+index 00a9b561ec9..f1f4a899c4f 100644
+--- a/src/include/utils/combocid.h
++++ b/src/include/utils/combocid.h
+@@ -15,7 +15,7 @@
+ #define COMBOCID_H
+
+ /*
+- * HeapTupleHeaderGetCmin and HeapTupleHeaderGetCmax function prototypes
++ * HeapTupleGetCmin and HeapTupleGetCmax function prototypes
+ * are in access/htup.h, because that's where the macro definitions that
+ * those functions replaced used to be.
+ */
+diff --git a/src/include/utils/xid8.h b/src/include/utils/xid8.h
+index e8f887c6333..91d3f6f9a5b 100644
+--- a/src/include/utils/xid8.h
++++ b/src/include/utils/xid8.h
+@@ -17,13 +17,13 @@
+ static inline FullTransactionId
+ DatumGetFullTransactionId(Datum X)
+ {
+- return FullTransactionIdFromU64(DatumGetUInt64(X));
++ return FullTransactionIdFromXid(DatumGetUInt64(X));
+ }
+
+ static inline Datum
+ FullTransactionIdGetDatum(FullTransactionId X)
+ {
+- return UInt64GetDatum(U64FromFullTransactionId(X));
++ return UInt64GetDatum(XidFromFullTransactionId(X));
+ }
+
+ #define PG_GETARG_FULLTRANSACTIONID(X) DatumGetFullTransactionId(PG_GETARG_DATUM(X))
+diff --git a/src/pl/plperl/plperl.c b/src/pl/plperl/plperl.c
+index 1b1677e333b..770537a5437 100644
+--- a/src/pl/plperl/plperl.c
++++ b/src/pl/plperl/plperl.c
+@@ -2675,7 +2675,7 @@ validate_plperl_function(plperl_proc_ptr *proc_ptr, HeapTuple procTup)
+ * This is needed because CREATE OR REPLACE FUNCTION can modify the
+ * function's pg_proc entry without changing its OID.
+ ************************************************************/
+- uptodate = (prodesc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ uptodate = (prodesc->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&prodesc->fn_tid, &procTup->t_self));
+
+ if (uptodate)
+@@ -2799,7 +2799,7 @@ compile_plperl_function(Oid fn_oid, bool is_trigger, bool is_event_trigger)
+ MemoryContextSetIdentifier(proc_cxt, prodesc->proname);
+ prodesc->fn_cxt = proc_cxt;
+ prodesc->fn_refcount = 0;
+- prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ prodesc->fn_xmin = HeapTupleGetRawXmin(procTup);
+ prodesc->fn_tid = procTup->t_self;
+ prodesc->nargs = procStruct->pronargs;
+ prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo));
+diff --git a/src/pl/plpgsql/src/pl_comp.c b/src/pl/plpgsql/src/pl_comp.c
+index 6255a86d75b..d0ef60c0d84 100644
+--- a/src/pl/plpgsql/src/pl_comp.c
++++ b/src/pl/plpgsql/src/pl_comp.c
+@@ -170,7 +170,7 @@ recheck:
+ if (function)
+ {
+ /* We have a compiled function, but is it still valid? */
+- if (function->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ if (function->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&function->fn_tid, &procTup->t_self))
+ function_valid = true;
+ else
+@@ -343,7 +343,7 @@ do_compile(FunctionCallInfo fcinfo,
+ function->fn_signature = format_procedure(fcinfo->flinfo->fn_oid);
+ MemoryContextSetIdentifier(func_cxt, function->fn_signature);
+ function->fn_oid = fcinfo->flinfo->fn_oid;
+- function->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ function->fn_xmin = HeapTupleGetRawXmin(procTup);
+ function->fn_tid = procTup->t_self;
+ function->fn_input_collation = fcinfo->fncollation;
+ function->fn_cxt = func_cxt;
+diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c
+index e31206e7f4c..65b55c40022 100644
+--- a/src/pl/plpgsql/src/pl_exec.c
++++ b/src/pl/plpgsql/src/pl_exec.c
+@@ -7402,6 +7402,7 @@ deconstruct_composite_datum(Datum value, HeapTupleData *tmptup)
+ tmptup->t_len = HeapTupleHeaderGetDatumLength(td);
+ ItemPointerSetInvalid(&(tmptup->t_self));
+ tmptup->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tmptup);
+ tmptup->t_data = td;
+
+ /* Extract rowtype info and find a tupdesc */
+@@ -7576,6 +7577,7 @@ exec_move_row_from_datum(PLpgSQL_execstate *estate,
+ tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tmptup);
+ tmptup.t_data = td;
+
+ /* Extract rowtype info */
+diff --git a/src/pl/plpython/plpy_procedure.c b/src/pl/plpython/plpy_procedure.c
+index c35a3b801ab..c0377567575 100644
+--- a/src/pl/plpython/plpy_procedure.c
++++ b/src/pl/plpython/plpy_procedure.c
+@@ -175,7 +175,7 @@ PLy_procedure_create(HeapTuple procTup, Oid fn_oid, bool is_trigger)
+ proc->proname = pstrdup(NameStr(procStruct->proname));
+ MemoryContextSetIdentifier(cxt, proc->proname);
+ proc->pyname = pstrdup(procName);
+- proc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ proc->fn_xmin = HeapTupleGetRawXmin(procTup);
+ proc->fn_tid = procTup->t_self;
+ proc->fn_readonly = (procStruct->provolatile != PROVOLATILE_VOLATILE);
+ proc->is_setof = procStruct->proretset;
+@@ -415,7 +415,7 @@ PLy_procedure_valid(PLyProcedure *proc, HeapTuple procTup)
+ return false;
+
+ /* If the pg_proc tuple has changed, it's not valid */
+- if (!(proc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ if (!(proc->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&proc->fn_tid, &procTup->t_self)))
+ return false;
+
+diff --git a/src/pl/tcl/pltcl.c b/src/pl/tcl/pltcl.c
+index e2d9246a678..74feb938498 100644
+--- a/src/pl/tcl/pltcl.c
++++ b/src/pl/tcl/pltcl.c
+@@ -1455,7 +1455,7 @@ compile_pltcl_function(Oid fn_oid, Oid tgreloid,
+ ************************************************************/
+ if (prodesc != NULL &&
+ prodesc->internal_proname != NULL &&
+- prodesc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ prodesc->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&prodesc->fn_tid, &procTup->t_self))
+ {
+ /* It's still up-to-date, so we can use it */
+@@ -1589,7 +1589,7 @@ compile_pltcl_function(Oid fn_oid, Oid tgreloid,
+ prodesc->internal_proname = pstrdup(internal_proname);
+ prodesc->fn_cxt = proc_cxt;
+ prodesc->fn_refcount = 0;
+- prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ prodesc->fn_xmin = HeapTupleGetRawXmin(procTup);
+ prodesc->fn_tid = procTup->t_self;
+ prodesc->nargs = procStruct->pronargs;
+ prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo));
+diff --git a/src/test/Makefile b/src/test/Makefile
+index 511a72e6238..b986d0e324e 100644
+--- a/src/test/Makefile
++++ b/src/test/Makefile
+@@ -12,7 +12,8 @@ subdir = src/test
+ top_builddir = ../..
+ include $(top_builddir)/src/Makefile.global
+
+-SUBDIRS = perl postmaster regress isolation modules authentication recovery subscription
++SUBDIRS = perl postmaster regress isolation modules authentication recovery subscription \
++ xid-64
+
+ ifeq ($(with_icu),yes)
+ SUBDIRS += icu
+diff --git a/src/test/meson.build b/src/test/meson.build
+index 67376e4b7fd..11344e47add 100644
+--- a/src/test/meson.build
++++ b/src/test/meson.build
+@@ -8,6 +8,7 @@ subdir('postmaster')
+ subdir('recovery')
+ subdir('subscription')
+ subdir('modules')
++subdir('xid-64')
+
+ if ssl.found()
+ subdir('ssl')
+diff --git a/src/test/modules/test_lfind/test_lfind.c b/src/test/modules/test_lfind/test_lfind.c
+index c04bc2f6b42..3cf305f56c6 100644
+--- a/src/test/modules/test_lfind/test_lfind.c
++++ b/src/test/modules/test_lfind/test_lfind.c
+@@ -120,29 +120,29 @@ Datum
+ test_lfind32(PG_FUNCTION_ARGS)
+ {
+ #define TEST_ARRAY_SIZE 135
+- uint32 test_array[TEST_ARRAY_SIZE] = {0};
++ uint64 test_array[TEST_ARRAY_SIZE] = {0};
+
+ test_array[8] = 1;
+ test_array[64] = 2;
+ test_array[TEST_ARRAY_SIZE - 1] = 3;
+
+- if (pg_lfind32(1, test_array, 4))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
+- if (!pg_lfind32(1, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() did not find existing element");
++ if (pg_lfind64(1, test_array, 4))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
++ if (!pg_lfind64(1, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() did not find existing element");
+
+- if (pg_lfind32(2, test_array, 32))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
+- if (!pg_lfind32(2, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() did not find existing element");
++ if (pg_lfind64(2, test_array, 32))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
++ if (!pg_lfind64(2, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() did not find existing element");
+
+- if (pg_lfind32(3, test_array, 96))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
+- if (!pg_lfind32(3, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() did not find existing element");
++ if (pg_lfind64(3, test_array, 96))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
++ if (!pg_lfind64(3, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() did not find existing element");
+
+- if (pg_lfind32(4, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
++ if (pg_lfind64(4, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
+
+ PG_RETURN_VOID();
+ }
+diff --git a/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm b/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
+index 239c17aced9..83287ec6d57 100644
+--- a/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
++++ b/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
+@@ -132,6 +132,10 @@ sub adjust_database_contents
+ 'drop table public.gtest_normal_child2');
+ }
+
++ # Can't upgrade xid type
++ _add_st($result, 'regression',
++ 'alter table public.tab_core_types drop column xid');
++
+ # stuff not supported from release 14
+ if ($old_version < 14)
+ {
+diff --git a/src/test/recovery/t/003_recovery_targets.pl b/src/test/recovery/t/003_recovery_targets.pl
+index 58241a68f0a..ecd1105d1ae 100644
+--- a/src/test/recovery/t/003_recovery_targets.pl
++++ b/src/test/recovery/t/003_recovery_targets.pl
+@@ -57,7 +57,7 @@ $node_primary->init(has_archiving => 1, allows_streaming => 1);
+
+ # Bump the transaction ID epoch. This is useful to stress the portability
+ # of recovery_target_xid parsing.
+-system_or_bail('pg_resetwal', '--epoch', '1', $node_primary->data_dir);
++system_or_bail('pg_resetwal', $node_primary->data_dir);
+
+ # Start it
+ $node_primary->start;
+diff --git a/src/test/recovery/t/039_end_of_wal.pl b/src/test/recovery/t/039_end_of_wal.pl
+index 349bd44b726..4e5b0fd6e41 100644
+--- a/src/test/recovery/t/039_end_of_wal.pl
++++ b/src/test/recovery/t/039_end_of_wal.pl
+@@ -21,7 +21,7 @@ use integer; # causes / operator to use integer math
+ my $BIG_ENDIAN = pack("L", 0x12345678) eq pack("N", 0x12345678);
+
+ # Header size of record header.
+-my $RECORD_HEADER_SIZE = 24;
++my $RECORD_HEADER_SIZE = 26;
+
+ # Fields retrieved from code headers.
+ my @scan_result = scan_server_header('access/xlog_internal.h',
+@@ -131,17 +131,21 @@ sub build_record_header
+
+ # This needs to follow the structure XLogRecord:
+ # I for xl_tot_len
+- # I for xl_xid
++ # I for xl_crc
++ # II for xl_xid
+ # II for xl_prev
+ # C for xl_info
+ # C for xl_rmid
+- # BB for two bytes of padding
+- # I for xl_crc
+- return pack("IIIICCBBI",
+- $xl_tot_len, $xl_xid,
++ # BBBBBB for two bytes of padding
++ return pack("IIIIIICCBBBBBB",
++ $xl_tot_len,
++ $xl_crc,
++ $BIG_ENDIAN ? 0 : $xl_xid,
++ $BIG_ENDIAN ? $xl_xid : 0,
+ $BIG_ENDIAN ? 0 : $xl_prev,
+ $BIG_ENDIAN ? $xl_prev : 0,
+- $xl_info, $xl_rmid, 0, 0, $xl_crc);
++ $xl_info, $xl_rmid,
++ 0, 0, 0, 0, 0, 0);
+ }
+
+ # Build a fake WAL page header, based on the data given by the caller
+@@ -271,7 +275,7 @@ $node->stop('immediate');
+ my $log_size = -s $node->logfile;
+ $node->start;
+ ok( $node->log_contains(
+- "invalid record length at .*: expected at least 24, got 0", $log_size
++ "invalid record length at .*: expected at least 26, got 0", $log_size
+ ),
+ "xl_tot_len zero");
+
+@@ -283,7 +287,7 @@ write_wal($node, $TLI, $end_lsn, build_record_header(23));
+ $log_size = -s $node->logfile;
+ $node->start;
+ ok( $node->log_contains(
+- "invalid record length at .*: expected at least 24, got 23",
++ "invalid record length at .*: expected at least 26, got 23",
+ $log_size),
+ "xl_tot_len short");
+
+@@ -296,7 +300,7 @@ write_wal($node, $TLI, $end_lsn, build_record_header(1));
+ $log_size = -s $node->logfile;
+ $node->start;
+ ok( $node->log_contains(
+- "invalid record length at .*: expected at least 24, got 1", $log_size
++ "invalid record length at .*: expected at least 26, got 1", $log_size
+ ),
+ "xl_tot_len short at end-of-page");
+
+diff --git a/src/test/regress/expected/indirect_toast.out b/src/test/regress/expected/indirect_toast.out
+index 44b54dc37fd..313482b866c 100644
+--- a/src/test/regress/expected/indirect_toast.out
++++ b/src/test/regress/expected/indirect_toast.out
+@@ -161,6 +161,14 @@ SELECT substring(indtoasttest::text, 1, 200) FROM indtoasttest;
+ ("one-toasted,one-null, via indirect",0,1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
+ (5 rows)
+
++create or replace function random_string(len integer) returns text as $$
++select substr((select string_agg(r,'') from (select random()::text as r from generate_series(1,(len+15)/16)) s1), 1, len);
++$$ language sql;
++create table toasttest_main(t text);
++alter table toasttest_main alter column t set storage main;
++insert into toasttest_main (select random_string(len) from generate_series(7000,8000) len);
+ DROP TABLE indtoasttest;
++DROP TABLE toasttest_main;
+ DROP FUNCTION update_using_indirect();
++DROP FUNCTION random_string(integer);
+ RESET default_toast_compression;
+diff --git a/src/test/regress/expected/insert.out b/src/test/regress/expected/insert.out
+index cf4b5221a8d..0d40f3e3026 100644
+--- a/src/test/regress/expected/insert.out
++++ b/src/test/regress/expected/insert.out
+@@ -100,7 +100,7 @@ SELECT pg_size_pretty(pg_relation_size('large_tuple_test'::regclass, 'main'));
+ INSERT INTO large_tuple_test (select 3, NULL);
+ -- now this tuple won't fit on the second page, but the insert should
+ -- still succeed by extending the relation
+-INSERT INTO large_tuple_test (select 4, repeat('a', 8126));
++INSERT INTO large_tuple_test (select 4, repeat('a', 8112));
+ DROP TABLE large_tuple_test;
+ --
+ -- check indirection (field/array assignment), cf bug #14265
+@@ -1094,3 +1094,17 @@ insert into returningwrtest values (2, 'foo') returning returningwrtest;
+ (1 row)
+
+ drop table returningwrtest;
++-- Check for MaxHeapTupleSize
++create table maxheaptuplesize_test(value text);
++alter table maxheaptuplesize_test alter column value set storage external;
++insert into maxheaptuplesize_test values (repeat('x', 8104));
++insert into maxheaptuplesize_test values (repeat('x', 8112));
++insert into maxheaptuplesize_test values (repeat('x', 8120));
++insert into maxheaptuplesize_test values (repeat('x', 8128));
++insert into maxheaptuplesize_test values (repeat('x', 8136));
++insert into maxheaptuplesize_test values (repeat('x', 8144));
++insert into maxheaptuplesize_test values (repeat('x', 8152));
++insert into maxheaptuplesize_test values (repeat('x', 8160));
++insert into maxheaptuplesize_test values (repeat('x', 8168));
++insert into maxheaptuplesize_test values (repeat('x', 8176));
++drop table maxheaptuplesize_test;
+diff --git a/src/test/regress/expected/opr_sanity.out b/src/test/regress/expected/opr_sanity.out
+index 34a32bd11d2..298c6563aa8 100644
+--- a/src/test/regress/expected/opr_sanity.out
++++ b/src/test/regress/expected/opr_sanity.out
+@@ -197,7 +197,7 @@ WHERE p1.oid != p2.oid AND
+ ORDER BY 1, 2;
+ proargtypes | proargtypes
+ -----------------------------+--------------------------
+- integer | xid
++ bigint | xid
+ timestamp without time zone | timestamp with time zone
+ bit | bit varying
+ txid_snapshot | pg_snapshot
+@@ -736,7 +736,7 @@ int8(oid)
+ tideq(tid,tid)
+ timestamptz_cmp(timestamp with time zone,timestamp with time zone)
+ interval_cmp(interval,interval)
+-xideqint4(xid,integer)
++xideqint8(xid,bigint)
+ timetz_eq(time with time zone,time with time zone)
+ timetz_ne(time with time zone,time with time zone)
+ timetz_lt(time with time zone,time with time zone)
+@@ -850,7 +850,7 @@ pg_lsn_gt(pg_lsn,pg_lsn)
+ pg_lsn_ne(pg_lsn,pg_lsn)
+ pg_lsn_cmp(pg_lsn,pg_lsn)
+ xidneq(xid,xid)
+-xidneqint4(xid,integer)
++xidneqint8(xid,bigint)
+ sha224(bytea)
+ sha256(bytea)
+ sha384(bytea)
+diff --git a/src/test/regress/expected/select_views.out b/src/test/regress/expected/select_views.out
+index 1aeed8452bd..804d9914e8d 100644
+--- a/src/test/regress/expected/select_views.out
++++ b/src/test/regress/expected/select_views.out
+@@ -2,9 +2,22 @@
+ -- SELECT_VIEWS
+ -- test the views defined in CREATE_VIEWS
+ --
+-SELECT * FROM street;
++SELECT * FROM street ORDER BY name COLLATE "C", thepath::text COLLATE "C", cname COLLATE "C";
+ name | thepath | cname
+ ------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------
++ 100th Ave | [(-122.1657,37.429),(-122.1647,37.432)] | Oakland
++ 107th Ave | [(-122.1555,37.403),(-122.1531,37.41)] | Oakland
++ 14th St | [(-122.299,37.147),(-122.3,37.148)] | Lafayette
++ 19th Ave | [(-122.2366,37.897),(-122.2359,37.905)] | Berkeley
++ 1st St | [(-121.75508,37.89294),(-121.753581,37.90031)] | Oakland
++ 5th St | [(-122.278,37),(-122.2792,37.005),(-122.2803,37.009)] | Lafayette
++ 5th St | [(-122.296,37.615),(-122.2953,37.598)] | Berkeley
++ 82nd Ave | [(-122.1695,37.596),(-122.1681,37.603)] | Berkeley
++ 85th Ave | [(-122.1877,37.466),(-122.186,37.476)] | Oakland
++ 89th Ave | [(-122.1822,37.459),(-122.1803,37.471)] | Oakland
++ 98th Ave | [(-122.1568,37.498),(-122.1558,37.502)] | Oakland
++ 98th Ave | [(-122.1693,37.438),(-122.1682,37.444)] | Oakland
++ 98th Ave | [(-122.2001,37.258),(-122.1974,37.27)] | Lafayette
+ Access Rd 25 | [(-121.9283,37.894),(-121.9283,37.9)] | Oakland
+ Ada St | [(-122.2487,37.398),(-122.2496,37.401)] | Lafayette
+ Agua Fria Creek | [(-121.9254,37.922),(-121.9281,37.889)] | Oakland
+@@ -22,10 +35,10 @@ SELECT * FROM street;
+ Arroyo Las Positas | [(-121.7973,37.997),(-121.7957,37.005)] | Oakland
+ Arroyo Seco | [(-121.7073,37.766),(-121.6997,37.729)] | Oakland
+ Ash St | [(-122.0408,37.31),(-122.04,37.292)] | Oakland
+- Avenue 134th | [(-122.1823,37.002),(-122.1851,37.992)] | Oakland
+ Avenue 134th | [(-122.1823,37.002),(-122.1851,37.992)] | Berkeley
+- Avenue 140th | [(-122.1656,37.003),(-122.1691,37.988)] | Oakland
++ Avenue 134th | [(-122.1823,37.002),(-122.1851,37.992)] | Oakland
+ Avenue 140th | [(-122.1656,37.003),(-122.1691,37.988)] | Berkeley
++ Avenue 140th | [(-122.1656,37.003),(-122.1691,37.988)] | Oakland
+ Avenue D | [(-122.298,37.848),(-122.3024,37.849)] | Berkeley
+ B St | [(-122.1749,37.451),(-122.1743,37.443)] | Oakland
+ Bancroft Ave | [(-122.15714,37.4242),(-122.156,37.409)] | Oakland
+@@ -37,9 +50,9 @@ SELECT * FROM street;
+ Broadmore Ave | [(-122.095,37.522),(-122.0936,37.497)] | Oakland
+ Broadway | [(-122.2409,37.586),(-122.2395,37.601)] | Berkeley
+ Buckingham Blvd | [(-122.2231,37.59),(-122.2214,37.606)] | Berkeley
++ Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Berkeley
+ Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Oakland
+ Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Oakland
+- Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Berkeley
+ C St | [(-122.1768,37.46),(-122.1749,37.435)] | Oakland
+ Calaveras Creek | [(-121.8203,37.035),(-121.8207,37.931)] | Oakland
+ Calaveras Creek | [(-121.8203,37.035),(-121.8207,37.931)] | Oakland
+@@ -60,9 +73,9 @@ SELECT * FROM street;
+ Chapman Dr | [(-122.0421,37.504),(-122.0414,37.498)] | Oakland
+ Charles St | [(-122.0255,37.505),(-122.0252,37.499)] | Oakland
+ Cherry St | [(-122.0437,37.42),(-122.0434,37.413)] | Oakland
++ Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Berkeley
+ Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Oakland
+ Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Oakland
+- Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Berkeley
+ Coliseum Way | [(-122.2001,37.47),(-122.1978,37.516)] | Oakland
+ Coliseum Way | [(-122.2113,37.626),(-122.2085,37.592),(-122.2063,37.568)] | Berkeley
+ Coolidge Ave | [(-122.2007,37.058),(-122.1992,37.06)] | Lafayette
+@@ -77,9 +90,9 @@ SELECT * FROM street;
+ Cull Canyon Road | [(-122.0536,37.435),(-122.0499,37.315)] | Oakland
+ Cull Creek | [(-122.0624,37.875),(-122.0582,37.527)] | Berkeley
+ D St | [(-122.1811,37.505),(-122.1805,37.497)] | Oakland
++ Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Berkeley
+ Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Oakland
+ Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Oakland
+- Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Berkeley
+ Deering St | [(-122.2146,37.904),(-122.2126,37.897)] | Berkeley
+ Dimond Ave | [(-122.2167,37.994),(-122.2162,37.006)] | Berkeley
+ Dimond Ave | [(-122.2167,37.994),(-122.2162,37.006)] | Lafayette
+@@ -89,9 +102,9 @@ SELECT * FROM street;
+ Driscoll Road | [(-121.9482,37.403),(-121.948451,37.39995)] | Oakland
+ E St | [(-122.1832,37.505),(-122.1826,37.498),(-122.182,37.49)] | Oakland
+ Eden Ave | [(-122.1143,37.505),(-122.1142,37.491)] | Oakland
++ Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Berkeley
+ Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Oakland
+ Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Oakland
+- Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Berkeley
+ Edgewater Dr | [(-122.201,37.379),(-122.2042,37.41)] | Lafayette
+ Enos Way | [(-121.7677,37.896),(-121.7673,37.91)] | Oakland
+ Euclid Ave | [(-122.2671,37.009),(-122.2666,37.987)] | Berkeley
+@@ -106,8 +119,8 @@ SELECT * FROM street;
+ Harris Road | [(-122.0659,37.372),(-122.0675,37.363)] | Oakland
+ Heartwood Dr | [(-122.2006,37.341),(-122.1992,37.338)] | Lafayette
+ Hegenberger Exwy | [(-122.1946,37.52),(-122.1947,37.497)] | Oakland
+- Herrier St | [(-122.1943,37.006),(-122.1936,37.998)] | Oakland
+ Herrier St | [(-122.1943,37.006),(-122.1936,37.998)] | Berkeley
++ Herrier St | [(-122.1943,37.006),(-122.1936,37.998)] | Oakland
+ Hesperian Blvd | [(-122.097,37.333),(-122.0956,37.31),(-122.0946,37.293)] | Oakland
+ Hesperian Blvd | [(-122.097,37.333),(-122.0956,37.31),(-122.0946,37.293)] | Oakland
+ Hesperian Blvd | [(-122.1132,37.6),(-122.1123,37.586)] | Berkeley
+@@ -117,10 +130,10 @@ SELECT * FROM street;
+ I- 580 | [(-121.9322,37.989),(-121.9243,37.006),(-121.9217,37.014)] | Oakland
+ I- 580 | [(-122.018,37.019),(-122.0009,37.032),(-121.9787,37.983),(-121.958,37.984),(-121.9571,37.986)] | Oakland
+ I- 580 | [(-122.018,37.019),(-122.0009,37.032),(-121.9787,37.983),(-121.958,37.984),(-121.9571,37.986)] | Oakland
+- I- 580 | [(-122.1108,37.023),(-122.1101,37.02),(-122.108103,37.00764),(-122.108,37.007),(-122.1069,37.998),(-122.1064,37.994),(-122.1053,37.982),(-122.1048,37.977),(-122.1032,37.958),(-122.1026,37.953),(-122.1013,37.938),(-122.0989,37.911),(-122.0984,37.91),(-122.098,37.908)] | Oakland
+ I- 580 | [(-122.1108,37.023),(-122.1101,37.02),(-122.108103,37.00764),(-122.108,37.007),(-122.1069,37.998),(-122.1064,37.994),(-122.1053,37.982),(-122.1048,37.977),(-122.1032,37.958),(-122.1026,37.953),(-122.1013,37.938),(-122.0989,37.911),(-122.0984,37.91),(-122.098,37.908)] | Berkeley
+- I- 580 | [(-122.1543,37.703),(-122.1535,37.694),(-122.1512,37.655),(-122.1475,37.603),(-122.1468,37.583),(-122.1472,37.569),(-122.149044,37.54874),(-122.1493,37.546),(-122.1501,37.532),(-122.1506,37.509),(-122.1495,37.482),(-122.1487,37.467),(-122.1477,37.447),(-122.1414,37.383),(-122.1404,37.376),(-122.1398,37.372),(-122.139,37.356),(-122.1388,37.353),(-122.1385,37.34),(-122.1382,37.33),(-122.1378,37.316)] | Oakland
++ I- 580 | [(-122.1108,37.023),(-122.1101,37.02),(-122.108103,37.00764),(-122.108,37.007),(-122.1069,37.998),(-122.1064,37.994),(-122.1053,37.982),(-122.1048,37.977),(-122.1032,37.958),(-122.1026,37.953),(-122.1013,37.938),(-122.0989,37.911),(-122.0984,37.91),(-122.098,37.908)] | Oakland
+ I- 580 | [(-122.1543,37.703),(-122.1535,37.694),(-122.1512,37.655),(-122.1475,37.603),(-122.1468,37.583),(-122.1472,37.569),(-122.149044,37.54874),(-122.1493,37.546),(-122.1501,37.532),(-122.1506,37.509),(-122.1495,37.482),(-122.1487,37.467),(-122.1477,37.447),(-122.1414,37.383),(-122.1404,37.376),(-122.1398,37.372),(-122.139,37.356),(-122.1388,37.353),(-122.1385,37.34),(-122.1382,37.33),(-122.1378,37.316)] | Berkeley
++ I- 580 | [(-122.1543,37.703),(-122.1535,37.694),(-122.1512,37.655),(-122.1475,37.603),(-122.1468,37.583),(-122.1472,37.569),(-122.149044,37.54874),(-122.1493,37.546),(-122.1501,37.532),(-122.1506,37.509),(-122.1495,37.482),(-122.1487,37.467),(-122.1477,37.447),(-122.1414,37.383),(-122.1404,37.376),(-122.1398,37.372),(-122.139,37.356),(-122.1388,37.353),(-122.1385,37.34),(-122.1382,37.33),(-122.1378,37.316)] | Oakland
+ I- 580 | [(-122.2197,37.99),(-122.22,37.99),(-122.222092,37.99523),(-122.2232,37.998),(-122.224146,37.99963),(-122.2261,37.003),(-122.2278,37.007),(-122.2302,37.026),(-122.2323,37.043),(-122.2344,37.059),(-122.235405,37.06427),(-122.2365,37.07)] | Berkeley
+ I- 580 | [(-122.2197,37.99),(-122.22,37.99),(-122.222092,37.99523),(-122.2232,37.998),(-122.224146,37.99963),(-122.2261,37.003),(-122.2278,37.007),(-122.2302,37.026),(-122.2323,37.043),(-122.2344,37.059),(-122.235405,37.06427),(-122.2365,37.07)] | Lafayette
+ I- 580 Ramp | [(-121.8521,37.011),(-121.8479,37.999),(-121.8476,37.999),(-121.8456,37.01),(-121.8455,37.011)] | Oakland
+@@ -136,8 +149,8 @@ SELECT * FROM street;
+ I- 580 Ramp | [(-122.0941,37.897),(-122.0943,37.902)] | Berkeley
+ I- 580 Ramp | [(-122.096,37.888),(-122.0962,37.891),(-122.0964,37.9)] | Berkeley
+ I- 580 Ramp | [(-122.101,37.898),(-122.1005,37.902),(-122.0989,37.911)] | Berkeley
+- I- 580 Ramp | [(-122.1086,37.003),(-122.1068,37.993),(-122.1066,37.992),(-122.1053,37.982)] | Oakland
+ I- 580 Ramp | [(-122.1086,37.003),(-122.1068,37.993),(-122.1066,37.992),(-122.1053,37.982)] | Berkeley
++ I- 580 Ramp | [(-122.1086,37.003),(-122.1068,37.993),(-122.1066,37.992),(-122.1053,37.982)] | Oakland
+ I- 580 Ramp | [(-122.1414,37.383),(-122.1407,37.376),(-122.1403,37.372),(-122.139,37.356)] | Oakland
+ I- 580/I-680 Ramp | ((-121.9207,37.988),(-121.9192,37.016)) | Oakland
+ I- 580/I-680 Ramp | ((-121.9207,37.988),(-121.9192,37.016)) | Oakland
+@@ -158,16 +171,16 @@ SELECT * FROM street;
+ I- 880 | ((-121.9669,37.075),(-121.9663,37.071),(-121.9656,37.065),(-121.9618,37.037),(-121.95689,37),(-121.948,37.933)) | Oakland
+ I- 880 | [(-121.948,37.933),(-121.9471,37.925),(-121.9467,37.923),(-121.946,37.918),(-121.9452,37.912),(-121.937,37.852)] | Oakland
+ I- 880 | [(-122.0219,37.466),(-122.0205,37.447),(-122.020331,37.44447),(-122.020008,37.43962),(-122.0195,37.432),(-122.0193,37.429),(-122.0164,37.393),(-122.010219,37.34771),(-122.0041,37.313)] | Oakland
+- I- 880 | [(-122.0375,37.632),(-122.0359,37.619),(-122.0358,37.616),(-122.034514,37.60409),(-122.031876,37.57965),(-122.031193,37.57332),(-122.03016,37.56375),(-122.02943,37.55698),(-122.028689,37.54929),(-122.027833,37.53908),(-122.025979,37.51698),(-122.0238,37.491)] | Oakland
+ I- 880 | [(-122.0375,37.632),(-122.0359,37.619),(-122.0358,37.616),(-122.034514,37.60409),(-122.031876,37.57965),(-122.031193,37.57332),(-122.03016,37.56375),(-122.02943,37.55698),(-122.028689,37.54929),(-122.027833,37.53908),(-122.025979,37.51698),(-122.0238,37.491)] | Berkeley
++ I- 880 | [(-122.0375,37.632),(-122.0359,37.619),(-122.0358,37.616),(-122.034514,37.60409),(-122.031876,37.57965),(-122.031193,37.57332),(-122.03016,37.56375),(-122.02943,37.55698),(-122.028689,37.54929),(-122.027833,37.53908),(-122.025979,37.51698),(-122.0238,37.491)] | Oakland
++ I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Berkeley
+ I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Oakland
+ I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Oakland
+- I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Berkeley
+ I- 880 | [(-122.0831,37.312),(-122.0819,37.296),(-122.081,37.285),(-122.0786,37.248),(-122.078,37.24),(-122.077642,37.23496),(-122.076983,37.22567),(-122.076599,37.22026),(-122.076229,37.21505),(-122.0758,37.209)] | Oakland
+ I- 880 | [(-122.0978,37.528),(-122.096,37.496),(-122.0931,37.453),(-122.09277,37.4496),(-122.090189,37.41442),(-122.0896,37.405),(-122.085,37.34)] | Oakland
+ I- 880 | [(-122.1365,37.902),(-122.1358,37.898),(-122.1333,37.881),(-122.1323,37.874),(-122.1311,37.866),(-122.1308,37.865),(-122.1307,37.864),(-122.1289,37.851),(-122.1277,37.843),(-122.1264,37.834),(-122.1231,37.812),(-122.1165,37.766),(-122.1104,37.72),(-122.109695,37.71094),(-122.109,37.702),(-122.108312,37.69168),(-122.1076,37.681)] | Berkeley
+- I- 880 | [(-122.1755,37.185),(-122.1747,37.178),(-122.1742,37.173),(-122.1692,37.126),(-122.167792,37.11594),(-122.16757,37.11435),(-122.1671,37.111),(-122.1655,37.1),(-122.165169,37.09811),(-122.1641,37.092),(-122.1596,37.061),(-122.158381,37.05275),(-122.155991,37.03657),(-122.1531,37.017),(-122.1478,37.98),(-122.1407,37.932),(-122.1394,37.924),(-122.1389,37.92),(-122.1376,37.91)] | Oakland
+ I- 880 | [(-122.1755,37.185),(-122.1747,37.178),(-122.1742,37.173),(-122.1692,37.126),(-122.167792,37.11594),(-122.16757,37.11435),(-122.1671,37.111),(-122.1655,37.1),(-122.165169,37.09811),(-122.1641,37.092),(-122.1596,37.061),(-122.158381,37.05275),(-122.155991,37.03657),(-122.1531,37.017),(-122.1478,37.98),(-122.1407,37.932),(-122.1394,37.924),(-122.1389,37.92),(-122.1376,37.91)] | Berkeley
++ I- 880 | [(-122.1755,37.185),(-122.1747,37.178),(-122.1742,37.173),(-122.1692,37.126),(-122.167792,37.11594),(-122.16757,37.11435),(-122.1671,37.111),(-122.1655,37.1),(-122.165169,37.09811),(-122.1641,37.092),(-122.1596,37.061),(-122.158381,37.05275),(-122.155991,37.03657),(-122.1531,37.017),(-122.1478,37.98),(-122.1407,37.932),(-122.1394,37.924),(-122.1389,37.92),(-122.1376,37.91)] | Oakland
+ I- 880 | [(-122.2214,37.711),(-122.2202,37.699),(-122.2199,37.695),(-122.219,37.682),(-122.2184,37.672),(-122.2173,37.652),(-122.2159,37.638),(-122.2144,37.616),(-122.2138,37.612),(-122.2135,37.609),(-122.212,37.592),(-122.2116,37.586),(-122.2111,37.581)] | Berkeley
+ I- 880 | [(-122.2707,37.975),(-122.2693,37.972),(-122.2681,37.966),(-122.267,37.962),(-122.2659,37.957),(-122.2648,37.952),(-122.2636,37.946),(-122.2625,37.935),(-122.2617,37.927),(-122.2607,37.921),(-122.2593,37.916),(-122.258,37.911),(-122.2536,37.898),(-122.2432,37.858),(-122.2408,37.845),(-122.2386,37.827),(-122.2374,37.811)] | Berkeley
+ I- 880 Ramp | [(-122.0019,37.301),(-122.002,37.293)] | Oakland
+@@ -175,12 +188,12 @@ SELECT * FROM street;
+ I- 880 Ramp | [(-122.0041,37.313),(-122.0038,37.308),(-122.0039,37.284),(-122.0013,37.287),(-121.9995,37.289)] | Oakland
+ I- 880 Ramp | [(-122.0236,37.488),(-122.0231,37.458),(-122.0227,37.458),(-122.0223,37.452),(-122.0205,37.447)] | Oakland
+ I- 880 Ramp | [(-122.0238,37.491),(-122.0215,37.483),(-122.0211,37.477),(-122.0205,37.447)] | Oakland
++ I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Berkeley
+ I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Oakland
+ I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Oakland
+- I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Berkeley
++ I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Berkeley
+ I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Oakland
+ I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Oakland
+- I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Berkeley
+ I- 880 Ramp | [(-122.085,37.34),(-122.0801,37.316),(-122.081,37.285)] | Oakland
+ I- 880 Ramp | [(-122.085,37.34),(-122.0801,37.316),(-122.081,37.285)] | Oakland
+ I- 880 Ramp | [(-122.085,37.34),(-122.0866,37.316),(-122.0819,37.296)] | Oakland
+@@ -212,26 +225,26 @@ SELECT * FROM street;
+ Livermore Ave | [(-121.7687,37.448),(-121.769,37.375)] | Oakland
+ Livermore Ave | [(-121.772719,37.99085),(-121.7728,37.001)] | Oakland
+ Livermore Ave | [(-121.772719,37.99085),(-121.7728,37.001)] | Oakland
+- Locust St | [(-122.1606,37.007),(-122.1593,37.987)] | Oakland
+ Locust St | [(-122.1606,37.007),(-122.1593,37.987)] | Berkeley
++ Locust St | [(-122.1606,37.007),(-122.1593,37.987)] | Oakland
+ Logan Ct | [(-122.0053,37.492),(-122.0061,37.484)] | Oakland
+ Magnolia St | [(-122.0971,37.5),(-122.0962,37.484)] | Oakland
+ Mandalay Road | [(-122.2322,37.397),(-122.2321,37.403)] | Lafayette
+ Marin Ave | [(-122.2741,37.894),(-122.272,37.901)] | Berkeley
+ Martin Luther King Jr Way | [(-122.2712,37.608),(-122.2711,37.599)] | Berkeley
+ Mattos Dr | [(-122.0005,37.502),(-122.000898,37.49683)] | Oakland
+- Maubert Ave | [(-122.1114,37.009),(-122.1096,37.995)] | Oakland
+ Maubert Ave | [(-122.1114,37.009),(-122.1096,37.995)] | Berkeley
+- McClure Ave | [(-122.1431,37.001),(-122.1436,37.998)] | Oakland
++ Maubert Ave | [(-122.1114,37.009),(-122.1096,37.995)] | Oakland
+ McClure Ave | [(-122.1431,37.001),(-122.1436,37.998)] | Berkeley
++ McClure Ave | [(-122.1431,37.001),(-122.1436,37.998)] | Oakland
+ Medlar Dr | [(-122.0627,37.378),(-122.0625,37.375)] | Oakland
+ Mildred Ct | [(-122.0002,37.388),(-121.9998,37.386)] | Oakland
+ Miller Road | [(-122.0902,37.645),(-122.0865,37.545)] | Berkeley
+ Miramar Ave | [(-122.1009,37.025),(-122.099089,37.03209)] | Oakland
+ Mission Blvd | [(-121.918886,37),(-121.9194,37.976),(-121.9198,37.975)] | Oakland
+ Mission Blvd | [(-121.918886,37),(-121.9194,37.976),(-121.9198,37.975)] | Oakland
+- Mission Blvd | [(-122.0006,37.896),(-121.9989,37.88)] | Oakland
+ Mission Blvd | [(-122.0006,37.896),(-121.9989,37.88)] | Berkeley
++ Mission Blvd | [(-122.0006,37.896),(-121.9989,37.88)] | Oakland
+ Moores Ave | [(-122.0087,37.301),(-122.0094,37.292)] | Oakland
+ National Ave | [(-122.1192,37.5),(-122.1281,37.489)] | Oakland
+ Navajo Ct | [(-121.8779,37.901),(-121.8783,37.9)] | Oakland
+@@ -242,49 +255,49 @@ SELECT * FROM street;
+ Parkridge Dr | [(-122.1438,37.884),(-122.1428,37.9)] | Berkeley
+ Parkside Dr | [(-122.0475,37.603),(-122.0443,37.596)] | Berkeley
+ Paseo Padre Pkwy | [(-121.9143,37.005),(-121.913522,37)] | Oakland
+- Paseo Padre Pkwy | [(-122.0021,37.639),(-121.996,37.628)] | Oakland
+ Paseo Padre Pkwy | [(-122.0021,37.639),(-121.996,37.628)] | Berkeley
++ Paseo Padre Pkwy | [(-122.0021,37.639),(-121.996,37.628)] | Oakland
+ Pearl St | [(-122.2383,37.594),(-122.2366,37.615)] | Berkeley
+ Periwinkle Road | [(-122.0451,37.301),(-122.044758,37.29844)] | Oakland
+ Pimlico Dr | [(-121.8616,37.998),(-121.8618,37.008)] | Oakland
+ Pimlico Dr | [(-121.8616,37.998),(-121.8618,37.008)] | Oakland
+ Portsmouth Ave | [(-122.1064,37.315),(-122.1064,37.308)] | Oakland
+ Proctor Ave | [(-122.2267,37.406),(-122.2251,37.386)] | Lafayette
++ Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Berkeley
+ Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Oakland
+ Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Oakland
+- Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Berkeley
++ Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Berkeley
+ Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Oakland
+ Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Oakland
+- Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Berkeley
+ Redding St | [(-122.1978,37.901),(-122.1975,37.895)] | Berkeley
+- Redwood Road | [(-122.1493,37.98),(-122.1437,37.001)] | Oakland
+ Redwood Road | [(-122.1493,37.98),(-122.1437,37.001)] | Berkeley
++ Redwood Road | [(-122.1493,37.98),(-122.1437,37.001)] | Oakland
+ Roca Dr | [(-122.0335,37.609),(-122.0314,37.599)] | Berkeley
+ Rosedale Ct | [(-121.9232,37.9),(-121.924,37.897)] | Oakland
+ Sacramento St | [(-122.2799,37.606),(-122.2797,37.597)] | Berkeley
+ Saddle Brook Dr | [(-122.1478,37.909),(-122.1454,37.904),(-122.1451,37.888)] | Berkeley
+ Saginaw Ct | [(-121.8803,37.898),(-121.8806,37.901)] | Oakland
+ San Andreas Dr | [(-122.0609,37.9),(-122.0614,37.895)] | Berkeley
++ Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Berkeley
+ Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Oakland
+ Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Oakland
+- Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Berkeley
+ Shattuck Ave | [(-122.2686,37.904),(-122.2686,37.897)] | Berkeley
+ Sheridan Road | [(-122.2279,37.425),(-122.2253,37.411),(-122.2223,37.377)] | Lafayette
+ Shoreline Dr | [(-122.2657,37.603),(-122.2648,37.6)] | Berkeley
+- Skyline Blvd | [(-122.1738,37.01),(-122.1714,37.996)] | Oakland
+ Skyline Blvd | [(-122.1738,37.01),(-122.1714,37.996)] | Berkeley
++ Skyline Blvd | [(-122.1738,37.01),(-122.1714,37.996)] | Oakland
+ Skyline Dr | [(-122.0277,37.5),(-122.0284,37.498)] | Oakland
+ Skywest Dr | [(-122.1161,37.62),(-122.1123,37.586)] | Berkeley
+ Southern Pacific Railroad | [(-122.3002,37.674),(-122.2999,37.661)] | Berkeley
+ Sp Railroad | [(-121.893564,37.99009),(-121.897,37.016)] | Oakland
+ Sp Railroad | [(-121.893564,37.99009),(-121.897,37.016)] | Oakland
+ Sp Railroad | [(-121.9565,37.898),(-121.9562,37.9)] | Oakland
++ Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Berkeley
+ Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Oakland
+ Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Oakland
+- Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Berkeley
+ Sp Railroad | [(-122.0914,37.601),(-122.087,37.56),(-122.086408,37.5551)] | Berkeley
+- Sp Railroad | [(-122.137792,37.003),(-122.1365,37.992),(-122.131257,37.94612)] | Oakland
+ Sp Railroad | [(-122.137792,37.003),(-122.1365,37.992),(-122.131257,37.94612)] | Berkeley
++ Sp Railroad | [(-122.137792,37.003),(-122.1365,37.992),(-122.131257,37.94612)] | Oakland
+ Sp Railroad | [(-122.1947,37.497),(-122.193328,37.4848)] | Oakland
+ Stanton Ave | [(-122.100392,37.0697),(-122.099513,37.06052)] | Oakland
+ State Hwy 123 | [(-122.3004,37.986),(-122.2998,37.969),(-122.2995,37.962),(-122.2992,37.952),(-122.299,37.942),(-122.2987,37.935),(-122.2984,37.924),(-122.2982,37.92),(-122.2976,37.904),(-122.297,37.88),(-122.2966,37.869),(-122.2959,37.848),(-122.2961,37.843)] | Berkeley
+@@ -316,28 +329,15 @@ SELECT * FROM street;
+ Welch Creek Road | [(-121.7695,37.386),(-121.7737,37.413)] | Oakland
+ Welch Creek Road | [(-121.7695,37.386),(-121.7737,37.413)] | Oakland
+ West Loop Road | [(-122.0576,37.604),(-122.0602,37.586)] | Berkeley
++ Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Berkeley
+ Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Oakland
+ Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Oakland
+- Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Berkeley
+ Whitlock Creek | [(-121.74683,37.91276),(-121.733107,37)] | Oakland
+ Whitlock Creek | [(-121.74683,37.91276),(-121.733107,37)] | Oakland
+ Willimet Way | [(-122.0964,37.517),(-122.0949,37.493)] | Oakland
+- Wisconsin St | [(-122.1994,37.017),(-122.1975,37.998),(-122.1971,37.994)] | Oakland
+ Wisconsin St | [(-122.1994,37.017),(-122.1975,37.998),(-122.1971,37.994)] | Berkeley
++ Wisconsin St | [(-122.1994,37.017),(-122.1975,37.998),(-122.1971,37.994)] | Oakland
+ Wp Railroad | [(-122.254,37.902),(-122.2506,37.891)] | Berkeley
+- 100th Ave | [(-122.1657,37.429),(-122.1647,37.432)] | Oakland
+- 107th Ave | [(-122.1555,37.403),(-122.1531,37.41)] | Oakland
+- 14th St | [(-122.299,37.147),(-122.3,37.148)] | Lafayette
+- 19th Ave | [(-122.2366,37.897),(-122.2359,37.905)] | Berkeley
+- 1st St | [(-121.75508,37.89294),(-121.753581,37.90031)] | Oakland
+- 5th St | [(-122.278,37),(-122.2792,37.005),(-122.2803,37.009)] | Lafayette
+- 5th St | [(-122.296,37.615),(-122.2953,37.598)] | Berkeley
+- 82nd Ave | [(-122.1695,37.596),(-122.1681,37.603)] | Berkeley
+- 85th Ave | [(-122.1877,37.466),(-122.186,37.476)] | Oakland
+- 89th Ave | [(-122.1822,37.459),(-122.1803,37.471)] | Oakland
+- 98th Ave | [(-122.1568,37.498),(-122.1558,37.502)] | Oakland
+- 98th Ave | [(-122.1693,37.438),(-122.1682,37.444)] | Oakland
+- 98th Ave | [(-122.2001,37.258),(-122.1974,37.27)] | Lafayette
+ (333 rows)
+
+ SELECT name, #thepath FROM iexit ORDER BY name COLLATE "C", 2;
+diff --git a/src/test/regress/expected/txid.out b/src/test/regress/expected/txid.out
+index 95ba66e95ee..2ea4434f513 100644
+--- a/src/test/regress/expected/txid.out
++++ b/src/test/regress/expected/txid.out
+@@ -238,9 +238,11 @@ SELECT txid_snapshot '1:9223372036854775807:3';
+ (1 row)
+
+ SELECT txid_snapshot '1:9223372036854775808:3';
+-ERROR: invalid input syntax for type pg_snapshot: "1:9223372036854775808:3"
+-LINE 1: SELECT txid_snapshot '1:9223372036854775808:3';
+- ^
++ txid_snapshot
++-------------------------
++ 1:9223372036854775808:3
++(1 row)
++
+ -- test txid_current_if_assigned
+ BEGIN;
+ SELECT txid_current_if_assigned() IS NULL;
+diff --git a/src/test/regress/expected/type_sanity.out b/src/test/regress/expected/type_sanity.out
+index 88d8f6c32d6..0c4b994343f 100644
+--- a/src/test/regress/expected/type_sanity.out
++++ b/src/test/regress/expected/type_sanity.out
+@@ -19,7 +19,7 @@ WHERE t1.typnamespace = 0 OR
+ (t1.typlen <= 0 AND t1.typlen != -1 AND t1.typlen != -2) OR
+ (t1.typtype not in ('b', 'c', 'd', 'e', 'm', 'p', 'r')) OR
+ NOT t1.typisdefined OR
+- (t1.typalign not in ('c', 's', 'i', 'd')) OR
++ (t1.typalign not in ('c', 's', 'i', 'd', 'x')) OR
+ (t1.typstorage not in ('p', 'x', 'e', 'm'));
+ oid | typname
+ -----+---------
+@@ -32,7 +32,8 @@ WHERE t1.typbyval AND
+ (t1.typlen != 1 OR t1.typalign != 'c') AND
+ (t1.typlen != 2 OR t1.typalign != 's') AND
+ (t1.typlen != 4 OR t1.typalign != 'i') AND
+- (t1.typlen != 8 OR t1.typalign != 'd');
++ (t1.typlen != 8 OR t1.typalign != 'd') AND
++ (t1.typlen != 8 OR t1.typalign != 'x');
+ oid | typname
+ -----+---------
+ (0 rows)
+diff --git a/src/test/regress/expected/xid.out b/src/test/regress/expected/xid.out
+index 835077e9d57..0154990d1af 100644
+--- a/src/test/regress/expected/xid.out
++++ b/src/test/regress/expected/xid.out
+@@ -8,9 +8,9 @@ select '010'::xid,
+ '42'::xid8,
+ '0xffffffffffffffff'::xid8,
+ '-1'::xid8;
+- xid | xid | xid | xid | xid8 | xid8 | xid8 | xid8
+------+-----+------------+------------+------+------+----------------------+----------------------
+- 8 | 42 | 4294967295 | 4294967295 | 8 | 42 | 18446744073709551615 | 18446744073709551615
++ xid | xid | xid | xid | xid8 | xid8 | xid8 | xid8
++-----+-----+------------+----------------------+------+------+----------------------+----------------------
++ 8 | 42 | 4294967295 | 18446744073709551615 | 8 | 42 | 18446744073709551615 | 18446744073709551615
+ (1 row)
+
+ -- garbage values
+@@ -43,10 +43,10 @@ SELECT pg_input_is_valid('asdf', 'xid');
+ f
+ (1 row)
+
+-SELECT * FROM pg_input_error_info('0xffffffffff', 'xid');
+- message | detail | hint | sql_error_code
+----------------------------------------------------+--------+------+----------------
+- value "0xffffffffff" is out of range for type xid | | | 22003
++SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid');
++ message | detail | hint | sql_error_code
++-------------------------------------------------------------+--------+------+----------------
++ value "0xffffffffffffffffffff" is out of range for type xid | | | 22003
+ (1 row)
+
+ SELECT pg_input_is_valid('42', 'xid8');
+@@ -441,9 +441,11 @@ SELECT pg_snapshot '1:9223372036854775807:3';
+ (1 row)
+
+ SELECT pg_snapshot '1:9223372036854775808:3';
+-ERROR: invalid input syntax for type pg_snapshot: "1:9223372036854775808:3"
+-LINE 1: SELECT pg_snapshot '1:9223372036854775808:3';
+- ^
++ pg_snapshot
++-------------------------
++ 1:9223372036854775808:3
++(1 row)
++
+ -- test pg_current_xact_id_if_assigned
+ BEGIN;
+ SELECT pg_current_xact_id_if_assigned() IS NULL;
+diff --git a/src/test/regress/expected/xid64.out b/src/test/regress/expected/xid64.out
+new file mode 100644
+index 00000000000..c30c5b57399
+--- /dev/null
++++ b/src/test/regress/expected/xid64.out
+@@ -0,0 +1,92 @@
++---
++--- Unit test for xid64 functions
++---
++-- directory paths and dlsuffix are passed to us in environment variables
++\getenv libdir PG_LIBDIR
++\getenv dlsuffix PG_DLSUFFIX
++\set regresslib :libdir '/regress' :dlsuffix
++CREATE FUNCTION xid64_test_1(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_1' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_2(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_2' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_double_xmax(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_double_xmax' LANGUAGE C STRICT;
++---
++--- Check page consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(a int);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++INSERT INTO test_xid64_table(a) SELECT a FROM generate_series(1, 1000) AS a;
++SELECT xid64_test_1('test_xid64_table');
++INFO: test 1: page is converted to xid64 format
++ xid64_test_1
++--------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++---
++--- Check tuples consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(s serial, i int, t text);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++DO $$
++BEGIN
++ FOR j IN 1..20 LOOP
++ INSERT INTO test_xid64_table(i, t) VALUES (random()::int, md5(random()::text));
++ COMMIT;
++ END LOOP;
++END $$;
++DO $$
++BEGIN
++ FOR j IN 1..10 LOOP
++ DELETE FROM test_xid64_table WHERE ctid IN (SELECT ctid FROM test_xid64_table TABLESAMPLE BERNOULLI (5));
++ COMMIT;
++ END LOOP;
++END $$;
++SELECT xid64_test_2('test_xid64_table');
++ xid64_test_2
++--------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++---
++--- Check tuples consistency after conversion to double xmax (on full page)
++---
++CREATE UNLOGGED TABLE test_xid64_table(i int);
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table SELECT i FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++SELECT xid64_test_2('test_xid64_table');
++ xid64_test_2
++--------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++CREATE UNLOGGED TABLE test_xid64_table(i text);
++INSERT INTO test_xid64_table(i) VALUES ('NNBABCDSDFGHJKLP');
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table(i) SELECT 'A' FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++SELECT xid64_test_double_xmax('test_xid64_table');
++INFO: test double xmax: page 0 is converted into double xmax format
++INFO: test double xmax: end
++ xid64_test_double_xmax
++------------------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++DROP FUNCTION xid64_test_1(rel regclass);
++DROP FUNCTION xid64_test_2(rel regclass);
++DROP FUNCTION xid64_test_double_xmax(rel regclass);
+diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
+index 81e4222d26a..881b5825892 100644
+--- a/src/test/regress/parallel_schedule
++++ b/src/test/regress/parallel_schedule
+@@ -28,7 +28,7 @@ test: strings md5 numerology point lseg line box path polygon circle date time t
+ # geometry depends on point, lseg, line, box, path, polygon, circle
+ # horology depends on date, time, timetz, timestamp, timestamptz, interval
+ # ----------
+-test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc database stats_import
++test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid xid64 mvcc database stats_import
+
+ # ----------
+ # Load huge amounts of data
+diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c
+index 8309166f5b2..f40c3fccbde 100644
+--- a/src/test/regress/regress.c
++++ b/src/test/regress/regress.c
+@@ -21,6 +21,9 @@
+
+ #include "access/detoast.h"
+ #include "access/htup_details.h"
++#include "access/transam.h"
++#include "access/xact.h"
++#include "catalog/catalog.h"
+ #include "catalog/namespace.h"
+ #include "catalog/pg_operator.h"
+ #include "catalog/pg_type.h"
+@@ -38,6 +41,7 @@
+ #include "port/atomics.h"
+ #include "storage/spin.h"
+ #include "utils/array.h"
++#include "storage/checksum.h"
+ #include "utils/builtins.h"
+ #include "utils/geo_decls.h"
+ #include "utils/memutils.h"
+@@ -574,6 +578,7 @@ make_tuple_indirect(PG_FUNCTION_ARGS)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = rec;
+
+ values = (Datum *) palloc(ncolumns * sizeof(Datum));
+@@ -1156,3 +1161,296 @@ binary_coercible(PG_FUNCTION_ARGS)
+
+ PG_RETURN_BOOL(IsBinaryCoercible(srctype, targettype));
+ }
++
++#include "access/hio.h"
++#include "access/relation.h"
++#include "storage/bufmgr.h"
++#include "utils/rel.h"
++
++static void
++CheckNewPage(char *msg, Page page)
++{
++ uint16 size;
++
++ if (PageGetPageLayoutVersion(page) != PG_PAGE_LAYOUT_VERSION)
++ elog(ERROR, "%s: page version is %d, expected %d ",
++ msg, PageGetPageLayoutVersion(page), PG_PAGE_LAYOUT_VERSION);
++
++ size = PageGetSpecialSize(page);
++ if (size == MAXALIGN(sizeof(HeapPageSpecialData)))
++ elog(INFO, "%s: page is converted to xid64 format", msg);
++ else if (HeapPageIsDoubleXmax(page))
++ elog(INFO, "%s: page is converted into double xmax format", msg);
++ else
++ elog(ERROR, "%s: converted page has pageSpecial size %u, expected %llu",
++ msg, size,
++ (unsigned long long) MAXALIGN(sizeof(HeapPageSpecialData)));
++}
++
++/*
++ * Get page from relation.
++ * Make this page look like in 32-bit xid format.
++ * Convert it to 64-bit xid format.
++ * Run basic checks.
++ */
++PG_FUNCTION_INFO_V1(xid64_test_1);
++Datum
++xid64_test_1(PG_FUNCTION_ARGS)
++{
++ Oid relid;
++ Relation rel;
++ Buffer buf;
++ Page page;
++ PageHeader hdr;
++
++ relid = PG_GETARG_OID(0);
++ rel = relation_open(relid, AccessExclusiveLock);
++ buf = ReadBuffer(rel, 0);
++ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
++
++ page = BufferGetPage(buf);
++ hdr = (PageHeader) page;
++
++ if (PageGetSpecialSize(page) != MAXALIGN(sizeof(HeapPageSpecialData)))
++ elog(ERROR, "page expected in new format");
++
++ if (PageGetPageLayoutVersion(page) != PG_PAGE_LAYOUT_VERSION)
++ elog(ERROR, "unknown page version (%u)",
++ PageGetPageLayoutVersion(page));
++
++ hdr->pd_special = BLCKSZ;
++ PageSetPageSizeAndVersion(page, BLCKSZ, PG_PAGE_LAYOUT_VERSION - 1);
++ hdr->pd_checksum = 0; //turn off check sum check performed in the convert_page
++ convert_page(rel, page, buf, 0);
++
++ CheckNewPage("test 1", page);
++
++ UnlockReleaseBuffer(buf);
++ relation_close(rel, AccessExclusiveLock);
++
++ PG_RETURN_VOID();
++}
++
++typedef struct TupleCheckValues
++{
++ TransactionId xmin;
++ TransactionId xmax;
++} TupleCheckValues;
++
++typedef struct RelCheckValues
++{
++ TupleCheckValues *tcv;
++ Size ntuples;
++} RelCheckValues;
++
++static RelCheckValues
++FillRelCheckValues(Relation rel, Buffer buffer, Page page)
++{
++ RelCheckValues set;
++ Size n;
++
++#define DEFAULT_SET_SIZE 64
++ n = DEFAULT_SET_SIZE;
++ set.ntuples = 0;
++ set.tcv = palloc(sizeof(set.tcv[0]) * n);
++
++ {
++ OffsetNumber maxoff,
++ offnum;
++ HeapTupleHeader tuphdr;
++ ItemId itemid;
++ HeapTupleData tuple;
++ TransactionId xmin,
++ xmax;
++
++ maxoff = PageGetMaxOffsetNumber(page);
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++ tuphdr = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_data = tuphdr;
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++
++ if (HeapPageGetSpecial(page) == heapDoubleXmaxSpecial)
++ {
++ xmin = tuphdr->t_choice.t_heap.t_xmin;
++ xmax = tuphdr->t_choice.t_heap.t_xmax;
++ }
++ else
++ {
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page,
++ IsToastRelation(rel));
++
++ xmin = HeapTupleGetRawXmin(&tuple);
++ xmax = HeapTupleGetRawXmax(&tuple);
++ }
++
++ if (set.ntuples == n)
++ {
++ n *= 2;
++ set.tcv = repalloc(set.tcv, sizeof(set.tcv[0]) * n);
++ }
++
++ set.tcv[set.ntuples].xmin = xmin;
++ set.tcv[set.ntuples].xmax = xmax;
++ set.ntuples++;
++ }
++ }
++
++ return set;
++}
++
++/*
++ * Test xmin/xmax invariant when converting page from 32bit xid to 64xid.
++ *
++ * Scenario:
++ * - enforce all relation pages to 32bit xid format, discarding pd_xid_base and
++ * pd_multi_base
++ * - store all xmin/xmax in array
++ * - convert all the pages from relation into 64xid format
++ * - store all new xmin/xmax in array
++ * - compare old and new xmin/xmax
++ *
++ * NOTE: inital xid value does not affect test as pd_xid_base/pd_multi_base
++ * discarded.
++ */
++PG_FUNCTION_INFO_V1(xid64_test_2);
++Datum
++xid64_test_2(PG_FUNCTION_ARGS)
++{
++ Oid relid;
++ Relation rel;
++ RelCheckValues before,
++ after;
++ BlockNumber pageno,
++ npages;
++ Size i;
++
++ relid = PG_GETARG_OID(0);
++ rel = relation_open(relid, AccessExclusiveLock);
++ npages = RelationGetNumberOfBlocks(rel);
++
++ for (pageno = 0; pageno != npages; ++pageno)
++ {
++ Buffer buf;
++ Page page;
++ PageHeader hdr;
++
++ /* get page */
++ buf = ReadBuffer(rel, pageno);
++ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
++ page = BufferGetPage(buf);
++ hdr = (PageHeader) page;
++
++ /* make page look like 32-bit xid page */
++ hdr->pd_special = BLCKSZ;
++ PageSetPageSizeAndVersion(page, BLCKSZ, PG_PAGE_LAYOUT_VERSION - 1);
++
++ before = FillRelCheckValues(rel, buf, page);
++ hdr->pd_checksum = pg_checksum_page((char *) page, pageno);
++ convert_page(rel, page, buf, pageno);
++ after = FillRelCheckValues(rel, buf, page);
++
++ /* check */
++ if (before.ntuples != after.ntuples)
++ elog(ERROR, "numer of tuples must be equal");
++
++ for (i = 0; i != before.ntuples; ++i)
++ {
++ if (before.tcv[i].xmin != after.tcv[i].xmin && after.tcv[i].xmin)
++ elog(ERROR, "old and new xmin does not match (%llu != %llu)",
++ (unsigned long long) before.tcv[i].xmin,
++ (unsigned long long) after.tcv[i].xmin);
++
++ if (before.tcv[i].xmax != after.tcv[i].xmax)
++ elog(ERROR, "old and new xmax does not match (%llu != %llu)",
++ (unsigned long long) before.tcv[i].xmax,
++ (unsigned long long) after.tcv[i].xmax);
++ }
++
++ Assert(npages != 0);
++ pfree(before.tcv);
++ pfree(after.tcv);
++
++ UnlockReleaseBuffer(buf);
++ }
++
++ relation_close(rel, AccessExclusiveLock);
++
++ PG_RETURN_VOID();
++}
++
++PG_FUNCTION_INFO_V1(xid64_test_double_xmax);
++Datum
++xid64_test_double_xmax(PG_FUNCTION_ARGS)
++{
++ Oid relid;
++ Relation rel;
++ BlockNumber pageno,
++ npages;
++ bool found;
++
++ relid = PG_GETARG_OID(0);
++ rel = relation_open(relid, AccessExclusiveLock);
++ npages = RelationGetNumberOfBlocks(rel);
++ found = false;
++
++ for (pageno = 0; pageno != npages; ++pageno)
++ {
++ Buffer buf;
++ Page page;
++ PageHeader hdr;
++ ItemId itemid;
++ OffsetNumber offnum;
++ HeapTupleHeader tuphdr;
++
++ buf = ReadBuffer(rel, pageno);
++ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
++ page = BufferGetPage(buf);
++ hdr = (PageHeader) page;
++
++ if (pageno == 0)
++ {
++ itemid = PageGetItemId(page, FirstOffsetNumber);
++ itemid->lp_len += 16; /* Move to overlap special */
++ }
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= PageGetMaxOffsetNumber(page);
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++ tuphdr = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuphdr->t_infomask |= HEAP_XMIN_COMMITTED;
++ }
++
++ hdr->pd_special = BLCKSZ;
++ PageSetPageSizeAndVersion(page, BLCKSZ, PG_PAGE_LAYOUT_VERSION - 1);
++ hdr->pd_checksum = pg_checksum_page((char *) page, pageno);
++
++ convert_page(rel, page, buf, pageno);
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ found = true;
++ elog(INFO, "test double xmax: page %u is converted into double xmax format",
++ pageno);
++ }
++
++ UnlockReleaseBuffer(buf);
++ }
++
++ if (!found)
++ elog(ERROR, "test double xmax: failed, no double xmax");
++
++ Assert(npages != 0);
++ elog(INFO, "test double xmax: end");
++
++ relation_close(rel, AccessExclusiveLock);
++
++ PG_RETURN_VOID();
++}
+diff --git a/src/test/regress/sql/indirect_toast.sql b/src/test/regress/sql/indirect_toast.sql
+index 3e2f6c02375..ea087b51282 100644
+--- a/src/test/regress/sql/indirect_toast.sql
++++ b/src/test/regress/sql/indirect_toast.sql
+@@ -76,7 +76,18 @@ SELECT substring(indtoasttest::text, 1, 200) FROM indtoasttest;
+ VACUUM FREEZE indtoasttest;
+ SELECT substring(indtoasttest::text, 1, 200) FROM indtoasttest;
+
++create or replace function random_string(len integer) returns text as $$
++select substr((select string_agg(r,'') from (select random()::text as r from generate_series(1,(len+15)/16)) s1), 1, len);
++$$ language sql;
++
++create table toasttest_main(t text);
++alter table toasttest_main alter column t set storage main;
++
++insert into toasttest_main (select random_string(len) from generate_series(7000,8000) len);
++
+ DROP TABLE indtoasttest;
++DROP TABLE toasttest_main;
+ DROP FUNCTION update_using_indirect();
++DROP FUNCTION random_string(integer);
+
+ RESET default_toast_compression;
+diff --git a/src/test/regress/sql/insert.sql b/src/test/regress/sql/insert.sql
+index 2b086eeb6d7..d8bb0a9222e 100644
+--- a/src/test/regress/sql/insert.sql
++++ b/src/test/regress/sql/insert.sql
+@@ -55,7 +55,7 @@ INSERT INTO large_tuple_test (select 3, NULL);
+
+ -- now this tuple won't fit on the second page, but the insert should
+ -- still succeed by extending the relation
+-INSERT INTO large_tuple_test (select 4, repeat('a', 8126));
++INSERT INTO large_tuple_test (select 4, repeat('a', 8112));
+
+ DROP TABLE large_tuple_test;
+
+@@ -674,3 +674,18 @@ alter table returningwrtest2 drop c;
+ alter table returningwrtest attach partition returningwrtest2 for values in (2);
+ insert into returningwrtest values (2, 'foo') returning returningwrtest;
+ drop table returningwrtest;
++
++-- Check for MaxHeapTupleSize
++create table maxheaptuplesize_test(value text);
++alter table maxheaptuplesize_test alter column value set storage external;
++insert into maxheaptuplesize_test values (repeat('x', 8104));
++insert into maxheaptuplesize_test values (repeat('x', 8112));
++insert into maxheaptuplesize_test values (repeat('x', 8120));
++insert into maxheaptuplesize_test values (repeat('x', 8128));
++insert into maxheaptuplesize_test values (repeat('x', 8136));
++insert into maxheaptuplesize_test values (repeat('x', 8144));
++insert into maxheaptuplesize_test values (repeat('x', 8152));
++insert into maxheaptuplesize_test values (repeat('x', 8160));
++insert into maxheaptuplesize_test values (repeat('x', 8168));
++insert into maxheaptuplesize_test values (repeat('x', 8176));
++drop table maxheaptuplesize_test;
+diff --git a/src/test/regress/sql/select_views.sql b/src/test/regress/sql/select_views.sql
+index e742f136990..a94bd7259c9 100644
+--- a/src/test/regress/sql/select_views.sql
++++ b/src/test/regress/sql/select_views.sql
+@@ -3,7 +3,7 @@
+ -- test the views defined in CREATE_VIEWS
+ --
+
+-SELECT * FROM street;
++SELECT * FROM street ORDER BY name COLLATE "C", thepath::text COLLATE "C", cname COLLATE "C";
+
+ SELECT name, #thepath FROM iexit ORDER BY name COLLATE "C", 2;
+
+diff --git a/src/test/regress/sql/type_sanity.sql b/src/test/regress/sql/type_sanity.sql
+index e88d6cbe49d..bbc2213b546 100644
+--- a/src/test/regress/sql/type_sanity.sql
++++ b/src/test/regress/sql/type_sanity.sql
+@@ -22,7 +22,7 @@ WHERE t1.typnamespace = 0 OR
+ (t1.typlen <= 0 AND t1.typlen != -1 AND t1.typlen != -2) OR
+ (t1.typtype not in ('b', 'c', 'd', 'e', 'm', 'p', 'r')) OR
+ NOT t1.typisdefined OR
+- (t1.typalign not in ('c', 's', 'i', 'd')) OR
++ (t1.typalign not in ('c', 's', 'i', 'd', 'x')) OR
+ (t1.typstorage not in ('p', 'x', 'e', 'm'));
+
+ -- Look for "pass by value" types that can't be passed by value.
+@@ -33,7 +33,8 @@ WHERE t1.typbyval AND
+ (t1.typlen != 1 OR t1.typalign != 'c') AND
+ (t1.typlen != 2 OR t1.typalign != 's') AND
+ (t1.typlen != 4 OR t1.typalign != 'i') AND
+- (t1.typlen != 8 OR t1.typalign != 'd');
++ (t1.typlen != 8 OR t1.typalign != 'd') AND
++ (t1.typlen != 8 OR t1.typalign != 'x');
+
+ -- Look for "toastable" types that aren't varlena.
+
+diff --git a/src/test/regress/sql/xid.sql b/src/test/regress/sql/xid.sql
+index 9f716b3653a..9b94cb9a4a8 100644
+--- a/src/test/regress/sql/xid.sql
++++ b/src/test/regress/sql/xid.sql
+@@ -19,7 +19,7 @@ select 'asdf'::xid8;
+ -- Also try it with non-error-throwing API
+ SELECT pg_input_is_valid('42', 'xid');
+ SELECT pg_input_is_valid('asdf', 'xid');
+-SELECT * FROM pg_input_error_info('0xffffffffff', 'xid');
++SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid');
+ SELECT pg_input_is_valid('42', 'xid8');
+ SELECT pg_input_is_valid('asdf', 'xid8');
+ SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid8');
+diff --git a/src/test/regress/sql/xid64.sql b/src/test/regress/sql/xid64.sql
+new file mode 100644
+index 00000000000..caa97a0ed99
+--- /dev/null
++++ b/src/test/regress/sql/xid64.sql
+@@ -0,0 +1,84 @@
++---
++--- Unit test for xid64 functions
++---
++
++-- directory paths and dlsuffix are passed to us in environment variables
++\getenv libdir PG_LIBDIR
++\getenv dlsuffix PG_DLSUFFIX
++
++\set regresslib :libdir '/regress' :dlsuffix
++
++CREATE FUNCTION xid64_test_1(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_1' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_2(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_2' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_double_xmax(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_double_xmax' LANGUAGE C STRICT;
++
++---
++--- Check page consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(a int);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++INSERT INTO test_xid64_table(a) SELECT a FROM generate_series(1, 1000) AS a;
++SELECT xid64_test_1('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++---
++--- Check tuples consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(s serial, i int, t text);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++
++DO $$
++BEGIN
++ FOR j IN 1..20 LOOP
++ INSERT INTO test_xid64_table(i, t) VALUES (random()::int, md5(random()::text));
++ COMMIT;
++ END LOOP;
++END $$;
++
++DO $$
++BEGIN
++ FOR j IN 1..10 LOOP
++ DELETE FROM test_xid64_table WHERE ctid IN (SELECT ctid FROM test_xid64_table TABLESAMPLE BERNOULLI (5));
++ COMMIT;
++ END LOOP;
++END $$;
++
++SELECT xid64_test_2('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++---
++--- Check tuples consistency after conversion to double xmax (on full page)
++---
++CREATE UNLOGGED TABLE test_xid64_table(i int);
++
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table SELECT i FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++
++SELECT xid64_test_2('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++CREATE UNLOGGED TABLE test_xid64_table(i text);
++INSERT INTO test_xid64_table(i) VALUES ('NNBABCDSDFGHJKLP');
++
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table(i) SELECT 'A' FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++
++SELECT xid64_test_double_xmax('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++DROP FUNCTION xid64_test_1(rel regclass);
++DROP FUNCTION xid64_test_2(rel regclass);
++DROP FUNCTION xid64_test_double_xmax(rel regclass);
+diff --git a/src/test/xid-64/.gitignore b/src/test/xid-64/.gitignore
+new file mode 100644
+index 00000000000..0d41f282aa3
+--- /dev/null
++++ b/src/test/xid-64/.gitignore
+@@ -0,0 +1,8 @@
++# Generated subdirectories
++/tmp_check/
++/results/
++/log/
++
++# Note: regression.* are only left behind on a failure; that's why they're not ignored
++#/regression.diffs
++#/regression.out
+diff --git a/src/test/xid-64/Makefile b/src/test/xid-64/Makefile
+new file mode 100644
+index 00000000000..3b1e50dfc0d
+--- /dev/null
++++ b/src/test/xid-64/Makefile
+@@ -0,0 +1,22 @@
++#-------------------------------------------------------------------------
++#
++# Makefile for src/test/xid-64
++#
++# Copyright (c) 2018, Postgres Professional
++#
++# src/test/xid-64/Makefile
++#
++#-------------------------------------------------------------------------
++
++subdir = src/test/xid-64
++top_builddir = ../../..
++include $(top_builddir)/src/Makefile.global
++
++check:
++ $(prove_check)
++
++installcheck:
++ $(prove_installcheck)
++
++clean distclean maintainer-clean:
++ rm -rf tmp_check
+diff --git a/src/test/xid-64/README b/src/test/xid-64/README
+new file mode 100644
+index 00000000000..01c0a1a1f74
+--- /dev/null
++++ b/src/test/xid-64/README
+@@ -0,0 +1,16 @@
++src/test/xid-64/README
++
++Regression tests for 64-bit XIDs
++=============================================
++
++This directory contains a test suite for 64-bit xids.
++
++Running the tests
++=================
++
++ make check
++
++NOTE: This creates a temporary installation, and some tests may
++create one or multiple nodes.
++
++NOTE: This requires the --enable-tap-tests argument to configure.
+diff --git a/src/test/xid-64/meson.build b/src/test/xid-64/meson.build
+new file mode 100644
+index 00000000000..63a780b69e8
+--- /dev/null
++++ b/src/test/xid-64/meson.build
+@@ -0,0 +1,16 @@
++tests += {
++ 'name': 'xid-64',
++ 'sd': meson.current_source_dir(),
++ 'bd': meson.current_build_dir(),
++ 'tap': {
++ 'tests': [
++ 't/001_test_large_xids.pl',
++ 't/002_test_gucs.pl',
++ 't/003_test_integrity.pl',
++ 't/004_test_relminmxid.pl',
++ 't/005_stream_subxact.pl',
++ 't/006_zeropage.pl',
++ 't/007_first_multi.pl',
++ ],
++ },
++}
+diff --git a/src/test/xid-64/t/002_test_gucs.pl b/src/test/xid-64/t/002_test_gucs.pl
+new file mode 100644
+index 00000000000..93413892336
+--- /dev/null
++++ b/src/test/xid-64/t/002_test_gucs.pl
+@@ -0,0 +1,79 @@
++# Tests for guc boundary values
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++use bigint;
++
++sub command_output
++{
++ my ($cmd) = @_;
++ my ($stdout, $stderr);
++ print("# Running: " . join(" ", @{$cmd}) . "\n");
++ my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
++ ok($result, "@$cmd exit code 0");
++ is($stderr, '', "@$cmd no stderr");
++ return $stdout;
++}
++
++sub set_guc
++{
++ my ($node, $guc, $val) = @_;
++ print("SET $guc = $val\n");
++ $node->safe_psql('postgres', "ALTER SYSTEM SET $guc = $val");
++ $node->restart();
++}
++
++sub test_pgbench
++{
++ my ($node) = @_;
++ $node->command_ok(
++ [ qw(pgbench --progress=5 --transactions=1000 --jobs=5 --client=5) ],
++ 'pgbench finished without errors');
++}
++
++my @guc_vals = (
++ [ "autovacuum_freeze_max_age", 100000, 2**63 - 1 ],
++ [ "autovacuum_multixact_freeze_max_age", 10000, 2**63 - 1 ],
++ [ "vacuum_freeze_min_age", 0, 2**63 - 1 ],
++ [ "vacuum_freeze_table_age", 0, 2**63 - 1 ],
++ [ "vacuum_multixact_freeze_min_age", 0, 2**63 - 1 ],
++ [ "vacuum_multixact_freeze_table_age", 0, 2**63 -1 ]
++);
++
++my $START_VAL = 2**32;
++my $MAX_VAL = 2**62;
++
++my $ixid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imxid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imoff = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++
++# Initialize master node
++my $node = PostgreSQL::Test::Cluster->new('master');
++$node->init;
++# Disable logging of all statements to avoid log bloat during pgbench
++$node->append_conf('postgresql.conf', "log_statement = none");
++$node->start;
++
++# Fill the test database with the pgbench data
++$node->command_ok(
++ [ qw(pgbench --initialize --scale=10) ],
++ 'pgbench finished without errors');
++
++# Test all GUCs with minimum, maximum and random value inbetween
++# (run pgbench for every configuration setting)
++foreach my $gi (0 .. $#guc_vals) {
++ print($guc_vals[$gi][0]); print("\n");
++ my $guc = $guc_vals[$gi][0];
++ my $minval = $guc_vals[$gi][1];
++ my $maxval = $guc_vals[$gi][2];
++ set_guc($node, $guc, $minval);
++ test_pgbench($node);
++ set_guc($node, $guc, $maxval);
++ test_pgbench($node);
++ set_guc($node, $guc, $minval + int(rand($maxval - $minval)));
++ test_pgbench($node);
++}
++
++done_testing();
+diff --git a/src/test/xid-64/t/003_test_integrity.pl b/src/test/xid-64/t/003_test_integrity.pl
+new file mode 100644
+index 00000000000..5b0789688ed
+--- /dev/null
++++ b/src/test/xid-64/t/003_test_integrity.pl
+@@ -0,0 +1,58 @@
++# Check integrity after dump/restore with different xids
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++use File::Compare;
++
++my $tempdir = PostgreSQL::Test::Utils::tempdir;
++use bigint;
++
++my $START_VAL = 2**32;
++my $MAX_VAL = 2**62;
++
++my $ixid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imxid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imoff = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++
++# Initialize master node
++my $node = PostgreSQL::Test::Cluster->new('master');
++$node->init();
++$node->start;
++
++# Create a database and fill it with the pgbench data
++$node->safe_psql('postgres', "CREATE DATABASE pgbench_db");
++$node->command_ok(
++ [ qw(pgbench --initialize --scale=2 pgbench_db) ],
++ 'pgbench finished without errors');
++# Dump the database (cluster the main table to put data in a determined order)
++$node->safe_psql('pgbench_db', qq(
++ CREATE INDEX pa_aid_idx ON pgbench_accounts (aid);
++ CLUSTER pgbench_accounts USING pa_aid_idx));
++$node->command_ok(
++ [ "pg_dump", "-w", "--inserts", "--file=$tempdir/pgbench.sql", "pgbench_db" ],
++ 'pgdump finished without errors');
++$node->stop('fast');
++
++# Initialize second node
++my $node2 = PostgreSQL::Test::Cluster->new('master2');
++$node2->init;
++# Disable logging of all statements to avoid log bloat during restore
++$node2->append_conf('postgresql.conf', "log_statement = none");
++$node2->start;
++
++# Create a database and restore the previous dump
++$node2->safe_psql('postgres', "CREATE DATABASE pgbench_db");
++my $txid0 = $node2->safe_psql('pgbench_db', 'SELECT txid_current()');
++print("# Initial txid_current: $txid0\n");
++$node2->command_ok(["psql", "-q", "-f", "$tempdir/pgbench.sql", "pgbench_db"]);
++
++# Dump the database and compare the dumped content with the previous one
++$node2->safe_psql('pgbench_db', 'CLUSTER pgbench_accounts');
++$node2->command_ok(
++ [ "pg_dump", "-w", "--inserts", "--file=$tempdir/pgbench2.sql", "pgbench_db" ],
++ 'pgdump finished without errors');
++ok(File::Compare::compare_text("$tempdir/pgbench.sql", "$tempdir/pgbench2.sql") == 0, "no differences detected");
++
++done_testing();
+diff --git a/src/test/xid-64/t/004_test_relminmxid.pl b/src/test/xid-64/t/004_test_relminmxid.pl
+new file mode 100644
+index 00000000000..e924f9cd9ab
+--- /dev/null
++++ b/src/test/xid-64/t/004_test_relminmxid.pl
+@@ -0,0 +1,90 @@
++# Check integrity after dump/restore with different xids
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++use bigint;
++
++my ($node, $rmm, $vacout);
++$node = PostgreSQL::Test::Cluster->new('master');
++$node->init;
++$node->append_conf('postgresql.conf', 'max_prepared_transactions = 2');
++$node->start;
++
++sub relminmxid
++{
++ my $rmm = $node->safe_psql("postgres", qq(
++ SELECT relminmxid
++ FROM pg_class
++ WHERE relname = 'foo';));
++ return $rmm + 0;
++}
++
++sub vacuum
++{
++ my ($rc, $stdout, $stderr) = $node->psql("postgres", "VACUUM foo;");
++ return $stdout.$stderr;
++}
++
++sub gen_multixact
++{
++ $node->safe_psql("postgres", qq(
++ BEGIN;
++ SELECT * FROM foo FOR KEY SHARE;
++ PREPARE TRANSACTION 'fooshare';
++ ));
++
++ my $xmax = $node->safe_psql("postgres", qq(
++ SELECT xmax FROM foo;
++ ));
++ isnt($xmax + 0, 0, "xmax not empty");
++
++ $node->safe_psql("postgres", qq(
++ BEGIN;
++ SELECT * FROM foo FOR KEY SHARE;
++ COMMIT;
++ COMMIT PREPARED 'fooshare';
++ ));
++
++ my $mxact = $node->safe_psql("postgres", qq(
++ SELECT xmax FROM foo;
++ ));
++ isnt($mxact + 0, 0, "mxact not empty");
++ cmp_ok($xmax, '>', $mxact, "xmax is greater than mxact");
++}
++
++# Initialize master node with the random xid-related parameters
++$node->safe_psql("postgres", "CREATE TABLE foo (a int); INSERT INTO foo VALUES (1);");
++
++is(relminmxid(), 1, "relminmxid is default");
++
++vacuum();
++is(relminmxid(), 1, "relminmxid is still default");
++
++gen_multixact();
++is(relminmxid(), 1, "relminmxid is still still default");
++
++unlike(vacuum(), qr/multixact.*before relminmxid/, "no relminmxid error");
++
++# No intentionally break relminmxid
++$node->safe_psql("postgres", qq(
++ UPDATE pg_class SET relminmxid = ((1::int8<<62) + 1)::text::xid
++ WHERE relname = 'foo'
++));
++cmp_ok(relminmxid(), '>', 2**62, "relminmxid broken (intentionally)");
++
++gen_multixact();
++like(vacuum(), qr/multixact.*before relminmxid/, "got relminmxid error");
++cmp_ok(relminmxid(), '>', 2**62, "relminmxid broken (still)");
++
++# Fix relminmxid by setting to default
++$node->safe_psql("postgres", qq(
++ UPDATE pg_class SET relminmxid = '1'
++ WHERE relname = 'foo'
++));
++is(relminmxid(), 1, "relminmxid is default again");
++
++unlike(vacuum(), qr/multixact.*before relminmxid/, "no relminmxid error again");
++
++done_testing();
+diff --git a/src/test/xid-64/t/005_stream_subxact.pl b/src/test/xid-64/t/005_stream_subxact.pl
+new file mode 100644
+index 00000000000..6765f6061ca
+--- /dev/null
++++ b/src/test/xid-64/t/005_stream_subxact.pl
+@@ -0,0 +1,100 @@
++
++# Copyright (c) 2021, PostgreSQL Global Development Group
++
++# Test xids streaming of large transaction containing large subtransactions
++# near 32-bit boundary.
++#
++# Mostly it is a copy of 016_stream_subxact.pl, but with publisher xid inited
++# just before 32-bit boundary, so if xids are replicated as 32-bit values,
++# subscriber will get 0 xid value.
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++
++# Create publisher node
++my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
++$node_publisher->init(allows_streaming => 'logical');
++$node_publisher->append_conf('postgresql.conf',
++ 'logical_decoding_work_mem = 64kB');
++$node_publisher->start;
++
++# Create subscriber node
++my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
++$node_subscriber->init(allows_streaming => 'logical');
++$node_subscriber->start;
++
++# Create some preexisting content on publisher
++$node_publisher->safe_psql('postgres',
++ "CREATE TABLE test_tab (a int primary key, b varchar)");
++$node_publisher->safe_psql('postgres',
++ "INSERT INTO test_tab VALUES (1, 'foo'), (2, 'bar')");
++
++# Setup structure on subscriber
++$node_subscriber->safe_psql('postgres',
++ "CREATE TABLE test_tab (a int primary key, b text, c timestamptz DEFAULT now(), d bigint DEFAULT 999)"
++);
++
++# Setup logical replication
++my $publisher_connstr = $node_publisher->connstr . ' dbname=postgres';
++$node_publisher->safe_psql('postgres',
++ "CREATE PUBLICATION tap_pub FOR TABLE test_tab");
++
++my $appname = 'tap_sub';
++$node_subscriber->safe_psql('postgres',
++ "CREATE SUBSCRIPTION tap_sub CONNECTION '$publisher_connstr application_name=$appname' PUBLICATION tap_pub WITH (streaming = on)"
++);
++
++$node_publisher->wait_for_catchup($appname);
++
++# Also wait for initial table sync to finish
++my $synced_query =
++ "SELECT count(1) = 0 FROM pg_subscription_rel WHERE srsubstate NOT IN ('r', 's');";
++$node_subscriber->poll_query_until('postgres', $synced_query)
++ or die "Timed out while waiting for subscriber to synchronize data";
++
++my $result =
++ $node_subscriber->safe_psql('postgres',
++ "SELECT count(*), count(c), count(d = 999) FROM test_tab");
++is($result, qq(2|2|2), 'check initial data was copied to subscriber');
++
++# Insert, update and delete enough rows to exceed 64kB limit.
++$node_publisher->safe_psql(
++ 'postgres', q{
++BEGIN;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series( 3, 500) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s1;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(501, 1000) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s2;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(1001, 1500) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s3;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(1501, 2000) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s4;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(2001, 2500) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++COMMIT;
++});
++
++$node_publisher->wait_for_catchup($appname);
++
++$result =
++ $node_subscriber->safe_psql('postgres',
++ "SELECT count(*), count(c), count(d = 999) FROM test_tab");
++is($result, qq(1667|1667|1667),
++ 'check data was copied to subscriber in streaming mode and extra columns contain local defaults'
++);
++
++$node_subscriber->stop;
++$node_publisher->stop;
++
++done_testing();
+diff --git a/src/test/xid-64/t/006_zeropage.pl b/src/test/xid-64/t/006_zeropage.pl
+new file mode 100644
+index 00000000000..4b87c90edcd
+--- /dev/null
++++ b/src/test/xid-64/t/006_zeropage.pl
+@@ -0,0 +1,33 @@
++use strict;
++use warnings;
++
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++
++# Check WAL for ZEROPAGE record.
++
++sub command_output
++{
++ my ($cmd) = @_;
++ my ($stdout, $stderr);
++ print("# Running: " . join(" ", @{$cmd}) . "\n");
++ my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
++ return $stdout;
++}
++
++my $node = PostgreSQL::Test::Cluster->new('main');
++$node->init;
++$node->start;
++my $pgdata = $node->data_dir;
++my $xlogfilename0 = $node->safe_psql('postgres',
++ "SELECT pg_walfile_name(pg_current_wal_lsn())");
++#$node->command_like(
++# [ 'pg_waldump', '-S', "$pgdata/pg_wal/$xlogfilename0" ],
++# qr/ZEROPAGE/,
++# 'pg_waldump prints start timestamp');
++my $wd_output = command_output(
++ [ 'pg_waldump', "$pgdata/pg_wal/$xlogfilename0" ]);
++ok($wd_output =~ qr/ZEROPAGE page 0/, "ZEROPAGE found");
++
++done_testing();
+diff --git a/src/test/xid-64/t/007_first_multi.pl b/src/test/xid-64/t/007_first_multi.pl
+new file mode 100644
+index 00000000000..eca2c39af9e
+--- /dev/null
++++ b/src/test/xid-64/t/007_first_multi.pl
+@@ -0,0 +1,83 @@
++# Test for pages with first tuple has xmax multi
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++
++sub test_multixact
++{
++ my ($primary, $standby, $test_name) = @_;
++
++ $primary->safe_psql('postgres', q{
++ CREATE TABLE t (id INT, data TEXT, CONSTRAINT t_id_pk PRIMARY KEY(id));
++ INSERT INTO t SELECT 1, repeat('a', 1000);
++ });
++
++ my %psql = (
++ '1' => $primary->background_psql('postgres'),
++ '2' => $primary->background_psql('postgres'),
++ );
++
++ # Lock tuples
++ $psql{1}->query_safe(q(
++ BEGIN;
++ SELECT * FROM t FOR KEY SHARE;
++ ));
++
++ $psql{2}->query_safe(q(
++ BEGIN;
++ SELECT * FROM t FOR KEY SHARE;
++ ));
++
++ # Repeat update until we get a new page with one tuple
++ my $res;
++ my $guard = 0;
++
++ do {
++ $res = $primary->safe_psql('postgres', q{
++ UPDATE t SET data = repeat('a', 1000) RETURNING ctid;
++ });
++ # Fail if we already write around 64k and still have no new page.
++ fail("creating second page") if (++$guard == 64);
++ } until ($res eq "(1,1)");
++
++ $psql{1}->quit;
++ $psql{2}->quit;
++ $primary->wait_for_catchup($standby);
++
++ # Check results
++ my $query = q{
++ SELECT xmax, ctid, id, data = repeat('a', 1000) as data FROM t;
++ };
++ my $res_primary = $primary->safe_psql('postgres', $query);
++ my $res_standby = $standby->safe_psql('postgres', $query);
++
++ is($res_primary, $res_standby, "rows are the same in test $test_name");
++}
++
++# We should run test for full_page_writes on and off.
++foreach ('true', 'false') {
++ # Create primary
++ my $primary = PostgreSQL::Test::Cluster->new("master_$_");
++ $primary->init(allows_streaming => 1);
++ $primary->append_conf('postgresql.conf', "full_page_writes = $_");
++ $primary->start;
++
++ # Take backup
++ my $backup_name = "my_backup_$_";
++ $primary->backup($backup_name);
++
++ # Create standby from backup
++ my $standby = PostgreSQL::Test::Cluster->new("standby_$_");
++ $standby->init_from_backup($primary, $backup_name, has_streaming => 1);
++ $standby->start;
++
++ # Check
++ test_multixact($primary, $standby, "with FPW $_");
++
++ $standby->stop();
++ $primary->stop();
++}
++
++done_testing();
+diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
+index 2d4c870423a..096d2251472 100644
+--- a/src/tools/pgindent/typedefs.list
++++ b/src/tools/pgindent/typedefs.list
+@@ -3583,8 +3583,8 @@ intset_node
+ intvKEY
+ io_callback_fn
+ io_stat_col
+-itemIdCompact
+-itemIdCompactData
++ItemIdCompact
++ItemIdCompactData
+ iterator
+ jmp_buf
+ join_search_hook_type
+--
+2.47.1
+
diff --git a/baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0001-Use-64-bit-format-output-for-multixact-offsets.patch b/baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0001-Use-64-bit-format-output-for-multixact-offsets.patch
new file mode 100644
index 00000000000..52886e98ca4
--- /dev/null
+++ b/baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0001-Use-64-bit-format-output-for-multixact-offsets.patch
@@ -0,0 +1,203 @@
+From cc588f091a2c1970849a6e341ca1a8a79fc1a935 Mon Sep 17 00:00:00 2001
+From: Maxim Orlov <orlovmg@gmail.com>
+Date: Wed, 7 Aug 2024 16:35:22 +0300
+Subject: [PATCH v3 1/3] Use 64-bit format output for multixact offsets
+
+Author: Maxim Orlov <orlovmg@gmail.com>
+---
+ src/backend/access/rmgrdesc/mxactdesc.c | 9 ++++----
+ src/backend/access/rmgrdesc/xlogdesc.c | 4 ++--
+ src/backend/access/transam/multixact.c | 26 +++++++++++++----------
+ src/backend/access/transam/xlogrecovery.c | 5 +++--
+ src/bin/pg_controldata/pg_controldata.c | 4 ++--
+ src/bin/pg_resetwal/pg_resetwal.c | 8 +++----
+ 6 files changed, 31 insertions(+), 25 deletions(-)
+
+diff --git a/src/backend/access/rmgrdesc/mxactdesc.c b/src/backend/access/rmgrdesc/mxactdesc.c
+index 3e8ad4d5ef..1b486de38c 100644
+--- a/src/backend/access/rmgrdesc/mxactdesc.c
++++ b/src/backend/access/rmgrdesc/mxactdesc.c
+@@ -65,8 +65,8 @@ multixact_desc(StringInfo buf, XLogReaderState *record)
+ xl_multixact_create *xlrec = (xl_multixact_create *) rec;
+ int i;
+
+- appendStringInfo(buf, "%u offset %u nmembers %d: ", xlrec->mid,
+- xlrec->moff, xlrec->nmembers);
++ appendStringInfo(buf, "%u offset %llu nmembers %d: ", xlrec->mid,
++ (unsigned long long) xlrec->moff, xlrec->nmembers);
+ for (i = 0; i < xlrec->nmembers; i++)
+ out_member(buf, &xlrec->members[i]);
+ }
+@@ -74,9 +74,10 @@ multixact_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_multixact_truncate *xlrec = (xl_multixact_truncate *) rec;
+
+- appendStringInfo(buf, "offsets [%u, %u), members [%u, %u)",
++ appendStringInfo(buf, "offsets [%u, %u), members [%llu, %llu)",
+ xlrec->startTruncOff, xlrec->endTruncOff,
+- xlrec->startTruncMemb, xlrec->endTruncMemb);
++ (unsigned long long) xlrec->startTruncMemb,
++ (unsigned long long) xlrec->endTruncMemb);
+ }
+ }
+
+diff --git a/src/backend/access/rmgrdesc/xlogdesc.c b/src/backend/access/rmgrdesc/xlogdesc.c
+index 363294d623..aaa19c81c8 100644
+--- a/src/backend/access/rmgrdesc/xlogdesc.c
++++ b/src/backend/access/rmgrdesc/xlogdesc.c
+@@ -66,7 +66,7 @@ xlog_desc(StringInfo buf, XLogReaderState *record)
+ CheckPoint *checkpoint = (CheckPoint *) rec;
+
+ appendStringInfo(buf, "redo %X/%X; "
+- "tli %u; prev tli %u; fpw %s; wal_level %s; xid %u:%u; oid %u; multi %u; offset %u; "
++ "tli %u; prev tli %u; fpw %s; wal_level %s; xid %u:%u; oid %u; multi %u; offset %llu; "
+ "oldest xid %u in DB %u; oldest multi %u in DB %u; "
+ "oldest/newest commit timestamp xid: %u/%u; "
+ "oldest running xid %u; %s",
+@@ -79,7 +79,7 @@ xlog_desc(StringInfo buf, XLogReaderState *record)
+ XidFromFullTransactionId(checkpoint->nextXid),
+ checkpoint->nextOid,
+ checkpoint->nextMulti,
+- checkpoint->nextMultiOffset,
++ (unsigned long long) checkpoint->nextMultiOffset,
+ checkpoint->oldestXid,
+ checkpoint->oldestXidDB,
+ checkpoint->oldestMulti,
+diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
+index 8c37d7eba7..ab90912ed3 100644
+--- a/src/backend/access/transam/multixact.c
++++ b/src/backend/access/transam/multixact.c
+@@ -1264,7 +1264,8 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+
+ LWLockRelease(MultiXactGenLock);
+
+- debug_elog4(DEBUG2, "GetNew: returning %u offset %u", result, *offset);
++ debug_elog4(DEBUG2, "GetNew: returning %u offset %llu", result,
++ (unsigned long long) *offset);
+ return result;
+ }
+
+@@ -2293,8 +2294,9 @@ MultiXactGetCheckptMulti(bool is_shutdown,
+ LWLockRelease(MultiXactGenLock);
+
+ debug_elog6(DEBUG2,
+- "MultiXact: checkpoint is nextMulti %u, nextOffset %u, oldestMulti %u in DB %u",
+- *nextMulti, *nextMultiOffset, *oldestMulti, *oldestMultiDB);
++ "MultiXact: checkpoint is nextMulti %u, nextOffset %llu, oldestMulti %u in DB %u",
++ *nextMulti, (unsigned long long) *nextMultiOffset, *oldestMulti,
++ *oldestMultiDB);
+ }
+
+ /*
+@@ -2328,8 +2330,8 @@ void
+ MultiXactSetNextMXact(MultiXactId nextMulti,
+ MultiXactOffset nextMultiOffset)
+ {
+- debug_elog4(DEBUG2, "MultiXact: setting next multi to %u offset %u",
+- nextMulti, nextMultiOffset);
++ debug_elog4(DEBUG2, "MultiXact: setting next multi to %u offset %llu",
++ nextMulti, (unsigned long long) nextMultiOffset);
+ LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
+ MultiXactState->nextMXact = nextMulti;
+ MultiXactState->nextOffset = nextMultiOffset;
+@@ -2519,8 +2521,8 @@ MultiXactAdvanceNextMXact(MultiXactId minMulti,
+ }
+ if (MultiXactOffsetPrecedes(MultiXactState->nextOffset, minMultiOffset))
+ {
+- debug_elog3(DEBUG2, "MultiXact: setting next offset to %u",
+- minMultiOffset);
++ debug_elog3(DEBUG2, "MultiXact: setting next offset to %llu",
++ (unsigned long long) minMultiOffset);
+ MultiXactState->nextOffset = minMultiOffset;
+ }
+ LWLockRelease(MultiXactGenLock);
+@@ -3211,11 +3213,12 @@ TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
+
+ elog(DEBUG1, "performing multixact truncation: "
+ "offsets [%u, %u), offsets segments [%llx, %llx), "
+- "members [%u, %u), members segments [%llx, %llx)",
++ "members [%llu, %llu), members segments [%llx, %llx)",
+ oldestMulti, newOldestMulti,
+ (unsigned long long) MultiXactIdToOffsetSegment(oldestMulti),
+ (unsigned long long) MultiXactIdToOffsetSegment(newOldestMulti),
+- oldestOffset, newOldestOffset,
++ (unsigned long long) oldestOffset,
++ (unsigned long long) newOldestOffset,
+ (unsigned long long) MXOffsetToMemberSegment(oldestOffset),
+ (unsigned long long) MXOffsetToMemberSegment(newOldestOffset));
+
+@@ -3471,11 +3474,12 @@ multixact_redo(XLogReaderState *record)
+
+ elog(DEBUG1, "replaying multixact truncation: "
+ "offsets [%u, %u), offsets segments [%llx, %llx), "
+- "members [%u, %u), members segments [%llx, %llx)",
++ "members [%llu, %llu), members segments [%llx, %llx)",
+ xlrec.startTruncOff, xlrec.endTruncOff,
+ (unsigned long long) MultiXactIdToOffsetSegment(xlrec.startTruncOff),
+ (unsigned long long) MultiXactIdToOffsetSegment(xlrec.endTruncOff),
+- xlrec.startTruncMemb, xlrec.endTruncMemb,
++ (unsigned long long) xlrec.startTruncMemb,
++ (unsigned long long) xlrec.endTruncMemb,
+ (unsigned long long) MXOffsetToMemberSegment(xlrec.startTruncMemb),
+ (unsigned long long) MXOffsetToMemberSegment(xlrec.endTruncMemb));
+
+diff --git a/src/backend/access/transam/xlogrecovery.c b/src/backend/access/transam/xlogrecovery.c
+index 178491f6f5..0c5980a436 100644
+--- a/src/backend/access/transam/xlogrecovery.c
++++ b/src/backend/access/transam/xlogrecovery.c
+@@ -877,8 +877,9 @@ InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr,
+ U64FromFullTransactionId(checkPoint.nextXid),
+ checkPoint.nextOid)));
+ ereport(DEBUG1,
+- (errmsg_internal("next MultiXactId: %u; next MultiXactOffset: %u",
+- checkPoint.nextMulti, checkPoint.nextMultiOffset)));
++ (errmsg_internal("next MultiXactId: %u; next MultiXactOffset: %llu",
++ checkPoint.nextMulti,
++ (unsigned long long) checkPoint.nextMultiOffset)));
+ ereport(DEBUG1,
+ (errmsg_internal("oldest unfrozen transaction ID: %u, in database %u",
+ checkPoint.oldestXid, checkPoint.oldestXidDB)));
+diff --git a/src/bin/pg_controldata/pg_controldata.c b/src/bin/pg_controldata/pg_controldata.c
+index 93a05d80ca..43b6727570 100644
+--- a/src/bin/pg_controldata/pg_controldata.c
++++ b/src/bin/pg_controldata/pg_controldata.c
+@@ -253,8 +253,8 @@ main(int argc, char *argv[])
+ ControlFile->checkPointCopy.nextOid);
+ printf(_("Latest checkpoint's NextMultiXactId: %u\n"),
+ ControlFile->checkPointCopy.nextMulti);
+- printf(_("Latest checkpoint's NextMultiOffset: %u\n"),
+- ControlFile->checkPointCopy.nextMultiOffset);
++ printf(_("Latest checkpoint's NextMultiOffset: %llu\n"),
++ (unsigned long long) ControlFile->checkPointCopy.nextMultiOffset);
+ printf(_("Latest checkpoint's oldestXID: %u\n"),
+ ControlFile->checkPointCopy.oldestXid);
+ printf(_("Latest checkpoint's oldestXID's DB: %u\n"),
+diff --git a/src/bin/pg_resetwal/pg_resetwal.c b/src/bin/pg_resetwal/pg_resetwal.c
+index e9dcb5a6d8..985cd06802 100644
+--- a/src/bin/pg_resetwal/pg_resetwal.c
++++ b/src/bin/pg_resetwal/pg_resetwal.c
+@@ -737,8 +737,8 @@ PrintControlValues(bool guessed)
+ ControlFile.checkPointCopy.nextOid);
+ printf(_("Latest checkpoint's NextMultiXactId: %u\n"),
+ ControlFile.checkPointCopy.nextMulti);
+- printf(_("Latest checkpoint's NextMultiOffset: %u\n"),
+- ControlFile.checkPointCopy.nextMultiOffset);
++ printf(_("Latest checkpoint's NextMultiOffset: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.nextMultiOffset);
+ printf(_("Latest checkpoint's oldestXID: %u\n"),
+ ControlFile.checkPointCopy.oldestXid);
+ printf(_("Latest checkpoint's oldestXID's DB: %u\n"),
+@@ -809,8 +809,8 @@ PrintNewControlValues(void)
+
+ if (set_mxoff != -1)
+ {
+- printf(_("NextMultiOffset: %u\n"),
+- ControlFile.checkPointCopy.nextMultiOffset);
++ printf(_("NextMultiOffset: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.nextMultiOffset);
+ }
+
+ if (set_oid != 0)
+--
+2.45.2
+
diff --git a/baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0002-Use-64-bit-multixact-offsets.patch b/baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0002-Use-64-bit-multixact-offsets.patch
new file mode 100644
index 00000000000..11929221053
--- /dev/null
+++ b/baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0002-Use-64-bit-multixact-offsets.patch
@@ -0,0 +1,342 @@
+From 231886c2fafe9eb2d8535c4b590e387085d7aec7 Mon Sep 17 00:00:00 2001
+From: Maxim Orlov <m.orlov@postgrespro.ru>
+Date: Wed, 6 Mar 2024 11:11:33 +0300
+Subject: [PATCH v3 2/3] Use 64-bit multixact offsets.
+
+Author: Maxim Orlov <orlovmg@gmail.com>
+---
+ src/backend/access/transam/multixact.c | 172 +------------------------
+ src/bin/pg_resetwal/pg_resetwal.c | 2 +-
+ src/bin/pg_resetwal/t/001_basic.pl | 2 +-
+ src/include/access/multixact.h | 2 +-
+ src/include/c.h | 2 +-
+ 5 files changed, 11 insertions(+), 169 deletions(-)
+
+diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
+index ab90912ed3..c51e03e832 100644
+--- a/src/backend/access/transam/multixact.c
++++ b/src/backend/access/transam/multixact.c
+@@ -96,14 +96,6 @@
+ /*
+ * Defines for MultiXactOffset page sizes. A page is the same BLCKSZ as is
+ * used everywhere else in Postgres.
+- *
+- * Note: because MultiXactOffsets are 32 bits and wrap around at 0xFFFFFFFF,
+- * MultiXact page numbering also wraps around at
+- * 0xFFFFFFFF/MULTIXACT_OFFSETS_PER_PAGE, and segment numbering at
+- * 0xFFFFFFFF/MULTIXACT_OFFSETS_PER_PAGE/SLRU_PAGES_PER_SEGMENT. We need
+- * take no explicit notice of that fact in this module, except when comparing
+- * segment and page numbers in TruncateMultiXact (see
+- * MultiXactOffsetPagePrecedes).
+ */
+
+ /* We need four bytes per offset */
+@@ -272,9 +264,6 @@ typedef struct MultiXactStateData
+ MultiXactId multiStopLimit;
+ MultiXactId multiWrapLimit;
+
+- /* support for members anti-wraparound measures */
+- MultiXactOffset offsetStopLimit; /* known if oldestOffsetKnown */
+-
+ /*
+ * This is used to sleep until a multixact offset is written when we want
+ * to create the next one.
+@@ -409,8 +398,6 @@ static bool MultiXactOffsetPrecedes(MultiXactOffset offset1,
+ MultiXactOffset offset2);
+ static void ExtendMultiXactOffset(MultiXactId multi);
+ static void ExtendMultiXactMember(MultiXactOffset offset, int nmembers);
+-static bool MultiXactOffsetWouldWrap(MultiXactOffset boundary,
+- MultiXactOffset start, uint32 distance);
+ static bool SetOffsetVacuumLimit(bool is_startup);
+ static bool find_multixact_start(MultiXactId multi, MultiXactOffset *result);
+ static void WriteMZeroPageXlogRec(int64 pageno, uint8 info);
+@@ -1164,78 +1151,6 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+ else
+ *offset = nextOffset;
+
+- /*----------
+- * Protect against overrun of the members space as well, with the
+- * following rules:
+- *
+- * If we're past offsetStopLimit, refuse to generate more multis.
+- * If we're close to offsetStopLimit, emit a warning.
+- *
+- * Arbitrarily, we start emitting warnings when we're 20 segments or less
+- * from offsetStopLimit.
+- *
+- * Note we haven't updated the shared state yet, so if we fail at this
+- * point, the multixact ID we grabbed can still be used by the next guy.
+- *
+- * Note that there is no point in forcing autovacuum runs here: the
+- * multixact freeze settings would have to be reduced for that to have any
+- * effect.
+- *----------
+- */
+-#define OFFSET_WARN_SEGMENTS 20
+- if (MultiXactState->oldestOffsetKnown &&
+- MultiXactOffsetWouldWrap(MultiXactState->offsetStopLimit, nextOffset,
+- nmembers))
+- {
+- /* see comment in the corresponding offsets wraparound case */
+- SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+-
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("multixact \"members\" limit exceeded"),
+- errdetail_plural("This command would create a multixact with %u members, but the remaining space is only enough for %u member.",
+- "This command would create a multixact with %u members, but the remaining space is only enough for %u members.",
+- MultiXactState->offsetStopLimit - nextOffset - 1,
+- nmembers,
+- MultiXactState->offsetStopLimit - nextOffset - 1),
+- errhint("Execute a database-wide VACUUM in database with OID %u with reduced \"vacuum_multixact_freeze_min_age\" and \"vacuum_multixact_freeze_table_age\" settings.",
+- MultiXactState->oldestMultiXactDB)));
+- }
+-
+- /*
+- * Check whether we should kick autovacuum into action, to prevent members
+- * wraparound. NB we use a much larger window to trigger autovacuum than
+- * just the warning limit. The warning is just a measure of last resort -
+- * this is in line with GetNewTransactionId's behaviour.
+- */
+- if (!MultiXactState->oldestOffsetKnown ||
+- (MultiXactState->nextOffset - MultiXactState->oldestOffset
+- > MULTIXACT_MEMBER_SAFE_THRESHOLD))
+- {
+- /*
+- * To avoid swamping the postmaster with signals, we issue the autovac
+- * request only when crossing a segment boundary. With default
+- * compilation settings that's roughly after 50k members. This still
+- * gives plenty of chances before we get into real trouble.
+- */
+- if ((MXOffsetToMemberPage(nextOffset) / SLRU_PAGES_PER_SEGMENT) !=
+- (MXOffsetToMemberPage(nextOffset + nmembers) / SLRU_PAGES_PER_SEGMENT))
+- SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+- }
+-
+- if (MultiXactState->oldestOffsetKnown &&
+- MultiXactOffsetWouldWrap(MultiXactState->offsetStopLimit,
+- nextOffset,
+- nmembers + MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT * OFFSET_WARN_SEGMENTS))
+- ereport(WARNING,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg_plural("database with OID %u must be vacuumed before %d more multixact member is used",
+- "database with OID %u must be vacuumed before %d more multixact members are used",
+- MultiXactState->offsetStopLimit - nextOffset + nmembers,
+- MultiXactState->oldestMultiXactDB,
+- MultiXactState->offsetStopLimit - nextOffset + nmembers),
+- errhint("Execute a database-wide VACUUM in that database with reduced \"vacuum_multixact_freeze_min_age\" and \"vacuum_multixact_freeze_table_age\" settings.")));
+-
+ ExtendMultiXactMember(nextOffset, nmembers);
+
+ /*
+@@ -1976,7 +1891,7 @@ MultiXactShmemInit(void)
+ "pg_multixact/offsets", LWTRANCHE_MULTIXACTOFFSET_BUFFER,
+ LWTRANCHE_MULTIXACTOFFSET_SLRU,
+ SYNC_HANDLER_MULTIXACT_OFFSET,
+- false);
++ true);
+ SlruPagePrecedesUnitTests(MultiXactOffsetCtl, MULTIXACT_OFFSETS_PER_PAGE);
+ SimpleLruInit(MultiXactMemberCtl,
+ "multixact_member", multixact_member_buffers, 0,
+@@ -2721,8 +2636,6 @@ SetOffsetVacuumLimit(bool is_startup)
+ MultiXactOffset nextOffset;
+ bool oldestOffsetKnown = false;
+ bool prevOldestOffsetKnown;
+- MultiXactOffset offsetStopLimit = 0;
+- MultiXactOffset prevOffsetStopLimit;
+
+ /*
+ * NB: Have to prevent concurrent truncation, we might otherwise try to
+@@ -2737,7 +2650,6 @@ SetOffsetVacuumLimit(bool is_startup)
+ nextOffset = MultiXactState->nextOffset;
+ prevOldestOffsetKnown = MultiXactState->oldestOffsetKnown;
+ prevOldestOffset = MultiXactState->oldestOffset;
+- prevOffsetStopLimit = MultiXactState->offsetStopLimit;
+ Assert(MultiXactState->finishedStartup);
+ LWLockRelease(MultiXactGenLock);
+
+@@ -2768,11 +2680,7 @@ SetOffsetVacuumLimit(bool is_startup)
+ oldestOffsetKnown =
+ find_multixact_start(oldestMultiXactId, &oldestOffset);
+
+- if (oldestOffsetKnown)
+- ereport(DEBUG1,
+- (errmsg_internal("oldest MultiXactId member is at offset %u",
+- oldestOffset)));
+- else
++ if (!oldestOffsetKnown)
+ ereport(LOG,
+ (errmsg("MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %u does not exist on disk",
+ oldestMultiXactId)));
+@@ -2785,24 +2693,7 @@ SetOffsetVacuumLimit(bool is_startup)
+ * overrun of old data in the members SLRU area. We can only do so if the
+ * oldest offset is known though.
+ */
+- if (oldestOffsetKnown)
+- {
+- /* move back to start of the corresponding segment */
+- offsetStopLimit = oldestOffset - (oldestOffset %
+- (MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT));
+-
+- /* always leave one segment before the wraparound point */
+- offsetStopLimit -= (MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT);
+-
+- if (!prevOldestOffsetKnown && !is_startup)
+- ereport(LOG,
+- (errmsg("MultiXact member wraparound protections are now enabled")));
+-
+- ereport(DEBUG1,
+- (errmsg_internal("MultiXact member stop limit is now %u based on MultiXact %u",
+- offsetStopLimit, oldestMultiXactId)));
+- }
+- else if (prevOldestOffsetKnown)
++ if (prevOldestOffsetKnown)
+ {
+ /*
+ * If we failed to get the oldest offset this time, but we have a
+@@ -2812,14 +2703,12 @@ SetOffsetVacuumLimit(bool is_startup)
+ */
+ oldestOffset = prevOldestOffset;
+ oldestOffsetKnown = true;
+- offsetStopLimit = prevOffsetStopLimit;
+ }
+
+ /* Install the computed values */
+ LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
+ MultiXactState->oldestOffset = oldestOffset;
+ MultiXactState->oldestOffsetKnown = oldestOffsetKnown;
+- MultiXactState->offsetStopLimit = offsetStopLimit;
+ LWLockRelease(MultiXactGenLock);
+
+ /*
+@@ -2829,54 +2718,6 @@ SetOffsetVacuumLimit(bool is_startup)
+ (nextOffset - oldestOffset > MULTIXACT_MEMBER_SAFE_THRESHOLD);
+ }
+
+-/*
+- * Return whether adding "distance" to "start" would move past "boundary".
+- *
+- * We use this to determine whether the addition is "wrapping around" the
+- * boundary point, hence the name. The reason we don't want to use the regular
+- * 2^31-modulo arithmetic here is that we want to be able to use the whole of
+- * the 2^32-1 space here, allowing for more multixacts than would fit
+- * otherwise.
+- */
+-static bool
+-MultiXactOffsetWouldWrap(MultiXactOffset boundary, MultiXactOffset start,
+- uint32 distance)
+-{
+- MultiXactOffset finish;
+-
+- /*
+- * Note that offset number 0 is not used (see GetMultiXactIdMembers), so
+- * if the addition wraps around the UINT_MAX boundary, skip that value.
+- */
+- finish = start + distance;
+- if (finish < start)
+- finish++;
+-
+- /*-----------------------------------------------------------------------
+- * When the boundary is numerically greater than the starting point, any
+- * value numerically between the two is not wrapped:
+- *
+- * <----S----B---->
+- * [---) = F wrapped past B (and UINT_MAX)
+- * [---) = F not wrapped
+- * [----] = F wrapped past B
+- *
+- * When the boundary is numerically less than the starting point (i.e. the
+- * UINT_MAX wraparound occurs somewhere in between) then all values in
+- * between are wrapped:
+- *
+- * <----B----S---->
+- * [---) = F not wrapped past B (but wrapped past UINT_MAX)
+- * [---) = F wrapped past B (and UINT_MAX)
+- * [----] = F not wrapped
+- *-----------------------------------------------------------------------
+- */
+- if (start < boundary)
+- return finish >= boundary || finish < start;
+- else
+- return finish >= boundary && finish < start;
+-}
+-
+ /*
+ * Find the starting offset of the given MultiXactId.
+ *
+@@ -2998,8 +2839,9 @@ MultiXactMemberFreezeThreshold(void)
+ * we try to eliminate from the system is based on how far we are past
+ * MULTIXACT_MEMBER_SAFE_THRESHOLD.
+ */
+- fraction = (double) (members - MULTIXACT_MEMBER_SAFE_THRESHOLD) /
+- (MULTIXACT_MEMBER_DANGER_THRESHOLD - MULTIXACT_MEMBER_SAFE_THRESHOLD);
++ fraction = (double) (members - MULTIXACT_MEMBER_SAFE_THRESHOLD);
++ fraction /= (double) (MULTIXACT_MEMBER_DANGER_THRESHOLD - MULTIXACT_MEMBER_SAFE_THRESHOLD);
++
+ victim_multixacts = multixacts * fraction;
+
+ /* fraction could be > 1.0, but lowest possible freeze age is zero */
+@@ -3345,7 +3187,7 @@ MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
+ static bool
+ MultiXactOffsetPrecedes(MultiXactOffset offset1, MultiXactOffset offset2)
+ {
+- int32 diff = (int32) (offset1 - offset2);
++ int64 diff = (int64) (offset1 - offset2);
+
+ return (diff < 0);
+ }
+diff --git a/src/bin/pg_resetwal/pg_resetwal.c b/src/bin/pg_resetwal/pg_resetwal.c
+index 985cd06802..1af2ce4b93 100644
+--- a/src/bin/pg_resetwal/pg_resetwal.c
++++ b/src/bin/pg_resetwal/pg_resetwal.c
+@@ -264,7 +264,7 @@ main(int argc, char *argv[])
+
+ case 'O':
+ errno = 0;
+- set_mxoff = strtoul(optarg, &endptr, 0);
++ set_mxoff = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-O");
+diff --git a/src/bin/pg_resetwal/t/001_basic.pl b/src/bin/pg_resetwal/t/001_basic.pl
+index 9829e48106..f8a8eef44d 100644
+--- a/src/bin/pg_resetwal/t/001_basic.pl
++++ b/src/bin/pg_resetwal/t/001_basic.pl
+@@ -206,7 +206,7 @@ push @cmd,
+ sprintf("%d,%d", hex($files[0]) == 0 ? 3 : hex($files[0]), hex($files[-1]));
+
+ @files = get_slru_files('pg_multixact/offsets');
+-$mult = 32 * $blcksz / 4;
++$mult = 32 * $blcksz / 8;
+ # -m argument is "new,old"
+ push @cmd, '-m',
+ sprintf("%d,%d",
+diff --git a/src/include/access/multixact.h b/src/include/access/multixact.h
+index 7ffd256c74..90583634ec 100644
+--- a/src/include/access/multixact.h
++++ b/src/include/access/multixact.h
+@@ -27,7 +27,7 @@
+
+ #define MultiXactIdIsValid(multi) ((multi) != InvalidMultiXactId)
+
+-#define MaxMultiXactOffset ((MultiXactOffset) 0xFFFFFFFF)
++#define MaxMultiXactOffset UINT64CONST(0xFFFFFFFFFFFFFFFF)
+
+ /*
+ * Possible multixact lock modes ("status"). The first four modes are for
+diff --git a/src/include/c.h b/src/include/c.h
+index dc1841346c..ccfb82b478 100644
+--- a/src/include/c.h
++++ b/src/include/c.h
+@@ -661,7 +661,7 @@ typedef uint32 SubTransactionId;
+ /* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
+ typedef TransactionId MultiXactId;
+
+-typedef uint32 MultiXactOffset;
++typedef uint64 MultiXactOffset;
+
+ typedef uint32 CommandId;
+
+--
+2.45.2
+
diff --git a/baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0003-Make-pg_upgrade-convert-multixact-offsets.patch b/baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0003-Make-pg_upgrade-convert-multixact-offsets.patch
new file mode 100644
index 00000000000..c01e270f2d7
--- /dev/null
+++ b/baloo/patches/func/pg18xid64v56/0010-MXIDOFF64-v4-0003-Make-pg_upgrade-convert-multixact-offsets.patch
@@ -0,0 +1,486 @@
+From 8501159fda6fac4465575a0c1bfd94bafa3c52ac Mon Sep 17 00:00:00 2001
+From: Evgeny Voropaev <evorop@gmail.com>
+Date: Mon, 23 Sep 2024 17:34:08 +0800
+Subject: [PATCH 3/3] Make pg_upgrade convert multixact offsets.
+
+Author: Maxim Orlov <orlovmg@gmail.com>
+Author: Evgeny Voropaev (rebase onto PG18dev) <evgeny.voropaev@tantorlabs.ru>, <evorop@gmail.com>
+---
+ src/bin/pg_upgrade/Makefile | 1 +
+ src/bin/pg_upgrade/meson.build | 1 +
+ src/bin/pg_upgrade/pg_upgrade.c | 29 ++-
+ src/bin/pg_upgrade/pg_upgrade.h | 14 +-
+ src/bin/pg_upgrade/segresize.c | 350 ++++++++++++++++++++++++++++++++
+ 5 files changed, 391 insertions(+), 4 deletions(-)
+ create mode 100644 src/bin/pg_upgrade/segresize.c
+
+diff --git a/src/bin/pg_upgrade/Makefile b/src/bin/pg_upgrade/Makefile
+index f83d2b5d30..70908d63a3 100644
+--- a/src/bin/pg_upgrade/Makefile
++++ b/src/bin/pg_upgrade/Makefile
+@@ -21,6 +21,7 @@ OBJS = \
+ info.o \
+ option.o \
+ parallel.o \
++ segresize.o \
+ pg_upgrade.o \
+ relfilenumber.o \
+ server.o \
+diff --git a/src/bin/pg_upgrade/meson.build b/src/bin/pg_upgrade/meson.build
+index 3d88419674..16f898ba14 100644
+--- a/src/bin/pg_upgrade/meson.build
++++ b/src/bin/pg_upgrade/meson.build
+@@ -10,6 +10,7 @@ pg_upgrade_sources = files(
+ 'info.c',
+ 'option.c',
+ 'parallel.c',
++ 'segresize.c',
+ 'pg_upgrade.c',
+ 'relfilenumber.c',
+ 'server.c',
+diff --git a/src/bin/pg_upgrade/pg_upgrade.c b/src/bin/pg_upgrade/pg_upgrade.c
+index 663235816f..d9d8d0ea78 100644
+--- a/src/bin/pg_upgrade/pg_upgrade.c
++++ b/src/bin/pg_upgrade/pg_upgrade.c
+@@ -750,7 +750,30 @@ copy_xact_xlog_xid(void)
+ if (old_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER &&
+ new_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER)
+ {
+- copy_subdir_files("pg_multixact/offsets", "pg_multixact/offsets");
++ /*
++ * If the old server is before the MULTIXACTOFFSET_FORMATCHANGE_CAT_VER
++ * it must have 32-bit multixid offsets, thus it should be converted.
++ */
++ if (old_cluster.controldata.cat_ver < MULTIXACTOFFSET_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= MULTIXACTOFFSET_FORMATCHANGE_CAT_VER)
++ {
++ uint64 oldest_offset = convert_multixact_offsets();
++
++ if (oldest_offset)
++ {
++ uint64 next_offset = old_cluster.controldata.chkpnt_nxtmxoff;
++
++ /* Handle possible wraparound. */
++ if (next_offset < oldest_offset)
++ next_offset += ((uint64) 1 << 32) - 1;
++
++ next_offset -= oldest_offset - 1;
++ old_cluster.controldata.chkpnt_nxtmxoff = next_offset;
++ }
++ }
++ else
++ copy_subdir_files("pg_multixact/offsets", "pg_multixact/offsets");
++
+ copy_subdir_files("pg_multixact/members", "pg_multixact/members");
+
+ prep_status("Setting next multixact ID and offset for new cluster");
+@@ -760,9 +783,9 @@ copy_xact_xlog_xid(void)
+ * counters here and the oldest multi present on system.
+ */
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+- "\"%s/pg_resetwal\" -O %u -m %u,%u \"%s\"",
++ "\"%s/pg_resetwal\" -O %llu -m %u,%u \"%s\"",
+ new_cluster.bindir,
+- old_cluster.controldata.chkpnt_nxtmxoff,
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtmxoff,
+ old_cluster.controldata.chkpnt_nxtmulti,
+ old_cluster.controldata.chkpnt_oldstMulti,
+ new_cluster.pgdata);
+diff --git a/src/bin/pg_upgrade/pg_upgrade.h b/src/bin/pg_upgrade/pg_upgrade.h
+index 53f693c2d4..3412469ff3 100644
+--- a/src/bin/pg_upgrade/pg_upgrade.h
++++ b/src/bin/pg_upgrade/pg_upgrade.h
+@@ -114,6 +114,13 @@ extern char *output_files[];
+ */
+ #define MULTIXACT_FORMATCHANGE_CAT_VER 201301231
+
++/*
++ * Swicth from 32-bit to 64-bit for multixid offsets.
++ *
++ * XXX: should be changed to the actual CATALOG_VERSION_NO on commit.
++ */
++#define MULTIXACTOFFSET_FORMATCHANGE_CAT_VER 202409041
++
+ /*
+ * large object chunk size added to pg_controldata,
+ * commit 5f93c37805e7485488480916b4585e098d3cc883
+@@ -230,7 +237,7 @@ typedef struct
+ uint32 chkpnt_nxtepoch;
+ uint32 chkpnt_nxtoid;
+ uint32 chkpnt_nxtmulti;
+- uint32 chkpnt_nxtmxoff;
++ uint64 chkpnt_nxtmxoff;
+ uint32 chkpnt_oldstMulti;
+ uint32 chkpnt_oldstxid;
+ uint32 align;
+@@ -495,6 +502,11 @@ void parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr
+ char *old_tablespace);
+ bool reap_child(bool wait_for_child);
+
++
++/* segresize.c */
++
++uint64 convert_multixact_offsets(void);
++
+ /* task.c */
+
+ typedef void (*UpgradeTaskProcessCB) (DbInfo *dbinfo, PGresult *res, void *arg);
+diff --git a/src/bin/pg_upgrade/segresize.c b/src/bin/pg_upgrade/segresize.c
+new file mode 100644
+index 0000000000..e47c0a2407
+--- /dev/null
++++ b/src/bin/pg_upgrade/segresize.c
+@@ -0,0 +1,350 @@
++/*
++ * segresize.c
++ *
++ * SLRU segment resize utility
++ *
++ * Copyright (c) 2024, PostgreSQL Global Development Group
++ * src/bin/pg_upgrade/segresize.c
++ */
++
++#include "postgres_fe.h"
++
++#include "pg_upgrade.h"
++#include "access/multixact.h"
++
++/* See slru.h */
++#define SLRU_PAGES_PER_SEGMENT 32
++
++/*
++ * Some kind of iterator associated with a particular SLRU segment. The idea is
++ * to specify the segment and page number and then move through the pages.
++ */
++typedef struct SlruSegState
++{
++ char *dir;
++ char *fn;
++ FILE *file;
++ int64 segno;
++ uint64 pageno;
++ bool leading_gap;
++ bool long_segment_names;
++} SlruSegState;
++
++/*
++ * Get SLRU segmen file name from state.
++ *
++ * NOTE: this function should mirror SlruFileName call.
++ */
++static inline char *
++SlruFileName(SlruSegState *state)
++{
++ if (state->long_segment_names)
++ {
++ Assert(state->segno >= 0 &&
++ state->segno <= INT64CONST(0xFFFFFFFFFFFFFFF));
++ return psprintf("%s/%015llX", state->dir, (long long) state->segno);
++ }
++ else
++ {
++ Assert(state->segno >= 0 &&
++ state->segno <= INT64CONST(0xFFFFFF));
++ return psprintf("%s/%04X", state->dir, (unsigned int) state->segno);
++ }
++}
++
++/*
++ * Create SLRU segment file.
++ */
++static void
++create_segment(SlruSegState *state)
++{
++ Assert(state->fn == NULL);
++ Assert(state->file == NULL);
++
++ state->fn = SlruFileName(state);
++ state->file = fopen(state->fn, "wb");
++ if (!state->file)
++ pg_fatal("could not create file \"%s\": %m", state->fn);
++}
++
++/*
++ * Open existing SLRU segment file.
++ */
++static void
++open_segment(SlruSegState *state)
++{
++ Assert(state->fn == NULL);
++ Assert(state->file == NULL);
++
++ state->fn = SlruFileName(state);
++ state->file = fopen(state->fn, "rb");
++ if (!state->file)
++ pg_fatal("could not open file \"%s\": %m", state->fn);
++}
++
++/*
++ * Close SLRU segment file.
++ */
++static void
++close_segment(SlruSegState *state)
++{
++ if (state->file)
++ {
++ fclose(state->file);
++ state->file = NULL;
++ }
++
++ if (state->fn)
++ {
++ pfree(state->fn);
++ state->fn = NULL;
++ }
++}
++
++/*
++ * Read next page from the old 32-bit offset segment file.
++ */
++static int
++read_old_segment_page(SlruSegState *state, void *buf, bool *empty)
++{
++ int len;
++
++ /* Open next segment file, if needed. */
++ if (!state->fn)
++ {
++ if (!state->segno)
++ state->leading_gap = true;
++
++ open_segment(state);
++
++ /* Set position to the needed page. */
++ if (state->pageno > 0 &&
++ fseek(state->file, state->pageno * BLCKSZ, SEEK_SET))
++ {
++ close_segment(state);
++ }
++ }
++
++ if (state->file)
++ {
++ /* Segment file do exists, read page from it. */
++ state->leading_gap = false;
++
++ len = fread(buf, sizeof(char), BLCKSZ, state->file);
++
++ /* Are we done or was there an error? */
++ if (len <= 0)
++ {
++ if (ferror(state->file))
++ pg_fatal("error reading file \"%s\": %m", state->fn);
++
++ if (feof(state->file))
++ {
++ *empty = true;
++ len = -1;
++
++ close_segment(state);
++ }
++ }
++ else
++ *empty = false;
++ }
++ else if (!state->leading_gap)
++ {
++ /* We reached the last segment. */
++ len = -1;
++ *empty = true;
++ }
++ else
++ {
++ /* Skip few first segments if they were frozen and removed. */
++ len = BLCKSZ;
++ *empty = true;
++ }
++
++ if (++state->pageno >= SLRU_PAGES_PER_SEGMENT)
++ {
++ /* Start a new segment. */
++ state->segno++;
++ state->pageno = 0;
++
++ close_segment(state);
++ }
++
++ return len;
++}
++
++/*
++ * Write next page to the new 64-bit offset segment file.
++ */
++static void
++write_new_segment_page(SlruSegState *state, void *buf)
++{
++ /*
++ * Create a new segment file if we still didn't. Creation is
++ * postponed until the first non-empty page is found. This helps
++ * not to create completely empty segments.
++ */
++ if (!state->file)
++ {
++ create_segment(state);
++
++ /* Write zeroes to the previously skipped prefix. */
++ if (state->pageno > 0)
++ {
++ char zerobuf[BLCKSZ] = {0};
++
++ for (int64 i = 0; i < state->pageno; i++)
++ {
++ if (fwrite(zerobuf, sizeof(char), BLCKSZ, state->file) != BLCKSZ)
++ pg_fatal("could not write file \"%s\": %m", state->fn);
++ }
++ }
++ }
++
++ /* Write page to the new segment (if it was created). */
++ if (state->file)
++ {
++ if (fwrite(buf, sizeof(char), BLCKSZ, state->file) != BLCKSZ)
++ pg_fatal("could not write file \"%s\": %m", state->fn);
++ }
++
++ state->pageno++;
++
++ /*
++ * Did we reach the maximum page number? Then close segment file
++ * and create a new one on the next iteration.
++ */
++ if (state->pageno >= SLRU_PAGES_PER_SEGMENT)
++ {
++ state->segno++;
++ state->pageno = 0;
++ close_segment(state);
++ }
++}
++
++/*
++ * Convert pg_multixact/offsets segments and return oldest multi offset.
++ */
++uint64
++convert_multixact_offsets(void)
++{
++ /* See multixact.c */
++#define MULTIXACT_OFFSETS_PER_PAGE_OLD (BLCKSZ / sizeof(uint32))
++#define MULTIXACT_OFFSETS_PER_PAGE (BLCKSZ / sizeof(MultiXactOffset))
++
++ SlruSegState oldseg = {0},
++ newseg = {0};
++ uint32 oldbuf[MULTIXACT_OFFSETS_PER_PAGE_OLD] = {0};
++ MultiXactOffset newbuf[MULTIXACT_OFFSETS_PER_PAGE] = {0};
++ /*
++ * It is much easier to deal with multi wraparound in 64 bitd format. Thus
++ * we use 64 bits for multi-transactions, although they remain 32 bits.
++ */
++ uint64 oldest_multi = old_cluster.controldata.chkpnt_oldstMulti,
++ next_multi = old_cluster.controldata.chkpnt_nxtmulti,
++ multi,
++ old_entry,
++ new_entry;
++ bool found = false;
++ uint64 oldest_offset = 0;
++
++ prep_status("Converting pg_multixact/offsets to 64-bit");
++
++ oldseg.pageno = oldest_multi / MULTIXACT_OFFSETS_PER_PAGE_OLD;
++ oldseg.segno = oldseg.pageno / SLRU_PAGES_PER_SEGMENT;
++ oldseg.pageno %= SLRU_PAGES_PER_SEGMENT;
++ oldseg.dir = psprintf("%s/pg_multixact/offsets", old_cluster.pgdata);
++ oldseg.long_segment_names = false; /* old format XXXX */
++
++ newseg.pageno = oldest_multi / MULTIXACT_OFFSETS_PER_PAGE;
++ newseg.segno = newseg.pageno / SLRU_PAGES_PER_SEGMENT;
++ newseg.pageno %= SLRU_PAGES_PER_SEGMENT;
++ newseg.dir = psprintf("%s/pg_multixact/offsets", new_cluster.pgdata);
++ newseg.long_segment_names = true;
++
++ old_entry = oldest_multi % MULTIXACT_OFFSETS_PER_PAGE_OLD;
++ new_entry = oldest_multi % MULTIXACT_OFFSETS_PER_PAGE;
++
++ if (next_multi < oldest_multi)
++ next_multi += (uint64) 1 << 32; /* wraparound */
++
++ for (multi = oldest_multi; multi < next_multi; old_entry = 0)
++ {
++ int oldlen;
++ bool empty;
++
++ /* Handle possible segment wraparound. */
++ if (oldseg.segno > MaxMultiXactId /
++ MULTIXACT_OFFSETS_PER_PAGE_OLD /
++ SLRU_PAGES_PER_SEGMENT)
++ oldseg.segno = 0;
++
++ /* Read old offset segment. */
++ oldlen = read_old_segment_page(&oldseg, oldbuf, &empty);
++ if (oldlen <= 0 || empty)
++ pg_fatal("cannot read page %llu from file \"%s\": %m",
++ (unsigned long long) oldseg.pageno, oldseg.fn);
++
++ /* Fill possible gap. */
++ if (oldlen < BLCKSZ)
++ memset((char *) oldbuf + oldlen, 0, BLCKSZ - oldlen);
++
++ /* Save oldest multi offset */
++ if (!found)
++ {
++ oldest_offset = oldbuf[old_entry];
++ found = true;
++ }
++
++ /* ... skip wrapped-around invalid multi */
++ if (multi == (uint64) 1 << 32)
++ {
++ Assert(oldseg.segno == 0);
++ Assert(oldseg.pageno == 1);
++ Assert(old_entry == 0);
++
++ multi += FirstMultiXactId;
++ old_entry = FirstMultiXactId;
++ }
++
++ /* Copy entries to the new page. */
++ for (; multi < next_multi && old_entry < MULTIXACT_OFFSETS_PER_PAGE_OLD;
++ multi++, old_entry++)
++ {
++ MultiXactOffset offset = oldbuf[old_entry];
++
++ /* Handle possible offset wraparound. */
++ if (offset < oldest_offset)
++ offset += ((uint64) 1 << 32) - 1;
++
++ /* Subtract oldest_offset, so new offsets will start from 1. */
++ newbuf[new_entry++] = offset - oldest_offset + 1;
++ if (new_entry >= MULTIXACT_OFFSETS_PER_PAGE)
++ {
++ /* Write a new page. */
++ write_new_segment_page(&newseg, newbuf);
++ new_entry = 0;
++ }
++ }
++ }
++
++ /* Write the last incomplete page. */
++ if (new_entry > 0 || oldest_multi == next_multi)
++ {
++ memset(&newbuf[new_entry], 0,
++ sizeof(newbuf[0]) * (MULTIXACT_OFFSETS_PER_PAGE - new_entry));
++ write_new_segment_page(&newseg, newbuf);
++ }
++
++ /* Release resources. */
++ close_segment(&oldseg);
++ close_segment(&newseg);
++
++ pfree(oldseg.dir);
++ pfree(newseg.dir);
++
++ check_ok();
++
++ return oldest_offset;
++}
+--
+2.46.0
+
diff --git a/baloo/patches/func/pg18xid64v56/0020-GUC64-v1-0001-Support-64-bit-integer-GUCs.patch b/baloo/patches/func/pg18xid64v56/0020-GUC64-v1-0001-Support-64-bit-integer-GUCs.patch
new file mode 100644
index 00000000000..9da988d5265
--- /dev/null
+++ b/baloo/patches/func/pg18xid64v56/0020-GUC64-v1-0001-Support-64-bit-integer-GUCs.patch
@@ -0,0 +1,1110 @@
+From 90c541d47a745a32f8a74529b6c1d9d74c6c0922 Mon Sep 17 00:00:00 2001
+From: Maxim Orlov <m.orlov@postgrespro.ru>
+Date: Fri, 11 Mar 2022 11:34:26 +0300
+Subject: [PATCH v1] Support 64-bit integer GUCs
+
+Author: Alexander Korotkov <aekorotkov@gmail.com>
+Author: Teodor Sigaev <teodor@sigaev.ru>
+Author: Nikita Glukhov <n.gluhov@postgrespro.ru>
+Author: Maxim Orlov <orlovmg@gmail.com>
+Author: Pavel Borisov <pashkin.elfe@gmail.com>
+Author: Yura Sokolov <y.sokolov@postgrespro.ru> <funny.falcon@gmail.com>
+Author: Aleksander Alekseev <aleksander@timescale.com>
+Discussion: TODO FIXME
+---
+ src/backend/access/common/reloptions.c | 187 +++++++----
+ src/backend/utils/misc/guc.c | 418 +++++++++++++++++++++++++
+ src/backend/utils/misc/guc_funcs.c | 25 ++
+ src/backend/utils/misc/guc_tables.c | 10 +
+ src/include/access/reloptions.h | 13 +
+ src/include/utils/guc.h | 17 +
+ src/include/utils/guc_tables.h | 19 ++
+ src/include/utils/rel.h | 14 +-
+ 8 files changed, 638 insertions(+), 65 deletions(-)
+
+diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c
+index 49fd35bfc5..62db0d231c 100644
+--- a/src/backend/access/common/reloptions.c
++++ b/src/backend/access/common/reloptions.c
+@@ -258,58 +258,6 @@ static relopt_int intRelOpts[] =
+ },
+ -1, 1, 10000
+ },
+- {
+- {
+- "autovacuum_freeze_min_age",
+- "Minimum age at which VACUUM should freeze a table row, for autovacuum",
+- RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
+- ShareUpdateExclusiveLock
+- },
+- -1, 0, 1000000000
+- },
+- {
+- {
+- "autovacuum_multixact_freeze_min_age",
+- "Minimum multixact age at which VACUUM should freeze a row multixact's, for autovacuum",
+- RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
+- ShareUpdateExclusiveLock
+- },
+- -1, 0, 1000000000
+- },
+- {
+- {
+- "autovacuum_freeze_max_age",
+- "Age at which to autovacuum a table to prevent transaction ID wraparound",
+- RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
+- ShareUpdateExclusiveLock
+- },
+- -1, 100000, 2000000000
+- },
+- {
+- {
+- "autovacuum_multixact_freeze_max_age",
+- "Multixact age at which to autovacuum a table to prevent multixact wraparound",
+- RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
+- ShareUpdateExclusiveLock
+- },
+- -1, 10000, 2000000000
+- },
+- {
+- {
+- "autovacuum_freeze_table_age",
+- "Age at which VACUUM should perform a full table sweep to freeze row versions",
+- RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
+- ShareUpdateExclusiveLock
+- }, -1, 0, 2000000000
+- },
+- {
+- {
+- "autovacuum_multixact_freeze_table_age",
+- "Age of multixact at which VACUUM should perform a full table sweep to freeze row versions",
+- RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
+- ShareUpdateExclusiveLock
+- }, -1, 0, 2000000000
+- },
+ {
+ {
+ "log_autovacuum_min_duration",
+@@ -380,7 +328,66 @@ static relopt_int intRelOpts[] =
+ },
+ -1, 0, 1024
+ },
++ /* list terminator */
++ {{NULL}}
++};
+
++static relopt_int64 int64RelOpts[] =
++{
++ {
++ {
++ "autovacuum_freeze_min_age",
++ "Minimum age at which VACUUM should freeze a table row, for autovacuum",
++ RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
++ ShareUpdateExclusiveLock
++ },
++ INT64CONST(-1), INT64CONST(0), INT64CONST(1000000000)
++ },
++ {
++ {
++ "autovacuum_multixact_freeze_min_age",
++ "Minimum multixact age at which VACUUM should freeze a row multixact's, for autovacuum",
++ RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
++ ShareUpdateExclusiveLock
++ },
++ INT64CONST(-1), INT64CONST(0), INT64CONST(1000000000)
++ },
++ {
++ {
++ "autovacuum_freeze_max_age",
++ "Age at which to autovacuum a table to prevent transaction ID wraparound",
++ RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
++ ShareUpdateExclusiveLock
++ },
++ INT64CONST(-1), INT64CONST(100000), INT64CONST(2000000000)
++ },
++ {
++ {
++ "autovacuum_multixact_freeze_max_age",
++ "Multixact age at which to autovacuum a table to prevent multixact wraparound",
++ RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
++ ShareUpdateExclusiveLock
++ },
++ INT64CONST(-1), INT64CONST(10000), INT64CONST(2000000000)
++ },
++ {
++ {
++ "autovacuum_freeze_table_age",
++ "Age at which VACUUM should perform a full table sweep to freeze row versions",
++ RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
++ ShareUpdateExclusiveLock
++ },
++ INT64CONST(-1), INT64CONST(0), INT64CONST(2000000000)
++ },
++ {
++ {
++ "autovacuum_multixact_freeze_table_age",
++ "Age of multixact at which VACUUM should perform a full table sweep to freeze row versions",
++ RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
++ ShareUpdateExclusiveLock
++ },
++ INT64CONST(-1), INT64CONST(0), INT64CONST(2000000000)
++ },
+ /* list terminator */
+ {{NULL}}
+ };
+@@ -595,6 +602,12 @@ initialize_reloptions(void)
+ intRelOpts[i].gen.lockmode));
+ j++;
+ }
++ for (i = 0; int64RelOpts[i].gen.name; i++)
++ {
++ Assert(DoLockModesConflict(int64RelOpts[i].gen.lockmode,
++ int64RelOpts[i].gen.lockmode));
++ j++;
++ }
+ for (i = 0; realRelOpts[i].gen.name; i++)
+ {
+ Assert(DoLockModesConflict(realRelOpts[i].gen.lockmode,
+@@ -637,6 +650,14 @@ initialize_reloptions(void)
+ j++;
+ }
+
++ for (i = 0; int64RelOpts[i].gen.name; i++)
++ {
++ relOpts[j] = &int64RelOpts[i].gen;
++ relOpts[j]->type = RELOPT_TYPE_INT64;
++ relOpts[j]->namelen = strlen(relOpts[j]->name);
++ j++;
++ }
++
+ for (i = 0; realRelOpts[i].gen.name; i++)
+ {
+ relOpts[j] = &realRelOpts[i].gen;
+@@ -792,6 +813,9 @@ allocate_reloption(bits32 kinds, int type, const char *name, const char *desc,
+ case RELOPT_TYPE_INT:
+ size = sizeof(relopt_int);
+ break;
++ case RELOPT_TYPE_INT64:
++ size = sizeof(relopt_int64);
++ break;
+ case RELOPT_TYPE_REAL:
+ size = sizeof(relopt_real);
+ break;
+@@ -946,6 +970,26 @@ init_real_reloption(bits32 kinds, const char *name, const char *desc,
+ return newoption;
+ }
+
++/*
++ * add_int64_reloption
++ * Add a new 64-bit integer reloption
++ */
++void
++add_int64_reloption(bits32 kinds, const char *name, char *desc,
++ int64 default_val, int64 min_val, int64 max_val,
++ LOCKMODE lockmode)
++{
++ relopt_int64 *newoption;
++
++ newoption = (relopt_int64 *) allocate_reloption(kinds, RELOPT_TYPE_INT64,
++ name, desc, lockmode);
++ newoption->default_val = default_val;
++ newoption->min = min_val;
++ newoption->max = max_val;
++
++ add_reloption((relopt_gen *) newoption);
++}
++
+ /*
+ * add_real_reloption
+ * Add a new float reloption
+@@ -1617,6 +1661,28 @@ parse_one_reloption(relopt_value *option, char *text_str, int text_len,
+ optint->min, optint->max)));
+ }
+ break;
++ case RELOPT_TYPE_INT64:
++ {
++ relopt_int64 *optint = (relopt_int64 *) option->gen;
++
++ parsed = parse_int64(value, &option->values.int64_val, 0, NULL);
++ if (validate && !parsed)
++ ereport(ERROR,
++ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
++ errmsg("invalid value for 64-bit integer option \"%s\": %s",
++ option->gen->name, value)));
++ if (validate && (option->values.int64_val < optint->min ||
++ option->values.int64_val > optint->max))
++ ereport(ERROR,
++ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
++ errmsg("value %s out of bounds for option \"%s\"",
++ value, option->gen->name),
++ errdetail("Valid values are between \"%lld"
++ "\" and \"%lld\".",
++ (long long ) optint->min,
++ (long long) optint->max)));
++ }
++ break;
+ case RELOPT_TYPE_REAL:
+ {
+ relopt_real *optreal = (relopt_real *) option->gen;
+@@ -1772,6 +1838,11 @@ fillRelOptions(void *rdopts, Size basesize,
+ options[i].values.int_val :
+ ((relopt_int *) options[i].gen)->default_val;
+ break;
++ case RELOPT_TYPE_INT64:
++ *(int64 *) itempos = options[i].isset ?
++ options[i].values.int64_val :
++ ((relopt_int64 *) options[i].gen)->default_val;
++ break;
+ case RELOPT_TYPE_REAL:
+ *(double *) itempos = options[i].isset ?
+ options[i].values.real_val :
+@@ -1849,17 +1920,17 @@ default_reloptions(Datum reloptions, bool validate, relopt_kind kind)
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)},
+ {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)},
+- {"autovacuum_freeze_min_age", RELOPT_TYPE_INT,
++ {"autovacuum_freeze_min_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)},
+- {"autovacuum_freeze_max_age", RELOPT_TYPE_INT,
++ {"autovacuum_freeze_max_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)},
+- {"autovacuum_freeze_table_age", RELOPT_TYPE_INT,
++ {"autovacuum_freeze_table_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)},
+- {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT,
++ {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)},
+- {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT,
++ {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)},
+- {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT,
++ {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)},
+ {"log_autovacuum_min_duration", RELOPT_TYPE_INT,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)},
+diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
+index 13527fc258..2798c04a54 100644
+--- a/src/backend/utils/misc/guc.c
++++ b/src/backend/utils/misc/guc.c
+@@ -262,6 +262,8 @@ static bool call_bool_check_hook(struct config_bool *conf, bool *newval,
+ void **extra, GucSource source, int elevel);
+ static bool call_int_check_hook(struct config_int *conf, int *newval,
+ void **extra, GucSource source, int elevel);
++static bool call_int64_check_hook(struct config_int64 *conf, int64 *newval,
++ void **extra, GucSource source, int elevel);
+ static bool call_real_check_hook(struct config_real *conf, double *newval,
+ void **extra, GucSource source, int elevel);
+ static bool call_string_check_hook(struct config_string *conf, char **newval,
+@@ -759,6 +761,10 @@ extra_field_used(struct config_generic *gconf, void *extra)
+ if (extra == ((struct config_int *) gconf)->reset_extra)
+ return true;
+ break;
++ case PGC_INT64:
++ if (extra == ((struct config_int64 *) gconf)->reset_extra)
++ return true;
++ break;
+ case PGC_REAL:
+ if (extra == ((struct config_real *) gconf)->reset_extra)
+ return true;
+@@ -820,6 +826,10 @@ set_stack_value(struct config_generic *gconf, config_var_value *val)
+ val->val.intval =
+ *((struct config_int *) gconf)->variable;
+ break;
++ case PGC_INT64:
++ val->val.int64val =
++ *((struct config_int64 *) gconf)->variable;
++ break;
+ case PGC_REAL:
+ val->val.realval =
+ *((struct config_real *) gconf)->variable;
+@@ -848,6 +858,7 @@ discard_stack_value(struct config_generic *gconf, config_var_value *val)
+ {
+ case PGC_BOOL:
+ case PGC_INT:
++ case PGC_INT64:
+ case PGC_REAL:
+ case PGC_ENUM:
+ /* no need to do anything */
+@@ -936,6 +947,14 @@ build_guc_variables(void)
+ num_vars++;
+ }
+
++ for (i = 0; ConfigureNamesInt64[i].gen.name; i++)
++ {
++ struct config_int64 *conf = &ConfigureNamesInt64[i];
++
++ conf->gen.vartype = PGC_INT64;
++ num_vars++;
++ }
++
+ for (i = 0; ConfigureNamesReal[i].gen.name; i++)
+ {
+ struct config_real *conf = &ConfigureNamesReal[i];
+@@ -999,6 +1018,18 @@ build_guc_variables(void)
+ hentry->gucvar = gucvar;
+ }
+
++ for (i = 0; ConfigureNamesInt64[i].gen.name; i++)
++ {
++ struct config_generic *gucvar = &ConfigureNamesInt64[i].gen;
++
++ hentry = (GUCHashEntry *) hash_search(guc_hashtab,
++ &gucvar->name,
++ HASH_ENTER,
++ &found);
++ Assert(!found);
++ hentry->gucvar = gucvar;
++ }
++
+ for (i = 0; ConfigureNamesReal[i].gen.name; i++)
+ {
+ struct config_generic *gucvar = &ConfigureNamesReal[i].gen;
+@@ -1426,6 +1457,7 @@ check_GUC_name_for_parameter_acl(const char *name)
+ * The following validation rules apply for the values:
+ * bool - can be false, otherwise must be same as the boot_val
+ * int - can be 0, otherwise must be same as the boot_val
++ * int64 - can be 0, otherwise must be same as the boot_val
+ * real - can be 0.0, otherwise must be same as the boot_val
+ * string - can be NULL, otherwise must be strcmp equal to the boot_val
+ * enum - must be same as the boot_val
+@@ -1461,6 +1493,20 @@ check_GUC_init(struct config_generic *gconf)
+ }
+ break;
+ }
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) gconf;
++
++ if (*conf->variable != 0 && *conf->variable != conf->boot_val)
++ {
++ elog(LOG, "GUC (PGC_INT64) %s, boot_val=%lld, C-var=%lld",
++ conf->gen.name,
++ (long long) conf->boot_val,
++ (long long) *conf->variable);
++ return false;
++ }
++ break;
++ }
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) gconf;
+@@ -1691,6 +1737,24 @@ InitializeOneGUCOption(struct config_generic *gconf)
+ conf->gen.extra = conf->reset_extra = extra;
+ break;
+ }
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) gconf;
++ int64 newval = conf->boot_val;
++ void *extra = NULL;
++
++ Assert(newval >= conf->min);
++ Assert(newval <= conf->max);
++ if (!call_int64_check_hook(conf, &newval, &extra,
++ PGC_S_DEFAULT, LOG))
++ elog(FATAL, "failed to initialize %s to %lld",
++ conf->gen.name, (long long) newval);
++ if (conf->assign_hook)
++ (*conf->assign_hook) (newval, extra);
++ *conf->variable = conf->reset_val = newval;
++ conf->gen.extra = conf->reset_extra = extra;
++ break;
++ }
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) gconf;
+@@ -2041,6 +2105,18 @@ ResetAllOptions(void)
+ {
+ struct config_int *conf = (struct config_int *) gconf;
+
++ if (conf->assign_hook)
++ conf->assign_hook(conf->reset_val,
++ conf->reset_extra);
++ *conf->variable = conf->reset_val;
++ set_extra_field(&conf->gen, &conf->gen.extra,
++ conf->reset_extra);
++ break;
++ }
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) gconf;
++
+ if (conf->assign_hook)
+ conf->assign_hook(conf->reset_val,
+ conf->reset_extra);
+@@ -2424,6 +2500,24 @@ AtEOXact_GUC(bool isCommit, int nestLevel)
+ int newval = newvalue.val.intval;
+ void *newextra = newvalue.extra;
+
++ if (*conf->variable != newval ||
++ conf->gen.extra != newextra)
++ {
++ if (conf->assign_hook)
++ conf->assign_hook(newval, newextra);
++ *conf->variable = newval;
++ set_extra_field(&conf->gen, &conf->gen.extra,
++ newextra);
++ changed = true;
++ }
++ break;
++ }
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) gconf;
++ int64 newval = newvalue.val.int64val;
++ void *newextra = newvalue.extra;
++
+ if (*conf->variable != newval ||
+ conf->gen.extra != newextra)
+ {
+@@ -2946,6 +3040,71 @@ parse_int(const char *value, int *result, int flags, const char **hintmsg)
+ return true;
+ }
+
++/*
++ * Try to parse value as an 64-bit integer. The accepted format is
++ * decimal number.
++ *
++ * If the string parses okay, return true, else false.
++ * If okay and result is not NULL, return the value in *result.
++ * If not okay and hintmsg is not NULL, *hintmsg is set to a suitable
++ * HINT message, or NULL if no hint provided.
++ */
++bool
++parse_int64(const char *value, int64 *result, int flags, const char **hintmsg)
++{
++ int64 val;
++ char *endptr;
++
++ /* To suppress compiler warnings, always set output params */
++ if (result)
++ *result = 0;
++ if (hintmsg)
++ *hintmsg = NULL;
++
++ /* We assume here that int64 is at least as wide as long */
++ errno = 0;
++ val = strtoi64(value, &endptr, 0);
++
++ if (endptr == value)
++ return false; /* no HINT for integer syntax error */
++
++ if (errno == ERANGE)
++ {
++ if (hintmsg)
++ *hintmsg = gettext_noop("Value exceeds 64-bit integer range.");
++ return false;
++ }
++
++ /*
++ * got double format and/or units. For now we attempts parse it as double
++ * and throw error on 53bit overflow
++ */
++ if (*endptr != '\0')
++ {
++ double dval;
++ bool ok;
++
++ ok = parse_real(value, &dval, flags, hintmsg);
++ if (!ok)
++ return false;
++
++ dval = rint(val);
++
++ if (fabs(dval) >= (double) ((uint64) 1 << 53))
++ {
++ *hintmsg = gettext_noop("Int64 value with units should be positive number < 2^53");
++ return false;
++ }
++
++ val = (int64) dval;
++ }
++
++
++ if (result)
++ *result = val;
++ return true;
++}
++
+ /*
+ * Try to parse value as a floating point number in the usual format.
+ * Optionally, the value can be followed by a unit name if "flags" indicates
+@@ -3192,6 +3351,36 @@ parse_and_validate_value(struct config_generic *record,
+ return false;
+ }
+ break;
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) record;
++ const char *hintmsg;
++
++ if (!parse_int64(value, &newval->int64val, conf->gen.flags, &hintmsg))
++ {
++ ereport(elevel,
++ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
++ errmsg("invalid value for parameter \"%s\": \"%s\"",
++ name, value),
++ hintmsg ? errhint("%s", _(hintmsg)) : 0));
++ return false;
++ }
++
++ if (newval->int64val < conf->min || newval->int64val > conf->max)
++ {
++ ereport(elevel,
++ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
++ errmsg("%lld is outside the valid range for parameter \"%s\" (%lld .. %lld)",
++ (long long) newval->int64val, name,
++ (long long) conf->min, (long long) conf->max)));
++ return false;
++ }
++
++ if (!call_int64_check_hook(conf, &newval->int64val, newextra,
++ source, elevel))
++ return false;
++ }
++ break;
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) record;
+@@ -3895,6 +4084,96 @@ set_config_with_handle(const char *name, config_handle *handle,
+ guc_free(newextra);
+ break;
+
++#undef newval
++ }
++
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) record;
++
++#define newval (newval_union.int64val)
++
++ if (value)
++ {
++ if (!parse_and_validate_value(record, name, value,
++ source, elevel,
++ &newval_union, &newextra))
++ return 0;
++ }
++ else if (source == PGC_S_DEFAULT)
++ {
++ newval = conf->boot_val;
++ if (!call_int64_check_hook(conf, &newval, &newextra,
++ source, elevel))
++ return 0;
++ }
++ else
++ {
++ newval = conf->reset_val;
++ newextra = conf->reset_extra;
++ source = conf->gen.reset_source;
++ context = conf->gen.reset_scontext;
++ }
++
++ if (prohibitValueChange)
++ {
++ if (*conf->variable != newval)
++ {
++ record->status |= GUC_PENDING_RESTART;
++ ereport(elevel,
++ (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
++ errmsg("parameter \"%s\" cannot be changed without restarting the server",
++ name)));
++ return 0;
++ }
++ record->status &= ~GUC_PENDING_RESTART;
++ return -1;
++ }
++
++ if (changeVal)
++ {
++ /* Save old value to support transaction abort */
++ if (!makeDefault)
++ push_old_value(&conf->gen, action);
++
++ if (conf->assign_hook)
++ (*conf->assign_hook) (newval, newextra);
++ *conf->variable = newval;
++ set_extra_field(&conf->gen, &conf->gen.extra,
++ newextra);
++ conf->gen.source = source;
++ conf->gen.scontext = context;
++ }
++ if (makeDefault)
++ {
++ GucStack *stack;
++
++ if (conf->gen.reset_source <= source)
++ {
++ conf->reset_val = newval;
++ set_extra_field(&conf->gen, &conf->reset_extra,
++ newextra);
++ conf->gen.reset_source = source;
++ conf->gen.reset_scontext = context;
++ }
++ for (stack = conf->gen.stack; stack; stack = stack->prev)
++ {
++ if (stack->source <= source)
++ {
++ stack->prior.val.intval = newval;
++ set_extra_field(&conf->gen, &stack->prior.extra,
++ newextra);
++ stack->source = source;
++ stack->scontext = context;
++ }
++ }
++ }
++
++ /* Perhaps we didn't install newextra anywhere */
++ if (newextra && !extra_field_used(&conf->gen, newextra))
++ guc_free(newextra);
++ break;
++
+ #undef newval
+ }
+
+@@ -4337,6 +4616,11 @@ GetConfigOption(const char *name, bool missing_ok, bool restrict_privileged)
+ *((struct config_int *) record)->variable);
+ return buffer;
+
++ case PGC_INT64:
++ snprintf(buffer, sizeof(buffer), "%lld",
++ (long long) *((struct config_int64 *) record)->variable);
++ return buffer;
++
+ case PGC_REAL:
+ snprintf(buffer, sizeof(buffer), "%g",
+ *((struct config_real *) record)->variable);
+@@ -4385,6 +4669,11 @@ GetConfigOptionResetString(const char *name)
+ ((struct config_int *) record)->reset_val);
+ return buffer;
+
++ case PGC_INT64:
++ snprintf(buffer, sizeof(buffer), "%lld",
++ (long long) ((struct config_int64 *) record)->reset_val);
++ return buffer;
++
+ case PGC_REAL:
+ snprintf(buffer, sizeof(buffer), "%g",
+ ((struct config_real *) record)->reset_val);
+@@ -5143,6 +5432,36 @@ DefineCustomIntVariable(const char *name,
+ define_custom_variable(&var->gen);
+ }
+
++void
++DefineCustomInt64Variable(const char *name,
++ const char *short_desc,
++ const char *long_desc,
++ int64 *valueAddr,
++ int64 bootValue,
++ int64 minValue,
++ int64 maxValue,
++ GucContext context,
++ int flags,
++ GucInt64CheckHook check_hook,
++ GucInt64AssignHook assign_hook,
++ GucShowHook show_hook)
++{
++ struct config_int64 *var;
++
++ var = (struct config_int64 *)
++ init_custom_variable(name, short_desc, long_desc, context, flags,
++ PGC_INT64, sizeof(struct config_int));
++ var->variable = valueAddr;
++ var->boot_val = bootValue;
++ var->reset_val = bootValue;
++ var->min = minValue;
++ var->max = maxValue;
++ var->check_hook = check_hook;
++ var->assign_hook = assign_hook;
++ var->show_hook = show_hook;
++ define_custom_variable(&var->gen);
++}
++
+ void
+ DefineCustomRealVariable(const char *name,
+ const char *short_desc,
+@@ -5336,6 +5655,14 @@ get_explain_guc_options(int *num)
+ }
+ break;
+
++ case PGC_INT64:
++ {
++ struct config_int64 *lconf = (struct config_int64 *) conf;
++
++ modified = (lconf->boot_val != *(lconf->variable));
++ }
++ break;
++
+ case PGC_REAL:
+ {
+ struct config_real *lconf = (struct config_real *) conf;
+@@ -5468,6 +5795,21 @@ ShowGUCOption(struct config_generic *record, bool use_units)
+ }
+ break;
+
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) record;
++
++ if (conf->show_hook)
++ val = (*conf->show_hook) ();
++ else
++ {
++ snprintf(buffer, sizeof(buffer), "%lld",
++ (long long) *conf->variable);
++ val = buffer;
++ }
++ }
++ break;
++
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) record;
+@@ -5570,6 +5912,14 @@ write_one_nondefault_variable(FILE *fp, struct config_generic *gconf)
+ }
+ break;
+
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) gconf;
++
++ fprintf(fp, "%lld", (long long) *conf->variable);
++ }
++ break;
++
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) gconf;
+@@ -5848,6 +6198,24 @@ estimate_variable_size(struct config_generic *gconf)
+ }
+ break;
+
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) gconf;
++
++ /*
++ * Instead of getting the exact display length, use max
++ * length. Also reduce the max length for typical ranges of
++ * small values. Maximum value is 2^63, i.e. 20 chars.
++ * Include one byte for sign.
++ */
++#define ABS(x) ((x) >= 0 ? (x) : -(x))
++ if (ABS(*conf->variable) < 1000)
++ valsize = 3 + 1;
++ else
++ valsize = 20 + 1;
++ }
++ break;
++
+ case PGC_REAL:
+ {
+ /*
+@@ -6014,6 +6382,14 @@ serialize_variable(char **destptr, Size *maxbytes,
+ }
+ break;
+
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) gconf;
++
++ do_serialize(destptr, maxbytes, "%lld", (long long) *conf->variable);
++ }
++ break;
++
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) gconf;
+@@ -6227,6 +6603,14 @@ RestoreGUCState(void *gucstate)
+ {
+ struct config_int *conf = (struct config_int *) gconf;
+
++ if (conf->reset_extra && conf->reset_extra != gconf->extra)
++ guc_free(conf->reset_extra);
++ break;
++ }
++ case PGC_INT64:
++ {
++ struct config_int64 *conf = (struct config_int64 *) gconf;
++
+ if (conf->reset_extra && conf->reset_extra != gconf->extra)
+ guc_free(conf->reset_extra);
+ break;
+@@ -6827,6 +7211,40 @@ call_int_check_hook(struct config_int *conf, int *newval, void **extra,
+ return true;
+ }
+
++static bool
++call_int64_check_hook(struct config_int64 *conf, int64 *newval, void **extra,
++ GucSource source, int elevel)
++{
++ /* Quick success if no hook */
++ if (!conf->check_hook)
++ return true;
++
++ /* Reset variables that might be set by hook */
++ GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
++ GUC_check_errmsg_string = NULL;
++ GUC_check_errdetail_string = NULL;
++ GUC_check_errhint_string = NULL;
++
++ if (!(*conf->check_hook) (newval, extra, source))
++ {
++ ereport(elevel,
++ (errcode(GUC_check_errcode_value),
++ GUC_check_errmsg_string ?
++ errmsg_internal("%s", GUC_check_errmsg_string) :
++ errmsg("invalid value for parameter \"%s\": %lld",
++ conf->gen.name, (long long) *newval),
++ GUC_check_errdetail_string ?
++ errdetail_internal("%s", GUC_check_errdetail_string) : 0,
++ GUC_check_errhint_string ?
++ errhint("%s", GUC_check_errhint_string) : 0));
++ /* Flush any strings created in ErrorContext */
++ FlushErrorState();
++ return false;
++ }
++
++ return true;
++}
++
+ static bool
+ call_real_check_hook(struct config_real *conf, double *newval, void **extra,
+ GucSource source, int elevel)
+diff --git a/src/backend/utils/misc/guc_funcs.c b/src/backend/utils/misc/guc_funcs.c
+index 9c9edd3d2f..d0625d18b3 100644
+--- a/src/backend/utils/misc/guc_funcs.c
++++ b/src/backend/utils/misc/guc_funcs.c
+@@ -673,6 +673,31 @@ GetConfigOptionValues(struct config_generic *conf, const char **values)
+ }
+ break;
+
++ case PGC_INT64:
++ {
++ struct config_int64 *lconf = (struct config_int64 *) conf;
++
++ /* min_val */
++ snprintf(buffer, sizeof(buffer), "%lld", (long long) lconf->min);
++ values[9] = pstrdup(buffer);
++
++ /* max_val */
++ snprintf(buffer, sizeof(buffer), "%lld", (long long) lconf->max);
++ values[10] = pstrdup(buffer);
++
++ /* enumvals */
++ values[11] = NULL;
++
++ /* boot_val */
++ snprintf(buffer, sizeof(buffer), "%lld", (long long) lconf->boot_val);
++ values[12] = pstrdup(buffer);
++
++ /* reset_val */
++ snprintf(buffer, sizeof(buffer), "%lld", (long long) lconf->reset_val);
++ values[13] = pstrdup(buffer);
++ }
++ break;
++
+ case PGC_REAL:
+ {
+ struct config_real *lconf = (struct config_real *) conf;
+diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
+index 686309db58..3397808931 100644
+--- a/src/backend/utils/misc/guc_tables.c
++++ b/src/backend/utils/misc/guc_tables.c
+@@ -731,6 +731,7 @@ const char *const config_type_names[] =
+ {
+ [PGC_BOOL] = "bool",
+ [PGC_INT] = "integer",
++ [PGC_INT64] = "int64",
+ [PGC_REAL] = "real",
+ [PGC_STRING] = "string",
+ [PGC_ENUM] = "enum",
+@@ -3721,6 +3722,15 @@ struct config_int ConfigureNamesInt[] =
+ };
+
+
++struct config_int64 ConfigureNamesInt64[] =
++{
++ /* End-of-list marker */
++ {
++ {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
++ }
++};
++
++
+ struct config_real ConfigureNamesReal[] =
+ {
+ {
+diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h
+index df6923c9d5..309c82ebf4 100644
+--- a/src/include/access/reloptions.h
++++ b/src/include/access/reloptions.h
+@@ -30,6 +30,7 @@ typedef enum relopt_type
+ {
+ RELOPT_TYPE_BOOL,
+ RELOPT_TYPE_INT,
++ RELOPT_TYPE_INT64,
+ RELOPT_TYPE_REAL,
+ RELOPT_TYPE_ENUM,
+ RELOPT_TYPE_STRING,
+@@ -81,6 +82,7 @@ typedef struct relopt_value
+ {
+ bool bool_val;
+ int int_val;
++ int64 int64_val;
+ double real_val;
+ int enum_val;
+ char *string_val; /* allocated separately */
+@@ -102,6 +104,14 @@ typedef struct relopt_int
+ int max;
+ } relopt_int;
+
++typedef struct relopt_int64
++{
++ relopt_gen gen;
++ int64 default_val;
++ int64 min;
++ int64 max;
++} relopt_int64;
++
+ typedef struct relopt_real
+ {
+ relopt_gen gen;
+@@ -185,6 +195,9 @@ extern void add_bool_reloption(bits32 kinds, const char *name, const char *desc,
+ extern void add_int_reloption(bits32 kinds, const char *name, const char *desc,
+ int default_val, int min_val, int max_val,
+ LOCKMODE lockmode);
++extern void add_int64_reloption(bits32 kinds, const char *name, char *desc,
++ int64 default_val, int64 min_val, int64 max_val,
++ LOCKMODE lockmode);
+ extern void add_real_reloption(bits32 kinds, const char *name, const char *desc,
+ double default_val, double min_val, double max_val,
+ LOCKMODE lockmode);
+diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
+index 840b0fe57f..0a3fe0b54f 100644
+--- a/src/include/utils/guc.h
++++ b/src/include/utils/guc.h
+@@ -178,12 +178,14 @@ struct config_enum_entry
+ */
+ typedef bool (*GucBoolCheckHook) (bool *newval, void **extra, GucSource source);
+ typedef bool (*GucIntCheckHook) (int *newval, void **extra, GucSource source);
++typedef bool (*GucInt64CheckHook) (int64 *newval, void **extra, GucSource source);
+ typedef bool (*GucRealCheckHook) (double *newval, void **extra, GucSource source);
+ typedef bool (*GucStringCheckHook) (char **newval, void **extra, GucSource source);
+ typedef bool (*GucEnumCheckHook) (int *newval, void **extra, GucSource source);
+
+ typedef void (*GucBoolAssignHook) (bool newval, void *extra);
+ typedef void (*GucIntAssignHook) (int newval, void *extra);
++typedef void (*GucInt64AssignHook) (int64 newval, void *extra);
+ typedef void (*GucRealAssignHook) (double newval, void *extra);
+ typedef void (*GucStringAssignHook) (const char *newval, void *extra);
+ typedef void (*GucEnumAssignHook) (int newval, void *extra);
+@@ -348,6 +350,19 @@ extern void DefineCustomIntVariable(const char *name,
+ GucIntAssignHook assign_hook,
+ GucShowHook show_hook) pg_attribute_nonnull(1, 4);
+
++extern void DefineCustomInt64Variable(const char *name,
++ const char *short_desc,
++ const char *long_desc,
++ int64 *valueAddr,
++ int64 bootValue,
++ int64 minValue,
++ int64 maxValue,
++ GucContext context,
++ int flags,
++ GucInt64CheckHook check_hook,
++ GucInt64AssignHook assign_hook,
++ GucShowHook show_hook) pg_attribute_nonnull(1, 4);
++
+ extern void DefineCustomRealVariable(const char *name,
+ const char *short_desc,
+ const char *long_desc,
+@@ -409,6 +424,8 @@ extern void ParseLongOption(const char *string, char **name, char **value);
+ extern const char *get_config_unit_name(int flags);
+ extern bool parse_int(const char *value, int *result, int flags,
+ const char **hintmsg);
++extern bool parse_int64(const char *value, int64 *result, int flags,
++ const char **hintmsg);
+ extern bool parse_real(const char *value, double *result, int flags,
+ const char **hintmsg);
+ extern int set_config_option(const char *name, const char *value,
+diff --git a/src/include/utils/guc_tables.h b/src/include/utils/guc_tables.h
+index 0c0277c423..c4dfe0afab 100644
+--- a/src/include/utils/guc_tables.h
++++ b/src/include/utils/guc_tables.h
+@@ -24,6 +24,7 @@ enum config_type
+ {
+ PGC_BOOL,
+ PGC_INT,
++ PGC_INT64,
+ PGC_REAL,
+ PGC_STRING,
+ PGC_ENUM,
+@@ -33,6 +34,7 @@ union config_var_val
+ {
+ bool boolval;
+ int intval;
++ int64 int64val;
+ double realval;
+ char *stringval;
+ int enumval;
+@@ -225,6 +227,22 @@ struct config_int
+ void *reset_extra;
+ };
+
++struct config_int64
++{
++ struct config_generic gen;
++ /* constant fields, must be set correctly in initial value: */
++ int64 *variable;
++ int64 boot_val;
++ int64 min;
++ int64 max;
++ GucInt64CheckHook check_hook;
++ GucInt64AssignHook assign_hook;
++ GucShowHook show_hook;
++ /* variable fields, initialized at runtime: */
++ int64 reset_val;
++ void *reset_extra;
++};
++
+ struct config_real
+ {
+ struct config_generic gen;
+@@ -289,6 +307,7 @@ extern PGDLLIMPORT const char *const GucSource_Names[];
+ /* data arrays defining all the built-in GUC variables */
+ extern PGDLLIMPORT struct config_bool ConfigureNamesBool[];
+ extern PGDLLIMPORT struct config_int ConfigureNamesInt[];
++extern PGDLLIMPORT struct config_int64 ConfigureNamesInt64[];
+ extern PGDLLIMPORT struct config_real ConfigureNamesReal[];
+ extern PGDLLIMPORT struct config_string ConfigureNamesString[];
+ extern PGDLLIMPORT struct config_enum ConfigureNamesEnum[];
+diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h
+index 8700204953..442a11c329 100644
+--- a/src/include/utils/rel.h
++++ b/src/include/utils/rel.h
+@@ -312,13 +312,13 @@ typedef struct AutoVacOpts
+ int vacuum_ins_threshold;
+ int analyze_threshold;
+ int vacuum_cost_limit;
+- int freeze_min_age;
+- int freeze_max_age;
+- int freeze_table_age;
+- int multixact_freeze_min_age;
+- int multixact_freeze_max_age;
+- int multixact_freeze_table_age;
+- int log_min_duration;
++ int64 freeze_min_age;
++ int64 freeze_max_age;
++ int64 freeze_table_age;
++ int64 multixact_freeze_min_age;
++ int64 multixact_freeze_max_age;
++ int64 multixact_freeze_table_age;
++ int64 log_min_duration;
+ float8 vacuum_cost_delay;
+ float8 vacuum_scale_factor;
+ float8 vacuum_ins_scale_factor;
+--
+2.46.0
+
diff --git a/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0001-Use-64-bit-format-to-output-XIDs.patch b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0001-Use-64-bit-format-to-output-XIDs.patch
new file mode 100644
index 00000000000..cd2376dd365
--- /dev/null
+++ b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0001-Use-64-bit-format-to-output-XIDs.patch
@@ -0,0 +1,3156 @@
+From 81bcda1a49a98e867e7eb470e4616e1bf3cc9f5c Mon Sep 17 00:00:00 2001
+From: Evgeny Voropaev <evorop@gmail.com>
+Date: Mon, 24 Sep 2024 18:11:00 +0800
+Subject: [PATCH v56 1/5] Use 64-bit format to output XIDs
+
+Replace the %u formatting string for XIDs with %llu and cast to
+unsigned long long. This is the part of a making XIDs 64-bit.
+While actually XIDs are still 32-bit, this patch completely supports both
+32 and 64-bit.
+
+Author: Alexander Korotkov <aekorotkov@gmail.com>
+Author: Teodor Sigaev <teodor@sigaev.ru>
+Author: Nikita Glukhov <n.gluhov@postgrespro.ru>
+Author: Maxim Orlov <orlovmg@gmail.com>
+Author: Pavel Borisov <pashkin.elfe@gmail.com>
+Author: Yura Sokolov <y.sokolov@postgrespro.ru> <funny.falcon@gmail.com>
+Author: Aleksander Alekseev <aleksander@timescale.com>
+Author: Evgeny Voropaev (rebase onto PG18dev+MXIDOFF64) <evorop@gmail.com> <evgeny.voropaev@tantorlabs.ru>
+Discussion: https://postgr.es/m/CACG%3DezZe1NQSCnfHOr78AtAZxJZeCvxrts0ygrxYwe%3DpyyjVWA%40mail.gmail.com
+Discussion: https://postgr.es/m/CAJ7c6TPDOYBYrnCAeyndkBktO0WG2xSdYduTF0nxq%2BvfkmTF5Q%40mail.gmail.com
+---
+ contrib/amcheck/verify_heapam.c | 140 +++++++++---------
+ contrib/pageinspect/btreefuncs.c | 8 +-
+ contrib/pgrowlocks/pgrowlocks.c | 9 +-
+ contrib/test_decoding/test_decoding.c | 38 +++--
+ doc/src/sgml/logicaldecoding.sgml | 2 +-
+ src/backend/access/heap/heapam.c | 71 +++++----
+ src/backend/access/heap/heapam_handler.c | 4 +-
+ src/backend/access/heap/vacuumlazy.c | 15 +-
+ src/backend/access/rmgrdesc/clogdesc.c | 5 +-
+ src/backend/access/rmgrdesc/committsdesc.c | 5 +-
+ src/backend/access/rmgrdesc/gistdesc.c | 13 +-
+ src/backend/access/rmgrdesc/hashdesc.c | 4 +-
+ src/backend/access/rmgrdesc/heapdesc.c | 43 +++---
+ src/backend/access/rmgrdesc/mxactdesc.c | 10 +-
+ src/backend/access/rmgrdesc/nbtdesc.c | 12 +-
+ src/backend/access/rmgrdesc/spgdesc.c | 4 +-
+ src/backend/access/rmgrdesc/standbydesc.c | 18 ++-
+ src/backend/access/rmgrdesc/xactdesc.c | 10 +-
+ src/backend/access/rmgrdesc/xlogdesc.c | 22 +--
+ src/backend/access/transam/commit_ts.c | 3 +-
+ src/backend/access/transam/multixact.c | 112 ++++++++------
+ src/backend/access/transam/slru.c | 27 ++--
+ src/backend/access/transam/subtrans.c | 5 +-
+ src/backend/access/transam/transam.c | 8 +-
+ src/backend/access/transam/twophase.c | 46 +++---
+ src/backend/access/transam/varsup.c | 20 +--
+ src/backend/access/transam/xact.c | 16 +-
+ src/backend/access/transam/xlogrecovery.c | 48 +++---
+ src/backend/commands/vacuum.c | 10 +-
+ src/backend/nodes/outfuncs.c | 2 +-
+ .../replication/logical/applyparallelworker.c | 6 +-
+ src/backend/replication/logical/logical.c | 4 +-
+ .../replication/logical/reorderbuffer.c | 23 +--
+ src/backend/replication/logical/snapbuild.c | 54 ++++---
+ src/backend/replication/logical/worker.c | 30 ++--
+ src/backend/replication/pgoutput/pgoutput.c | 3 +-
+ src/backend/replication/slot.c | 4 +-
+ src/backend/replication/walreceiver.c | 5 +-
+ src/backend/replication/walsender.c | 6 +-
+ src/backend/storage/ipc/procarray.c | 37 ++---
+ src/backend/storage/ipc/standby.c | 26 ++--
+ src/backend/storage/lmgr/predicate.c | 9 +-
+ src/backend/utils/adt/lockfuncs.c | 2 +-
+ src/backend/utils/error/csvlog.c | 5 +-
+ src/backend/utils/error/elog.c | 12 +-
+ src/backend/utils/error/jsonlog.c | 8 +-
+ src/backend/utils/misc/pg_controldata.c | 4 +-
+ src/backend/utils/time/snapmgr.c | 17 ++-
+ src/bin/pg_controldata/pg_controldata.c | 28 ++--
+ src/bin/pg_dump/pg_dump.c | 17 ++-
+ src/bin/pg_resetwal/pg_resetwal.c | 66 +++++----
+ src/bin/pg_upgrade/pg_upgrade.c | 44 +++---
+ src/bin/pg_waldump/pg_waldump.c | 4 +-
+ .../modules/xid_wraparound/xid_wraparound.c | 10 +-
+ 54 files changed, 638 insertions(+), 516 deletions(-)
+
+diff --git a/contrib/amcheck/verify_heapam.c b/contrib/amcheck/verify_heapam.c
+index f2526ed63a..868fcacd6b 100644
+--- a/contrib/amcheck/verify_heapam.c
++++ b/contrib/amcheck/verify_heapam.c
+@@ -714,10 +714,10 @@ verify_heapam(PG_FUNCTION_ARGS)
+ TransactionIdIsInProgress(curr_xmin))
+ {
+ report_corruption(&ctx,
+- psprintf("tuple with in-progress xmin %u was updated to produce a tuple at offset %u with committed xmin %u",
+- (unsigned) curr_xmin,
++ psprintf("tuple with in-progress xmin %llu was updated to produce a tuple at offset %u with committed xmin %llu",
++ (unsigned long long) curr_xmin,
+ (unsigned) ctx.offnum,
+- (unsigned) next_xmin));
++ (unsigned long long) next_xmin));
+ }
+
+ /*
+@@ -730,16 +730,16 @@ verify_heapam(PG_FUNCTION_ARGS)
+ {
+ if (xmin_commit_status[nextoffnum] == XID_IN_PROGRESS)
+ report_corruption(&ctx,
+- psprintf("tuple with aborted xmin %u was updated to produce a tuple at offset %u with in-progress xmin %u",
+- (unsigned) curr_xmin,
++ psprintf("tuple with aborted xmin %llu was updated to produce a tuple at offset %u with in-progress xmin %llu",
++ (unsigned long long) curr_xmin,
+ (unsigned) ctx.offnum,
+- (unsigned) next_xmin));
++ (unsigned long long) next_xmin));
+ else if (xmin_commit_status[nextoffnum] == XID_COMMITTED)
+ report_corruption(&ctx,
+- psprintf("tuple with aborted xmin %u was updated to produce a tuple at offset %u with committed xmin %u",
+- (unsigned) curr_xmin,
++ psprintf("tuple with aborted xmin %llu was updated to produce a tuple at offset %u with committed xmin %llu",
++ (unsigned long long) curr_xmin,
+ (unsigned) ctx.offnum,
+- (unsigned) next_xmin));
++ (unsigned long long) next_xmin));
+ }
+ }
+
+@@ -1040,24 +1040,24 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ break;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("xmin %u equals or exceeds next valid transaction ID %u:%u",
+- xmin,
++ psprintf("xmin %llu equals or exceeds next valid transaction ID %u:%llu",
++ (unsigned long long) xmin,
+ EpochFromFullTransactionId(ctx->next_fxid),
+- XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("xmin %u precedes oldest valid transaction ID %u:%u",
+- xmin,
++ psprintf("xmin %llu precedes oldest valid transaction ID %u:%llu",
++ (unsigned long long) xmin,
+ EpochFromFullTransactionId(ctx->oldest_fxid),
+- XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("xmin %u precedes relation freeze threshold %u:%u",
+- xmin,
++ psprintf("xmin %llu precedes relation freeze threshold %u:%llu",
++ (unsigned long long) xmin,
+ EpochFromFullTransactionId(ctx->relfrozenfxid),
+- XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ }
+
+@@ -1081,24 +1081,24 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ return false;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved off tuple equals or exceeds next valid transaction ID %u:%u",
+- xvac,
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple equals or exceeds next valid transaction ID %u:%llu",
++ (unsigned long long) xvac,
+ EpochFromFullTransactionId(ctx->next_fxid),
+- XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved off tuple precedes relation freeze threshold %u:%u",
+- xvac,
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes relation freeze threshold %u:%llu",
++ (unsigned long long) xvac,
+ EpochFromFullTransactionId(ctx->relfrozenfxid),
+- XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved off tuple precedes oldest valid transaction ID %u:%u",
+- xvac,
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes oldest valid transaction ID %u:%llu",
++ (unsigned long long) xvac,
+ EpochFromFullTransactionId(ctx->oldest_fxid),
+- XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1108,13 +1108,13 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ {
+ case XID_IS_CURRENT_XID:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved off tuple matches our current transaction ID",
+- xvac));
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple matches our current transaction ID",
++ (unsigned long long) xvac));
+ return false;
+ case XID_IN_PROGRESS:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved off tuple appears to be in progress",
+- xvac));
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple appears to be in progress",
++ (unsigned long long) xvac));
+ return false;
+
+ case XID_COMMITTED:
+@@ -1150,24 +1150,24 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ return false;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved in tuple equals or exceeds next valid transaction ID %u:%u",
+- xvac,
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple equals or exceeds next valid transaction ID %u:%llu",
++ (unsigned long long) xvac,
+ EpochFromFullTransactionId(ctx->next_fxid),
+- XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved in tuple precedes relation freeze threshold %u:%u",
+- xvac,
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes relation freeze threshold %u:%llu",
++ (unsigned long long) xvac,
+ EpochFromFullTransactionId(ctx->relfrozenfxid),
+- XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved in tuple precedes oldest valid transaction ID %u:%u",
+- xvac,
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes oldest valid transaction ID %u:%llu",
++ (unsigned long long) xvac,
+ EpochFromFullTransactionId(ctx->oldest_fxid),
+- XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1177,13 +1177,13 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ {
+ case XID_IS_CURRENT_XID:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved in tuple matches our current transaction ID",
+- xvac));
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple matches our current transaction ID",
++ (unsigned long long) xvac));
+ return false;
+ case XID_IN_PROGRESS:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %u for moved in tuple appears to be in progress",
+- xvac));
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple appears to be in progress",
++ (unsigned long long) xvac));
+ return false;
+
+ case XID_COMMITTED:
+@@ -1253,19 +1253,21 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ return true;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("multitransaction ID %u precedes relation minimum multitransaction ID threshold %u",
+- xmax, ctx->relminmxid));
++ psprintf("multitransaction ID %llu precedes relation minimum multitransaction ID threshold %llu",
++ (unsigned long long) xmax,
++ (unsigned long long) ctx->relminmxid));
+ return true;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("multitransaction ID %u precedes oldest valid multitransaction ID threshold %u",
+- xmax, ctx->oldest_mxact));
++ psprintf("multitransaction ID %llu precedes oldest valid multitransaction ID threshold %llu",
++ (unsigned long long) xmax,
++ (unsigned long long) ctx->oldest_mxact));
+ return true;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("multitransaction ID %u equals or exceeds next valid multitransaction ID %u",
+- xmax,
+- ctx->next_mxact));
++ psprintf("multitransaction ID %llu equals or exceeds next valid multitransaction ID %llu",
++ (unsigned long long) xmax,
++ (unsigned long long) ctx->next_mxact));
+ return true;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1311,24 +1313,24 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ return true;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("update xid %u equals or exceeds next valid transaction ID %u:%u",
+- xmax,
++ psprintf("update xid %llu equals or exceeds next valid transaction ID %u:%llu",
++ (unsigned long long) xmax,
+ EpochFromFullTransactionId(ctx->next_fxid),
+- XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return true;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("update xid %u precedes relation freeze threshold %u:%u",
+- xmax,
++ psprintf("update xid %llu precedes relation freeze threshold %u:%llu",
++ (unsigned long long) xmax,
+ EpochFromFullTransactionId(ctx->relfrozenfxid),
+- XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return true;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("update xid %u precedes oldest valid transaction ID %u:%u",
+- xmax,
++ psprintf("update xid %llu precedes oldest valid transaction ID %u:%llu",
++ (unsigned long long) xmax,
+ EpochFromFullTransactionId(ctx->oldest_fxid),
+- XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return true;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1376,24 +1378,24 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ return true;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("xmax %u equals or exceeds next valid transaction ID %u:%u",
+- xmax,
++ psprintf("xmax %llu equals or exceeds next valid transaction ID %u:%llu",
++ (unsigned long long) xmax,
+ EpochFromFullTransactionId(ctx->next_fxid),
+- XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("xmax %u precedes relation freeze threshold %u:%u",
+- xmax,
++ psprintf("xmax %llu precedes relation freeze threshold %u:%llu",
++ (unsigned long long) xmax,
+ EpochFromFullTransactionId(ctx->relfrozenfxid),
+- XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("xmax %u precedes oldest valid transaction ID %u:%u",
+- xmax,
++ psprintf("xmax %llu precedes oldest valid transaction ID %u:%llu",
++ (unsigned long long) xmax,
+ EpochFromFullTransactionId(ctx->oldest_fxid),
+- XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false; /* corrupt */
+ case XID_BOUNDS_OK:
+ break;
+diff --git a/contrib/pageinspect/btreefuncs.c b/contrib/pageinspect/btreefuncs.c
+index 9cdc8e182b..fd6043850c 100644
+--- a/contrib/pageinspect/btreefuncs.c
++++ b/contrib/pageinspect/btreefuncs.c
+@@ -142,13 +142,13 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+ {
+ FullTransactionId safexid = BTPageGetDeleteXid(page);
+
+- elog(DEBUG2, "deleted page from block %u has safexid %u:%u",
++ elog(DEBUG2, "deleted page from block %u has safexid %u:%llu",
+ blkno, EpochFromFullTransactionId(safexid),
+- XidFromFullTransactionId(safexid));
++ (unsigned long long) XidFromFullTransactionId(safexid));
+ }
+ else
+- elog(DEBUG2, "deleted page from block %u has safexid %u",
+- blkno, opaque->btpo_level);
++ elog(DEBUG2, "deleted page from block %u has safexid %llu",
++ blkno, (unsigned long long) opaque->btpo_level);
+
+ /* Don't interpret BTDeletedPageData as index tuples */
+ maxoff = InvalidOffsetNumber;
+diff --git a/contrib/pgrowlocks/pgrowlocks.c b/contrib/pgrowlocks/pgrowlocks.c
+index adbc8279c3..dea76d8dcb 100644
+--- a/contrib/pgrowlocks/pgrowlocks.c
++++ b/contrib/pgrowlocks/pgrowlocks.c
+@@ -142,7 +142,8 @@ pgrowlocks(PG_FUNCTION_ARGS)
+ PointerGetDatum(&tuple->t_self));
+
+ values[Atnum_xmax] = palloc(NCHARS * sizeof(char));
+- snprintf(values[Atnum_xmax], NCHARS, "%u", xmax);
++ snprintf(values[Atnum_xmax], NCHARS, "%llu",
++ (unsigned long long) xmax);
+ if (infomask & HEAP_XMAX_IS_MULTI)
+ {
+ MultiXactMember *members;
+@@ -183,7 +184,8 @@ pgrowlocks(PG_FUNCTION_ARGS)
+ strcat(values[Atnum_modes], ",");
+ strcat(values[Atnum_pids], ",");
+ }
+- snprintf(buf, NCHARS, "%u", members[j].xid);
++ snprintf(buf, NCHARS, "%llu",
++ (unsigned long long) members[j].xid);
+ strcat(values[Atnum_xids], buf);
+ switch (members[j].status)
+ {
+@@ -224,7 +226,8 @@ pgrowlocks(PG_FUNCTION_ARGS)
+ values[Atnum_ismulti] = pstrdup("false");
+
+ values[Atnum_xids] = palloc(NCHARS * sizeof(char));
+- snprintf(values[Atnum_xids], NCHARS, "{%u}", xmax);
++ snprintf(values[Atnum_xids], NCHARS, "{%llu}",
++ (unsigned long long) xmax);
+
+ values[Atnum_modes] = palloc(NCHARS);
+ if (infomask & HEAP_XMAX_LOCK_ONLY)
+diff --git a/contrib/test_decoding/test_decoding.c b/contrib/test_decoding/test_decoding.c
+index 7c50d13969..6927244575 100644
+--- a/contrib/test_decoding/test_decoding.c
++++ b/contrib/test_decoding/test_decoding.c
+@@ -308,7 +308,7 @@ pg_output_begin(LogicalDecodingContext *ctx, TestDecodingData *data, ReorderBuff
+ {
+ OutputPluginPrepareWrite(ctx, last_write);
+ if (data->include_xids)
+- appendStringInfo(ctx->out, "BEGIN %u", txn->xid);
++ appendStringInfo(ctx->out, "BEGIN %llu", (unsigned long long) txn->xid);
+ else
+ appendStringInfoString(ctx->out, "BEGIN");
+ OutputPluginWrite(ctx, last_write);
+@@ -331,7 +331,7 @@ pg_decode_commit_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
+
+ OutputPluginPrepareWrite(ctx, true);
+ if (data->include_xids)
+- appendStringInfo(ctx->out, "COMMIT %u", txn->xid);
++ appendStringInfo(ctx->out, "COMMIT %llu", (unsigned long long) txn->xid);
+ else
+ appendStringInfoString(ctx->out, "COMMIT");
+
+@@ -384,7 +384,7 @@ pg_decode_prepare_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
+ quote_literal_cstr(txn->gid));
+
+ if (data->include_xids)
+- appendStringInfo(ctx->out, ", txid %u", txn->xid);
++ appendStringInfo(ctx->out, ", txid %llu", (unsigned long long) txn->xid);
+
+ if (data->include_timestamp)
+ appendStringInfo(ctx->out, " (at %s)",
+@@ -406,7 +406,7 @@ pg_decode_commit_prepared_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn
+ quote_literal_cstr(txn->gid));
+
+ if (data->include_xids)
+- appendStringInfo(ctx->out, ", txid %u", txn->xid);
++ appendStringInfo(ctx->out, ", txid %llu", (unsigned long long) txn->xid);
+
+ if (data->include_timestamp)
+ appendStringInfo(ctx->out, " (at %s)",
+@@ -430,7 +430,7 @@ pg_decode_rollback_prepared_txn(LogicalDecodingContext *ctx,
+ quote_literal_cstr(txn->gid));
+
+ if (data->include_xids)
+- appendStringInfo(ctx->out, ", txid %u", txn->xid);
++ appendStringInfo(ctx->out, ", txid %llu", (unsigned long long) txn->xid);
+
+ if (data->include_timestamp)
+ appendStringInfo(ctx->out, " (at %s)",
+@@ -791,7 +791,9 @@ pg_output_stream_start(LogicalDecodingContext *ctx, TestDecodingData *data, Reor
+ {
+ OutputPluginPrepareWrite(ctx, last_write);
+ if (data->include_xids)
+- appendStringInfo(ctx->out, "opening a streamed block for transaction TXN %u", txn->xid);
++ appendStringInfo(ctx->out,
++ "opening a streamed block for transaction TXN %llu",
++ (unsigned long long) txn->xid);
+ else
+ appendStringInfoString(ctx->out, "opening a streamed block for transaction");
+ OutputPluginWrite(ctx, last_write);
+@@ -809,7 +811,9 @@ pg_decode_stream_stop(LogicalDecodingContext *ctx,
+
+ OutputPluginPrepareWrite(ctx, true);
+ if (data->include_xids)
+- appendStringInfo(ctx->out, "closing a streamed block for transaction TXN %u", txn->xid);
++ appendStringInfo(ctx->out,
++ "closing a streamed block for transaction TXN %llu",
++ (unsigned long long) txn->xid);
+ else
+ appendStringInfoString(ctx->out, "closing a streamed block for transaction");
+ OutputPluginWrite(ctx, true);
+@@ -843,7 +847,9 @@ pg_decode_stream_abort(LogicalDecodingContext *ctx,
+
+ OutputPluginPrepareWrite(ctx, true);
+ if (data->include_xids)
+- appendStringInfo(ctx->out, "aborting streamed (sub)transaction TXN %u", txn->xid);
++ appendStringInfo(ctx->out,
++ "aborting streamed (sub)transaction TXN %llu",
++ (unsigned long long) txn->xid);
+ else
+ appendStringInfoString(ctx->out, "aborting streamed (sub)transaction");
+ OutputPluginWrite(ctx, true);
+@@ -863,8 +869,10 @@ pg_decode_stream_prepare(LogicalDecodingContext *ctx,
+ OutputPluginPrepareWrite(ctx, true);
+
+ if (data->include_xids)
+- appendStringInfo(ctx->out, "preparing streamed transaction TXN %s, txid %u",
+- quote_literal_cstr(txn->gid), txn->xid);
++ appendStringInfo(ctx->out,
++ "preparing streamed transaction TXN %s, txid %llu",
++ quote_literal_cstr(txn->gid),
++ (unsigned long long) txn->xid);
+ else
+ appendStringInfo(ctx->out, "preparing streamed transaction %s",
+ quote_literal_cstr(txn->gid));
+@@ -894,7 +902,9 @@ pg_decode_stream_commit(LogicalDecodingContext *ctx,
+ OutputPluginPrepareWrite(ctx, true);
+
+ if (data->include_xids)
+- appendStringInfo(ctx->out, "committing streamed transaction TXN %u", txn->xid);
++ appendStringInfo(ctx->out,
++ "committing streamed transaction TXN %llu",
++ (unsigned long long) txn->xid);
+ else
+ appendStringInfoString(ctx->out, "committing streamed transaction");
+
+@@ -928,7 +938,8 @@ pg_decode_stream_change(LogicalDecodingContext *ctx,
+
+ OutputPluginPrepareWrite(ctx, true);
+ if (data->include_xids)
+- appendStringInfo(ctx->out, "streaming change for TXN %u", txn->xid);
++ appendStringInfo(ctx->out, "streaming change for TXN %llu",
++ (unsigned long long) txn->xid);
+ else
+ appendStringInfoString(ctx->out, "streaming change for transaction");
+ OutputPluginWrite(ctx, true);
+@@ -994,7 +1005,8 @@ pg_decode_stream_truncate(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
+
+ OutputPluginPrepareWrite(ctx, true);
+ if (data->include_xids)
+- appendStringInfo(ctx->out, "streaming truncate for TXN %u", txn->xid);
++ appendStringInfo(ctx->out, "streaming truncate for TXN %llu",
++ (unsigned long long) txn->xid);
+ else
+ appendStringInfoString(ctx->out, "streaming truncate for transaction");
+ OutputPluginWrite(ctx, true);
+diff --git a/doc/src/sgml/logicaldecoding.sgml b/doc/src/sgml/logicaldecoding.sgml
+index 1c4ae38f1b..a1c92f0f65 100644
+--- a/doc/src/sgml/logicaldecoding.sgml
++++ b/doc/src/sgml/logicaldecoding.sgml
+@@ -1168,7 +1168,7 @@ typedef void (*LogicalDecodeStreamTruncateCB) (struct LogicalDecodingContext *ct
+ output plugin:
+ <programlisting>
+ OutputPluginPrepareWrite(ctx, true);
+-appendStringInfo(ctx->out, "BEGIN %u", txn->xid);
++appendStringInfo(ctx->out, "BEGIN %llu", (unsigned long long) txn->xid);
+ OutputPluginWrite(ctx, true);
+ </programlisting>
+ </para>
+diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
+index f167107257..0d24fd765e 100644
+--- a/src/backend/access/heap/heapam.c
++++ b/src/backend/access/heap/heapam.c
+@@ -5209,7 +5209,8 @@ l5:
+ * TransactionIdIsInProgress() should have returned false. We
+ * assume it's no longer locked in this case.
+ */
+- elog(WARNING, "LOCK_ONLY found for Xid in progress %u", xmax);
++ elog(WARNING, "LOCK_ONLY found for Xid in progress %llu",
++ (unsigned long long) xmax);
+ old_infomask |= HEAP_XMAX_INVALID;
+ old_infomask &= ~HEAP_XMAX_LOCK_ONLY;
+ goto l5;
+@@ -6209,8 +6210,9 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ else if (MultiXactIdPrecedes(multi, cutoffs->relminmxid))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("found multixact %u from before relminmxid %u",
+- multi, cutoffs->relminmxid)));
++ errmsg_internal("found multixact %llu from before relminmxid %llu",
++ (unsigned long long) multi,
++ (unsigned long long) cutoffs->relminmxid)));
+ else if (MultiXactIdPrecedes(multi, cutoffs->OldestMxact))
+ {
+ TransactionId update_xact;
+@@ -6225,8 +6227,9 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ HEAP_XMAX_IS_LOCKED_ONLY(t_infomask)))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("multixact %u from before multi freeze cutoff %u found to be still running",
+- multi, cutoffs->OldestMxact)));
++ errmsg_internal("multixact %llu from before cutoff %llu found to be still running",
++ (unsigned long long) multi,
++ (unsigned long long) cutoffs->OldestMxact)));
+
+ if (HEAP_XMAX_IS_LOCKED_ONLY(t_infomask))
+ {
+@@ -6240,9 +6243,10 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ if (TransactionIdPrecedes(update_xact, cutoffs->relfrozenxid))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("multixact %u contains update XID %u from before relfrozenxid %u",
+- multi, update_xact,
+- cutoffs->relfrozenxid)));
++ errmsg_internal("multixact %llu contains update XID %llu from before relfrozenxid %llu",
++ (unsigned long long) multi,
++ (unsigned long long) update_xact,
++ (unsigned long long) cutoffs->relfrozenxid)));
+ else if (TransactionIdPrecedes(update_xact, cutoffs->OldestXmin))
+ {
+ /*
+@@ -6253,9 +6257,10 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ if (TransactionIdDidCommit(update_xact))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("multixact %u contains committed update XID %u from before removable cutoff %u",
+- multi, update_xact,
+- cutoffs->OldestXmin)));
++ errmsg_internal("multixact %llu contains non-aborted update XID %llu from before removable cutoff %llu",
++ (unsigned long long) multi,
++ (unsigned long long) update_xact,
++ (unsigned long long) cutoffs->OldestXmin)));
+ *flags |= FRM_INVALIDATE_XMAX;
+ pagefrz->freeze_required = true;
+ return InvalidTransactionId;
+@@ -6374,9 +6379,10 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ if (TransactionIdPrecedes(xid, cutoffs->OldestXmin))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("multixact %u contains running locker XID %u from before removable cutoff %u",
+- multi, xid,
+- cutoffs->OldestXmin)));
++ errmsg_internal("multixact %llu contains running locker XID %llu from before removable cutoff %llu",
++ (unsigned long long) multi,
++ (unsigned long long) xid,
++ (unsigned long long) cutoffs->OldestXmin)));
+ newmembers[nnewmembers++] = members[i];
+ has_lockers = true;
+ }
+@@ -6398,10 +6404,11 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ if (TransactionIdIsValid(update_xid))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("multixact %u has two or more updating members",
+- multi),
+- errdetail_internal("First updater XID=%u second updater XID=%u.",
+- update_xid, xid)));
++ errmsg_internal("multixact %llu has two or more updating members",
++ (unsigned long long) multi),
++ errdetail_internal("First updater XID=%llu second updater XID=%llu.",
++ (unsigned long long) update_xid,
++ (unsigned long long) xid)));
+
+ /*
+ * As with all tuple visibility routines, it's critical to test
+@@ -6437,8 +6444,10 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ if (TransactionIdPrecedes(xid, cutoffs->OldestXmin))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("multixact %u contains committed update XID %u from before removable cutoff %u",
+- multi, xid, cutoffs->OldestXmin)));
++ errmsg_internal("multixact %llu contains committed update XID %llu from before removable cutoff %llu",
++ (unsigned long long) multi,
++ (unsigned long long) xid,
++ (unsigned long long) cutoffs->OldestXmin)));
+ newmembers[nnewmembers++] = members[i];
+ }
+
+@@ -6561,8 +6570,9 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ if (TransactionIdPrecedes(xid, cutoffs->relfrozenxid))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("found xmin %u from before relfrozenxid %u",
+- xid, cutoffs->relfrozenxid)));
++ errmsg_internal("found xmin %llu from before relfrozenxid %llu",
++ (unsigned long long) xid,
++ (unsigned long long) cutoffs->relfrozenxid)));
+
+ /* Will set freeze_xmin flags in freeze plan below */
+ freeze_xmin = TransactionIdPrecedes(xid, cutoffs->OldestXmin);
+@@ -6700,8 +6710,9 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ if (TransactionIdPrecedes(xid, cutoffs->relfrozenxid))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("found xmax %u from before relfrozenxid %u",
+- xid, cutoffs->relfrozenxid)));
++ errmsg_internal("found xmax %llu from before relfrozenxid %llu",
++ (unsigned long long) xid,
++ (unsigned long long) cutoffs->relfrozenxid)));
+
+ /* Will set freeze_xmax flags in freeze plan below */
+ freeze_xmax = TransactionIdPrecedes(xid, cutoffs->OldestXmin);
+@@ -6723,8 +6734,8 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ else
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("found raw xmax %u (infomask 0x%04x) not invalid and not multi",
+- xid, tuple->t_infomask)));
++ errmsg_internal("found raw xmax %llu (infomask 0x%04x) not invalid and not multi",
++ (unsigned long long) xid, tuple->t_infomask)));
+
+ if (freeze_xmin)
+ {
+@@ -6824,8 +6835,8 @@ heap_pre_freeze_checks(Buffer buffer,
+ if (unlikely(!TransactionIdDidCommit(xmin)))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("uncommitted xmin %u needs to be frozen",
+- xmin)));
++ errmsg_internal("uncommitted xmin %llu needs to be frozen",
++ (unsigned long long) xmin)));
+ }
+
+ /*
+@@ -6841,8 +6852,8 @@ heap_pre_freeze_checks(Buffer buffer,
+ if (unlikely(TransactionIdDidCommit(xmax)))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("cannot freeze committed xmax %u",
+- xmax)));
++ errmsg_internal("cannot freeze non-aborted xmax %llu",
++ (unsigned long long) xmax)));
+ }
+ }
+ }
+diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
+index 1c6da286d4..97aad71eed 100644
+--- a/src/backend/access/heap/heapam_handler.c
++++ b/src/backend/access/heap/heapam_handler.c
+@@ -434,8 +434,8 @@ tuple_lock_retry:
+ if (TransactionIdIsValid(SnapshotDirty.xmin))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("t_xmin %u is uncommitted in tuple (%u,%u) to be updated in table \"%s\"",
+- SnapshotDirty.xmin,
++ errmsg_internal("t_xmin %llu is uncommitted in tuple (%u,%u) to be updated in table \"%s\"",
++ (unsigned long long) SnapshotDirty.xmin,
+ ItemPointerGetBlockNumber(&tuple->t_self),
+ ItemPointerGetOffsetNumber(&tuple->t_self),
+ RelationGetRelationName(relation))));
+diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
+index d82aa3d489..4f21429341 100644
+--- a/src/backend/access/heap/vacuumlazy.c
++++ b/src/backend/access/heap/vacuumlazy.c
+@@ -679,23 +679,26 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ diff = (int32) (ReadNextTransactionId() -
+ vacrel->cutoffs.OldestXmin);
+ appendStringInfo(&buf,
+- _("removable cutoff: %u, which was %d XIDs old when operation ended\n"),
+- vacrel->cutoffs.OldestXmin, diff);
++ _("removable cutoff: %llu, which was %lld XIDs old when operation ended\n"),
++ (unsigned long long) vacrel->cutoffs.OldestXmin,
++ (long long) diff);
+ if (frozenxid_updated)
+ {
+ diff = (int32) (vacrel->NewRelfrozenXid -
+ vacrel->cutoffs.relfrozenxid);
+ appendStringInfo(&buf,
+- _("new relfrozenxid: %u, which is %d XIDs ahead of previous value\n"),
+- vacrel->NewRelfrozenXid, diff);
++ _("new relfrozenxid: %llu, which is %lld XIDs ahead of previous value\n"),
++ (unsigned long long) vacrel->NewRelfrozenXid,
++ (long long) diff);
+ }
+ if (minmulti_updated)
+ {
+ diff = (int32) (vacrel->NewRelminMxid -
+ vacrel->cutoffs.relminmxid);
+ appendStringInfo(&buf,
+- _("new relminmxid: %u, which is %d MXIDs ahead of previous value\n"),
+- vacrel->NewRelminMxid, diff);
++ _("new relminmxid: %llu, which is %lld MXIDs ahead of previous value\n"),
++ (unsigned long long) vacrel->NewRelminMxid,
++ (long long) diff);
+ }
+ appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %lld tuples frozen\n"),
+ vacrel->frozen_pages,
+diff --git a/src/backend/access/rmgrdesc/clogdesc.c b/src/backend/access/rmgrdesc/clogdesc.c
+index c1d47c219f..060f0347b7 100644
+--- a/src/backend/access/rmgrdesc/clogdesc.c
++++ b/src/backend/access/rmgrdesc/clogdesc.c
+@@ -35,8 +35,9 @@ clog_desc(StringInfo buf, XLogReaderState *record)
+ xl_clog_truncate xlrec;
+
+ memcpy(&xlrec, rec, sizeof(xl_clog_truncate));
+- appendStringInfo(buf, "page %lld; oldestXact %u",
+- (long long) xlrec.pageno, xlrec.oldestXact);
++ appendStringInfo(buf, "page %lld; oldestXact %llu",
++ (long long) xlrec.pageno,
++ (unsigned long long) xlrec.oldestXact);
+ }
+ }
+
+diff --git a/src/backend/access/rmgrdesc/committsdesc.c b/src/backend/access/rmgrdesc/committsdesc.c
+index f5f09a1bc7..51e1db6b21 100644
+--- a/src/backend/access/rmgrdesc/committsdesc.c
++++ b/src/backend/access/rmgrdesc/committsdesc.c
+@@ -34,8 +34,9 @@ commit_ts_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_commit_ts_truncate *trunc = (xl_commit_ts_truncate *) rec;
+
+- appendStringInfo(buf, "pageno %lld, oldestXid %u",
+- (long long) trunc->pageno, trunc->oldestXid);
++ appendStringInfo(buf, "pageno %lld, oldestXid %llu",
++ (long long) trunc->pageno,
++ (unsigned long long) trunc->oldestXid);
+ }
+ }
+
+diff --git a/src/backend/access/rmgrdesc/gistdesc.c b/src/backend/access/rmgrdesc/gistdesc.c
+index 5efbbf72e5..f21567fa7b 100644
+--- a/src/backend/access/rmgrdesc/gistdesc.c
++++ b/src/backend/access/rmgrdesc/gistdesc.c
+@@ -25,19 +25,20 @@ out_gistxlogPageUpdate(StringInfo buf, gistxlogPageUpdate *xlrec)
+ static void
+ out_gistxlogPageReuse(StringInfo buf, gistxlogPageReuse *xlrec)
+ {
+- appendStringInfo(buf, "rel %u/%u/%u; blk %u; snapshotConflictHorizon %u:%u, isCatalogRel %c",
++ appendStringInfo(buf, "rel %u/%u/%u; blk %u; snapshotConflictHorizon %u:%llu, isCatalogRel %c",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber, xlrec->block,
+ EpochFromFullTransactionId(xlrec->snapshotConflictHorizon),
+- XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
++ (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
+ xlrec->isCatalogRel ? 'T' : 'F');
+ }
+
+ static void
+ out_gistxlogDelete(StringInfo buf, gistxlogDelete *xlrec)
+ {
+- appendStringInfo(buf, "delete: snapshotConflictHorizon %u, nitems: %u, isCatalogRel %c",
+- xlrec->snapshotConflictHorizon, xlrec->ntodelete,
++ appendStringInfo(buf, "delete: snapshotConflictHorizon %llu, nitems: %u, isCatalogRel %c",
++ (unsigned long long) xlrec->snapshotConflictHorizon,
++ xlrec->ntodelete,
+ xlrec->isCatalogRel ? 'T' : 'F');
+ }
+
+@@ -51,9 +52,9 @@ out_gistxlogPageSplit(StringInfo buf, gistxlogPageSplit *xlrec)
+ static void
+ out_gistxlogPageDelete(StringInfo buf, gistxlogPageDelete *xlrec)
+ {
+- appendStringInfo(buf, "deleteXid %u:%u; downlink %u",
++ appendStringInfo(buf, "deleteXid %u:%llu; downlink %u",
+ EpochFromFullTransactionId(xlrec->deleteXid),
+- XidFromFullTransactionId(xlrec->deleteXid),
++ (unsigned long long) XidFromFullTransactionId(xlrec->deleteXid),
+ xlrec->downlinkOffset);
+ }
+
+diff --git a/src/backend/access/rmgrdesc/hashdesc.c b/src/backend/access/rmgrdesc/hashdesc.c
+index dd0bfff8cb..4d20585843 100644
+--- a/src/backend/access/rmgrdesc/hashdesc.c
++++ b/src/backend/access/rmgrdesc/hashdesc.c
+@@ -113,9 +113,9 @@ hash_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_hash_vacuum_one_page *xlrec = (xl_hash_vacuum_one_page *) rec;
+
+- appendStringInfo(buf, "ntuples %d, snapshotConflictHorizon %u, isCatalogRel %c",
++ appendStringInfo(buf, "ntuples %d, snapshotConflictHorizon %llu, isCatalogRel %c",
+ xlrec->ntuples,
+- xlrec->snapshotConflictHorizon,
++ (unsigned long long) xlrec->snapshotConflictHorizon,
+ xlrec->isCatalogRel ? 'T' : 'F');
+ break;
+ }
+diff --git a/src/backend/access/rmgrdesc/heapdesc.c b/src/backend/access/rmgrdesc/heapdesc.c
+index 5f5673e088..09268c2a34 100644
+--- a/src/backend/access/rmgrdesc/heapdesc.c
++++ b/src/backend/access/rmgrdesc/heapdesc.c
+@@ -77,8 +77,8 @@ plan_elem_desc(StringInfo buf, void *plan, void *data)
+ xlhp_freeze_plan *new_plan = (xlhp_freeze_plan *) plan;
+ OffsetNumber **offsets = data;
+
+- appendStringInfo(buf, "{ xmax: %u, infomask: %u, infomask2: %u, ntuples: %u",
+- new_plan->xmax,
++ appendStringInfo(buf, "{ xmax: %llu, infomask: %u, infomask2: %u, ntuples: %u",
++ (unsigned long long) new_plan->xmax,
+ new_plan->t_infomask, new_plan->t_infomask2,
+ new_plan->ntuples);
+
+@@ -198,8 +198,8 @@ heap_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_heap_delete *xlrec = (xl_heap_delete *) rec;
+
+- appendStringInfo(buf, "xmax: %u, off: %u, ",
+- xlrec->xmax, xlrec->offnum);
++ appendStringInfo(buf, "xmax: %llu, off: %u, ",
++ (unsigned long long) xlrec->xmax, xlrec->offnum);
+ infobits_desc(buf, xlrec->infobits_set, "infobits");
+ appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
+ }
+@@ -207,21 +207,26 @@ heap_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_heap_update *xlrec = (xl_heap_update *) rec;
+
+- appendStringInfo(buf, "old_xmax: %u, old_off: %u, ",
+- xlrec->old_xmax, xlrec->old_offnum);
++ appendStringInfo(buf, "old_xmax: %llu, old_off: %u, ",
++ (unsigned long long) xlrec->old_xmax,
++ xlrec->old_offnum);
+ infobits_desc(buf, xlrec->old_infobits_set, "old_infobits");
+- appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %u, new_off: %u",
+- xlrec->flags, xlrec->new_xmax, xlrec->new_offnum);
++ appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %llu, new_off: %u",
++ xlrec->flags,
++ (unsigned long long) xlrec->new_xmax,
++ xlrec->new_offnum);
+ }
+ else if (info == XLOG_HEAP_HOT_UPDATE)
+ {
+ xl_heap_update *xlrec = (xl_heap_update *) rec;
+
+- appendStringInfo(buf, "old_xmax: %u, old_off: %u, ",
+- xlrec->old_xmax, xlrec->old_offnum);
++ appendStringInfo(buf, "old_xmax: %llu, old_off: %u, ",
++ (unsigned long long) xlrec->old_xmax,
++ xlrec->old_offnum);
+ infobits_desc(buf, xlrec->old_infobits_set, "old_infobits");
+- appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %u, new_off: %u",
+- xlrec->flags, xlrec->new_xmax, xlrec->new_offnum);
++ appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %llu, new_off: %u",
++ xlrec->flags, (unsigned long long) xlrec->new_xmax,
++ xlrec->new_offnum);
+ }
+ else if (info == XLOG_HEAP_TRUNCATE)
+ {
+@@ -243,8 +248,8 @@ heap_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_heap_lock *xlrec = (xl_heap_lock *) rec;
+
+- appendStringInfo(buf, "xmax: %u, off: %u, ",
+- xlrec->xmax, xlrec->offnum);
++ appendStringInfo(buf, "xmax: %llu, off: %u, ",
++ (unsigned long long) xlrec->xmax, xlrec->offnum);
+ infobits_desc(buf, xlrec->infobits_set, "infobits");
+ appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
+ }
+@@ -275,6 +280,7 @@ heap2_desc(StringInfo buf, XLogReaderState *record)
+
+ memcpy(&conflict_xid, rec + SizeOfHeapPrune, sizeof(TransactionId));
+
++ /* XXX 64-bit conflict xid? - a.alekseev */
+ appendStringInfo(buf, "snapshotConflictHorizon: %u",
+ conflict_xid);
+ }
+@@ -339,8 +345,9 @@ heap2_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_heap_visible *xlrec = (xl_heap_visible *) rec;
+
+- appendStringInfo(buf, "snapshotConflictHorizon: %u, flags: 0x%02X",
+- xlrec->snapshotConflictHorizon, xlrec->flags);
++ appendStringInfo(buf, "snapshotConflictHorizon: %llu, flags: 0x%02X",
++ (unsigned long long) xlrec->snapshotConflictHorizon,
++ xlrec->flags);
+ }
+ else if (info == XLOG_HEAP2_MULTI_INSERT)
+ {
+@@ -361,8 +368,8 @@ heap2_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_heap_lock_updated *xlrec = (xl_heap_lock_updated *) rec;
+
+- appendStringInfo(buf, "xmax: %u, off: %u, ",
+- xlrec->xmax, xlrec->offnum);
++ appendStringInfo(buf, "xmax: %llu, off: %u, ",
++ (unsigned long long) xlrec->xmax, xlrec->offnum);
+ infobits_desc(buf, xlrec->infobits_set, "infobits");
+ appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
+ }
+diff --git a/src/backend/access/rmgrdesc/mxactdesc.c b/src/backend/access/rmgrdesc/mxactdesc.c
+index 1b486de38c..7b32bec943 100644
+--- a/src/backend/access/rmgrdesc/mxactdesc.c
++++ b/src/backend/access/rmgrdesc/mxactdesc.c
+@@ -19,7 +19,7 @@
+ static void
+ out_member(StringInfo buf, MultiXactMember *member)
+ {
+- appendStringInfo(buf, "%u ", member->xid);
++ appendStringInfo(buf, "%llu ", (unsigned long long) member->xid);
+ switch (member->status)
+ {
+ case MultiXactStatusForKeyShare:
+@@ -65,7 +65,8 @@ multixact_desc(StringInfo buf, XLogReaderState *record)
+ xl_multixact_create *xlrec = (xl_multixact_create *) rec;
+ int i;
+
+- appendStringInfo(buf, "%u offset %llu nmembers %d: ", xlrec->mid,
++ appendStringInfo(buf, "%llu offset %llu nmembers %d: ",
++ (unsigned long long) xlrec->mid,
+ (unsigned long long) xlrec->moff, xlrec->nmembers);
+ for (i = 0; i < xlrec->nmembers; i++)
+ out_member(buf, &xlrec->members[i]);
+@@ -74,8 +75,9 @@ multixact_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_multixact_truncate *xlrec = (xl_multixact_truncate *) rec;
+
+- appendStringInfo(buf, "offsets [%u, %u), members [%llu, %llu)",
+- xlrec->startTruncOff, xlrec->endTruncOff,
++ appendStringInfo(buf, "offsets [%llu, %llu), members [%llu, %llu)",
++ (unsigned long long) xlrec->startTruncOff,
++ (unsigned long long) xlrec->endTruncOff,
+ (unsigned long long) xlrec->startTruncMemb,
+ (unsigned long long) xlrec->endTruncMemb);
+ }
+diff --git a/src/backend/access/rmgrdesc/nbtdesc.c b/src/backend/access/rmgrdesc/nbtdesc.c
+index 0f201ca223..ce7a7a83cb 100644
+--- a/src/backend/access/rmgrdesc/nbtdesc.c
++++ b/src/backend/access/rmgrdesc/nbtdesc.c
+@@ -71,8 +71,8 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_btree_delete *xlrec = (xl_btree_delete *) rec;
+
+- appendStringInfo(buf, "snapshotConflictHorizon: %u, ndeleted: %u, nupdated: %u, isCatalogRel: %c",
+- xlrec->snapshotConflictHorizon,
++ appendStringInfo(buf, "snapshotConflictHorizon: %llu, ndeleted: %u, nupdated: %u, isCatalogRel: %c",
++ (unsigned long long) xlrec->snapshotConflictHorizon,
+ xlrec->ndeleted, xlrec->nupdated,
+ xlrec->isCatalogRel ? 'T' : 'F');
+
+@@ -94,10 +94,10 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_btree_unlink_page *xlrec = (xl_btree_unlink_page *) rec;
+
+- appendStringInfo(buf, "left: %u, right: %u, level: %u, safexid: %u:%u, ",
++ appendStringInfo(buf, "left: %u, right: %u, level: %u, safexid: %u:%llu, ",
+ xlrec->leftsib, xlrec->rightsib, xlrec->level,
+ EpochFromFullTransactionId(xlrec->safexid),
+- XidFromFullTransactionId(xlrec->safexid));
++ (unsigned long long) XidFromFullTransactionId(xlrec->safexid));
+ appendStringInfo(buf, "leafleft: %u, leafright: %u, leaftopparent: %u",
+ xlrec->leafleftsib, xlrec->leafrightsib,
+ xlrec->leaftopparent);
+@@ -114,11 +114,11 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_btree_reuse_page *xlrec = (xl_btree_reuse_page *) rec;
+
+- appendStringInfo(buf, "rel: %u/%u/%u, snapshotConflictHorizon: %u:%u, isCatalogRel: %c",
++ appendStringInfo(buf, "rel: %u/%u/%u, snapshotConflictHorizon: %u:%llu, isCatalogRel: %c",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber,
+ EpochFromFullTransactionId(xlrec->snapshotConflictHorizon),
+- XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
++ (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
+ xlrec->isCatalogRel ? 'T' : 'F');
+ break;
+ }
+diff --git a/src/backend/access/rmgrdesc/spgdesc.c b/src/backend/access/rmgrdesc/spgdesc.c
+index e75971100c..f4c0e73700 100644
+--- a/src/backend/access/rmgrdesc/spgdesc.c
++++ b/src/backend/access/rmgrdesc/spgdesc.c
+@@ -118,10 +118,10 @@ spg_desc(StringInfo buf, XLogReaderState *record)
+ {
+ spgxlogVacuumRedirect *xlrec = (spgxlogVacuumRedirect *) rec;
+
+- appendStringInfo(buf, "ntoplaceholder: %u, firstplaceholder: %u, snapshotConflictHorizon: %u, isCatalogRel: %c",
++ appendStringInfo(buf, "ntoplaceholder: %u, firstplaceholder: %u, snapshotConflictHorizon: %llu, isCatalogRel: %c",
+ xlrec->nToPlaceholder,
+ xlrec->firstPlaceholder,
+- xlrec->snapshotConflictHorizon,
++ (unsigned long long) xlrec->snapshotConflictHorizon,
+ xlrec->isCatalogRel ? 'T' : 'F');
+ }
+ break;
+diff --git a/src/backend/access/rmgrdesc/standbydesc.c b/src/backend/access/rmgrdesc/standbydesc.c
+index 25f870b187..97ab1ae7a6 100644
+--- a/src/backend/access/rmgrdesc/standbydesc.c
++++ b/src/backend/access/rmgrdesc/standbydesc.c
+@@ -21,15 +21,15 @@ standby_desc_running_xacts(StringInfo buf, xl_running_xacts *xlrec)
+ {
+ int i;
+
+- appendStringInfo(buf, "nextXid %u latestCompletedXid %u oldestRunningXid %u",
+- xlrec->nextXid,
+- xlrec->latestCompletedXid,
+- xlrec->oldestRunningXid);
++ appendStringInfo(buf, "nextXid %llu latestCompletedXid %llu oldestRunningXid %llu",
++ (unsigned long long) xlrec->nextXid,
++ (unsigned long long) xlrec->latestCompletedXid,
++ (unsigned long long) xlrec->oldestRunningXid);
+ if (xlrec->xcnt > 0)
+ {
+ appendStringInfo(buf, "; %d xacts:", xlrec->xcnt);
+ for (i = 0; i < xlrec->xcnt; i++)
+- appendStringInfo(buf, " %u", xlrec->xids[i]);
++ appendStringInfo(buf, " %llu", (unsigned long long) xlrec->xids[i]);
+ }
+
+ if (xlrec->subxid_overflow)
+@@ -39,7 +39,8 @@ standby_desc_running_xacts(StringInfo buf, xl_running_xacts *xlrec)
+ {
+ appendStringInfo(buf, "; %d subxacts:", xlrec->subxcnt);
+ for (i = 0; i < xlrec->subxcnt; i++)
+- appendStringInfo(buf, " %u", xlrec->xids[xlrec->xcnt + i]);
++ appendStringInfo(buf, " %llu",
++ (unsigned long long) xlrec->xids[xlrec->xcnt + i]);
+ }
+ }
+
+@@ -55,8 +56,9 @@ standby_desc(StringInfo buf, XLogReaderState *record)
+ int i;
+
+ for (i = 0; i < xlrec->nlocks; i++)
+- appendStringInfo(buf, "xid %u db %u rel %u ",
+- xlrec->locks[i].xid, xlrec->locks[i].dbOid,
++ appendStringInfo(buf, "xid %llu db %u rel %u ",
++ (unsigned long long) xlrec->locks[i].xid,
++ xlrec->locks[i].dbOid,
+ xlrec->locks[i].relOid);
+ }
+ else if (info == XLOG_RUNNING_XACTS)
+diff --git a/src/backend/access/rmgrdesc/xactdesc.c b/src/backend/access/rmgrdesc/xactdesc.c
+index 889cb955c1..d8ff6be390 100644
+--- a/src/backend/access/rmgrdesc/xactdesc.c
++++ b/src/backend/access/rmgrdesc/xactdesc.c
+@@ -304,7 +304,7 @@ xact_desc_subxacts(StringInfo buf, int nsubxacts, TransactionId *subxacts)
+ {
+ appendStringInfoString(buf, "; subxacts:");
+ for (i = 0; i < nsubxacts; i++)
+- appendStringInfo(buf, " %u", subxacts[i]);
++ appendStringInfo(buf, " %llu", (unsigned long long) subxacts[i]);
+ }
+ }
+
+@@ -339,7 +339,7 @@ xact_desc_commit(StringInfo buf, uint8 info, xl_xact_commit *xlrec, RepOriginId
+
+ /* If this is a prepared xact, show the xid of the original xact */
+ if (TransactionIdIsValid(parsed.twophase_xid))
+- appendStringInfo(buf, "%u: ", parsed.twophase_xid);
++ appendStringInfo(buf, "%llu: ", (unsigned long long) parsed.twophase_xid);
+
+ appendStringInfoString(buf, timestamptz_to_str(xlrec->xact_time));
+
+@@ -375,7 +375,7 @@ xact_desc_abort(StringInfo buf, uint8 info, xl_xact_abort *xlrec, RepOriginId or
+
+ /* If this is a prepared xact, show the xid of the original xact */
+ if (TransactionIdIsValid(parsed.twophase_xid))
+- appendStringInfo(buf, "%u: ", parsed.twophase_xid);
++ appendStringInfo(buf, "%llu: ", (unsigned long long) parsed.twophase_xid);
+
+ appendStringInfoString(buf, timestamptz_to_str(xlrec->xact_time));
+
+@@ -432,7 +432,7 @@ xact_desc_assignment(StringInfo buf, xl_xact_assignment *xlrec)
+ appendStringInfoString(buf, "subxacts:");
+
+ for (i = 0; i < xlrec->nsubxacts; i++)
+- appendStringInfo(buf, " %u", xlrec->xsub[i]);
++ appendStringInfo(buf, " %llu", (unsigned long long) xlrec->xsub[i]);
+ }
+
+ void
+@@ -471,7 +471,7 @@ xact_desc(StringInfo buf, XLogReaderState *record)
+ * interested in the top-level xid that issued the record and which
+ * xids are being reported here.
+ */
+- appendStringInfo(buf, "xtop %u: ", xlrec->xtop);
++ appendStringInfo(buf, "xtop %llu: ", (unsigned long long) xlrec->xtop);
+ xact_desc_assignment(buf, xlrec);
+ }
+ else if (info == XLOG_XACT_INVALIDATIONS)
+diff --git a/src/backend/access/rmgrdesc/xlogdesc.c b/src/backend/access/rmgrdesc/xlogdesc.c
+index aaa19c81c8..f41f7d963b 100644
+--- a/src/backend/access/rmgrdesc/xlogdesc.c
++++ b/src/backend/access/rmgrdesc/xlogdesc.c
+@@ -66,27 +66,27 @@ xlog_desc(StringInfo buf, XLogReaderState *record)
+ CheckPoint *checkpoint = (CheckPoint *) rec;
+
+ appendStringInfo(buf, "redo %X/%X; "
+- "tli %u; prev tli %u; fpw %s; wal_level %s; xid %u:%u; oid %u; multi %u; offset %llu; "
+- "oldest xid %u in DB %u; oldest multi %u in DB %u; "
+- "oldest/newest commit timestamp xid: %u/%u; "
+- "oldest running xid %u; %s",
++ "tli %u; prev tli %u; fpw %s; wal_level %s; xid %u:%llu; oid %u; multi %llu; offset %llu; "
++ "oldest xid %llu in DB %u; oldest multi %llu in DB %u; "
++ "oldest/newest commit timestamp xid: %llu/%llu; "
++ "oldest running xid %llu; %s",
+ LSN_FORMAT_ARGS(checkpoint->redo),
+ checkpoint->ThisTimeLineID,
+ checkpoint->PrevTimeLineID,
+ checkpoint->fullPageWrites ? "true" : "false",
+ get_wal_level_string(checkpoint->wal_level),
+ EpochFromFullTransactionId(checkpoint->nextXid),
+- XidFromFullTransactionId(checkpoint->nextXid),
++ (unsigned long long) XidFromFullTransactionId(checkpoint->nextXid),
+ checkpoint->nextOid,
+- checkpoint->nextMulti,
++ (unsigned long long) checkpoint->nextMulti,
+ (unsigned long long) checkpoint->nextMultiOffset,
+- checkpoint->oldestXid,
++ (unsigned long long) checkpoint->oldestXid,
+ checkpoint->oldestXidDB,
+- checkpoint->oldestMulti,
++ (unsigned long long) checkpoint->oldestMulti,
+ checkpoint->oldestMultiDB,
+- checkpoint->oldestCommitTsXid,
+- checkpoint->newestCommitTsXid,
+- checkpoint->oldestActiveXid,
++ (unsigned long long) checkpoint->oldestCommitTsXid,
++ (unsigned long long) checkpoint->newestCommitTsXid,
++ (unsigned long long) checkpoint->oldestActiveXid,
+ (info == XLOG_CHECKPOINT_SHUTDOWN) ? "shutdown" : "online");
+ }
+ else if (info == XLOG_NEXTOID)
+diff --git a/src/backend/access/transam/commit_ts.c b/src/backend/access/transam/commit_ts.c
+index 77e1899d7a..00c1f29302 100644
+--- a/src/backend/access/transam/commit_ts.c
++++ b/src/backend/access/transam/commit_ts.c
+@@ -284,7 +284,8 @@ TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts,
+ if (!TransactionIdIsValid(xid))
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+- errmsg("cannot retrieve commit timestamp for transaction %u", xid)));
++ errmsg("cannot retrieve commit timestamp for transaction %llu",
++ (unsigned long long) xid)));
+ else if (!TransactionIdIsNormal(xid))
+ {
+ /* frozen and bootstrap xids are always committed far in the past */
+diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
+index c51e03e832..1bcead11f5 100644
+--- a/src/backend/access/transam/multixact.c
++++ b/src/backend/access/transam/multixact.c
+@@ -486,8 +486,9 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
+ /* MultiXactIdSetOldestMember() must have been called already. */
+ Assert(MultiXactIdIsValid(OldestMemberMXactId[MyProcNumber]));
+
+- debug_elog5(DEBUG2, "Expand: received multi %u, xid %u status %s",
+- multi, xid, mxstatus_to_string(status));
++ debug_elog5(DEBUG2, "Expand: received multi %llu, xid %llu status %s",
++ (unsigned long long) multi, (unsigned long long) xid,
++ mxstatus_to_string(status));
+
+ /*
+ * Note: we don't allow for old multis here. The reason is that the only
+@@ -511,8 +512,8 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
+ member.status = status;
+ newMulti = MultiXactIdCreateFromMembers(1, &member);
+
+- debug_elog4(DEBUG2, "Expand: %u has no members, create singleton %u",
+- multi, newMulti);
++ debug_elog4(DEBUG2, "Expand: %llu has no members, create singleton %llu",
++ (unsigned long long) multi, (unsigned long long) newMulti);
+ return newMulti;
+ }
+
+@@ -525,8 +526,8 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
+ if (TransactionIdEquals(members[i].xid, xid) &&
+ (members[i].status == status))
+ {
+- debug_elog4(DEBUG2, "Expand: %u is already a member of %u",
+- xid, multi);
++ debug_elog4(DEBUG2, "Expand: %llu is already a member of %llu",
++ (unsigned long long) xid, (unsigned long long) multi);
+ pfree(members);
+ return multi;
+ }
+@@ -561,12 +562,14 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
+
+ newMembers[j].xid = xid;
+ newMembers[j++].status = status;
++
+ newMulti = MultiXactIdCreateFromMembers(j, newMembers);
+
+ pfree(members);
+ pfree(newMembers);
+
+- debug_elog3(DEBUG2, "Expand: returning new multi %u", newMulti);
++ debug_elog3(DEBUG2, "Expand: returning new multi %llu",
++ (unsigned long long) newMulti);
+
+ return newMulti;
+ }
+@@ -589,7 +592,7 @@ MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly)
+ int nmembers;
+ int i;
+
+- debug_elog3(DEBUG2, "IsRunning %u?", multi);
++ debug_elog3(DEBUG2, "IsRunning %llu?", (unsigned long long) multi);
+
+ /*
+ * "false" here means we assume our callers have checked that the given
+@@ -629,8 +632,8 @@ MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly)
+ {
+ if (TransactionIdIsInProgress(members[i].xid))
+ {
+- debug_elog4(DEBUG2, "IsRunning: member %d (%u) is running",
+- i, members[i].xid);
++ debug_elog4(DEBUG2, "IsRunning: member %d (%llu) is running", i,
++ (unsigned long long) members[i].xid);
+ pfree(members);
+ return true;
+ }
+@@ -638,7 +641,8 @@ MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly)
+
+ pfree(members);
+
+- debug_elog3(DEBUG2, "IsRunning: %u is not running", multi);
++ debug_elog3(DEBUG2, "IsRunning: %llu is not running",
++ (unsigned long long) multi);
+
+ return false;
+ }
+@@ -692,8 +696,8 @@ MultiXactIdSetOldestMember(void)
+
+ LWLockRelease(MultiXactGenLock);
+
+- debug_elog4(DEBUG2, "MultiXact: setting OldestMember[%d] = %u",
+- MyProcNumber, nextMXact);
++ debug_elog4(DEBUG2, "MultiXact: setting OldestMember[%d] = %llu",
++ MyProcNumber, (unsigned long long) nextMXact);
+ }
+ }
+
+@@ -745,8 +749,8 @@ MultiXactIdSetOldestVisible(void)
+
+ LWLockRelease(MultiXactGenLock);
+
+- debug_elog4(DEBUG2, "MultiXact: setting OldestVisible[%d] = %u",
+- MyProcNumber, oldestMXact);
++ debug_elog4(DEBUG2, "MultiXact: setting OldestVisible[%d] = %llu",
++ MyProcNumber, (unsigned long long) oldestMXact);
+ }
+ }
+
+@@ -1179,7 +1183,8 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+
+ LWLockRelease(MultiXactGenLock);
+
+- debug_elog4(DEBUG2, "GetNew: returning %u offset %llu", result,
++ debug_elog4(DEBUG2, "GetNew: returning %llu offset %llu",
++ (unsigned long long) result,
+ (unsigned long long) *offset);
+ return result;
+ }
+@@ -1231,7 +1236,8 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
+ LWLock *lock;
+ bool slept = false;
+
+- debug_elog3(DEBUG2, "GetMembers: asked for %u", multi);
++ debug_elog3(DEBUG2, "GetMembers: asked for %llu",
++ (unsigned long long) multi);
+
+ if (!MultiXactIdIsValid(multi) || from_pgupgrade)
+ {
+@@ -1290,14 +1296,14 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
+ if (MultiXactIdPrecedes(multi, oldestMXact))
+ ereport(ERROR,
+ (errcode(ERRCODE_INTERNAL_ERROR),
+- errmsg("MultiXactId %u does no longer exist -- apparent wraparound",
+- multi)));
++ errmsg("MultiXactId %llu does no longer exist -- apparent wraparound",
++ (unsigned long long) multi)));
+
+ if (!MultiXactIdPrecedes(multi, nextMXact))
+ ereport(ERROR,
+ (errcode(ERRCODE_INTERNAL_ERROR),
+- errmsg("MultiXactId %u has not been created yet -- apparent wraparound",
+- multi)));
++ errmsg("MultiXactId %llu has not been created yet -- apparent wraparound",
++ (unsigned long long) multi)));
+
+ /*
+ * Find out the offset at which we need to start reading MultiXactMembers
+@@ -1556,7 +1562,8 @@ mXactCacheGetBySet(int nmembers, MultiXactMember *members)
+ */
+ if (memcmp(members, entry->members, nmembers * sizeof(MultiXactMember)) == 0)
+ {
+- debug_elog3(DEBUG2, "CacheGet: found %u", entry->multi);
++ debug_elog3(DEBUG2, "CacheGet: found %llu",
++ (unsigned long long) entry->multi);
+ dclist_move_head(&MXactCache, iter.cur);
+ return entry->multi;
+ }
+@@ -1579,7 +1586,8 @@ mXactCacheGetById(MultiXactId multi, MultiXactMember **members)
+ {
+ dlist_iter iter;
+
+- debug_elog3(DEBUG2, "CacheGet: looking for %u", multi);
++ debug_elog3(DEBUG2, "CacheGet: looking for %llu",
++ (unsigned long long) multi);
+
+ dclist_foreach(iter, &MXactCache)
+ {
+@@ -1659,8 +1667,8 @@ mXactCachePut(MultiXactId multi, int nmembers, MultiXactMember *members)
+ dclist_delete_from(&MXactCache, node);
+
+ entry = dclist_container(mXactCacheEnt, node, node);
+- debug_elog3(DEBUG2, "CachePut: pruning cached multi %u",
+- entry->multi);
++ debug_elog3(DEBUG2, "CachePut: pruning cached multi %llu",
++ (unsigned long long) entry->multi);
+
+ pfree(entry);
+ }
+@@ -1701,11 +1709,13 @@ mxid_to_string(MultiXactId multi, int nmembers, MultiXactMember *members)
+
+ initStringInfo(&buf);
+
+- appendStringInfo(&buf, "%u %d[%u (%s)", multi, nmembers, members[0].xid,
++ appendStringInfo(&buf, "%llu %d[%llu (%s)", (unsigned long long) multi,
++ nmembers, (unsigned long long) members[0].xid,
+ mxstatus_to_string(members[0].status));
+
+ for (i = 1; i < nmembers; i++)
+- appendStringInfo(&buf, ", %u (%s)", members[i].xid,
++ appendStringInfo(&buf, ", %llu (%s)",
++ (unsigned long long) members[i].xid,
+ mxstatus_to_string(members[i].status));
+
+ appendStringInfoChar(&buf, ']');
+@@ -2209,8 +2219,10 @@ MultiXactGetCheckptMulti(bool is_shutdown,
+ LWLockRelease(MultiXactGenLock);
+
+ debug_elog6(DEBUG2,
+- "MultiXact: checkpoint is nextMulti %u, nextOffset %llu, oldestMulti %u in DB %u",
+- *nextMulti, (unsigned long long) *nextMultiOffset, *oldestMulti,
++ "MultiXact: checkpoint is nextMulti %llu, nextOffset %llu, oldestMulti %llu in DB %u",
++ (unsigned long long) *nextMulti,
++ (unsigned long long) *nextMultiOffset,
++ (unsigned long long) *oldestMulti,
+ *oldestMultiDB);
+ }
+
+@@ -2245,8 +2257,9 @@ void
+ MultiXactSetNextMXact(MultiXactId nextMulti,
+ MultiXactOffset nextMultiOffset)
+ {
+- debug_elog4(DEBUG2, "MultiXact: setting next multi to %u offset %llu",
+- nextMulti, (unsigned long long) nextMultiOffset);
++ debug_elog4(DEBUG2, "MultiXact: setting next multi to %llu offset %llu",
++ (unsigned long long) nextMulti,
++ (unsigned long long) nextMultiOffset);
+ LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
+ MultiXactState->nextMXact = nextMulti;
+ MultiXactState->nextOffset = nextMultiOffset;
+@@ -2431,7 +2444,8 @@ MultiXactAdvanceNextMXact(MultiXactId minMulti,
+ LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
+ if (MultiXactIdPrecedes(MultiXactState->nextMXact, minMulti))
+ {
+- debug_elog3(DEBUG2, "MultiXact: setting next multi to %u", minMulti);
++ debug_elog3(DEBUG2, "MultiXact: setting next multi to %llu",
++ (unsigned long long) minMulti);
+ MultiXactState->nextMXact = minMulti;
+ }
+ if (MultiXactOffsetPrecedes(MultiXactState->nextOffset, minMultiOffset))
+@@ -2682,8 +2696,8 @@ SetOffsetVacuumLimit(bool is_startup)
+
+ if (!oldestOffsetKnown)
+ ereport(LOG,
+- (errmsg("MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %u does not exist on disk",
+- oldestMultiXactId)));
++ (errmsg("MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %llu does not exist on disk",
++ (unsigned long long) oldestMultiXactId)));
+ }
+
+ LWLockRelease(MultiXactTruncationLock);
+@@ -3029,8 +3043,9 @@ TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
+ else if (!find_multixact_start(oldestMulti, &oldestOffset))
+ {
+ ereport(LOG,
+- (errmsg("oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation",
+- oldestMulti, earliest)));
++ (errmsg("oldest MultiXact %llu not found, earliest MultiXact %llu, skipping truncation",
++ (unsigned long long) oldestMulti,
++ (unsigned long long) earliest)));
+ LWLockRelease(MultiXactTruncationLock);
+ return;
+ }
+@@ -3047,20 +3062,20 @@ TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
+ else if (!find_multixact_start(newOldestMulti, &newOldestOffset))
+ {
+ ereport(LOG,
+- (errmsg("cannot truncate up to MultiXact %u because it does not exist on disk, skipping truncation",
+- newOldestMulti)));
++ (errmsg("cannot truncate up to MultiXact %llu because it does not exist on disk, skipping truncation",
++ (unsigned long long) newOldestMulti)));
+ LWLockRelease(MultiXactTruncationLock);
+ return;
+ }
+
+ elog(DEBUG1, "performing multixact truncation: "
+- "offsets [%u, %u), offsets segments [%llx, %llx), "
+- "members [%llu, %llu), members segments [%llx, %llx)",
+- oldestMulti, newOldestMulti,
++ "offsets [%llu, %llu), offsets segments [%llx, %llx), "
++ "members [%lld, %lld), members segments [%llx, %llx)",
++ (unsigned long long) oldestMulti, (unsigned long long) newOldestMulti,
+ (unsigned long long) MultiXactIdToOffsetSegment(oldestMulti),
+ (unsigned long long) MultiXactIdToOffsetSegment(newOldestMulti),
+- (unsigned long long) oldestOffset,
+- (unsigned long long) newOldestOffset,
++ (long long) oldestOffset,
++ (long long) newOldestOffset,
+ (unsigned long long) MXOffsetToMemberSegment(oldestOffset),
+ (unsigned long long) MXOffsetToMemberSegment(newOldestOffset));
+
+@@ -3315,9 +3330,10 @@ multixact_redo(XLogReaderState *record)
+ SizeOfMultiXactTruncate);
+
+ elog(DEBUG1, "replaying multixact truncation: "
+- "offsets [%u, %u), offsets segments [%llx, %llx), "
++ "offsets [%llu, %llu), offsets segments [%llx, %llx), "
+ "members [%llu, %llu), members segments [%llx, %llx)",
+- xlrec.startTruncOff, xlrec.endTruncOff,
++ (unsigned long long) xlrec.startTruncOff,
++ (unsigned long long) xlrec.endTruncOff,
+ (unsigned long long) MultiXactIdToOffsetSegment(xlrec.startTruncOff),
+ (unsigned long long) MultiXactIdToOffsetSegment(xlrec.endTruncOff),
+ (unsigned long long) xlrec.startTruncMemb,
+@@ -3368,7 +3384,8 @@ pg_get_multixact_members(PG_FUNCTION_ARGS)
+ if (mxid < FirstMultiXactId)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+- errmsg("invalid MultiXactId: %u", mxid)));
++ errmsg("invalid MultiXactId: %llu",
++ (unsigned long long) mxid)));
+
+ if (SRF_IS_FIRSTCALL())
+ {
+@@ -3401,7 +3418,8 @@ pg_get_multixact_members(PG_FUNCTION_ARGS)
+ HeapTuple tuple;
+ char *values[2];
+
+- values[0] = psprintf("%u", multi->members[multi->iter].xid);
++ values[0] = psprintf("%llu",
++ (unsigned long long) multi->members[multi->iter].xid);
+ values[1] = mxstatus_to_string(multi->members[multi->iter].status);
+
+ tuple = BuildTupleFromCStrings(funccxt->attinmeta, values);
+diff --git a/src/backend/access/transam/slru.c b/src/backend/access/transam/slru.c
+index e7f73bf427..a2ecf5a77f 100644
+--- a/src/backend/access/transam/slru.c
++++ b/src/backend/access/transam/slru.c
+@@ -1056,13 +1056,15 @@ SlruReportIOError(SlruCtl ctl, int64 pageno, TransactionId xid)
+ case SLRU_OPEN_FAILED:
+ ereport(ERROR,
+ (errcode_for_file_access(),
+- errmsg("could not access status of transaction %u", xid),
++ errmsg("could not access status of transaction %llu",
++ (unsigned long long) xid),
+ errdetail("Could not open file \"%s\": %m.", path)));
+ break;
+ case SLRU_SEEK_FAILED:
+ ereport(ERROR,
+ (errcode_for_file_access(),
+- errmsg("could not access status of transaction %u", xid),
++ errmsg("could not access status of transaction %llu",
++ (unsigned long long) xid),
+ errdetail("Could not seek in file \"%s\" to offset %d: %m.",
+ path, offset)));
+ break;
+@@ -1070,38 +1072,45 @@ SlruReportIOError(SlruCtl ctl, int64 pageno, TransactionId xid)
+ if (errno)
+ ereport(ERROR,
+ (errcode_for_file_access(),
+- errmsg("could not access status of transaction %u", xid),
++ errmsg("could not access status of transaction %llu",
++ (unsigned long long) xid),
+ errdetail("Could not read from file \"%s\" at offset %d: %m.",
+ path, offset)));
+ else
+ ereport(ERROR,
+- (errmsg("could not access status of transaction %u", xid),
+- errdetail("Could not read from file \"%s\" at offset %d: read too few bytes.", path, offset)));
++ (errmsg("could not access status of transaction %llu",
++ (unsigned long long) xid),
++ errdetail("Could not read from file \"%s\" at offset %d: read too few bytes.",
++ path, offset)));
+ break;
+ case SLRU_WRITE_FAILED:
+ if (errno)
+ ereport(ERROR,
+ (errcode_for_file_access(),
+- errmsg("could not access status of transaction %u", xid),
++ errmsg("could not access status of transaction %llu",
++ (unsigned long long) xid),
+ errdetail("Could not write to file \"%s\" at offset %d: %m.",
+ path, offset)));
+ else
+ ereport(ERROR,
+- (errmsg("could not access status of transaction %u", xid),
++ (errmsg("could not access status of transaction %llu",
++ (unsigned long long) xid),
+ errdetail("Could not write to file \"%s\" at offset %d: wrote too few bytes.",
+ path, offset)));
+ break;
+ case SLRU_FSYNC_FAILED:
+ ereport(data_sync_elevel(ERROR),
+ (errcode_for_file_access(),
+- errmsg("could not access status of transaction %u", xid),
++ errmsg("could not access status of transaction %llu",
++ (unsigned long long) xid),
+ errdetail("Could not fsync file \"%s\": %m.",
+ path)));
+ break;
+ case SLRU_CLOSE_FAILED:
+ ereport(ERROR,
+ (errcode_for_file_access(),
+- errmsg("could not access status of transaction %u", xid),
++ errmsg("could not access status of transaction %llu",
++ (unsigned long long) xid),
+ errdetail("Could not close file \"%s\": %m.",
+ path)));
+ break;
+diff --git a/src/backend/access/transam/subtrans.c b/src/backend/access/transam/subtrans.c
+index 50bb1d8cfc..3f0fdeb10e 100644
+--- a/src/backend/access/transam/subtrans.c
++++ b/src/backend/access/transam/subtrans.c
+@@ -181,8 +181,9 @@ SubTransGetTopmostTransaction(TransactionId xid)
+ * structure that could lead to an infinite loop, so exit.
+ */
+ if (!TransactionIdPrecedes(parentXid, previousXid))
+- elog(ERROR, "pg_subtrans contains invalid entry: xid %u points to parent xid %u",
+- previousXid, parentXid);
++ elog(ERROR, "pg_subtrans contains invalid entry: xid %llu points to parent xid %llu",
++ (unsigned long long) previousXid,
++ (unsigned long long) parentXid);
+ }
+
+ Assert(TransactionIdIsValid(previousXid));
+diff --git a/src/backend/access/transam/transam.c b/src/backend/access/transam/transam.c
+index 75b5325df8..bf3e5ac327 100644
+--- a/src/backend/access/transam/transam.c
++++ b/src/backend/access/transam/transam.c
+@@ -158,8 +158,8 @@ TransactionIdDidCommit(TransactionId transactionId)
+ parentXid = SubTransGetParent(transactionId);
+ if (!TransactionIdIsValid(parentXid))
+ {
+- elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",
+- transactionId);
++ elog(WARNING, "no pg_subtrans entry for subcommitted XID %llu",
++ (unsigned long long) transactionId);
+ return false;
+ }
+ return TransactionIdDidCommit(parentXid);
+@@ -213,8 +213,8 @@ TransactionIdDidAbort(TransactionId transactionId)
+ if (!TransactionIdIsValid(parentXid))
+ {
+ /* see notes in TransactionIdDidCommit */
+- elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",
+- transactionId);
++ elog(WARNING, "no pg_subtrans entry for subcommitted XID %llu",
++ (unsigned long long) transactionId);
+ return true;
+ }
+ return TransactionIdDidAbort(parentXid);
+diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
+index e98286d768..f294b67ff2 100644
+--- a/src/backend/access/transam/twophase.c
++++ b/src/backend/access/transam/twophase.c
+@@ -832,7 +832,8 @@ TwoPhaseGetGXact(TransactionId xid, bool lock_held)
+ LWLockRelease(TwoPhaseStateLock);
+
+ if (result == NULL) /* should not happen */
+- elog(ERROR, "failed to find GlobalTransaction for xid %u", xid);
++ elog(ERROR, "failed to find GlobalTransaction for xid %llu",
++ (unsigned long long) xid);
+
+ cached_xid = xid;
+ cached_gxact = result;
+@@ -2113,7 +2114,8 @@ RecoverPreparedTransactions(void)
+ continue;
+
+ ereport(LOG,
+- (errmsg("recovering prepared transaction %u from shared memory", xid)));
++ (errmsg("recovering prepared transaction %llu from shared memory",
++ (unsigned long long) xid)));
+
+ hdr = (TwoPhaseFileHeader *) buf;
+ Assert(TransactionIdEquals(hdr->xid, xid));
+@@ -2206,15 +2208,15 @@ ProcessTwoPhaseBuffer(TransactionId xid,
+ if (fromdisk)
+ {
+ ereport(WARNING,
+- (errmsg("removing stale two-phase state file for transaction %u",
+- xid)));
++ (errmsg("removing stale two-phase state file for transaction %llu",
++ (unsigned long long) xid)));
+ RemoveTwoPhaseFile(xid, true);
+ }
+ else
+ {
+ ereport(WARNING,
+- (errmsg("removing stale two-phase state from memory for transaction %u",
+- xid)));
++ (errmsg("removing stale two-phase state from memory for transaction %llu",
++ (unsigned long long) xid)));
+ PrepareRedoRemove(xid, true);
+ }
+ return NULL;
+@@ -2226,15 +2228,15 @@ ProcessTwoPhaseBuffer(TransactionId xid,
+ if (fromdisk)
+ {
+ ereport(WARNING,
+- (errmsg("removing future two-phase state file for transaction %u",
+- xid)));
++ (errmsg("removing future two-phase state file for transaction %llu",
++ (unsigned long long) xid)));
+ RemoveTwoPhaseFile(xid, true);
+ }
+ else
+ {
+ ereport(WARNING,
+- (errmsg("removing future two-phase state from memory for transaction %u",
+- xid)));
++ (errmsg("removing future two-phase state from memory for transaction %llu",
++ (unsigned long long) xid)));
+ PrepareRedoRemove(xid, true);
+ }
+ return NULL;
+@@ -2258,13 +2260,13 @@ ProcessTwoPhaseBuffer(TransactionId xid,
+ if (fromdisk)
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg("corrupted two-phase state file for transaction %u",
+- xid)));
++ errmsg("corrupted two-phase state file for transaction %llu",
++ (unsigned long long) xid)));
+ else
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg("corrupted two-phase state in memory for transaction %u",
+- xid)));
++ errmsg("corrupted two-phase state in memory for transaction %llu",
++ (unsigned long long) xid)));
+ }
+
+ /*
+@@ -2425,8 +2427,8 @@ RecordTransactionAbortPrepared(TransactionId xid,
+ * RecordTransactionCommitPrepared ...
+ */
+ if (TransactionIdDidCommit(xid))
+- elog(PANIC, "cannot abort transaction %u, it was already committed",
+- xid);
++ elog(PANIC, "cannot abort transaction %llu, it was already committed",
++ (unsigned long long) xid);
+
+ START_CRIT_SECTION();
+
+@@ -2520,8 +2522,8 @@ PrepareRedoAdd(char *buf, XLogRecPtr start_lsn,
+ if (access(path, F_OK) == 0)
+ {
+ ereport(reachedConsistency ? ERROR : WARNING,
+- (errmsg("could not recover two-phase state file for transaction %u",
+- hdr->xid),
++ (errmsg("could not recover two-phase state file for transaction %llu",
++ (unsigned long long) hdr->xid),
+ errdetail("Two-phase state file has been found in WAL record %X/%X, but this transaction has already been restored from disk.",
+ LSN_FORMAT_ARGS(start_lsn))));
+ return;
+@@ -2565,7 +2567,8 @@ PrepareRedoAdd(char *buf, XLogRecPtr start_lsn,
+ false /* backward */ , false /* WAL */ );
+ }
+
+- elog(DEBUG2, "added 2PC data in shared memory for transaction %u", gxact->xid);
++ elog(DEBUG2, "added 2PC data in shared memory for transaction %llu",
++ (unsigned long long) gxact->xid);
+ }
+
+ /*
+@@ -2608,7 +2611,8 @@ PrepareRedoRemove(TransactionId xid, bool giveWarning)
+ /*
+ * And now we can clean up any files we may have left.
+ */
+- elog(DEBUG2, "removing 2PC data for transaction %u", xid);
++ elog(DEBUG2, "removing 2PC data for transaction %llu",
++ (unsigned long long) xid);
+ if (gxact->ondisk)
+ RemoveTwoPhaseFile(xid, giveWarning);
+ RemoveGXact(gxact);
+@@ -2698,7 +2702,7 @@ TwoPhaseTransactionGid(Oid subid, TransactionId xid, char *gid_res, int szgid)
+ (errcode(ERRCODE_PROTOCOL_VIOLATION),
+ errmsg_internal("invalid two-phase transaction ID")));
+
+- snprintf(gid_res, szgid, "pg_gid_%u_%u", subid, xid);
++ snprintf(gid_res, szgid, "pg_gid_%u_%llu", subid, (unsigned long long) xid);
+ }
+
+ /*
+diff --git a/src/backend/access/transam/varsup.c b/src/backend/access/transam/varsup.c
+index cfe8c6cf8d..e595eb1ad9 100644
+--- a/src/backend/access/transam/varsup.c
++++ b/src/backend/access/transam/varsup.c
+@@ -172,16 +172,16 @@ GetNewTransactionId(bool isSubXact)
+ /* complain even if that DB has disappeared */
+ if (oldest_datname)
+ ereport(WARNING,
+- (errmsg("database \"%s\" must be vacuumed within %u transactions",
++ (errmsg("database \"%s\" must be vacuumed within %llu transactions",
+ oldest_datname,
+- xidWrapLimit - xid),
++ (unsigned long long) xidWrapLimit - xid),
+ errhint("To avoid transaction ID assignment failures, execute a database-wide VACUUM in that database.\n"
+ "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+ else
+ ereport(WARNING,
+- (errmsg("database with OID %u must be vacuumed within %u transactions",
++ (errmsg("database with OID %u must be vacuumed within %llu transactions",
+ oldest_datoid,
+- xidWrapLimit - xid),
++ (unsigned long long) xidWrapLimit - xid),
+ errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+ "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+ }
+@@ -452,8 +452,8 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+
+ /* Log the info */
+ ereport(DEBUG1,
+- (errmsg_internal("transaction ID wrap limit is %u, limited by database with OID %u",
+- xidWrapLimit, oldest_datoid)));
++ (errmsg_internal("transaction ID wrap limit is %llu, limited by database with OID %u",
++ (unsigned long long) xidWrapLimit, oldest_datoid)));
+
+ /*
+ * If past the autovacuum force point, immediately signal an autovac
+@@ -487,16 +487,16 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+
+ if (oldest_datname)
+ ereport(WARNING,
+- (errmsg("database \"%s\" must be vacuumed within %u transactions",
++ (errmsg("database \"%s\" must be vacuumed within %llu transactions",
+ oldest_datname,
+- xidWrapLimit - curXid),
++ (unsigned long long) xidWrapLimit - curXid),
+ errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+ "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+ else
+ ereport(WARNING,
+- (errmsg("database with OID %u must be vacuumed within %u transactions",
++ (errmsg("database with OID %u must be vacuumed within %llu transactions",
+ oldest_datoid,
+- xidWrapLimit - curXid),
++ (unsigned long long) xidWrapLimit - curXid),
+ errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+ "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+ }
+diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
+index 87700c7c5c..b0277de603 100644
+--- a/src/backend/access/transam/xact.c
++++ b/src/backend/access/transam/xact.c
+@@ -1779,8 +1779,8 @@ RecordTransactionAbort(bool isSubXact)
+ * Check that we haven't aborted halfway through RecordTransactionCommit.
+ */
+ if (TransactionIdDidCommit(xid))
+- elog(PANIC, "cannot abort transaction %u, it was already committed",
+- xid);
++ elog(PANIC, "cannot abort transaction %llu, it was already committed",
++ (unsigned long long) xid);
+
+ /*
+ * Are we using the replication origins feature? Or, in other words, are
+@@ -5668,18 +5668,20 @@ ShowTransactionStateRec(const char *str, TransactionState s)
+ {
+ int i;
+
+- appendStringInfo(&buf, ", children: %u", s->childXids[0]);
++ appendStringInfo(&buf, ", children: %llu",
++ (unsigned long long) s->childXids[0]);
+ for (i = 1; i < s->nChildXids; i++)
+- appendStringInfo(&buf, " %u", s->childXids[i]);
++ appendStringInfo(&buf, " %llu",
++ (unsigned long long) s->childXids[i]);
+ }
+ ereport(DEBUG5,
+- (errmsg_internal("%s(%d) name: %s; blockState: %s; state: %s, xid/subid/cid: %u/%u/%u%s%s",
++ (errmsg_internal("%s(%d) name: %s; blockState: %s; state: %s, xid/subid/cid: %llu/%llu/%u%s%s",
+ str, s->nestingLevel,
+ PointerIsValid(s->name) ? s->name : "unnamed",
+ BlockStateAsString(s->blockState),
+ TransStateAsString(s->state),
+- (unsigned int) XidFromFullTransactionId(s->fullTransactionId),
+- (unsigned int) s->subTransactionId,
++ (unsigned long long) XidFromFullTransactionId(s->fullTransactionId),
++ (unsigned long long) s->subTransactionId,
+ (unsigned int) currentCommandId,
+ currentCommandIdUsed ? " (used)" : "",
+ buf.data)));
+diff --git a/src/backend/access/transam/xlogrecovery.c b/src/backend/access/transam/xlogrecovery.c
+index 4846126ef9..28e9602e34 100644
+--- a/src/backend/access/transam/xlogrecovery.c
++++ b/src/backend/access/transam/xlogrecovery.c
+@@ -807,8 +807,8 @@ InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr,
+ (errmsg("entering standby mode")));
+ else if (recoveryTarget == RECOVERY_TARGET_XID)
+ ereport(LOG,
+- (errmsg("starting point-in-time recovery to XID %u",
+- recoveryTargetXid)));
++ (errmsg("starting point-in-time recovery to XID %llu",
++ (unsigned long long) recoveryTargetXid)));
+ else if (recoveryTarget == RECOVERY_TARGET_TIME)
+ ereport(LOG,
+ (errmsg("starting point-in-time recovery to %s",
+@@ -873,23 +873,25 @@ InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr,
+ LSN_FORMAT_ARGS(checkPoint.redo),
+ wasShutdown ? "true" : "false")));
+ ereport(DEBUG1,
+- (errmsg_internal("next transaction ID: " UINT64_FORMAT "; next OID: %u",
+- U64FromFullTransactionId(checkPoint.nextXid),
++ (errmsg_internal("next transaction ID: %llu; next OID: %u",
++ (unsigned long long) U64FromFullTransactionId(checkPoint.nextXid),
+ checkPoint.nextOid)));
+ ereport(DEBUG1,
+- (errmsg_internal("next MultiXactId: %u; next MultiXactOffset: %llu",
+- checkPoint.nextMulti,
++ (errmsg_internal("next MultiXactId: %llu; next MultiXactOffset: %llu",
++ (unsigned long long) checkPoint.nextMulti,
+ (unsigned long long) checkPoint.nextMultiOffset)));
+ ereport(DEBUG1,
+- (errmsg_internal("oldest unfrozen transaction ID: %u, in database %u",
+- checkPoint.oldestXid, checkPoint.oldestXidDB)));
++ (errmsg_internal("oldest unfrozen transaction ID: %llu, in database %u",
++ (unsigned long long) checkPoint.oldestXid,
++ checkPoint.oldestXidDB)));
+ ereport(DEBUG1,
+- (errmsg_internal("oldest MultiXactId: %u, in database %u",
+- checkPoint.oldestMulti, checkPoint.oldestMultiDB)));
++ (errmsg_internal("oldest MultiXactId: %llu, in database %u",
++ (unsigned long long) checkPoint.oldestMulti,
++ checkPoint.oldestMultiDB)));
+ ereport(DEBUG1,
+- (errmsg_internal("commit timestamp Xid oldest/newest: %u/%u",
+- checkPoint.oldestCommitTsXid,
+- checkPoint.newestCommitTsXid)));
++ (errmsg_internal("commit timestamp Xid oldest/newest: %llu/%llu",
++ (unsigned long long) checkPoint.oldestCommitTsXid,
++ (unsigned long long) checkPoint.newestCommitTsXid)));
+ if (!TransactionIdIsNormal(XidFromFullTransactionId(checkPoint.nextXid)))
+ ereport(PANIC,
+ (errmsg("invalid next transaction ID")));
+@@ -2714,15 +2716,15 @@ recoveryStopsBefore(XLogReaderState *record)
+ if (isCommit)
+ {
+ ereport(LOG,
+- (errmsg("recovery stopping before commit of transaction %u, time %s",
+- recoveryStopXid,
++ (errmsg("recovery stopping before commit of transaction %llu, time %s",
++ (unsigned long long) recoveryStopXid,
+ timestamptz_to_str(recoveryStopTime))));
+ }
+ else
+ {
+ ereport(LOG,
+- (errmsg("recovery stopping before abort of transaction %u, time %s",
+- recoveryStopXid,
++ (errmsg("recovery stopping before abort of transaction %llu, time %s",
++ (unsigned long long) recoveryStopXid,
+ timestamptz_to_str(recoveryStopTime))));
+ }
+ }
+@@ -2859,16 +2861,16 @@ recoveryStopsAfter(XLogReaderState *record)
+ xact_info == XLOG_XACT_COMMIT_PREPARED)
+ {
+ ereport(LOG,
+- (errmsg("recovery stopping after commit of transaction %u, time %s",
+- recoveryStopXid,
++ (errmsg("recovery stopping after commit of transaction %llu, time %s",
++ (unsigned long long) recoveryStopXid,
+ timestamptz_to_str(recoveryStopTime))));
+ }
+ else if (xact_info == XLOG_XACT_ABORT ||
+ xact_info == XLOG_XACT_ABORT_PREPARED)
+ {
+ ereport(LOG,
+- (errmsg("recovery stopping after abort of transaction %u, time %s",
+- recoveryStopXid,
++ (errmsg("recovery stopping after abort of transaction %llu, time %s",
++ (unsigned long long) recoveryStopXid,
+ timestamptz_to_str(recoveryStopTime))));
+ }
+ return true;
+@@ -2903,9 +2905,9 @@ getRecoveryStopReason(void)
+
+ if (recoveryTarget == RECOVERY_TARGET_XID)
+ snprintf(reason, sizeof(reason),
+- "%s transaction %u",
++ "%s transaction %llu",
+ recoveryStopAfter ? "after" : "before",
+- recoveryStopXid);
++ (unsigned long long) recoveryStopXid);
+ else if (recoveryTarget == RECOVERY_TARGET_TIME)
+ snprintf(reason, sizeof(reason),
+ "%s %s\n",
+diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
+index 7d8e9d2045..d72b26418c 100644
+--- a/src/backend/commands/vacuum.c
++++ b/src/backend/commands/vacuum.c
+@@ -1528,14 +1528,16 @@ vac_update_relstats(Relation relation,
+ if (futurexid)
+ ereport(WARNING,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("overwrote invalid relfrozenxid value %u with new value %u for table \"%s\"",
+- oldfrozenxid, frozenxid,
++ errmsg_internal("overwrote invalid relfrozenxid value %llu with new value %llu for table \"%s\"",
++ (unsigned long long) oldfrozenxid,
++ (unsigned long long) frozenxid,
+ RelationGetRelationName(relation))));
+ if (futuremxid)
+ ereport(WARNING,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+- errmsg_internal("overwrote invalid relminmxid value %u with new value %u for table \"%s\"",
+- oldminmulti, minmulti,
++ errmsg_internal("overwrote invalid relminmxid value %llu with new value %llu for table \"%s\"",
++ (unsigned long long) oldminmulti,
++ (unsigned long long) minmulti,
+ RelationGetRelationName(relation))));
+ }
+
+diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
+index 9827cf16be..70a5792841 100644
+--- a/src/backend/nodes/outfuncs.c
++++ b/src/backend/nodes/outfuncs.c
+@@ -303,7 +303,7 @@ _outList(StringInfo str, const List *node)
+ else if (IsA(node, OidList))
+ appendStringInfo(str, " %u", lfirst_oid(lc));
+ else if (IsA(node, XidList))
+- appendStringInfo(str, " %u", lfirst_xid(lc));
++ appendStringInfo(str, " %llu", (unsigned long long) lfirst_xid(lc));
+ else
+ elog(ERROR, "unrecognized list node type: %d",
+ (int) node->type);
+diff --git a/src/backend/replication/logical/applyparallelworker.c b/src/backend/replication/logical/applyparallelworker.c
+index e7f7d4c5e4..e31006f0e4 100644
+--- a/src/backend/replication/logical/applyparallelworker.c
++++ b/src/backend/replication/logical/applyparallelworker.c
+@@ -1212,8 +1212,8 @@ pa_switch_to_partial_serialize(ParallelApplyWorkerInfo *winfo,
+ bool stream_locked)
+ {
+ ereport(LOG,
+- (errmsg("logical replication apply worker will serialize the remaining changes of remote transaction %u to a file",
+- winfo->shared->xid)));
++ (errmsg("logical replication apply worker will serialize the remaining changes of remote transaction %llu to a file",
++ (unsigned long long) winfo->shared->xid)));
+
+ /*
+ * The parallel apply worker could be stuck for some reason (say waiting
+@@ -1347,7 +1347,7 @@ pa_set_stream_apply_worker(ParallelApplyWorkerInfo *winfo)
+ static void
+ pa_savepoint_name(Oid suboid, TransactionId xid, char *spname, Size szsp)
+ {
+- snprintf(spname, szsp, "pg_sp_%u_%u", suboid, xid);
++ snprintf(spname, szsp, "pg_sp_%u_%llu", suboid, (unsigned long long) xid);
+ }
+
+ /*
+diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c
+index 3fe1774a1e..9ef1ca0947 100644
+--- a/src/backend/replication/logical/logical.c
++++ b/src/backend/replication/logical/logical.c
+@@ -1742,8 +1742,8 @@ LogicalIncreaseXminForSlot(XLogRecPtr current_lsn, TransactionId xmin)
+ SpinLockRelease(&slot->mutex);
+
+ if (got_new_xmin)
+- elog(DEBUG1, "got new catalog xmin %u at %X/%X", xmin,
+- LSN_FORMAT_ARGS(current_lsn));
++ elog(DEBUG1, "got new catalog xmin %llu at %X/%X",
++ (unsigned long long) xmin, LSN_FORMAT_ARGS(current_lsn));
+
+ /* candidate already valid with the current flush position, apply */
+ if (updated_xmin)
+diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
+index 22bcf171ff..6094cfef71 100644
+--- a/src/backend/replication/logical/reorderbuffer.c
++++ b/src/backend/replication/logical/reorderbuffer.c
+@@ -2545,8 +2545,8 @@ ReorderBufferProcessTXN(ReorderBuffer *rb, ReorderBufferTXN *txn,
+
+ /* this is just a sanity check against bad output plugin behaviour */
+ if (GetCurrentTransactionIdIfAny() != InvalidTransactionId)
+- elog(ERROR, "output plugin used XID %u",
+- GetCurrentTransactionId());
++ elog(ERROR, "output plugin used XID %llu",
++ (unsigned long long) GetCurrentTransactionId());
+
+ /*
+ * Remember the command ID and snapshot for the next set of changes in
+@@ -2987,7 +2987,8 @@ ReorderBufferAbortOld(ReorderBuffer *rb, TransactionId oldestRunningXid)
+
+ if (TransactionIdPrecedes(txn->xid, oldestRunningXid))
+ {
+- elog(DEBUG2, "aborting old transaction %u", txn->xid);
++ elog(DEBUG2, "aborting old transaction %llu",
++ (unsigned long long) txn->xid);
+
+ /* Notify the remote node about the crash/immediate restart. */
+ if (rbtxn_is_streamed(txn))
+@@ -3711,8 +3712,8 @@ ReorderBufferSerializeTXN(ReorderBuffer *rb, ReorderBufferTXN *txn)
+ Size spilled = 0;
+ Size size = txn->size;
+
+- elog(DEBUG2, "spill %u changes in XID %u to disk",
+- (uint32) txn->nentries_mem, txn->xid);
++ elog(DEBUG2, "spill %u changes in XID %llu to disk",
++ (uint32) txn->nentries_mem, (unsigned long long) txn->xid);
+
+ /* do the same to all child TXs */
+ dlist_foreach(subtxn_i, &txn->subtxns)
+@@ -3991,8 +3992,8 @@ ReorderBufferSerializeChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
+ errno = save_errno ? save_errno : ENOSPC;
+ ereport(ERROR,
+ (errcode_for_file_access(),
+- errmsg("could not write to data file for XID %u: %m",
+- txn->xid)));
++ errmsg("could not write to data file for XID %llu: %m",
++ (unsigned long long) txn->xid)));
+ }
+ pgstat_report_wait_end();
+
+@@ -4636,10 +4637,10 @@ ReorderBufferSerializedPath(char *path, ReplicationSlot *slot, TransactionId xid
+
+ XLogSegNoOffsetToRecPtr(segno, 0, wal_segment_size, recptr);
+
+- snprintf(path, MAXPGPATH, "%s/%s/xid-%u-lsn-%X-%X.spill",
++ snprintf(path, MAXPGPATH, "%s/%s/xid-%llu-lsn-%X-%X.spill",
+ PG_REPLSLOT_DIR,
+ NameStr(MyReplicationSlot->data.name),
+- xid, LSN_FORMAT_ARGS(recptr));
++ (unsigned long long) xid, LSN_FORMAT_ARGS(recptr));
+ }
+
+ /*
+@@ -5255,8 +5256,8 @@ UpdateLogicalMappings(HTAB *tuplecid_data, Oid relid, Snapshot snapshot)
+ {
+ RewriteMappingFile *f = (RewriteMappingFile *) lfirst(file);
+
+- elog(DEBUG1, "applying mapping: \"%s\" in %u", f->fname,
+- snapshot->subxip[0]);
++ elog(DEBUG1, "applying mapping: \"%s\" in %llu", f->fname,
++ (unsigned long long) snapshot->subxip[0]);
+ ApplyLogicalMappingFile(tuplecid_data, relid, f->fname);
+ pfree(f);
+ }
+diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c
+index 0450f94ba8..ec9c011f2d 100644
+--- a/src/backend/replication/logical/snapbuild.c
++++ b/src/backend/replication/logical/snapbuild.c
+@@ -619,8 +619,8 @@ SnapBuildInitialSnapshot(SnapBuild *builder)
+ LWLockRelease(ProcArrayLock);
+
+ if (TransactionIdFollows(safeXid, snap->xmin))
+- elog(ERROR, "cannot build an initial slot snapshot as oldest safe xid %u follows snapshot's xmin %u",
+- safeXid, snap->xmin);
++ elog(ERROR, "cannot build an initial slot snapshot as oldest safe xid %llu follows snapshot's xmin %llu",
++ (unsigned long long) safeXid, (unsigned long long) snap->xmin);
+
+ MyProc->xmin = snap->xmin;
+
+@@ -903,8 +903,8 @@ SnapBuildDistributeNewCatalogSnapshot(SnapBuild *builder, XLogRecPtr lsn)
+ if (rbtxn_prepared(txn) || rbtxn_skip_prepared(txn))
+ continue;
+
+- elog(DEBUG2, "adding a new snapshot to %u at %X/%X",
+- txn->xid, LSN_FORMAT_ARGS(lsn));
++ elog(DEBUG2, "adding a new snapshot to %llu at %X/%X",
++ (unsigned long long) txn->xid, LSN_FORMAT_ARGS(lsn));
+
+ /*
+ * increase the snapshot's refcount for the transaction we are handing
+@@ -983,9 +983,9 @@ SnapBuildPurgeOlderTxn(SnapBuild *builder)
+ memcpy(builder->committed.xip, workspace,
+ surviving_xids * sizeof(TransactionId));
+
+- elog(DEBUG3, "purged committed transactions from %u to %u, xmin: %u, xmax: %u",
++ elog(DEBUG3, "purged committed transactions from %u to %u, xmin: %llu, xmax: %llu",
+ (uint32) builder->committed.xcnt, (uint32) surviving_xids,
+- builder->xmin, builder->xmax);
++ (unsigned long long) builder->xmin, (unsigned long long) builder->xmax);
+ builder->committed.xcnt = surviving_xids;
+
+ pfree(workspace);
+@@ -1020,9 +1020,10 @@ SnapBuildPurgeOlderTxn(SnapBuild *builder)
+ builder->catchange.xip = NULL;
+ }
+
+- elog(DEBUG3, "purged catalog modifying transactions from %u to %u, xmin: %u, xmax: %u",
++ elog(DEBUG3, "purged catalog modifying transactions from %u to %u, xmin: %llu, xmax: %llu",
+ (uint32) builder->catchange.xcnt, (uint32) surviving_xids,
+- builder->xmin, builder->xmax);
++ (unsigned long long) builder->xmin,
++ (unsigned long long) builder->xmax);
+ builder->catchange.xcnt = surviving_xids;
+ }
+ }
+@@ -1085,8 +1086,8 @@ SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid,
+ sub_needs_timetravel = true;
+ needs_snapshot = true;
+
+- elog(DEBUG1, "found subtransaction %u:%u with catalog changes",
+- xid, subxid);
++ elog(DEBUG1, "found subtransaction %llu:%llu with catalog changes",
++ (unsigned long long) xid, (unsigned long long) subxid);
+
+ SnapBuildAddCommittedTxn(builder, subxid);
+
+@@ -1111,8 +1112,8 @@ SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid,
+ /* if top-level modified catalog, it'll need a snapshot */
+ if (SnapBuildXidHasCatalogChanges(builder, xid, xinfo))
+ {
+- elog(DEBUG2, "found top level transaction %u, with catalog changes",
+- xid);
++ elog(DEBUG2, "found top level transaction %llu, with catalog changes",
++ (unsigned long long) xid);
+ needs_snapshot = true;
+ needs_timetravel = true;
+ SnapBuildAddCommittedTxn(builder, xid);
+@@ -1120,14 +1121,15 @@ SnapBuildCommitTxn(SnapBuild *builder, XLogRecPtr lsn, TransactionId xid,
+ else if (sub_needs_timetravel)
+ {
+ /* track toplevel txn as well, subxact alone isn't meaningful */
+- elog(DEBUG2, "forced transaction %u to do timetravel due to one of its subtransactions",
+- xid);
++ elog(DEBUG2, "forced transaction %llu to do timetravel due to one of its subtransactions",
++ (unsigned long long) xid);
+ needs_timetravel = true;
+ SnapBuildAddCommittedTxn(builder, xid);
+ }
+ else if (needs_timetravel)
+ {
+- elog(DEBUG2, "forced transaction %u to do timetravel", xid);
++ elog(DEBUG2, "forced transaction %llu to do timetravel",
++ (unsigned long long) xid);
+
+ SnapBuildAddCommittedTxn(builder, xid);
+ }
+@@ -1272,8 +1274,11 @@ SnapBuildProcessRunningXacts(SnapBuild *builder, XLogRecPtr lsn, xl_running_xact
+ xmin = ReorderBufferGetOldestXmin(builder->reorder);
+ if (xmin == InvalidTransactionId)
+ xmin = running->oldestRunningXid;
+- elog(DEBUG3, "xmin: %u, xmax: %u, oldest running: %u, oldest xmin: %u",
+- builder->xmin, builder->xmax, running->oldestRunningXid, xmin);
++ elog(DEBUG3, "xmin: %llu, xmax: %llu, oldest running: %llu, oldest xmin: %llu",
++ (unsigned long long) builder->xmin,
++ (unsigned long long) builder->xmax,
++ (unsigned long long) running->oldestRunningXid,
++ (unsigned long long) xmin);
+ LogicalIncreaseXminForSlot(lsn, xmin);
+
+ /*
+@@ -1364,8 +1369,9 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn
+ ereport(DEBUG1,
+ (errmsg_internal("skipping snapshot at %X/%X while building logical decoding snapshot, xmin horizon too low",
+ LSN_FORMAT_ARGS(lsn)),
+- errdetail_internal("initial xmin horizon of %u vs the snapshot's %u",
+- builder->initial_xmin_horizon, running->oldestRunningXid)));
++ errdetail_internal("initial xmin horizon of %llu vs the snapshot's %llu",
++ (unsigned long long) builder->initial_xmin_horizon,
++ (unsigned long long) running->oldestRunningXid)));
+
+
+ SnapBuildWaitSnapshot(running, builder->initial_xmin_horizon);
+@@ -1452,8 +1458,9 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn
+ ereport(LOG,
+ (errmsg("logical decoding found initial starting point at %X/%X",
+ LSN_FORMAT_ARGS(lsn)),
+- errdetail("Waiting for transactions (approximately %d) older than %u to end.",
+- running->xcnt, running->nextXid)));
++ errdetail("Waiting for transactions (approximately %d) older than %llu to end.",
++ running->xcnt,
++ (unsigned long long) running->nextXid)));
+
+ SnapBuildWaitSnapshot(running, running->nextXid);
+ }
+@@ -1476,8 +1483,9 @@ SnapBuildFindSnapshot(SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *runn
+ ereport(LOG,
+ (errmsg("logical decoding found initial consistent point at %X/%X",
+ LSN_FORMAT_ARGS(lsn)),
+- errdetail("Waiting for transactions (approximately %d) older than %u to end.",
+- running->xcnt, running->nextXid)));
++ errdetail("Waiting for transactions (approximately %d) older than %llu to end.",
++ running->xcnt,
++ (unsigned long long) running->nextXid)));
+
+ SnapBuildWaitSnapshot(running, running->nextXid);
+ }
+diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c
+index 925dff9cc4..aeab7eccd5 100644
+--- a/src/backend/replication/logical/worker.c
++++ b/src/backend/replication/logical/worker.c
+@@ -4275,14 +4275,16 @@ subxact_info_add(TransactionId xid)
+ static inline void
+ subxact_filename(char *path, Oid subid, TransactionId xid)
+ {
+- snprintf(path, MAXPGPATH, "%u-%u.subxacts", subid, xid);
++ snprintf(path, MAXPGPATH, "%u-%llu.subxacts", subid,
++ (unsigned long long) xid);
+ }
+
+ /* format filename for file containing serialized changes */
+ static inline void
+ changes_filename(char *path, Oid subid, TransactionId xid)
+ {
+- snprintf(path, MAXPGPATH, "%u-%u.changes", subid, xid);
++ snprintf(path, MAXPGPATH, "%u-%llu.changes", subid,
++ (unsigned long long) xid);
+ }
+
+ /*
+@@ -5016,15 +5018,15 @@ apply_error_callback(void *arg)
+ errarg->origin_name,
+ logicalrep_message_type(errarg->command));
+ else if (XLogRecPtrIsInvalid(errarg->finish_lsn))
+- errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" in transaction %u",
++ errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" in transaction %llu",
+ errarg->origin_name,
+ logicalrep_message_type(errarg->command),
+- errarg->remote_xid);
++ (unsigned long long) errarg->remote_xid);
+ else
+- errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" in transaction %u, finished at %X/%X",
++ errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" in transaction %llu, finished at %X/%X",
+ errarg->origin_name,
+ logicalrep_message_type(errarg->command),
+- errarg->remote_xid,
++ (unsigned long long) errarg->remote_xid,
+ LSN_FORMAT_ARGS(errarg->finish_lsn));
+ }
+ else
+@@ -5032,39 +5034,39 @@ apply_error_callback(void *arg)
+ if (errarg->remote_attnum < 0)
+ {
+ if (XLogRecPtrIsInvalid(errarg->finish_lsn))
+- errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" for replication target relation \"%s.%s\" in transaction %u",
++ errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" for replication target relation \"%s.%s\" in transaction %llu",
+ errarg->origin_name,
+ logicalrep_message_type(errarg->command),
+ errarg->rel->remoterel.nspname,
+ errarg->rel->remoterel.relname,
+- errarg->remote_xid);
++ (unsigned long long) errarg->remote_xid);
+ else
+- errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" for replication target relation \"%s.%s\" in transaction %u, finished at %X/%X",
++ errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" for replication target relation \"%s.%s\" in transaction %llu, finished at %X/%X",
+ errarg->origin_name,
+ logicalrep_message_type(errarg->command),
+ errarg->rel->remoterel.nspname,
+ errarg->rel->remoterel.relname,
+- errarg->remote_xid,
++ (unsigned long long) errarg->remote_xid,
+ LSN_FORMAT_ARGS(errarg->finish_lsn));
+ }
+ else
+ {
+ if (XLogRecPtrIsInvalid(errarg->finish_lsn))
+- errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" for replication target relation \"%s.%s\" column \"%s\" in transaction %u",
++ errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" for replication target relation \"%s.%s\" column \"%s\" in transaction %llu",
+ errarg->origin_name,
+ logicalrep_message_type(errarg->command),
+ errarg->rel->remoterel.nspname,
+ errarg->rel->remoterel.relname,
+ errarg->rel->remoterel.attnames[errarg->remote_attnum],
+- errarg->remote_xid);
++ (unsigned long long) errarg->remote_xid);
+ else
+- errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" for replication target relation \"%s.%s\" column \"%s\" in transaction %u, finished at %X/%X",
++ errcontext("processing remote data for replication origin \"%s\" during message type \"%s\" for replication target relation \"%s.%s\" column \"%s\" in transaction %llu, finished at %X/%X",
+ errarg->origin_name,
+ logicalrep_message_type(errarg->command),
+ errarg->rel->remoterel.nspname,
+ errarg->rel->remoterel.relname,
+ errarg->rel->remoterel.attnames[errarg->remote_attnum],
+- errarg->remote_xid,
++ (unsigned long long) errarg->remote_xid,
+ LSN_FORMAT_ARGS(errarg->finish_lsn));
+ }
+ }
+diff --git a/src/backend/replication/pgoutput/pgoutput.c b/src/backend/replication/pgoutput/pgoutput.c
+index 00e7024563..a094adbcb8 100644
+--- a/src/backend/replication/pgoutput/pgoutput.c
++++ b/src/backend/replication/pgoutput/pgoutput.c
+@@ -600,7 +600,8 @@ pgoutput_commit_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
+
+ if (!sent_begin_txn)
+ {
+- elog(DEBUG1, "skipped replication of an empty transaction with XID: %u", txn->xid);
++ elog(DEBUG1, "skipped replication of an empty transaction with XID: %llu",
++ (unsigned long long) txn->xid);
+ return;
+ }
+
+diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
+index 6828100cf1..f1516bc404 100644
+--- a/src/backend/replication/slot.c
++++ b/src/backend/replication/slot.c
+@@ -1531,8 +1531,8 @@ ReportSlotInvalidation(ReplicationSlotInvalidationCause cause,
+ break;
+ }
+ case RS_INVAL_HORIZON:
+- appendStringInfo(&err_detail, _("The slot conflicted with xid horizon %u."),
+- snapshotConflictHorizon);
++ appendStringInfo(&err_detail, _("The slot conflicted with xid horizon %llu."),
++ (unsigned long long) snapshotConflictHorizon);
+ break;
+
+ case RS_INVAL_WAL_LEVEL:
+diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
+index a27aee63de..c8f2245070 100644
+--- a/src/backend/replication/walreceiver.c
++++ b/src/backend/replication/walreceiver.c
+@@ -1238,8 +1238,9 @@ XLogWalRcvSendHSFeedback(bool immed)
+ if (nextXid < catalog_xmin)
+ catalog_xmin_epoch--;
+
+- elog(DEBUG2, "sending hot standby feedback xmin %u epoch %u catalog_xmin %u catalog_xmin_epoch %u",
+- xmin, xmin_epoch, catalog_xmin, catalog_xmin_epoch);
++ elog(DEBUG2, "sending hot standby feedback xmin %llu epoch %u catalog_xmin %llu catalog_xmin_epoch %u",
++ (unsigned long long) xmin, xmin_epoch,
++ (unsigned long long) catalog_xmin, catalog_xmin_epoch);
+
+ /* Construct the message and send it. */
+ resetStringInfo(&reply_message);
+diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
+index c5f1009f37..65194e8d10 100644
+--- a/src/backend/replication/walsender.c
++++ b/src/backend/replication/walsender.c
+@@ -2598,10 +2598,10 @@ ProcessStandbyHSFeedbackMessage(void)
+ /* Copy because timestamptz_to_str returns a static buffer */
+ replyTimeStr = pstrdup(timestamptz_to_str(replyTime));
+
+- elog(DEBUG2, "hot standby feedback xmin %u epoch %u, catalog_xmin %u epoch %u reply_time %s",
+- feedbackXmin,
++ elog(DEBUG2, "hot standby feedback xmin %llu epoch %u, catalog_xmin %llu epoch %u reply_time %s",
++ (unsigned long long) feedbackXmin,
+ feedbackEpoch,
+- feedbackCatalogXmin,
++ (unsigned long long) feedbackCatalogXmin,
+ feedbackCatalogEpoch,
+ replyTimeStr);
+
+diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
+index 36610a1c7e..016ead2825 100644
+--- a/src/backend/storage/ipc/procarray.c
++++ b/src/backend/storage/ipc/procarray.c
+@@ -1127,9 +1127,9 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running)
+ else
+ elog(DEBUG1,
+ "recovery snapshot waiting for non-overflowed snapshot or "
+- "until oldest active xid on standby is at least %u (now %u)",
+- standbySnapshotPendingXmin,
+- running->oldestRunningXid);
++ "until oldest active xid on standby is at least %llu (now %llu)",
++ (unsigned long long) standbySnapshotPendingXmin,
++ (unsigned long long) running->oldestRunningXid);
+ return;
+ }
+ }
+@@ -1213,8 +1213,8 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running)
+ if (i > 0 && TransactionIdEquals(xids[i - 1], xids[i]))
+ {
+ elog(DEBUG1,
+- "found duplicated transaction %u for KnownAssignedXids insertion",
+- xids[i]);
++ "found duplicated transaction %llu for KnownAssignedXids insertion",
++ (unsigned long long) xids[i]);
+ continue;
+ }
+ KnownAssignedXidsAdd(xids[i], xids[i], true);
+@@ -1305,9 +1305,9 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running)
+ else
+ elog(DEBUG1,
+ "recovery snapshot waiting for non-overflowed snapshot or "
+- "until oldest active xid on standby is at least %u (now %u)",
+- standbySnapshotPendingXmin,
+- running->oldestRunningXid);
++ "until oldest active xid on standby is at least %llu (now %llu)",
++ (unsigned long long) standbySnapshotPendingXmin,
++ (unsigned long long) running->oldestRunningXid);
+ }
+
+ /*
+@@ -3958,8 +3958,8 @@ ProcArraySetReplicationSlotXmin(TransactionId xmin, TransactionId catalog_xmin,
+ if (!already_locked)
+ LWLockRelease(ProcArrayLock);
+
+- elog(DEBUG1, "xmin required by slots: data %u, catalog %u",
+- xmin, catalog_xmin);
++ elog(DEBUG1, "xmin required by slots: data %llu, catalog %llu",
++ (unsigned long long) xmin, (unsigned long long) catalog_xmin);
+ }
+
+ /*
+@@ -4047,7 +4047,8 @@ XidCacheRemoveRunningXids(TransactionId xid,
+ * debug warning.
+ */
+ if (j < 0 && !MyProc->subxidStatus.overflowed)
+- elog(WARNING, "did not find subXID %u in MyProc", anxid);
++ elog(WARNING, "did not find subXID %llu in MyProc",
++ (unsigned long long) anxid);
+ }
+
+ for (j = MyProc->subxidStatus.count - 1; j >= 0; j--)
+@@ -4063,7 +4064,8 @@ XidCacheRemoveRunningXids(TransactionId xid,
+ }
+ /* Ordinarily we should have found it, unless the cache has overflowed */
+ if (j < 0 && !MyProc->subxidStatus.overflowed)
+- elog(WARNING, "did not find subXID %u in MyProc", xid);
++ elog(WARNING, "did not find subXID %llu in MyProc",
++ (unsigned long long) xid);
+
+ /* Also advance global latestCompletedXid while holding the lock */
+ MaintainLatestCompletedXid(latestXid);
+@@ -4410,8 +4412,8 @@ RecordKnownAssignedTransactionIds(TransactionId xid)
+ Assert(TransactionIdIsValid(xid));
+ Assert(TransactionIdIsValid(latestObservedXid));
+
+- elog(DEBUG4, "record known xact %u latestObservedXid %u",
+- xid, latestObservedXid);
++ elog(DEBUG4, "record known xact %llu latestObservedXid %llu",
++ (unsigned long long) xid, (unsigned long long) latestObservedXid);
+
+ /*
+ * When a newly observed xid arrives, it is frequently the case that it is
+@@ -4968,7 +4970,7 @@ KnownAssignedXidsRemove(TransactionId xid)
+ {
+ Assert(TransactionIdIsValid(xid));
+
+- elog(DEBUG4, "remove KnownAssignedXid %u", xid);
++ elog(DEBUG4, "remove KnownAssignedXid %llu", (unsigned long long) xid);
+
+ /*
+ * Note: we cannot consider it an error to remove an XID that's not
+@@ -5028,7 +5030,7 @@ KnownAssignedXidsRemovePreceding(TransactionId removeXid)
+ return;
+ }
+
+- elog(DEBUG4, "prune KnownAssignedXids to %u", removeXid);
++ elog(DEBUG4, "prune KnownAssignedXids to %llu", (unsigned long long) removeXid);
+
+ /*
+ * Mark entries invalid starting at the tail. Since array is sorted, we
+@@ -5214,7 +5216,8 @@ KnownAssignedXidsDisplay(int trace_level)
+ if (KnownAssignedXidsValid[i])
+ {
+ nxids++;
+- appendStringInfo(&buf, "[%d]=%u ", i, KnownAssignedXids[i]);
++ appendStringInfo(&buf, "[%d]=%llu ", i,
++ (unsigned long long) KnownAssignedXids[i]);
+ }
+ }
+
+diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c
+index 872679ca44..09cef400f7 100644
+--- a/src/backend/storage/ipc/standby.c
++++ b/src/backend/storage/ipc/standby.c
+@@ -1041,15 +1041,17 @@ StandbyReleaseXidEntryLocks(RecoveryLockXidEntry *xidentry)
+ LOCKTAG locktag;
+
+ elog(DEBUG4,
+- "releasing recovery lock: xid %u db %u rel %u",
+- entry->key.xid, entry->key.dbOid, entry->key.relOid);
++ "releasing recovery lock: xid %llu db %u rel %u",
++ (unsigned long long) entry->key.xid, entry->key.dbOid, entry->key.relOid);
++
+ /* Release the lock ... */
+ SET_LOCKTAG_RELATION(locktag, entry->key.dbOid, entry->key.relOid);
+ if (!LockRelease(&locktag, AccessExclusiveLock, true))
+ {
+ elog(LOG,
+- "RecoveryLockHash contains entry for lock no longer recorded by lock manager: xid %u database %u relation %u",
+- entry->key.xid, entry->key.dbOid, entry->key.relOid);
++ "RecoveryLockHash contains entry for lock no longer recorded by lock manager: xid %llu database %u relation %u",
++ (unsigned long long) entry->key.xid, entry->key.dbOid,
++ entry->key.relOid);
+ Assert(false);
+ }
+ /* ... and remove the per-lock hash entry */
+@@ -1368,20 +1370,20 @@ LogCurrentRunningXacts(RunningTransactions CurrRunningXacts)
+
+ if (xlrec.subxid_overflow)
+ elog(DEBUG2,
+- "snapshot of %d running transactions overflowed (lsn %X/%X oldest xid %u latest complete %u next xid %u)",
++ "snapshot of %d running transactions overflowed (lsn %X/%X oldest xid %llu latest complete %llu next xid %llu)",
+ CurrRunningXacts->xcnt,
+ LSN_FORMAT_ARGS(recptr),
+- CurrRunningXacts->oldestRunningXid,
+- CurrRunningXacts->latestCompletedXid,
+- CurrRunningXacts->nextXid);
++ (unsigned long long) CurrRunningXacts->oldestRunningXid,
++ (unsigned long long) CurrRunningXacts->latestCompletedXid,
++ (unsigned long long) CurrRunningXacts->nextXid);
+ else
+ elog(DEBUG2,
+- "snapshot of %d+%d running transaction ids (lsn %X/%X oldest xid %u latest complete %u next xid %u)",
++ "snapshot of %d+%d running transaction ids (lsn %X/%X oldest xid %llu latest complete %llu next xid %llu)",
+ CurrRunningXacts->xcnt, CurrRunningXacts->subxcnt,
+ LSN_FORMAT_ARGS(recptr),
+- CurrRunningXacts->oldestRunningXid,
+- CurrRunningXacts->latestCompletedXid,
+- CurrRunningXacts->nextXid);
++ (unsigned long long) CurrRunningXacts->oldestRunningXid,
++ (unsigned long long) CurrRunningXacts->latestCompletedXid,
++ (unsigned long long) CurrRunningXacts->nextXid);
+
+ /*
+ * Ensure running_xacts information is synced to disk not too far in the
+diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
+index e24a0f2fdb..491003736a 100644
+--- a/src/backend/storage/lmgr/predicate.c
++++ b/src/backend/storage/lmgr/predicate.c
+@@ -4053,7 +4053,8 @@ CheckForSerializableConflictOut(Relation relation, TransactionId xid, Snapshot s
+ ereport(ERROR,
+ (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
+ errmsg("could not serialize access due to read/write dependencies among transactions"),
+- errdetail_internal("Reason code: Canceled on conflict out to old pivot %u.", xid),
++ errdetail_internal("Reason code: Canceled on conflict out to old pivot %llu.",
++ (unsigned long long) xid),
+ errhint("The transaction might succeed if retried.")));
+
+ if (SxactHasSummaryConflictIn(MySerializableXact)
+@@ -4061,7 +4062,8 @@ CheckForSerializableConflictOut(Relation relation, TransactionId xid, Snapshot s
+ ereport(ERROR,
+ (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
+ errmsg("could not serialize access due to read/write dependencies among transactions"),
+- errdetail_internal("Reason code: Canceled on identification as a pivot, with conflict out to old committed transaction %u.", xid),
++ errdetail_internal("Reason code: Canceled on identification as a pivot, with conflict out to old committed transaction %llu.",
++ (unsigned long long) xid),
+ errhint("The transaction might succeed if retried.")));
+
+ MySerializableXact->flags |= SXACT_FLAG_SUMMARY_CONFLICT_OUT;
+@@ -4661,7 +4663,8 @@ OnConflict_CheckForSerializationFailure(const SERIALIZABLEXACT *reader,
+ ereport(ERROR,
+ (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
+ errmsg("could not serialize access due to read/write dependencies among transactions"),
+- errdetail_internal("Reason code: Canceled on conflict out to pivot %u, during read.", writer->topXid),
++ errdetail_internal("Reason code: Canceled on conflict out to pivot %llu, during read.",
++ (unsigned long long) writer->topXid),
+ errhint("The transaction might succeed if retried.")));
+ }
+ writer->flags |= SXACT_FLAG_DOOMED;
+diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c
+index e790f856ab..1f57ba7fd5 100644
+--- a/src/backend/utils/adt/lockfuncs.c
++++ b/src/backend/utils/adt/lockfuncs.c
+@@ -80,7 +80,7 @@ VXIDGetDatum(ProcNumber procNumber, LocalTransactionId lxid)
+ */
+ char vxidstr[32];
+
+- snprintf(vxidstr, sizeof(vxidstr), "%d/%u", procNumber, lxid);
++ snprintf(vxidstr, sizeof(vxidstr), "%d/%llu", procNumber, (unsigned long long) lxid);
+
+ return CStringGetTextDatum(vxidstr);
+ }
+diff --git a/src/backend/utils/error/csvlog.c b/src/backend/utils/error/csvlog.c
+index 855e130a97..1a54e57e07 100644
+--- a/src/backend/utils/error/csvlog.c
++++ b/src/backend/utils/error/csvlog.c
+@@ -151,11 +151,12 @@ write_csvlog(ErrorData *edata)
+ /* Virtual transaction id */
+ /* keep VXID format in sync with lockfuncs.c */
+ if (MyProc != NULL && MyProc->vxid.procNumber != INVALID_PROC_NUMBER)
+- appendStringInfo(&buf, "%d/%u", MyProc->vxid.procNumber, MyProc->vxid.lxid);
++ appendStringInfo(&buf, "%d/%llu", MyProc->vxid.procNumber, (unsigned long long)MyProc->vxid.lxid);
++
+ appendStringInfoChar(&buf, ',');
+
+ /* Transaction id */
+- appendStringInfo(&buf, "%u", GetTopTransactionIdIfAny());
++ appendStringInfo(&buf, "%llu", (unsigned long long) GetTopTransactionIdIfAny());
+ appendStringInfoChar(&buf, ',');
+
+ /* Error severity */
+diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
+index 5cbb5b5416..8d2cc03a29 100644
+--- a/src/backend/utils/error/elog.c
++++ b/src/backend/utils/error/elog.c
+@@ -3120,12 +3120,12 @@ log_status_format(StringInfo buf, const char *format, ErrorData *edata)
+ {
+ char strfbuf[128];
+
+- snprintf(strfbuf, sizeof(strfbuf) - 1, "%d/%u",
+- MyProc->vxid.procNumber, MyProc->vxid.lxid);
++ snprintf(strfbuf, sizeof(strfbuf) - 1, "%d/%llu",
++ MyProc->vxid.procNumber, (unsigned long long) MyProc->vxid.lxid);
+ appendStringInfo(buf, "%*s", padding, strfbuf);
+ }
+ else
+- appendStringInfo(buf, "%d/%u", MyProc->vxid.procNumber, MyProc->vxid.lxid);
++ appendStringInfo(buf, "%d/%llu", MyProc->vxid.procNumber, (unsigned long long) MyProc->vxid.lxid);
+ }
+ else if (padding != 0)
+ appendStringInfoSpaces(buf,
+@@ -3133,9 +3133,11 @@ log_status_format(StringInfo buf, const char *format, ErrorData *edata)
+ break;
+ case 'x':
+ if (padding != 0)
+- appendStringInfo(buf, "%*u", padding, GetTopTransactionIdIfAny());
++ appendStringInfo(buf, "%*llu", padding,
++ (unsigned long long) GetTopTransactionIdIfAny());
+ else
+- appendStringInfo(buf, "%u", GetTopTransactionIdIfAny());
++ appendStringInfo(buf, "%llu",
++ (unsigned long long) GetTopTransactionIdIfAny());
+ break;
+ case 'e':
+ if (padding != 0)
+diff --git a/src/backend/utils/error/jsonlog.c b/src/backend/utils/error/jsonlog.c
+index bd0124869d..e114d011a8 100644
+--- a/src/backend/utils/error/jsonlog.c
++++ b/src/backend/utils/error/jsonlog.c
+@@ -196,12 +196,12 @@ write_jsonlog(ErrorData *edata)
+ /* Virtual transaction id */
+ /* keep VXID format in sync with lockfuncs.c */
+ if (MyProc != NULL && MyProc->vxid.procNumber != INVALID_PROC_NUMBER)
+- appendJSONKeyValueFmt(&buf, "vxid", true, "%d/%u",
+- MyProc->vxid.procNumber, MyProc->vxid.lxid);
++ appendJSONKeyValueFmt(&buf, "vxid", true, "%d/%llu",
++ MyProc->vxid.procNumber, (unsigned long long) MyProc->vxid.lxid);
+
+ /* Transaction id */
+- appendJSONKeyValueFmt(&buf, "txid", false, "%u",
+- GetTopTransactionIdIfAny());
++ appendJSONKeyValueFmt(&buf, "txid", false, "%llu",
++ (unsigned long long) GetTopTransactionIdIfAny());
+
+ /* Error severity */
+ if (edata->elevel)
+diff --git a/src/backend/utils/misc/pg_controldata.c b/src/backend/utils/misc/pg_controldata.c
+index 98c932dc7b..215f4ef6fa 100644
+--- a/src/backend/utils/misc/pg_controldata.c
++++ b/src/backend/utils/misc/pg_controldata.c
+@@ -116,9 +116,9 @@ pg_control_checkpoint(PG_FUNCTION_ARGS)
+ values[5] = BoolGetDatum(ControlFile->checkPointCopy.fullPageWrites);
+ nulls[5] = false;
+
+- values[6] = CStringGetTextDatum(psprintf("%u:%u",
++ values[6] = CStringGetTextDatum(psprintf("%u:%llu",
+ EpochFromFullTransactionId(ControlFile->checkPointCopy.nextXid),
+- XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
++ (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
+ nulls[6] = false;
+
+ values[7] = ObjectIdGetDatum(ControlFile->checkPointCopy.nextOid);
+diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c
+index 7d2b34d4f2..09919ec651 100644
+--- a/src/backend/utils/time/snapmgr.c
++++ b/src/backend/utils/time/snapmgr.c
+@@ -1175,14 +1175,14 @@ ExportSnapshot(Snapshot snapshot)
+ */
+ initStringInfo(&buf);
+
+- appendStringInfo(&buf, "vxid:%d/%u\n", MyProc->vxid.procNumber, MyProc->vxid.lxid);
++ appendStringInfo(&buf, "vxid:%d/%llu\n", MyProc->vxid.procNumber, (unsigned long long) MyProc->vxid.lxid);
+ appendStringInfo(&buf, "pid:%d\n", MyProcPid);
+ appendStringInfo(&buf, "dbid:%u\n", MyDatabaseId);
+ appendStringInfo(&buf, "iso:%d\n", XactIsoLevel);
+ appendStringInfo(&buf, "ro:%d\n", XactReadOnly);
+
+- appendStringInfo(&buf, "xmin:%u\n", snapshot->xmin);
+- appendStringInfo(&buf, "xmax:%u\n", snapshot->xmax);
++ appendStringInfo(&buf, "xmin:%llu\n", (unsigned long long) snapshot->xmin);
++ appendStringInfo(&buf, "xmax:%llu\n", (unsigned long long) snapshot->xmax);
+
+ /*
+ * We must include our own top transaction ID in the top-xid data, since
+@@ -1199,9 +1199,10 @@ ExportSnapshot(Snapshot snapshot)
+ TransactionIdPrecedes(topXid, snapshot->xmax)) ? 1 : 0;
+ appendStringInfo(&buf, "xcnt:%d\n", snapshot->xcnt + addTopXid);
+ for (i = 0; i < snapshot->xcnt; i++)
+- appendStringInfo(&buf, "xip:%u\n", snapshot->xip[i]);
++ appendStringInfo(&buf, "xip:%llu\n",
++ (unsigned long long) snapshot->xip[i]);
+ if (addTopXid)
+- appendStringInfo(&buf, "xip:%u\n", topXid);
++ appendStringInfo(&buf, "xip:%llu\n", (unsigned long long) topXid);
+
+ /*
+ * Similarly, we add our subcommitted child XIDs to the subxid data. Here,
+@@ -1215,9 +1216,11 @@ ExportSnapshot(Snapshot snapshot)
+ appendStringInfoString(&buf, "sof:0\n");
+ appendStringInfo(&buf, "sxcnt:%d\n", snapshot->subxcnt + nchildren);
+ for (i = 0; i < snapshot->subxcnt; i++)
+- appendStringInfo(&buf, "sxp:%u\n", snapshot->subxip[i]);
++ appendStringInfo(&buf, "sxp:%llu\n",
++ (unsigned long long) snapshot->subxip[i]);
+ for (i = 0; i < nchildren; i++)
+- appendStringInfo(&buf, "sxp:%u\n", children[i]);
++ appendStringInfo(&buf, "sxp:%llu\n",
++ (unsigned long long) children[i]);
+ }
+ appendStringInfo(&buf, "rec:%u\n", snapshot->takenDuringRecovery);
+
+diff --git a/src/bin/pg_controldata/pg_controldata.c b/src/bin/pg_controldata/pg_controldata.c
+index 43b6727570..26c5eb76fd 100644
+--- a/src/bin/pg_controldata/pg_controldata.c
++++ b/src/bin/pg_controldata/pg_controldata.c
+@@ -246,29 +246,29 @@ main(int argc, char *argv[])
+ ControlFile->checkPointCopy.PrevTimeLineID);
+ printf(_("Latest checkpoint's full_page_writes: %s\n"),
+ ControlFile->checkPointCopy.fullPageWrites ? _("on") : _("off"));
+- printf(_("Latest checkpoint's NextXID: %u:%u\n"),
++ printf(_("Latest checkpoint's NextXID: %u:%llu\n"),
+ EpochFromFullTransactionId(ControlFile->checkPointCopy.nextXid),
+- XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid));
++ (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid));
+ printf(_("Latest checkpoint's NextOID: %u\n"),
+ ControlFile->checkPointCopy.nextOid);
+- printf(_("Latest checkpoint's NextMultiXactId: %u\n"),
+- ControlFile->checkPointCopy.nextMulti);
++ printf(_("Latest checkpoint's NextMultiXactId: %llu\n"),
++ (unsigned long long) ControlFile->checkPointCopy.nextMulti);
+ printf(_("Latest checkpoint's NextMultiOffset: %llu\n"),
+ (unsigned long long) ControlFile->checkPointCopy.nextMultiOffset);
+- printf(_("Latest checkpoint's oldestXID: %u\n"),
+- ControlFile->checkPointCopy.oldestXid);
++ printf(_("Latest checkpoint's oldestXID: %llu\n"),
++ (unsigned long long) ControlFile->checkPointCopy.oldestXid);
+ printf(_("Latest checkpoint's oldestXID's DB: %u\n"),
+ ControlFile->checkPointCopy.oldestXidDB);
+- printf(_("Latest checkpoint's oldestActiveXID: %u\n"),
+- ControlFile->checkPointCopy.oldestActiveXid);
+- printf(_("Latest checkpoint's oldestMultiXid: %u\n"),
+- ControlFile->checkPointCopy.oldestMulti);
++ printf(_("Latest checkpoint's oldestActiveXID: %llu\n"),
++ (unsigned long long) ControlFile->checkPointCopy.oldestActiveXid);
++ printf(_("Latest checkpoint's oldestMultiXid: %llu\n"),
++ (unsigned long long) ControlFile->checkPointCopy.oldestMulti);
+ printf(_("Latest checkpoint's oldestMulti's DB: %u\n"),
+ ControlFile->checkPointCopy.oldestMultiDB);
+- printf(_("Latest checkpoint's oldestCommitTsXid:%u\n"),
+- ControlFile->checkPointCopy.oldestCommitTsXid);
+- printf(_("Latest checkpoint's newestCommitTsXid:%u\n"),
+- ControlFile->checkPointCopy.newestCommitTsXid);
++ printf(_("Latest checkpoint's oldestCommitTsXid:%llu\n"),
++ (unsigned long long) ControlFile->checkPointCopy.oldestCommitTsXid);
++ printf(_("Latest checkpoint's newestCommitTsXid:%llu\n"),
++ (unsigned long long) ControlFile->checkPointCopy.newestCommitTsXid);
+ printf(_("Time of latest checkpoint: %s\n"),
+ ckpttime_str);
+ printf(_("Fake LSN counter for unlogged rels: %X/%X\n"),
+diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
+index 130b80775d..3586053878 100644
+--- a/src/bin/pg_dump/pg_dump.c
++++ b/src/bin/pg_dump/pg_dump.c
+@@ -3441,9 +3441,10 @@ dumpDatabase(Archive *fout)
+ {
+ appendPQExpBufferStr(creaQry, "\n-- For binary upgrade, set datfrozenxid and datminmxid.\n");
+ appendPQExpBuffer(creaQry, "UPDATE pg_catalog.pg_database\n"
+- "SET datfrozenxid = '%u', datminmxid = '%u'\n"
++ "SET datfrozenxid = '%llu', datminmxid = '%llu'\n"
+ "WHERE datname = ",
+- frozenxid, minmxid);
++ (unsigned long long) frozenxid,
++ (unsigned long long) minmxid);
+ appendStringLiteralAH(creaQry, datname, fout);
+ appendPQExpBufferStr(creaQry, ";\n");
+ }
+@@ -16353,9 +16354,10 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
+ {
+ appendPQExpBufferStr(q, "\n-- For binary upgrade, set heap's relfrozenxid and relminmxid\n");
+ appendPQExpBuffer(q, "UPDATE pg_catalog.pg_class\n"
+- "SET relfrozenxid = '%u', relminmxid = '%u'\n"
++ "SET relfrozenxid = '%llu', relminmxid = '%llu'\n"
+ "WHERE oid = ",
+- tbinfo->frozenxid, tbinfo->minmxid);
++ (unsigned long long) tbinfo->frozenxid,
++ (unsigned long long) tbinfo->minmxid);
+ appendStringLiteralAH(q, qualrelname, fout);
+ appendPQExpBufferStr(q, "::pg_catalog.regclass;\n");
+
+@@ -16367,10 +16369,11 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
+ */
+ appendPQExpBufferStr(q, "\n-- For binary upgrade, set toast's relfrozenxid and relminmxid\n");
+ appendPQExpBuffer(q, "UPDATE pg_catalog.pg_class\n"
+- "SET relfrozenxid = '%u', relminmxid = '%u'\n"
++ "SET relfrozenxid = '%llu', relminmxid = '%llu'\n"
+ "WHERE oid = '%u';\n",
+- tbinfo->toast_frozenxid,
+- tbinfo->toast_minmxid, tbinfo->toast_oid);
++ (unsigned long long) tbinfo->toast_frozenxid,
++ (unsigned long long) tbinfo->toast_minmxid,
++ tbinfo->toast_oid);
+ }
+ }
+
+diff --git a/src/bin/pg_resetwal/pg_resetwal.c b/src/bin/pg_resetwal/pg_resetwal.c
+index 1af2ce4b93..b2f2026382 100644
+--- a/src/bin/pg_resetwal/pg_resetwal.c
++++ b/src/bin/pg_resetwal/pg_resetwal.c
+@@ -179,7 +179,8 @@ main(int argc, char *argv[])
+ exit(1);
+ }
+ if (!TransactionIdIsNormal(set_oldest_xid))
+- pg_fatal("oldest transaction ID (-u) must be greater than or equal to %u", FirstNormalTransactionId);
++ pg_fatal("oldest transaction ID (-u) must be greater than or equal to %llu",
++ (unsigned long long) FirstNormalTransactionId);
+ break;
+
+ case 'x':
+@@ -192,7 +193,8 @@ main(int argc, char *argv[])
+ exit(1);
+ }
+ if (!TransactionIdIsNormal(set_xid))
+- pg_fatal("transaction ID (-x) must be greater than or equal to %u", FirstNormalTransactionId);
++ pg_fatal("transaction ID (-x) must be greater than or equal to %llu",
++ (unsigned long long) FirstNormalTransactionId);
+ break;
+
+ case 'c':
+@@ -214,11 +216,15 @@ main(int argc, char *argv[])
+
+ if (set_oldest_commit_ts_xid < FirstNormalTransactionId &&
+ set_oldest_commit_ts_xid != InvalidTransactionId)
+- pg_fatal("transaction ID (-c) must be either %u or greater than or equal to %u", InvalidTransactionId, FirstNormalTransactionId);
++ pg_fatal("transaction ID (-c) must be either %llu or greater than or equal to %llu",
++ (unsigned long long) InvalidTransactionId,
++ (unsigned long long) FirstNormalTransactionId);
+
+ if (set_newest_commit_ts_xid < FirstNormalTransactionId &&
+ set_newest_commit_ts_xid != InvalidTransactionId)
+- pg_fatal("transaction ID (-c) must be either %u or greater than or equal to %u", InvalidTransactionId, FirstNormalTransactionId);
++ pg_fatal("transaction ID (-c) must be either %llu or greater than or equal to %llu",
++ (unsigned long long) InvalidTransactionId,
++ (unsigned long long) FirstNormalTransactionId);
+ break;
+
+ case 'o':
+@@ -730,29 +736,29 @@ PrintControlValues(bool guessed)
+ ControlFile.checkPointCopy.ThisTimeLineID);
+ printf(_("Latest checkpoint's full_page_writes: %s\n"),
+ ControlFile.checkPointCopy.fullPageWrites ? _("on") : _("off"));
+- printf(_("Latest checkpoint's NextXID: %u:%u\n"),
++ printf(_("Latest checkpoint's NextXID: %u:%llu\n"),
+ EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid),
+- XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
++ (unsigned long long) XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+ printf(_("Latest checkpoint's NextOID: %u\n"),
+ ControlFile.checkPointCopy.nextOid);
+- printf(_("Latest checkpoint's NextMultiXactId: %u\n"),
+- ControlFile.checkPointCopy.nextMulti);
++ printf(_("Latest checkpoint's NextMultiXactId: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.nextMulti);
+ printf(_("Latest checkpoint's NextMultiOffset: %llu\n"),
+ (unsigned long long) ControlFile.checkPointCopy.nextMultiOffset);
+- printf(_("Latest checkpoint's oldestXID: %u\n"),
+- ControlFile.checkPointCopy.oldestXid);
++ printf(_("Latest checkpoint's oldestXID: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.oldestXid);
+ printf(_("Latest checkpoint's oldestXID's DB: %u\n"),
+ ControlFile.checkPointCopy.oldestXidDB);
+- printf(_("Latest checkpoint's oldestActiveXID: %u\n"),
+- ControlFile.checkPointCopy.oldestActiveXid);
+- printf(_("Latest checkpoint's oldestMultiXid: %u\n"),
+- ControlFile.checkPointCopy.oldestMulti);
++ printf(_("Latest checkpoint's oldestActiveXID: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.oldestActiveXid);
++ printf(_("Latest checkpoint's oldestMultiXid: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.oldestMulti);
+ printf(_("Latest checkpoint's oldestMulti's DB: %u\n"),
+ ControlFile.checkPointCopy.oldestMultiDB);
+- printf(_("Latest checkpoint's oldestCommitTsXid:%u\n"),
+- ControlFile.checkPointCopy.oldestCommitTsXid);
+- printf(_("Latest checkpoint's newestCommitTsXid:%u\n"),
+- ControlFile.checkPointCopy.newestCommitTsXid);
++ printf(_("Latest checkpoint's oldestCommitTsXid:%llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.oldestCommitTsXid);
++ printf(_("Latest checkpoint's newestCommitTsXid:%llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.newestCommitTsXid);
+ printf(_("Maximum data alignment: %u\n"),
+ ControlFile.maxAlign);
+ /* we don't print floatFormat since can't say much useful about it */
+@@ -799,10 +805,10 @@ PrintNewControlValues(void)
+
+ if (set_mxid != 0)
+ {
+- printf(_("NextMultiXactId: %u\n"),
+- ControlFile.checkPointCopy.nextMulti);
+- printf(_("OldestMultiXid: %u\n"),
+- ControlFile.checkPointCopy.oldestMulti);
++ printf(_("NextMultiXactId: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.nextMulti);
++ printf(_("OldestMultiXid: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.oldestMulti);
+ printf(_("OldestMulti's DB: %u\n"),
+ ControlFile.checkPointCopy.oldestMultiDB);
+ }
+@@ -821,10 +827,10 @@ PrintNewControlValues(void)
+
+ if (set_xid != 0)
+ {
+- printf(_("NextXID: %u\n"),
+- XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+- printf(_("OldestXID: %u\n"),
+- ControlFile.checkPointCopy.oldestXid);
++ printf(_("NextXID: %llu\n"),
++ (unsigned long long) XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
++ printf(_("OldestXID: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.oldestXid);
+ printf(_("OldestXID's DB: %u\n"),
+ ControlFile.checkPointCopy.oldestXidDB);
+ }
+@@ -837,13 +843,13 @@ PrintNewControlValues(void)
+
+ if (set_oldest_commit_ts_xid != 0)
+ {
+- printf(_("oldestCommitTsXid: %u\n"),
+- ControlFile.checkPointCopy.oldestCommitTsXid);
++ printf(_("oldestCommitTsXid: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.oldestCommitTsXid);
+ }
+ if (set_newest_commit_ts_xid != 0)
+ {
+- printf(_("newestCommitTsXid: %u\n"),
+- ControlFile.checkPointCopy.newestCommitTsXid);
++ printf(_("newestCommitTsXid: %llu\n"),
++ (unsigned long long) ControlFile.checkPointCopy.newestCommitTsXid);
+ }
+
+ if (set_wal_segsize != 0)
+diff --git a/src/bin/pg_upgrade/pg_upgrade.c b/src/bin/pg_upgrade/pg_upgrade.c
+index d9d8d0ea78..24672e3d8d 100644
+--- a/src/bin/pg_upgrade/pg_upgrade.c
++++ b/src/bin/pg_upgrade/pg_upgrade.c
+@@ -717,16 +717,18 @@ copy_xact_xlog_xid(void)
+
+ prep_status("Setting oldest XID for new cluster");
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+- "\"%s/pg_resetwal\" -f -u %u \"%s\"",
+- new_cluster.bindir, old_cluster.controldata.chkpnt_oldstxid,
++ "\"%s/pg_resetwal\" -f -u %llu \"%s\"",
++ new_cluster.bindir,
++ (unsigned long long) old_cluster.controldata.chkpnt_oldstxid,
+ new_cluster.pgdata);
+ check_ok();
+
+ /* set the next transaction id and epoch of the new cluster */
+ prep_status("Setting next transaction ID and epoch for new cluster");
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+- "\"%s/pg_resetwal\" -f -x %u \"%s\"",
+- new_cluster.bindir, old_cluster.controldata.chkpnt_nxtxid,
++ "\"%s/pg_resetwal\" -f -x %llu \"%s\"",
++ new_cluster.bindir,
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
+ new_cluster.pgdata);
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -e %u \"%s\"",
+@@ -734,10 +736,10 @@ copy_xact_xlog_xid(void)
+ new_cluster.pgdata);
+ /* must reset commit timestamp limits also */
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+- "\"%s/pg_resetwal\" -f -c %u,%u \"%s\"",
++ "\"%s/pg_resetwal\" -f -c %llu,%llu \"%s\"",
+ new_cluster.bindir,
+- old_cluster.controldata.chkpnt_nxtxid,
+- old_cluster.controldata.chkpnt_nxtxid,
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
+ new_cluster.pgdata);
+ check_ok();
+
+@@ -783,11 +785,11 @@ copy_xact_xlog_xid(void)
+ * counters here and the oldest multi present on system.
+ */
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+- "\"%s/pg_resetwal\" -O %llu -m %u,%u \"%s\"",
++ "\"%s/pg_resetwal\" -O %llu -m %llu,%llu \"%s\"",
+ new_cluster.bindir,
+ (unsigned long long) old_cluster.controldata.chkpnt_nxtmxoff,
+- old_cluster.controldata.chkpnt_nxtmulti,
+- old_cluster.controldata.chkpnt_oldstMulti,
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti,
++ (unsigned long long) old_cluster.controldata.chkpnt_oldstMulti,
+ new_cluster.pgdata);
+ check_ok();
+ }
+@@ -811,10 +813,10 @@ copy_xact_xlog_xid(void)
+ * next=MaxMultiXactId, but multixact.c can cope with that just fine.
+ */
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+- "\"%s/pg_resetwal\" -m %u,%u \"%s\"",
++ "\"%s/pg_resetwal\" -m %llu,%llu \"%s\"",
+ new_cluster.bindir,
+- old_cluster.controldata.chkpnt_nxtmulti + 1,
+- old_cluster.controldata.chkpnt_nxtmulti,
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti + 1,
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti,
+ new_cluster.pgdata);
+ check_ok();
+ }
+@@ -873,14 +875,14 @@ set_frozenxids(bool minmxid_only)
+ /* set pg_database.datfrozenxid */
+ PQclear(executeQueryOrDie(conn_template1,
+ "UPDATE pg_catalog.pg_database "
+- "SET datfrozenxid = '%u'",
+- old_cluster.controldata.chkpnt_nxtxid));
++ "SET datfrozenxid = '%llu'",
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtxid));
+
+ /* set pg_database.datminmxid */
+ PQclear(executeQueryOrDie(conn_template1,
+ "UPDATE pg_catalog.pg_database "
+- "SET datminmxid = '%u'",
+- old_cluster.controldata.chkpnt_nxtmulti));
++ "SET datminmxid = '%llu'",
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti));
+
+ /* get database names */
+ dbres = executeQueryOrDie(conn_template1,
+@@ -914,24 +916,24 @@ set_frozenxids(bool minmxid_only)
+ /* set pg_class.relfrozenxid */
+ PQclear(executeQueryOrDie(conn,
+ "UPDATE pg_catalog.pg_class "
+- "SET relfrozenxid = '%u' "
++ "SET relfrozenxid = '%llu' "
+ /* only heap, materialized view, and TOAST are vacuumed */
+ "WHERE relkind IN ("
+ CppAsString2(RELKIND_RELATION) ", "
+ CppAsString2(RELKIND_MATVIEW) ", "
+ CppAsString2(RELKIND_TOASTVALUE) ")",
+- old_cluster.controldata.chkpnt_nxtxid));
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtxid));
+
+ /* set pg_class.relminmxid */
+ PQclear(executeQueryOrDie(conn,
+ "UPDATE pg_catalog.pg_class "
+- "SET relminmxid = '%u' "
++ "SET relminmxid = '%llu' "
+ /* only heap, materialized view, and TOAST are vacuumed */
+ "WHERE relkind IN ("
+ CppAsString2(RELKIND_RELATION) ", "
+ CppAsString2(RELKIND_MATVIEW) ", "
+ CppAsString2(RELKIND_TOASTVALUE) ")",
+- old_cluster.controldata.chkpnt_nxtmulti));
++ (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti));
+ PQfinish(conn);
+
+ /* Reset datallowconn flag */
+diff --git a/src/bin/pg_waldump/pg_waldump.c b/src/bin/pg_waldump/pg_waldump.c
+index 1f9403fc5c..508185bdd5 100644
+--- a/src/bin/pg_waldump/pg_waldump.c
++++ b/src/bin/pg_waldump/pg_waldump.c
+@@ -555,10 +555,10 @@ XLogDumpDisplayRecord(XLogDumpConfig *config, XLogReaderState *record)
+
+ XLogRecGetLen(record, &rec_len, &fpi_len);
+
+- printf("rmgr: %-11s len (rec/tot): %6u/%6u, tx: %10u, lsn: %X/%08X, prev %X/%08X, ",
++ printf("rmgr: %-11s len (rec/tot): %6u/%6u, tx: %20llu, lsn: %X/%08X, prev %X/%08X, ",
+ desc->rm_name,
+ rec_len, XLogRecGetTotalLen(record),
+- XLogRecGetXid(record),
++ (unsigned long long) XLogRecGetXid(record),
+ LSN_FORMAT_ARGS(record->ReadRecPtr),
+ LSN_FORMAT_ARGS(xl_prev));
+
+diff --git a/src/test/modules/xid_wraparound/xid_wraparound.c b/src/test/modules/xid_wraparound/xid_wraparound.c
+index dce81c0c6d..99a46e07c8 100644
+--- a/src/test/modules/xid_wraparound/xid_wraparound.c
++++ b/src/test/modules/xid_wraparound/xid_wraparound.c
+@@ -136,16 +136,16 @@ consume_xids_common(FullTransactionId untilxid, uint64 nxids)
+ if (consumed - last_reported_at >= REPORT_INTERVAL)
+ {
+ if (nxids > 0)
+- elog(NOTICE, "consumed %llu / %llu XIDs, latest %u:%u",
++ elog(NOTICE, "consumed %llu / %llu XIDs, latest %u:%llu",
+ (unsigned long long) consumed, (unsigned long long) nxids,
+ EpochFromFullTransactionId(lastxid),
+- XidFromFullTransactionId(lastxid));
++ (unsigned long long) XidFromFullTransactionId(lastxid));
+ else
+- elog(NOTICE, "consumed up to %u:%u / %u:%u",
++ elog(NOTICE, "consumed up to %u:%llu / %u:%llu",
+ EpochFromFullTransactionId(lastxid),
+- XidFromFullTransactionId(lastxid),
++ (unsigned long long) XidFromFullTransactionId(lastxid),
+ EpochFromFullTransactionId(untilxid),
+- XidFromFullTransactionId(untilxid));
++ (unsigned long long) XidFromFullTransactionId(untilxid));
+ last_reported_at = consumed;
+ }
+ }
+--
+2.46.0
+
diff --git a/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0002-Use-64-bit-FullTransactionId-instead-of-Epoch-xi.patch b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0002-Use-64-bit-FullTransactionId-instead-of-Epoch-xi.patch
new file mode 100644
index 00000000000..21c81fb46b5
--- /dev/null
+++ b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0002-Use-64-bit-FullTransactionId-instead-of-Epoch-xi.patch
@@ -0,0 +1,463 @@
+From a408532826d3a13836fd7374c33c84719311195d Mon Sep 17 00:00:00 2001
+From: Maxim Orlov <m.orlov@postgrespro.ru>
+Date: Fri, 25 Mar 2022 12:36:24 +0300
+Subject: [PATCH v55 2/5] Use 64-bit FullTransactionId instead of Epoch:xid
+
+NextXid in controldata is now compatible with old format Epoch:xid and the new
+one. This is next step to make XIDs 64-bit.
+
+Author: Alexander Korotkov <aekorotkov@gmail.com>
+Author: Teodor Sigaev <teodor@sigaev.ru>
+Author: Nikita Glukhov <n.gluhov@postgrespro.ru>
+Author: Maxim Orlov <orlovmg@gmail.com>
+Author: Pavel Borisov <pashkin.elfe@gmail.com>
+Author: Yura Sokolov <y.sokolov@postgrespro.ru> <funny.falcon@gmail.com>
+Author: Aleksander Alekseev <aleksander@timescale.com>
+Discussion: https://postgr.es/m/CACG%3DezZe1NQSCnfHOr78AtAZxJZeCvxrts0ygrxYwe%3DpyyjVWA%40mail.gmail.com
+Discussion: https://postgr.es/m/CAJ7c6TPDOYBYrnCAeyndkBktO0WG2xSdYduTF0nxq%2BvfkmTF5Q%40mail.gmail.com
+---
+ contrib/amcheck/verify_heapam.c | 75 ++++++++-----------
+ contrib/pageinspect/btreefuncs.c | 5 +-
+ src/backend/access/rmgrdesc/gistdesc.c | 10 +--
+ src/backend/access/rmgrdesc/nbtdesc.c | 10 +--
+ src/backend/access/rmgrdesc/xlogdesc.c | 5 +-
+ src/backend/utils/misc/pg_controldata.c | 5 +-
+ src/bin/pg_amcheck/t/004_verify_heapam.pl | 10 +--
+ src/bin/pg_controldata/pg_controldata.c | 5 +-
+ src/bin/pg_upgrade/controldata.c | 32 ++++++--
+ .../modules/xid_wraparound/xid_wraparound.c | 13 ++--
+ 10 files changed, 83 insertions(+), 87 deletions(-)
+
+diff --git a/contrib/amcheck/verify_heapam.c b/contrib/amcheck/verify_heapam.c
+index 868fcacd6b..7f383a5ffc 100644
+--- a/contrib/amcheck/verify_heapam.c
++++ b/contrib/amcheck/verify_heapam.c
+@@ -1040,24 +1040,21 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ break;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("xmin %llu equals or exceeds next valid transaction ID %u:%llu",
++ psprintf("xmin %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmin,
+- EpochFromFullTransactionId(ctx->next_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("xmin %llu precedes oldest valid transaction ID %u:%llu",
++ psprintf("xmin %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmin,
+- EpochFromFullTransactionId(ctx->oldest_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("xmin %llu precedes relation freeze threshold %u:%llu",
++ psprintf("xmin %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmin,
+- EpochFromFullTransactionId(ctx->relfrozenfxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ }
+
+@@ -1081,24 +1078,21 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ return false;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple equals or exceeds next valid transaction ID %u:%llu",
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xvac,
+- EpochFromFullTransactionId(ctx->next_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes relation freeze threshold %u:%llu",
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes relation freeze threshold %llu",
+ (unsigned long long) xvac,
+- EpochFromFullTransactionId(ctx->relfrozenfxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes oldest valid transaction ID %u:%llu",
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes oldest valid transaction ID %llu",
+ (unsigned long long) xvac,
+- EpochFromFullTransactionId(ctx->oldest_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1150,24 +1144,21 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ return false;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple equals or exceeds next valid transaction ID %u:%llu",
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xvac,
+- EpochFromFullTransactionId(ctx->next_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes relation freeze threshold %u:%llu",
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes relation freeze threshold %llu",
+ (unsigned long long) xvac,
+- EpochFromFullTransactionId(ctx->relfrozenfxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes oldest valid transaction ID %u:%llu",
++ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes oldest valid transaction ID %llu",
+ (unsigned long long) xvac,
+- EpochFromFullTransactionId(ctx->oldest_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1313,24 +1304,21 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ return true;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("update xid %llu equals or exceeds next valid transaction ID %u:%llu",
++ psprintf("update xid %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmax,
+- EpochFromFullTransactionId(ctx->next_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
+ return true;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("update xid %llu precedes relation freeze threshold %u:%llu",
++ psprintf("update xid %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmax,
+- EpochFromFullTransactionId(ctx->relfrozenfxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
+ return true;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("update xid %llu precedes oldest valid transaction ID %u:%llu",
++ psprintf("update xid %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmax,
+- EpochFromFullTransactionId(ctx->oldest_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
+ return true;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1378,24 +1366,21 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ return true;
+ case XID_IN_FUTURE:
+ report_corruption(ctx,
+- psprintf("xmax %llu equals or exceeds next valid transaction ID %u:%llu",
++ psprintf("xmax %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmax,
+- EpochFromFullTransactionId(ctx->next_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+- psprintf("xmax %llu precedes relation freeze threshold %u:%llu",
++ psprintf("xmax %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmax,
+- EpochFromFullTransactionId(ctx->relfrozenfxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+- psprintf("xmax %llu precedes oldest valid transaction ID %u:%llu",
++ psprintf("xmax %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmax,
+- EpochFromFullTransactionId(ctx->oldest_fxid),
+- (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
+ return false; /* corrupt */
+ case XID_BOUNDS_OK:
+ break;
+diff --git a/contrib/pageinspect/btreefuncs.c b/contrib/pageinspect/btreefuncs.c
+index fd6043850c..afa1947fad 100644
+--- a/contrib/pageinspect/btreefuncs.c
++++ b/contrib/pageinspect/btreefuncs.c
+@@ -142,9 +142,8 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+ {
+ FullTransactionId safexid = BTPageGetDeleteXid(page);
+
+- elog(DEBUG2, "deleted page from block %u has safexid %u:%llu",
+- blkno, EpochFromFullTransactionId(safexid),
+- (unsigned long long) XidFromFullTransactionId(safexid));
++ elog(DEBUG2, "deleted page from block %u has safexid %llu",
++ blkno, (unsigned long long) U64FromFullTransactionId(safexid));
+ }
+ else
+ elog(DEBUG2, "deleted page from block %u has safexid %llu",
+diff --git a/src/backend/access/rmgrdesc/gistdesc.c b/src/backend/access/rmgrdesc/gistdesc.c
+index f21567fa7b..b5d72a8e54 100644
+--- a/src/backend/access/rmgrdesc/gistdesc.c
++++ b/src/backend/access/rmgrdesc/gistdesc.c
+@@ -25,11 +25,10 @@ out_gistxlogPageUpdate(StringInfo buf, gistxlogPageUpdate *xlrec)
+ static void
+ out_gistxlogPageReuse(StringInfo buf, gistxlogPageReuse *xlrec)
+ {
+- appendStringInfo(buf, "rel %u/%u/%u; blk %u; snapshotConflictHorizon %u:%llu, isCatalogRel %c",
++ appendStringInfo(buf, "rel %u/%u/%u; blk %u; snapshotConflictHorizon %llu, isCatalogRel %c",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber, xlrec->block,
+- EpochFromFullTransactionId(xlrec->snapshotConflictHorizon),
+- (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
++ (unsigned long long) U64FromFullTransactionId(xlrec->snapshotConflictHorizon),
+ xlrec->isCatalogRel ? 'T' : 'F');
+ }
+
+@@ -52,9 +51,8 @@ out_gistxlogPageSplit(StringInfo buf, gistxlogPageSplit *xlrec)
+ static void
+ out_gistxlogPageDelete(StringInfo buf, gistxlogPageDelete *xlrec)
+ {
+- appendStringInfo(buf, "deleteXid %u:%llu; downlink %u",
+- EpochFromFullTransactionId(xlrec->deleteXid),
+- (unsigned long long) XidFromFullTransactionId(xlrec->deleteXid),
++ appendStringInfo(buf, "deleteXid %llu; downlink %u",
++ (unsigned long long) U64FromFullTransactionId(xlrec->deleteXid),
+ xlrec->downlinkOffset);
+ }
+
+diff --git a/src/backend/access/rmgrdesc/nbtdesc.c b/src/backend/access/rmgrdesc/nbtdesc.c
+index ce7a7a83cb..3c2f38df94 100644
+--- a/src/backend/access/rmgrdesc/nbtdesc.c
++++ b/src/backend/access/rmgrdesc/nbtdesc.c
+@@ -94,10 +94,9 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_btree_unlink_page *xlrec = (xl_btree_unlink_page *) rec;
+
+- appendStringInfo(buf, "left: %u, right: %u, level: %u, safexid: %u:%llu, ",
++ appendStringInfo(buf, "left: %u, right: %u, level: %u, safexid: %llu, ",
+ xlrec->leftsib, xlrec->rightsib, xlrec->level,
+- EpochFromFullTransactionId(xlrec->safexid),
+- (unsigned long long) XidFromFullTransactionId(xlrec->safexid));
++ (unsigned long long) U64FromFullTransactionId(xlrec->safexid));
+ appendStringInfo(buf, "leafleft: %u, leafright: %u, leaftopparent: %u",
+ xlrec->leafleftsib, xlrec->leafrightsib,
+ xlrec->leaftopparent);
+@@ -114,11 +113,10 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+ {
+ xl_btree_reuse_page *xlrec = (xl_btree_reuse_page *) rec;
+
+- appendStringInfo(buf, "rel: %u/%u/%u, snapshotConflictHorizon: %u:%llu, isCatalogRel: %c",
++ appendStringInfo(buf, "rel: %u/%u/%u, snapshotConflictHorizon: %llu, isCatalogRel: %c",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber,
+- EpochFromFullTransactionId(xlrec->snapshotConflictHorizon),
+- (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
++ (unsigned long long) U64FromFullTransactionId(xlrec->snapshotConflictHorizon),
+ xlrec->isCatalogRel ? 'T' : 'F');
+ break;
+ }
+diff --git a/src/backend/access/rmgrdesc/xlogdesc.c b/src/backend/access/rmgrdesc/xlogdesc.c
+index f41f7d963b..a6e8e3dd23 100644
+--- a/src/backend/access/rmgrdesc/xlogdesc.c
++++ b/src/backend/access/rmgrdesc/xlogdesc.c
+@@ -66,7 +66,7 @@ xlog_desc(StringInfo buf, XLogReaderState *record)
+ CheckPoint *checkpoint = (CheckPoint *) rec;
+
+ appendStringInfo(buf, "redo %X/%X; "
+- "tli %u; prev tli %u; fpw %s; wal_level %s; xid %u:%llu; oid %u; multi %llu; offset %llu; "
++ "tli %u; prev tli %u; fpw %s; wal_level %s; xid %llu; oid %u; multi %llu; offset %llu; "
+ "oldest xid %llu in DB %u; oldest multi %llu in DB %u; "
+ "oldest/newest commit timestamp xid: %llu/%llu; "
+ "oldest running xid %llu; %s",
+@@ -75,8 +75,7 @@ xlog_desc(StringInfo buf, XLogReaderState *record)
+ checkpoint->PrevTimeLineID,
+ checkpoint->fullPageWrites ? "true" : "false",
+ get_wal_level_string(checkpoint->wal_level),
+- EpochFromFullTransactionId(checkpoint->nextXid),
+- (unsigned long long) XidFromFullTransactionId(checkpoint->nextXid),
++ (unsigned long long) U64FromFullTransactionId(checkpoint->nextXid),
+ checkpoint->nextOid,
+ (unsigned long long) checkpoint->nextMulti,
+ (unsigned long long) checkpoint->nextMultiOffset,
+diff --git a/src/backend/utils/misc/pg_controldata.c b/src/backend/utils/misc/pg_controldata.c
+index 215f4ef6fa..1cb101fe82 100644
+--- a/src/backend/utils/misc/pg_controldata.c
++++ b/src/backend/utils/misc/pg_controldata.c
+@@ -116,9 +116,8 @@ pg_control_checkpoint(PG_FUNCTION_ARGS)
+ values[5] = BoolGetDatum(ControlFile->checkPointCopy.fullPageWrites);
+ nulls[5] = false;
+
+- values[6] = CStringGetTextDatum(psprintf("%u:%llu",
+- EpochFromFullTransactionId(ControlFile->checkPointCopy.nextXid),
+- (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
++ values[6] = CStringGetTextDatum(psprintf("%llu",
++ (unsigned long long) U64FromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
+ nulls[6] = false;
+
+ values[7] = ObjectIdGetDatum(ControlFile->checkPointCopy.nextOid);
+diff --git a/src/bin/pg_amcheck/t/004_verify_heapam.pl b/src/bin/pg_amcheck/t/004_verify_heapam.pl
+index f6d2c5f787..e528e3c4d5 100644
+--- a/src/bin/pg_amcheck/t/004_verify_heapam.pl
++++ b/src/bin/pg_amcheck/t/004_verify_heapam.pl
+@@ -454,7 +454,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+
+ # Expected corruption report
+ push @expected,
+- qr/${header}xmin $xmin precedes relation freeze threshold 0:\d+/;
++ qr/${header}xmin $xmin precedes relation freeze threshold \d+/;
+ }
+ elsif ($offnum == 2)
+ {
+@@ -465,7 +465,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ $tup->{t_infomask} &= ~HEAP_XMIN_INVALID;
+
+ push @expected,
+- qr/${$header}xmin $xmin precedes oldest valid transaction ID 0:\d+/;
++ qr/${$header}xmin $xmin precedes oldest valid transaction ID \d+/;
+ }
+ elsif ($offnum == 3)
+ {
+@@ -477,7 +477,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ $tup->{t_infomask} &= ~HEAP_XMIN_INVALID;
+
+ push @expected,
+- qr/${$header}xmin ${xmin} precedes oldest valid transaction ID 0:\d+/;
++ qr/${$header}xmin ${xmin} precedes oldest valid transaction ID \d+/;
+ }
+ elsif ($offnum == 4)
+ {
+@@ -487,7 +487,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ $tup->{t_infomask} &= ~HEAP_XMAX_INVALID;
+
+ push @expected,
+- qr/${$header}xmax ${xmax} precedes oldest valid transaction ID 0:\d+/;
++ qr/${$header}xmax ${xmax} precedes oldest valid transaction ID \d+/;
+ }
+ elsif ($offnum == 5)
+ {
+@@ -614,7 +614,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ $tup->{t_infomask} &= ~HEAP_XMIN_INVALID;
+
+ push @expected,
+- qr/${$header}xmin ${xmin} equals or exceeds next valid transaction ID 0:\d+/;
++ qr/${$header}xmin ${xmin} equals or exceeds next valid transaction ID \d+/;
+ }
+ elsif ($offnum == 17)
+ {
+diff --git a/src/bin/pg_controldata/pg_controldata.c b/src/bin/pg_controldata/pg_controldata.c
+index 26c5eb76fd..5414b921c3 100644
+--- a/src/bin/pg_controldata/pg_controldata.c
++++ b/src/bin/pg_controldata/pg_controldata.c
+@@ -246,9 +246,8 @@ main(int argc, char *argv[])
+ ControlFile->checkPointCopy.PrevTimeLineID);
+ printf(_("Latest checkpoint's full_page_writes: %s\n"),
+ ControlFile->checkPointCopy.fullPageWrites ? _("on") : _("off"));
+- printf(_("Latest checkpoint's NextXID: %u:%llu\n"),
+- EpochFromFullTransactionId(ControlFile->checkPointCopy.nextXid),
+- (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid));
++ printf(_("Latest checkpoint's NextXID: %llu\n"),
++ (unsigned long long) U64FromFullTransactionId(ControlFile->checkPointCopy.nextXid));
+ printf(_("Latest checkpoint's NextOID: %u\n"),
+ ControlFile->checkPointCopy.nextOid);
+ printf(_("Latest checkpoint's NextMultiXactId: %llu\n"),
+diff --git a/src/bin/pg_upgrade/controldata.c b/src/bin/pg_upgrade/controldata.c
+index 1f0ccea3ed..39e141b9b3 100644
+--- a/src/bin/pg_upgrade/controldata.c
++++ b/src/bin/pg_upgrade/controldata.c
+@@ -8,6 +8,7 @@
+ */
+
+ #include "postgres_fe.h"
++#include "access/transam.h"
+
+ #include <ctype.h>
+
+@@ -267,13 +268,22 @@ get_control_data(ClusterInfo *cluster, bool live_check)
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's NextXID:")) != NULL)
+ {
++ FullTransactionId xid;
++
+ p = strchr(p, ':');
+
+ if (p == NULL || strlen(p) <= 1)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_nxtepoch = str2uint(p);
++
++ /*
++ * NextXID representation in controldata file changed from Epoch:Xid
++ * to 64-bit FullTransactionId representation as a part of making
++ * xids 64-bit in the future. Here we support both controldata
++ * formats.
++ */
++ xid.value = strtou64(p, NULL, 10);
+
+ /*
+ * Delimiter changed from '/' to ':' in 9.6. We don't test for
+@@ -288,11 +298,23 @@ get_control_data(ClusterInfo *cluster, bool live_check)
+ else
+ p = NULL;
+
+- if (p == NULL || strlen(p) <= 1)
+- pg_fatal("%d: controldata retrieval problem", __LINE__);
++ if (p == NULL)
++ {
++ /* FullTransactionId representation */
++ cluster->controldata.chkpnt_nxtxid = XidFromFullTransactionId(xid);
++ cluster->controldata.chkpnt_nxtepoch = EpochFromFullTransactionId(xid);
++ }
++ else
++ {
++ if (strlen(p) <= 1)
++ pg_fatal("%d: controldata retrieval problem", __LINE__);
++
++ /* Epoch:Xid representation */
++ p++; /* remove '/' or ':' char */
++ cluster->controldata.chkpnt_nxtxid = str2uint(p);
++ cluster->controldata.chkpnt_nxtepoch = (TransactionId) XidFromFullTransactionId(xid);
++ }
+
+- p++; /* remove '/' or ':' char */
+- cluster->controldata.chkpnt_nxtxid = str2uint(p);
+ got_xid = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's NextOID:")) != NULL)
+diff --git a/src/test/modules/xid_wraparound/xid_wraparound.c b/src/test/modules/xid_wraparound/xid_wraparound.c
+index 99a46e07c8..9b0f499f2b 100644
+--- a/src/test/modules/xid_wraparound/xid_wraparound.c
++++ b/src/test/modules/xid_wraparound/xid_wraparound.c
+@@ -136,16 +136,13 @@ consume_xids_common(FullTransactionId untilxid, uint64 nxids)
+ if (consumed - last_reported_at >= REPORT_INTERVAL)
+ {
+ if (nxids > 0)
+- elog(NOTICE, "consumed %llu / %llu XIDs, latest %u:%llu",
++ elog(NOTICE, "consumed %llu / %llu XIDs, latest %llu",
+ (unsigned long long) consumed, (unsigned long long) nxids,
+- EpochFromFullTransactionId(lastxid),
+- (unsigned long long) XidFromFullTransactionId(lastxid));
++ (unsigned long long) U64FromFullTransactionId(lastxid));
+ else
+- elog(NOTICE, "consumed up to %u:%llu / %u:%llu",
+- EpochFromFullTransactionId(lastxid),
+- (unsigned long long) XidFromFullTransactionId(lastxid),
+- EpochFromFullTransactionId(untilxid),
+- (unsigned long long) XidFromFullTransactionId(untilxid));
++ elog(NOTICE, "consumed up to %llu / %llu",
++ (unsigned long long) U64FromFullTransactionId(lastxid),
++ (unsigned long long) U64FromFullTransactionId(untilxid));
+ last_reported_at = consumed;
+ }
+ }
+--
+2.45.2
+
diff --git a/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0003-Use-64-bit-SLRU-pages-in-callers.patch b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0003-Use-64-bit-SLRU-pages-in-callers.patch
new file mode 100644
index 00000000000..c626af2ed51
--- /dev/null
+++ b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0003-Use-64-bit-SLRU-pages-in-callers.patch
@@ -0,0 +1,97 @@
+From dcc6a54d5b43d0fdd3ccffb1f27d3c600f9d7a75 Mon Sep 17 00:00:00 2001
+From: Maxim Orlov <m.orlov@postgrespro.ru>
+Date: Thu, 7 Dec 2023 18:52:45 +0300
+Subject: [PATCH v55 3/5] Use 64-bit SLRU pages in callers.
+
+TODO:
+ - add upgrade for slru segments
+---
+ src/backend/access/transam/clog.c | 2 +-
+ src/backend/access/transam/commit_ts.c | 2 +-
+ src/backend/access/transam/multixact.c | 4 ++--
+ src/backend/access/transam/subtrans.c | 2 +-
+ src/backend/storage/lmgr/predicate.c | 2 +-
+ src/bin/pg_verifybackup/t/003_corruption.pl | 2 +-
+ 6 files changed, 7 insertions(+), 7 deletions(-)
+
+diff --git a/src/backend/access/transam/clog.c b/src/backend/access/transam/clog.c
+index 44c253246b..41ae3da851 100644
+--- a/src/backend/access/transam/clog.c
++++ b/src/backend/access/transam/clog.c
+@@ -810,7 +810,7 @@ CLOGShmemInit(void)
+ XactCtl->PagePrecedes = CLOGPagePrecedes;
+ SimpleLruInit(XactCtl, "transaction", CLOGShmemBuffers(), CLOG_LSNS_PER_PAGE,
+ "pg_xact", LWTRANCHE_XACT_BUFFER,
+- LWTRANCHE_XACT_SLRU, SYNC_HANDLER_CLOG, false);
++ LWTRANCHE_XACT_SLRU, SYNC_HANDLER_CLOG, true);
+ SlruPagePrecedesUnitTests(XactCtl, CLOG_XACTS_PER_PAGE);
+ }
+
+diff --git a/src/backend/access/transam/commit_ts.c b/src/backend/access/transam/commit_ts.c
+index 00c1f29302..a46602f91f 100644
+--- a/src/backend/access/transam/commit_ts.c
++++ b/src/backend/access/transam/commit_ts.c
+@@ -558,7 +558,7 @@ CommitTsShmemInit(void)
+ "pg_commit_ts", LWTRANCHE_COMMITTS_BUFFER,
+ LWTRANCHE_COMMITTS_SLRU,
+ SYNC_HANDLER_COMMIT_TS,
+- false);
++ true);
+ SlruPagePrecedesUnitTests(CommitTsCtl, COMMIT_TS_XACTS_PER_PAGE);
+
+ commitTsShared = ShmemInitStruct("CommitTs shared",
+diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
+index 97e6403e8a..7b76ef1cca 100644
+--- a/src/backend/access/transam/multixact.c
++++ b/src/backend/access/transam/multixact.c
+@@ -1906,7 +1906,7 @@ MultiXactShmemInit(void)
+ "pg_multixact/members", LWTRANCHE_MULTIXACTMEMBER_BUFFER,
+ LWTRANCHE_MULTIXACTMEMBER_SLRU,
+ SYNC_HANDLER_MULTIXACT_MEMBER,
+- false);
++ true);
+ /* doesn't call SimpleLruTruncate() or meet criteria for unit tests */
+
+ /* Initialize our shared state struct */
+diff --git a/src/backend/access/transam/subtrans.c b/src/backend/access/transam/subtrans.c
+index 3f0fdeb10e..9d762b75c2 100644
+--- a/src/backend/access/transam/subtrans.c
++++ b/src/backend/access/transam/subtrans.c
+@@ -244,7 +244,7 @@ SUBTRANSShmemInit(void)
+ SubTransCtl->PagePrecedes = SubTransPagePrecedes;
+ SimpleLruInit(SubTransCtl, "subtransaction", SUBTRANSShmemBuffers(), 0,
+ "pg_subtrans", LWTRANCHE_SUBTRANS_BUFFER,
+- LWTRANCHE_SUBTRANS_SLRU, SYNC_HANDLER_NONE, false);
++ LWTRANCHE_SUBTRANS_SLRU, SYNC_HANDLER_NONE, true);
+ SlruPagePrecedesUnitTests(SubTransCtl, SUBTRANS_XACTS_PER_PAGE);
+ }
+
+diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
+index 3539eb489a..98f330b9ac 100644
+--- a/src/backend/storage/lmgr/predicate.c
++++ b/src/backend/storage/lmgr/predicate.c
+@@ -814,7 +814,7 @@ SerialInit(void)
+ SimpleLruInit(SerialSlruCtl, "serializable",
+ serializable_buffers, 0, "pg_serial",
+ LWTRANCHE_SERIAL_BUFFER, LWTRANCHE_SERIAL_SLRU,
+- SYNC_HANDLER_NONE, false);
++ SYNC_HANDLER_NONE, true);
+ #ifdef USE_ASSERT_CHECKING
+ SerialPagePrecedesLogicallyUnitTests();
+ #endif
+diff --git a/src/bin/pg_verifybackup/t/003_corruption.pl b/src/bin/pg_verifybackup/t/003_corruption.pl
+index ae91e04338..b4ea3a8bd9 100644
+--- a/src/bin/pg_verifybackup/t/003_corruption.pl
++++ b/src/bin/pg_verifybackup/t/003_corruption.pl
+@@ -182,7 +182,7 @@ sub mutilate_extra_tablespace_file
+ sub mutilate_missing_file
+ {
+ my ($backup_path) = @_;
+- my $pathname = "$backup_path/pg_xact/0000";
++ my $pathname = "$backup_path/pg_xact/000000000000000";
+ unlink($pathname) || die "$pathname: $!";
+ return;
+ }
+--
+2.45.2
+
diff --git a/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0005-README.XID64.patch b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0005-README.XID64.patch
new file mode 100644
index 00000000000..7f363093bd1
--- /dev/null
+++ b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0005-README.XID64.patch
@@ -0,0 +1,161 @@
+From 91460c2a6770098d34063ee2c00a0ecbfcae990c Mon Sep 17 00:00:00 2001
+From: Maxim Orlov <m.orlov@postgrespro.ru>
+Date: Fri, 11 Mar 2022 11:35:16 +0300
+Subject: [PATCH v55 5/5] README.XID64
+
+Author: Alexander Korotkov <aekorotkov@gmail.com>
+Author: Teodor Sigaev <teodor@sigaev.ru>
+Author: Nikita Glukhov <n.gluhov@postgrespro.ru>
+Author: Maxim Orlov <orlovmg@gmail.com>
+Author: Pavel Borisov <pashkin.elfe@gmail.com>
+Author: Yura Sokolov <y.sokolov@postgrespro.ru> <funny.falcon@gmail.com>
+Discussion: https://postgr.es/m/CACG%3DezZe1NQSCnfHOr78AtAZxJZeCvxrts0ygrxYwe%3DpyyjVWA%40mail.gmail.com
+Discussion: https://postgr.es/m/CAJ7c6TPDOYBYrnCAeyndkBktO0WG2xSdYduTF0nxq%2BvfkmTF5Q%40mail.gmail.com
+---
+ src/backend/access/heap/README.XID64 | 134 +++++++++++++++++++++++++++
+ 1 file changed, 134 insertions(+)
+ create mode 100644 src/backend/access/heap/README.XID64
+
+diff --git a/src/backend/access/heap/README.XID64 b/src/backend/access/heap/README.XID64
+new file mode 100644
+index 0000000000..9b4e6e03a2
+--- /dev/null
++++ b/src/backend/access/heap/README.XID64
+@@ -0,0 +1,134 @@
++src/backend/access/heap/README.XID64
++
++64-bit Transaction ID's (XID)
++=============================
++
++A limited number (N = 2^32) of XID's required to do vacuum freeze to prevent
++wraparound every N/2 transactions. This causes performance degradation due
++to the need to read and rewrite all not yet frozen pages tables while being
++vacuumed. In each wraparound cycle, SLRU buffers are also being cut.
++
++With 64-bit XID's wraparound is effectively postponed to a very distant
++future. Even in highly loaded systems that had 2^32 transactions per day
++it will take huge 2^31 days before the first enforced "vacuum to prevent
++wraparound"). Buffers cutting and routine vacuum are not enforced, and DBA
++can plan them independently at the time with the least system load and least
++critical for database performance. Also, it can be done less frequently
++(several times a year vs every several days) on systems with transaction rates
++similar to those mentioned above.
++
++On-disk tuple and page format
++-----------------------------
++
++On-disk tuple format remains unchanged. 32-bit t_xmin and t_xmax store the
++lower parts of 64-bit XMIN and XMAX values. Each heap page has additional
++64-bit pd_xid_base and pd_multi_base which are common for all tuples on a page.
++They are placed into a pd_special area - 16 bytes in the end of a heap page.
++Actual XMIN/XMAX for a tuple are calculated upon reading a tuple from a page
++as follows:
++
++XMIN = t_xmin + pd_xid_base. (1)
++XMAX = t_xmax + pd_xid_base/pd_multi_base. (2)
++
++"Double XMAX" page format
++---------------------------------
++
++At first read of a heap page after pg_upgrade from 32-bit XID PostgreSQL
++version pd_special area with a size of 16 bytes should be added to a page.
++Though a page may not have space for this. Then it can be converted to a
++temporary format called "double XMAX".
++
++All tuples after pg-upgrade doesn't need t_xmin anymore as no older transactions
++could be running. So we don't need tuple header t_xmin field and we reuse
++t_xmin to store higher 32 bits of its XMAX.
++
++Double XMAX format is only for full pages that don't have 16 bytes for
++pd_special. So it neither has a place for a single tuple. Insert and HOT update
++for double XMAX pages is impossible and not supported. We can only read or
++delete tuples from it.
++
++When we are able to prune page double XMAX it will be converted from it to
++general 64-bit XID page format with all operations on its tuples supported.
++
++In-memory tuple format
++----------------------
++
++In-memory tuple representation consists of two parts:
++- HeapTupleHeader from disk page (contains all heap tuple contents, not only
++header)
++- HeapTuple with additional in-memory fields
++
++HeapTuple for each tuple in memory stores 64bit XMIN/XMAX. They are
++precalculated on tuple read from page with (1) and (2).
++
++The filling of XMIN and XMAX in HeapTuple is done in the same way as the other
++fields of HeapTuple struct. It is done in all cases of HeapTuple manipulation.
++
++Update/delete with 64-bit XIDs and 32-bit t_xmin/t_xmax
++--------------------------------------------------------------
++
++When we try to delete/update a tuple, we check that XMAX for a page fits (2).
++I.e. that t_xmax will not be over MaxShortTransactionId relative to
++pd_xid_base/pd_multi_base of a its page.
++
++If the current XID doesn't fit a range
++(pd_xid_base, pd_xid_base + MaxShortTransactionId) (3):
++
++- heap_page_prepare_for_xid() will try to increase pd_xid_base/pd_multi_base on
++a page and update all t_xmin/t_xmax of the other tuples on the page to
++correspond new pd_xid_base/pd_multi_base.
++
++- If it was impossible, it will try to prune and freeze tuples on a page.
++
++- If this is unsuccessful it will throw an error. Normally this is very
++unlikely but if there is a very old living transaction with an age of around
++2^32 this can arise. Basically, this is a behavior similar to one during the
++vacuum to prevent wraparound when XID was 32-bit. DBA should take care and
++avoid very-long-living transactions with an age close to 2^32. So long-living
++transactions often they are most likely defunct.
++
++Insert with 64-bit XIDs and 32-bit t_xmin/t_xmax
++------------------------------------------------
++
++On insert we check if current XID fits a range (3). Otherwise:
++
++- heap_page_prepare_for_xid() will try to increase pd_xid_base for t_xmin will
++not be over MaxShortTransactionId.
++
++- If it is impossible, then it will try to prune and freeze tuples on a page.
++
++Known issue: if pd_xid_base could not be shifted to accommodate a tuple being
++inserted due to a very long-running transaction, we just throw an error. We
++neither try to insert a tuple into another page nor mark the current page as
++full. So, in this (unlikely) case we will get regular insert errors on the next
++tries to insert to the page 'locked' by this very long-running transaction.
++
++Upgrade from 32-bit XID versions
++--------------------------------
++
++pg_upgrade doesn't change pages format itself. It is done lazily after.
++
++1. At first heap page read, tuples on a page are repacked to free 16 bytes
++at the end of a page, possibly freeing space from dead tuples.
++
++2A. 16 bytes of pd_special is added if there is a place for it
++
++2B. Page is converted to "Double XMAX" format if there is no place for
++pd_special
++
++3. If a page is in double XMAX format after its first read, and vacuum (or
++micro-vacuum at select query) could prune some tuples and free space for
++pd_special, prune_page will add pd_special and convert page from double XMAX
++to general 64-bit XID page format.
++
++This lazy conversion is called only on pages being read. This can slow down
++performance after upgrade, but just for a short period of time while "hot"
++pages are read (and therefore converted to 64-bit format).
++
++There is a special case when the first read of a tuple is done in read-only
++state (in read-only transaction or on replica). This tuples are to be converted
++"in memory", but not sync "to disk", unless cluster or transaction changed to
++read-write state (e.g. replica is promoted). In order to support this, we mark
++"in memory" pages with converted tuples with bit REGBUF_CONVERTED in buffer
++descriptor. When in read-write state this will trigger full page write xlog
++record.
+--
+2.45.2
+
diff --git a/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0006-Use-64-bit-XIDs.patch b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0006-Use-64-bit-XIDs.patch
new file mode 100644
index 00000000000..7dce937efe5
--- /dev/null
+++ b/baloo/patches/func/pg18xid64v56/0030-XID64-v56-0006-Use-64-bit-XIDs.patch
@@ -0,0 +1,17993 @@
+From ce3daeeb1b213b1a2efb5965fc9aa082608cd591 Mon Sep 17 00:00:00 2001
+From: Maxim Orlov <m.orlov@postgrespro.ru>
+Date: Fri, 11 Mar 2022 11:37:29 +0300
+Subject: [PATCH v52 5/7] Use 64-bit XIDs
+
+- change TransactionId to 64bit
+- disk tuple format (HeapTupleHeader) is (almost) unchanged: xmin and xmax remains 32bit
+ -- now 32bit xid is named ShortTransactionId
+- heap page format is changed to contain xid and multixact base value, tuple's
+ xmin and xmax are offsets from.
+ -- xid_base and multi_base are stored as a page special data. PageHeader remains unmodified.
+- in-memory tuple (HeapTuple) were enriched with precalulated 64bit xmin/xmax.
+
+Authors:
+- Alexander Korotkov <aekorotkov@gmail.com>
+- Teodor Sigaev <teodor@sigaev.ru>
+- Nikita Glukhov <n.gluhov@postgrespro.ru>
+- Maxim Orlov <orlovmg@gmail.com>
+- Pavel Borisov <pashkin.elfe@gmail.com>
+- Yura Sokolov <y.sokolov@postgrespro.ru> <funny.falcon@gmail.com>
+- Aleksander Alekseev <aleksander@timescale.com>
+Discussion: https://postgr.es/m/CACG%3DezZe1NQSCnfHOr78AtAZxJZeCvxrts0ygrxYwe%3DpyyjVWA%40mail.gmail.com
+Discussion: https://postgr.es/m/CAJ7c6TPDOYBYrnCAeyndkBktO0WG2xSdYduTF0nxq%2BvfkmTF5Q%40mail.gmail.com
+---
+ contrib/amcheck/verify_heapam.c | 119 +-
+ contrib/amcheck/verify_nbtree.c | 2 +-
+ contrib/hstore/hstore_io.c | 2 +
+ contrib/pageinspect/Makefile | 3 +-
+ contrib/pageinspect/btreefuncs.c | 18 +-
+ contrib/pageinspect/expected/btree.out | 4 +-
+ contrib/pageinspect/expected/hash_1.out | 166 +++
+ .../pageinspect/expected/oldextversions.out | 10 +-
+ contrib/pageinspect/expected/page.out | 28 +-
+ contrib/pageinspect/heapfuncs.c | 9 +-
+ .../pageinspect/pageinspect--1.12--1.13.sql | 145 ++
+ contrib/pageinspect/pageinspect--1.5.sql | 2 +
+ contrib/pageinspect/rawpage.c | 35 +-
+ contrib/pageinspect/sql/btree.sql | 3 +-
+ contrib/pg_surgery/heap_surgery.c | 17 +-
+ contrib/pg_visibility/pg_visibility.c | 7 +-
+ contrib/pgrowlocks/pgrowlocks.c | 2 +-
+ contrib/pgstattuple/pgstatapprox.c | 2 +
+ contrib/pgstattuple/pgstatindex.c | 2 +-
+ .../postgres_fdw/expected/postgres_fdw.out | 55 +-
+ contrib/postgres_fdw/postgres_fdw.c | 9 +-
+ contrib/postgres_fdw/sql/postgres_fdw.sql | 15 +-
+ src/backend/access/common/heaptuple.c | 10 +-
+ src/backend/access/common/reloptions.c | 12 +-
+ src/backend/access/hash/hashvalidate.c | 5 +-
+ src/backend/access/heap/heapam.c | 1228 +++++++++++++++--
+ src/backend/access/heap/heapam_handler.c | 62 +-
+ src/backend/access/heap/heapam_visibility.c | 173 +--
+ src/backend/access/heap/heaptoast.c | 3 +
+ src/backend/access/heap/hio.c | 36 +-
+ src/backend/access/heap/pruneheap.c | 92 +-
+ src/backend/access/heap/rewriteheap.c | 101 +-
+ src/backend/access/heap/vacuumlazy.c | 150 +-
+ src/backend/access/nbtree/nbtpage.c | 2 +
+ src/backend/access/nbtree/nbtsplitloc.c | 16 +-
+ src/backend/access/rmgrdesc/gistdesc.c | 4 +-
+ src/backend/access/rmgrdesc/heapdesc.c | 32 +
+ src/backend/access/rmgrdesc/nbtdesc.c | 4 +-
+ src/backend/access/rmgrdesc/xactdesc.c | 6 +-
+ src/backend/access/rmgrdesc/xlogdesc.c | 2 +-
+ src/backend/access/transam/clog.c | 19 +-
+ src/backend/access/transam/commit_ts.c | 19 -
+ src/backend/access/transam/multixact.c | 624 +--------
+ src/backend/access/transam/slru.c | 11 +-
+ src/backend/access/transam/subtrans.c | 9 +-
+ src/backend/access/transam/transam.c | 18 +-
+ src/backend/access/transam/twophase.c | 53 +-
+ src/backend/access/transam/varsup.c | 177 +--
+ src/backend/access/transam/xact.c | 35 +-
+ src/backend/access/transam/xlog.c | 9 +-
+ src/backend/access/transam/xloginsert.c | 7 +
+ src/backend/access/transam/xlogreader.c | 34 -
+ src/backend/bootstrap/bootstrap.c | 2 +-
+ src/backend/catalog/heap.c | 8 +-
+ src/backend/catalog/pg_inherits.c | 2 +-
+ src/backend/commands/async.c | 2 +-
+ src/backend/commands/dbcommands.c | 9 +-
+ src/backend/commands/indexcmds.c | 6 +-
+ src/backend/commands/sequence.c | 30 +-
+ src/backend/commands/vacuum.c | 22 +-
+ src/backend/executor/execExprInterp.c | 1 +
+ src/backend/executor/execUtils.c | 1 +
+ src/backend/executor/nodeModifyTable.c | 1 +
+ src/backend/executor/spi.c | 1 +
+ src/backend/nodes/gen_node_support.pl | 6 +-
+ src/backend/optimizer/util/plancat.c | 2 +-
+ src/backend/postmaster/autovacuum.c | 72 +-
+ src/backend/replication/logical/decode.c | 24 +-
+ src/backend/replication/logical/proto.c | 50 +-
+ .../replication/logical/reorderbuffer.c | 17 +-
+ src/backend/replication/logical/snapbuild.c | 4 +-
+ src/backend/replication/logical/worker.c | 2 +-
+ src/backend/replication/walreceiver.c | 28 +-
+ src/backend/replication/walsender.c | 73 +-
+ src/backend/statistics/extended_stats.c | 1 +
+ src/backend/storage/buffer/Makefile | 3 +-
+ src/backend/storage/buffer/bufmgr.c | 136 +-
+ src/backend/storage/buffer/heap_convert.c | 549 ++++++++
+ src/backend/storage/buffer/meson.build | 1 +
+ src/backend/storage/ipc/procarray.c | 182 +--
+ src/backend/storage/ipc/sinvaladt.c | 4 +-
+ src/backend/storage/ipc/standby.c | 4 +-
+ src/backend/storage/lmgr/lmgr.c | 14 +-
+ src/backend/storage/lmgr/lock.c | 4 +-
+ src/backend/storage/lmgr/predicate.c | 31 +-
+ src/backend/storage/lmgr/proc.c | 12 +-
+ src/backend/storage/page/bufpage.c | 254 +++-
+ src/backend/utils/adt/enum.c | 2 +-
+ src/backend/utils/adt/jsonfuncs.c | 2 +
+ src/backend/utils/adt/lockfuncs.c | 9 +-
+ src/backend/utils/adt/pgstatfuncs.c | 1 +
+ src/backend/utils/adt/rowtypes.c | 12 +
+ src/backend/utils/adt/xid.c | 37 +-
+ src/backend/utils/adt/xid8funcs.c | 83 +-
+ src/backend/utils/cache/catcache.c | 1 +
+ src/backend/utils/cache/relcache.c | 3 +-
+ src/backend/utils/fmgr/fmgr.c | 4 +-
+ src/backend/utils/misc/guc_tables.c | 164 +--
+ src/backend/utils/misc/help_config.c | 8 +-
+ src/backend/utils/misc/pg_controldata.c | 2 +-
+ src/backend/utils/misc/postgresql.conf.sample | 2 +-
+ src/backend/utils/sort/tuplesortvariants.c | 14 +-
+ src/backend/utils/time/combocid.c | 20 +-
+ src/backend/utils/time/snapmgr.c | 23 +-
+ src/bin/pg_amcheck/t/004_verify_heapam.pl | 185 ++-
+ src/bin/pg_controldata/pg_controldata.c | 2 +-
+ src/bin/pg_dump/pg_dump.c | 27 +-
+ src/bin/pg_dump/pg_dump.h | 8 +-
+ src/bin/pg_resetwal/pg_resetwal.c | 55 +-
+ src/bin/pg_resetwal/t/001_basic.pl | 18 +-
+ src/bin/pg_upgrade/Makefile | 1 +
+ src/bin/pg_upgrade/check.c | 149 +-
+ src/bin/pg_upgrade/controldata.c | 17 +-
+ src/bin/pg_upgrade/file.c | 99 +-
+ src/bin/pg_upgrade/meson.build | 1 +
+ src/bin/pg_upgrade/pg_upgrade.c | 144 +-
+ src/bin/pg_upgrade/pg_upgrade.h | 34 +-
+ src/bin/pg_upgrade/relfilenumber.c | 34 +-
+ src/bin/pg_upgrade/segresize.c | 586 ++++++++
+ src/bin/pg_upgrade/t/002_pg_upgrade.pl | 18 +
+ src/bin/pg_upgrade/version.c | 104 +-
+ src/bin/pg_waldump/pg_waldump.c | 2 +-
+ src/bin/pg_waldump/t/001_basic.pl | 3 +-
+ src/include/access/ginblock.h | 11 +-
+ src/include/access/gist.h | 2 +-
+ src/include/access/heapam.h | 24 +-
+ src/include/access/heapam_xlog.h | 31 +-
+ src/include/access/heaptoast.h | 11 +-
+ src/include/access/htup.h | 19 +-
+ src/include/access/htup_details.h | 279 +++-
+ src/include/access/multixact.h | 11 +-
+ src/include/access/nbtree.h | 10 +
+ src/include/access/reloptions.h | 2 +-
+ src/include/access/rewriteheap.h | 4 +-
+ src/include/access/rmgrlist.h | 1 +
+ src/include/access/slru.h | 10 +-
+ src/include/access/tableam.h | 2 +-
+ src/include/access/transam.h | 92 +-
+ src/include/access/tupmacs.h | 3 +-
+ src/include/access/xact.h | 13 +-
+ src/include/access/xloginsert.h | 1 +
+ src/include/access/xlogreader.h | 4 -
+ src/include/access/xlogrecord.h | 5 +-
+ src/include/c.h | 23 +-
+ src/include/catalog/catversion.h | 3 +-
+ src/include/catalog/pg_amproc.dat | 4 +-
+ src/include/catalog/pg_operator.dat | 8 +-
+ src/include/catalog/pg_proc.dat | 12 +-
+ src/include/catalog/pg_type.dat | 4 +-
+ src/include/catalog/pg_type.h | 5 +
+ src/include/commands/vacuum.h | 22 +-
+ src/include/fmgr.h | 2 +
+ src/include/nodes/pg_list.h | 4 +
+ src/include/pg_config.h.in | 3 +
+ src/include/port/pg_lfind.h | 163 ++-
+ src/include/postgres.h | 9 +-
+ src/include/postmaster/autovacuum.h | 4 +-
+ src/include/storage/buf_internals.h | 5 +-
+ src/include/storage/bufmgr.h | 6 +
+ src/include/storage/bufpage.h | 232 +++-
+ src/include/storage/itemid.h | 2 +
+ src/include/storage/lock.h | 14 +-
+ src/include/storage/proc.h | 7 +-
+ src/include/utils/combocid.h | 2 +-
+ src/include/utils/rel.h | 12 +-
+ src/include/utils/xid8.h | 4 +-
+ src/pl/plperl/plperl.c | 4 +-
+ src/pl/plpgsql/src/pl_comp.c | 4 +-
+ src/pl/plpgsql/src/pl_exec.c | 2 +
+ src/pl/plpython/plpy_procedure.c | 4 +-
+ src/pl/tcl/pltcl.c | 4 +-
+ src/test/Makefile | 3 +-
+ src/test/meson.build | 1 +
+ src/test/modules/test_lfind/test_lfind.c | 30 +-
+ .../perl/PostgreSQL/Test/AdjustUpgrade.pm | 4 +
+ src/test/recovery/t/003_recovery_targets.pl | 2 +-
+ src/test/recovery/t/039_end_of_wal.pl | 24 +-
+ src/test/regress/expected/indirect_toast.out | 8 +
+ src/test/regress/expected/insert.out | 16 +-
+ src/test/regress/expected/opr_sanity.out | 6 +-
+ src/test/regress/expected/select_views.out | 86 +-
+ src/test/regress/expected/txid.out | 8 +-
+ src/test/regress/expected/type_sanity.out | 5 +-
+ src/test/regress/expected/xid.out | 22 +-
+ src/test/regress/expected/xid64.out | 92 ++
+ src/test/regress/parallel_schedule | 2 +-
+ src/test/regress/regress.c | 292 ++++
+ src/test/regress/sql/indirect_toast.sql | 11 +
+ src/test/regress/sql/insert.sql | 17 +-
+ src/test/regress/sql/select_views.sql | 2 +-
+ src/test/regress/sql/type_sanity.sql | 5 +-
+ src/test/regress/sql/xid.sql | 2 +-
+ src/test/regress/sql/xid64.sql | 84 ++
+ src/test/xid-64/Makefile | 22 +
+ src/test/xid-64/README | 16 +
+ src/test/xid-64/meson.build | 16 +
+ src/test/xid-64/t/002_test_gucs.pl | 79 ++
+ src/test/xid-64/t/003_test_integrity.pl | 58 +
+ src/test/xid-64/t/004_test_relminmxid.pl | 90 ++
+ src/test/xid-64/t/005_stream_subxact.pl | 100 ++
+ src/test/xid-64/t/006_zeropage.pl | 33 +
+ src/test/xid-64/t/007_first_multi.pl | 83 ++
+ src/tools/pgindent/typedefs.list | 4 +-
+ 203 files changed, 6800 insertions(+), 2566 deletions(-)
+ create mode 100644 contrib/pageinspect/expected/hash_1.out
+ create mode 100644 contrib/pageinspect/pageinspect--1.12--1.13.sql
+ create mode 100644 src/backend/storage/buffer/heap_convert.c
+ create mode 100644 src/bin/pg_upgrade/segresize.c
+ create mode 100644 src/test/regress/expected/xid64.out
+ create mode 100644 src/test/regress/sql/xid64.sql
+ create mode 100644 src/test/xid-64/Makefile
+ create mode 100644 src/test/xid-64/README
+ create mode 100644 src/test/xid-64/meson.build
+ create mode 100644 src/test/xid-64/t/002_test_gucs.pl
+ create mode 100644 src/test/xid-64/t/003_test_integrity.pl
+ create mode 100644 src/test/xid-64/t/004_test_relminmxid.pl
+ create mode 100644 src/test/xid-64/t/005_stream_subxact.pl
+ create mode 100644 src/test/xid-64/t/006_zeropage.pl
+ create mode 100644 src/test/xid-64/t/007_first_multi.pl
+
+diff --git a/contrib/amcheck/verify_heapam.c b/contrib/amcheck/verify_heapam.c
+index 00a65b5448..d109ccd66b 100644
+--- a/contrib/amcheck/verify_heapam.c
++++ b/contrib/amcheck/verify_heapam.c
+@@ -17,6 +17,7 @@
+ #include "access/multixact.h"
+ #include "access/toast_internals.h"
+ #include "access/visibilitymap.h"
++#include "catalog/catalog.h"
+ #include "catalog/pg_am.h"
+ #include "funcapi.h"
+ #include "miscadmin.h"
+@@ -85,7 +86,7 @@ typedef struct HeapCheckContext
+ * from them.
+ */
+ FullTransactionId next_fxid; /* ShmemVariableCache->nextXid */
+- TransactionId next_xid; /* 32-bit version of next_fxid */
++ TransactionId next_xid; /* 64-bit version of next_fxid */
+ TransactionId oldest_xid; /* ShmemVariableCache->oldestXid */
+ FullTransactionId oldest_fxid; /* 64-bit version of oldest_xid, computed
+ * relative to next_fxid */
+@@ -126,6 +127,7 @@ typedef struct HeapCheckContext
+ uint16 lp_len;
+ uint16 lp_off;
+ HeapTupleHeader tuphdr;
++ HeapTupleData tuple;
+ int natts;
+
+ /* Values for iterating over attributes within the tuple */
+@@ -169,8 +171,6 @@ static bool check_tuple_visibility(HeapCheckContext *ctx,
+ static void report_corruption(HeapCheckContext *ctx, char *msg);
+ static void report_toast_corruption(HeapCheckContext *ctx,
+ ToastedAttribute *ta, char *msg);
+-static FullTransactionId FullTransactionIdFromXidAndCtx(TransactionId xid,
+- const HeapCheckContext *ctx);
+ static void update_cached_xid_range(HeapCheckContext *ctx);
+ static void update_cached_mxid_range(HeapCheckContext *ctx);
+ static XidBoundsViolation check_mxid_in_range(MultiXactId mxid,
+@@ -394,7 +394,7 @@ verify_heapam(PG_FUNCTION_ARGS)
+ update_cached_xid_range(&ctx);
+ update_cached_mxid_range(&ctx);
+ ctx.relfrozenxid = ctx.rel->rd_rel->relfrozenxid;
+- ctx.relfrozenfxid = FullTransactionIdFromXidAndCtx(ctx.relfrozenxid, &ctx);
++ ctx.relfrozenfxid = FullTransactionIdFromXid(ctx.relfrozenxid);
+ ctx.relminmxid = ctx.rel->rd_rel->relminmxid;
+
+ if (TransactionIdIsNormal(ctx.relfrozenxid))
+@@ -555,6 +555,12 @@ verify_heapam(PG_FUNCTION_ARGS)
+ ctx.tuphdr = (HeapTupleHeader) PageGetItem(ctx.page, ctx.itemid);
+ ctx.natts = HeapTupleHeaderGetNatts(ctx.tuphdr);
+
++ ctx.tuple.t_data = ctx.tuphdr;
++ ctx.tuple.t_len = ItemIdGetLength(ctx.itemid);
++ ctx.tuple.t_tableOid = RelationGetRelid(ctx.rel);
++ HeapTupleCopyXidsFromPage(ctx.buffer, &ctx.tuple, ctx.page,
++ IsToastRelation(ctx.rel));
++
+ /* Ok, ready to check this next tuple */
+ check_tuple(&ctx,
+ &xmin_commit_status_ok[ctx.offnum],
+@@ -588,6 +594,8 @@ verify_heapam(PG_FUNCTION_ARGS)
+ TransactionId curr_xmax;
+ TransactionId next_xmin;
+ OffsetNumber nextoffnum = successor[ctx.offnum];
++ HeapTupleData curr_tup;
++ HeapTupleData next_tup;
+
+ /*
+ * The current line pointer may not have a successor, either
+@@ -650,9 +658,13 @@ verify_heapam(PG_FUNCTION_ARGS)
+ if (ItemIdIsRedirected(next_lp))
+ continue;
+ curr_htup = (HeapTupleHeader) PageGetItem(ctx.page, curr_lp);
+- curr_xmax = HeapTupleHeaderGetUpdateXid(curr_htup);
++ curr_tup.t_data = curr_htup;
++ HeapTupleCopyXidsFromPage(ctx.buffer, &curr_tup, ctx.page, false);
++ curr_xmax = HeapTupleGetUpdateXidAny(&curr_tup);
+ next_htup = (HeapTupleHeader) PageGetItem(ctx.page, next_lp);
+- next_xmin = HeapTupleHeaderGetXmin(next_htup);
++ next_tup.t_data = next_htup;
++ HeapTupleCopyXidsFromPage(ctx.buffer, &next_tup, ctx.page, false);
++ next_xmin = HeapTupleGetXmin(&next_tup);
+ if (!TransactionIdIsValid(curr_xmax) ||
+ !TransactionIdEquals(curr_xmax, next_xmin))
+ continue;
+@@ -706,7 +718,7 @@ verify_heapam(PG_FUNCTION_ARGS)
+ * xmin. This should be safe because the xmin itself can't have
+ * changed, only its commit status.
+ */
+- curr_xmin = HeapTupleHeaderGetXmin(curr_htup);
++ curr_xmin = HeapTupleGetXmin(&curr_tup);
+ if (xmin_commit_status_ok[ctx.offnum] &&
+ xmin_commit_status[ctx.offnum] == XID_IN_PROGRESS &&
+ xmin_commit_status_ok[nextoffnum] &&
+@@ -904,7 +916,7 @@ check_tuple_header(HeapCheckContext *ctx)
+ {
+ HeapTupleHeader tuphdr = ctx->tuphdr;
+ uint16 infomask = tuphdr->t_infomask;
+- TransactionId curr_xmax = HeapTupleHeaderGetUpdateXid(tuphdr);
++ TransactionId curr_xmax = HeapTupleGetUpdateXidAny(&ctx->tuple);
+ bool result = true;
+ unsigned expected_hoff;
+
+@@ -1022,13 +1034,14 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ XidCommitStatus xmin_status;
+ XidCommitStatus xvac_status;
+ XidCommitStatus xmax_status;
++ HeapTuple tuple = &ctx->tuple;
+ HeapTupleHeader tuphdr = ctx->tuphdr;
+
+ ctx->tuple_could_be_pruned = true; /* have not yet proven otherwise */
+ *xmin_commit_status_ok = false; /* have not yet proven otherwise */
+
+ /* If xmin is normal, it should be within valid range */
+- xmin = HeapTupleHeaderGetXmin(tuphdr);
++ xmin = HeapTupleGetXmin(tuple);
+ switch (get_xid_status(xmin, ctx, &xmin_status))
+ {
+ case XID_INVALID:
+@@ -1042,19 +1055,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("xmin %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmin,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("xmin %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmin,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("xmin %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmin,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ }
+
+@@ -1080,19 +1093,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes relation freeze threshold %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes oldest valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1146,19 +1159,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes relation freeze threshold %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes oldest valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1235,7 +1248,7 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ * HEAP_XMAX_IS_LOCKED_ONLY is true, but for now we err on the side of
+ * avoiding possibly-bogus complaints about missing TOAST entries.
+ */
+- xmax = HeapTupleHeaderGetRawXmax(tuphdr);
++ xmax = HeapTupleGetRawXmax(tuple);
+ switch (check_mxid_valid_in_rel(xmax, ctx))
+ {
+ case XID_INVALID:
+@@ -1294,7 +1307,7 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ * We already checked above that this multixact is within limits for
+ * this table. Now check the update xid from this multixact.
+ */
+- xmax = HeapTupleGetUpdateXid(tuphdr);
++ xmax = HeapTupleGetUpdateXid(tuple);
+ switch (get_xid_status(xmax, ctx, &xmax_status))
+ {
+ case XID_INVALID:
+@@ -1306,19 +1319,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("update xid %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return true;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("update xid %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return true;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("update xid %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return true;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1358,7 +1371,7 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ }
+
+ /* xmax is an XID, not a MXID. Sanity check it. */
+- xmax = HeapTupleHeaderGetRawXmax(tuphdr);
++ xmax = HeapTupleGetRawXmax(tuple);
+ switch (get_xid_status(xmax, ctx, &xmax_status))
+ {
+ case XID_INVALID:
+@@ -1368,19 +1381,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("xmax %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("xmax %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("xmax %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false; /* corrupt */
+ case XID_BOUNDS_OK:
+ break;
+@@ -1859,50 +1872,6 @@ check_tuple(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ ctx->attnum = -1;
+ }
+
+-/*
+- * Convert a TransactionId into a FullTransactionId using our cached values of
+- * the valid transaction ID range. It is the caller's responsibility to have
+- * already updated the cached values, if necessary.
+- */
+-static FullTransactionId
+-FullTransactionIdFromXidAndCtx(TransactionId xid, const HeapCheckContext *ctx)
+-{
+- uint64 nextfxid_i;
+- int32 diff;
+- FullTransactionId fxid;
+-
+- Assert(TransactionIdIsNormal(ctx->next_xid));
+- Assert(FullTransactionIdIsNormal(ctx->next_fxid));
+- Assert(XidFromFullTransactionId(ctx->next_fxid) == ctx->next_xid);
+-
+- if (!TransactionIdIsNormal(xid))
+- return FullTransactionIdFromEpochAndXid(0, xid);
+-
+- nextfxid_i = U64FromFullTransactionId(ctx->next_fxid);
+-
+- /* compute the 32bit modulo difference */
+- diff = (int32) (ctx->next_xid - xid);
+-
+- /*
+- * In cases of corruption we might see a 32bit xid that is before epoch 0.
+- * We can't represent that as a 64bit xid, due to 64bit xids being
+- * unsigned integers, without the modulo arithmetic of 32bit xid. There's
+- * no really nice way to deal with that, but it works ok enough to use
+- * FirstNormalFullTransactionId in that case, as a freshly initdb'd
+- * cluster already has a newer horizon.
+- */
+- if (diff > 0 && (nextfxid_i - FirstNormalTransactionId) < (int64) diff)
+- {
+- Assert(EpochFromFullTransactionId(ctx->next_fxid) == 0);
+- fxid = FirstNormalFullTransactionId;
+- }
+- else
+- fxid = FullTransactionIdFromU64(nextfxid_i - diff);
+-
+- Assert(FullTransactionIdIsNormal(fxid));
+- return fxid;
+-}
+-
+ /*
+ * Update our cached range of valid transaction IDs.
+ */
+@@ -1916,8 +1885,8 @@ update_cached_xid_range(HeapCheckContext *ctx)
+ LWLockRelease(XidGenLock);
+
+ /* And compute alternate versions of the same */
++ ctx->oldest_fxid = FullTransactionIdFromXid(ctx->oldest_xid);
+ ctx->next_xid = XidFromFullTransactionId(ctx->next_fxid);
+- ctx->oldest_fxid = FullTransactionIdFromXidAndCtx(ctx->oldest_xid, ctx);
+ }
+
+ /*
+@@ -2016,7 +1985,7 @@ get_xid_status(TransactionId xid, HeapCheckContext *ctx,
+ }
+
+ /* Check if the xid is within bounds */
+- fxid = FullTransactionIdFromXidAndCtx(xid, ctx);
++ fxid = FullTransactionIdFromXid(xid);
+ if (!fxid_in_cached_range(fxid, ctx))
+ {
+ /*
+@@ -2025,7 +1994,6 @@ get_xid_status(TransactionId xid, HeapCheckContext *ctx,
+ * performed the full xid conversion, reconvert.
+ */
+ update_cached_xid_range(ctx);
+- fxid = FullTransactionIdFromXidAndCtx(xid, ctx);
+ }
+
+ if (FullTransactionIdPrecedesOrEquals(ctx->next_fxid, fxid))
+@@ -2049,8 +2017,7 @@ get_xid_status(TransactionId xid, HeapCheckContext *ctx,
+ *status = XID_COMMITTED;
+ LWLockAcquire(XactTruncationLock, LW_SHARED);
+ clog_horizon =
+- FullTransactionIdFromXidAndCtx(ShmemVariableCache->oldestClogXid,
+- ctx);
++ FullTransactionIdFromXid(ShmemVariableCache->oldestClogXid);
+ if (FullTransactionIdPrecedesOrEquals(clog_horizon, fxid))
+ {
+ if (TransactionIdIsCurrentTransactionId(xid))
+diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
+index bcff849aa9..860fc10cfb 100644
+--- a/contrib/amcheck/verify_nbtree.c
++++ b/contrib/amcheck/verify_nbtree.c
+@@ -571,7 +571,7 @@ bt_check_every_level(Relation rel, Relation heaprel, bool heapkeyspace,
+ * avoid this.
+ */
+ if (IsolationUsesXactSnapshot() && rel->rd_index->indcheckxmin &&
+- !TransactionIdPrecedes(HeapTupleHeaderGetXmin(rel->rd_indextuple->t_data),
++ !TransactionIdPrecedes(HeapTupleGetXmin(rel->rd_indextuple),
+ snapshot->xmin))
+ ereport(ERROR,
+ (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
+diff --git a/contrib/hstore/hstore_io.c b/contrib/hstore/hstore_io.c
+index 999ddad76d..f7e2fa847e 100644
+--- a/contrib/hstore/hstore_io.c
++++ b/contrib/hstore/hstore_io.c
+@@ -914,6 +914,7 @@ hstore_from_record(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = rec;
++ HeapTupleSetZeroXids(&tuple);
+
+ values = (Datum *) palloc(ncolumns * sizeof(Datum));
+ nulls = (bool *) palloc(ncolumns * sizeof(bool));
+@@ -1067,6 +1068,7 @@ hstore_populate_record(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = rec;
++ HeapTupleSetZeroXids(&tuple);
+ }
+
+ /*
+diff --git a/contrib/pageinspect/Makefile b/contrib/pageinspect/Makefile
+index 95e030b396..446721018e 100644
+--- a/contrib/pageinspect/Makefile
++++ b/contrib/pageinspect/Makefile
+@@ -13,7 +13,8 @@ OBJS = \
+ rawpage.o
+
+ EXTENSION = pageinspect
+-DATA = pageinspect--1.11--1.12.sql pageinspect--1.10--1.11.sql \
++DATA = pageinspect--1.12--1.13.sql \
++ pageinspect--1.11--1.12.sql pageinspect--1.10--1.11.sql \
+ pageinspect--1.9--1.10.sql pageinspect--1.8--1.9.sql \
+ pageinspect--1.7--1.8.sql pageinspect--1.6--1.7.sql \
+ pageinspect--1.5.sql pageinspect--1.5--1.6.sql \
+diff --git a/contrib/pageinspect/btreefuncs.c b/contrib/pageinspect/btreefuncs.c
+index afa1947fad..a810be4530 100644
+--- a/contrib/pageinspect/btreefuncs.c
++++ b/contrib/pageinspect/btreefuncs.c
+@@ -122,6 +122,9 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+
+ stat->page_size = PageGetPageSize(page);
+
++ stat->btpo_prev = opaque->btpo_prev;
++ stat->btpo_level = opaque->btpo_level;
++
+ /* page type (flags) */
+ if (P_ISDELETED(opaque))
+ {
+@@ -143,11 +146,18 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+ FullTransactionId safexid = BTPageGetDeleteXid(page);
+
+ elog(DEBUG2, "deleted page from block %u has safexid %llu",
+- blkno, (unsigned long long) U64FromFullTransactionId(safexid));
++ blkno, (unsigned long long) XidFromFullTransactionId(safexid));
+ }
+ else
+- elog(DEBUG2, "deleted page from block %u has safexid %llu",
+- blkno, (unsigned long long) opaque->btpo_level);
++ {
++ ShortTransactionId safexid = BTP_GET_XACT(opaque);
++
++ stat->btpo_prev = 0;
++ stat->btpo_level = 0;
++
++ elog(DEBUG2, "deleted page from block %u has safexid %u",
++ blkno, safexid);
++ }
+
+ /* Don't interpret BTDeletedPageData as index tuples */
+ maxoff = InvalidOffsetNumber;
+@@ -162,9 +172,7 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+ stat->type = 'i';
+
+ /* btpage opaque data */
+- stat->btpo_prev = opaque->btpo_prev;
+ stat->btpo_next = opaque->btpo_next;
+- stat->btpo_level = opaque->btpo_level;
+ stat->btpo_flags = opaque->btpo_flags;
+ stat->btpo_cycleid = opaque->btpo_cycleid;
+
+diff --git a/contrib/pageinspect/expected/btree.out b/contrib/pageinspect/expected/btree.out
+index 0aa5d73322..f5b05dbc06 100644
+--- a/contrib/pageinspect/expected/btree.out
++++ b/contrib/pageinspect/expected/btree.out
+@@ -207,8 +207,8 @@ SELECT bt_page_items('aaa'::bytea);
+ ERROR: invalid page size
+ -- invalid special area size
+ CREATE INDEX test1_a_brin ON test1 USING brin(a);
+-SELECT bt_page_items(get_raw_page('test1', 0));
+-ERROR: input page is not a valid btree page
++-- XXX: false positive in 64xids due to equal sizes of BTPageOpaque and HeapPageSpecialData
++-- SELECT bt_page_items(get_raw_page('test1', 0));
+ SELECT bt_page_items(get_raw_page('test1_a_brin', 0));
+ ERROR: input page is not a valid btree page
+ \set VERBOSITY default
+diff --git a/contrib/pageinspect/expected/hash_1.out b/contrib/pageinspect/expected/hash_1.out
+new file mode 100644
+index 0000000000..5e64eb9260
+--- /dev/null
++++ b/contrib/pageinspect/expected/hash_1.out
+@@ -0,0 +1,166 @@
++CREATE TABLE test_hash (a int, b text);
++INSERT INTO test_hash VALUES (1, 'one');
++CREATE INDEX test_hash_a_idx ON test_hash USING hash (a);
++\x
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 0));
++-[ RECORD 1 ]--+---------
++hash_page_type | metapage
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 1));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 2));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 3));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 4));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 5));
++-[ RECORD 1 ]--+-------
++hash_page_type | bitmap
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 6));
++ERROR: block number 6 is out of range for relation "test_hash_a_idx"
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', -1);
++ERROR: invalid block number
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 0);
++ERROR: invalid overflow block number 0
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 1);
++ERROR: invalid overflow block number 1
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 2);
++ERROR: invalid overflow block number 2
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 3);
++ERROR: invalid overflow block number 3
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 4);
++ERROR: invalid overflow block number 4
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 5);
++ERROR: invalid overflow block number 5
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 6);
++ERROR: block number 6 is out of range for relation "test_hash_a_idx"
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 0));
++-[ RECORD 1 ]--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
++magic | 105121344
++version | 4
++ntuples | 1
++bsize | 8156
++bmsize | 4096
++bmshift | 15
++maxbucket | 3
++highmask | 7
++lowmask | 3
++ovflpoint | 2
++firstfree | 0
++nmaps | 1
++procid | 450
++spares | {0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
++mapp | {5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
++
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 1));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 2));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 3));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 4));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 5));
++ERROR: page is not a hash meta page
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 0));
++ERROR: page is not a hash bucket or overflow page
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 1));
++-[ RECORD 1 ]---+-----------
++live_items | 0
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 0
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 2));
++-[ RECORD 1 ]---+-----------
++live_items | 0
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 1
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 3));
++-[ RECORD 1 ]---+-----------
++live_items | 1
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 2
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 4));
++-[ RECORD 1 ]---+-----------
++live_items | 0
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 3
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 5));
++ERROR: page is not a hash bucket or overflow page
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 0));
++ERROR: page is not a hash bucket or overflow page
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 1));
++(0 rows)
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 2));
++(0 rows)
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 3));
++-[ RECORD 1 ]----------
++itemoffset | 1
++ctid | (0,1)
++data | 2389907270
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 4));
++(0 rows)
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 5));
++ERROR: page is not a hash bucket or overflow page
++DROP TABLE test_hash;
+diff --git a/contrib/pageinspect/expected/oldextversions.out b/contrib/pageinspect/expected/oldextversions.out
+index f5c4b61bd7..00323d392d 100644
+--- a/contrib/pageinspect/expected/oldextversions.out
++++ b/contrib/pageinspect/expected/oldextversions.out
+@@ -40,16 +40,16 @@ SELECT * FROM bt_page_items('test1_a_idx', 1);
+ -- pagesize in pageinspect >= 1.10.
+ ALTER EXTENSION pageinspect UPDATE TO '1.9';
+ \df page_header
+- List of functions
+- Schema | Name | Result data type | Argument data types | Type
+---------+-------------+------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------
+- public | page_header | record | page bytea, OUT lsn pg_lsn, OUT checksum smallint, OUT flags smallint, OUT lower smallint, OUT upper smallint, OUT special smallint, OUT pagesize smallint, OUT version smallint, OUT prune_xid xid | func
++ List of functions
++ Schema | Name | Result data type | Argument data types | Type
++--------+-------------+------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------
++ public | page_header | record | page bytea, OUT lsn pg_lsn, OUT checksum smallint, OUT flags smallint, OUT lower smallint, OUT upper smallint, OUT special smallint, OUT pagesize smallint, OUT version smallint, OUT xid_base xid, OUT multi_base xid, OUT prune_xid xid | func
+ (1 row)
+
+ SELECT pagesize, version FROM page_header(get_raw_page('test1', 0));
+ pagesize | version
+ ----------+---------
+- 8192 | 4
++ 8192 | 5
+ (1 row)
+
+ DROP TABLE test1;
+diff --git a/contrib/pageinspect/expected/page.out b/contrib/pageinspect/expected/page.out
+index 80ddb45a60..631b6c7be4 100644
+--- a/contrib/pageinspect/expected/page.out
++++ b/contrib/pageinspect/expected/page.out
+@@ -49,7 +49,7 @@ SELECT get_raw_page('test1', 0) = get_raw_page('test1', 'main', 0);
+ SELECT pagesize, version FROM page_header(get_raw_page('test1', 0));
+ pagesize | version
+ ----------+---------
+- 8192 | 4
++ 8192 | 5
+ (1 row)
+
+ SELECT page_checksum(get_raw_page('test1', 0), 0) IS NOT NULL AS silly_checksum_test;
+@@ -70,19 +70,19 @@ SELECT tuple_data_split('test1'::regclass, t_data, t_infomask, t_infomask2, t_bi
+ SELECT * FROM fsm_page_contents(get_raw_page('test1', 'fsm', 0));
+ fsm_page_contents
+ -------------------
+- 0: 254 +
+- 1: 254 +
+- 3: 254 +
+- 7: 254 +
+- 15: 254 +
+- 31: 254 +
+- 63: 254 +
+- 127: 254 +
+- 255: 254 +
+- 511: 254 +
+- 1023: 254 +
+- 2047: 254 +
+- 4095: 254 +
++ 0: 253 +
++ 1: 253 +
++ 3: 253 +
++ 7: 253 +
++ 15: 253 +
++ 31: 253 +
++ 63: 253 +
++ 127: 253 +
++ 255: 253 +
++ 511: 253 +
++ 1023: 253 +
++ 2047: 253 +
++ 4095: 253 +
+ fp_next_slot: 0 +
+
+ (1 row)
+diff --git a/contrib/pageinspect/heapfuncs.c b/contrib/pageinspect/heapfuncs.c
+index 0f0252558c..5687f469a8 100644
+--- a/contrib/pageinspect/heapfuncs.c
++++ b/contrib/pageinspect/heapfuncs.c
+@@ -163,7 +163,7 @@ heap_page_items(PG_FUNCTION_ARGS)
+ inter_call_data->tupd = tupdesc;
+
+ inter_call_data->offset = FirstOffsetNumber;
+- inter_call_data->page = VARDATA(raw_page);
++ inter_call_data->page = get_page_from_raw(raw_page);
+
+ fctx->max_calls = PageGetMaxOffsetNumber(inter_call_data->page);
+ fctx->user_fctx = inter_call_data;
+@@ -211,6 +211,7 @@ heap_page_items(PG_FUNCTION_ARGS)
+ lp_offset == MAXALIGN(lp_offset) &&
+ lp_offset + lp_len <= raw_page_size)
+ {
++ HeapTupleData tup;
+ HeapTupleHeader tuphdr;
+ bytea *tuple_data_bytea;
+ int tuple_data_len;
+@@ -218,9 +219,11 @@ heap_page_items(PG_FUNCTION_ARGS)
+ /* Extract information from the tuple header */
+
+ tuphdr = (HeapTupleHeader) PageGetItem(page, id);
++ tup.t_data = tuphdr;
++ HeapTupleCopyXidsFromPage(InvalidBuffer, &tup, page, false);
+
+- values[4] = UInt32GetDatum(HeapTupleHeaderGetRawXmin(tuphdr));
+- values[5] = UInt32GetDatum(HeapTupleHeaderGetRawXmax(tuphdr));
++ values[4] = TransactionIdGetDatum(HeapTupleGetXmin(&tup));
++ values[5] = TransactionIdGetDatum(HeapTupleGetRawXmax(&tup));
+ /* shared with xvac */
+ values[6] = UInt32GetDatum(HeapTupleHeaderGetRawCommandId(tuphdr));
+ values[7] = PointerGetDatum(&tuphdr->t_ctid);
+diff --git a/contrib/pageinspect/pageinspect--1.12--1.13.sql b/contrib/pageinspect/pageinspect--1.12--1.13.sql
+new file mode 100644
+index 0000000000..a2e0232a10
+--- /dev/null
++++ b/contrib/pageinspect/pageinspect--1.12--1.13.sql
+@@ -0,0 +1,145 @@
++/* contrib/pageinspect/pageinspect--1.12--1.13.sql */
++
++-- complain if script is sourced in psql, rather than via ALTER EXTENSION
++\echo Use "ALTER EXTENSION pageinspect UPDATE TO '1.13'" to load this file. \quit
++
++--
++-- gist_page_opaque_info()
++--
++DROP FUNCTION gist_page_opaque_info(bytea);
++CREATE FUNCTION gist_page_opaque_info(IN page bytea,
++ OUT lsn pg_lsn,
++ OUT nsn pg_lsn,
++ OUT rightlink bigint,
++ OUT flags text[])
++AS 'MODULE_PATHNAME', 'gist_page_opaque_info'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++
++--
++-- gist_page_items_bytea()
++--
++DROP FUNCTION gist_page_items_bytea(bytea);
++CREATE FUNCTION gist_page_items_bytea(IN page bytea,
++ OUT itemoffset smallint,
++ OUT ctid tid,
++ OUT itemlen smallint,
++ OUT dead boolean,
++ OUT key_data bytea)
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'gist_page_items_bytea'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- gist_page_items()
++--
++DROP FUNCTION gist_page_items(bytea, regclass);
++CREATE FUNCTION gist_page_items(IN page bytea,
++ IN index_oid regclass,
++ OUT itemoffset smallint,
++ OUT ctid tid,
++ OUT itemlen smallint,
++ OUT dead boolean,
++ OUT keys text)
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'gist_page_items'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- get_raw_page()
++--
++DROP FUNCTION get_raw_page(text, int8);
++DROP FUNCTION IF EXISTS get_raw_page(text, int4);
++CREATE FUNCTION get_raw_page(text, int8)
++RETURNS bytea
++AS 'MODULE_PATHNAME', 'get_raw_page_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++DROP FUNCTION get_raw_page(text, text, int8);
++DROP FUNCTION IF EXISTS get_raw_page(text, text, int4);
++CREATE FUNCTION get_raw_page(text, text, int8)
++RETURNS bytea
++AS 'MODULE_PATHNAME', 'get_raw_page_fork_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- page_checksum()
++--
++DROP FUNCTION page_checksum(IN page bytea, IN blkno int8);
++DROP FUNCTION IF EXISTS page_checksum(IN page bytea, IN blkno int4);
++CREATE FUNCTION page_checksum(IN page bytea, IN blkno int8)
++RETURNS smallint
++AS 'MODULE_PATHNAME', 'page_checksum_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- bt_metap()
++--
++DROP FUNCTION bt_metap(text);
++CREATE FUNCTION bt_metap(IN relname text,
++ OUT magic int4,
++ OUT version int4,
++ OUT root int8,
++ OUT level int8,
++ OUT fastroot int8,
++ OUT fastlevel int8,
++ OUT last_cleanup_num_delpages int8,
++ OUT last_cleanup_num_tuples float8,
++ OUT allequalimage boolean)
++AS 'MODULE_PATHNAME', 'bt_metap'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- bt_page_stats()
++--
++DROP FUNCTION bt_page_stats(text, int8);
++DROP FUNCTION IF EXISTS bt_page_stats(text, int4);
++CREATE FUNCTION bt_page_stats(IN relname text, IN blkno int8,
++ OUT blkno int8,
++ OUT type "char",
++ OUT live_items int4,
++ OUT dead_items int4,
++ OUT avg_item_size int4,
++ OUT page_size int4,
++ OUT free_size int4,
++ OUT btpo_prev int8,
++ OUT btpo_next int8,
++ OUT btpo_level int8,
++ OUT btpo_flags int4)
++AS 'MODULE_PATHNAME', 'bt_page_stats_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- bt_page_items()
++--
++DROP FUNCTION bt_page_items(text, int8);
++DROP FUNCTION IF EXISTS bt_page_items(text, int4);
++CREATE FUNCTION bt_page_items(IN relname text, IN blkno int8,
++ OUT itemoffset smallint,
++ OUT ctid tid,
++ OUT itemlen smallint,
++ OUT nulls bool,
++ OUT vars bool,
++ OUT data text,
++ OUT dead boolean,
++ OUT htid tid,
++ OUT tids tid[])
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'bt_page_items_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- brin_page_items()
++--
++DROP FUNCTION brin_page_items(IN page bytea, IN index_oid regclass);
++CREATE FUNCTION brin_page_items(IN page bytea, IN index_oid regclass,
++ OUT itemoffset int,
++ OUT blknum int8,
++ OUT attnum int,
++ OUT allnulls bool,
++ OUT hasnulls bool,
++ OUT placeholder bool,
++ OUT value text)
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'brin_page_items'
++LANGUAGE C STRICT PARALLEL SAFE;
+diff --git a/contrib/pageinspect/pageinspect--1.5.sql b/contrib/pageinspect/pageinspect--1.5.sql
+index 1e40c3c97e..fdbd2995a2 100644
+--- a/contrib/pageinspect/pageinspect--1.5.sql
++++ b/contrib/pageinspect/pageinspect--1.5.sql
+@@ -28,6 +28,8 @@ CREATE FUNCTION page_header(IN page bytea,
+ OUT special smallint,
+ OUT pagesize smallint,
+ OUT version smallint,
++ OUT xid_base xid,
++ OUT multi_base xid,
+ OUT prune_xid xid)
+ AS 'MODULE_PATHNAME', 'page_header'
+ LANGUAGE C STRICT PARALLEL SAFE;
+diff --git a/contrib/pageinspect/rawpage.c b/contrib/pageinspect/rawpage.c
+index b25a63cbd6..5e6b8c6cfa 100644
+--- a/contrib/pageinspect/rawpage.c
++++ b/contrib/pageinspect/rawpage.c
+@@ -17,6 +17,7 @@
+
+ #include "access/htup_details.h"
+ #include "access/relation.h"
++#include "commands/sequence.h"
+ #include "catalog/namespace.h"
+ #include "catalog/pg_type.h"
+ #include "funcapi.h"
+@@ -251,8 +252,9 @@ page_header(PG_FUNCTION_ARGS)
+
+ Datum result;
+ HeapTuple tuple;
+- Datum values[9];
+- bool nulls[9];
++ Datum values[11];
++ bool nulls[11];
++ bool is_toast;
+
+ Page page;
+ PageHeader pageheader;
+@@ -314,12 +316,37 @@ page_header(PG_FUNCTION_ARGS)
+ }
+
+ values[7] = UInt16GetDatum(PageGetPageLayoutVersion(page));
+- values[8] = TransactionIdGetDatum(pageheader->pd_prune_xid);
++ is_toast = PageGetSpecialSize(page) ==
++ MAXALIGN(sizeof(ToastPageSpecialData));
++ values[8] = TransactionIdGetDatum(HeapPageGetPruneXidNoAssert((Page) page,
++ is_toast));
+
+ /* Build and return the tuple. */
+-
+ memset(nulls, 0, sizeof(nulls));
+
++ if (PageGetSpecialSize(page) == MAXALIGN(sizeof(HeapPageSpecialData)))
++ {
++ /* Heap page */
++ HeapPageSpecial pageSpecial = HeapPageGetSpecial((Page) page);
++
++ values[9] = TransactionIdGetDatum(pageSpecial->pd_xid_base);
++ values[10] = TransactionIdGetDatum(pageSpecial->pd_multi_base);
++ }
++ else if (PageGetSpecialSize(page) == MAXALIGN(sizeof(ToastPageSpecialData)))
++ {
++ /* TOAST page */
++ ToastPageSpecial pageSpecial = ToastPageGetSpecial((Page) page);
++
++ values[9] = TransactionIdGetDatum(pageSpecial->pd_xid_base);
++ nulls[10] = true;
++ }
++ else
++ {
++ /* Double xmax page */
++ nulls[9] = true;
++ nulls[10] = true;
++ }
++
+ tuple = heap_form_tuple(tupdesc, values, nulls);
+ result = HeapTupleGetDatum(tuple);
+
+diff --git a/contrib/pageinspect/sql/btree.sql b/contrib/pageinspect/sql/btree.sql
+index 102ebdefe3..87f202fb9f 100644
+--- a/contrib/pageinspect/sql/btree.sql
++++ b/contrib/pageinspect/sql/btree.sql
+@@ -51,7 +51,8 @@ SELECT bt_page_items(get_raw_page('test1_b_gist', 0));
+ SELECT bt_page_items('aaa'::bytea);
+ -- invalid special area size
+ CREATE INDEX test1_a_brin ON test1 USING brin(a);
+-SELECT bt_page_items(get_raw_page('test1', 0));
++-- XXX: false positive in 64xids due to equal sizes of BTPageOpaque and HeapPageSpecialData
++-- SELECT bt_page_items(get_raw_page('test1', 0));
+ SELECT bt_page_items(get_raw_page('test1_a_brin', 0));
+ \set VERBOSITY default
+
+diff --git a/contrib/pg_surgery/heap_surgery.c b/contrib/pg_surgery/heap_surgery.c
+index 4308d1933b..bb57e5dd9c 100644
+--- a/contrib/pg_surgery/heap_surgery.c
++++ b/contrib/pg_surgery/heap_surgery.c
+@@ -15,6 +15,7 @@
+ #include "access/heapam.h"
+ #include "access/visibilitymap.h"
+ #include "access/xloginsert.h"
++#include "catalog/catalog.h"
+ #include "catalog/pg_am_d.h"
+ #include "catalog/pg_proc_d.h"
+ #include "miscadmin.h"
+@@ -272,11 +273,20 @@ heap_force_common(FunctionCallInfo fcinfo, HeapTupleForceOption heap_force_opt)
+ else
+ {
+ HeapTupleHeader htup;
++ HeapTupleData tuple;
++ bool is_toast;
+
+ Assert(heap_force_opt == HEAP_FORCE_FREEZE);
+
++ is_toast = IsToastRelation(rel);
++
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
+
++ tuple.t_data = htup;
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, is_toast);
++
+ /*
+ * Reset all visibility-related fields of the tuple. This
+ * logic should mimic heap_execute_freeze_tuple(), but we
+@@ -284,8 +294,11 @@ heap_force_common(FunctionCallInfo fcinfo, HeapTupleForceOption heap_force_opt)
+ * potentially-garbled data is left behind.
+ */
+ ItemPointerSet(&htup->t_ctid, blkno, curoff);
+- HeapTupleHeaderSetXmin(htup, FrozenTransactionId);
+- HeapTupleHeaderSetXmax(htup, InvalidTransactionId);
++ HeapTupleAndHeaderSetXmin(page, &tuple, FrozenTransactionId,
++ is_toast);
++ HeapTupleAndHeaderSetXmax(page, &tuple, InvalidTransactionId,
++ is_toast);
++
+ if (htup->t_infomask & HEAP_MOVED)
+ {
+ if (htup->t_infomask & HEAP_MOVED_OFF)
+diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
+index 2a4acfd1ee..f6d574a5c1 100644
+--- a/contrib/pg_visibility/pg_visibility.c
++++ b/contrib/pg_visibility/pg_visibility.c
+@@ -14,6 +14,7 @@
+ #include "access/htup_details.h"
+ #include "access/visibilitymap.h"
+ #include "access/xloginsert.h"
++#include "catalog/catalog.h"
+ #include "catalog/pg_type.h"
+ #include "catalog/storage_xlog.h"
+ #include "funcapi.h"
+@@ -650,6 +651,8 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = relid;
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page,
++ IsToastRelation(rel));
+
+ /*
+ * If we're checking whether the page is all-visible, we expect
+@@ -693,7 +696,7 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
+ */
+ if (check_frozen)
+ {
+- if (heap_tuple_needs_eventual_freeze(tuple.t_data))
++ if (heap_tuple_needs_eventual_freeze(&tuple))
+ record_corrupt_item(items, &tuple.t_self);
+ }
+ }
+@@ -756,7 +759,7 @@ tuple_all_visible(HeapTuple tup, TransactionId OldestXmin, Buffer buffer)
+ * be set here. So just check the xmin.
+ */
+
+- xmin = HeapTupleHeaderGetXmin(tup->t_data);
++ xmin = HeapTupleGetXmin(tup);
+ if (!TransactionIdPrecedes(xmin, OldestXmin))
+ return false; /* xmin not old enough for all to see */
+
+diff --git a/contrib/pgrowlocks/pgrowlocks.c b/contrib/pgrowlocks/pgrowlocks.c
+index dea76d8dcb..5616ea64f5 100644
+--- a/contrib/pgrowlocks/pgrowlocks.c
++++ b/contrib/pgrowlocks/pgrowlocks.c
+@@ -130,7 +130,7 @@ pgrowlocks(PG_FUNCTION_ARGS)
+ htsu = HeapTupleSatisfiesUpdate(tuple,
+ GetCurrentCommandId(false),
+ hscan->rs_cbuf);
+- xmax = HeapTupleHeaderGetRawXmax(tuple->t_data);
++ xmax = HeapTupleGetRawXmax(tuple);
+ infomask = tuple->t_data->t_infomask;
+
+ /*
+diff --git a/contrib/pgstattuple/pgstatapprox.c b/contrib/pgstattuple/pgstatapprox.c
+index f601dc6121..40a45727c1 100644
+--- a/contrib/pgstattuple/pgstatapprox.c
++++ b/contrib/pgstattuple/pgstatapprox.c
+@@ -19,6 +19,7 @@
+ #include "access/transam.h"
+ #include "access/visibilitymap.h"
+ #include "access/xact.h"
++#include "catalog/catalog.h"
+ #include "catalog/namespace.h"
+ #include "catalog/pg_am_d.h"
+ #include "commands/vacuum.h"
+@@ -153,6 +154,7 @@ statapprox_heap(Relation rel, output_type *stat)
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, IsToastRelation(rel));
+
+ /*
+ * We follow VACUUM's lead in counting INSERT_IN_PROGRESS tuples
+diff --git a/contrib/pgstattuple/pgstatindex.c b/contrib/pgstattuple/pgstatindex.c
+index 8e5a4d6a66..55ef89d8e2 100644
+--- a/contrib/pgstattuple/pgstatindex.c
++++ b/contrib/pgstattuple/pgstatindex.c
+@@ -631,7 +631,7 @@ pgstathashindex(PG_FUNCTION_ARGS)
+ metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
+ metap = HashPageGetMeta(BufferGetPage(metabuf));
+ stats.version = metap->hashm_version;
+- stats.space_per_page = metap->hashm_bsize;
++ stats.space_per_page = BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(HashPageOpaqueData));
+ _hash_relbuf(rel, metabuf);
+
+ /* Get the current relation length */
+diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
+index c988745b92..152f3295c8 100644
+--- a/contrib/postgres_fdw/expected/postgres_fdw.out
++++ b/contrib/postgres_fdw/expected/postgres_fdw.out
+@@ -4915,16 +4915,24 @@ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *; -- can be pushed down
+- QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------------------
+- Update on public.ft2
+- Output: c1, c2, c3, c4, c5, c6, c7, c8
+- -> Foreign Update on public.ft2
+- Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7') WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+-(4 rows)
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1; -- can be pushed down
++ QUERY PLAN
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------
++ Sort
++ Output: t.c1, t.c2, t.c3, t.c4, t.c5, t.c6, t.c7, t.c8
++ Sort Key: t.c1
++ CTE t
++ -> Update on public.ft2
++ Output: ft2.c1, ft2.c2, ft2.c3, ft2.c4, ft2.c5, ft2.c6, ft2.c7, ft2.c8
++ -> Foreign Update on public.ft2
++ Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7') WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
++ -> CTE Scan on t
++ Output: t.c1, t.c2, t.c3, t.c4, t.c5, t.c6, t.c7, t.c8
++(10 rows)
+
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+ c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8
+ ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
+ 7 | 407 | 00007_update7 | Thu Jan 08 00:00:00 1970 PST | Thu Jan 08 00:00:00 1970 | 7 | 7 | foo
+@@ -5044,16 +5052,24 @@ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
+ EXPLAIN (verbose, costs off)
+- DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4; -- can be pushed down
+- QUERY PLAN
+---------------------------------------------------------------------------------------------
+- Delete on public.ft2
+- Output: c1, c4
+- -> Foreign Delete on public.ft2
+- Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
+-(4 rows)
++ WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++ SELECT * FROM t ORDER BY c1; -- can be pushed down
++ QUERY PLAN
++----------------------------------------------------------------------------------------------------
++ Sort
++ Output: t.c1, t.c4
++ Sort Key: t.c1
++ CTE t
++ -> Delete on public.ft2
++ Output: ft2.c1, ft2.c4
++ -> Foreign Delete on public.ft2
++ Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
++ -> CTE Scan on t
++ Output: t.c1, t.c4
++(10 rows)
+
+-DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
++WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++SELECT * FROM t ORDER BY c1;
+ c1 | c4
+ ------+------------------------------
+ 5 | Tue Jan 06 00:00:00 1970 PST
+@@ -6314,7 +6330,8 @@ INSERT INTO ft2 (c1,c2,c3,c6) VALUES (1218, 818, 'ggg', '(--;') RETURNING *;
+ 1218 | 818 | ggg_trig_update | | | (--; | ft2 |
+ (1 row)
+
+-UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+ c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8
+ ------+-----+------------------------+------------------------------+--------------------------+----+------------+-----
+ 8 | 608 | 00008_trig_update | Fri Jan 09 00:00:00 1970 PST | Fri Jan 09 00:00:00 1970 | 8 | 8 | foo
+diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
+index e9144beb62..0ffb8b61be 100644
+--- a/contrib/postgres_fdw/postgres_fdw.c
++++ b/contrib/postgres_fdw/postgres_fdw.c
+@@ -4818,8 +4818,8 @@ apply_returning_filter(PgFdwDirectModifyState *dmstate,
+ * Note: no need to care about tableoid here because it will be
+ * initialized in ExecProcessReturning().
+ */
+- HeapTupleHeaderSetXmin(resultTup->t_data, InvalidTransactionId);
+- HeapTupleHeaderSetXmax(resultTup->t_data, InvalidTransactionId);
++ HeapTupleSetXmin(resultTup, InvalidTransactionId);
++ HeapTupleSetXmax(resultTup, InvalidTransactionId);
+ HeapTupleHeaderSetCmin(resultTup->t_data, InvalidTransactionId);
+ }
+
+@@ -7640,6 +7640,7 @@ make_tuple_from_result_row(PGresult *res,
+ */
+ if (ctid)
+ tuple->t_self = tuple->t_data->t_ctid = *ctid;
++ HeapTupleSetZeroXids(tuple);
+
+ /*
+ * Stomp on the xmin, xmax, and cmin fields from the tuple created by
+@@ -7649,8 +7650,8 @@ make_tuple_from_result_row(PGresult *res,
+ * assumption. If we don't do this then, for example, the tuple length
+ * ends up in the xmin field, which isn't what we want.
+ */
+- HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId);
+- HeapTupleHeaderSetXmin(tuple->t_data, InvalidTransactionId);
++ HeapTupleSetXmax(tuple, InvalidTransactionId);
++ HeapTupleSetXmin(tuple, InvalidTransactionId);
+ HeapTupleHeaderSetCmin(tuple->t_data, InvalidTransactionId);
+
+ /* Clean up */
+diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql
+index cb40540702..4b1c43637c 100644
+--- a/contrib/postgres_fdw/sql/postgres_fdw.sql
++++ b/contrib/postgres_fdw/sql/postgres_fdw.sql
+@@ -1442,16 +1442,20 @@ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3; -- can be pushed down
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *; -- can be pushed down
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1; -- can be pushed down
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9; -- can be pushed down
+ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
+ EXPLAIN (verbose, costs off)
+- DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4; -- can be pushed down
+-DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
++ WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++ SELECT * FROM t ORDER BY c1; -- can be pushed down
++WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++SELECT * FROM t ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2; -- can be pushed down
+ DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
+@@ -1558,7 +1562,8 @@ CREATE TRIGGER t1_br_insert BEFORE INSERT OR UPDATE
+
+ INSERT INTO ft2 (c1,c2,c3) VALUES (1208, 818, 'fff') RETURNING *;
+ INSERT INTO ft2 (c1,c2,c3,c6) VALUES (1218, 818, 'ggg', '(--;') RETURNING *;
+-UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+
+ -- Test errors thrown on remote side during update
+ ALTER TABLE "S 1"."T 1" ADD CONSTRAINT c2positive CHECK (c2 >= 0);
+diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
+index c52d40dce0..7413304ddd 100644
+--- a/src/backend/access/common/heaptuple.c
++++ b/src/backend/access/common/heaptuple.c
+@@ -737,10 +737,10 @@ heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
+ result = PointerGetDatum(&(tup->t_self));
+ break;
+ case MinTransactionIdAttributeNumber:
+- result = TransactionIdGetDatum(HeapTupleHeaderGetRawXmin(tup->t_data));
++ result = TransactionIdGetDatum(HeapTupleGetRawXmin(tup));
+ break;
+ case MaxTransactionIdAttributeNumber:
+- result = TransactionIdGetDatum(HeapTupleHeaderGetRawXmax(tup->t_data));
++ result = TransactionIdGetDatum(HeapTupleGetRawXmax(tup));
+ break;
+ case MinCommandIdAttributeNumber:
+ case MaxCommandIdAttributeNumber:
+@@ -785,6 +785,7 @@ heap_copytuple(HeapTuple tuple)
+ newTuple->t_len = tuple->t_len;
+ newTuple->t_self = tuple->t_self;
+ newTuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(newTuple, tuple);
+ newTuple->t_data = (HeapTupleHeader) ((char *) newTuple + HEAPTUPLESIZE);
+ memcpy((char *) newTuple->t_data, (char *) tuple->t_data, tuple->t_len);
+ return newTuple;
+@@ -811,6 +812,7 @@ heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest)
+ dest->t_len = src->t_len;
+ dest->t_self = src->t_self;
+ dest->t_tableOid = src->t_tableOid;
++ HeapTupleCopyXids(dest, src);
+ dest->t_data = (HeapTupleHeader) palloc(src->t_len);
+ memcpy((char *) dest->t_data, (char *) src->t_data, src->t_len);
+ }
+@@ -1174,6 +1176,7 @@ heap_form_tuple(TupleDesc tupleDescriptor,
+ tuple->t_len = len;
+ ItemPointerSetInvalid(&(tuple->t_self));
+ tuple->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tuple);
+
+ HeapTupleHeaderSetDatumLength(td, len);
+ HeapTupleHeaderSetTypeId(td, tupleDescriptor->tdtypeid);
+@@ -1258,6 +1261,7 @@ heap_modify_tuple(HeapTuple tuple,
+ newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
+ newTuple->t_self = tuple->t_self;
+ newTuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(newTuple, tuple);
+
+ return newTuple;
+ }
+@@ -1321,6 +1325,7 @@ heap_modify_tuple_by_cols(HeapTuple tuple,
+ newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
+ newTuple->t_self = tuple->t_self;
+ newTuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(newTuple, tuple);
+
+ return newTuple;
+ }
+@@ -1561,6 +1566,7 @@ heap_tuple_from_minimal_tuple(MinimalTuple mtup)
+ result->t_len = len;
+ ItemPointerSetInvalid(&(result->t_self));
+ result->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(result);
+ result->t_data = (HeapTupleHeader) ((char *) result + HEAPTUPLESIZE);
+ memcpy((char *) result->t_data + MINIMAL_TUPLE_OFFSET, mtup, mtup->t_len);
+ memset(result->t_data, 0, offsetof(HeapTupleHeaderData, t_infomask2));
+diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c
+index c852b1fb74..0498115c92 100644
+--- a/src/backend/access/common/reloptions.c
++++ b/src/backend/access/common/reloptions.c
+@@ -1922,17 +1922,17 @@ default_reloptions(Datum reloptions, bool validate, relopt_kind kind)
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)},
+ {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)},
+- {"autovacuum_freeze_min_age", RELOPT_TYPE_INT,
++ {"autovacuum_freeze_min_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)},
+- {"autovacuum_freeze_max_age", RELOPT_TYPE_INT,
++ {"autovacuum_freeze_max_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)},
+- {"autovacuum_freeze_table_age", RELOPT_TYPE_INT,
++ {"autovacuum_freeze_table_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)},
+- {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT,
++ {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)},
+- {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT,
++ {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)},
+- {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT,
++ {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT64,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)},
+ {"log_autovacuum_min_duration", RELOPT_TYPE_INT,
+ offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)},
+diff --git a/src/backend/access/hash/hashvalidate.c b/src/backend/access/hash/hashvalidate.c
+index 24bab58499..3fd0c4609d 100644
+--- a/src/backend/access/hash/hashvalidate.c
++++ b/src/backend/access/hash/hashvalidate.c
+@@ -317,11 +317,10 @@ check_hash_func_signature(Oid funcid, int16 amprocnum, Oid argtype)
+ * INTERNAL and allowing any such function seems too scary.
+ */
+ if ((funcid == F_HASHINT4 || funcid == F_HASHINT4EXTENDED) &&
+- (argtype == DATEOID ||
+- argtype == XIDOID || argtype == CIDOID))
++ (argtype == DATEOID || argtype == CIDOID))
+ /* okay, allowed use of hashint4() */ ;
+ else if ((funcid == F_HASHINT8 || funcid == F_HASHINT8EXTENDED) &&
+- (argtype == XID8OID))
++ (argtype == XID8OID || argtype == XIDOID))
+ /* okay, allowed use of hashint8() */ ;
+ else if ((funcid == F_TIMESTAMP_HASH ||
+ funcid == F_TIMESTAMP_HASH_EXTENDED) &&
+diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
+index b6ee64d856..a33cbc207b 100644
+--- a/src/backend/access/heap/heapam.c
++++ b/src/backend/access/heap/heapam.c
+@@ -52,11 +52,14 @@
+ #include "access/xloginsert.h"
+ #include "access/xlogutils.h"
+ #include "catalog/catalog.h"
++#include "catalog/index.h"
++#include "catalog/namespace.h"
+ #include "commands/vacuum.h"
+ #include "miscadmin.h"
+ #include "pgstat.h"
+ #include "port/atomics.h"
+ #include "port/pg_bitutils.h"
++#include "storage/buf_internals.h"
+ #include "storage/bufmgr.h"
+ #include "storage/freespace.h"
+ #include "storage/lmgr.h"
+@@ -74,7 +77,7 @@
+
+
+ static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup,
+- TransactionId xid, CommandId cid, int options);
++ CommandId cid, int options);
+ static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf,
+ Buffer newbuf, HeapTuple oldtup,
+ HeapTuple newtup, HeapTuple old_key_tuple,
+@@ -114,6 +117,8 @@ static int bottomup_sort_and_shrink(TM_IndexDeleteOp *delstate);
+ static XLogRecPtr log_heap_new_cid(Relation relation, HeapTuple tup);
+ static HeapTuple ExtractReplicaIdentity(Relation relation, HeapTuple tp, bool key_required,
+ bool *copy);
++static bool heap_page_prepare_for_xid(Relation relation, Buffer buffer,
++ TransactionId xid, bool multi);
+
+
+ /*
+@@ -462,6 +467,8 @@ heapgetpage(TableScanDesc sscan, BlockNumber block)
+ loctup.t_tableOid = RelationGetRelid(scan->rs_base.rs_rd);
+ loctup.t_data = (HeapTupleHeader) PageGetItem(page, lpp);
+ loctup.t_len = ItemIdGetLength(lpp);
++ HeapTupleCopyXidsFromPage(buffer, &loctup, page,
++ IsToastRelation(scan->rs_base.rs_rd));
+ ItemPointerSet(&(loctup.t_self), block, lineoff);
+
+ if (all_visible)
+@@ -473,7 +480,16 @@ heapgetpage(TableScanDesc sscan, BlockNumber block)
+ &loctup, buffer, snapshot);
+
+ if (valid)
+- scan->rs_vistuples[ntup++] = lineoff;
++ {
++ scan->rs_vistuples[ntup] = lineoff;
++ /*
++ * Since there is no lock futher and xmin or xmax may be
++ * changed while base shift, copy them here.
++ */
++ scan->rs_xmin[ntup] = loctup.t_xmin;
++ scan->rs_xmax[ntup] = loctup.t_xmax;
++ ++ntup;
++ }
+ }
+
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+@@ -777,6 +793,8 @@ continue_page:
+
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
+ tuple->t_len = ItemIdGetLength(lpp);
++ HeapTupleCopyXidsFromPage(scan->rs_cbuf, tuple, page,
++ IsToastRelation(scan->rs_base.rs_rd));
+ ItemPointerSet(&(tuple->t_self), block, lineoff);
+
+ visible = HeapTupleSatisfiesVisibility(tuple,
+@@ -867,6 +885,9 @@ heapgettup_pagemode(HeapScanDesc scan,
+ linesleft = scan->rs_cindex;
+ /* lineindex now references the next or previous visible tid */
+
++ tuple->t_xmin = scan->rs_xmin[scan->rs_cindex];
++ tuple->t_xmax = scan->rs_xmax[scan->rs_cindex];
++
+ goto continue_page;
+ }
+
+@@ -895,6 +916,8 @@ continue_page:
+
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
+ tuple->t_len = ItemIdGetLength(lpp);
++ tuple->t_xmin = scan->rs_xmin[lineindex];
++ tuple->t_xmax = scan->rs_xmax[lineindex];
+ ItemPointerSet(&(tuple->t_self), block, lineoff);
+
+ /* skip any tuples that don't match the scan key */
+@@ -1403,6 +1426,7 @@ heap_fetch(Relation relation,
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tuple->t_len = ItemIdGetLength(lp);
+ tuple->t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, tuple, page, IsToastRelation(relation));
+
+ /*
+ * check tuple visibility, then release lock
+@@ -1411,7 +1435,7 @@ heap_fetch(Relation relation,
+
+ if (valid)
+ PredicateLockTID(relation, &(tuple->t_self), snapshot,
+- HeapTupleHeaderGetXmin(tuple->t_data));
++ HeapTupleGetXmin(tuple));
+
+ HeapCheckForSerializableConflictOut(valid, relation, tuple, buffer, snapshot);
+
+@@ -1488,6 +1512,8 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ Assert(TransactionIdIsValid(RecentXmin));
+ Assert(BufferGetBlockNumber(buffer) == blkno);
+
++ heapTuple->t_self = *tid;
++
+ /* Scan through possible multiple members of HOT-chain */
+ for (;;)
+ {
+@@ -1523,6 +1549,8 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ heapTuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ heapTuple->t_len = ItemIdGetLength(lp);
+ heapTuple->t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, heapTuple, page,
++ IsToastRelation(relation));
+ ItemPointerSet(&heapTuple->t_self, blkno, offnum);
+
+ /*
+@@ -1537,7 +1565,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ */
+ if (TransactionIdIsValid(prev_xmax) &&
+ !TransactionIdEquals(prev_xmax,
+- HeapTupleHeaderGetXmin(heapTuple->t_data)))
++ HeapTupleGetXmin(heapTuple)))
+ break;
+
+ /*
+@@ -1558,7 +1586,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ {
+ ItemPointerSetOffsetNumber(tid, offnum);
+ PredicateLockTID(relation, &heapTuple->t_self, snapshot,
+- HeapTupleHeaderGetXmin(heapTuple->t_data));
++ HeapTupleGetXmin(heapTuple));
+ if (all_dead)
+ *all_dead = false;
+ return true;
+@@ -1593,7 +1621,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ blkno);
+ offnum = ItemPointerGetOffsetNumber(&heapTuple->t_data->t_ctid);
+ at_chain_start = false;
+- prev_xmax = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
++ prev_xmax = HeapTupleGetUpdateXidAny(heapTuple);
+ }
+ else
+ break; /* end of chain */
+@@ -1679,13 +1707,14 @@ heap_get_latest_tid(TableScanDesc sscan,
+ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tp.t_len = ItemIdGetLength(lp);
+ tp.t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
+
+ /*
+ * After following a t_ctid link, we might arrive at an unrelated
+ * tuple. Check for XMIN match.
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(tp.t_data)))
++ !TransactionIdEquals(priorXmax, HeapTupleGetXmin(&tp)))
+ {
+ UnlockReleaseBuffer(buffer);
+ break;
+@@ -1704,7 +1733,7 @@ heap_get_latest_tid(TableScanDesc sscan,
+ * If there's a valid t_ctid link, follow it, else we're done.
+ */
+ if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
+- HeapTupleHeaderIsOnlyLocked(tp.t_data) ||
++ HeapTupleIsOnlyLocked(&tp) ||
+ HeapTupleHeaderIndicatesMovedPartitions(tp.t_data) ||
+ ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid))
+ {
+@@ -1713,7 +1742,7 @@ heap_get_latest_tid(TableScanDesc sscan,
+ }
+
+ ctid = tp.t_data->t_ctid;
+- priorXmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
++ priorXmax = HeapTupleGetUpdateXidAny(&tp);
+ UnlockReleaseBuffer(buffer);
+ } /* end of loop */
+ }
+@@ -1738,7 +1767,7 @@ heap_get_latest_tid(TableScanDesc sscan,
+ static void
+ UpdateXmaxHintBits(HeapTupleHeader tuple, Buffer buffer, TransactionId xid)
+ {
+- Assert(TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple), xid));
++ Assert(TransactionIdEquals(HeapTupleHeaderGetRawXmax(BufferGetPage(buffer), tuple), xid));
+ Assert(!(tuple->t_infomask & HEAP_XMAX_IS_MULTI));
+
+ if (!(tuple->t_infomask & (HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID)))
+@@ -1805,6 +1834,31 @@ ReleaseBulkInsertStatePin(BulkInsertState bistate)
+ bistate->last_free = InvalidBlockNumber;
+ }
+
++/*
++ * Add xid_base and multi base to the WAL record.
++ *
++ * WAL record must being constructed.
++ */
++static inline void
++xlog_register_base(Page page, bool is_toast, TransactionId *xid_base,
++ TransactionId *multi_base)
++{
++ if (is_toast)
++ {
++ *xid_base = ToastPageGetSpecial(page)->pd_xid_base;
++ *multi_base = InvalidTransactionId;
++ }
++ else
++ {
++ HeapPageSpecial special = HeapPageGetSpecial(page);
++
++ *xid_base = special->pd_xid_base;
++ *multi_base = special->pd_multi_base;
++ }
++
++ XLogRegisterData((char *) xid_base, sizeof(*xid_base));
++ XLogRegisterData((char *) multi_base, sizeof(*multi_base));
++}
+
+ /*
+ * heap_insert - insert tuple into a heap
+@@ -1844,7 +1898,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ * Note: below this point, heaptup is the data we actually intend to store
+ * into the relation; tup is the caller's original untoasted data.
+ */
+- heaptup = heap_prepare_insert(relation, tup, xid, cid, options);
++ heaptup = heap_prepare_insert(relation, tup, cid, options);
+
+ /*
+ * Find buffer to insert this tuple into. If the page is all visible,
+@@ -1872,6 +1926,9 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ */
+ CheckForSerializableConflictIn(relation, NULL, InvalidBlockNumber);
+
++ heap_page_prepare_for_xid(relation, buffer, xid, false);
++ HeapTupleSetXmin(heaptup, xid);
++
+ /* NO EREPORT(ERROR) from here till changes are logged */
+ START_CRIT_SECTION();
+
+@@ -1909,6 +1966,8 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ Page page = BufferGetPage(buffer);
+ uint8 info = XLOG_HEAP_INSERT;
+ int bufflags = 0;
++ TransactionId xid_base,
++ multi_base;
+
+ /*
+ * If this is a catalog, we need to transmit combo CIDs to properly
+@@ -1947,12 +2006,17 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ {
+ xlrec.flags |= XLH_INSERT_CONTAINS_NEW_TUPLE;
+ bufflags |= REGBUF_KEEP_DATA;
+-
+- if (IsToastRelation(relation))
+- xlrec.flags |= XLH_INSERT_ON_TOAST_RELATION;
+ }
+
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_INSERT_ON_TOAST_RELATION;
++
+ XLogBeginInsert();
++
++ if (info & XLOG_HEAP_INIT_PAGE)
++ xlog_register_base(page, IsToastRelation(relation), &xid_base,
++ &multi_base);
++
+ XLogRegisterData((char *) &xlrec, SizeOfHeapInsert);
+
+ xlhdr.t_infomask2 = heaptup->t_data->t_infomask2;
+@@ -2014,7 +2078,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ * that in any case, the header fields are also set in the original tuple.
+ */
+ static HeapTuple
+-heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
++heap_prepare_insert(Relation relation, HeapTuple tup,
+ CommandId cid, int options)
+ {
+ /*
+@@ -2031,12 +2095,12 @@ heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
+ tup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
+ tup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);
+ tup->t_data->t_infomask |= HEAP_XMAX_INVALID;
+- HeapTupleHeaderSetXmin(tup->t_data, xid);
++ HeapTupleSetXmin(tup, InvalidTransactionId);
+ if (options & HEAP_INSERT_FROZEN)
+- HeapTupleHeaderSetXminFrozen(tup->t_data);
++ HeapTupleHeaderStoreXminFrozen(tup->t_data);
+
+ HeapTupleHeaderSetCmin(tup->t_data, cid);
+- HeapTupleHeaderSetXmax(tup->t_data, 0); /* for cleanliness */
++ HeapTupleSetXmax(tup, 0); /* for cleanliness */
+ tup->t_tableOid = RelationGetRelid(relation);
+
+ /*
+@@ -2128,8 +2192,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ tuple = ExecFetchSlotHeapTuple(slots[i], true, NULL);
+ slots[i]->tts_tableOid = RelationGetRelid(relation);
+ tuple->t_tableOid = slots[i]->tts_tableOid;
+- heaptuples[i] = heap_prepare_insert(relation, tuple, xid, cid,
+- options);
++ heaptuples[i] = heap_prepare_insert(relation, tuple, cid, options);
+ }
+
+ /*
+@@ -2204,6 +2267,8 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ if (starting_with_empty_page && (options & HEAP_INSERT_FROZEN))
+ all_frozen_set = true;
+
++ heap_page_prepare_for_xid(relation, buffer, xid, false);
++
+ /* NO EREPORT(ERROR) from here till changes are logged */
+ START_CRIT_SECTION();
+
+@@ -2211,6 +2276,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ * RelationGetBufferForTuple has ensured that the first tuple fits.
+ * Put that on the page, and then as many other tuples as fit.
+ */
++ HeapTupleSetXmin(heaptuples[ndone], xid);
+ RelationPutHeapTuple(relation, buffer, heaptuples[ndone], false);
+
+ /*
+@@ -2227,6 +2293,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ if (PageGetHeapFreeSpace(page) < MAXALIGN(heaptup->t_len) + saveFreeSpace)
+ break;
+
++ HeapTupleSetXmin(heaptup, xid);
+ RelationPutHeapTuple(relation, buffer, heaptup, false);
+
+ /*
+@@ -2272,6 +2339,8 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ char *scratchptr = scratch.data;
+ bool init;
+ int bufflags = 0;
++ TransactionId xid_base,
++ multi_base;
+
+ /*
+ * If the page was previously empty, we can reinit the page
+@@ -2362,6 +2431,11 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ bufflags |= REGBUF_KEEP_DATA;
+
+ XLogBeginInsert();
++
++ if (info & XLOG_HEAP_INIT_PAGE)
++ xlog_register_base(page, IsToastRelation(relation), &xid_base,
++ &multi_base);
++
+ XLogRegisterData((char *) xlrec, tupledata - scratch.data);
+ XLogRegisterBuffer(0, buffer, REGBUF_STANDARD | bufflags);
+
+@@ -2569,6 +2643,7 @@ heap_delete(Relation relation, ItemPointer tid,
+ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tp.t_len = ItemIdGetLength(lp);
+ tp.t_self = *tid;
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
+
+ l1:
+
+@@ -2600,7 +2675,7 @@ l1:
+ uint16 infomask;
+
+ /* must copy state data before unlocking buffer */
+- xwait = HeapTupleHeaderGetRawXmax(tp.t_data);
++ xwait = HeapTupleGetRawXmax(&tp);
+ infomask = tp.t_data->t_infomask;
+
+ /*
+@@ -2639,6 +2714,10 @@ l1:
+ NULL);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+
++ /* Copy possibly updated xid base after relocking */
++ HeapTupleCopyXidsFromPage(buffer, &tp, page,
++ IsToastRelation(relation));
++
+ /*
+ * If xwait had just locked the tuple then some other xact
+ * could update this tuple before we get to this point. Check
+@@ -2649,7 +2728,7 @@ l1:
+ */
+ if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
+ xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tp.t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(&tp),
+ xwait))
+ goto l1;
+ }
+@@ -2676,6 +2755,10 @@ l1:
+ XactLockTableWait(xwait, relation, &(tp.t_self), XLTW_Delete);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+
++ /* Copy possibly updated xid base after relocking */
++ HeapTupleCopyXidsFromPage(buffer, &tp, page,
++ IsToastRelation(relation));
++
+ /*
+ * xwait is done, but if xwait had just locked the tuple then some
+ * other xact could update this tuple before we get to this point.
+@@ -2686,7 +2769,7 @@ l1:
+ */
+ if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
+ xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tp.t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(&tp),
+ xwait))
+ goto l1;
+
+@@ -2700,7 +2783,7 @@ l1:
+ */
+ if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
+ HEAP_XMAX_IS_LOCKED_ONLY(tp.t_data->t_infomask) ||
+- HeapTupleHeaderIsOnlyLocked(tp.t_data))
++ HeapTupleIsOnlyLocked(&tp))
+ result = TM_Ok;
+ else if (!ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid))
+ result = TM_Updated;
+@@ -2730,9 +2813,9 @@ l1:
+ if (result != TM_Ok)
+ {
+ tmfd->ctid = tp.t_data->t_ctid;
+- tmfd->xmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
++ tmfd->xmax = HeapTupleGetUpdateXidAny(&tp);
+ if (result == TM_SelfModified)
+- tmfd->cmax = HeapTupleHeaderGetCmax(tp.t_data);
++ tmfd->cmax = HeapTupleGetCmax(&tp);
+ else
+ tmfd->cmax = InvalidCommandId;
+ UnlockReleaseBuffer(buffer);
+@@ -2755,7 +2838,7 @@ l1:
+ CheckForSerializableConflictIn(relation, tid, BufferGetBlockNumber(buffer));
+
+ /* replace cid with a combo CID if necessary */
+- HeapTupleHeaderAdjustCmax(tp.t_data, &cid, &iscombo);
++ HeapTupleAdjustCmax(&tp, &cid, &iscombo);
+
+ /*
+ * Compute replica identity tuple before entering the critical section so
+@@ -2773,11 +2856,20 @@ l1:
+ */
+ MultiXactIdSetOldestMember();
+
+- compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(tp.t_data),
++ compute_new_xmax_infomask(HeapTupleGetRawXmax(&tp),
+ tp.t_data->t_infomask, tp.t_data->t_infomask2,
+ xid, LockTupleExclusive, true,
+ &new_xmax, &new_infomask, &new_infomask2);
+
++#ifdef USE_ASSERT_CHECKING
++ if (IsToastRelation(relation))
++ Assert((new_infomask & HEAP_XMAX_IS_MULTI) == 0);
++#endif
++
++ heap_page_prepare_for_xid(relation, buffer, new_xmax,
++ (new_infomask & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
++
+ START_CRIT_SECTION();
+
+ /*
+@@ -2787,7 +2879,7 @@ l1:
+ * the subsequent page pruning will be a no-op and the hint will be
+ * cleared.
+ */
+- PageSetPrunable(page, xid);
++ PageSetPrunable(page, xid, IsToastRelation(relation));
+
+ if (PageIsAllVisible(page))
+ {
+@@ -2803,7 +2895,7 @@ l1:
+ tp.t_data->t_infomask |= new_infomask;
+ tp.t_data->t_infomask2 |= new_infomask2;
+ HeapTupleHeaderClearHotUpdated(tp.t_data);
+- HeapTupleHeaderSetXmax(tp.t_data, new_xmax);
++ HeapTupleAndHeaderSetXmax(page, &tp, new_xmax, IsToastRelation(relation));
+ HeapTupleHeaderSetCmax(tp.t_data, cid, iscombo);
+ /* Make sure there is no forward chain link in t_ctid */
+ tp.t_data->t_ctid = tp.t_self;
+@@ -2842,6 +2934,8 @@ l1:
+ tp.t_data->t_infomask2);
+ xlrec.offnum = ItemPointerGetOffsetNumber(&tp.t_self);
+ xlrec.xmax = new_xmax;
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_DELETE_PAGE_ON_TOAST_RELATION;
+
+ if (old_key_tuple != NULL)
+ {
+@@ -2999,7 +3093,8 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
+ HeapTuple heaptup;
+ HeapTuple old_key_tuple = NULL;
+ bool old_key_copied = false;
+- Page page;
++ Page page,
++ newpage;
+ BlockNumber block;
+ MultiXactStatus mxact_status;
+ Buffer buffer,
+@@ -3026,6 +3121,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
+ infomask_new_tuple,
+ infomask2_new_tuple;
+
++ Assert(!IsToastRelation(relation));
+ Assert(ItemPointerIsValid(otid));
+
+ /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
+@@ -3097,6 +3193,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
+ oldtup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ oldtup.t_len = ItemIdGetLength(lp);
+ oldtup.t_self = *otid;
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+
+ /* the new tuple is ready, except for this: */
+ newtup->t_tableOid = RelationGetRelid(relation);
+@@ -3190,7 +3287,7 @@ l2:
+ */
+
+ /* must copy state data before unlocking buffer */
+- xwait = HeapTupleHeaderGetRawXmax(oldtup.t_data);
++ xwait = HeapTupleGetRawXmax(&oldtup);
+ infomask = oldtup.t_data->t_infomask;
+
+ /*
+@@ -3241,6 +3338,7 @@ l2:
+ checked_lockers = true;
+ locker_remains = remain != 0;
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+
+ /*
+ * If xwait had just locked the tuple then some other xact
+@@ -3249,7 +3347,7 @@ l2:
+ */
+ if (xmax_infomask_changed(oldtup.t_data->t_infomask,
+ infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(oldtup.t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(&oldtup),
+ xwait))
+ goto l2;
+ }
+@@ -3275,7 +3373,7 @@ l2:
+ * subxact aborts.
+ */
+ if (!HEAP_XMAX_IS_LOCKED_ONLY(oldtup.t_data->t_infomask))
+- update_xact = HeapTupleGetUpdateXid(oldtup.t_data);
++ update_xact = HeapTupleGetUpdateXid(&oldtup);
+ else
+ update_xact = InvalidTransactionId;
+
+@@ -3322,7 +3420,7 @@ l2:
+ XLTW_Update);
+ checked_lockers = true;
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+-
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+ /*
+ * xwait is done, but if xwait had just locked the tuple then some
+ * other xact could update this tuple before we get to this point.
+@@ -3330,7 +3428,7 @@ l2:
+ */
+ if (xmax_infomask_changed(oldtup.t_data->t_infomask, infomask) ||
+ !TransactionIdEquals(xwait,
+- HeapTupleHeaderGetRawXmax(oldtup.t_data)))
++ HeapTupleGetRawXmax(&oldtup)))
+ goto l2;
+
+ /* Otherwise check if it committed or aborted */
+@@ -3369,9 +3467,9 @@ l2:
+ if (result != TM_Ok)
+ {
+ tmfd->ctid = oldtup.t_data->t_ctid;
+- tmfd->xmax = HeapTupleHeaderGetUpdateXid(oldtup.t_data);
++ tmfd->xmax = HeapTupleGetUpdateXidAny(&oldtup);
+ if (result == TM_SelfModified)
+- tmfd->cmax = HeapTupleHeaderGetCmax(oldtup.t_data);
++ tmfd->cmax = HeapTupleGetCmax(&oldtup);
+ else
+ tmfd->cmax = InvalidCommandId;
+ UnlockReleaseBuffer(buffer);
+@@ -3404,6 +3502,7 @@ l2:
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ visibilitymap_pin(relation, block, &vmbuffer);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+ goto l2;
+ }
+
+@@ -3413,7 +3512,7 @@ l2:
+ * If the tuple we're updating is locked, we need to preserve the locking
+ * info in the old tuple's Xmax. Prepare a new Xmax value for this.
+ */
+- compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
++ compute_new_xmax_infomask(HeapTupleGetRawXmax(&oldtup),
+ oldtup.t_data->t_infomask,
+ oldtup.t_data->t_infomask2,
+ xid, *lockmode, true,
+@@ -3432,7 +3531,7 @@ l2:
+ (checked_lockers && !locker_remains))
+ xmax_new_tuple = InvalidTransactionId;
+ else
+- xmax_new_tuple = HeapTupleHeaderGetRawXmax(oldtup.t_data);
++ xmax_new_tuple = HeapTupleGetRawXmax(&oldtup);
+
+ if (!TransactionIdIsValid(xmax_new_tuple))
+ {
+@@ -3465,17 +3564,15 @@ l2:
+ */
+ newtup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
+ newtup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);
+- HeapTupleHeaderSetXmin(newtup->t_data, xid);
+ HeapTupleHeaderSetCmin(newtup->t_data, cid);
+ newtup->t_data->t_infomask |= HEAP_UPDATED | infomask_new_tuple;
+ newtup->t_data->t_infomask2 |= infomask2_new_tuple;
+- HeapTupleHeaderSetXmax(newtup->t_data, xmax_new_tuple);
+
+ /*
+ * Replace cid with a combo CID if necessary. Note that we already put
+ * the plain cid into the new tuple.
+ */
+- HeapTupleHeaderAdjustCmax(oldtup.t_data, &cid, &iscombo);
++ HeapTupleAdjustCmax(&oldtup, &cid, &iscombo);
+
+ /*
+ * If the toaster needs to be activated, OR if the new tuple will not fit
+@@ -3505,7 +3602,7 @@ l2:
+
+ newtupsize = MAXALIGN(newtup->t_len);
+
+- if (need_toast || newtupsize > pagefree)
++ if (need_toast || newtupsize > pagefree || HeapPageIsDoubleXmax(page))
+ {
+ TransactionId xmax_lock_old_tuple;
+ uint16 infomask_lock_old_tuple,
+@@ -3530,7 +3627,7 @@ l2:
+ * updating, because the potentially created multixact would otherwise
+ * be wrong.
+ */
+- compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
++ compute_new_xmax_infomask(HeapTupleGetRawXmax(&oldtup),
+ oldtup.t_data->t_infomask,
+ oldtup.t_data->t_infomask2,
+ xid, *lockmode, false,
+@@ -3539,6 +3636,10 @@ l2:
+
+ Assert(HEAP_XMAX_IS_LOCKED_ONLY(infomask_lock_old_tuple));
+
++ heap_page_prepare_for_xid(relation, buffer, xmax_lock_old_tuple,
++ (infomask_lock_old_tuple & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
++
+ START_CRIT_SECTION();
+
+ /* Clear obsolete visibility flags ... */
+@@ -3547,9 +3648,9 @@ l2:
+ HeapTupleClearHotUpdated(&oldtup);
+ /* ... and store info about transaction updating this tuple */
+ Assert(TransactionIdIsValid(xmax_lock_old_tuple));
+- HeapTupleHeaderSetXmax(oldtup.t_data, xmax_lock_old_tuple);
+ oldtup.t_data->t_infomask |= infomask_lock_old_tuple;
+ oldtup.t_data->t_infomask2 |= infomask2_lock_old_tuple;
++ HeapTupleAndHeaderSetXmax(page, &oldtup, xmax_lock_old_tuple, false);
+ HeapTupleHeaderSetCmax(oldtup.t_data, cid, iscombo);
+
+ /* temporarily make it look not-updated, but locked */
+@@ -3632,7 +3733,11 @@ l2:
+ */
+ for (;;)
+ {
+- if (newtupsize > pagefree)
++ /*
++ * We can't fit new tuple to "double xmax" page, since it's
++ * impossible to set xmin there.
++ */
++ if (newtupsize > pagefree || HeapPageIsDoubleXmax(page))
+ {
+ /* It doesn't fit, must use RelationGetBufferForTuple. */
+ newbuf = RelationGetBufferForTuple(relation, heaptup->t_len,
+@@ -3666,6 +3771,9 @@ l2:
+ break;
+ }
+ }
++
++ /* Copy possibly updated xid base to old tuple after relocking */
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+ }
+ else
+ {
+@@ -3737,6 +3845,33 @@ l2:
+ id_has_external,
+ &old_key_copied);
+
++ newpage = BufferGetPage(newbuf);
++
++ /*
++ * Prepare pages for the current xid, that witten to the new tuple's Xmax
++ * and old page's pd_prune_xid.
++ */
++ heap_page_prepare_for_xid(relation, buffer, xid, false);
++ if (newbuf != buffer)
++ heap_page_prepare_for_xid(relation, newbuf, xid, false);
++
++ /* Prepare pages for tuple's Xmax */
++ heap_page_prepare_for_xid(relation, buffer, xmax_old_tuple,
++ (infomask_old_tuple & HEAP_XMAX_IS_MULTI) != 0);
++ heap_page_prepare_for_xid(relation, newbuf, xmax_new_tuple,
++ (heaptup->t_data->t_infomask & HEAP_XMAX_IS_MULTI) != 0);
++
++ /* Copy possibly updated Xid bases to the both tuples. */
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
++
++ /*
++ * Set new tuple's Xmin/Xmax, old tuple's Xmin/Xmax were already shifted.
++ */
++ HeapTupleAndHeaderSetXmin(newpage, heaptup, xid,
++ IsToastRelation(relation));
++ HeapTupleAndHeaderSetXmax(newpage, heaptup, xmax_new_tuple,
++ IsToastRelation(relation));
++
+ /* NO EREPORT(ERROR) from here till changes are logged */
+ START_CRIT_SECTION();
+
+@@ -3752,7 +3887,7 @@ l2:
+ * not to optimize for aborts. Note that heap_xlog_update must be kept in
+ * sync if this decision changes.
+ */
+- PageSetPrunable(page, xid);
++ PageSetPrunable(page, xid, false);
+
+ if (use_hot_update)
+ {
+@@ -3779,10 +3914,11 @@ l2:
+ oldtup.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+ /* ... and store info about transaction updating this tuple */
+ Assert(TransactionIdIsValid(xmax_old_tuple));
+- HeapTupleHeaderSetXmax(oldtup.t_data, xmax_old_tuple);
+ oldtup.t_data->t_infomask |= infomask_old_tuple;
+ oldtup.t_data->t_infomask2 |= infomask2_old_tuple;
++ HeapTupleAndHeaderSetXmax(page, &oldtup, xmax_old_tuple, false);
+ HeapTupleHeaderSetCmax(oldtup.t_data, cid, iscombo);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+
+ /* record address of new tuple in t_ctid of old one */
+ oldtup.t_data->t_ctid = heaptup->t_self;
+@@ -3836,6 +3972,18 @@ l2:
+
+ END_CRIT_SECTION();
+
++ if (newtup != heaptup)
++ {
++ /*
++ * Set new tuple's Xmin/Xmax only after both xid base preparations.
++ * Old tuple's Xmin/Xmax were already shifted because old tuple is on
++ * the page.
++ */
++ Assert(!IsToastRelation(relation));
++ HeapTupleAndHeaderSetXmin(newpage, heaptup, xid, false);
++ HeapTupleAndHeaderSetXmax(newpage, newtup, xmax_new_tuple, false);
++ }
++
+ if (newbuf != buffer)
+ LockBuffer(newbuf, BUFFER_LOCK_UNLOCK);
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+@@ -4183,6 +4331,7 @@ heap_lock_tuple(Relation relation, HeapTuple tuple,
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tuple->t_len = ItemIdGetLength(lp);
+ tuple->t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ l3:
+ result = HeapTupleSatisfiesUpdate(tuple, cid, *buffer);
+@@ -4209,7 +4358,7 @@ l3:
+ ItemPointerData t_ctid;
+
+ /* must copy state data before unlocking buffer */
+- xwait = HeapTupleHeaderGetRawXmax(tuple->t_data);
++ xwait = HeapTupleGetRawXmax(tuple);
+ infomask = tuple->t_data->t_infomask;
+ infomask2 = tuple->t_data->t_infomask2;
+ ItemPointerCopy(&tuple->t_data->t_ctid, &t_ctid);
+@@ -4367,11 +4516,13 @@ l3:
+ result = res;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+ }
+
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /*
+ * Make sure it's still an appropriate lock, else start over.
+@@ -4380,7 +4531,7 @@ l3:
+ * now need to follow the update chain to lock the new
+ * versions.
+ */
+- if (!HeapTupleHeaderIsOnlyLocked(tuple->t_data) &&
++ if (!HeapTupleIsOnlyLocked(tuple) &&
+ ((tuple->t_data->t_infomask2 & HEAP_KEYS_UPDATED) ||
+ !updated))
+ goto l3;
+@@ -4407,6 +4558,7 @@ l3:
+ !HEAP_XMAX_IS_EXCL_LOCKED(infomask))
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /*
+ * Make sure it's still an appropriate lock, else start over.
+@@ -4435,8 +4587,10 @@ l3:
+ * meantime, start over.
+ */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
++
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+
+@@ -4447,10 +4601,11 @@ l3:
+ else if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask))
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /* if the xmax changed in the meantime, start over */
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+ /* otherwise, we're good */
+@@ -4475,8 +4630,10 @@ l3:
+ {
+ /* ... but if the xmax changed in the meantime, start over */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
++
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+ Assert(HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask));
+@@ -4497,6 +4654,7 @@ l3:
+ if (require_sleep && (result == TM_Updated || result == TM_Deleted))
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+ else if (require_sleep)
+@@ -4522,6 +4680,7 @@ l3:
+ result = TM_WouldBlock;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+
+@@ -4548,6 +4707,8 @@ l3:
+ result = TM_WouldBlock;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page,
++ false);
+ goto failed;
+ }
+ break;
+@@ -4588,6 +4749,8 @@ l3:
+ result = TM_WouldBlock;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page,
++ false);
+ goto failed;
+ }
+ break;
+@@ -4614,11 +4777,13 @@ l3:
+ result = res;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+ }
+
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /*
+ * xwait is done, but if xwait had just locked the tuple then some
+@@ -4626,7 +4791,7 @@ l3:
+ * Check for xmax change, and start over if so.
+ */
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+
+@@ -4654,7 +4819,7 @@ l3:
+ if (!require_sleep ||
+ (tuple->t_data->t_infomask & HEAP_XMAX_INVALID) ||
+ HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask) ||
+- HeapTupleHeaderIsOnlyLocked(tuple->t_data))
++ HeapTupleIsOnlyLocked(tuple))
+ result = TM_Ok;
+ else if (!ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid))
+ result = TM_Updated;
+@@ -4680,9 +4845,9 @@ failed:
+ Assert(result != TM_Updated ||
+ !ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid));
+ tmfd->ctid = tuple->t_data->t_ctid;
+- tmfd->xmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
++ tmfd->xmax = HeapTupleGetUpdateXidAny(tuple);
+ if (result == TM_SelfModified)
+- tmfd->cmax = HeapTupleHeaderGetCmax(tuple->t_data);
++ tmfd->cmax = HeapTupleGetCmax(tuple);
+ else
+ tmfd->cmax = InvalidCommandId;
+ goto out_locked;
+@@ -4702,10 +4867,11 @@ failed:
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
+ visibilitymap_pin(relation, block, &vmbuffer);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto l3;
+ }
+
+- xmax = HeapTupleHeaderGetRawXmax(tuple->t_data);
++ xmax = HeapTupleGetRawXmax(tuple);
+ old_infomask = tuple->t_data->t_infomask;
+
+ /*
+@@ -4727,6 +4893,10 @@ failed:
+ GetCurrentTransactionId(), mode, false,
+ &xid, &new_infomask, &new_infomask2);
+
++ heap_page_prepare_for_xid(relation, *buffer, xid,
++ (new_infomask & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
++
+ START_CRIT_SECTION();
+
+ /*
+@@ -4745,7 +4915,8 @@ failed:
+ tuple->t_data->t_infomask2 |= new_infomask2;
+ if (HEAP_XMAX_IS_LOCKED_ONLY(new_infomask))
+ HeapTupleHeaderClearHotUpdated(tuple->t_data);
+- HeapTupleHeaderSetXmax(tuple->t_data, xid);
++ Assert(!IsToastRelation(relation));
++ HeapTupleAndHeaderSetXmax(page, tuple, xid, false);
+
+ /*
+ * Make sure there is no forward chain link in t_ctid. Note that in the
+@@ -5339,12 +5510,19 @@ l4:
+ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+ }
+
++ /*
++ * Copy xid base after buffer relocking, it could have changed since
++ * heap_fetch().
++ */
++ HeapTupleCopyXidsFromPage(buf, &mytup, BufferGetPage(buf),
++ IsToastRelation(rel));
++
+ /*
+ * Check the tuple XMIN against prior XMAX, if any. If we reached the
+ * end of the chain, we're done, so return success.
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(HeapTupleHeaderGetXmin(mytup.t_data),
++ !TransactionIdEquals(HeapTupleGetXmin(&mytup),
+ priorXmax))
+ {
+ result = TM_Ok;
+@@ -5356,7 +5534,7 @@ l4:
+ * (sub)transaction, then we already locked the last live one in the
+ * chain, thus we're done, so return success.
+ */
+- if (TransactionIdDidAbort(HeapTupleHeaderGetXmin(mytup.t_data)))
++ if (TransactionIdDidAbort(HeapTupleGetXmin(&mytup)))
+ {
+ result = TM_Ok;
+ goto out_locked;
+@@ -5364,7 +5542,7 @@ l4:
+
+ old_infomask = mytup.t_data->t_infomask;
+ old_infomask2 = mytup.t_data->t_infomask2;
+- xmax = HeapTupleHeaderGetRawXmax(mytup.t_data);
++ xmax = HeapTupleGetRawXmax(&mytup);
+
+ /*
+ * If this tuple version has been updated or locked by some concurrent
+@@ -5377,7 +5555,7 @@ l4:
+ TransactionId rawxmax;
+ bool needwait;
+
+- rawxmax = HeapTupleHeaderGetRawXmax(mytup.t_data);
++ rawxmax = HeapTupleGetRawXmax(&mytup);
+ if (old_infomask & HEAP_XMAX_IS_MULTI)
+ {
+ int nmembers;
+@@ -5518,14 +5696,25 @@ l4:
+ VISIBILITYMAP_ALL_FROZEN))
+ cleared_all_frozen = true;
+
++#ifdef USE_ASSERT_CHECKING
++ if (IsToastRelation(rel))
++ Assert((new_infomask & HEAP_XMAX_IS_MULTI) == 0);
++#endif
++
++ heap_page_prepare_for_xid(rel, buf, new_xmax,
++ (new_infomask & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(buf, &mytup, BufferGetPage(buf),
++ IsToastRelation(rel));
++
+ START_CRIT_SECTION();
+
+ /* ... and set them */
+- HeapTupleHeaderSetXmax(mytup.t_data, new_xmax);
+ mytup.t_data->t_infomask &= ~HEAP_XMAX_BITS;
+ mytup.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+ mytup.t_data->t_infomask |= new_infomask;
+ mytup.t_data->t_infomask2 |= new_infomask2;
++ Assert(!IsToastRelation(rel));
++ HeapTupleAndHeaderSetXmax(BufferGetPage(buf), &mytup, new_xmax, false);
+
+ MarkBufferDirty(buf);
+
+@@ -5559,14 +5748,14 @@ next:
+ if (mytup.t_data->t_infomask & HEAP_XMAX_INVALID ||
+ HeapTupleHeaderIndicatesMovedPartitions(mytup.t_data) ||
+ ItemPointerEquals(&mytup.t_self, &mytup.t_data->t_ctid) ||
+- HeapTupleHeaderIsOnlyLocked(mytup.t_data))
++ HeapTupleIsOnlyLocked(&mytup))
+ {
+ result = TM_Ok;
+ goto out_locked;
+ }
+
+ /* tail recursion */
+- priorXmax = HeapTupleHeaderGetUpdateXid(mytup.t_data);
++ priorXmax = HeapTupleGetUpdateXidAny(&mytup);
+ ItemPointerCopy(&(mytup.t_data->t_ctid), &tupid);
+ UnlockReleaseBuffer(buf);
+ }
+@@ -5769,12 +5958,13 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tp.t_len = ItemIdGetLength(lp);
+ tp.t_self = *tid;
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
+
+ /*
+ * Sanity check that the tuple really is a speculatively inserted tuple,
+ * inserted by us.
+ */
+- if (tp.t_data->t_choice.t_heap.t_xmin != xid)
++ if (HeapTupleGetRawXmin(&tp) != xid)
+ elog(ERROR, "attempted to kill a tuple inserted by another transaction");
+ if (!(IsToastRelation(relation) || HeapTupleHeaderIsSpeculative(tp.t_data)))
+ elog(ERROR, "attempted to kill a non-speculative tuple");
+@@ -5803,7 +5993,9 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ prune_xid = relation->rd_rel->relfrozenxid;
+ else
+ prune_xid = TransactionXmin;
+- PageSetPrunable(page, prune_xid);
++ Assert(TransactionIdIsValid(prune_xid));
++ heap_page_prepare_for_xid(relation, buffer, prune_xid, false);
++ PageSetPrunable(page, prune_xid, IsToastRelation(relation));
+
+ /* store transaction information of xact deleting the tuple */
+ tp.t_data->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
+@@ -5812,9 +6004,12 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ /*
+ * Set the tuple header xmin to InvalidTransactionId. This makes the
+ * tuple immediately invisible everyone. (In particular, to any
+- * transactions waiting on the speculative token, woken up later.)
++ * transactions waiting on the speculative token, woken up later.) Don't
++ * need to reload xid base from page because InvalidTransactionId doesn't
++ * require xid base to be valid.
+ */
+- HeapTupleHeaderSetXmin(tp.t_data, InvalidTransactionId);
++ HeapTupleAndHeaderSetXmin(page, &tp, InvalidTransactionId,
++ IsToastRelation(relation));
+
+ /* Clear the speculative insertion token too */
+ tp.t_data->t_ctid = tp.t_self;
+@@ -5833,6 +6028,8 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ XLogRecPtr recptr;
+
+ xlrec.flags = XLH_DELETE_IS_SUPER;
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_DELETE_PAGE_ON_TOAST_RELATION;
+ xlrec.infobits_set = compute_infobits(tp.t_data->t_infomask,
+ tp.t_data->t_infomask2);
+ xlrec.offnum = ItemPointerGetOffsetNumber(&tp.t_self);
+@@ -6101,7 +6298,7 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ * been pruned away instead, since updater XID is < OldestXmin).
+ * Just remove xmax.
+ */
+- if (TransactionIdDidCommit(update_xact))
++ if (!TransactionIdDidAbort(update_xact))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg_internal("multixact %llu contains non-aborted update XID %llu from before removable cutoff %llu",
+@@ -6199,7 +6396,7 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ * even member XIDs >= OldestXmin often won't be kept by second pass.
+ */
+ nnewmembers = 0;
+- newmembers = palloc(sizeof(MultiXactMember) * nmembers);
++ newmembers = palloc0(sizeof(MultiXactMember) * nmembers);
+ has_lockers = false;
+ update_xid = InvalidTransactionId;
+ update_committed = false;
+@@ -6385,7 +6582,7 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ * then caller had better have an exclusive lock on it already.
+ */
+ bool
+-heap_prepare_freeze_tuple(HeapTupleHeader tuple,
++heap_prepare_freeze_tuple(HeapTuple htup,
+ const struct VacuumCutoffs *cutoffs,
+ HeapPageFreeze *pagefrz,
+ HeapTupleFreeze *frz, bool *totally_frozen)
+@@ -6397,8 +6594,9 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ replace_xmax = false,
+ freeze_xmax = false;
+ TransactionId xid;
++ HeapTupleHeader tuple = htup->t_data;
+
+- frz->xmax = HeapTupleHeaderGetRawXmax(tuple);
++ frz->xmax = HeapTupleGetRawXmax(htup);
+ frz->t_infomask2 = tuple->t_infomask2;
+ frz->t_infomask = tuple->t_infomask;
+ frz->frzflags = 0;
+@@ -6409,7 +6607,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ * will become frozen iff our freeze plan is executed by caller (could be
+ * neither).
+ */
+- xid = HeapTupleHeaderGetXmin(tuple);
++ xid = HeapTupleGetXmin(htup);
+ if (!TransactionIdIsNormal(xid))
+ xmin_already_frozen = true;
+ else
+@@ -6551,6 +6749,15 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ /* MultiXactId processing forces freezing (barring FRM_NOOP case) */
+ Assert(pagefrz->freeze_required || (!freeze_xmax && !replace_xmax));
+ }
++ else if ((tuple->t_infomask & HEAP_XMAX_INVALID) &&
++ TransactionIdIsNormal(xid))
++ {
++ /*
++ * To reset xmax without reading clog.
++ * This prevent excess growth of xmax.
++ */
++ freeze_xmax = true;
++ }
+ else if (TransactionIdIsNormal(xid))
+ {
+ /* Raw xmax is normal XID */
+@@ -6572,7 +6779,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ if (freeze_xmax && !HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ frz->checkflags |= HEAP_FREEZE_CHECK_XMAX_ABORTED;
+ }
+- else if (!TransactionIdIsValid(xid))
++ else if (!TransactionIdIsValid(HeapTupleGetRawXmax(htup)))
+ {
+ /* Raw xmax is InvalidTransactionId XID */
+ Assert((tuple->t_infomask & HEAP_XMAX_IS_MULTI) == 0);
+@@ -6642,7 +6849,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ * Does this tuple force caller to freeze the entire page?
+ */
+ pagefrz->freeze_required =
+- heap_tuple_should_freeze(tuple, cutoffs,
++ heap_tuple_should_freeze(htup, cutoffs,
+ &pagefrz->NoFreezePageRelfrozenXid,
+ &pagefrz->NoFreezePageRelminMxid);
+ }
+@@ -6661,18 +6868,32 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ * in private storage (which is what CLUSTER and friends do).
+ */
+ static inline void
+-heap_execute_freeze_tuple(HeapTupleHeader tuple, HeapTupleFreeze *frz)
++heap_execute_freeze_tuple(HeapTuple htup, HeapTupleFreeze *frz)
+ {
+- HeapTupleHeaderSetXmax(tuple, frz->xmax);
++ HeapTupleHeader tuple = htup->t_data;
++
++ tuple->t_infomask = frz->t_infomask;
++ tuple->t_infomask2 = frz->t_infomask2;
++
++ HeapTupleSetXmax(htup, frz->xmax);
+
+ if (frz->frzflags & XLH_FREEZE_XVAC)
+ HeapTupleHeaderSetXvac(tuple, FrozenTransactionId);
+
+ if (frz->frzflags & XLH_INVALID_XVAC)
+ HeapTupleHeaderSetXvac(tuple, InvalidTransactionId);
++}
+
+- tuple->t_infomask = frz->t_infomask;
+- tuple->t_infomask2 = frz->t_infomask2;
++static inline void
++heap_execute_freeze_tuple_page(Page page, HeapTupleHeader htup,
++ HeapTupleFreeze *frz, bool is_toast)
++{
++ HeapTupleData tuple;
++
++ tuple.t_data = htup;
++ heap_execute_freeze_tuple(&tuple, frz);
++
++ HeapTupleHeaderStoreXmax(page, &tuple, is_toast);
+ }
+
+ /*
+@@ -6709,34 +6930,31 @@ heap_freeze_execute_prepared(Relation rel, Buffer buffer,
+ {
+ HeapTupleFreeze *frz = tuples + i;
+ ItemId itemid = PageGetItemId(page, frz->offset);
+- HeapTupleHeader htup;
++ HeapTupleData tuple;
+
+- htup = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page, IsToastRelation(rel));
+
+ /* Deliberately avoid relying on tuple hint bits here */
+ if (frz->checkflags & HEAP_FREEZE_CHECK_XMIN_COMMITTED)
+ {
+- TransactionId xmin = HeapTupleHeaderGetRawXmin(htup);
++ TransactionId xmin = HeapTupleGetXmin(&tuple);
+
+- Assert(!HeapTupleHeaderXminFrozen(htup));
++ Assert(!HeapTupleHeaderXminFrozen(tuple.t_data));
+ if (unlikely(!TransactionIdDidCommit(xmin)))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg_internal("uncommitted xmin %llu needs to be frozen",
+ (unsigned long long) xmin)));
+ }
+-
+- /*
+- * TransactionIdDidAbort won't work reliably in the presence of XIDs
+- * left behind by transactions that were in progress during a crash,
+- * so we can only check that xmax didn't commit
+- */
+ if (frz->checkflags & HEAP_FREEZE_CHECK_XMAX_ABORTED)
+ {
+- TransactionId xmax = HeapTupleHeaderGetRawXmax(htup);
++ TransactionId xmax = HeapTupleGetRawXmax(&tuple);
+
+ Assert(TransactionIdIsNormal(xmax));
+- if (unlikely(TransactionIdDidCommit(xmax)))
++ if (unlikely(!TransactionIdDidAbort(xmax)))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg_internal("cannot freeze non-aborted xmax %llu",
+@@ -6753,7 +6971,8 @@ heap_freeze_execute_prepared(Relation rel, Buffer buffer,
+ HeapTupleHeader htup;
+
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
+- heap_execute_freeze_tuple(htup, frz);
++ heap_execute_freeze_tuple_page(page, htup, frz,
++ IsToastRelation(rel));
+ }
+
+ MarkBufferDirty(buffer);
+@@ -6764,7 +6983,7 @@ heap_freeze_execute_prepared(Relation rel, Buffer buffer,
+ xl_heap_freeze_plan plans[MaxHeapTuplesPerPage];
+ OffsetNumber offsets[MaxHeapTuplesPerPage];
+ int nplans;
+- xl_heap_freeze_page xlrec;
++ xl_heap_freeze_page xlrec = {0};
+ XLogRecPtr recptr;
+
+ /* Prepare deduplicated representation for use in WAL record */
+@@ -6773,6 +6992,8 @@ heap_freeze_execute_prepared(Relation rel, Buffer buffer,
+ xlrec.snapshotConflictHorizon = snapshotConflictHorizon;
+ xlrec.isCatalogRel = RelationIsAccessibleInLogicalDecoding(rel);
+ xlrec.nplans = nplans;
++ if (IsToastRelation(rel))
++ xlrec.flags = XLH_FREEZE_PAGE_ON_TOAST_RELATION;
+
+ XLogBeginInsert();
+ XLogRegisterData((char *) &xlrec, SizeOfHeapFreezePage);
+@@ -6941,7 +7162,7 @@ heap_log_freeze_plan(HeapTupleFreeze *tuples, int ntuples,
+ * Useful for callers like CLUSTER that perform their own WAL logging.
+ */
+ bool
+-heap_freeze_tuple(HeapTupleHeader tuple,
++heap_freeze_tuple(HeapTuple tuple,
+ TransactionId relfrozenxid, TransactionId relminmxid,
+ TransactionId FreezeLimit, TransactionId MultiXactCutoff)
+ {
+@@ -7118,10 +7339,10 @@ MultiXactIdGetUpdateXid(TransactionId xmax, uint16 t_infomask)
+ * checking the hint bits.
+ */
+ TransactionId
+-HeapTupleGetUpdateXid(HeapTupleHeader tuple)
++HeapTupleGetUpdateXid(HeapTuple tuple)
+ {
+- return MultiXactIdGetUpdateXid(HeapTupleHeaderGetRawXmax(tuple),
+- tuple->t_infomask);
++ return MultiXactIdGetUpdateXid(HeapTupleGetRawXmax(tuple),
++ tuple->t_data->t_infomask);
+ }
+
+ /*
+@@ -7347,15 +7568,18 @@ ConditionalMultiXactIdWait(MultiXactId multi, MultiXactStatus status,
+ * will eventually require freezing (if tuple isn't removed by pruning first).
+ */
+ bool
+-heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
++heap_tuple_needs_eventual_freeze(HeapTuple htup)
+ {
+ TransactionId xid;
++ HeapTupleHeader tuple;
++
++ tuple = htup->t_data;
+
+ /*
+ * If xmin is a normal transaction ID, this tuple is definitely not
+ * frozen.
+ */
+- xid = HeapTupleHeaderGetXmin(tuple);
++ xid = HeapTupleGetXmin(htup);
+ if (TransactionIdIsNormal(xid))
+ return true;
+
+@@ -7366,13 +7590,13 @@ heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
+ {
+ MultiXactId multi;
+
+- multi = HeapTupleHeaderGetRawXmax(tuple);
++ multi = HeapTupleGetRawXmax(htup);
+ if (MultiXactIdIsValid(multi))
+ return true;
+ }
+ else
+ {
+- xid = HeapTupleHeaderGetRawXmax(tuple);
++ xid = HeapTupleGetRawXmax(htup);
+ if (TransactionIdIsNormal(xid))
+ return true;
+ }
+@@ -7402,17 +7626,18 @@ heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
+ * point that it fully commits to not freezing the tuple/page in question.
+ */
+ bool
+-heap_tuple_should_freeze(HeapTupleHeader tuple,
++heap_tuple_should_freeze(HeapTuple htup,
+ const struct VacuumCutoffs *cutoffs,
+ TransactionId *NoFreezePageRelfrozenXid,
+ MultiXactId *NoFreezePageRelminMxid)
+ {
+ TransactionId xid;
+ MultiXactId multi;
++ HeapTupleHeader tuple = htup->t_data;
+ bool freeze = false;
+
+ /* First deal with xmin */
+- xid = HeapTupleHeaderGetXmin(tuple);
++ xid = HeapTupleGetXmin(htup);
+ if (TransactionIdIsNormal(xid))
+ {
+ Assert(TransactionIdPrecedesOrEquals(cutoffs->relfrozenxid, xid));
+@@ -7426,9 +7651,9 @@ heap_tuple_should_freeze(HeapTupleHeader tuple,
+ xid = InvalidTransactionId;
+ multi = InvalidMultiXactId;
+ if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
+- multi = HeapTupleHeaderGetRawXmax(tuple);
++ multi = HeapTupleGetRawXmax(htup);
+ else
+- xid = HeapTupleHeaderGetRawXmax(tuple);
++ xid = HeapTupleGetRawXmax(htup);
+
+ if (TransactionIdIsNormal(xid))
+ {
+@@ -7439,6 +7664,14 @@ heap_tuple_should_freeze(HeapTupleHeader tuple,
+ if (TransactionIdPrecedes(xid, cutoffs->FreezeLimit))
+ freeze = true;
+ }
++ else if ((tuple->t_infomask & HEAP_XMAX_INVALID) &&
++ TransactionIdIsNormal(xid))
++ {
++ /*
++ * To reset xmax without reading clog.
++ */
++ freeze = true;
++ }
+ else if (!MultiXactIdIsValid(multi))
+ {
+ /* xmax is a permanent XID or invalid MultiXactId/XID */
+@@ -7510,14 +7743,14 @@ heap_tuple_should_freeze(HeapTupleHeader tuple,
+ * caller's WAL record) by REDO routine when it replays caller's operation.
+ */
+ void
+-HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
++HeapTupleHeaderAdvanceConflictHorizon(HeapTuple tuple,
+ TransactionId *snapshotConflictHorizon)
+ {
+- TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
+- TransactionId xmax = HeapTupleHeaderGetUpdateXid(tuple);
+- TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
++ TransactionId xmin = HeapTupleGetXmin(tuple);
++ TransactionId xmax = HeapTupleGetUpdateXidAny(tuple);
++ TransactionId xvac = HeapTupleHeaderGetXvac(tuple->t_data);
+
+- if (tuple->t_infomask & HEAP_MOVED)
++ if (tuple->t_data->t_infomask & HEAP_MOVED)
+ {
+ if (TransactionIdPrecedes(*snapshotConflictHorizon, xvac))
+ *snapshotConflictHorizon = xvac;
+@@ -7529,8 +7762,8 @@ HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
+ *
+ * Look for a committed hint bit, or if no xmin bit is set, check clog.
+ */
+- if (HeapTupleHeaderXminCommitted(tuple) ||
+- (!HeapTupleHeaderXminInvalid(tuple) && TransactionIdDidCommit(xmin)))
++ if (HeapTupleHeaderXminCommitted(tuple->t_data) ||
++ (!HeapTupleHeaderXminInvalid(tuple->t_data) && TransactionIdDidCommit(xmin)))
+ {
+ if (xmax != xmin &&
+ TransactionIdFollows(xmax, *snapshotConflictHorizon))
+@@ -7878,7 +8111,7 @@ heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
+ for (;;)
+ {
+ ItemId lp;
+- HeapTupleHeader htup;
++ HeapTupleData htup;
+
+ /* Sanity check (pure paranoia) */
+ if (offnum < FirstOffsetNumber)
+@@ -7915,16 +8148,18 @@ heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
+ if (!ItemIdIsNormal(lp))
+ break;
+
+- htup = (HeapTupleHeader) PageGetItem(page, lp);
++ htup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
++ htup.t_len = ItemIdGetLength(lp);
++ HeapTupleCopyXidsFromPage(buf, &htup, page, IsToastRelation(rel));
+
+ /*
+ * Check the tuple XMIN against prior XMAX, if any
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(HeapTupleHeaderGetXmin(htup), priorXmax))
++ !TransactionIdEquals(HeapTupleGetXmin(&htup), priorXmax))
+ break;
+
+- HeapTupleHeaderAdvanceConflictHorizon(htup,
++ HeapTupleHeaderAdvanceConflictHorizon(&htup,
+ &snapshotConflictHorizon);
+
+ /*
+@@ -7933,13 +8168,13 @@ heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
+ * chain (they get their own index entries) -- just move on to
+ * next htid from index AM caller.
+ */
+- if (!HeapTupleHeaderIsHotUpdated(htup))
++ if (!HeapTupleHeaderIsHotUpdated(htup.t_data))
+ break;
+
+ /* Advance to next HOT chain member */
+- Assert(ItemPointerGetBlockNumber(&htup->t_ctid) == blkno);
+- offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ Assert(ItemPointerGetBlockNumber(&htup.t_data->t_ctid) == blkno);
++ offnum = ItemPointerGetOffsetNumber(&htup.t_data->t_ctid);
++ priorXmax = HeapTupleGetUpdateXidAny(&htup);
+ }
+
+ /* Enable further/final shrinking of deltids for caller */
+@@ -8382,6 +8617,8 @@ log_heap_update(Relation reln, Buffer oldbuf,
+ bool all_visible_cleared, bool new_all_visible_cleared)
+ {
+ xl_heap_update xlrec;
++ TransactionId xid_base,
++ multi_base;
+ xl_heap_header xlhdr;
+ xl_heap_header xlhdr_idx;
+ uint8 info;
+@@ -8490,13 +8727,13 @@ log_heap_update(Relation reln, Buffer oldbuf,
+
+ /* Prepare WAL data for the old page */
+ xlrec.old_offnum = ItemPointerGetOffsetNumber(&oldtup->t_self);
+- xlrec.old_xmax = HeapTupleHeaderGetRawXmax(oldtup->t_data);
++ xlrec.old_xmax = HeapTupleGetRawXmax(oldtup);
+ xlrec.old_infobits_set = compute_infobits(oldtup->t_data->t_infomask,
+ oldtup->t_data->t_infomask2);
+
+ /* Prepare WAL data for the new page */
+ xlrec.new_offnum = ItemPointerGetOffsetNumber(&newtup->t_self);
+- xlrec.new_xmax = HeapTupleHeaderGetRawXmax(newtup->t_data);
++ xlrec.new_xmax = HeapTupleGetRawXmax(newtup);
+
+ bufflags = REGBUF_STANDARD;
+ if (init)
+@@ -8508,6 +8745,17 @@ log_heap_update(Relation reln, Buffer oldbuf,
+ if (oldbuf != newbuf)
+ XLogRegisterBuffer(1, oldbuf, REGBUF_STANDARD);
+
++ if (info & XLOG_HEAP_INIT_PAGE)
++ {
++ HeapPageSpecial special = HeapPageGetSpecial(page);
++
++ Assert(!IsToastRelation(reln));
++ xid_base = special->pd_xid_base;
++ multi_base = special->pd_multi_base;
++ XLogRegisterData((char *) &xid_base, sizeof(xid_base));
++ XLogRegisterData((char *) &multi_base, sizeof(multi_base));
++ }
++
+ XLogRegisterData((char *) &xlrec, SizeOfHeapUpdate);
+
+ /*
+@@ -8620,8 +8868,8 @@ log_heap_new_cid(Relation relation, HeapTuple tup)
+ {
+ Assert(!(hdr->t_infomask & HEAP_XMAX_INVALID));
+ Assert(!HeapTupleHeaderXminInvalid(hdr));
+- xlrec.cmin = HeapTupleHeaderGetCmin(hdr);
+- xlrec.cmax = HeapTupleHeaderGetCmax(hdr);
++ xlrec.cmin = HeapTupleGetCmin(tup);
++ xlrec.cmax = HeapTupleGetCmax(tup);
+ xlrec.combocid = HeapTupleHeaderGetRawCommandId(hdr);
+ }
+ /* No combo CID, so only cmin or cmax can be set by this TX */
+@@ -8825,7 +9073,9 @@ heap_xlog_prune(XLogReaderState *record)
+ heap_page_prune_execute(buffer,
+ redirected, nredirected,
+ nowdead, ndead,
+- nowunused, nunused);
++ nowunused, nunused,
++ (xlrec->flags & XLH_PRUNE_REPAIR_FRAGMENTATION) != 0,
++ (xlrec->flags & XLH_PRUNE_ON_TOAST_RELATION) != 0);
+
+ /*
+ * Note: we don't worry about updating the page's prunability hints.
+@@ -9121,7 +9371,8 @@ heap_xlog_freeze_page(XLogReaderState *record)
+
+ lp = PageGetItemId(page, offset);
+ tuple = (HeapTupleHeader) PageGetItem(page, lp);
+- heap_execute_freeze_tuple(tuple, &frz);
++ heap_execute_freeze_tuple_page(page, tuple, &frz,
++ (xlrec->flags & XLH_FREEZE_PAGE_ON_TOAST_RELATION) != 0);
+ }
+ }
+
+@@ -9193,6 +9444,8 @@ heap_xlog_delete(XLogReaderState *record)
+
+ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = BufferGetPage(buffer);
+
+ if (PageGetMaxOffsetNumber(page) >= xlrec->offnum)
+@@ -9208,14 +9461,19 @@ heap_xlog_delete(XLogReaderState *record)
+ HeapTupleHeaderClearHotUpdated(htup);
+ fix_infomask_from_infobits(xlrec->infobits_set,
+ &htup->t_infomask, &htup->t_infomask2);
++ tuple.t_data = htup;
++
+ if (!(xlrec->flags & XLH_DELETE_IS_SUPER))
+- HeapTupleHeaderSetXmax(htup, xlrec->xmax);
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->xmax,
++ (xlrec->flags & XLH_DELETE_PAGE_ON_TOAST_RELATION) != 0);
+ else
+- HeapTupleHeaderSetXmin(htup, InvalidTransactionId);
++ HeapTupleAndHeaderSetXmin(page, &tuple, InvalidTransactionId,
++ (xlrec->flags & XLH_DELETE_PAGE_ON_TOAST_RELATION) != 0);
+ HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
+
+ /* Mark the page as a candidate for pruning */
+- PageSetPrunable(page, XLogRecGetXid(record));
++ PageSetPrunable(page, XLogRecGetXid(record),
++ (xlrec->flags & XLH_DELETE_PAGE_ON_TOAST_RELATION) != 0);
+
+ if (xlrec->flags & XLH_DELETE_ALL_VISIBLE_CLEARED)
+ PageClearAllVisible(page);
+@@ -9236,7 +9494,7 @@ static void
+ heap_xlog_insert(XLogReaderState *record)
+ {
+ XLogRecPtr lsn = record->EndRecPtr;
+- xl_heap_insert *xlrec = (xl_heap_insert *) XLogRecGetData(record);
++ xl_heap_insert *xlrec;
+ Buffer buffer;
+ Page page;
+ union
+@@ -9252,6 +9510,20 @@ heap_xlog_insert(XLogReaderState *record)
+ BlockNumber blkno;
+ ItemPointerData target_tid;
+ XLogRedoAction action;
++ bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(record);
++ TransactionId xid_base = InvalidTransactionId;
++ TransactionId multi_base = InvalidTransactionId;
++
++ if (isinit)
++ {
++ xid_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ multi_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ }
++
++ xlrec = (xl_heap_insert *) rec_data;
+
+ XLogRecGetBlockTag(record, 0, &target_locator, NULL, &blkno);
+ ItemPointerSetBlockNumber(&target_tid, blkno);
+@@ -9276,11 +9548,28 @@ heap_xlog_insert(XLogReaderState *record)
+ * If we inserted the first and only tuple on the page, re-initialize the
+ * page from scratch.
+ */
+- if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
++ if (isinit)
+ {
+ buffer = XLogInitBufferForRedo(record, 0);
+ page = BufferGetPage(buffer);
+- PageInit(page, BufferGetPageSize(buffer), 0);
++
++ if (xlrec->flags & XLH_INSERT_ON_TOAST_RELATION)
++ {
++ PageInit(page, BufferGetPageSize(buffer),
++ sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ PageInit(page, BufferGetPageSize(buffer),
++ sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
++ }
++
+ action = BLK_NEEDS_REDO;
+ }
+ else
+@@ -9289,6 +9578,7 @@ heap_xlog_insert(XLogReaderState *record)
+ {
+ Size datalen;
+ char *data;
++ HeapTupleData tuple;
+
+ page = BufferGetPage(buffer);
+
+@@ -9312,7 +9602,9 @@ heap_xlog_insert(XLogReaderState *record)
+ htup->t_infomask2 = xlhdr.t_infomask2;
+ htup->t_infomask = xlhdr.t_infomask;
+ htup->t_hoff = xlhdr.t_hoff;
+- HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmin(page, &tuple, XLogRecGetXid(record),
++ (xlrec->flags & XLH_INSERT_ON_TOAST_RELATION) != 0);
+ HeapTupleHeaderSetCmin(htup, FirstCommandId);
+ htup->t_ctid = target_tid;
+
+@@ -9372,12 +9664,22 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ int i;
+ bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
+ XLogRedoAction action;
++ TransactionId xid_base = InvalidTransactionId,
++ multi_base = InvalidTransactionId;
++ Pointer rec_data = (Pointer) XLogRecGetData(record);
+
+ /*
+ * Insertion doesn't overwrite MVCC data, so no conflict processing is
+ * required.
+ */
+- xlrec = (xl_heap_multi_insert *) XLogRecGetData(record);
++ if (isinit)
++ {
++ xid_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ multi_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ }
++ xlrec = (xl_heap_multi_insert *) rec_data;
+
+ XLogRecGetBlockTag(record, 0, &rlocator, NULL, &blkno);
+
+@@ -9404,7 +9706,22 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ {
+ buffer = XLogInitBufferForRedo(record, 0);
+ page = BufferGetPage(buffer);
+- PageInit(page, BufferGetPageSize(buffer), 0);
++
++ if ((xlrec->flags & XLH_INSERT_ON_TOAST_RELATION) != 0)
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ PageInit(page, BufferGetPageSize(buffer), sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
++ }
++
+ action = BLK_NEEDS_REDO;
+ }
+ else
+@@ -9425,6 +9742,7 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ {
+ OffsetNumber offnum;
+ xl_multi_insert_tuple *xlhdr;
++ HeapTupleData tuple;
+
+ /*
+ * If we're reinitializing the page, the tuples are stored in
+@@ -9455,7 +9773,9 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ htup->t_infomask2 = xlhdr->t_infomask2;
+ htup->t_infomask = xlhdr->t_infomask;
+ htup->t_hoff = xlhdr->t_hoff;
+- HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmin(page, &tuple, XLogRecGetXid(record),
++ false);
+ HeapTupleHeaderSetCmin(htup, FirstCommandId);
+ ItemPointerSetBlockNumber(&htup->t_ctid, blkno);
+ ItemPointerSetOffsetNumber(&htup->t_ctid, offnum);
+@@ -9503,8 +9823,8 @@ static void
+ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ {
+ XLogRecPtr lsn = record->EndRecPtr;
+- xl_heap_update *xlrec = (xl_heap_update *) XLogRecGetData(record);
+ RelFileLocator rlocator;
++ xl_heap_update *xlrec;
+ BlockNumber oldblk;
+ BlockNumber newblk;
+ ItemPointerData newtid;
+@@ -9528,6 +9848,20 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ Size freespace = 0;
+ XLogRedoAction oldaction;
+ XLogRedoAction newaction;
++ bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(record);
++ TransactionId xid_base = InvalidTransactionId,
++ multi_base = InvalidTransactionId;
++
++ if (isinit)
++ {
++ xid_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ multi_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ }
++
++ xlrec = (xl_heap_update *) rec_data;
+
+ /* initialize to keep the compiler quiet */
+ oldtup.t_data = NULL;
+@@ -9574,6 +9908,8 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ &obuffer);
+ if (oldaction == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = BufferGetPage(obuffer);
+ offnum = xlrec->old_offnum;
+ if (PageGetMaxOffsetNumber(page) >= offnum)
+@@ -9586,6 +9922,8 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+
+ oldtup.t_data = htup;
+ oldtup.t_len = ItemIdGetLength(lp);
++ /* Toast tuples are never updated. */
++ HeapTupleCopyXidsFromPage(obuffer, &oldtup, page, false);
+
+ htup->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
+ htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+@@ -9595,13 +9933,15 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ HeapTupleHeaderClearHotUpdated(htup);
+ fix_infomask_from_infobits(xlrec->old_infobits_set, &htup->t_infomask,
+ &htup->t_infomask2);
+- HeapTupleHeaderSetXmax(htup, xlrec->old_xmax);
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->old_xmax, false);
+ HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
+ /* Set forward chain link in t_ctid */
+ htup->t_ctid = newtid;
+
+ /* Mark the page as a candidate for pruning */
+- PageSetPrunable(page, XLogRecGetXid(record));
++ /* Toast tuples are never updated. */
++ PageSetPrunable(page, XLogRecGetXid(record), false);
+
+ if (xlrec->flags & XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED)
+ PageClearAllVisible(page);
+@@ -9618,11 +9958,18 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ nbuffer = obuffer;
+ newaction = oldaction;
+ }
+- else if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
++ else if (isinit)
+ {
++ HeapPageSpecial special;
++
+ nbuffer = XLogInitBufferForRedo(record, 0);
+ page = (Page) BufferGetPage(nbuffer);
+- PageInit(page, BufferGetPageSize(nbuffer), 0);
++
++ /* Toast tuples are never updated. */
++ PageInit(page, BufferGetPageSize(nbuffer), sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
+ newaction = BLK_NEEDS_REDO;
+ }
+ else
+@@ -9650,6 +9997,7 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ char *recdata_end;
+ Size datalen;
+ Size tuplen;
++ HeapTupleData tuple;
+
+ recdata = XLogRecGetBlockData(record, 0, &datalen);
+ recdata_end = recdata + datalen;
+@@ -9728,9 +10076,10 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ htup->t_infomask = xlhdr.t_infomask;
+ htup->t_hoff = xlhdr.t_hoff;
+
+- HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmin(page, &tuple, XLogRecGetXid(record), false);
+ HeapTupleHeaderSetCmin(htup, FirstCommandId);
+- HeapTupleHeaderSetXmax(htup, xlrec->new_xmax);
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->new_xmax, false);
+ /* Make sure there is no forward chain link in t_ctid */
+ htup->t_ctid = newtid;
+
+@@ -9841,6 +10190,8 @@ heap_xlog_lock(XLogReaderState *record)
+
+ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = (Page) BufferGetPage(buffer);
+
+ offnum = xlrec->offnum;
+@@ -9869,7 +10220,9 @@ heap_xlog_lock(XLogReaderState *record)
+ BufferGetBlockNumber(buffer),
+ offnum);
+ }
+- HeapTupleHeaderSetXmax(htup, xlrec->xmax);
++
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->xmax, false);
+ HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
+ PageSetLSN(page, lsn);
+ MarkBufferDirty(buffer);
+@@ -9914,6 +10267,8 @@ heap_xlog_lock_updated(XLogReaderState *record)
+
+ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = BufferGetPage(buffer);
+
+ offnum = xlrec->offnum;
+@@ -9929,7 +10284,8 @@ heap_xlog_lock_updated(XLogReaderState *record)
+ htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+ fix_infomask_from_infobits(xlrec->infobits_set, &htup->t_infomask,
+ &htup->t_infomask2);
+- HeapTupleHeaderSetXmax(htup, xlrec->xmax);
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->xmax, false);
+
+ PageSetLSN(page, lsn);
+ MarkBufferDirty(buffer);
+@@ -10077,6 +10433,10 @@ heap_mask(char *pagedata, BlockNumber blkno)
+ mask_page_lsn_and_checksum(page);
+
+ mask_page_hint_bits(page);
++
++ /* Ignore prune_xid (it's like a hint-bit) */
++ HeapPageSetPruneXid(page, InvalidTransactionId, false);
++
+ mask_unused_space(page);
+
+ for (off = 1; off <= PageGetMaxOffsetNumber(page); off++)
+@@ -10192,14 +10552,14 @@ HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+ case HEAPTUPLE_LIVE:
+ if (visible)
+ return;
+- xid = HeapTupleHeaderGetXmin(tuple->t_data);
++ xid = HeapTupleGetXmin(tuple);
+ break;
+ case HEAPTUPLE_RECENTLY_DEAD:
+ case HEAPTUPLE_DELETE_IN_PROGRESS:
+ if (visible)
+- xid = HeapTupleHeaderGetUpdateXid(tuple->t_data);
++ xid = HeapTupleGetUpdateXidAny(tuple);
+ else
+- xid = HeapTupleHeaderGetXmin(tuple->t_data);
++ xid = HeapTupleGetXmin(tuple);
+
+ if (TransactionIdPrecedes(xid, TransactionXmin))
+ {
+@@ -10209,7 +10569,7 @@ HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+ }
+ break;
+ case HEAPTUPLE_INSERT_IN_PROGRESS:
+- xid = HeapTupleHeaderGetXmin(tuple->t_data);
++ xid = HeapTupleGetXmin(tuple);
+ break;
+ case HEAPTUPLE_DEAD:
+ Assert(!visible);
+@@ -10247,3 +10607,567 @@ HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+
+ CheckForSerializableConflictOut(relation, xid, snapshot);
+ }
++
++static void
++xid_min_max(ShortTransactionId *min, ShortTransactionId *max,
++ ShortTransactionId xid,
++ bool *found)
++{
++ Assert(TransactionIdIsNormal(xid));
++ Assert(xid <= MaxShortTransactionId);
++
++ if (!*found)
++ {
++ *min = *max = xid;
++ *found = true;
++ }
++ else
++ {
++ *min = Min(*min, xid);
++ *max = Max(*max, xid);
++ }
++}
++
++/*
++ * Find minimum and maximum short transaction ids which occurs in the page.
++ *
++ * Works for multi and non multi transaction. Which is defined by "multi"
++ * argument.
++ */
++static bool
++heap_page_xid_min_max(Page page, bool multi,
++ ShortTransactionId *min, ShortTransactionId *max,
++ bool is_toast)
++{
++ bool found;
++ OffsetNumber offnum,
++ maxoff;
++ ItemId itemid;
++ HeapTupleHeader htup;
++
++ maxoff = PageGetMaxOffsetNumber(page);
++ found = false;
++
++ Assert(!multi || !is_toast);
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++
++ if (!multi)
++ {
++ /*
++ * For non multi transactions we should see inside the tuple for
++ * update transaction.
++ */
++ Assert(!is_toast || !(htup->t_infomask & HEAP_XMAX_IS_MULTI));
++
++ if (TransactionIdIsNormal(htup->t_choice.t_heap.t_xmin) &&
++ !HeapTupleHeaderXminFrozen(htup))
++ {
++ xid_min_max(min, max, htup->t_choice.t_heap.t_xmin, &found);
++ }
++
++ if ((htup->t_infomask & HEAP_XMAX_IS_MULTI) &&
++ (!(htup->t_infomask & HEAP_XMAX_LOCK_ONLY)))
++ {
++ TransactionId update_xid;
++ ShortTransactionId xid;
++
++ Assert(!is_toast);
++ update_xid = MultiXactIdGetUpdateXid(HeapTupleHeaderGetRawXmax(page, htup),
++ htup->t_infomask);
++ xid = NormalTransactionIdToShort(HeapPageGetSpecial(page)->pd_xid_base,
++ update_xid);
++
++ xid_min_max(min, max, xid, &found);
++ }
++ }
++
++ if (!TransactionIdIsNormal(htup->t_choice.t_heap.t_xmax))
++ continue;
++
++ if (multi != ((htup->t_infomask & HEAP_XMAX_IS_MULTI) != 0))
++ continue;
++
++ xid_min_max(min, max, htup->t_choice.t_heap.t_xmax, &found);
++ }
++
++ Assert(!found || (*min > InvalidTransactionId && *max <= MaxShortTransactionId));
++
++ return found;
++}
++
++/*
++ * Shift xid base in the page. WAL-logged if buffer is specified.
++ */
++static void
++heap_page_shift_base(Relation relation, Buffer buffer, Page page,
++ bool multi, int64 delta, bool is_toast)
++{
++ TransactionId *xid_base,
++ *multi_base;
++ OffsetNumber offnum,
++ maxoff;
++ ItemId itemid;
++ HeapTupleHeader htup;
++
++ Assert(IsBufferLockedExclusive(buffer));
++
++ START_CRIT_SECTION();
++
++ if (is_toast)
++ {
++ Assert(!multi);
++ xid_base = &ToastPageGetSpecial(page)->pd_xid_base;
++ multi_base = NULL;
++ }
++ else
++ {
++ HeapPageSpecial special = HeapPageGetSpecial(page);
++
++ xid_base = &special->pd_xid_base;
++ multi_base = &special->pd_multi_base;
++ }
++
++ /* Iterate over page items */
++ maxoff = PageGetMaxOffsetNumber(page);
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++
++ /* Apply xid shift to heap tuple */
++ if (!multi)
++ {
++ /* shift xmin */
++ if (TransactionIdIsNormal(htup->t_choice.t_heap.t_xmin) &&
++ !HeapTupleHeaderXminFrozen(htup))
++ {
++ Assert(htup->t_choice.t_heap.t_xmin - delta >= FirstNormalTransactionId);
++ Assert(htup->t_choice.t_heap.t_xmin - delta <= MaxShortTransactionId);
++ htup->t_choice.t_heap.t_xmin -= delta;
++ }
++ }
++
++ /* shift xmax */
++ if (!TransactionIdIsNormal(htup->t_choice.t_heap.t_xmax))
++ continue;
++
++ if (multi != (bool) (htup->t_infomask & HEAP_XMAX_IS_MULTI))
++ continue;
++
++ Assert(htup->t_choice.t_heap.t_xmax - delta >= FirstNormalTransactionId);
++ Assert(htup->t_choice.t_heap.t_xmax - delta <= MaxShortTransactionId);
++ htup->t_choice.t_heap.t_xmax -= delta;
++ }
++
++ /* Apply xid shift to base as well */
++ if (!multi)
++ *xid_base += delta;
++ else
++ *multi_base += delta;
++
++ if (BufferIsValid(buffer))
++ MarkBufferDirty(buffer);
++
++ /* Write WAL record if needed */
++ if (relation && RelationNeedsWAL(relation) && maxoff != 0)
++ {
++ XLogRecPtr recptr;
++ xl_heap_base_shift xlrec;
++
++ xlrec.delta = delta;
++ xlrec.multi = multi;
++ xlrec.flags = 0;
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_BASE_SHIFT_ON_TOAST_RELATION;
++
++ XLogBeginInsert();
++ XLogRegisterData((char *) &xlrec, SizeOfHeapBaseShift);
++ XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
++
++ recptr = XLogInsert(RM_HEAP3_ID, XLOG_HEAP3_BASE_SHIFT);
++
++ PageSetLSN(page, recptr);
++ }
++
++ END_CRIT_SECTION();
++}
++
++/*
++ * Freeze xids in the single heap page. Useful when we can't fit new xid even
++ * with base shift.
++ */
++static void
++freeze_single_heap_page(Relation relation, Buffer buffer)
++{
++ Page page = BufferGetPage(buffer);
++ OffsetNumber offnum,
++ maxoff;
++ HeapTupleData tuple;
++ int nfrozen = 0;
++ HeapTupleFreeze *frozen;
++ TransactionId FreezeXid;
++ GlobalVisState *vistest;
++ ItemId itemid;
++ bool totally_frozen;
++ VacuumParams params = {0};
++ struct VacuumCutoffs cutoffs = {0};
++ HeapPageFreeze pagefrz;
++ PruneResult presult;
++
++ vacuum_get_cutoffs(relation, ¶ms, &cutoffs);
++ FreezeXid = cutoffs.relfrozenxid; /* ??? cutoffs.FreezeLimit; */
++ pagefrz.freeze_required = true;
++ pagefrz.FreezePageRelfrozenXid = cutoffs.FreezeLimit;
++ pagefrz.FreezePageRelminMxid = cutoffs.MultiXactCutoff;
++ pagefrz.NoFreezePageRelfrozenXid = cutoffs.FreezeLimit;
++ pagefrz.NoFreezePageRelminMxid = cutoffs.MultiXactCutoff;
++
++ vistest = GlobalVisTestFor(relation);
++
++ heap_page_prune(relation, buffer, vistest, &presult, &offnum, false);
++ if (presult.ndeleted > presult.nnewlpdead)
++ pgstat_update_heap_dead_tuples(relation,
++ presult.ndeleted - presult.nnewlpdead);
++
++ /*
++ * Now scan the page to collect vacuumable items and check for tuples
++ * requiring freezing.
++ */
++ maxoff = PageGetMaxOffsetNumber(page);
++ frozen = palloc(sizeof(HeapTupleFreeze) * MaxHeapTuplesPerPage);
++
++ /*
++ * Note: If you change anything in the loop below, also look at
++ * heap_page_is_all_visible to see if that needs to be changed.
++ */
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page,
++ IsToastRelation(relation));
++
++ /*
++ * Each non-removable tuple must be checked to see if it needs
++ * freezing. Note we already have exclusive buffer lock.
++ */
++ if (heap_prepare_freeze_tuple(&tuple, &cutoffs, &pagefrz,
++ &frozen[nfrozen], &totally_frozen))
++ frozen[nfrozen++].offset = offnum;
++ }
++
++ /*
++ * If we froze any tuples, mark the buffer dirty, and write a WAL record
++ * recording the changes. We must log the changes to be crash-safe
++ * against future truncation of CLOG.
++ */
++ if (nfrozen > 0)
++ heap_freeze_execute_prepared(relation, buffer, FreezeXid, frozen,
++ nfrozen);
++
++ pfree(frozen);
++}
++
++/*
++ * Check if xid still fits on a page with given base and delta.
++ */
++static inline bool
++is_delta_fits_heap_page(TransactionId xid, TransactionId base, int64 delta)
++{
++ return xid >= base + delta + FirstNormalTransactionId &&
++ xid <= base + delta + MaxShortTransactionId;
++}
++
++/*
++ * Check if xid fits on a page with given base.
++ */
++static inline bool
++is_xid_fits_heap_page(TransactionId xid, TransactionId base)
++{
++ return xid >= base + FirstNormalTransactionId &&
++ xid <= base + MaxShortTransactionId;
++}
++
++/*
++ * Check if delta fits on a page.
++ *
++ * If delta does not fits, never return.
++ */
++static void
++heap_page_check_delta(Buffer buffer,
++ TransactionId xid, TransactionId base,
++ ShortTransactionId min, ShortTransactionId max,
++ int64 delta, int64 *freeDelta, int64 *requiredDelta)
++{
++ BufferDesc *buf;
++ char *path;
++ BackendId backend;
++
++ Assert((freeDelta == NULL) == (requiredDelta == NULL));
++
++ /*
++ * If delta fits the page, we good to go ...
++ */
++ if (is_delta_fits_heap_page(xid, base, delta))
++ return;
++
++ /*
++ * ... otherwise handle the error.
++ */
++ if (buffer == InvalidBuffer)
++ return;
++
++ if (BufferIsLocal(buffer))
++ {
++ buf = GetLocalBufferDescriptor(-buffer - 1);
++ backend = MyBackendId;
++ }
++ else
++ {
++ buf = GetBufferDescriptor(buffer - 1);
++ backend = InvalidBackendId;
++ }
++
++ path = relpathbackend(BufTagGetRelFileLocator(&buf->tag), backend,
++ buf->tag.forkNum);
++
++ if (freeDelta == NULL)
++ elog(FATAL, "Fatal xid base calculation error: xid = %llu, base = %llu, min = %u, max = %u, delta = %lld (rel=%s, blockNum=%u)",
++ (unsigned long long) xid, (unsigned long long) base,
++ min, max,
++ (long long) delta,
++ path, buf->tag.blockNum);
++
++ elog(FATAL, "Fatal xid base calculation error: xid = %llu, base = %llu, min = %u, max = %u, freeDelta = %lld, requiredDelta = %lld, delta = %lld (rel=%s, blockNum=%u)",
++ (unsigned long long) xid, (unsigned long long) base,
++ min, max,
++ (long long) *freeDelta, (long long) *requiredDelta,
++ (long long) delta,
++ path, buf->tag.blockNum);
++}
++
++/*
++ * Shift page base.
++ */
++static void
++heap_page_apply_delta(Relation relation, Buffer buffer, Page page,
++ TransactionId xid, bool multi,
++ TransactionId base, int64 delta, bool is_toast)
++{
++ Assert(is_delta_fits_heap_page(xid, base, delta));
++
++ heap_page_shift_base(relation, buffer, page, multi, delta, is_toast);
++
++#ifdef USE_ASSERT_CHECKING
++ if (is_toast)
++ {
++ Assert(!multi);
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ }
++ else
++ base = multi ? HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ Assert(is_xid_fits_heap_page(xid, base));
++#endif /* USE_ASSERT_CHECKING */
++}
++
++/*
++ * Try to fit xid on a page.
++ */
++static int
++heap_page_try_prepare_for_xid(Relation relation, Buffer buffer, Page page,
++ TransactionId xid, bool multi, bool is_toast)
++{
++ TransactionId base;
++ ShortTransactionId min = InvalidTransactionId,
++ max = InvalidTransactionId;
++ int64 delta,
++ freeDelta,
++ requiredDelta;
++
++ if (is_toast)
++ {
++ Assert(!multi);
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ }
++ else
++ base = multi ? HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ /* If xid fits the page no action needed. */
++ if (is_xid_fits_heap_page(xid, base))
++ return 0;
++
++ /* No items on the page? */
++ if (!heap_page_xid_min_max(page, multi, &min, &max, is_toast))
++ {
++ delta = (int64) (xid - FirstNormalTransactionId) - (int64) base;
++ heap_page_check_delta(buffer, xid, base, min, max, delta, NULL, NULL);
++ heap_page_apply_delta(relation, buffer, page, xid, multi, base, delta,
++ is_toast);
++ return 0;
++ }
++
++ /* Can we just shift base on the page? */
++ if (xid < base + FirstNormalTransactionId)
++ {
++ freeDelta = MaxShortTransactionId - max;
++ requiredDelta = (base + FirstNormalTransactionId) - xid;
++ /* Shouldn't consider setting base less than 0 */
++ freeDelta = Min(freeDelta, base);
++
++ if (requiredDelta > freeDelta)
++ return -1;
++
++ delta = -(freeDelta + requiredDelta) / 2;
++ }
++ else
++ {
++ freeDelta = min - FirstNormalTransactionId;
++ requiredDelta = xid - (base + MaxShortTransactionId);
++
++ if (requiredDelta > freeDelta)
++ return -1;
++
++ delta = (freeDelta + requiredDelta) / 2;
++ }
++
++ heap_page_check_delta(buffer, xid, base, min, max,
++ delta, &freeDelta, &requiredDelta);
++ heap_page_apply_delta(relation, buffer, page, xid, multi, base,
++ delta, is_toast);
++
++ return 0;
++}
++
++static void
++heap_xlog_base_shift(XLogReaderState *record)
++{
++ XLogRecPtr lsn = record->EndRecPtr;
++ xl_heap_base_shift *xlrec = (xl_heap_base_shift *) XLogRecGetData(record);
++ Buffer buffer;
++ Page page;
++ BlockNumber blkno;
++ RelFileLocator target_node;
++
++ XLogRecGetBlockTag(record, 0, &target_node, NULL, &blkno);
++
++ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
++ {
++ page = BufferGetPage(buffer);
++ heap_page_shift_base(NULL, InvalidBuffer, page, xlrec->multi,
++ xlrec->delta,
++ xlrec->flags & XLH_BASE_SHIFT_ON_TOAST_RELATION);
++ PageSetLSN(page, lsn);
++ MarkBufferDirty(buffer);
++ }
++
++ if (BufferIsValid(buffer))
++ UnlockReleaseBuffer(buffer);
++}
++
++/*
++ * Ensure that given xid fits base of given page.
++ */
++static bool
++heap_page_prepare_for_xid(Relation relation, Buffer buffer,
++ TransactionId xid, bool multi)
++{
++ Page page = BufferGetPage(buffer);
++ int res;
++
++ /* "Double xmax" page format doesn't require any preparation */
++ if (HeapPageIsDoubleXmax(page))
++ return false;
++
++ if (!TransactionIdIsNormal(xid))
++ return false;
++
++ res = heap_page_try_prepare_for_xid(relation, buffer, page, xid, multi,
++ IsToastRelation(relation));
++ if (res != -1)
++ return res == 1;
++
++ /* Have to try freeing the page... */
++ freeze_single_heap_page(relation, buffer);
++
++ res = heap_page_try_prepare_for_xid(relation, buffer, page, xid, multi,
++ IsToastRelation(relation));
++ if (res != -1)
++ return res == 1;
++
++ elog(ERROR, "could not fit xid into page");
++
++ return false;
++}
++
++/*
++ * Ensure that given xid fits base of given page.
++ */
++void
++rewrite_page_prepare_for_xid(Page page, HeapTuple tup, bool is_toast)
++{
++ TransactionId xid;
++ int res;
++
++ /* xmin */
++ xid = HeapTupleGetXmin(tup);
++ if (TransactionIdIsNormal(xid))
++ {
++ res = heap_page_try_prepare_for_xid(NULL, InvalidBuffer, page, xid,
++ false, is_toast);
++ if (res == -1)
++ elog(ERROR, "could not fit xid into page");
++ }
++
++ /* xmax */
++ xid = HeapTupleGetRawXmax(tup);
++ if (TransactionIdIsNormal(xid))
++ {
++ res = heap_page_try_prepare_for_xid(NULL, InvalidBuffer, page, xid,
++ tup->t_data->t_infomask & HEAP_XMAX_IS_MULTI,
++ is_toast);
++ if (res == -1)
++ elog(ERROR, "could not fit xid into page");
++ }
++}
++
++void
++heap3_redo(XLogReaderState *record)
++{
++ uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
++
++ switch (info & XLOG_HEAP_OPMASK)
++ {
++ case XLOG_HEAP3_BASE_SHIFT:
++ heap_xlog_base_shift(record);
++ break;
++ default:
++ elog(PANIC, "heap3_redo: unknown op code %u", info);
++ }
++}
+diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
+index 0ed612e244..7d02aa52bb 100644
+--- a/src/backend/access/heap/heapam_handler.c
++++ b/src/backend/access/heap/heapam_handler.c
+@@ -424,7 +424,7 @@ tuple_lock_retry:
+ * changes in an existing tuple, except to invalid or
+ * frozen, and neither of those can match priorXmax.)
+ */
+- if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
++ if (!TransactionIdEquals(HeapTupleGetXmin(tuple),
+ priorXmax))
+ {
+ ReleaseBuffer(buffer);
+@@ -484,7 +484,7 @@ tuple_lock_retry:
+ * variable instead of doing HeapTupleHeaderGetXmin again.
+ */
+ if (TransactionIdIsCurrentTransactionId(priorXmax) &&
+- HeapTupleHeaderGetCmin(tuple->t_data) >= cid)
++ HeapTupleGetCmin(tuple) >= cid)
+ {
+ tmfd->xmax = priorXmax;
+
+@@ -492,7 +492,7 @@ tuple_lock_retry:
+ * Cmin is the problematic value, so store that. See
+ * above.
+ */
+- tmfd->cmax = HeapTupleHeaderGetCmin(tuple->t_data);
++ tmfd->cmax = HeapTupleGetCmin(tuple);
+ ReleaseBuffer(buffer);
+ return TM_SelfModified;
+ }
+@@ -518,7 +518,7 @@ tuple_lock_retry:
+ /*
+ * As above, if xmin isn't what we're expecting, do nothing.
+ */
+- if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
++ if (!TransactionIdEquals(HeapTupleGetXmin(tuple),
+ priorXmax))
+ {
+ ReleaseBuffer(buffer);
+@@ -549,7 +549,7 @@ tuple_lock_retry:
+ /* updated, so look at the updated row */
+ *tid = tuple->t_data->t_ctid;
+ /* updated row should have xmin matching this xmax */
+- priorXmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
++ priorXmax = HeapTupleGetUpdateXidAny(tuple);
+ ReleaseBuffer(buffer);
+ /* loop back to fetch next in chain */
+ }
+@@ -865,7 +865,7 @@ heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap,
+ * case we had better copy it.
+ */
+ if (!is_system_catalog &&
+- !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tuple->t_data)))
++ !TransactionIdIsCurrentTransactionId(HeapTupleGetXmin(tuple)))
+ elog(WARNING, "concurrent insert in progress within table \"%s\"",
+ RelationGetRelationName(OldHeap));
+ /* treat as live */
+@@ -877,7 +877,7 @@ heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap,
+ * Similar situation to INSERT_IN_PROGRESS case.
+ */
+ if (!is_system_catalog &&
+- !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple->t_data)))
++ !TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(tuple)))
+ elog(WARNING, "concurrent delete in progress within table \"%s\"",
+ RelationGetRelationName(OldHeap));
+ /* treat as recently dead */
+@@ -1062,6 +1062,8 @@ heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin,
+ targtuple->t_tableOid = RelationGetRelid(scan->rs_rd);
+ targtuple->t_data = (HeapTupleHeader) PageGetItem(targpage, itemid);
+ targtuple->t_len = ItemIdGetLength(itemid);
++ HeapTupleCopyXidsFromPage(hscan->rs_cbuf, targtuple, targpage,
++ IsToastRelation(scan->rs_rd));
+
+ switch (HeapTupleSatisfiesVacuum(targtuple, OldestXmin,
+ hscan->rs_cbuf))
+@@ -1097,7 +1099,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin,
+ * numbers we report to the cumulative stats system to make
+ * this come out right.)
+ */
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(targtuple->t_data)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetXmin(targtuple)))
+ {
+ sample_it = true;
+ *liverows += 1;
+@@ -1128,7 +1130,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin,
+ * but not the post-image. We also get sane results if the
+ * concurrent transaction never commits.
+ */
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(targtuple->t_data)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(targtuple)))
+ *deadrows += 1;
+ else
+ {
+@@ -1377,7 +1379,8 @@ heapam_index_build_range_scan(Relation heapRelation,
+ Page page = BufferGetPage(hscan->rs_cbuf);
+
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
+- heap_get_root_tuples(page, root_offsets);
++ heap_get_root_tuples(heapRelation, hscan->rs_cbuf, page,
++ root_offsets);
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+
+ root_blkno = hscan->rs_cblock;
+@@ -1470,7 +1473,7 @@ heapam_index_build_range_scan(Relation heapRelation,
+ * before commit there. Give a warning if neither case
+ * applies.
+ */
+- xwait = HeapTupleHeaderGetXmin(heapTuple->t_data);
++ xwait = HeapTupleGetXmin(heapTuple);
+ if (!TransactionIdIsCurrentTransactionId(xwait))
+ {
+ if (!is_system_catalog)
+@@ -1529,7 +1532,7 @@ heapam_index_build_range_scan(Relation heapRelation,
+ break;
+ }
+
+- xwait = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
++ xwait = HeapTupleGetUpdateXidAny(heapTuple);
+ if (!TransactionIdIsCurrentTransactionId(xwait))
+ {
+ if (!is_system_catalog)
+@@ -1674,7 +1677,8 @@ heapam_index_build_range_scan(Relation heapRelation,
+ Page page = BufferGetPage(hscan->rs_cbuf);
+
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
+- heap_get_root_tuples(page, root_offsets);
++ heap_get_root_tuples(heapRelation, hscan->rs_cbuf, page,
++ root_offsets);
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+ }
+
+@@ -1840,7 +1844,8 @@ heapam_index_validate_scan(Relation heapRelation,
+ Page page = BufferGetPage(hscan->rs_cbuf);
+
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
+- heap_get_root_tuples(page, root_offsets);
++ heap_get_root_tuples(heapRelation, hscan->rs_cbuf, page,
++ root_offsets);
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+
+ memset(in_index, 0, sizeof(in_index));
+@@ -2180,7 +2185,12 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
+ ItemPointerSet(&tid, block, offnum);
+ if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot,
+ &heapTuple, NULL, true))
+- hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
++ {
++ hscan->rs_vistuples[ntup] = ItemPointerGetOffsetNumber(&tid);
++ hscan->rs_xmin[ntup] = heapTuple.t_xmin;
++ hscan->rs_xmax[ntup] = heapTuple.t_xmax;
++ ++ntup;
++ }
+ }
+ }
+ else
+@@ -2205,13 +2215,18 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
+ loctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ loctup.t_len = ItemIdGetLength(lp);
+ loctup.t_tableOid = scan->rs_rd->rd_id;
++ HeapTupleCopyXidsFromPage(hscan->rs_cbuf, &loctup, page,
++ IsToastRelation(scan->rs_rd));
+ ItemPointerSet(&loctup.t_self, block, offnum);
+ valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
+ if (valid)
+ {
+- hscan->rs_vistuples[ntup++] = offnum;
++ hscan->rs_vistuples[ntup] = offnum;
++ hscan->rs_xmin[ntup] = loctup.t_xmin;
++ hscan->rs_xmax[ntup] = loctup.t_xmax;
++ ++ntup;
+ PredicateLockTID(scan->rs_rd, &loctup.t_self, snapshot,
+- HeapTupleHeaderGetXmin(loctup.t_data));
++ HeapTupleGetXmin(&loctup));
+ }
+ HeapCheckForSerializableConflictOut(valid, scan->rs_rd, &loctup,
+ buffer, snapshot);
+@@ -2250,6 +2265,8 @@ heapam_scan_bitmap_next_tuple(TableScanDesc scan,
+ hscan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ hscan->rs_ctup.t_len = ItemIdGetLength(lp);
+ hscan->rs_ctup.t_tableOid = scan->rs_rd->rd_id;
++ hscan->rs_ctup.t_xmin = hscan->rs_xmin[hscan->rs_cindex];
++ hscan->rs_ctup.t_xmax = hscan->rs_xmax[hscan->rs_cindex];
+ ItemPointerSet(&hscan->rs_ctup.t_self, hscan->rs_cblock, targoffset);
+
+ pgstat_count_heap_fetch(scan->rs_rd);
+@@ -2390,8 +2407,17 @@ heapam_scan_sample_next_tuple(TableScanDesc scan, SampleScanState *scanstate,
+
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple->t_len = ItemIdGetLength(itemid);
+- ItemPointerSet(&(tuple->t_self), blockno, tupoffset);
+
++ if (pagemode)
++ {
++ tuple->t_xmin = InvalidTransactionId;
++ tuple->t_xmax = InvalidTransactionId;
++ }
++ else
++ HeapTupleCopyXidsFromPage(hscan->rs_cbuf, tuple, page,
++ IsToastRelation(scan->rs_rd));
++
++ ItemPointerSet(&(tuple->t_self), blockno, tupoffset);
+
+ if (all_visible)
+ visible = true;
+diff --git a/src/backend/access/heap/heapam_visibility.c b/src/backend/access/heap/heapam_visibility.c
+index a716001341..26fa51e6eb 100644
+--- a/src/backend/access/heap/heapam_visibility.c
++++ b/src/backend/access/heap/heapam_visibility.c
+@@ -220,7 +220,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return true;
+@@ -232,7 +232,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -244,7 +244,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ return false;
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -254,11 +254,11 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+
+ return false;
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ return false;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -287,7 +287,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -302,17 +302,17 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ return true;
+ }
+
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+ return false;
+ }
+
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return true;
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -330,7 +330,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ }
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ return false;
+ }
+
+@@ -419,7 +419,7 @@ HeapTupleSatisfiesToast(HeapTuple htup, Snapshot snapshot,
+ * is canceled by super-deleting the tuple. This also applies to
+ * TOAST tuples created during speculative insertion.
+ */
+- else if (!TransactionIdIsValid(HeapTupleHeaderGetXmin(tuple)))
++ else if (!TransactionIdIsValid(HeapTupleGetXmin(htup)))
+ return false;
+ }
+
+@@ -509,9 +509,9 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+- if (HeapTupleHeaderGetCmin(tuple) >= curcid)
++ if (HeapTupleGetCmin(htup) >= curcid)
+ return TM_Invisible; /* inserted after scan started */
+
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+@@ -521,7 +521,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleHeaderGetRawXmax(tuple);
++ xmax = HeapTupleGetRawXmax(htup);
+
+ /*
+ * Careful here: even though this tuple was created by our own
+@@ -552,7 +552,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -560,21 +560,21 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ /* deleting subtransaction must have aborted */
+ if (!TransactionIdIsCurrentTransactionId(xmax))
+ {
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple),
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup),
+ false))
+ return TM_BeingModified;
+ return TM_Ok;
+ }
+ else
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -582,16 +582,16 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ return TM_Ok;
+ }
+
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ return TM_Invisible;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -625,17 +625,17 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ {
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), true))
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), true))
+ return TM_BeingModified;
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
+ return TM_Ok;
+ }
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+ if (!TransactionIdIsValid(xmax))
+ {
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ return TM_BeingModified;
+ }
+
+@@ -644,13 +644,13 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+
+ if (TransactionIdIsCurrentTransactionId(xmax))
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ return TM_BeingModified;
+
+ if (TransactionIdDidCommit(xmax))
+@@ -666,7 +666,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ * what about the other members?
+ */
+
+- if (!MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ if (!MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ {
+ /*
+ * There's no member, even just a locker, alive anymore, so we can
+@@ -683,20 +683,20 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ }
+ }
+
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return TM_BeingModified;
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return TM_BeingModified;
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -714,7 +714,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ }
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ if (!ItemPointerEquals(&htup->t_self, &tuple->t_ctid))
+ return TM_Updated; /* updated by other */
+ else
+@@ -797,7 +797,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return true;
+@@ -809,7 +809,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -821,7 +821,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ return false;
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -831,7 +831,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+
+ return false;
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ {
+ /*
+ * Return the speculative token to caller. Caller can worry about
+@@ -847,13 +847,13 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ Assert(snapshot->speculativeToken != 0);
+ }
+
+- snapshot->xmin = HeapTupleHeaderGetRawXmin(tuple);
++ snapshot->xmin = HeapTupleGetRawXmin(htup);
+ /* XXX shouldn't we fall through to look at xmax? */
+ return true; /* in insertion by other */
+ }
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -882,7 +882,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -900,21 +900,21 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ return true;
+ }
+
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+ return false;
+ }
+
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ {
+ if (!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+- snapshot->xmax = HeapTupleHeaderGetRawXmax(tuple);
++ snapshot->xmax = HeapTupleGetRawXmax(htup);
+ return true;
+ }
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -932,7 +932,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ }
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ return false; /* updated by other */
+ }
+
+@@ -1011,9 +1011,9 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+- if (HeapTupleHeaderGetCmin(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmin(htup) >= snapshot->curcid)
+ return false; /* inserted after scan started */
+
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+@@ -1026,7 +1026,7 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -1034,13 +1034,13 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ /* updating subtransaction must have aborted */
+ if (!TransactionIdIsCurrentTransactionId(xmax))
+ return true;
+- else if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ else if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* updated after scan started */
+ else
+ return false; /* updated before scan started */
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -1048,16 +1048,16 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ return true;
+ }
+
+- if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* deleted after scan started */
+ else
+ return false; /* deleted before scan started */
+ }
+- else if (XidInMVCCSnapshot(HeapTupleHeaderGetRawXmin(tuple), snapshot))
++ else if (XidInMVCCSnapshot(HeapTupleGetRawXmin(htup), snapshot))
+ return false;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -1070,7 +1070,7 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ {
+ /* xmin is committed, but maybe not according to our snapshot */
+ if (!HeapTupleHeaderXminFrozen(tuple) &&
+- XidInMVCCSnapshot(HeapTupleHeaderGetRawXmin(tuple), snapshot))
++ XidInMVCCSnapshot(HeapTupleGetRawXmin(htup), snapshot))
+ return false; /* treat as still in progress */
+ }
+
+@@ -1089,14 +1089,14 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ /* already checked above */
+ Assert(!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask));
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+
+ if (TransactionIdIsCurrentTransactionId(xmax))
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* deleted after scan started */
+ else
+ return false; /* deleted before scan started */
+@@ -1111,18 +1111,18 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+
+ if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
+ {
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* deleted after scan started */
+ else
+ return false; /* deleted before scan started */
+ }
+
+- if (XidInMVCCSnapshot(HeapTupleHeaderGetRawXmax(tuple), snapshot))
++ if (XidInMVCCSnapshot(HeapTupleGetRawXmax(htup), snapshot))
+ return true;
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -1132,12 +1132,12 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+
+ /* xmax transaction committed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ }
+ else
+ {
+ /* xmax is committed, but maybe not according to our snapshot */
+- if (XidInMVCCSnapshot(HeapTupleHeaderGetRawXmax(tuple), snapshot))
++ if (XidInMVCCSnapshot(HeapTupleGetRawXmax(htup), snapshot))
+ return true; /* treat as still in progress */
+ }
+
+@@ -1252,21 +1252,21 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ return HEAPTUPLE_DEAD;
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ /* only locked? run infomask-only check first, for performance */
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask) ||
+- HeapTupleHeaderIsOnlyLocked(tuple))
++ HeapTupleIsOnlyLocked(htup))
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ /* inserted and then deleted by same xact */
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(htup)))
+ return HEAPTUPLE_DELETE_IN_PROGRESS;
+ /* deleting subtransaction must have aborted */
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ {
+ /*
+ * It'd be possible to discern between INSERT/DELETE in progress
+@@ -1278,9 +1278,9 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ */
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ }
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /*
+@@ -1322,14 +1322,14 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ * possibly be running; otherwise have to check.
+ */
+ if (!HEAP_LOCKED_UPGRADED(tuple->t_infomask) &&
+- MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple),
++ MultiXactIdIsRunning(HeapTupleGetRawXmax(htup),
+ true))
+ return HEAPTUPLE_LIVE;
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
+ }
+ else
+ {
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return HEAPTUPLE_LIVE;
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+ InvalidTransactionId);
+@@ -1347,7 +1347,7 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+
+ if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
+ {
+- TransactionId xmax = HeapTupleGetUpdateXid(tuple);
++ TransactionId xmax = HeapTupleGetUpdateXid(htup);
+
+ /* already checked above */
+ Assert(!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask));
+@@ -1370,7 +1370,7 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ *dead_after = xmax;
+ return HEAPTUPLE_RECENTLY_DEAD;
+ }
+- else if (!MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ else if (!MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ {
+ /*
+ * Not in Progress, Not Committed, so either Aborted or crashed.
+@@ -1384,11 +1384,11 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+
+ if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
+ {
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return HEAPTUPLE_DELETE_IN_PROGRESS;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ else
+ {
+ /*
+@@ -1410,7 +1410,7 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ * Deleter committed, allow caller to check if it was recent enough that
+ * some open transactions could still see the tuple.
+ */
+- *dead_after = HeapTupleHeaderGetRawXmax(tuple);
++ *dead_after = HeapTupleGetRawXmax(htup);
+ return HEAPTUPLE_RECENTLY_DEAD;
+ }
+
+@@ -1506,7 +1506,7 @@ HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
+
+ /* Deleter committed, so tuple is dead if the XID is old enough. */
+ return GlobalVisTestIsRemovableXid(vistest,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ }
+
+ /*
+@@ -1519,8 +1519,9 @@ HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
+ * at the top of this file.
+ */
+ bool
+-HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
++HeapTupleIsOnlyLocked(HeapTuple htup)
+ {
++ HeapTupleHeader tuple = htup->t_data;
+ TransactionId xmax;
+
+ /* if there's no valid Xmax, then there's obviously no update either */
+@@ -1531,7 +1532,7 @@ HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
+ return true;
+
+ /* invalid xmax means no update */
+- if (!TransactionIdIsValid(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsValid(HeapTupleGetRawXmax(htup)))
+ return true;
+
+ /*
+@@ -1542,7 +1543,7 @@ HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
+ return false;
+
+ /* ... but if it's a multi, then perhaps the updating Xid aborted. */
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -1590,8 +1591,8 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
+ Buffer buffer)
+ {
+ HeapTupleHeader tuple = htup->t_data;
+- TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
+- TransactionId xmax = HeapTupleHeaderGetRawXmax(tuple);
++ TransactionId xmin = HeapTupleGetXmin(htup);
++ TransactionId xmax = HeapTupleGetRawXmax(htup);
+
+ Assert(ItemPointerIsValid(&htup->t_self));
+ Assert(htup->t_tableOid != InvalidOid);
+@@ -1691,7 +1692,7 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
+ */
+ else if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
+ {
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+ }
+
+ /* check if it's one of our txids, toplevel is also in there */
+diff --git a/src/backend/access/heap/heaptoast.c b/src/backend/access/heap/heaptoast.c
+index 52ecd45654..3d0e62ba64 100644
+--- a/src/backend/access/heap/heaptoast.c
++++ b/src/backend/access/heap/heaptoast.c
+@@ -307,6 +307,7 @@ heap_toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup,
+ result_tuple->t_len = new_tuple_len;
+ result_tuple->t_self = newtup->t_self;
+ result_tuple->t_tableOid = newtup->t_tableOid;
++ HeapTupleCopyXids(result_tuple, newtup);
+ new_data = (HeapTupleHeader) ((char *) result_tuple + HEAPTUPLESIZE);
+ result_tuple->t_data = new_data;
+
+@@ -395,6 +396,7 @@ toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)
+ */
+ new_tuple->t_self = tup->t_self;
+ new_tuple->t_tableOid = tup->t_tableOid;
++ HeapTupleCopyXids(new_tuple, tup);
+
+ new_tuple->t_data->t_choice = tup->t_data->t_choice;
+ new_tuple->t_data->t_ctid = tup->t_data->t_ctid;
+@@ -467,6 +469,7 @@ toast_flatten_tuple_to_datum(HeapTupleHeader tup,
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
+ tmptup.t_data = tup;
++ HeapTupleSetZeroXids(&tmptup);
+
+ /*
+ * Break down the tuple into fields.
+diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c
+index ccc4c6966a..9e6a0a3d5d 100644
+--- a/src/backend/access/heap/hio.c
++++ b/src/backend/access/heap/hio.c
+@@ -19,6 +19,7 @@
+ #include "access/hio.h"
+ #include "access/htup_details.h"
+ #include "access/visibilitymap.h"
++#include "catalog/catalog.h"
+ #include "storage/bufmgr.h"
+ #include "storage/freespace.h"
+ #include "storage/lmgr.h"
+@@ -59,6 +60,9 @@ RelationPutHeapTuple(Relation relation,
+ /* Add the tuple to the page */
+ pageHeader = BufferGetPage(buffer);
+
++ HeapTupleHeaderStoreXmin(pageHeader, tuple, IsToastRelation(relation));
++ HeapTupleHeaderStoreXmax(pageHeader, tuple, IsToastRelation(relation));
++
+ offnum = PageAddItem(pageHeader, (Item) tuple->t_data,
+ tuple->t_len, InvalidOffsetNumber, false, true);
+
+@@ -361,7 +365,17 @@ RelationAddBlocks(Relation relation, BulkInsertState bistate,
+ first_block,
+ RelationGetRelationName(relation));
+
+- PageInit(page, BufferGetPageSize(buffer), 0);
++ if (IsToastRelation(relation))
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++ else
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(HeapPageSpecialData));
++ HeapPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++
+ MarkBufferDirty(buffer);
+
+ /*
+@@ -394,7 +408,7 @@ RelationAddBlocks(Relation relation, BulkInsertState bistate,
+ if (use_fsm && i >= not_in_fsm_pages)
+ {
+ Size freespace = BufferGetPageSize(victim_buffers[i]) -
+- SizeOfPageHeaderData;
++ SizeOfPageHeaderData - MAXALIGN(sizeof(HeapPageSpecialData));
+
+ RecordPageWithFreeSpace(relation, curBlock, freespace);
+ }
+@@ -685,6 +699,9 @@ loop:
+ /*
+ * Now we can check to see if there's enough free space here. If so,
+ * we're done.
++ *
++ * "Double xmax" page is not suitable for any new tuple, since xmin
++ * can't be set there.
+ */
+ page = BufferGetPage(buffer);
+
+@@ -696,12 +713,23 @@ loop:
+ */
+ if (PageIsNew(page))
+ {
+- PageInit(page, BufferGetPageSize(buffer), 0);
++ if (IsToastRelation(relation))
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++ else
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(HeapPageSpecialData));
++ HeapPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++
+ MarkBufferDirty(buffer);
+ }
+
+ pageFreeSpace = PageGetHeapFreeSpace(page);
+- if (targetFreeSpace <= pageFreeSpace)
++ if (targetFreeSpace <= pageFreeSpace &&
++ !HeapPageIsDoubleXmax(page))
+ {
+ /* use this page as future insert target, too */
+ RelationSetTargetBlock(relation, targetBlock);
+diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c
+index c5f1abd95a..9ab46bfc31 100644
+--- a/src/backend/access/heap/pruneheap.c
++++ b/src/backend/access/heap/pruneheap.c
+@@ -70,6 +70,17 @@ static void heap_prune_record_dead(PruneState *prstate, OffsetNumber offnum);
+ static void heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum);
+ static void page_verify_redirects(Page page);
+
++static inline bool
++XidFitsPage(Page page, TransactionId xid, bool is_toast)
++{
++ TransactionId base;
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ return xid >= base + FirstNormalTransactionId &&
++ xid <= base + MaxShortTransactionId;
++}
+
+ /*
+ * Optionally prune and repair fragmentation in the specified page.
+@@ -104,7 +115,8 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
+ * determining the appropriate horizon is a waste if there's no prune_xid
+ * (i.e. no updates/deletes left potentially dead tuples around).
+ */
+- prune_xid = ((PageHeader) page)->pd_prune_xid;
++ prune_xid = HeapPageGetPruneXidNoAssert(page, IsToastRelation(relation));
++
+ if (!TransactionIdIsValid(prune_xid))
+ return;
+
+@@ -148,7 +160,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
+ {
+ PruneResult presult;
+
+- heap_page_prune(relation, buffer, vistest, &presult, NULL);
++ heap_page_prune(relation, buffer, vistest, &presult, NULL, false);
+
+ /*
+ * Report the number of tuples reclaimed to pgstats. This is
+@@ -204,7 +216,8 @@ void
+ heap_page_prune(Relation relation, Buffer buffer,
+ GlobalVisState *vistest,
+ PruneResult *presult,
+- OffsetNumber *off_loc)
++ OffsetNumber *off_loc,
++ bool repairFragmentation)
+ {
+ Page page = BufferGetPage(buffer);
+ BlockNumber blockno = BufferGetBlockNumber(buffer);
+@@ -278,6 +291,8 @@ heap_page_prune(Relation relation, Buffer buffer,
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
+ tup.t_data = htup;
+ tup.t_len = ItemIdGetLength(itemid);
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+ ItemPointerSet(&(tup.t_self), blockno, offnum);
+
+ /*
+@@ -333,13 +348,17 @@ heap_page_prune(Relation relation, Buffer buffer,
+ heap_page_prune_execute(buffer,
+ prstate.redirected, prstate.nredirected,
+ prstate.nowdead, prstate.ndead,
+- prstate.nowunused, prstate.nunused);
++ prstate.nowunused, prstate.nunused,
++ repairFragmentation,
++ IsToastRelation(relation));
+
+ /*
+ * Update the page's pd_prune_xid field to either zero, or the lowest
+ * XID of any soon-prunable tuple.
+ */
+- ((PageHeader) page)->pd_prune_xid = prstate.new_prune_xid;
++ if (XidFitsPage(page, prstate.new_prune_xid, IsToastRelation(relation)))
++ HeapPageSetPruneXid(page, prstate.new_prune_xid,
++ IsToastRelation(relation));
+
+ /*
+ * Also clear the "page is full" flag, since there's no point in
+@@ -362,6 +381,13 @@ heap_page_prune(Relation relation, Buffer buffer,
+ xlrec.snapshotConflictHorizon = prstate.snapshotConflictHorizon;
+ xlrec.nredirected = prstate.nredirected;
+ xlrec.ndead = prstate.ndead;
++ xlrec.flags = 0;
++
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_PRUNE_ON_TOAST_RELATION;
++
++ if (repairFragmentation)
++ xlrec.flags |= XLH_PRUNE_REPAIR_FRAGMENTATION;
+
+ XLogBeginInsert();
+ XLogRegisterData((char *) &xlrec, SizeOfHeapPrune);
+@@ -402,10 +428,12 @@ heap_page_prune(Relation relation, Buffer buffer,
+ * point in repeating the prune/defrag process until something else
+ * happens to the page.
+ */
+- if (((PageHeader) page)->pd_prune_xid != prstate.new_prune_xid ||
++ bool is_toast = IsToastRelation(relation);
++
++ if (HeapPageGetPruneXid(page, is_toast) != prstate.new_prune_xid ||
+ PageIsFull(page))
+ {
+- ((PageHeader) page)->pd_prune_xid = prstate.new_prune_xid;
++ HeapPageSetPruneXid(page, prstate.new_prune_xid, is_toast);
+ PageClearFull(page);
+ MarkBufferDirtyHint(buffer, true);
+ }
+@@ -485,6 +513,9 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum,
+ OffsetNumber chainitems[MaxHeapTuplesPerPage];
+ int nchain = 0,
+ i;
++ HeapTupleData tup;
++
++ tup.t_tableOid = RelationGetRelid(prstate->rel);
+
+ rootlp = PageGetItemId(dp, rootoffnum);
+
+@@ -496,6 +527,12 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum,
+ Assert(htsv[rootoffnum] != -1);
+ htup = (HeapTupleHeader) PageGetItem(dp, rootlp);
+
++ tup.t_data = htup;
++ tup.t_len = ItemIdGetLength(rootlp);
++ ItemPointerSet(&(tup.t_self), BufferGetBlockNumber(buffer), rootoffnum);
++ HeapTupleCopyXidsFromPage(buffer, &tup, dp,
++ IsToastRelation(prstate->rel));
++
+ if (HeapTupleHeaderIsHeapOnly(htup))
+ {
+ /*
+@@ -520,7 +557,7 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum,
+ !HeapTupleHeaderIsHotUpdated(htup))
+ {
+ heap_prune_record_unused(prstate, rootoffnum);
+- HeapTupleHeaderAdvanceConflictHorizon(htup,
++ HeapTupleHeaderAdvanceConflictHorizon(&tup,
+ &prstate->snapshotConflictHorizon);
+ ndeleted++;
+ }
+@@ -586,11 +623,17 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum,
+ Assert(ItemIdIsNormal(lp));
+ htup = (HeapTupleHeader) PageGetItem(dp, lp);
+
++ tup.t_data = htup;
++ tup.t_len = ItemIdGetLength(lp);
++ HeapTupleCopyXidsFromPage(buffer, &tup, dp,
++ IsToastRelation(prstate->rel));
++ ItemPointerSet(&(tup.t_self), BufferGetBlockNumber(buffer), offnum);
++
+ /*
+ * Check the tuple XMIN against prior XMAX, if any
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(HeapTupleHeaderGetXmin(htup), priorXmax))
++ !TransactionIdEquals(HeapTupleGetXmin(&tup), priorXmax))
+ break;
+
+ /*
+@@ -617,7 +660,7 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum,
+ * that the page is reconsidered for pruning in future.
+ */
+ heap_prune_record_prunable(prstate,
+- HeapTupleHeaderGetUpdateXid(htup));
++ HeapTupleGetUpdateXidAny(&tup));
+ break;
+
+ case HEAPTUPLE_DELETE_IN_PROGRESS:
+@@ -627,7 +670,7 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum,
+ * that the page is reconsidered for pruning in future.
+ */
+ heap_prune_record_prunable(prstate,
+- HeapTupleHeaderGetUpdateXid(htup));
++ HeapTupleGetUpdateXidAny(&tup));
+ break;
+
+ case HEAPTUPLE_LIVE:
+@@ -656,7 +699,7 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum,
+ if (tupdead)
+ {
+ latestdead = offnum;
+- HeapTupleHeaderAdvanceConflictHorizon(htup,
++ HeapTupleHeaderAdvanceConflictHorizon(&tup,
+ &prstate->snapshotConflictHorizon);
+ }
+ else if (!recent_dead)
+@@ -678,7 +721,7 @@ heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum,
+ Assert(ItemPointerGetBlockNumber(&htup->t_ctid) ==
+ BufferGetBlockNumber(buffer));
+ offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ priorXmax = HeapTupleGetUpdateXidAny(&tup);
+ }
+
+ /*
+@@ -795,7 +838,9 @@ void
+ heap_page_prune_execute(Buffer buffer,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *nowdead, int ndead,
+- OffsetNumber *nowunused, int nunused)
++ OffsetNumber *nowunused, int nunused,
++ bool repairFragmentation,
++ bool is_toast)
+ {
+ Page page = (Page) BufferGetPage(buffer);
+ OffsetNumber *offnum;
+@@ -919,7 +964,8 @@ heap_page_prune_execute(Buffer buffer,
+ * Finally, repair any fragmentation, and update the page's hint bit about
+ * whether it has free pointers.
+ */
+- PageRepairFragmentation(page);
++ if (repairFragmentation)
++ PageRepairFragmentation(page, is_toast);
+
+ /*
+ * Now that the page has been modified, assert that redirect items still
+@@ -991,7 +1037,8 @@ page_verify_redirects(Page page)
+ * and reused by a completely unrelated tuple.
+ */
+ void
+-heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
++heap_get_root_tuples(Relation relation, Buffer buffer, Page page,
++ OffsetNumber *root_offsets)
+ {
+ OffsetNumber offnum,
+ maxoff;
+@@ -1006,6 +1053,7 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ HeapTupleHeader htup;
+ OffsetNumber nextoffnum;
+ TransactionId priorXmax;
++ HeapTupleData tup;
+
+ /* skip unused and dead items */
+ if (!ItemIdIsUsed(lp) || ItemIdIsDead(lp))
+@@ -1014,6 +1062,9 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ if (ItemIdIsNormal(lp))
+ {
+ htup = (HeapTupleHeader) PageGetItem(page, lp);
++ tup.t_data = htup;
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+
+ /*
+ * Check if this tuple is part of a HOT-chain rooted at some other
+@@ -1035,7 +1086,7 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+
+ /* Set up to scan the HOT-chain */
+ nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ priorXmax = HeapTupleGetUpdateXidAny(&tup);
+ }
+ else
+ {
+@@ -1074,9 +1125,12 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ break;
+
+ htup = (HeapTupleHeader) PageGetItem(page, lp);
++ tup.t_data = htup;
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(htup)))
++ !TransactionIdEquals(priorXmax, HeapTupleGetXmin(&tup)))
+ break;
+
+ /* Remember the root line pointer for this item */
+@@ -1090,7 +1144,7 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ Assert(!HeapTupleHeaderIndicatesMovedPartitions(htup));
+
+ nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ priorXmax = HeapTupleGetUpdateXidAny(&tup);
+ }
+ }
+ }
+diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
+index 424958912c..2b485cdc72 100644
+--- a/src/backend/access/heap/rewriteheap.c
++++ b/src/backend/access/heap/rewriteheap.c
+@@ -378,6 +378,7 @@ rewrite_heap_tuple(RewriteState state,
+ &old_tuple->t_data->t_choice.t_heap,
+ sizeof(HeapTupleFields));
+
++ HeapTupleCopyXids(new_tuple, old_tuple);
+ new_tuple->t_data->t_infomask &= ~HEAP_XACT_MASK;
+ new_tuple->t_data->t_infomask2 &= ~HEAP2_XACT_MASK;
+ new_tuple->t_data->t_infomask |=
+@@ -387,7 +388,7 @@ rewrite_heap_tuple(RewriteState state,
+ * While we have our hands on the tuple, we may as well freeze any
+ * eligible xmin or xmax, so that future VACUUM effort can be saved.
+ */
+- heap_freeze_tuple(new_tuple->t_data,
++ heap_freeze_tuple(new_tuple,
+ state->rs_old_rel->rd_rel->relfrozenxid,
+ state->rs_old_rel->rd_rel->relminmxid,
+ state->rs_freeze_xid,
+@@ -403,7 +404,7 @@ rewrite_heap_tuple(RewriteState state,
+ * If the tuple has been updated, check the old-to-new mapping hash table.
+ */
+ if (!((old_tuple->t_data->t_infomask & HEAP_XMAX_INVALID) ||
+- HeapTupleHeaderIsOnlyLocked(old_tuple->t_data)) &&
++ HeapTupleIsOnlyLocked(old_tuple)) &&
+ !HeapTupleHeaderIndicatesMovedPartitions(old_tuple->t_data) &&
+ !(ItemPointerEquals(&(old_tuple->t_self),
+ &(old_tuple->t_data->t_ctid))))
+@@ -411,7 +412,7 @@ rewrite_heap_tuple(RewriteState state,
+ OldToNewMapping mapping;
+
+ memset(&hashkey, 0, sizeof(hashkey));
+- hashkey.xmin = HeapTupleHeaderGetUpdateXid(old_tuple->t_data);
++ hashkey.xmin = HeapTupleGetUpdateXidAny(old_tuple);
+ hashkey.tid = old_tuple->t_data->t_ctid;
+
+ mapping = (OldToNewMapping)
+@@ -484,7 +485,7 @@ rewrite_heap_tuple(RewriteState state,
+ * RECENTLY_DEAD if and only if the xmin is not before OldestXmin.
+ */
+ if ((new_tuple->t_data->t_infomask & HEAP_UPDATED) &&
+- !TransactionIdPrecedes(HeapTupleHeaderGetXmin(new_tuple->t_data),
++ !TransactionIdPrecedes(HeapTupleGetXmin(new_tuple),
+ state->rs_oldest_xmin))
+ {
+ /*
+@@ -493,7 +494,7 @@ rewrite_heap_tuple(RewriteState state,
+ UnresolvedTup unresolved;
+
+ memset(&hashkey, 0, sizeof(hashkey));
+- hashkey.xmin = HeapTupleHeaderGetXmin(new_tuple->t_data);
++ hashkey.xmin = HeapTupleGetXmin(new_tuple);
+ hashkey.tid = old_tid;
+
+ unresolved = hash_search(state->rs_unresolved_tups, &hashkey,
+@@ -581,7 +582,7 @@ rewrite_heap_dead_tuple(RewriteState state, HeapTuple old_tuple)
+ bool found;
+
+ memset(&hashkey, 0, sizeof(hashkey));
+- hashkey.xmin = HeapTupleHeaderGetXmin(old_tuple->t_data);
++ hashkey.xmin = HeapTupleGetXmin(old_tuple);
+ hashkey.tid = old_tuple->t_self;
+
+ unresolved = hash_search(state->rs_unresolved_tups, &hashkey,
+@@ -617,6 +618,8 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
+ Size len;
+ OffsetNumber newoff;
+ HeapTuple heaptup;
++ TransactionId xmin;
++ bool immutable_tuple;
+
+ /*
+ * If the new tuple is too big for storage or contains already toasted
+@@ -651,9 +654,19 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
+ len = MAXALIGN(heaptup->t_len); /* be conservative */
+
+ /*
+- * If we're gonna fail for oversize tuple, do it right away
++ * Due to update to 64-xid maximum plain tuple size was decreased due to adding
++ * PageSpecial to a heap page. Pages with tuple that became too large to fit,
++ * should remain in Double Xmax format (read only). Inserting plain tuples with
++ * size over new MaxHeapTupleSizs is prohibited anyway, but vaccum full will
++ * transfer this page to a rebuild relation unmodified.
+ */
+- if (len > MaxHeapTupleSize)
++ immutable_tuple = len <= MaxHeapTupleSize_32 && len > MaxHeapTupleSize;
++
++ /*
++ * If we're gonna fail for oversize tuple, do it right away. But allow to process
++ * immutable_tuple (see above).
++ */
++ if (len > MaxHeapTupleSize && !immutable_tuple)
+ ereport(ERROR,
+ (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+ errmsg("row is too big: size %zu, maximum size %zu",
+@@ -702,10 +715,42 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
+ if (!state->rs_buffer_valid)
+ {
+ /* Initialize a new empty page */
+- PageInit(page, BLCKSZ, 0);
++ if (immutable_tuple)
++ /* Initialize DoubleXmax page */
++ PageInit(page, BLCKSZ, 0);
++ else
++ {
++ Size special_size;
++
++ special_size = IsToastRelation(state->rs_new_rel) ?
++ sizeof(ToastPageSpecialData) :
++ sizeof(HeapPageSpecialData);
++ PageInit(page, BLCKSZ, special_size);
++ }
+ state->rs_buffer_valid = true;
+ }
+
++ rewrite_page_prepare_for_xid(page, heaptup,
++ IsToastRelation(state->rs_new_rel));
++
++ /*
++ * Tuple with HEAP_XMIN_FROZEN in t_infomask should have xmin set
++ * to FrozenTransactionId to avoid these tuples be treated like normal.
++ */
++ xmin = HeapTupleGetXmin(heaptup);
++ HeapTupleSetXmin(heaptup, xmin);
++
++ /*
++ * Tuples on DoubleXmax page could not appear modified after they had been
++ * frozen by pg_upgrade. Just check this to be safe.
++ */
++ Assert(!immutable_tuple || xmin == FrozenTransactionId);
++
++ if (!immutable_tuple)
++ HeapTupleAndHeaderSetXmin(page, heaptup, xmin, false);
++
++ HeapTupleHeaderStoreXmax(page, heaptup, false);
++
+ /* And now we can insert the tuple into the page */
+ newoff = PageAddItem(page, (Item) heaptup->t_data, heaptup->t_len,
+ InvalidOffsetNumber, false, true);
+@@ -986,19 +1031,24 @@ logical_rewrite_log_mapping(RewriteState state, TransactionId xid,
+ */
+ if (!found)
+ {
+- char path[MAXPGPATH];
+- Oid dboid;
++ char path[MAXPGPATH];
++ Oid dboid;
++ TransactionId current_xid;
+
+ if (state->rs_old_rel->rd_rel->relisshared)
+ dboid = InvalidOid;
+ else
+ dboid = MyDatabaseId;
+
++ current_xid = GetCurrentTransactionId();
+ snprintf(path, MAXPGPATH,
+ "pg_logical/mappings/" LOGICAL_REWRITE_FORMAT,
+ dboid, relid,
+ LSN_FORMAT_ARGS(state->rs_begin_lsn),
+- xid, GetCurrentTransactionId());
++ (uint32) (xid >> 32),
++ (uint32) xid,
++ (uint32) (current_xid >> 32),
++ (uint32) current_xid);
+
+ dclist_init(&src->mappings);
+ src->off = 0;
+@@ -1045,9 +1095,9 @@ logical_rewrite_heap_tuple(RewriteState state, ItemPointerData old_tid,
+ if (!state->rs_logical_rewrite)
+ return;
+
+- xmin = HeapTupleHeaderGetXmin(new_tuple->t_data);
++ xmin = HeapTupleGetXmin(new_tuple);
+ /* use *GetUpdateXid to correctly deal with multixacts */
+- xmax = HeapTupleHeaderGetUpdateXid(new_tuple->t_data);
++ xmax = HeapTupleGetUpdateXidAny(new_tuple);
+
+ /*
+ * Log the mapping iff the tuple has been created recently.
+@@ -1111,14 +1161,19 @@ heap_xlog_logical_rewrite(XLogReaderState *r)
+ xl_heap_rewrite_mapping *xlrec;
+ uint32 len;
+ char *data;
++ TransactionId xid;
+
+ xlrec = (xl_heap_rewrite_mapping *) XLogRecGetData(r);
+
++ xid = XLogRecGetXid(r);
+ snprintf(path, MAXPGPATH,
+ "pg_logical/mappings/" LOGICAL_REWRITE_FORMAT,
+ xlrec->mapped_db, xlrec->mapped_rel,
+ LSN_FORMAT_ARGS(xlrec->start_lsn),
+- xlrec->mapped_xid, XLogRecGetXid(r));
++ (uint32) (xlrec->mapped_xid >> 32),
++ (uint32) xlrec->mapped_xid,
++ (uint32) (xid >> 32),
++ (uint32) xid);
+
+ fd = OpenTransientFile(path,
+ O_CREAT | O_WRONLY | PG_BINARY);
+@@ -1213,10 +1268,12 @@ CheckPointLogicalRewriteHeap(void)
+ Oid dboid;
+ Oid relid;
+ XLogRecPtr lsn;
+- TransactionId rewrite_xid;
+- TransactionId create_xid;
+- uint32 hi,
+- lo;
++ uint32 lsn_hi,
++ lsn_lo,
++ rewrite_xid_hi,
++ rewrite_xid_lo,
++ create_xid_hi,
++ create_xid_lo;
+ PGFileType de_type;
+
+ if (strcmp(mapping_de->d_name, ".") == 0 ||
+@@ -1234,10 +1291,12 @@ CheckPointLogicalRewriteHeap(void)
+ continue;
+
+ if (sscanf(mapping_de->d_name, LOGICAL_REWRITE_FORMAT,
+- &dboid, &relid, &hi, &lo, &rewrite_xid, &create_xid) != 6)
++ &dboid, &relid, &lsn_hi, &lsn_lo,
++ &rewrite_xid_hi, &rewrite_xid_lo,
++ &create_xid_hi, &create_xid_lo) != 8)
+ elog(ERROR, "could not parse filename \"%s\"", mapping_de->d_name);
+
+- lsn = ((uint64) hi) << 32 | lo;
++ lsn = ((uint64) lsn_hi) << 32 | lsn_lo;
+
+ if (lsn < cutoff || cutoff == InvalidXLogRecPtr)
+ {
+diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
+index 3623f13b07..3afd41b9b9 100644
+--- a/src/backend/access/heap/vacuumlazy.c
++++ b/src/backend/access/heap/vacuumlazy.c
+@@ -46,6 +46,7 @@
+ #include "access/xlog.h"
+ #include "access/xloginsert.h"
+ #include "catalog/index.h"
++#include "catalog/catalog.h"
+ #include "catalog/storage.h"
+ #include "commands/dbcommands.h"
+ #include "commands/progress.h"
+@@ -259,7 +260,6 @@ static bool lazy_vacuum_all_indexes(LVRelState *vacrel);
+ static void lazy_vacuum_heap_rel(LVRelState *vacrel);
+ static int lazy_vacuum_heap_page(LVRelState *vacrel, BlockNumber blkno,
+ Buffer buffer, int index, Buffer vmbuffer);
+-static bool lazy_check_wraparound_failsafe(LVRelState *vacrel);
+ static void lazy_cleanup_all_indexes(LVRelState *vacrel);
+ static IndexBulkDeleteResult *lazy_vacuum_one_index(Relation indrel,
+ IndexBulkDeleteResult *istat,
+@@ -496,7 +496,6 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ * ensure that parallel VACUUM won't be attempted at all when relfrozenxid
+ * is already dangerously old.)
+ */
+- lazy_check_wraparound_failsafe(vacrel);
+ dead_items_alloc(vacrel, params->nworkers);
+
+ /*
+@@ -613,7 +612,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ WalUsage walusage;
+ StringInfoData buf;
+ char *msgfmt;
+- int32 diff;
++ int64 diff;
+ int64 PageHitOp = VacuumPageHit - StartPageHit,
+ PageMissOp = VacuumPageMiss - StartPageMiss,
+ PageDirtyOp = VacuumPageDirty - StartPageDirty;
+@@ -666,16 +665,17 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ orig_rel_pages == 0 ? 100.0 :
+ 100.0 * vacrel->scanned_pages / orig_rel_pages);
+ appendStringInfo(&buf,
+- _("tuples: %lld removed, %lld remain, %lld are dead but not yet removable\n"),
++ _("tuples: %lld removed, %lld remain, %lld are dead but not yet removable, oldest xmin: %llu\n"),
+ (long long) vacrel->tuples_deleted,
+ (long long) vacrel->new_rel_tuples,
+- (long long) vacrel->recently_dead_tuples);
++ (long long) vacrel->recently_dead_tuples,
++ (unsigned long long) vacrel->cutoffs.OldestXmin);
+ if (vacrel->missed_dead_tuples > 0)
+ appendStringInfo(&buf,
+ _("tuples missed: %lld dead from %u pages not removed due to cleanup lock contention\n"),
+ (long long) vacrel->missed_dead_tuples,
+ vacrel->missed_dead_pages);
+- diff = (int32) (ReadNextTransactionId() -
++ diff = (int64) (ReadNextTransactionId() -
+ vacrel->cutoffs.OldestXmin);
+ appendStringInfo(&buf,
+ _("removable cutoff: %llu, which was %lld XIDs old when operation ended\n"),
+@@ -683,7 +683,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ (long long) diff);
+ if (frozenxid_updated)
+ {
+- diff = (int32) (vacrel->NewRelfrozenXid -
++ diff = (int64) (vacrel->NewRelfrozenXid -
+ vacrel->cutoffs.relfrozenxid);
+ appendStringInfo(&buf,
+ _("new relfrozenxid: %llu, which is %lld XIDs ahead of previous value\n"),
+@@ -692,7 +692,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ }
+ if (minmulti_updated)
+ {
+- diff = (int32) (vacrel->NewRelminMxid -
++ diff = (int64) (vacrel->NewRelminMxid -
+ vacrel->cutoffs.relminmxid);
+ appendStringInfo(&buf,
+ _("new relminmxid: %llu, which is %lld MXIDs ahead of previous value\n"),
+@@ -894,18 +894,6 @@ lazy_scan_heap(LVRelState *vacrel)
+
+ vacuum_delay_point();
+
+- /*
+- * Regularly check if wraparound failsafe should trigger.
+- *
+- * There is a similar check inside lazy_vacuum_all_indexes(), but
+- * relfrozenxid might start to look dangerously old before we reach
+- * that point. This check also provides failsafe coverage for the
+- * one-pass strategy, and the two-pass strategy with the index_cleanup
+- * param set to 'off'.
+- */
+- if (vacrel->scanned_pages % FAILSAFE_EVERY_PAGES == 0)
+- lazy_check_wraparound_failsafe(vacrel);
+-
+ /*
+ * Consider if we definitely have enough space to process TIDs on page
+ * already. If we are close to overrunning the available space for
+@@ -1448,7 +1436,14 @@ lazy_scan_new_or_empty(LVRelState *vacrel, Buffer buf, BlockNumber blkno,
+
+ if (GetRecordedFreeSpace(vacrel->rel, blkno) == 0)
+ {
+- freespace = BLCKSZ - SizeOfPageHeaderData;
++ Size special_size;
++
++ special_size = IsToastRelation(vacrel->rel) ?
++ sizeof(ToastPageSpecialData) :
++ sizeof(HeapPageSpecialData);
++ freespace = BufferGetPageSize(buf)
++ - SizeOfPageHeaderData
++ - special_size;
+
+ RecordPageWithFreeSpace(vacrel->rel, blkno, freespace);
+ }
+@@ -1552,6 +1547,7 @@ lazy_scan_prune(LVRelState *vacrel,
+ OffsetNumber offnum,
+ maxoff;
+ ItemId itemid;
++ HeapTupleData tuple;
+ PruneResult presult;
+ int tuples_frozen,
+ lpdead_items,
+@@ -1590,7 +1586,7 @@ lazy_scan_prune(LVRelState *vacrel,
+ * lpdead_items's final value can be thought of as the number of tuples
+ * that were deleted from indexes.
+ */
+- heap_page_prune(rel, buf, vacrel->vistest, &presult, &vacrel->offnum);
++ heap_page_prune(rel, buf, vacrel->vistest, &presult, &vacrel->offnum, true);
+
+ /*
+ * Now scan the page to collect LP_DEAD items and check for tuples
+@@ -1650,6 +1646,11 @@ lazy_scan_prune(LVRelState *vacrel,
+ Assert(ItemIdIsNormal(itemid));
+
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++ ItemPointerSet(&(tuple.t_self), blkno, offnum);
++ tuple.t_data = htup;
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, IsToastRelation(rel));
+
+ /*
+ * The criteria for counting a tuple as live in this block need to
+@@ -1702,7 +1703,7 @@ lazy_scan_prune(LVRelState *vacrel,
+ * The inserter definitely committed. But is it old enough
+ * that everyone sees it as committed?
+ */
+- xmin = HeapTupleHeaderGetXmin(htup);
++ xmin = HeapTupleGetXmin(&tuple);
+ if (!TransactionIdPrecedes(xmin,
+ vacrel->cutoffs.OldestXmin))
+ {
+@@ -1756,7 +1757,7 @@ lazy_scan_prune(LVRelState *vacrel,
+ prunestate->hastup = true; /* page makes rel truncation unsafe */
+
+ /* Tuple with storage -- consider need to freeze */
+- if (heap_prepare_freeze_tuple(htup, &vacrel->cutoffs, &pagefrz,
++ if (heap_prepare_freeze_tuple(&tuple, &vacrel->cutoffs, &pagefrz,
+ &frozen[tuples_frozen], &totally_frozen))
+ {
+ /* Save prepared freeze plan for later */
+@@ -1956,7 +1957,6 @@ lazy_scan_noprune(LVRelState *vacrel,
+ live_tuples,
+ recently_dead_tuples,
+ missed_dead_tuples;
+- HeapTupleHeader tupleheader;
+ TransactionId NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid;
+ MultiXactId NoFreezePageRelminMxid = vacrel->NewRelminMxid;
+ OffsetNumber deadoffsets[MaxHeapTuplesPerPage];
+@@ -2002,8 +2002,13 @@ lazy_scan_noprune(LVRelState *vacrel,
+ }
+
+ *hastup = true; /* page prevents rel truncation */
+- tupleheader = (HeapTupleHeader) PageGetItem(page, itemid);
+- if (heap_tuple_should_freeze(tupleheader, &vacrel->cutoffs,
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(vacrel->rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page,
++ IsToastRelation(vacrel->rel));
++ ItemPointerSet(&(tuple.t_self), blkno, offnum);
++ if (heap_tuple_should_freeze(&tuple, &vacrel->cutoffs,
+ &NoFreezePageRelfrozenXid,
+ &NoFreezePageRelminMxid))
+ {
+@@ -2039,6 +2044,8 @@ lazy_scan_noprune(LVRelState *vacrel,
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationGetRelid(vacrel->rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page,
++ IsToastRelation(vacrel->rel));
+
+ switch (HeapTupleSatisfiesVacuum(&tuple, vacrel->cutoffs.OldestXmin,
+ buf))
+@@ -2322,13 +2329,6 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
+ Assert(vacrel->do_index_vacuuming);
+ Assert(vacrel->do_index_cleanup);
+
+- /* Precheck for XID wraparound emergencies */
+- if (lazy_check_wraparound_failsafe(vacrel))
+- {
+- /* Wraparound emergency -- don't even start an index scan */
+- return false;
+- }
+-
+ /*
+ * Report that we are now vacuuming indexes and the number of indexes to
+ * vacuum.
+@@ -2352,12 +2352,6 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
+ pgstat_progress_update_param(PROGRESS_VACUUM_INDEXES_PROCESSED,
+ idx + 1);
+
+- if (lazy_check_wraparound_failsafe(vacrel))
+- {
+- /* Wraparound emergency -- end current index scan */
+- allindexes = false;
+- break;
+- }
+ }
+ }
+ else
+@@ -2365,13 +2359,6 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
+ /* Outsource everything to parallel variant */
+ parallel_vacuum_bulkdel_all_indexes(vacrel->pvs, old_live_tuples,
+ vacrel->num_index_scans);
+-
+- /*
+- * Do a postcheck to consider applying wraparound failsafe now. Note
+- * that parallel VACUUM only gets the precheck and this postcheck.
+- */
+- if (lazy_check_wraparound_failsafe(vacrel))
+- allindexes = false;
+ }
+
+ /*
+@@ -2612,68 +2599,6 @@ lazy_vacuum_heap_page(LVRelState *vacrel, BlockNumber blkno, Buffer buffer,
+ return index;
+ }
+
+-/*
+- * Trigger the failsafe to avoid wraparound failure when vacrel table has a
+- * relfrozenxid and/or relminmxid that is dangerously far in the past.
+- * Triggering the failsafe makes the ongoing VACUUM bypass any further index
+- * vacuuming and heap vacuuming. Truncating the heap is also bypassed.
+- *
+- * Any remaining work (work that VACUUM cannot just bypass) is typically sped
+- * up when the failsafe triggers. VACUUM stops applying any cost-based delay
+- * that it started out with.
+- *
+- * Returns true when failsafe has been triggered.
+- */
+-static bool
+-lazy_check_wraparound_failsafe(LVRelState *vacrel)
+-{
+- /* Don't warn more than once per VACUUM */
+- if (VacuumFailsafeActive)
+- return true;
+-
+- if (unlikely(vacuum_xid_failsafe_check(&vacrel->cutoffs)))
+- {
+- const int progress_index[] = {
+- PROGRESS_VACUUM_INDEXES_TOTAL,
+- PROGRESS_VACUUM_INDEXES_PROCESSED
+- };
+- int64 progress_val[2] = {0, 0};
+-
+- VacuumFailsafeActive = true;
+-
+- /*
+- * Abandon use of a buffer access strategy to allow use of all of
+- * shared buffers. We assume the caller who allocated the memory for
+- * the BufferAccessStrategy will free it.
+- */
+- vacrel->bstrategy = NULL;
+-
+- /* Disable index vacuuming, index cleanup, and heap rel truncation */
+- vacrel->do_index_vacuuming = false;
+- vacrel->do_index_cleanup = false;
+- vacrel->do_rel_truncate = false;
+-
+- /* Reset the progress counters */
+- pgstat_progress_update_multi_param(2, progress_index, progress_val);
+-
+- ereport(WARNING,
+- (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans",
+- vacrel->dbname, vacrel->relnamespace, vacrel->relname,
+- vacrel->num_index_scans),
+- errdetail("The table's relfrozenxid or relminmxid is too far in the past."),
+- errhint("Consider increasing configuration parameter maintenance_work_mem or autovacuum_work_mem.\n"
+- "You might also need to consider other ways for VACUUM to keep up with the allocation of transaction IDs.")));
+-
+- /* Stop applying cost limits from this point on */
+- VacuumCostActive = false;
+- VacuumCostBalance = 0;
+-
+- return true;
+- }
+-
+- return false;
+-}
+-
+ /*
+ * lazy_cleanup_all_indexes() -- cleanup all indexes of relation.
+ */
+@@ -3319,7 +3244,8 @@ heap_page_is_all_visible(LVRelState *vacrel, Buffer buf,
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationGetRelid(vacrel->rel);
+-
++ HeapTupleCopyXidsFromPage(buf, &tuple, page,
++ IsToastRelation(vacrel->rel));
+ switch (HeapTupleSatisfiesVacuum(&tuple, vacrel->cutoffs.OldestXmin,
+ buf))
+ {
+@@ -3339,7 +3265,7 @@ heap_page_is_all_visible(LVRelState *vacrel, Buffer buf,
+ * The inserter definitely committed. But is it old enough
+ * that everyone sees it as committed?
+ */
+- xmin = HeapTupleHeaderGetXmin(tuple.t_data);
++ xmin = HeapTupleGetXmin(&tuple);
+ if (!TransactionIdPrecedes(xmin,
+ vacrel->cutoffs.OldestXmin))
+ {
+@@ -3355,7 +3281,7 @@ heap_page_is_all_visible(LVRelState *vacrel, Buffer buf,
+
+ /* Check whether this tuple is already frozen or not */
+ if (all_visible && *all_frozen &&
+- heap_tuple_needs_eventual_freeze(tuple.t_data))
++ heap_tuple_needs_eventual_freeze(&tuple))
+ *all_frozen = false;
+ }
+ break;
+diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
+index b7660a459e..726edb24a3 100644
+--- a/src/backend/access/nbtree/nbtpage.c
++++ b/src/backend/access/nbtree/nbtpage.c
+@@ -549,6 +549,7 @@ _bt_getroot(Relation rel, Relation heaprel, int access)
+ rootblkno = rootopaque->btpo_next;
+ }
+
++ /* Note: can't check btpo_level on deleted pages */
+ if (rootopaque->btpo_level != rootlevel)
+ elog(ERROR, "root page %u of index \"%s\" has level %u, expected %u",
+ rootblkno, RelationGetRelationName(rel),
+@@ -652,6 +653,7 @@ _bt_gettrueroot(Relation rel)
+ rootblkno = rootopaque->btpo_next;
+ }
+
++ /* Note: can't check btpo_level on deleted pages */
+ if (rootopaque->btpo_level != rootlevel)
+ elog(ERROR, "root page %u of index \"%s\" has level %u, expected %u",
+ rootblkno, RelationGetRelationName(rel),
+diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
+index 85834c3dd7..fd985f9282 100644
+--- a/src/backend/access/nbtree/nbtsplitloc.c
++++ b/src/backend/access/nbtree/nbtsplitloc.c
+@@ -140,6 +140,7 @@ _bt_findsplitloc(Relation rel,
+ olddataitemstoleft,
+ perfectpenalty,
+ leaffillfactor;
++ int maxTupleEnd PG_USED_FOR_ASSERTS_ONLY;
+ FindSplitData state;
+ FindSplitStrat strategy;
+ ItemId itemid;
+@@ -153,6 +154,7 @@ _bt_findsplitloc(Relation rel,
+
+ opaque = BTPageGetOpaque(origpage);
+ maxoff = PageGetMaxOffsetNumber(origpage);
++ maxTupleEnd = ItemIdGetTupleEnd(PageGetItemId(origpage, P_HIKEY));
+
+ /* Total free space available on a btree page, after fixed overhead */
+ leftspace = rightspace =
+@@ -214,6 +216,18 @@ _bt_findsplitloc(Relation rel,
+ itemid = PageGetItemId(origpage, offnum);
+ itemsz = MAXALIGN(ItemIdGetLength(itemid)) + sizeof(ItemIdData);
+
++#ifdef USE_ASSERT_CHECKING
++
++ /*
++ * Ending of rightmost tuple on a page can be shifted relative to left
++ * boundary of BTPageOpaqueData due to conversion from EE96, which
++ * used different BTPageOpaqueData layout. It is only checked in the
++ * assert below.
++ */
++ if (maxTupleEnd < ItemIdGetTupleEnd(itemid))
++ maxTupleEnd = ItemIdGetTupleEnd(itemid);
++#endif
++
+ /*
+ * When item offset number is not newitemoff, neither side of the
+ * split can be newitem. Record a split after the previous data item
+@@ -248,7 +262,7 @@ _bt_findsplitloc(Relation rel,
+ * (Though only when it's possible that newitem will end up alone on new
+ * right page.)
+ */
+- Assert(olddataitemstoleft == olddataitemstotal);
++ Assert(olddataitemstoleft + ((PageHeader) origpage)->pd_special - maxTupleEnd == olddataitemstotal);
+ if (newitemoff > maxoff)
+ _bt_recsplitloc(&state, newitemoff, false, olddataitemstotal, 0);
+
+diff --git a/src/backend/access/rmgrdesc/gistdesc.c b/src/backend/access/rmgrdesc/gistdesc.c
+index baac2a65b3..fd9ca7df94 100644
+--- a/src/backend/access/rmgrdesc/gistdesc.c
++++ b/src/backend/access/rmgrdesc/gistdesc.c
+@@ -29,7 +29,7 @@ out_gistxlogPageReuse(StringInfo buf, gistxlogPageReuse *xlrec)
+ appendStringInfo(buf, "rel %u/%u/%u; blk %u; snapshotConflictHorizon %llu",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber, xlrec->block,
+- (unsigned long long) U64FromFullTransactionId(xlrec->snapshotConflictHorizon));
++ (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon));
+ }
+
+ static void
+@@ -51,7 +51,7 @@ static void
+ out_gistxlogPageDelete(StringInfo buf, gistxlogPageDelete *xlrec)
+ {
+ appendStringInfo(buf, "deleteXid %llu; downlink %u",
+- (unsigned long long) U64FromFullTransactionId(xlrec->deleteXid),
++ (unsigned long long) XidFromFullTransactionId(xlrec->deleteXid),
+ xlrec->downlinkOffset);
+ }
+
+diff --git a/src/backend/access/rmgrdesc/heapdesc.c b/src/backend/access/rmgrdesc/heapdesc.c
+index 1bf2c1ab85..4b6d6c3904 100644
+--- a/src/backend/access/rmgrdesc/heapdesc.c
++++ b/src/backend/access/rmgrdesc/heapdesc.c
+@@ -308,6 +308,23 @@ heap2_desc(StringInfo buf, XLogReaderState *record)
+ }
+ }
+
++void
++heap3_desc(StringInfo buf, XLogReaderState *record)
++{
++ char *rec = XLogRecGetData(record);
++ uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
++
++ info &= XLOG_HEAP_OPMASK;
++ if (info == XLOG_HEAP3_BASE_SHIFT)
++ {
++ xl_heap_base_shift *xlrec = (xl_heap_base_shift *) rec;
++
++ appendStringInfo(buf, "%s delta %lld ",
++ xlrec->multi ? "MultiXactId" : "XactId",
++ (long long) xlrec->delta);
++ }
++}
++
+ const char *
+ heap_identify(uint8 info)
+ {
+@@ -391,3 +408,18 @@ heap2_identify(uint8 info)
+
+ return id;
+ }
++
++const char *
++heap3_identify(uint8 info)
++{
++ const char *id = NULL;
++
++ switch (info & ~XLR_INFO_MASK)
++ {
++ case XLOG_HEAP3_BASE_SHIFT:
++ id = "BASE_SHIFT";
++ break;
++ }
++
++ return id;
++}
+diff --git a/src/backend/access/rmgrdesc/nbtdesc.c b/src/backend/access/rmgrdesc/nbtdesc.c
+index f26664f32d..f42de19c87 100644
+--- a/src/backend/access/rmgrdesc/nbtdesc.c
++++ b/src/backend/access/rmgrdesc/nbtdesc.c
+@@ -95,7 +95,7 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+
+ appendStringInfo(buf, "left: %u, right: %u, level: %u, safexid: %llu, ",
+ xlrec->leftsib, xlrec->rightsib, xlrec->level,
+- (unsigned long long) U64FromFullTransactionId(xlrec->safexid));
++ (unsigned long long) XidFromFullTransactionId(xlrec->safexid));
+ appendStringInfo(buf, "leafleft: %u, leafright: %u, leaftopparent: %u",
+ xlrec->leafleftsib, xlrec->leafrightsib,
+ xlrec->leaftopparent);
+@@ -115,7 +115,7 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+ appendStringInfo(buf, "rel: %u/%u/%u, snapshotConflictHorizon: %llu",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber,
+- (unsigned long long) U64FromFullTransactionId(xlrec->snapshotConflictHorizon));
++ (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon));
+ break;
+ }
+ case XLOG_BTREE_META_CLEANUP:
+diff --git a/src/backend/access/rmgrdesc/xactdesc.c b/src/backend/access/rmgrdesc/xactdesc.c
+index 6b3e8fe9e5..dfc7741e79 100644
+--- a/src/backend/access/rmgrdesc/xactdesc.c
++++ b/src/backend/access/rmgrdesc/xactdesc.c
+@@ -110,7 +110,8 @@ ParseCommitRecord(uint8 info, xl_xact_commit *xlrec, xl_xact_parsed_commit *pars
+ {
+ xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
+
+- parsed->twophase_xid = xl_twophase->xid;
++ parsed->twophase_xid =
++ ((uint64) xl_twophase->xid_hi << 32) | xl_twophase->xid_lo;
+
+ data += sizeof(xl_xact_twophase);
+
+@@ -205,7 +206,8 @@ ParseAbortRecord(uint8 info, xl_xact_abort *xlrec, xl_xact_parsed_abort *parsed)
+ {
+ xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
+
+- parsed->twophase_xid = xl_twophase->xid;
++ parsed->twophase_xid =
++ ((uint64) xl_twophase->xid_hi << 32) | xl_twophase->xid_lo;
+
+ data += sizeof(xl_xact_twophase);
+
+diff --git a/src/backend/access/rmgrdesc/xlogdesc.c b/src/backend/access/rmgrdesc/xlogdesc.c
+index 48fb5022e0..108991680d 100644
+--- a/src/backend/access/rmgrdesc/xlogdesc.c
++++ b/src/backend/access/rmgrdesc/xlogdesc.c
+@@ -53,7 +53,7 @@ xlog_desc(StringInfo buf, XLogReaderState *record)
+ checkpoint->ThisTimeLineID,
+ checkpoint->PrevTimeLineID,
+ checkpoint->fullPageWrites ? "true" : "false",
+- (unsigned long long) U64FromFullTransactionId(checkpoint->nextXid),
++ (unsigned long long) XidFromFullTransactionId(checkpoint->nextXid),
+ checkpoint->nextOid,
+ (unsigned long long) checkpoint->nextMulti,
+ (unsigned long long) checkpoint->nextMultiOffset,
+diff --git a/src/backend/access/transam/clog.c b/src/backend/access/transam/clog.c
+index 0e75dd2ca0..e96b739c8c 100644
+--- a/src/backend/access/transam/clog.c
++++ b/src/backend/access/transam/clog.c
+@@ -302,7 +302,7 @@ TransactionIdSetPageStatus(TransactionId xid, int nsubxids,
+ * sub-XIDs and all of the XIDs for which we're adjusting clog should be
+ * on the same page. Check those conditions, too.
+ */
+- if (all_xact_same_page && xid == MyProc->xid &&
++ if (all_xact_same_page && xid == pg_atomic_read_u64(&MyProc->xid) &&
+ nsubxids <= THRESHOLD_SUBTRANS_CLOG_OPT &&
+ nsubxids == MyProc->subxidStatus.count &&
+ (nsubxids == 0 ||
+@@ -920,24 +920,11 @@ TruncateCLOG(TransactionId oldestXact, Oid oldestxid_datoid)
+ SimpleLruTruncate(XactCtl, cutoffPage);
+ }
+
+-
+ /*
+ * Decide whether a CLOG page number is "older" for truncation purposes.
+ *
+- * We need to use comparison of TransactionIds here in order to do the right
+- * thing with wraparound XID arithmetic. However, TransactionIdPrecedes()
+- * would get weird about permanent xact IDs. So, offset both such that xid1,
+- * xid2, and xid2 + CLOG_XACTS_PER_PAGE - 1 are all normal XIDs; this offset
+- * is relevant to page 0 and to the page preceding page 0.
+- *
+- * The page containing oldestXact-2^31 is the important edge case. The
+- * portion of that page equaling or following oldestXact-2^31 is expendable,
+- * but the portion preceding oldestXact-2^31 is not. When oldestXact-2^31 is
+- * the first XID of a page and segment, the entire page and segment is
+- * expendable, and we could truncate the segment. Recognizing that case would
+- * require making oldestXact, not just the page containing oldestXact,
+- * available to this callback. The benefit would be rare and small, so we
+- * don't optimize that edge case.
++ * With 64xid this function is just "<", but we left it as a function in order
++ * for its calls remain "vanilla" like.
+ */
+ static bool
+ CLOGPagePrecedes(int64 page1, int64 page2)
+diff --git a/src/backend/access/transam/commit_ts.c b/src/backend/access/transam/commit_ts.c
+index f157854e70..36582e5b4f 100644
+--- a/src/backend/access/transam/commit_ts.c
++++ b/src/backend/access/transam/commit_ts.c
+@@ -908,25 +908,6 @@ AdvanceOldestCommitTsXid(TransactionId oldestXact)
+ /*
+ * Decide whether a commitTS page number is "older" for truncation purposes.
+ * Analogous to CLOGPagePrecedes().
+- *
+- * At default BLCKSZ, (1 << 31) % COMMIT_TS_XACTS_PER_PAGE == 128. This
+- * introduces differences compared to CLOG and the other SLRUs having (1 <<
+- * 31) % per_page == 0. This function never tests exactly
+- * TransactionIdPrecedes(x-2^31, x). When the system reaches xidStopLimit,
+- * there are two possible counts of page boundaries between oldestXact and the
+- * latest XID assigned, depending on whether oldestXact is within the first
+- * 128 entries of its page. Since this function doesn't know the location of
+- * oldestXact within page2, it returns false for one page that actually is
+- * expendable. This is a wider (yet still negligible) version of the
+- * truncation opportunity that CLOGPagePrecedes() cannot recognize.
+- *
+- * For the sake of a worked example, number entries with decimal values such
+- * that page1==1 entries range from 1.0 to 1.999. Let N+0.15 be the number of
+- * pages that 2^31 entries will span (N is an integer). If oldestXact=N+2.1,
+- * then the final safe XID assignment leaves newestXact=1.95. We keep page 2,
+- * because entry=2.85 is the border that toggles whether entries precede the
+- * last entry of the oldestXact page. While page 2 is expendable at
+- * oldestXact=N+2.1, it would be precious at oldestXact=N+2.9.
+ */
+ static bool
+ CommitTsPagePrecedes(int64 page1, int64 page2)
+diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
+index 4c30525250..c14efe56f6 100644
+--- a/src/backend/access/transam/multixact.c
++++ b/src/backend/access/transam/multixact.c
+@@ -112,15 +112,15 @@
+ ((xid) / (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)
+ #define MultiXactIdToOffsetEntry(xid) \
+ ((xid) % (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)
+-#define MultiXactIdToOffsetSegment(xid) (MultiXactIdToOffsetPage(xid) / SLRU_PAGES_PER_SEGMENT)
++#define MultiXactIdToOffsetSegment(xid) ((uint64)(MultiXactIdToOffsetPage(xid) / SLRU_PAGES_PER_SEGMENT))
+
+ /*
+ * The situation for members is a bit more complex: we store one byte of
+ * additional flag bits for each TransactionId. To do this without getting
+- * into alignment issues, we store four bytes of flags, and then the
+- * corresponding 4 Xids. Each such 5-word (20-byte) set we call a "group", and
+- * are stored as a whole in pages. Thus, with 8kB BLCKSZ, we keep 409 groups
+- * per page. This wastes 12 bytes per page, but that's OK -- simplicity (and
++ * into alignment issues, we store eight bytes of flags, and then the
++ * corresponding 8 Xids. Each such 9-word (72-byte) set we call a "group", and
++ * are stored as a whole in pages. Thus, with 8kB BLCKSZ, we keep 113 groups
++ * per page. This wastes 56 bytes per page, but that's OK -- simplicity (and
+ * performance) trumps space efficiency here.
+ *
+ * Note that the "offset" macros work with byte offset, not array indexes, so
+@@ -132,7 +132,7 @@
+ #define MXACT_MEMBER_XACT_BITMASK ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)
+
+ /* how many full bytes of flags are there in a group? */
+-#define MULTIXACT_FLAGBYTES_PER_GROUP 4
++#define MULTIXACT_FLAGBYTES_PER_GROUP 8
+ #define MULTIXACT_MEMBERS_PER_MEMBERGROUP \
+ (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
+ /* size in bytes of a complete group */
+@@ -142,22 +142,9 @@
+ #define MULTIXACT_MEMBERS_PER_PAGE \
+ (MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)
+
+-/*
+- * Because the number of items per page is not a divisor of the last item
+- * number (member 0xFFFFFFFF), the last segment does not use the maximum number
+- * of pages, and moreover the last used page therein does not use the same
+- * number of items as previous pages. (Another way to say it is that the
+- * 0xFFFFFFFF member is somewhere in the middle of the last page, so the page
+- * has some empty space after that item.)
+- *
+- * This constant is the number of members in the last page of the last segment.
+- */
+-#define MAX_MEMBERS_IN_LAST_MEMBERS_PAGE \
+- ((uint32) ((0xFFFFFFFF % MULTIXACT_MEMBERS_PER_PAGE) + 1))
+-
+ /* page in which a member is to be found */
+ #define MXOffsetToMemberPage(xid) ((xid) / (TransactionId) MULTIXACT_MEMBERS_PER_PAGE)
+-#define MXOffsetToMemberSegment(xid) (MXOffsetToMemberPage(xid) / SLRU_PAGES_PER_SEGMENT)
++#define MXOffsetToMemberSegment(xid) ((uint64)(MXOffsetToMemberPage(xid) / SLRU_PAGES_PER_SEGMENT))
+
+ /* Location (byte offset within page) of flag word for a given member */
+ #define MXOffsetToFlagsOffset(xid) \
+@@ -216,22 +203,8 @@ typedef struct MultiXactStateData
+ MultiXactId oldestMultiXactId;
+ Oid oldestMultiXactDB;
+
+- /*
+- * Oldest multixact offset that is potentially referenced by a multixact
+- * referenced by a relation. We don't always know this value, so there's
+- * a flag here to indicate whether or not we currently do.
+- */
+- MultiXactOffset oldestOffset;
+- bool oldestOffsetKnown;
+-
+ /* support for anti-wraparound measures */
+ MultiXactId multiVacLimit;
+- MultiXactId multiWarnLimit;
+- MultiXactId multiStopLimit;
+- MultiXactId multiWrapLimit;
+-
+- /* support for members anti-wraparound measures */
+- MultiXactOffset offsetStopLimit; /* known if oldestOffsetKnown */
+
+ /*
+ * Per-backend data starts here. We have two arrays stored in the area
+@@ -362,9 +335,6 @@ static bool MultiXactOffsetPrecedes(MultiXactOffset offset1,
+ MultiXactOffset offset2);
+ static void ExtendMultiXactOffset(MultiXactId multi);
+ static void ExtendMultiXactMember(MultiXactOffset offset, int nmembers);
+-static bool MultiXactOffsetWouldWrap(MultiXactOffset boundary,
+- MultiXactOffset start, uint32 distance);
+-static bool SetOffsetVacuumLimit(bool is_startup);
+ static bool find_multixact_start(MultiXactId multi, MultiXactOffset *result);
+ static void WriteMZeroPageXlogRec(int64 pageno, uint8 info);
+ static void WriteMTruncateXlogRec(Oid oldestMultiDB,
+@@ -398,6 +368,9 @@ MultiXactIdCreate(TransactionId xid1, MultiXactStatus status1,
+ /* MultiXactIdSetOldestMember() must have been called already. */
+ Assert(MultiXactIdIsValid(OldestMemberMXactId[MyBackendId]));
+
++ /* memset members array because with 64-bit xids it has a padding hole */
++ MemSet(members, 0, sizeof(members));
++
+ /*
+ * Note: unlike MultiXactIdExpand, we don't bother to check that both XIDs
+ * are still running. In typical usage, xid2 will be our own XID and the
+@@ -513,7 +486,7 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
+ * end of the loop.
+ */
+ newMembers = (MultiXactMember *)
+- palloc(sizeof(MultiXactMember) * (nmembers + 1));
++ palloc0(sizeof(MultiXactMember) * (nmembers + 1));
+
+ for (i = 0, j = 0; i < nmembers; i++)
+ {
+@@ -528,7 +501,6 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
+
+ newMembers[j].xid = xid;
+ newMembers[j++].status = status;
+-
+ newMulti = MultiXactIdCreateFromMembers(j, newMembers);
+
+ pfree(members);
+@@ -905,8 +877,8 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
+ for (i = 0; i < nmembers; i++, offset++)
+ {
+ TransactionId *memberptr;
+- uint32 *flagsptr;
+- uint32 flagsval;
++ uint64 *flagsptr;
++ uint64 flagsval;
+ int bshift;
+ int flagsoff;
+ int memberoff;
+@@ -929,12 +901,12 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
+
+ *memberptr = members[i].xid;
+
+- flagsptr = (uint32 *)
++ flagsptr = (uint64 *)
+ (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
+
+ flagsval = *flagsptr;
+- flagsval &= ~(((1 << MXACT_MEMBER_BITS_PER_XACT) - 1) << bshift);
+- flagsval |= (members[i].status << bshift);
++ flagsval &= ~((uint64) ((1ULL << MXACT_MEMBER_BITS_PER_XACT) - 1) << bshift);
++ flagsval |= ((uint64) members[i].status << bshift);
+ *flagsptr = flagsval;
+
+ MultiXactMemberCtl->shared->page_dirty[slotno] = true;
+@@ -987,8 +959,6 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+ * If we're past multiVacLimit or the safe threshold for member storage
+ * space, or we don't know what the safe threshold for member storage is,
+ * start trying to force autovacuum cycles.
+- * If we're past multiWarnLimit, start issuing warnings.
+- * If we're past multiStopLimit, refuse to create new MultiXactIds.
+ *
+ * Note these are pretty much the same protections in GetNewTransactionId.
+ *----------
+@@ -1002,41 +972,9 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+ * possibility of deadlock while doing get_database_name(). First,
+ * copy all the shared values we'll need in this path.
+ */
+- MultiXactId multiWarnLimit = MultiXactState->multiWarnLimit;
+- MultiXactId multiStopLimit = MultiXactState->multiStopLimit;
+- MultiXactId multiWrapLimit = MultiXactState->multiWrapLimit;
+- Oid oldest_datoid = MultiXactState->oldestMultiXactDB;
+
+ LWLockRelease(MultiXactGenLock);
+
+- if (IsUnderPostmaster &&
+- !MultiXactIdPrecedes(result, multiStopLimit))
+- {
+- char *oldest_datname = get_database_name(oldest_datoid);
+-
+- /*
+- * Immediately kick autovacuum into action as we're already in
+- * ERROR territory.
+- */
+- SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+-
+- /* complain even if that DB has disappeared */
+- if (oldest_datname)
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("database is not accepting commands that assign new MultiXactIds to avoid wraparound data loss in database \"%s\"",
+- oldest_datname),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("database is not accepting commands that assign new MultiXactIds to avoid wraparound data loss in database with OID %u",
+- oldest_datoid),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+-
+ /*
+ * To avoid swamping the postmaster with signals, we issue the autovac
+ * request only once per 64K multis generated. This still gives
+@@ -1045,31 +983,6 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+ if (IsUnderPostmaster && (result % 65536) == 0)
+ SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+
+- if (!MultiXactIdPrecedes(result, multiWarnLimit))
+- {
+- char *oldest_datname = get_database_name(oldest_datoid);
+-
+- /* complain even if that DB has disappeared */
+- if (oldest_datname)
+- ereport(WARNING,
+- (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
+- "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
+- multiWrapLimit - result,
+- oldest_datname,
+- multiWrapLimit - result),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(WARNING,
+- (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",
+- "database with OID %u must be vacuumed before %u more MultiXactIds are used",
+- multiWrapLimit - result,
+- oldest_datoid,
+- multiWrapLimit - result),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+-
+ /* Re-acquire lock and start over */
+ LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
+ result = MultiXactState->nextMXact;
+@@ -1094,78 +1007,6 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+ else
+ *offset = nextOffset;
+
+- /*----------
+- * Protect against overrun of the members space as well, with the
+- * following rules:
+- *
+- * If we're past offsetStopLimit, refuse to generate more multis.
+- * If we're close to offsetStopLimit, emit a warning.
+- *
+- * Arbitrarily, we start emitting warnings when we're 20 segments or less
+- * from offsetStopLimit.
+- *
+- * Note we haven't updated the shared state yet, so if we fail at this
+- * point, the multixact ID we grabbed can still be used by the next guy.
+- *
+- * Note that there is no point in forcing autovacuum runs here: the
+- * multixact freeze settings would have to be reduced for that to have any
+- * effect.
+- *----------
+- */
+-#define OFFSET_WARN_SEGMENTS 20
+- if (MultiXactState->oldestOffsetKnown &&
+- MultiXactOffsetWouldWrap(MultiXactState->offsetStopLimit, nextOffset,
+- nmembers))
+- {
+- /* see comment in the corresponding offsets wraparound case */
+- SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+-
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("multixact \"members\" limit exceeded"),
+- errdetail_plural("This command would create a multixact with %u members, but the remaining space is only enough for %u member.",
+- "This command would create a multixact with %u members, but the remaining space is only enough for %u members.",
+- MultiXactState->offsetStopLimit - nextOffset - 1,
+- nmembers,
+- MultiXactState->offsetStopLimit - nextOffset - 1),
+- errhint("Execute a database-wide VACUUM in database with OID %u with reduced vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age settings.",
+- MultiXactState->oldestMultiXactDB)));
+- }
+-
+- /*
+- * Check whether we should kick autovacuum into action, to prevent members
+- * wraparound. NB we use a much larger window to trigger autovacuum than
+- * just the warning limit. The warning is just a measure of last resort -
+- * this is in line with GetNewTransactionId's behaviour.
+- */
+- if (!MultiXactState->oldestOffsetKnown ||
+- (MultiXactState->nextOffset - MultiXactState->oldestOffset
+- > MULTIXACT_MEMBER_SAFE_THRESHOLD))
+- {
+- /*
+- * To avoid swamping the postmaster with signals, we issue the autovac
+- * request only when crossing a segment boundary. With default
+- * compilation settings that's roughly after 50k members. This still
+- * gives plenty of chances before we get into real trouble.
+- */
+- if ((MXOffsetToMemberPage(nextOffset) / SLRU_PAGES_PER_SEGMENT) !=
+- (MXOffsetToMemberPage(nextOffset + nmembers) / SLRU_PAGES_PER_SEGMENT))
+- SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+- }
+-
+- if (MultiXactState->oldestOffsetKnown &&
+- MultiXactOffsetWouldWrap(MultiXactState->offsetStopLimit,
+- nextOffset,
+- nmembers + MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT * OFFSET_WARN_SEGMENTS))
+- ereport(WARNING,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg_plural("database with OID %u must be vacuumed before %d more multixact member is used",
+- "database with OID %u must be vacuumed before %d more multixact members are used",
+- MultiXactState->offsetStopLimit - nextOffset + nmembers,
+- MultiXactState->oldestMultiXactDB,
+- MultiXactState->offsetStopLimit - nextOffset + nmembers),
+- errhint("Execute a database-wide VACUUM in that database with reduced vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age settings.")));
+-
+ ExtendMultiXactMember(nextOffset, nmembers);
+
+ /*
+@@ -1358,7 +1199,10 @@ retry:
+ offptr += entryno;
+ offset = *offptr;
+
+- Assert(offset != 0);
++ if (offset == 0)
++ ereport(ERROR,
++ (errmsg("found invalid zero offset in multixact %llu",
++ (unsigned long long) multi)));
+
+ /*
+ * Use the same increment rule as GetNewMultiXactId(), that is, don't
+@@ -1405,7 +1249,7 @@ retry:
+
+ LWLockRelease(MultiXactOffsetSLRULock);
+
+- ptr = (MultiXactMember *) palloc(length * sizeof(MultiXactMember));
++ ptr = (MultiXactMember *) palloc0(length * sizeof(MultiXactMember));
+
+ /* Now get the members themselves. */
+ LWLockAcquire(MultiXactMemberSLRULock, LW_EXCLUSIVE);
+@@ -1415,7 +1259,7 @@ retry:
+ for (i = 0; i < length; i++, offset++)
+ {
+ TransactionId *xactptr;
+- uint32 *flagsptr;
++ uint64 *flagsptr;
+ int flagsoff;
+ int bshift;
+ int memberoff;
+@@ -1441,7 +1285,7 @@ retry:
+
+ flagsoff = MXOffsetToFlagsOffset(offset);
+ bshift = MXOffsetToFlagsBitShift(offset);
+- flagsptr = (uint32 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
++ flagsptr = (uint64 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
+
+ ptr[truelength].xid = *xactptr;
+ ptr[truelength].status = (*flagsptr >> bshift) & MXACT_MEMBER_XACT_BITMASK;
+@@ -2228,47 +2072,9 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
+ bool is_startup)
+ {
+ MultiXactId multiVacLimit;
+- MultiXactId multiWarnLimit;
+- MultiXactId multiStopLimit;
+- MultiXactId multiWrapLimit;
+- MultiXactId curMulti;
+- bool needs_offset_vacuum;
+
+ Assert(MultiXactIdIsValid(oldest_datminmxid));
+
+- /*
+- * We pretend that a wrap will happen halfway through the multixact ID
+- * space, but that's not really true, because multixacts wrap differently
+- * from transaction IDs. Note that, separately from any concern about
+- * multixact IDs wrapping, we must ensure that multixact members do not
+- * wrap. Limits for that are set in SetOffsetVacuumLimit, not here.
+- */
+- multiWrapLimit = oldest_datminmxid + (MaxMultiXactId >> 1);
+- if (multiWrapLimit < FirstMultiXactId)
+- multiWrapLimit += FirstMultiXactId;
+-
+- /*
+- * We'll refuse to continue assigning MultiXactIds once we get within 3M
+- * multi of data loss. See SetTransactionIdLimit.
+- */
+- multiStopLimit = multiWrapLimit - 3000000;
+- if (multiStopLimit < FirstMultiXactId)
+- multiStopLimit -= FirstMultiXactId;
+-
+- /*
+- * We'll start complaining loudly when we get within 40M multis of data
+- * loss. This is kind of arbitrary, but if you let your gas gauge get
+- * down to 2% of full, would you be looking for the next gas station? We
+- * need to be fairly liberal about this number because there are lots of
+- * scenarios where most transactions are done by automatic clients that
+- * won't pay attention to warnings. (No, we're not gonna make this
+- * configurable. If you know enough to configure it, you know enough to
+- * not get in this kind of trouble in the first place.)
+- */
+- multiWarnLimit = multiWrapLimit - 40000000;
+- if (multiWarnLimit < FirstMultiXactId)
+- multiWarnLimit -= FirstMultiXactId;
+-
+ /*
+ * We'll start trying to force autovacuums when oldest_datminmxid gets to
+ * be more than autovacuum_multixact_freeze_max_age mxids old.
+@@ -2278,25 +2084,14 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
+ * its value. See SetTransactionIdLimit.
+ */
+ multiVacLimit = oldest_datminmxid + autovacuum_multixact_freeze_max_age;
+- if (multiVacLimit < FirstMultiXactId)
+- multiVacLimit += FirstMultiXactId;
+
+ /* Grab lock for just long enough to set the new limit values */
+ LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
+ MultiXactState->oldestMultiXactId = oldest_datminmxid;
+ MultiXactState->oldestMultiXactDB = oldest_datoid;
+ MultiXactState->multiVacLimit = multiVacLimit;
+- MultiXactState->multiWarnLimit = multiWarnLimit;
+- MultiXactState->multiStopLimit = multiStopLimit;
+- MultiXactState->multiWrapLimit = multiWrapLimit;
+- curMulti = MultiXactState->nextMXact;
+ LWLockRelease(MultiXactGenLock);
+
+- /* Log the info */
+- ereport(DEBUG1,
+- (errmsg_internal("MultiXactId wrap limit is %u, limited by database with OID %u",
+- multiWrapLimit, oldest_datoid)));
+-
+ /*
+ * Computing the actual limits is only possible once the data directory is
+ * in a consistent state. There's no need to compute the limits while
+@@ -2308,59 +2103,6 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
+ return;
+
+ Assert(!InRecovery);
+-
+- /* Set limits for offset vacuum. */
+- needs_offset_vacuum = SetOffsetVacuumLimit(is_startup);
+-
+- /*
+- * If past the autovacuum force point, immediately signal an autovac
+- * request. The reason for this is that autovac only processes one
+- * database per invocation. Once it's finished cleaning up the oldest
+- * database, it'll call here, and we'll signal the postmaster to start
+- * another iteration immediately if there are still any old databases.
+- */
+- if ((MultiXactIdPrecedes(multiVacLimit, curMulti) ||
+- needs_offset_vacuum) && IsUnderPostmaster)
+- SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+-
+- /* Give an immediate warning if past the wrap warn point */
+- if (MultiXactIdPrecedes(multiWarnLimit, curMulti))
+- {
+- char *oldest_datname;
+-
+- /*
+- * We can be called when not inside a transaction, for example during
+- * StartupXLOG(). In such a case we cannot do database access, so we
+- * must just report the oldest DB's OID.
+- *
+- * Note: it's also possible that get_database_name fails and returns
+- * NULL, for example because the database just got dropped. We'll
+- * still warn, even though the warning might now be unnecessary.
+- */
+- if (IsTransactionState())
+- oldest_datname = get_database_name(oldest_datoid);
+- else
+- oldest_datname = NULL;
+-
+- if (oldest_datname)
+- ereport(WARNING,
+- (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
+- "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
+- multiWrapLimit - curMulti,
+- oldest_datname,
+- multiWrapLimit - curMulti),
+- errhint("To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(WARNING,
+- (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",
+- "database with OID %u must be vacuumed before %u more MultiXactIds are used",
+- multiWrapLimit - curMulti,
+- oldest_datoid,
+- multiWrapLimit - curMulti),
+- errhint("To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+ }
+
+ /*
+@@ -2458,7 +2200,7 @@ ExtendMultiXactMember(MultiXactOffset offset, int nmembers)
+ {
+ int flagsoff;
+ int flagsbit;
+- uint32 difference;
++ uint64 difference;
+
+ /*
+ * Only zero when at first entry of a page.
+@@ -2479,23 +2221,7 @@ ExtendMultiXactMember(MultiXactOffset offset, int nmembers)
+ LWLockRelease(MultiXactMemberSLRULock);
+ }
+
+- /*
+- * Compute the number of items till end of current page. Careful: if
+- * addition of unsigned ints wraps around, we're at the last page of
+- * the last segment; since that page holds a different number of items
+- * than other pages, we need to do it differently.
+- */
+- if (offset + MAX_MEMBERS_IN_LAST_MEMBERS_PAGE < offset)
+- {
+- /*
+- * This is the last page of the last segment; we can compute the
+- * number of items left to allocate in it without modulo
+- * arithmetic.
+- */
+- difference = MaxMultiXactOffset - offset + 1;
+- }
+- else
+- difference = MULTIXACT_MEMBERS_PER_PAGE - offset % MULTIXACT_MEMBERS_PER_PAGE;
++ difference = MULTIXACT_MEMBERS_PER_PAGE - offset % MULTIXACT_MEMBERS_PER_PAGE;
+
+ /*
+ * Advance to next page, taking care to properly handle the wraparound
+@@ -2560,184 +2286,6 @@ GetOldestMultiXactId(void)
+ return oldestMXact;
+ }
+
+-/*
+- * Determine how aggressively we need to vacuum in order to prevent member
+- * wraparound.
+- *
+- * To do so determine what's the oldest member offset and install the limit
+- * info in MultiXactState, where it can be used to prevent overrun of old data
+- * in the members SLRU area.
+- *
+- * The return value is true if emergency autovacuum is required and false
+- * otherwise.
+- */
+-static bool
+-SetOffsetVacuumLimit(bool is_startup)
+-{
+- MultiXactId oldestMultiXactId;
+- MultiXactId nextMXact;
+- MultiXactOffset oldestOffset = 0; /* placate compiler */
+- MultiXactOffset prevOldestOffset;
+- MultiXactOffset nextOffset;
+- bool oldestOffsetKnown = false;
+- bool prevOldestOffsetKnown;
+- MultiXactOffset offsetStopLimit = 0;
+- MultiXactOffset prevOffsetStopLimit;
+-
+- /*
+- * NB: Have to prevent concurrent truncation, we might otherwise try to
+- * lookup an oldestMulti that's concurrently getting truncated away.
+- */
+- LWLockAcquire(MultiXactTruncationLock, LW_SHARED);
+-
+- /* Read relevant fields from shared memory. */
+- LWLockAcquire(MultiXactGenLock, LW_SHARED);
+- oldestMultiXactId = MultiXactState->oldestMultiXactId;
+- nextMXact = MultiXactState->nextMXact;
+- nextOffset = MultiXactState->nextOffset;
+- prevOldestOffsetKnown = MultiXactState->oldestOffsetKnown;
+- prevOldestOffset = MultiXactState->oldestOffset;
+- prevOffsetStopLimit = MultiXactState->offsetStopLimit;
+- Assert(MultiXactState->finishedStartup);
+- LWLockRelease(MultiXactGenLock);
+-
+- /*
+- * Determine the offset of the oldest multixact. Normally, we can read
+- * the offset from the multixact itself, but there's an important special
+- * case: if there are no multixacts in existence at all, oldestMXact
+- * obviously can't point to one. It will instead point to the multixact
+- * ID that will be assigned the next time one is needed.
+- */
+- if (oldestMultiXactId == nextMXact)
+- {
+- /*
+- * When the next multixact gets created, it will be stored at the next
+- * offset.
+- */
+- oldestOffset = nextOffset;
+- oldestOffsetKnown = true;
+- }
+- else
+- {
+- /*
+- * Figure out where the oldest existing multixact's offsets are
+- * stored. Due to bugs in early release of PostgreSQL 9.3.X and 9.4.X,
+- * the supposedly-earliest multixact might not really exist. We are
+- * careful not to fail in that case.
+- */
+- oldestOffsetKnown =
+- find_multixact_start(oldestMultiXactId, &oldestOffset);
+-
+- if (oldestOffsetKnown)
+- ereport(DEBUG1,
+- (errmsg_internal("oldest MultiXactId member is at offset %llu",
+- (unsigned long long) oldestOffset)));
+- else
+- ereport(LOG,
+- (errmsg("MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %llu does not exist on disk",
+- (unsigned long long) oldestMultiXactId)));
+- }
+-
+- LWLockRelease(MultiXactTruncationLock);
+-
+- /*
+- * If we can, compute limits (and install them MultiXactState) to prevent
+- * overrun of old data in the members SLRU area. We can only do so if the
+- * oldest offset is known though.
+- */
+- if (oldestOffsetKnown)
+- {
+- /* move back to start of the corresponding segment */
+- offsetStopLimit = oldestOffset - (oldestOffset %
+- (MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT));
+-
+- /* always leave one segment before the wraparound point */
+- offsetStopLimit -= (MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT);
+-
+- if (!prevOldestOffsetKnown && !is_startup)
+- ereport(LOG,
+- (errmsg("MultiXact member wraparound protections are now enabled")));
+-
+- ereport(DEBUG1,
+- (errmsg_internal("MultiXact member stop limit is now %llu based on MultiXact %llu",
+- (unsigned long long) offsetStopLimit,
+- (unsigned long long) oldestMultiXactId)));
+- }
+- else if (prevOldestOffsetKnown)
+- {
+- /*
+- * If we failed to get the oldest offset this time, but we have a
+- * value from a previous pass through this function, use the old
+- * values rather than automatically forcing an emergency autovacuum
+- * cycle again.
+- */
+- oldestOffset = prevOldestOffset;
+- oldestOffsetKnown = true;
+- offsetStopLimit = prevOffsetStopLimit;
+- }
+-
+- /* Install the computed values */
+- LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
+- MultiXactState->oldestOffset = oldestOffset;
+- MultiXactState->oldestOffsetKnown = oldestOffsetKnown;
+- MultiXactState->offsetStopLimit = offsetStopLimit;
+- LWLockRelease(MultiXactGenLock);
+-
+- /*
+- * Do we need an emergency autovacuum? If we're not sure, assume yes.
+- */
+- return !oldestOffsetKnown ||
+- (nextOffset - oldestOffset > MULTIXACT_MEMBER_SAFE_THRESHOLD);
+-}
+-
+-/*
+- * Return whether adding "distance" to "start" would move past "boundary".
+- *
+- * We use this to determine whether the addition is "wrapping around" the
+- * boundary point, hence the name. The reason we don't want to use the regular
+- * 2^31-modulo arithmetic here is that we want to be able to use the whole of
+- * the 2^32-1 space here, allowing for more multixacts than would fit
+- * otherwise.
+- */
+-static bool
+-MultiXactOffsetWouldWrap(MultiXactOffset boundary, MultiXactOffset start,
+- uint32 distance)
+-{
+- MultiXactOffset finish;
+-
+- /*
+- * Note that offset number 0 is not used (see GetMultiXactIdMembers), so
+- * if the addition wraps around the UINT_MAX boundary, skip that value.
+- */
+- finish = start + distance;
+- if (finish < start)
+- finish++;
+-
+- /*-----------------------------------------------------------------------
+- * When the boundary is numerically greater than the starting point, any
+- * value numerically between the two is not wrapped:
+- *
+- * <----S----B---->
+- * [---) = F wrapped past B (and UINT_MAX)
+- * [---) = F not wrapped
+- * [----] = F wrapped past B
+- *
+- * When the boundary is numerically less than the starting point (i.e. the
+- * UINT_MAX wraparound occurs somewhere in between) then all values in
+- * between are wrapped:
+- *
+- * <----B----S---->
+- * [---) = F not wrapped past B (but wrapped past UINT_MAX)
+- * [---) = F wrapped past B (and UINT_MAX)
+- * [----] = F not wrapped
+- *-----------------------------------------------------------------------
+- */
+- if (start < boundary)
+- return finish >= boundary || finish < start;
+- else
+- return finish >= boundary && finish < start;
+-}
+-
+ /*
+ * Find the starting offset of the given MultiXactId.
+ *
+@@ -2781,93 +2329,6 @@ find_multixact_start(MultiXactId multi, MultiXactOffset *result)
+ return true;
+ }
+
+-/*
+- * Determine how many multixacts, and how many multixact members, currently
+- * exist. Return false if unable to determine.
+- */
+-static bool
+-ReadMultiXactCounts(uint32 *multixacts, MultiXactOffset *members)
+-{
+- MultiXactOffset nextOffset;
+- MultiXactOffset oldestOffset;
+- MultiXactId oldestMultiXactId;
+- MultiXactId nextMultiXactId;
+- bool oldestOffsetKnown;
+-
+- LWLockAcquire(MultiXactGenLock, LW_SHARED);
+- nextOffset = MultiXactState->nextOffset;
+- oldestMultiXactId = MultiXactState->oldestMultiXactId;
+- nextMultiXactId = MultiXactState->nextMXact;
+- oldestOffset = MultiXactState->oldestOffset;
+- oldestOffsetKnown = MultiXactState->oldestOffsetKnown;
+- LWLockRelease(MultiXactGenLock);
+-
+- if (!oldestOffsetKnown)
+- return false;
+-
+- *members = nextOffset - oldestOffset;
+- *multixacts = nextMultiXactId - oldestMultiXactId;
+- return true;
+-}
+-
+-/*
+- * Multixact members can be removed once the multixacts that refer to them
+- * are older than every datminmxid. autovacuum_multixact_freeze_max_age and
+- * vacuum_multixact_freeze_table_age work together to make sure we never have
+- * too many multixacts; we hope that, at least under normal circumstances,
+- * this will also be sufficient to keep us from using too many offsets.
+- * However, if the average multixact has many members, we might exhaust the
+- * members space while still using few enough members that these limits fail
+- * to trigger relminmxid advancement by VACUUM. At that point, we'd have no
+- * choice but to start failing multixact-creating operations with an error.
+- *
+- * To prevent that, if more than a threshold portion of the members space is
+- * used, we effectively reduce autovacuum_multixact_freeze_max_age and
+- * to a value just less than the number of multixacts in use. We hope that
+- * this will quickly trigger autovacuuming on the table or tables with the
+- * oldest relminmxid, thus allowing datminmxid values to advance and removing
+- * some members.
+- *
+- * As the fraction of the member space currently in use grows, we become
+- * more aggressive in clamping this value. That not only causes autovacuum
+- * to ramp up, but also makes any manual vacuums the user issues more
+- * aggressive. This happens because vacuum_get_cutoffs() will clamp the
+- * freeze table and the minimum freeze age cutoffs based on the effective
+- * autovacuum_multixact_freeze_max_age this function returns. In the worst
+- * case, we'll claim the freeze_max_age to zero, and every vacuum of any
+- * table will freeze every multixact.
+- */
+-int
+-MultiXactMemberFreezeThreshold(void)
+-{
+- MultiXactOffset members;
+- uint32 multixacts;
+- uint32 victim_multixacts;
+- double fraction;
+-
+- /* If we can't determine member space utilization, assume the worst. */
+- if (!ReadMultiXactCounts(&multixacts, &members))
+- return 0;
+-
+- /* If member space utilization is low, no special action is required. */
+- if (members <= MULTIXACT_MEMBER_SAFE_THRESHOLD)
+- return autovacuum_multixact_freeze_max_age;
+-
+- /*
+- * Compute a target for relminmxid advancement. The number of multixacts
+- * we try to eliminate from the system is based on how far we are past
+- * MULTIXACT_MEMBER_SAFE_THRESHOLD.
+- */
+- fraction = (double) (members - MULTIXACT_MEMBER_SAFE_THRESHOLD) /
+- (MULTIXACT_MEMBER_DANGER_THRESHOLD - MULTIXACT_MEMBER_SAFE_THRESHOLD);
+- victim_multixacts = multixacts * fraction;
+-
+- /* fraction could be > 1.0, but lowest possible freeze age is zero */
+- if (victim_multixacts > multixacts)
+- return 0;
+- return multixacts - victim_multixacts;
+-}
+-
+ typedef struct mxtruncinfo
+ {
+ int64 earliestExistingPage;
+@@ -2894,35 +2355,12 @@ SlruScanDirCbFindEarliest(SlruCtl ctl, char *filename, int64 segpage, void *data
+
+ /*
+ * Delete members segments [oldest, newOldest)
+- *
+- * The members SLRU can, in contrast to the offsets one, be filled to almost
+- * the full range at once. This means SimpleLruTruncate() can't trivially be
+- * used - instead the to-be-deleted range is computed using the offsets
+- * SLRU. C.f. TruncateMultiXact().
+ */
+ static void
+ PerformMembersTruncation(MultiXactOffset oldestOffset, MultiXactOffset newOldestOffset)
+ {
+- const int maxsegment = MXOffsetToMemberSegment(MaxMultiXactOffset);
+- int startsegment = MXOffsetToMemberSegment(oldestOffset);
+- int endsegment = MXOffsetToMemberSegment(newOldestOffset);
+- int segment = startsegment;
+-
+- /*
+- * Delete all the segments but the last one. The last segment can still
+- * contain, possibly partially, valid data.
+- */
+- while (segment != endsegment)
+- {
+- elog(DEBUG2, "truncating multixact members segment %x", segment);
+- SlruDeleteSegment(MultiXactMemberCtl, segment);
+-
+- /* move to next segment, handling wraparound correctly */
+- if (segment == maxsegment)
+- segment = 0;
+- else
+- segment += 1;
+- }
++ SimpleLruTruncate(MultiXactMemberCtl,
++ MXOffsetToMemberPage(newOldestOffset));
+ }
+
+ /*
+@@ -3147,7 +2585,7 @@ MultiXactOffsetPagePrecedes(int64 page1, int64 page2)
+
+ /*
+ * Decide whether a MultiXactMember page number is "older" for truncation
+- * purposes. There is no "invalid offset number" so use the numbers verbatim.
++ * purposes. There is no "invalid offset number" so use the numbers verbatim.
+ */
+ static bool
+ MultiXactMemberPagePrecedes(int64 page1, int64 page2)
+@@ -3172,7 +2610,7 @@ MultiXactMemberPagePrecedes(int64 page1, int64 page2)
+ bool
+ MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
+ {
+- int32 diff = (int32) (multi1 - multi2);
++ int64 diff = (int64) (multi1 - multi2);
+
+ return (diff < 0);
+ }
+@@ -3186,7 +2624,7 @@ MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
+ bool
+ MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
+ {
+- int32 diff = (int32) (multi1 - multi2);
++ int64 diff = (int64) (multi1 - multi2);
+
+ return (diff <= 0);
+ }
+@@ -3198,7 +2636,7 @@ MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
+ static bool
+ MultiXactOffsetPrecedes(MultiXactOffset offset1, MultiXactOffset offset2)
+ {
+- int32 diff = (int32) (offset1 - offset2);
++ int64 diff = (int64) (offset1 - offset2);
+
+ return (diff < 0);
+ }
+diff --git a/src/backend/access/transam/slru.c b/src/backend/access/transam/slru.c
+index ce1730740a..89669fbfb4 100644
+--- a/src/backend/access/transam/slru.c
++++ b/src/backend/access/transam/slru.c
+@@ -1453,7 +1453,7 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ * must not assign.
+ */
+ lhs = per_page + offset; /* skip first page to avoid non-normal XIDs */
+- rhs = lhs + (1U << 31);
++ rhs = lhs + (1ULL << 63);
+ Assert(TransactionIdPrecedes(lhs, rhs));
+ Assert(TransactionIdPrecedes(rhs, lhs));
+ Assert(!TransactionIdPrecedes(lhs - 1, rhs));
+@@ -1469,13 +1469,14 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ Assert(ctl->PagePrecedes(rhs / per_page, (lhs - 3 * per_page) / per_page));
+ Assert(ctl->PagePrecedes(rhs / per_page, (lhs - 2 * per_page) / per_page));
+ Assert(ctl->PagePrecedes(rhs / per_page, (lhs - 1 * per_page) / per_page)
+- || (1U << 31) % per_page != 0); /* See CommitTsPagePrecedes() */
++ || (1ULL << 63) % per_page != 0); /* See CommitTsPagePrecedes() */
+ Assert(ctl->PagePrecedes((lhs + 1 * per_page) / per_page, rhs / per_page)
+- || (1U << 31) % per_page != 0);
++ || (1ULL << 63) % per_page != 0);
+ Assert(ctl->PagePrecedes((lhs + 2 * per_page) / per_page, rhs / per_page));
+ Assert(ctl->PagePrecedes((lhs + 3 * per_page) / per_page, rhs / per_page));
+ Assert(!ctl->PagePrecedes(rhs / per_page, (lhs + per_page) / per_page));
+
++
+ /*
+ * GetNewTransactionId() has assigned the last XID it can safely use, and
+ * that XID is in the *LAST* page of the second segment. We must not
+@@ -1485,7 +1486,7 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ newestXact = newestPage * per_page + offset;
+ Assert(newestXact / per_page == newestPage);
+ oldestXact = newestXact + 1;
+- oldestXact -= 1U << 31;
++ oldestXact -= 1ULL << 63;
+ oldestPage = oldestXact / per_page;
+ Assert(!SlruMayDeleteSegment(ctl,
+ (newestPage -
+@@ -1501,7 +1502,7 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ newestXact = newestPage * per_page + offset;
+ Assert(newestXact / per_page == newestPage);
+ oldestXact = newestXact + 1;
+- oldestXact -= 1U << 31;
++ oldestXact -= 1ULL << 63;
+ oldestPage = oldestXact / per_page;
+ Assert(!SlruMayDeleteSegment(ctl,
+ (newestPage -
+diff --git a/src/backend/access/transam/subtrans.c b/src/backend/access/transam/subtrans.c
+index f45836192b..39260bf64b 100644
+--- a/src/backend/access/transam/subtrans.c
++++ b/src/backend/access/transam/subtrans.c
+@@ -222,11 +222,14 @@ void
+ BootStrapSUBTRANS(void)
+ {
+ int slotno;
++ int64 pageno;
++
++ pageno = TransactionIdToPage(XidFromFullTransactionId(ShmemVariableCache->nextXid));
+
+ LWLockAcquire(SubtransSLRULock, LW_EXCLUSIVE);
+
+ /* Create and zero the first page of the subtrans log */
+- slotno = ZeroSUBTRANSPage(0);
++ slotno = ZeroSUBTRANSPage(pageno);
+
+ /* Make sure it's written out */
+ SimpleLruWritePage(SubTransCtl, slotno);
+@@ -279,9 +282,6 @@ StartupSUBTRANS(TransactionId oldestActiveXID)
+ {
+ (void) ZeroSUBTRANSPage(startPage);
+ startPage++;
+- /* must account for wraparound */
+- if (startPage > TransactionIdToPage(MaxTransactionId))
+- startPage = 0;
+ }
+ (void) ZeroSUBTRANSPage(startPage);
+
+@@ -358,6 +358,7 @@ TruncateSUBTRANS(TransactionId oldestXact)
+ * a page and oldestXact == next XID. In that case, if we didn't subtract
+ * one, we'd trigger SimpleLruTruncate's wraparound detection.
+ */
++
+ TransactionIdRetreat(oldestXact);
+ cutoffPage = TransactionIdToPage(oldestXact);
+
+diff --git a/src/backend/access/transam/transam.c b/src/backend/access/transam/transam.c
+index beb7d54f4d..de3b30cec8 100644
+--- a/src/backend/access/transam/transam.c
++++ b/src/backend/access/transam/transam.c
+@@ -281,14 +281,14 @@ TransactionIdPrecedes(TransactionId id1, TransactionId id2)
+ {
+ /*
+ * If either ID is a permanent XID then we can just do unsigned
+- * comparison. If both are normal, do a modulo-2^32 comparison.
++ * comparison. If both are normal, do a modulo-2^64 comparison.
+ */
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 < id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff < 0);
+ }
+
+@@ -298,12 +298,12 @@ TransactionIdPrecedes(TransactionId id1, TransactionId id2)
+ bool
+ TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
+ {
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 <= id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff <= 0);
+ }
+
+@@ -313,12 +313,12 @@ TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
+ bool
+ TransactionIdFollows(TransactionId id1, TransactionId id2)
+ {
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 > id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff > 0);
+ }
+
+@@ -328,12 +328,12 @@ TransactionIdFollows(TransactionId id1, TransactionId id2)
+ bool
+ TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
+ {
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 >= id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff >= 0);
+ }
+
+diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
+index 6007fd50f0..205d577584 100644
+--- a/src/backend/access/transam/twophase.c
++++ b/src/backend/access/transam/twophase.c
+@@ -477,8 +477,8 @@ MarkAsPreparingGuts(GlobalTransaction gxact, TransactionId xid, const char *gid,
+ proc->lxid = xid;
+ proc->backendId = InvalidBackendId;
+ }
+- proc->xid = xid;
+- Assert(proc->xmin == InvalidTransactionId);
++ pg_atomic_write_u64(&proc->xid, xid);
++ Assert(pg_atomic_read_u64(&proc->xmin) == InvalidTransactionId);
+ proc->delayChkptFlags = 0;
+ proc->statusFlags = 0;
+ proc->pid = 0;
+@@ -793,7 +793,7 @@ pg_prepared_xact(PG_FUNCTION_ARGS)
+ * Form tuple with appropriate data.
+ */
+
+- values[0] = TransactionIdGetDatum(proc->xid);
++ values[0] = TransactionIdGetDatum(pg_atomic_read_u64(&proc->xid));
+ values[1] = CStringGetTextDatum(gxact->gid);
+ values[2] = TimestampTzGetDatum(gxact->prepared_at);
+ values[3] = ObjectIdGetDatum(gxact->owner);
+@@ -943,46 +943,8 @@ TwoPhaseGetDummyProc(TransactionId xid, bool lock_held)
+ /* State file support */
+ /************************************************************************/
+
+-/*
+- * Compute the FullTransactionId for the given TransactionId.
+- *
+- * The wrap logic is safe here because the span of active xids cannot exceed one
+- * epoch at any given time.
+- */
+-static inline FullTransactionId
+-AdjustToFullTransactionId(TransactionId xid)
+-{
+- FullTransactionId nextFullXid;
+- TransactionId nextXid;
+- uint32 epoch;
+-
+- Assert(TransactionIdIsValid(xid));
+-
+- LWLockAcquire(XidGenLock, LW_SHARED);
+- nextFullXid = ShmemVariableCache->nextXid;
+- LWLockRelease(XidGenLock);
+-
+- nextXid = XidFromFullTransactionId(nextFullXid);
+- epoch = EpochFromFullTransactionId(nextFullXid);
+- if (unlikely(xid > nextXid))
+- {
+- /* Wraparound occurred, must be from a prev epoch. */
+- Assert(epoch > 0);
+- epoch--;
+- }
+-
+- return FullTransactionIdFromEpochAndXid(epoch, xid);
+-}
+-
+-static inline int
+-TwoPhaseFilePath(char *path, TransactionId xid)
+-{
+- FullTransactionId fxid = AdjustToFullTransactionId(xid);
+-
+- return snprintf(path, MAXPGPATH, TWOPHASE_DIR "/%08X%08X",
+- EpochFromFullTransactionId(fxid),
+- XidFromFullTransactionId(fxid));
+-}
++#define TwoPhaseFilePath(path, xid) \
++ snprintf(path, MAXPGPATH, TWOPHASE_DIR "/%016llX", (unsigned long long) xid)
+
+ /*
+ * 2PC state file format:
+@@ -1925,11 +1887,9 @@ restoreTwoPhaseData(void)
+ strspn(clde->d_name, "0123456789ABCDEF") == 16)
+ {
+ TransactionId xid;
+- FullTransactionId fxid;
+ char *buf;
+
+- fxid = FullTransactionIdFromU64(strtou64(clde->d_name, NULL, 16));
+- xid = XidFromFullTransactionId(fxid);
++ xid = (TransactionId) strtou64(clde->d_name, NULL, 16);
+
+ buf = ProcessTwoPhaseBuffer(xid, InvalidXLogRecPtr,
+ true, false, false);
+@@ -2261,7 +2221,6 @@ ProcessTwoPhaseBuffer(TransactionId xid,
+
+ if (fromdisk)
+ {
+- /* Read and validate file */
+ buf = ReadTwoPhaseFile(xid, false);
+ }
+ else
+diff --git a/src/backend/access/transam/varsup.c b/src/backend/access/transam/varsup.c
+index 4be1055c1a..b8eefe7d3f 100644
+--- a/src/backend/access/transam/varsup.c
++++ b/src/backend/access/transam/varsup.c
+@@ -66,9 +66,9 @@ GetNewTransactionId(bool isSubXact)
+ if (IsBootstrapProcessingMode())
+ {
+ Assert(!isSubXact);
+- MyProc->xid = BootstrapTransactionId;
+- ProcGlobal->xids[MyProc->pgxactoff] = BootstrapTransactionId;
+- return FullTransactionIdFromEpochAndXid(0, BootstrapTransactionId);
++ pg_atomic_write_u64(&MyProc->xid, BootstrapTransactionId);
++ pg_atomic_write_u64(&ProcGlobal->xids[MyProc->pgxactoff], BootstrapTransactionId);
++ return FullTransactionIdFromXid(BootstrapTransactionId);
+ }
+
+ /* safety check, we should never get this far in a HS standby */
+@@ -80,19 +80,6 @@ GetNewTransactionId(bool isSubXact)
+ full_xid = ShmemVariableCache->nextXid;
+ xid = XidFromFullTransactionId(full_xid);
+
+- /*----------
+- * Check to see if it's safe to assign another XID. This protects against
+- * catastrophic data loss due to XID wraparound. The basic rules are:
+- *
+- * If we're past xidVacLimit, start trying to force autovacuum cycles.
+- * If we're past xidWarnLimit, start issuing warnings.
+- * If we're past xidStopLimit, refuse to execute transactions, unless
+- * we are running in single-user mode (which gives an escape hatch
+- * to the DBA who somehow got past the earlier defenses).
+- *
+- * Note that this coding also appears in GetNewMultiXactId.
+- *----------
+- */
+ if (TransactionIdFollowsOrEquals(xid, ShmemVariableCache->xidVacLimit))
+ {
+ /*
+@@ -102,11 +89,6 @@ GetNewTransactionId(bool isSubXact)
+ * possibility of deadlock while doing get_database_name(). First,
+ * copy all the shared values we'll need in this path.
+ */
+- TransactionId xidWarnLimit = ShmemVariableCache->xidWarnLimit;
+- TransactionId xidStopLimit = ShmemVariableCache->xidStopLimit;
+- TransactionId xidWrapLimit = ShmemVariableCache->xidWrapLimit;
+- Oid oldest_datoid = ShmemVariableCache->oldestXidDB;
+-
+ LWLockRelease(XidGenLock);
+
+ /*
+@@ -117,48 +99,6 @@ GetNewTransactionId(bool isSubXact)
+ if (IsUnderPostmaster && (xid % 65536) == 0)
+ SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+
+- if (IsUnderPostmaster &&
+- TransactionIdFollowsOrEquals(xid, xidStopLimit))
+- {
+- char *oldest_datname = get_database_name(oldest_datoid);
+-
+- /* complain even if that DB has disappeared */
+- if (oldest_datname)
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("database is not accepting commands that assign new XIDs to avoid wraparound data loss in database \"%s\"",
+- oldest_datname),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("database is not accepting commands that assign new XIDs to avoid wraparound data loss in database with OID %u",
+- oldest_datoid),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+- else if (TransactionIdFollowsOrEquals(xid, xidWarnLimit))
+- {
+- char *oldest_datname = get_database_name(oldest_datoid);
+-
+- /* complain even if that DB has disappeared */
+- if (oldest_datname)
+- ereport(WARNING,
+- (errmsg("database \"%s\" must be vacuumed within %llu transactions",
+- oldest_datname,
+- (unsigned long long) xidWrapLimit - xid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(WARNING,
+- (errmsg("database with OID %u must be vacuumed within %llu transactions",
+- oldest_datoid,
+- (unsigned long long) xidWrapLimit - xid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+-
+ /* Re-acquire lock and start over */
+ LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
+ full_xid = ShmemVariableCache->nextXid;
+@@ -228,8 +168,8 @@ GetNewTransactionId(bool isSubXact)
+ Assert(!MyProc->subxidStatus.overflowed);
+
+ /* LWLockRelease acts as barrier */
+- MyProc->xid = xid;
+- ProcGlobal->xids[MyProc->pgxactoff] = xid;
++ pg_atomic_write_u64(&MyProc->xid, xid);
++ pg_atomic_write_u64(&ProcGlobal->xids[MyProc->pgxactoff], xid);
+ }
+ else
+ {
+@@ -270,7 +210,7 @@ ReadNextFullTransactionId(void)
+ }
+
+ /*
+- * Advance nextXid to the value after a given xid. The epoch is inferred.
++ * Advance nextXid to the value after a given xid.
+ * This must only be called during recovery or from two-phase start-up code.
+ */
+ void
+@@ -278,7 +218,6 @@ AdvanceNextFullTransactionIdPastXid(TransactionId xid)
+ {
+ FullTransactionId newNextFullXid;
+ TransactionId next_xid;
+- uint32 epoch;
+
+ /*
+ * It is safe to read nextXid without a lock, because this is only called
+@@ -292,19 +231,9 @@ AdvanceNextFullTransactionIdPastXid(TransactionId xid)
+ if (!TransactionIdFollowsOrEquals(xid, next_xid))
+ return;
+
+- /*
+- * Compute the FullTransactionId that comes after the given xid. To do
+- * this, we preserve the existing epoch, but detect when we've wrapped
+- * into a new epoch. This is necessary because WAL records and 2PC state
+- * currently contain 32 bit xids. The wrap logic is safe in those cases
+- * because the span of active xids cannot exceed one epoch at any given
+- * point in the WAL stream.
+- */
++ /* Compute the FullTransactionId that comes after the given xid. */
+ TransactionIdAdvance(xid);
+- epoch = EpochFromFullTransactionId(ShmemVariableCache->nextXid);
+- if (unlikely(xid < next_xid))
+- ++epoch;
+- newNextFullXid = FullTransactionIdFromEpochAndXid(epoch, xid);
++ newNextFullXid = FullTransactionIdFromXid(xid);
+
+ /*
+ * We still need to take a lock to modify the value when there are
+@@ -345,61 +274,14 @@ void
+ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+ {
+ TransactionId xidVacLimit;
+- TransactionId xidWarnLimit;
+- TransactionId xidStopLimit;
+- TransactionId xidWrapLimit;
+ TransactionId curXid;
+
+ Assert(TransactionIdIsNormal(oldest_datfrozenxid));
+
+- /*
+- * The place where we actually get into deep trouble is halfway around
+- * from the oldest potentially-existing XID. (This calculation is
+- * probably off by one or two counts, because the special XIDs reduce the
+- * size of the loop a little bit. But we throw in plenty of slop below,
+- * so it doesn't matter.)
+- */
+- xidWrapLimit = oldest_datfrozenxid + (MaxTransactionId >> 1);
+- if (xidWrapLimit < FirstNormalTransactionId)
+- xidWrapLimit += FirstNormalTransactionId;
+-
+- /*
+- * We'll refuse to continue assigning XIDs in interactive mode once we get
+- * within 3M transactions of data loss. This leaves lots of room for the
+- * DBA to fool around fixing things in a standalone backend, while not
+- * being significant compared to total XID space. (VACUUM requires an XID
+- * if it truncates at wal_level!=minimal. "VACUUM (ANALYZE)", which a DBA
+- * might do by reflex, assigns an XID. Hence, we had better be sure
+- * there's lots of XIDs left...) Also, at default BLCKSZ, this leaves two
+- * completely-idle segments. In the event of edge-case bugs involving
+- * page or segment arithmetic, idle segments render the bugs unreachable
+- * outside of single-user mode.
+- */
+- xidStopLimit = xidWrapLimit - 3000000;
+- if (xidStopLimit < FirstNormalTransactionId)
+- xidStopLimit -= FirstNormalTransactionId;
+-
+- /*
+- * We'll start complaining loudly when we get within 40M transactions of
+- * data loss. This is kind of arbitrary, but if you let your gas gauge
+- * get down to 2% of full, would you be looking for the next gas station?
+- * We need to be fairly liberal about this number because there are lots
+- * of scenarios where most transactions are done by automatic clients that
+- * won't pay attention to warnings. (No, we're not gonna make this
+- * configurable. If you know enough to configure it, you know enough to
+- * not get in this kind of trouble in the first place.)
+- */
+- xidWarnLimit = xidWrapLimit - 40000000;
+- if (xidWarnLimit < FirstNormalTransactionId)
+- xidWarnLimit -= FirstNormalTransactionId;
+-
+ /*
+ * We'll start trying to force autovacuums when oldest_datfrozenxid gets
+ * to be more than autovacuum_freeze_max_age transactions old.
+ *
+- * Note: guc.c ensures that autovacuum_freeze_max_age is in a sane range,
+- * so that xidVacLimit will be well before xidWarnLimit.
+- *
+ * Note: autovacuum_freeze_max_age is a PGC_POSTMASTER parameter so that
+ * we don't have to worry about dealing with on-the-fly changes in its
+ * value. It doesn't look practical to update shared state from a GUC
+@@ -416,18 +298,10 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+ LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
+ ShmemVariableCache->oldestXid = oldest_datfrozenxid;
+ ShmemVariableCache->xidVacLimit = xidVacLimit;
+- ShmemVariableCache->xidWarnLimit = xidWarnLimit;
+- ShmemVariableCache->xidStopLimit = xidStopLimit;
+- ShmemVariableCache->xidWrapLimit = xidWrapLimit;
+ ShmemVariableCache->oldestXidDB = oldest_datoid;
+ curXid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ LWLockRelease(XidGenLock);
+
+- /* Log the info */
+- ereport(DEBUG1,
+- (errmsg_internal("transaction ID wrap limit is %llu, limited by database with OID %u",
+- (unsigned long long) xidWrapLimit, oldest_datoid)));
+-
+ /*
+ * If past the autovacuum force point, immediately signal an autovac
+ * request. The reason for this is that autovac only processes one
+@@ -438,41 +312,6 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+ if (TransactionIdFollowsOrEquals(curXid, xidVacLimit) &&
+ IsUnderPostmaster && !InRecovery)
+ SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+-
+- /* Give an immediate warning if past the wrap warn point */
+- if (TransactionIdFollowsOrEquals(curXid, xidWarnLimit) && !InRecovery)
+- {
+- char *oldest_datname;
+-
+- /*
+- * We can be called when not inside a transaction, for example during
+- * StartupXLOG(). In such a case we cannot do database access, so we
+- * must just report the oldest DB's OID.
+- *
+- * Note: it's also possible that get_database_name fails and returns
+- * NULL, for example because the database just got dropped. We'll
+- * still warn, even though the warning might now be unnecessary.
+- */
+- if (IsTransactionState())
+- oldest_datname = get_database_name(oldest_datoid);
+- else
+- oldest_datname = NULL;
+-
+- if (oldest_datname)
+- ereport(WARNING,
+- (errmsg("database \"%s\" must be vacuumed within %llu transactions",
+- oldest_datname,
+- (unsigned long long) xidWrapLimit - curXid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(WARNING,
+- (errmsg("database with OID %u must be vacuumed within %llu transactions",
+- oldest_datoid,
+- (unsigned long long) xidWrapLimit - curXid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+ }
+
+
+diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
+index 8d7427115b..483afac8b7 100644
+--- a/src/backend/access/transam/xact.c
++++ b/src/backend/access/transam/xact.c
+@@ -5714,6 +5714,17 @@ XactLogCommitRecord(TimestampTz commit_time,
+ xl_subxacts.nsubxacts = nsubxacts;
+ }
+
++ if (TransactionIdIsValid(twophase_xid))
++ {
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
++ xl_twophase.xid_lo = (uint32) (twophase_xid & 0xFFFFFFFF);
++ xl_twophase.xid_hi = (uint32) (twophase_xid >> 32);
++ Assert(twophase_gid != NULL);
++
++ if (XLogLogicalInfoActive())
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
++ }
++
+ if (nrels > 0)
+ {
+ xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
+@@ -5733,16 +5744,6 @@ XactLogCommitRecord(TimestampTz commit_time,
+ xl_invals.nmsgs = nmsgs;
+ }
+
+- if (TransactionIdIsValid(twophase_xid))
+- {
+- xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
+- xl_twophase.xid = twophase_xid;
+- Assert(twophase_gid != NULL);
+-
+- if (XLogLogicalInfoActive())
+- xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
+- }
+-
+ /* dump transaction origin information */
+ if (replorigin_session_origin != InvalidRepOriginId)
+ {
+@@ -5863,6 +5864,17 @@ XactLogAbortRecord(TimestampTz abort_time,
+ xl_subxacts.nsubxacts = nsubxacts;
+ }
+
++ if (TransactionIdIsValid(twophase_xid))
++ {
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
++ xl_twophase.xid_lo = (uint32) (twophase_xid & 0xFFFFFFFF);
++ xl_twophase.xid_hi = (uint32) (twophase_xid >> 32);
++ Assert(twophase_gid != NULL);
++
++ if (XLogLogicalInfoActive())
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
++ }
++
+ if (nrels > 0)
+ {
+ xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
+@@ -5879,7 +5891,8 @@ XactLogAbortRecord(TimestampTz abort_time,
+ if (TransactionIdIsValid(twophase_xid))
+ {
+ xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
+- xl_twophase.xid = twophase_xid;
++ xl_twophase.xid_lo = (uint32) (twophase_xid & 0xFFFFFFFF);
++ xl_twophase.xid_hi = (uint32) (twophase_xid >> 32);
+ Assert(twophase_gid != NULL);
+
+ if (XLogLogicalInfoActive())
+diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
+index 2d603d8dee..6613563aff 100644
+--- a/src/backend/access/transam/xlog.c
++++ b/src/backend/access/transam/xlog.c
+@@ -4805,8 +4805,7 @@ BootStrapXLOG(void)
+ checkPoint.ThisTimeLineID = BootstrapTimeLineID;
+ checkPoint.PrevTimeLineID = BootstrapTimeLineID;
+ checkPoint.fullPageWrites = fullPageWrites;
+- checkPoint.nextXid =
+- FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
++ checkPoint.nextXid = FullTransactionIdFromXid(FirstNormalTransactionId);
+ checkPoint.nextOid = FirstGenbkiObjectId;
+ checkPoint.nextMulti = FirstMultiXactId;
+ checkPoint.nextMultiOffset = 0;
+@@ -6945,7 +6944,7 @@ CreateCheckPoint(int flags)
+ UpdateControlFile();
+ LWLockRelease(ControlFileLock);
+
+- /* Update shared-memory copy of checkpoint XID/epoch */
++ /* Update shared-memory copy of checkpoint XID/base */
+ SpinLockAcquire(&XLogCtl->info_lck);
+ XLogCtl->ckptFullXid = checkPoint.nextXid;
+ SpinLockRelease(&XLogCtl->info_lck);
+@@ -7976,7 +7975,7 @@ xlog_redo(XLogReaderState *record)
+ ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
+ LWLockRelease(ControlFileLock);
+
+- /* Update shared-memory copy of checkpoint XID/epoch */
++ /* Update shared-memory copy of checkpoint XID/base */
+ SpinLockAcquire(&XLogCtl->info_lck);
+ XLogCtl->ckptFullXid = checkPoint.nextXid;
+ SpinLockRelease(&XLogCtl->info_lck);
+@@ -8037,7 +8036,7 @@ xlog_redo(XLogReaderState *record)
+ ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
+ LWLockRelease(ControlFileLock);
+
+- /* Update shared-memory copy of checkpoint XID/epoch */
++ /* Update shared-memory copy of checkpoint XID/base */
+ SpinLockAcquire(&XLogCtl->info_lck);
+ XLogCtl->ckptFullXid = checkPoint.nextXid;
+ SpinLockRelease(&XLogCtl->info_lck);
+diff --git a/src/backend/access/transam/xloginsert.c b/src/backend/access/transam/xloginsert.c
+index e4aaa551a0..e84261684c 100644
+--- a/src/backend/access/transam/xloginsert.c
++++ b/src/backend/access/transam/xloginsert.c
+@@ -274,6 +274,11 @@ XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
+ BufferGetTag(buffer, ®buf->rlocator, ®buf->forkno, ®buf->block);
+ regbuf->page = BufferGetPage(buffer);
+ regbuf->flags = flags;
++ if (IsBufferConverted(buffer))
++ {
++ regbuf->flags |= REGBUF_CONVERTED;
++ MarkBufferConverted(buffer, false);
++ }
+ regbuf->rdata_tail = (XLogRecData *) ®buf->rdata_head;
+ regbuf->rdata_len = 0;
+
+@@ -607,6 +612,8 @@ XLogRecordAssemble(RmgrId rmid, uint8 info,
+ needs_backup = true;
+ else if (regbuf->flags & REGBUF_NO_IMAGE)
+ needs_backup = false;
++ else if (regbuf->flags & REGBUF_CONVERTED)
++ needs_backup = true;
+ else if (!doPageWrites)
+ needs_backup = false;
+ else
+diff --git a/src/backend/access/transam/xlogreader.c b/src/backend/access/transam/xlogreader.c
+index e0baa86bd3..5cbd428e52 100644
+--- a/src/backend/access/transam/xlogreader.c
++++ b/src/backend/access/transam/xlogreader.c
+@@ -2134,37 +2134,3 @@ RestoreBlockImage(XLogReaderState *record, uint8 block_id, char *page)
+
+ return true;
+ }
+-
+-#ifndef FRONTEND
+-
+-/*
+- * Extract the FullTransactionId from a WAL record.
+- */
+-FullTransactionId
+-XLogRecGetFullXid(XLogReaderState *record)
+-{
+- TransactionId xid,
+- next_xid;
+- uint32 epoch;
+-
+- /*
+- * This function is only safe during replay, because it depends on the
+- * replay state. See AdvanceNextFullTransactionIdPastXid() for more.
+- */
+- Assert(AmStartupProcess() || !IsUnderPostmaster);
+-
+- xid = XLogRecGetXid(record);
+- next_xid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+- epoch = EpochFromFullTransactionId(ShmemVariableCache->nextXid);
+-
+- /*
+- * If xid is numerically greater than next_xid, it has to be from the last
+- * epoch.
+- */
+- if (unlikely(xid > next_xid))
+- --epoch;
+-
+- return FullTransactionIdFromEpochAndXid(epoch, xid);
+-}
+-
+-#endif
+diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c
+index e01dca9b7c..16de61f5ed 100644
+--- a/src/backend/bootstrap/bootstrap.c
++++ b/src/backend/bootstrap/bootstrap.c
+@@ -120,7 +120,7 @@ static const struct typinfo TypInfo[] = {
+ F_OIDIN, F_OIDOUT},
+ {"tid", TIDOID, 0, 6, false, TYPALIGN_SHORT, TYPSTORAGE_PLAIN, InvalidOid,
+ F_TIDIN, F_TIDOUT},
+- {"xid", XIDOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
++ {"xid", XIDOID, 0, 8, FLOAT8PASSBYVAL, TYPALIGN_XID, TYPSTORAGE_PLAIN, InvalidOid,
+ F_XIDIN, F_XIDOUT},
+ {"cid", CIDOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
+ F_CIDIN, F_CIDOUT},
+diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
+index 7224d96695..3313d309ee 100644
+--- a/src/backend/catalog/heap.c
++++ b/src/backend/catalog/heap.c
+@@ -159,8 +159,8 @@ static const FormData_pg_attribute a2 = {
+ .attnum = MinTransactionIdAttributeNumber,
+ .attcacheoff = -1,
+ .atttypmod = -1,
+- .attbyval = true,
+- .attalign = TYPALIGN_INT,
++ .attbyval = FLOAT8PASSBYVAL,
++ .attalign = TYPALIGN_XID,
+ .attstorage = TYPSTORAGE_PLAIN,
+ .attnotnull = true,
+ .attislocal = true,
+@@ -187,8 +187,8 @@ static const FormData_pg_attribute a4 = {
+ .attnum = MaxTransactionIdAttributeNumber,
+ .attcacheoff = -1,
+ .atttypmod = -1,
+- .attbyval = true,
+- .attalign = TYPALIGN_INT,
++ .attbyval = FLOAT8PASSBYVAL,
++ .attalign = TYPALIGN_XID,
+ .attstorage = TYPSTORAGE_PLAIN,
+ .attnotnull = true,
+ .attislocal = true,
+diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
+index da969bd2f9..ac6fd7cc2a 100644
+--- a/src/backend/catalog/pg_inherits.c
++++ b/src/backend/catalog/pg_inherits.c
+@@ -146,7 +146,7 @@ find_inheritance_children_extended(Oid parentrelId, bool omit_detached,
+ TransactionId xmin;
+ Snapshot snap;
+
+- xmin = HeapTupleHeaderGetXmin(inheritsTuple->t_data);
++ xmin = HeapTupleGetXmin(inheritsTuple);
+ snap = GetActiveSnapshot();
+
+ if (!XidInMVCCSnapshot(xmin, snap))
+diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
+index 264f25a8f9..ff60d303e1 100644
+--- a/src/backend/commands/async.c
++++ b/src/backend/commands/async.c
+@@ -186,7 +186,7 @@ typedef struct AsyncQueueEntry
+ } AsyncQueueEntry;
+
+ /* Currently, no field of AsyncQueueEntry requires more than int alignment */
+-#define QUEUEALIGN(len) INTALIGN(len)
++#define QUEUEALIGN(len) TYPEALIGN(8, len)
+
+ #define AsyncQueueEntryEmptySize (offsetof(AsyncQueueEntry, data) + 2)
+
+diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c
+index ae38f83024..246220a1de 100644
+--- a/src/backend/commands/dbcommands.c
++++ b/src/backend/commands/dbcommands.c
+@@ -130,7 +130,8 @@ static void CreateDatabaseUsingWalLog(Oid src_dboid, Oid dst_dboid, Oid src_tsid
+ static List *ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath);
+ static List *ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid,
+ Oid dbid, char *srcpath,
+- List *rlocatorlist, Snapshot snapshot);
++ List *rlocatorlist, Snapshot snapshot,
++ bool is_toast);
+ static CreateDBRelInfo *ScanSourceDatabasePgClassTuple(HeapTupleData *tuple,
+ Oid tbid, Oid dbid,
+ char *srcpath);
+@@ -308,9 +309,10 @@ ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath)
+ }
+
+ /* Append relevant pg_class tuples for current page to rlocatorlist. */
++ /* No toast is expected in sys tables */
+ rlocatorlist = ScanSourceDatabasePgClassPage(page, buf, tbid, dbid,
+ srcpath, rlocatorlist,
+- snapshot);
++ snapshot, false);
+
+ UnlockReleaseBuffer(buf);
+ }
+@@ -328,7 +330,7 @@ ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath)
+ static List *
+ ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid, Oid dbid,
+ char *srcpath, List *rlocatorlist,
+- Snapshot snapshot)
++ Snapshot snapshot, bool is_toast)
+ {
+ BlockNumber blkno = BufferGetBlockNumber(buf);
+ OffsetNumber offnum;
+@@ -358,6 +360,7 @@ ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid, Oid dbid,
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationRelationId;
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, is_toast);
+
+ /* Skip tuples that are not visible to this snapshot. */
+ if (HeapTupleSatisfiesVisibility(&tuple, snapshot, buf))
+diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
+index e56205abd8..d0aac5d080 100644
+--- a/src/backend/commands/indexcmds.c
++++ b/src/backend/commands/indexcmds.c
+@@ -1760,7 +1760,7 @@ DefineIndex(Oid tableId,
+ set_indexsafe_procflags();
+
+ /* We should now definitely not be advertising any xmin. */
+- Assert(MyProc->xmin == InvalidTransactionId);
++ Assert(pg_atomic_read_u64(&MyProc->xmin) == InvalidTransactionId);
+
+ /*
+ * The index is now valid in the sense that it contains all currently
+@@ -4433,8 +4433,8 @@ set_indexsafe_procflags(void)
+ * This should only be called before installing xid or xmin in MyProc;
+ * otherwise, concurrent processes could see an Xmin that moves backwards.
+ */
+- Assert(MyProc->xid == InvalidTransactionId &&
+- MyProc->xmin == InvalidTransactionId);
++ Assert(pg_atomic_read_u64(&MyProc->xid) == InvalidTransactionId &&
++ pg_atomic_read_u64(&MyProc->xmin) == InvalidTransactionId);
+
+ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
+ MyProc->statusFlags |= PROC_IN_SAFE_IC;
+diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
+index da2ace79cc..47e7b879ea 100644
+--- a/src/backend/commands/sequence.c
++++ b/src/backend/commands/sequence.c
+@@ -48,6 +48,25 @@
+ #include "utils/syscache.h"
+ #include "utils/varlena.h"
+
++static inline void
++SeqTupleSetXmin(HeapTuple htup, TransactionId xid)
++{
++ htup->t_xmin = xid;
++ htup->t_data->t_choice.t_heap.t_xmin = xid;
++}
++
++static inline void
++SeqTupleSetXmax(HeapTuple htup, TransactionId xid)
++{
++ htup->t_xmin = xid;
++ htup->t_data->t_choice.t_heap.t_xmax = xid;
++}
++
++static inline TransactionId
++SeqTupleHeaderGetRawXmax(HeapTupleHeader htup)
++{
++ return htup->t_choice.t_heap.t_xmax;
++}
+
+ /*
+ * We don't want to log each fetching of a value from a sequence,
+@@ -383,10 +402,10 @@ fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNumber forkNum)
+ * because if the current transaction aborts, no other xact will ever
+ * examine the sequence tuple anyway.
+ */
+- HeapTupleHeaderSetXmin(tuple->t_data, FrozenTransactionId);
+- HeapTupleHeaderSetXminFrozen(tuple->t_data);
++ SeqTupleSetXmin(tuple, FrozenTransactionId);
++ HeapTupleHeaderStoreXminFrozen(tuple->t_data);
+ HeapTupleHeaderSetCmin(tuple->t_data, FirstCommandId);
+- HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId);
++ SeqTupleSetXmax(tuple, InvalidTransactionId);
+ tuple->t_data->t_infomask |= HEAP_XMAX_INVALID;
+ ItemPointerSet(&tuple->t_data->t_ctid, 0, FirstOffsetNumber);
+
+@@ -1208,6 +1227,7 @@ read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple)
+ /* Note we currently only bother to set these two fields of *seqdatatuple */
+ seqdatatuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ seqdatatuple->t_len = ItemIdGetLength(lp);
++ HeapTupleCopyHeaderXids(seqdatatuple);
+
+ /*
+ * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE on
+@@ -1218,9 +1238,9 @@ read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple)
+ * this again if the update gets lost.
+ */
+ Assert(!(seqdatatuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI));
+- if (HeapTupleHeaderGetRawXmax(seqdatatuple->t_data) != InvalidTransactionId)
++ if (SeqTupleHeaderGetRawXmax(seqdatatuple->t_data) != InvalidTransactionId)
+ {
+- HeapTupleHeaderSetXmax(seqdatatuple->t_data, InvalidTransactionId);
++ SeqTupleSetXmax(seqdatatuple, InvalidTransactionId);
+ seqdatatuple->t_data->t_infomask &= ~HEAP_XMAX_COMMITTED;
+ seqdatatuple->t_data->t_infomask |= HEAP_XMAX_INVALID;
+ MarkBufferDirtyHint(*buf, true);
+diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
+index 087ac3e3b4..3931c075ee 100644
+--- a/src/backend/commands/vacuum.c
++++ b/src/backend/commands/vacuum.c
+@@ -66,12 +66,12 @@
+ /*
+ * GUC parameters
+ */
+-int vacuum_freeze_min_age;
+-int vacuum_freeze_table_age;
+-int vacuum_multixact_freeze_min_age;
+-int vacuum_multixact_freeze_table_age;
+-int vacuum_failsafe_age;
+-int vacuum_multixact_failsafe_age;
++int64 vacuum_freeze_min_age;
++int64 vacuum_freeze_table_age;
++int64 vacuum_multixact_freeze_min_age;
++int64 vacuum_multixact_freeze_table_age;
++int64 vacuum_failsafe_age;
++int64 vacuum_multixact_failsafe_age;
+
+ /*
+ * Variables for cost-based vacuum delay. The defaults differ between
+@@ -1075,7 +1075,7 @@ bool
+ vacuum_get_cutoffs(Relation rel, const VacuumParams *params,
+ struct VacuumCutoffs *cutoffs)
+ {
+- int freeze_min_age,
++ int64 freeze_min_age,
+ multixact_freeze_min_age,
+ freeze_table_age,
+ multixact_freeze_table_age,
+@@ -1125,7 +1125,7 @@ vacuum_get_cutoffs(Relation rel, const VacuumParams *params,
+ * normally autovacuum_multixact_freeze_max_age, but may be less if we are
+ * short of multixact member space.
+ */
+- effective_multixact_freeze_max_age = MultiXactMemberFreezeThreshold();
++ effective_multixact_freeze_max_age = autovacuum_multixact_freeze_max_age;
+
+ /*
+ * Almost ready to set freeze output parameters; check if OldestXmin or
+@@ -1484,6 +1484,9 @@ vac_update_relstats(Relation relation,
+ futurexid = false;
+ if (frozenxid_updated)
+ *frozenxid_updated = false;
++
++ Assert(TransactionIdPrecedesOrEquals(frozenxid, ReadNextTransactionId()));
++
+ if (TransactionIdIsNormal(frozenxid) && oldfrozenxid != frozenxid)
+ {
+ bool update = false;
+@@ -1507,6 +1510,9 @@ vac_update_relstats(Relation relation,
+ futuremxid = false;
+ if (minmulti_updated)
+ *minmulti_updated = false;
++
++ Assert(MultiXactIdPrecedesOrEquals(minmulti, ReadNextMultiXactId()));
++
+ if (MultiXactIdIsValid(minmulti) && oldminmulti != minmulti)
+ {
+ bool update = false;
+diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
+index 24c2b60c62..56d09d28c3 100644
+--- a/src/backend/executor/execExprInterp.c
++++ b/src/backend/executor/execExprInterp.c
+@@ -3196,6 +3196,7 @@ ExecEvalFieldStoreDeForm(ExprState *state, ExprEvalStep *op, ExprContext *econte
+ tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tmptup);
+ tmptup.t_data = tuphdr;
+
+ /*
+diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
+index 16704c0c2f..5d299e0083 100644
+--- a/src/backend/executor/execUtils.c
++++ b/src/backend/executor/execUtils.c
+@@ -1047,6 +1047,7 @@ GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)
+ tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tmptup);
+ tmptup.t_data = tuple;
+
+ result = heap_getattr(&tmptup,
+diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
+index b16fbe9e22..2981dc4934 100644
+--- a/src/backend/executor/nodeModifyTable.c
++++ b/src/backend/executor/nodeModifyTable.c
+@@ -3783,6 +3783,7 @@ ExecModifyTable(PlanState *pstate)
+ HeapTupleHeaderGetDatumLength(oldtupdata.t_data);
+ ItemPointerSetInvalid(&(oldtupdata.t_self));
+ /* Historically, view triggers see invalid t_tableOid. */
++ HeapTupleCopyHeaderXids(&oldtupdata);
+ oldtupdata.t_tableOid =
+ (relkind == RELKIND_VIEW) ? InvalidOid :
+ RelationGetRelid(resultRelInfo->ri_RelationDesc);
+diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c
+index 0e46c59d25..88846e4fd2 100644
+--- a/src/backend/executor/spi.c
++++ b/src/backend/executor/spi.c
+@@ -1154,6 +1154,7 @@ SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum,
+ mtuple->t_data->t_ctid = tuple->t_data->t_ctid;
+ mtuple->t_self = tuple->t_self;
+ mtuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(mtuple, tuple);
+ }
+ else
+ {
+diff --git a/src/backend/nodes/gen_node_support.pl b/src/backend/nodes/gen_node_support.pl
+index 72c7963578..e32335ea3c 100644
+--- a/src/backend/nodes/gen_node_support.pl
++++ b/src/backend/nodes/gen_node_support.pl
+@@ -1027,14 +1027,14 @@ _read${n}(void)
+ elsif ($t eq 'uint32'
+ || $t eq 'bits32'
+ || $t eq 'BlockNumber'
+- || $t eq 'Index'
+- || $t eq 'SubTransactionId')
++ || $t eq 'Index')
+ {
+ print $off "\tWRITE_UINT_FIELD($f);\n";
+ print $rff "\tREAD_UINT_FIELD($f);\n" unless $no_read;
+ }
+ elsif ($t eq 'uint64'
+- || $t eq 'AclMode')
++ || $t eq 'AclMode'
++ || $t eq 'SubTransactionId')
+ {
+ print $off "\tWRITE_UINT64_FIELD($f);\n";
+ print $rff "\tREAD_UINT64_FIELD($f);\n" unless $no_read;
+diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
+index 7159c775fb..825d23a18e 100644
+--- a/src/backend/optimizer/util/plancat.c
++++ b/src/backend/optimizer/util/plancat.c
+@@ -243,7 +243,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
+ * src/backend/access/heap/README.HOT for discussion.
+ */
+ if (index->indcheckxmin &&
+- !TransactionIdPrecedes(HeapTupleHeaderGetXmin(indexRelation->rd_indextuple->t_data),
++ !TransactionIdPrecedes(HeapTupleGetXmin(indexRelation->rd_indextuple),
+ TransactionXmin))
+ {
+ root->glob->transientPlan = true;
+diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
+index 3e037248d6..a508d5d694 100644
+--- a/src/backend/postmaster/autovacuum.c
++++ b/src/backend/postmaster/autovacuum.c
+@@ -123,8 +123,8 @@ int autovacuum_vac_ins_thresh;
+ double autovacuum_vac_ins_scale;
+ int autovacuum_anl_thresh;
+ double autovacuum_anl_scale;
+-int autovacuum_freeze_max_age;
+-int autovacuum_multixact_freeze_max_age;
++int64 autovacuum_freeze_max_age;
++int64 autovacuum_multixact_freeze_max_age;
+
+ double autovacuum_vac_cost_delay;
+ int autovacuum_vac_cost_limit;
+@@ -159,10 +159,10 @@ static TransactionId recentXid;
+ static MultiXactId recentMulti;
+
+ /* Default freeze ages to use for autovacuum (varies by database) */
+-static int default_freeze_min_age;
+-static int default_freeze_table_age;
+-static int default_multixact_freeze_min_age;
+-static int default_multixact_freeze_table_age;
++static int64 default_freeze_min_age;
++static int64 default_freeze_table_age;
++static int64 default_multixact_freeze_min_age;
++static int64 default_multixact_freeze_table_age;
+
+ /* Memory context for long-lived data */
+ static MemoryContext AutovacMemCxt;
+@@ -338,15 +338,15 @@ static void FreeWorkerInfo(int code, Datum arg);
+
+ static autovac_table *table_recheck_autovac(Oid relid, HTAB *table_toast_map,
+ TupleDesc pg_class_desc,
+- int effective_multixact_freeze_max_age);
++ int64 effective_multixact_freeze_max_age);
+ static void recheck_relation_needs_vacanalyze(Oid relid, AutoVacOpts *avopts,
+ Form_pg_class classForm,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ bool *dovacuum, bool *doanalyze, bool *wraparound);
+ static void relation_needs_vacanalyze(Oid relid, AutoVacOpts *relopts,
+ Form_pg_class classForm,
+ PgStat_StatTabEntry *tabentry,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ bool *dovacuum, bool *doanalyze, bool *wraparound);
+
+ static void autovacuum_do_vac_analyze(autovac_table *tab,
+@@ -1143,6 +1143,7 @@ do_start_worker(void)
+ ListCell *cell;
+ TransactionId xidForceLimit;
+ MultiXactId multiForceLimit;
++ int64 multiMembersThreshold;
+ bool for_xid_wrap;
+ bool for_multi_wrap;
+ avw_dbase *avdb;
+@@ -1179,17 +1180,18 @@ do_start_worker(void)
+ * particular tables, but not loosened.)
+ */
+ recentXid = ReadNextTransactionId();
+- xidForceLimit = recentXid - autovacuum_freeze_max_age;
+- /* ensure it's a "normal" XID, else TransactionIdPrecedes misbehaves */
+- /* this can cause the limit to go backwards by 3, but that's OK */
+- if (xidForceLimit < FirstNormalTransactionId)
+- xidForceLimit -= FirstNormalTransactionId;
++ if (recentXid > FirstNormalTransactionId + autovacuum_freeze_max_age)
++ xidForceLimit = recentXid - autovacuum_freeze_max_age;
++ else
++ xidForceLimit = FirstNormalTransactionId;
+
+ /* Also determine the oldest datminmxid we will consider. */
+ recentMulti = ReadNextMultiXactId();
+- multiForceLimit = recentMulti - MultiXactMemberFreezeThreshold();
+- if (multiForceLimit < FirstMultiXactId)
+- multiForceLimit -= FirstMultiXactId;
++ multiMembersThreshold = autovacuum_multixact_freeze_max_age;
++ if (recentMulti > FirstMultiXactId + multiMembersThreshold)
++ multiForceLimit = recentMulti - multiMembersThreshold;
++ else
++ multiForceLimit = FirstMultiXactId;
+
+ /*
+ * Choose a database to connect to. We pick the database that was least
+@@ -2010,7 +2012,7 @@ do_autovacuum(void)
+ BufferAccessStrategy bstrategy;
+ ScanKeyData key;
+ TupleDesc pg_class_desc;
+- int effective_multixact_freeze_max_age;
++ int64 effective_multixact_freeze_max_age;
+ bool did_vacuum = false;
+ bool found_concurrent_worker = false;
+ int i;
+@@ -2033,7 +2035,7 @@ do_autovacuum(void)
+ * normally autovacuum_multixact_freeze_max_age, but may be less if we are
+ * short of multixact member space.
+ */
+- effective_multixact_freeze_max_age = MultiXactMemberFreezeThreshold();
++ effective_multixact_freeze_max_age = autovacuum_multixact_freeze_max_age;
+
+ /*
+ * Find the pg_database entry and select the default freeze ages. We use
+@@ -2811,7 +2813,7 @@ extract_autovac_opts(HeapTuple tup, TupleDesc pg_class_desc)
+ static autovac_table *
+ table_recheck_autovac(Oid relid, HTAB *table_toast_map,
+ TupleDesc pg_class_desc,
+- int effective_multixact_freeze_max_age)
++ int64 effective_multixact_freeze_max_age)
+ {
+ Form_pg_class classForm;
+ HeapTuple classTup;
+@@ -2850,10 +2852,10 @@ table_recheck_autovac(Oid relid, HTAB *table_toast_map,
+ /* OK, it needs something done */
+ if (doanalyze || dovacuum)
+ {
+- int freeze_min_age;
+- int freeze_table_age;
+- int multixact_freeze_min_age;
+- int multixact_freeze_table_age;
++ int64 freeze_min_age;
++ int64 freeze_table_age;
++ int64 multixact_freeze_min_age;
++ int64 multixact_freeze_table_age;
+ int log_min_duration;
+
+ /*
+@@ -2951,7 +2953,7 @@ static void
+ recheck_relation_needs_vacanalyze(Oid relid,
+ AutoVacOpts *avopts,
+ Form_pg_class classForm,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ bool *dovacuum,
+ bool *doanalyze,
+ bool *wraparound)
+@@ -3013,7 +3015,7 @@ relation_needs_vacanalyze(Oid relid,
+ AutoVacOpts *relopts,
+ Form_pg_class classForm,
+ PgStat_StatTabEntry *tabentry,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ /* output params below */
+ bool *dovacuum,
+ bool *doanalyze,
+@@ -3042,8 +3044,8 @@ relation_needs_vacanalyze(Oid relid,
+ anltuples;
+
+ /* freeze parameters */
+- int freeze_max_age;
+- int multixact_freeze_max_age;
++ int64 freeze_max_age;
++ int64 multixact_freeze_max_age;
+ TransactionId xidForceLimit;
+ MultiXactId multiForceLimit;
+
+@@ -3093,17 +3095,19 @@ relation_needs_vacanalyze(Oid relid,
+ av_enabled = (relopts ? relopts->enabled : true);
+
+ /* Force vacuum if table is at risk of wraparound */
+- xidForceLimit = recentXid - freeze_max_age;
+- if (xidForceLimit < FirstNormalTransactionId)
+- xidForceLimit -= FirstNormalTransactionId;
++ if (recentXid > FirstNormalTransactionId + freeze_max_age)
++ xidForceLimit = recentXid - freeze_max_age;
++ else
++ xidForceLimit = FirstNormalTransactionId;
+ force_vacuum = (TransactionIdIsNormal(classForm->relfrozenxid) &&
+ TransactionIdPrecedes(classForm->relfrozenxid,
+ xidForceLimit));
+ if (!force_vacuum)
+ {
+- multiForceLimit = recentMulti - multixact_freeze_max_age;
+- if (multiForceLimit < FirstMultiXactId)
+- multiForceLimit -= FirstMultiXactId;
++ if (recentMulti > FirstMultiXactId + multixact_freeze_max_age)
++ multiForceLimit = recentMulti - multixact_freeze_max_age;
++ else
++ multiForceLimit = FirstMultiXactId;
+ force_vacuum = MultiXactIdIsValid(classForm->relminmxid) &&
+ MultiXactIdPrecedes(classForm->relminmxid, multiForceLimit);
+ }
+diff --git a/src/backend/replication/logical/decode.c b/src/backend/replication/logical/decode.c
+index 1237118e84..ffc4ead751 100644
+--- a/src/backend/replication/logical/decode.c
++++ b/src/backend/replication/logical/decode.c
+@@ -902,8 +902,14 @@ DecodeInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ xl_heap_insert *xlrec;
+ ReorderBufferChange *change;
+ RelFileLocator target_locator;
++ bool isinit = (XLogRecGetInfo(r) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(r);
+
+- xlrec = (xl_heap_insert *) XLogRecGetData(r);
++ /* Bypass pd_xid_base and pd_multi_base */
++ if (isinit)
++ rec_data += sizeof(TransactionId) * 2;
++
++ xlrec = (xl_heap_insert *) rec_data;
+
+ /*
+ * Ignore insert records without new tuples (this does happen when
+@@ -959,8 +965,13 @@ DecodeUpdate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ ReorderBufferChange *change;
+ char *data;
+ RelFileLocator target_locator;
++ bool isinit = (XLogRecGetInfo(r) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(r);
+
+- xlrec = (xl_heap_update *) XLogRecGetData(r);
++ /* Bypass pd_xid_base and pd_multi_base */
++ if (isinit)
++ rec_data += sizeof(TransactionId) * 2;
++ xlrec = (xl_heap_update *) rec_data;
+
+ /* only interested in our database */
+ XLogRecGetBlockTag(r, 0, &target_locator, NULL, NULL);
+@@ -1120,8 +1131,13 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ char *tupledata;
+ Size tuplelen;
+ RelFileLocator rlocator;
++ bool isinit = (XLogRecGetInfo(r) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(r);
+
+- xlrec = (xl_heap_multi_insert *) XLogRecGetData(r);
++ /* Bypass pd_xid_base and pd_multi_base */
++ if (isinit)
++ rec_data += sizeof(TransactionId) * 2;
++ xlrec = (xl_heap_multi_insert *) rec_data;
+
+ /*
+ * Ignore insert records without new tuples. This happens when a
+@@ -1178,6 +1194,7 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ * We can only figure this out after reassembling the transactions.
+ */
+ tuple->tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple->tuple);
+
+ tuple->tuple.t_len = datalen + SizeofHeapTupleHeader;
+
+@@ -1269,6 +1286,7 @@ DecodeXLogTuple(char *data, Size len, ReorderBufferTupleBuf *tuple)
+
+ /* we can only figure this out after reassembling the transactions */
+ tuple->tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple->tuple);
+
+ /* data is not stored aligned, copy to aligned storage */
+ memcpy((char *) &xlhdr,
+diff --git a/src/backend/replication/logical/proto.c b/src/backend/replication/logical/proto.c
+index aa471dccdf..21cd2a5202 100644
+--- a/src/backend/replication/logical/proto.c
++++ b/src/backend/replication/logical/proto.c
+@@ -64,7 +64,7 @@ logicalrep_write_begin(StringInfo out, ReorderBufferTXN *txn)
+ /* fixed fields */
+ pq_sendint64(out, txn->final_lsn);
+ pq_sendint64(out, txn->xact_time.commit_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+ }
+
+ /*
+@@ -78,7 +78,7 @@ logicalrep_read_begin(StringInfo in, LogicalRepBeginData *begin_data)
+ if (begin_data->final_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "final_lsn not set in begin message");
+ begin_data->committime = pq_getmsgint64(in);
+- begin_data->xid = pq_getmsgint(in, 4);
++ begin_data->xid = pq_getmsgint64(in);
+ }
+
+
+@@ -132,7 +132,7 @@ logicalrep_write_begin_prepare(StringInfo out, ReorderBufferTXN *txn)
+ pq_sendint64(out, txn->final_lsn);
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, txn->xact_time.prepare_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -152,7 +152,7 @@ logicalrep_read_begin_prepare(StringInfo in, LogicalRepPreparedTxnData *begin_da
+ if (begin_data->end_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "end_lsn not set in begin prepare message");
+ begin_data->prepare_time = pq_getmsgint64(in);
+- begin_data->xid = pq_getmsgint(in, 4);
++ begin_data->xid = pq_getmsgint64(in);
+
+ /* read gid (copy it into a pre-allocated buffer) */
+ strlcpy(begin_data->gid, pq_getmsgstring(in), sizeof(begin_data->gid));
+@@ -185,7 +185,7 @@ logicalrep_write_prepare_common(StringInfo out, LogicalRepMsgType type,
+ pq_sendint64(out, prepare_lsn);
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, txn->xact_time.prepare_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -224,7 +224,7 @@ logicalrep_read_prepare_common(StringInfo in, char *msgtype,
+ if (prepare_data->end_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "end_lsn is not set in %s message", msgtype);
+ prepare_data->prepare_time = pq_getmsgint64(in);
+- prepare_data->xid = pq_getmsgint(in, 4);
++ prepare_data->xid = pq_getmsgint64(in);
+ if (prepare_data->xid == InvalidTransactionId)
+ elog(ERROR, "invalid two-phase transaction ID in %s message", msgtype);
+
+@@ -265,7 +265,7 @@ logicalrep_write_commit_prepared(StringInfo out, ReorderBufferTXN *txn,
+ pq_sendint64(out, commit_lsn);
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, txn->xact_time.commit_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -291,7 +291,7 @@ logicalrep_read_commit_prepared(StringInfo in, LogicalRepCommitPreparedTxnData *
+ if (prepare_data->end_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "end_lsn is not set in commit prepared message");
+ prepare_data->commit_time = pq_getmsgint64(in);
+- prepare_data->xid = pq_getmsgint(in, 4);
++ prepare_data->xid = pq_getmsgint64(in);
+
+ /* read gid (copy it into a pre-allocated buffer) */
+ strlcpy(prepare_data->gid, pq_getmsgstring(in), sizeof(prepare_data->gid));
+@@ -323,7 +323,7 @@ logicalrep_write_rollback_prepared(StringInfo out, ReorderBufferTXN *txn,
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, prepare_time);
+ pq_sendint64(out, txn->xact_time.commit_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -351,7 +351,7 @@ logicalrep_read_rollback_prepared(StringInfo in,
+ elog(ERROR, "rollback_end_lsn is not set in rollback prepared message");
+ rollback_data->prepare_time = pq_getmsgint64(in);
+ rollback_data->rollback_time = pq_getmsgint64(in);
+- rollback_data->xid = pq_getmsgint(in, 4);
++ rollback_data->xid = pq_getmsgint64(in);
+
+ /* read gid (copy it into a pre-allocated buffer) */
+ strlcpy(rollback_data->gid, pq_getmsgstring(in), sizeof(rollback_data->gid));
+@@ -418,7 +418,7 @@ logicalrep_write_insert(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -467,7 +467,7 @@ logicalrep_write_update(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -542,7 +542,7 @@ logicalrep_write_delete(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -596,7 +596,7 @@ logicalrep_write_truncate(StringInfo out,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ pq_sendint32(out, nrelids);
+
+@@ -654,7 +654,7 @@ logicalrep_write_message(StringInfo out, TransactionId xid, XLogRecPtr lsn,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ pq_sendint8(out, flags);
+ pq_sendint64(out, lsn);
+@@ -676,7 +676,7 @@ logicalrep_write_rel(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -732,7 +732,7 @@ logicalrep_write_typ(StringInfo out, TransactionId xid, Oid typoid)
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(basetypoid));
+ if (!HeapTupleIsValid(tup))
+@@ -1074,7 +1074,7 @@ logicalrep_write_stream_start(StringInfo out,
+ Assert(TransactionIdIsValid(xid));
+
+ /* transaction ID (we're starting to stream, so must be valid) */
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* 1 if this is the first streaming segment for this xid */
+ pq_sendbyte(out, first_segment ? 1 : 0);
+@@ -1090,7 +1090,7 @@ logicalrep_read_stream_start(StringInfo in, bool *first_segment)
+
+ Assert(first_segment);
+
+- xid = pq_getmsgint(in, 4);
++ xid = pq_getmsgint64(in);
+ *first_segment = (pq_getmsgbyte(in) == 1);
+
+ return xid;
+@@ -1119,7 +1119,7 @@ logicalrep_write_stream_commit(StringInfo out, ReorderBufferTXN *txn,
+ Assert(TransactionIdIsValid(txn->xid));
+
+ /* transaction ID */
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send the flags field (unused for now) */
+ pq_sendbyte(out, flags);
+@@ -1139,7 +1139,7 @@ logicalrep_read_stream_commit(StringInfo in, LogicalRepCommitData *commit_data)
+ TransactionId xid;
+ uint8 flags;
+
+- xid = pq_getmsgint(in, 4);
++ xid = pq_getmsgint64(in);
+
+ /* read flags (unused for now) */
+ flags = pq_getmsgbyte(in);
+@@ -1172,8 +1172,8 @@ logicalrep_write_stream_abort(StringInfo out, TransactionId xid,
+ Assert(TransactionIdIsValid(xid) && TransactionIdIsValid(subxid));
+
+ /* transaction ID */
+- pq_sendint32(out, xid);
+- pq_sendint32(out, subxid);
++ pq_sendint64(out, xid);
++ pq_sendint64(out, subxid);
+
+ if (write_abort_info)
+ {
+@@ -1195,8 +1195,8 @@ logicalrep_read_stream_abort(StringInfo in,
+ {
+ Assert(abort_data);
+
+- abort_data->xid = pq_getmsgint(in, 4);
+- abort_data->subxid = pq_getmsgint(in, 4);
++ abort_data->xid = pq_getmsgint64(in);
++ abort_data->subxid = pq_getmsgint64(in);
+
+ if (read_abort_info)
+ {
+diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
+index 4c4b1c4868..f355e26257 100644
+--- a/src/backend/replication/logical/reorderbuffer.c
++++ b/src/backend/replication/logical/reorderbuffer.c
+@@ -5151,8 +5151,12 @@ UpdateLogicalMappings(HTAB *tuplecid_data, Oid relid, Snapshot snapshot)
+ TransactionId f_mapped_xid;
+ TransactionId f_create_xid;
+ XLogRecPtr f_lsn;
+- uint32 f_hi,
+- f_lo;
++ uint32 f_lsn_hi,
++ f_lsn_lo,
++ f_mapped_xid_hi,
++ f_mapped_xid_lo,
++ f_create_xid_hi,
++ f_create_xid_lo;
+ RewriteMappingFile *f;
+
+ if (strcmp(mapping_de->d_name, ".") == 0 ||
+@@ -5164,11 +5168,14 @@ UpdateLogicalMappings(HTAB *tuplecid_data, Oid relid, Snapshot snapshot)
+ continue;
+
+ if (sscanf(mapping_de->d_name, LOGICAL_REWRITE_FORMAT,
+- &f_dboid, &f_relid, &f_hi, &f_lo,
+- &f_mapped_xid, &f_create_xid) != 6)
++ &f_dboid, &f_relid, &f_lsn_hi, &f_lsn_lo,
++ &f_mapped_xid_hi, &f_mapped_xid_lo,
++ &f_create_xid_hi, &f_create_xid_lo) != 8)
+ elog(ERROR, "could not parse filename \"%s\"", mapping_de->d_name);
+
+- f_lsn = ((uint64) f_hi) << 32 | f_lo;
++ f_lsn = ((uint64) f_lsn_hi) << 32 | f_lsn_lo;
++ f_mapped_xid = ((uint64) f_mapped_xid_hi) << 32 | f_mapped_xid_lo;
++ f_create_xid = ((uint64) f_create_xid_hi) << 32 | f_create_xid_lo;
+
+ /* mapping for another database */
+ if (f_dboid != dboid)
+diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c
+index 5c630116ec..95871f5ad9 100644
+--- a/src/backend/replication/logical/snapbuild.c
++++ b/src/backend/replication/logical/snapbuild.c
+@@ -591,7 +591,7 @@ SnapBuildInitialSnapshot(SnapBuild *builder)
+ elog(ERROR, "cannot build an initial slot snapshot, not all transactions are monitored anymore");
+
+ /* so we don't overwrite the existing value */
+- if (TransactionIdIsValid(MyProc->xmin))
++ if (TransactionIdIsValid(pg_atomic_read_u64(&MyProc->xmin)))
+ elog(ERROR, "cannot build an initial slot snapshot when MyProc->xmin already is valid");
+
+ snap = SnapBuildBuildSnapshot(builder);
+@@ -613,7 +613,7 @@ SnapBuildInitialSnapshot(SnapBuild *builder)
+ elog(ERROR, "cannot build an initial slot snapshot as oldest safe xid %llu follows snapshot's xmin %llu",
+ (unsigned long long) safeXid, (unsigned long long) snap->xmin);
+
+- MyProc->xmin = snap->xmin;
++ pg_atomic_write_u64(&MyProc->xmin, snap->xmin);
+
+ /* allocate in transaction context */
+ newxip = (TransactionId *)
+diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c
+index 899ea5502d..37a8cc944f 100644
+--- a/src/backend/replication/logical/worker.c
++++ b/src/backend/replication/logical/worker.c
+@@ -601,7 +601,7 @@ handle_streamed_transaction(LogicalRepMsgType action, StringInfo s)
+ * We should have received XID of the subxact as the first part of the
+ * message, so extract it.
+ */
+- current_xid = pq_getmsgint(s, 4);
++ current_xid = pq_getmsgint64(s);
+
+ if (!TransactionIdIsValid(current_xid))
+ ereport(ERROR,
+diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
+index 5507e2e1f6..2fc25a298d 100644
+--- a/src/backend/replication/walreceiver.c
++++ b/src/backend/replication/walreceiver.c
+@@ -1167,10 +1167,6 @@ static void
+ XLogWalRcvSendHSFeedback(bool immed)
+ {
+ TimestampTz now;
+- FullTransactionId nextFullXid;
+- TransactionId nextXid;
+- uint32 xmin_epoch,
+- catalog_xmin_epoch;
+ TransactionId xmin,
+ catalog_xmin;
+
+@@ -1222,31 +1218,15 @@ XLogWalRcvSendHSFeedback(bool immed)
+ catalog_xmin = InvalidTransactionId;
+ }
+
+- /*
+- * Get epoch and adjust if nextXid and oldestXmin are different sides of
+- * the epoch boundary.
+- */
+- nextFullXid = ReadNextFullTransactionId();
+- nextXid = XidFromFullTransactionId(nextFullXid);
+- xmin_epoch = EpochFromFullTransactionId(nextFullXid);
+- catalog_xmin_epoch = xmin_epoch;
+- if (nextXid < xmin)
+- xmin_epoch--;
+- if (nextXid < catalog_xmin)
+- catalog_xmin_epoch--;
+-
+- elog(DEBUG2, "sending hot standby feedback xmin %llu epoch %u catalog_xmin %llu catalog_xmin_epoch %u",
+- (unsigned long long) xmin, xmin_epoch,
+- (unsigned long long) catalog_xmin, catalog_xmin_epoch);
++ elog(DEBUG2, "sending hot standby feedback xmin %llu catalog_xmin %llu",
++ (unsigned long long) xmin, (unsigned long long) catalog_xmin);
+
+ /* Construct the message and send it. */
+ resetStringInfo(&reply_message);
+ pq_sendbyte(&reply_message, 'h');
+ pq_sendint64(&reply_message, GetCurrentTimestamp());
+- pq_sendint32(&reply_message, xmin);
+- pq_sendint32(&reply_message, xmin_epoch);
+- pq_sendint32(&reply_message, catalog_xmin);
+- pq_sendint32(&reply_message, catalog_xmin_epoch);
++ pq_sendint64(&reply_message, xmin);
++ pq_sendint64(&reply_message, catalog_xmin);
+ walrcv_send(wrconn, reply_message.data, reply_message.len);
+ if (TransactionIdIsValid(xmin) || TransactionIdIsValid(catalog_xmin))
+ primary_has_standby_xmin = true;
+diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
+index bdfa5e8fa3..719dc89365 100644
+--- a/src/backend/replication/walsender.c
++++ b/src/backend/replication/walsender.c
+@@ -255,7 +255,6 @@ static void WalSndUpdateProgress(LogicalDecodingContext *ctx, XLogRecPtr lsn, Tr
+ static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+ static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+ static TimeOffset LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
+-static bool TransactionIdInRecentPast(TransactionId xid, uint32 epoch);
+
+ static void WalSndSegmentOpen(XLogReaderState *state, XLogSegNo nextSegNo,
+ TimeLineID *tli_p);
+@@ -293,7 +292,7 @@ InitWalSender(void)
+ */
+ if (MyDatabaseId == InvalidOid)
+ {
+- Assert(MyProc->xmin == InvalidTransactionId);
++ Assert(pg_atomic_read_u64(&MyProc->xmin) == InvalidTransactionId);
+ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
+ MyProc->statusFlags |= PROC_AFFECTS_ALL_HORIZONS;
+ ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
+@@ -2174,7 +2173,7 @@ PhysicalReplicationSlotNewXmin(TransactionId feedbackXmin, TransactionId feedbac
+ ReplicationSlot *slot = MyReplicationSlot;
+
+ SpinLockAcquire(&slot->mutex);
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&MyProc->xmin, InvalidTransactionId);
+
+ /*
+ * For physical replication we don't need the interlock provided by xmin
+@@ -2206,44 +2205,6 @@ PhysicalReplicationSlotNewXmin(TransactionId feedbackXmin, TransactionId feedbac
+ }
+ }
+
+-/*
+- * Check that the provided xmin/epoch are sane, that is, not in the future
+- * and not so far back as to be already wrapped around.
+- *
+- * Epoch of nextXid should be same as standby, or if the counter has
+- * wrapped, then one greater than standby.
+- *
+- * This check doesn't care about whether clog exists for these xids
+- * at all.
+- */
+-static bool
+-TransactionIdInRecentPast(TransactionId xid, uint32 epoch)
+-{
+- FullTransactionId nextFullXid;
+- TransactionId nextXid;
+- uint32 nextEpoch;
+-
+- nextFullXid = ReadNextFullTransactionId();
+- nextXid = XidFromFullTransactionId(nextFullXid);
+- nextEpoch = EpochFromFullTransactionId(nextFullXid);
+-
+- if (xid <= nextXid)
+- {
+- if (epoch != nextEpoch)
+- return false;
+- }
+- else
+- {
+- if (epoch + 1 != nextEpoch)
+- return false;
+- }
+-
+- if (!TransactionIdPrecedesOrEquals(xid, nextXid))
+- return false; /* epoch OK, but it's wrapped around */
+-
+- return true;
+-}
+-
+ /*
+ * Hot Standby feedback
+ */
+@@ -2251,9 +2212,7 @@ static void
+ ProcessStandbyHSFeedbackMessage(void)
+ {
+ TransactionId feedbackXmin;
+- uint32 feedbackEpoch;
+ TransactionId feedbackCatalogXmin;
+- uint32 feedbackCatalogEpoch;
+ TimestampTz replyTime;
+
+ /*
+@@ -2262,10 +2221,8 @@ ProcessStandbyHSFeedbackMessage(void)
+ * of this message.
+ */
+ replyTime = pq_getmsgint64(&reply_message);
+- feedbackXmin = pq_getmsgint(&reply_message, 4);
+- feedbackEpoch = pq_getmsgint(&reply_message, 4);
+- feedbackCatalogXmin = pq_getmsgint(&reply_message, 4);
+- feedbackCatalogEpoch = pq_getmsgint(&reply_message, 4);
++ feedbackXmin = pq_getmsgint64(&reply_message);
++ feedbackCatalogXmin = pq_getmsgint64(&reply_message);
+
+ if (message_level_is_interesting(DEBUG2))
+ {
+@@ -2274,11 +2231,9 @@ ProcessStandbyHSFeedbackMessage(void)
+ /* Copy because timestamptz_to_str returns a static buffer */
+ replyTimeStr = pstrdup(timestamptz_to_str(replyTime));
+
+- elog(DEBUG2, "hot standby feedback xmin %llu epoch %u, catalog_xmin %llu epoch %u reply_time %s",
++ elog(DEBUG2, "hot standby feedback xmin %llu, catalog_xmin %llu reply_time %s",
+ (unsigned long long) feedbackXmin,
+- feedbackEpoch,
+ (unsigned long long) feedbackCatalogXmin,
+- feedbackCatalogEpoch,
+ replyTimeStr);
+
+ pfree(replyTimeStr);
+@@ -2303,24 +2258,12 @@ ProcessStandbyHSFeedbackMessage(void)
+ if (!TransactionIdIsNormal(feedbackXmin)
+ && !TransactionIdIsNormal(feedbackCatalogXmin))
+ {
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&MyProc->xmin, InvalidTransactionId);
+ if (MyReplicationSlot != NULL)
+ PhysicalReplicationSlotNewXmin(feedbackXmin, feedbackCatalogXmin);
+ return;
+ }
+
+- /*
+- * Check that the provided xmin/epoch are sane, that is, not in the future
+- * and not so far back as to be already wrapped around. Ignore if not.
+- */
+- if (TransactionIdIsNormal(feedbackXmin) &&
+- !TransactionIdInRecentPast(feedbackXmin, feedbackEpoch))
+- return;
+-
+- if (TransactionIdIsNormal(feedbackCatalogXmin) &&
+- !TransactionIdInRecentPast(feedbackCatalogXmin, feedbackCatalogEpoch))
+- return;
+-
+ /*
+ * Set the WalSender's xmin equal to the standby's requested xmin, so that
+ * the xmin will be taken into account by GetSnapshotData() /
+@@ -2358,9 +2301,9 @@ ProcessStandbyHSFeedbackMessage(void)
+ {
+ if (TransactionIdIsNormal(feedbackCatalogXmin)
+ && TransactionIdPrecedes(feedbackCatalogXmin, feedbackXmin))
+- MyProc->xmin = feedbackCatalogXmin;
++ pg_atomic_write_u64(&MyProc->xmin, feedbackCatalogXmin);
+ else
+- MyProc->xmin = feedbackXmin;
++ pg_atomic_write_u64(&MyProc->xmin, feedbackXmin);
+ }
+ }
+
+diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c
+index 7f014a0cbb..16e46a331a 100644
+--- a/src/backend/statistics/extended_stats.c
++++ b/src/backend/statistics/extended_stats.c
+@@ -2456,6 +2456,7 @@ statext_expressions_load(Oid stxoid, bool inh, int idx)
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
+ tmptup.t_data = td;
++ HeapTupleCopyHeaderXids(&tmptup);
+
+ tup = heap_copytuple(&tmptup);
+
+diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
+index fd7c40dcb0..ffcc0fc290 100644
+--- a/src/backend/storage/buffer/Makefile
++++ b/src/backend/storage/buffer/Makefile
+@@ -17,6 +17,7 @@ OBJS = \
+ buf_table.o \
+ bufmgr.o \
+ freelist.o \
+- localbuf.o
++ localbuf.o \
++ heap_convert.o
+
+ include $(top_srcdir)/src/backend/common.mk
+diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
+index f7c67d504c..3487610497 100644
+--- a/src/backend/storage/buffer/bufmgr.c
++++ b/src/backend/storage/buffer/bufmgr.c
+@@ -472,7 +472,8 @@ ForgetPrivateRefCountEntry(PrivateRefCountEntry *ref)
+ )
+
+
+-static Buffer ReadBuffer_common(SMgrRelation smgr, char relpersistence,
++static Buffer ReadBuffer_common(Relation reln,
++ SMgrRelation smgr, char relpersistence,
+ ForkNumber forkNum, BlockNumber blockNum,
+ ReadBufferMode mode, BufferAccessStrategy strategy,
+ bool *hit);
+@@ -800,7 +801,8 @@ ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum,
+ * miss.
+ */
+ pgstat_count_buffer_read(reln);
+- buf = ReadBuffer_common(RelationGetSmgr(reln), reln->rd_rel->relpersistence,
++ buf = ReadBuffer_common(reln,
++ RelationGetSmgr(reln), reln->rd_rel->relpersistence,
+ forkNum, blockNum, mode, strategy, &hit);
+ if (hit)
+ pgstat_count_buffer_hit(reln);
+@@ -827,7 +829,7 @@ ReadBufferWithoutRelcache(RelFileLocator rlocator, ForkNumber forkNum,
+
+ SMgrRelation smgr = smgropen(rlocator, InvalidBackendId);
+
+- return ReadBuffer_common(smgr, permanent ? RELPERSISTENCE_PERMANENT :
++ return ReadBuffer_common(NULL, smgr, permanent ? RELPERSISTENCE_PERMANENT :
+ RELPERSISTENCE_UNLOGGED, forkNum, blockNum,
+ mode, strategy, &hit);
+ }
+@@ -1002,7 +1004,7 @@ ExtendBufferedRelTo(BufferManagerRelation bmr,
+ bool hit;
+
+ Assert(extended_by == 0);
+- buffer = ReadBuffer_common(bmr.smgr, bmr.relpersistence,
++ buffer = ReadBuffer_common(bmr.rel, bmr.smgr, bmr.relpersistence,
+ fork, extend_to - 1, mode, strategy,
+ &hit);
+ }
+@@ -1016,7 +1018,8 @@ ExtendBufferedRelTo(BufferManagerRelation bmr,
+ * *hit is set to true if the request was satisfied from shared buffer cache.
+ */
+ static Buffer
+-ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
++ReadBuffer_common(Relation reln,
++ SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
+ BlockNumber blockNum, ReadBufferMode mode,
+ BufferAccessStrategy strategy, bool *hit)
+ {
+@@ -1170,6 +1173,30 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
+ blockNum,
+ relpath(smgr->smgr_rlocator, forkNum))));
+ }
++
++ if (PageGetPageLayoutVersion(bufBlock) != PG_PAGE_LAYOUT_VERSION &&
++ !PageIsNew((Page) bufBlock))
++ {
++ Buffer buf = BufferDescriptorGetBuffer(bufHdr);
++
++ /*
++ * All the forks but MAIN_FORKNUM should be converted to the
++ * actual page layout version in pg_upgrade.
++ */
++ if (forkNum != MAIN_FORKNUM)
++ ereport(ERROR,
++ (errcode(ERRCODE_DATA_CORRUPTED),
++ errmsg("invalid fork type (%d) in block %u of relation %s",
++ forkNum, blockNum,
++ relpath(smgr->smgr_rlocator, forkNum))));
++
++ LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_EXCLUSIVE);
++ /* Check for no concurrent changes */
++ if (PageGetPageLayoutVersion(bufBlock) != PG_PAGE_LAYOUT_VERSION)
++ convert_page(reln, bufBlock, buf, blockNum);
++
++ LWLockRelease(BufferDescriptorGetContentLock(bufHdr));
++ }
+ }
+
+ /*
+@@ -4767,6 +4794,64 @@ MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
+ }
+ }
+
++/*
++ * Mark buffer as converted - ie its format is changed without logical changes.
++ *
++ * It will override `full_page_write` GUC setting in XLogRecordAssemble.
++ */
++void
++MarkBufferConverted(Buffer buffer, bool converted)
++{
++ BufferDesc *bufHdr;
++ uint32 buf_state;
++ bool has_mark;
++
++ if (!BufferIsValid(buffer))
++ elog(ERROR, "bad buffer ID: %d", buffer);
++
++ Assert(!BufferIsLocal(buffer));
++
++ bufHdr = GetBufferDescriptor(buffer - 1);
++
++ Assert(GetPrivateRefCount(buffer) > 0);
++ if (converted)
++ {
++ /* here, either share or exclusive lock is OK */
++ Assert(LWLockHeldByMe(BufferDescriptorGetContentLock(bufHdr)));
++ }
++
++ buf_state = pg_atomic_read_u32(&bufHdr->state);
++ has_mark = (buf_state & BM_CONVERTED) != 0;
++ if (converted == has_mark)
++ return;
++
++ buf_state = LockBufHdr(bufHdr);
++ buf_state &= ~BM_CONVERTED;
++ if (converted)
++ buf_state |= BM_CONVERTED;
++ UnlockBufHdr(bufHdr, buf_state);
++}
++
++bool
++IsBufferConverted(Buffer buffer)
++{
++
++ BufferDesc *bufHdr;
++ uint32 buf_state;
++
++ if (!BufferIsValid(buffer))
++ elog(ERROR, "bad buffer ID: %d", buffer);
++
++ Assert(!BufferIsLocal(buffer));
++
++ bufHdr = GetBufferDescriptor(buffer - 1);
++
++ Assert(GetPrivateRefCount(buffer) > 0);
++
++ buf_state = pg_atomic_read_u32(&bufHdr->state);
++ return (buf_state & BM_CONVERTED) != 0;
++}
++
+ /*
+ * Release buffer content locks for shared buffers.
+ *
+@@ -4801,6 +4886,47 @@ UnlockBuffers(void)
+ }
+ }
+
++/*
++ * Is shared buffer is locked?
++ */
++bool
++IsBufferLocked(Buffer buffer)
++{
++ BufferDesc *buf;
++
++ if (buffer == InvalidBuffer)
++ return true;
++
++ Assert(BufferIsPinned(buffer));
++ if (BufferIsLocal(buffer))
++ return true; /* local buffers need no lock */
++
++ buf = GetBufferDescriptor(buffer - 1);
++
++ return LWLockHeldByMe(BufferDescriptorGetContentLock(buf));
++}
++
++/*
++ * Is shared buffer is locked exclusive?
++ */
++bool
++IsBufferLockedExclusive(Buffer buffer)
++{
++ BufferDesc *buf;
++
++ if (buffer == InvalidBuffer)
++ return true;
++
++ Assert(BufferIsPinned(buffer));
++ if (BufferIsLocal(buffer))
++ return true; /* local buffers need no lock */
++
++ buf = GetBufferDescriptor(buffer - 1);
++
++ return LWLockHeldByMeInMode(BufferDescriptorGetContentLock(buf),
++ LW_EXCLUSIVE);
++}
++
+ /*
+ * Acquire or release the content_lock for the buffer.
+ */
+diff --git a/src/backend/storage/buffer/heap_convert.c b/src/backend/storage/buffer/heap_convert.c
+new file mode 100644
+index 0000000000..2609f11072
+--- /dev/null
++++ b/src/backend/storage/buffer/heap_convert.c
+@@ -0,0 +1,549 @@
++/*-------------------------------------------------------------------------
++ *
++ * heap_convert.c
++ * Heap page converter from 32bit to 64bit xid format
++ *
++ * Copyright (c) 2015-2022, Postgres Professional
++ *
++ * IDENTIFICATION
++ * src/backend/storage/buffer/heap_convert.c
++ *
++ *-------------------------------------------------------------------------
++ */
++
++#include "postgres.h"
++
++#include "access/generic_xlog.h"
++#include "access/heapam.h"
++#include "access/multixact.h"
++#include "catalog/catalog.h"
++#include "storage/bufmgr.h"
++#include "storage/checksum.h"
++
++static void repack_heap_tuples(Relation rel, Page page, Buffer buf,
++ BlockNumber blkno, bool double_xmax);
++
++/*
++ * itemoffcompare
++ * Sorting support for repack_tuples()
++ */
++int
++itemoffcompare(const void *item1, const void *item2)
++{
++ /* Sort in decreasing itemoff order */
++ return ((ItemIdCompactData *) item2)->itemoff -
++ ((ItemIdCompactData *) item1)->itemoff;
++}
++
++/*
++ * Lazy page conversion from 32-bit to 64-bit XID at first read.
++ */
++void
++convert_page(Relation rel, Page page, Buffer buf, BlockNumber blkno)
++{
++ static unsigned logcnt = 0;
++ bool logit;
++ PageHeader hdr = (PageHeader) page;
++ GenericXLogState *state = NULL;
++ uint16 checksum;
++ bool try_double_xmax;
++
++ /* Not during XLog replaying */
++ Assert(rel != NULL);
++
++ /* Verify checksum */
++ if (hdr->pd_checksum)
++ {
++ checksum = pg_checksum_page((char *) page, blkno);
++ if (checksum != hdr->pd_checksum)
++ ereport(ERROR,
++ (errcode(ERRCODE_INDEX_CORRUPTED),
++ errmsg("page verification failed, calculated checksum %u but expected %u",
++ checksum, hdr->pd_checksum)));
++ }
++
++ /*
++ * We occasionally force logging of page conversion, so never-changed
++ * pages are converted in the end. FORCE_LOG_EVERY is chosen arbitrarily
++ * to log neither too much nor too little.
++ */
++#define FORCE_LOG_EVERY 128
++ logit = !RecoveryInProgress() && XLogIsNeeded() && RelationNeedsWAL(rel);
++ logit = logit && (++logcnt % FORCE_LOG_EVERY) == 0;
++ if (logit)
++ {
++ state = GenericXLogStart(rel);
++ page = GenericXLogRegisterBuffer(state, buf,
++ GENERIC_XLOG_FULL_IMAGE);
++ hdr = (PageHeader) page;
++ }
++#ifdef USE_ASSERT_CHECKING
++ else
++ {
++ /* Not already converted */
++ Assert(PageGetPageLayoutVersion(page) != PG_PAGE_LAYOUT_VERSION);
++ /* Page in 32-bit xid format should not have PageSpecial. */
++ Assert(PageGetSpecialSize(page) == 0);
++ }
++#endif
++
++ switch (rel->rd_rel->relkind)
++ {
++ case 't':
++ try_double_xmax = hdr->pd_upper - hdr->pd_lower <
++ MAXALIGN(sizeof(ToastPageSpecialData));
++ repack_heap_tuples(rel, page, buf, blkno, try_double_xmax);
++ break;
++ case 'r':
++ case 'p':
++ case 'm':
++ try_double_xmax = hdr->pd_upper - hdr->pd_lower <
++ MAXALIGN(sizeof(HeapPageSpecialData));
++ repack_heap_tuples(rel, page, buf, blkno, try_double_xmax);
++ break;
++ case 'i':
++ /* no need to convert index */
++ case 'S':
++ /* no real need to convert sequences */
++ break;
++ default:
++ ereport(ERROR,
++ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
++ errmsg("conversion for relation \"%s\" cannot be done",
++ RelationGetRelationName(rel)),
++ errdetail_relkind_not_supported(rel->rd_rel->relkind)));
++ }
++
++ hdr->pd_checksum = pg_checksum_page((char *) page, blkno);
++
++ PageSetPageSizeAndVersion(page, PageGetPageSize(page),
++ PG_PAGE_LAYOUT_VERSION);
++
++ if (logit)
++ {
++ /*
++ * Finish logging buffer conversion and mark buffer as dirty.
++ */
++ Assert(state != NULL);
++ MarkBufferDirty(buf);
++ GenericXLogFinish(state);
++ }
++ else
++ {
++ /*
++ * Otherwise, it will be logged with full-page-write record on first
++ * actual change.
++ */
++ MarkBufferConverted(buf, true);
++ }
++}
++
++/*
++ * Convert xmin and xmax in a tuple.
++ * This also considers special cases: "double xmax" page format and multixact
++ * in xmax.
++ */
++static void
++convert_heap_tuple_xids(HeapTupleHeader tuple, TransactionId xid_base,
++ MultiXactId multi_base, bool double_xmax)
++{
++ /* Convert xmin */
++ if (double_xmax)
++ {
++ /* Prepare tuple for "double xmax" page format */
++ tuple->t_infomask |= HEAP_XMIN_FROZEN;
++ tuple->t_choice.t_heap.t_xmin = 0;
++ }
++ else
++ {
++ TransactionId xmin = tuple->t_choice.t_heap.t_xmin;
++
++ if (TransactionIdIsNormal(xmin))
++ {
++ if (HeapTupleHeaderXminFrozen(tuple))
++ tuple->t_choice.t_heap.t_xmin = FrozenTransactionId;
++ else if (HeapTupleHeaderXminInvalid(tuple))
++ tuple->t_choice.t_heap.t_xmin = InvalidTransactionId;
++ else
++ {
++ Assert(xmin >= xid_base + FirstNormalTransactionId);
++ /* Subtract xid_base from normal xmin */
++ tuple->t_choice.t_heap.t_xmin = xmin - xid_base;
++ }
++ }
++ }
++
++ /* If tuple has multixact flag, handle mxid wraparound */
++ if ((tuple->t_infomask & HEAP_XMAX_IS_MULTI) &&
++ !(tuple->t_infomask & HEAP_XMAX_INVALID))
++ {
++ MultiXactId mxid = tuple->t_choice.t_heap.t_xmax;
++
++ /* Handle mxid wraparound */
++ if (mxid < multi_base)
++ {
++ mxid += ((MultiXactId) 1 << 32) - FirstMultiXactId;
++ Assert(mxid >= multi_base);
++ }
++
++ if (double_xmax)
++ {
++ /* Save converted mxid into "double xmax" format */
++ HeapTupleHeaderSetDoubleXmax(tuple, mxid);
++ }
++ else
++ {
++ /*
++ * Save converted mxid offset relative to (minmxid - 1), which
++ * will be page's mxid base.
++ */
++ Assert(mxid - multi_base + FirstMultiXactId <= PG_UINT32_MAX);
++ tuple->t_choice.t_heap.t_xmax =
++ (uint32) (mxid - multi_base + FirstMultiXactId);
++ }
++ }
++ /* Convert xmax */
++ else if (!(tuple->t_infomask & HEAP_XMAX_INVALID))
++ {
++ TransactionId xmax = tuple->t_choice.t_heap.t_xmax;
++
++ if (double_xmax)
++ {
++ /* Save converted xmax into "double xmax" format */
++ HeapTupleHeaderSetDoubleXmax(tuple, xmax);
++ }
++ else if (TransactionIdIsNormal(xmax))
++ {
++ /* Subtract xid_base from normal xmax */
++ Assert(xmax >= xid_base + FirstNormalTransactionId);
++ tuple->t_choice.t_heap.t_xmax = xmax - xid_base;
++ }
++ }
++ else
++ {
++ if (double_xmax)
++ HeapTupleHeaderSetDoubleXmax(tuple, InvalidTransactionId);
++ else
++ tuple->t_choice.t_heap.t_xmax = InvalidTransactionId;
++ }
++}
++
++/*
++ * Correct page xmin/xmax based on tuple xmin/xmax values.
++ */
++static void
++compute_xid_min_max(HeapTuple tuple, MultiXactId multi_base,
++ TransactionId *xid_min, TransactionId *xid_max,
++ MultiXactId *multi_min, MultiXactId *multi_max)
++{
++ /* xmin */
++ if (!HeapTupleHeaderXminInvalid(tuple->t_data) &&
++ !HeapTupleHeaderXminFrozen(tuple->t_data))
++ {
++ TransactionId xid = HeapTupleGetRawXmin(tuple);
++
++ if (TransactionIdIsNormal(xid))
++ {
++ *xid_max = Max(*xid_max, xid);
++ *xid_min = Min(*xid_min, xid);
++ }
++ }
++
++ /* xmax */
++ if (!(tuple->t_data->t_infomask & HEAP_XMAX_INVALID))
++ {
++ TransactionId xid;
++
++ if (tuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI)
++ {
++ MultiXactId mxid = HeapTupleGetRawXmax(tuple);
++
++ Assert(MultiXactIdIsValid(mxid));
++
++ /* Handle mxid wraparound */
++ if (mxid < multi_base)
++ {
++ mxid += ((MultiXactId) 1 << 32) - FirstMultiXactId;
++ Assert(mxid >= multi_base);
++ }
++
++ *multi_max = Max(*multi_max, mxid);
++ *multi_min = Min(*multi_min, mxid);
++
++ /*
++ * Also take into account hidden update xid, which can be
++ * extracted by the vacuum.
++ */
++ if (tuple->t_data->t_infomask & HEAP_XMAX_LOCK_ONLY)
++ xid = InvalidTransactionId;
++ else
++ xid = HeapTupleGetUpdateXid(tuple);
++ }
++ else
++ {
++ xid = HeapTupleGetRawXmax(tuple);
++ }
++
++ if (TransactionIdIsNormal(xid))
++ {
++ *xid_max = Max(*xid_max, xid);
++ *xid_min = Min(*xid_min, xid);
++ }
++ }
++}
++
++/*
++ * Returns true if both:
++ * - xid_max: an uppper boundary of xmin's and xmax'es of all tuples on a page
++ * - xid_min: a lower boundary of xmin's and xmax'es of all tuples on a page
++ * can be expressed by 32-bit number relative to page's xid_base/multi_base
++ * or invalid.
++ *
++ * True value effectively means that these tuples can be directly put on one
++ * page in 64-xid format.
++ */
++static inline bool
++xids_fit_page(TransactionId xid_min, TransactionId xid_max,
++ MultiXactId multi_min, MultiXactId multi_max)
++{
++ bool xid_max_fits = false;
++ bool multi_max_fits = false;
++
++ if (xid_max == InvalidTransactionId)
++ xid_max_fits = true;
++
++ if (xid_max - xid_min <= MaxShortTransactionId - FirstNormalTransactionId)
++ xid_max_fits = true;
++
++ if (multi_max == InvalidMultiXactId)
++ multi_max_fits = true;
++
++ if (multi_max - multi_min <= MaxShortTransactionId - FirstMultiXactId)
++ multi_max_fits = true;
++
++ return xid_max_fits && multi_max_fits;
++}
++
++/*
++ * Set "base" for page in 64-bit XID format.
++ *
++ * This should not be called for double xmax pages. They do not have place for
++ * page special.
++ */
++static inline void
++heap_page_set_base(Page page,
++ TransactionId xid_min, TransactionId xid_max,
++ MultiXactId multi_min, MultiXactId multi_max,
++ TransactionId *xid_base, MultiXactId *multi_base,
++ bool is_toast)
++{
++ PageHeader hdr = (PageHeader) page;
++
++ if (xid_max != InvalidTransactionId)
++ *xid_base = xid_min - FirstNormalTransactionId;
++ else
++ *xid_base = InvalidTransactionId;
++
++ if (multi_max != InvalidMultiXactId)
++ *multi_base = multi_min - FirstMultiXactId;
++ else
++ *multi_base = InvalidMultiXactId;
++
++ if (is_toast)
++ {
++ ToastPageSpecial special;
++
++ hdr->pd_special = BLCKSZ - MAXALIGN(sizeof(ToastPageSpecialData));
++ special = ToastPageGetSpecial(page);
++ special->pd_xid_base = *xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ hdr->pd_special = BLCKSZ - MAXALIGN(sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = *xid_base;
++ special->pd_multi_base = *multi_base;
++ }
++}
++
++/*
++ * repack_heap_tuples
++ * Convert heap page format reusing space of dead tuples
++ */
++static void
++repack_heap_tuples(Relation rel, Page page, Buffer buf, BlockNumber blkno,
++ bool try_double_xmax)
++{
++ ItemIdCompactData items[MaxHeapTuplesPerPage];
++ ItemIdCompact itemPtr = items;
++ int nitems = 0,
++ maxoff = PageGetMaxOffsetNumber(page),
++ idx,
++ occupied_space = 0;
++ Offset upper;
++ bool double_xmax,
++ special_fits,
++ toast;
++ PageHeader hdr = (PageHeader) page,
++ new_hdr;
++ PGAlignedBlock zerobuf = {0};
++ Page new_page;
++ MultiXactId multi_base = rel->rd_rel->relminmxid,
++ multi_min = MaxMultiXactId,
++ multi_max = InvalidMultiXactId;
++ TransactionId xid_base = rel->rd_rel->relfrozenxid,
++ xid_min = MaxTransactionId,
++ xid_max = InvalidTransactionId;
++
++ toast = IsToastRelation(rel);
++
++ if (TransactionIdIsNormal(hdr->pd_prune_xid))
++ xid_min = xid_max = hdr->pd_prune_xid;
++
++ for (idx = 0; idx < maxoff; idx++)
++ {
++ HeapTupleData tuple;
++ ItemId lp;
++
++ lp = PageGetItemId(page, idx + 1);
++
++ /* Skip redirects and items without storage */
++ if (!ItemIdHasStorage(lp))
++ continue;
++
++ /* Build in-memory tuple representation */
++ tuple.t_tableOid = 1; /* doesn't matter in this case */
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, lp);
++ HeapTupleCopyHeaderXids(&tuple);
++ tuple.t_len = ItemIdGetLength(lp);
++ ItemPointerSet(&(tuple.t_self), blkno, ItemIdGetOffset(lp));
++
++ /*
++ * This is only needed to determine whether tuple is HEAPTUPLE_DEAD or
++ * HEAPTUPLE_RECENTLY_DEAD. And since this is the first time we read
++ * page after pg_upgrade, it cannot be HEAPTUPLE_RECENTLY_DEAD. See
++ * HeapTupleSatisfiesVacuum() for details
++ */
++ if (try_double_xmax &&
++ HeapTupleSatisfiesVacuum(&tuple,
++ (TransactionId) 1 << 32, buf) == HEAPTUPLE_DEAD)
++ {
++ ItemIdSetDead(lp);
++ }
++
++ if (ItemIdIsNormal(lp) && ItemIdHasStorage(lp))
++ {
++ itemPtr->offsetindex = idx;
++ itemPtr->itemoff = ItemIdGetOffset(lp);
++ if (unlikely(itemPtr->itemoff < hdr->pd_upper ||
++ itemPtr->itemoff >= hdr->pd_special))
++ {
++ ereport(ERROR,
++ (errcode(ERRCODE_DATA_CORRUPTED),
++ errmsg("corrupted item pointer: %u",
++ itemPtr->itemoff)));
++ }
++
++ itemPtr->alignedlen = MAXALIGN(ItemIdGetLength(lp));
++ occupied_space += itemPtr->alignedlen;
++ nitems++;
++ itemPtr++;
++ if (try_double_xmax)
++ {
++ HeapTupleSetXmin(&tuple, FrozenTransactionId);
++ HeapTupleHeaderStoreXminFrozen(tuple.t_data);
++ }
++
++ compute_xid_min_max(&tuple, multi_base,
++ &xid_min, &xid_max,
++ &multi_min, &multi_max);
++ }
++ }
++
++ new_page = (Page) zerobuf.data;
++ MemSet(new_page, 0, BLCKSZ);
++ /* Write new header */
++ new_hdr = (PageHeader) new_page;
++ *new_hdr = *hdr;
++ new_hdr->pd_lower = SizeOfPageHeaderData + maxoff * sizeof(ItemIdData);
++
++ if (toast)
++ special_fits = BLCKSZ - new_hdr->pd_lower - occupied_space >=
++ sizeof(ToastPageSpecialData);
++ else
++ special_fits = BLCKSZ - new_hdr->pd_lower - occupied_space >=
++ sizeof(HeapPageSpecialData);
++
++ double_xmax = !special_fits ||
++ !xids_fit_page(xid_min, xid_max, multi_min, multi_max);
++
++ if (!double_xmax)
++ {
++ Assert(xid_max == InvalidTransactionId || xid_max >= xid_min);
++ Assert(multi_max == InvalidMultiXactId || multi_max >= multi_min);
++
++ heap_page_set_base(new_page,
++ xid_min, xid_max,
++ multi_min, multi_max,
++ &xid_base, &multi_base,
++ toast);
++
++ HeapPageSetPruneXid(new_page, new_hdr->pd_prune_xid, toast);
++ }
++ else
++ {
++ /* No space for special area, switch to "double xmax" format */
++ elog(DEBUG2, "convert heap page %u of relation \"%s\" to double xmax format",
++ blkno, RelationGetRelationName(rel));
++
++ if (try_double_xmax)
++ {
++ xid_base = InvalidTransactionId;
++ multi_base = InvalidMultiXactId;
++ }
++ else
++ {
++ repack_heap_tuples(rel, page, buf, blkno, true);
++ return;
++ }
++ }
++
++ /* Copy ItemIds with an offset */
++ memcpy((char *) new_page + SizeOfPageHeaderData,
++ (char *) page + SizeOfPageHeaderData,
++ hdr->pd_lower - SizeOfPageHeaderData);
++
++ /* Move live tuples */
++ upper = new_hdr->pd_special;
++ for (idx = 0; idx < nitems; idx++)
++ {
++ HeapTupleHeader tuple;
++ ItemId lp;
++
++ itemPtr = &items[idx];
++ lp = PageGetItemId(new_page, itemPtr->offsetindex + 1);
++ upper -= itemPtr->alignedlen;
++ occupied_space -= itemPtr->alignedlen;
++
++ memcpy((char *) new_page + upper,
++ (char *) page + itemPtr->itemoff,
++ itemPtr->alignedlen);
++
++ tuple = (HeapTupleHeader) (((char *) new_page) + upper);
++
++ convert_heap_tuple_xids(tuple, xid_base, multi_base, double_xmax);
++
++ lp->lp_off = upper;
++ }
++
++ Assert(occupied_space == 0);
++
++ new_hdr->pd_upper = upper;
++ if (new_hdr->pd_lower > new_hdr->pd_upper)
++ elog(ERROR, "cannot convert block %u of relation \"%s\"",
++ blkno, RelationGetRelationName(rel));
++
++ memcpy(page, new_page, BLCKSZ);
++}
+diff --git a/src/backend/storage/buffer/meson.build b/src/backend/storage/buffer/meson.build
+index ea2f9c045a..e1ca4a23d4 100644
+--- a/src/backend/storage/buffer/meson.build
++++ b/src/backend/storage/buffer/meson.build
+@@ -5,5 +5,6 @@ backend_sources += files(
+ 'buf_table.c',
+ 'bufmgr.c',
+ 'freelist.c',
++ 'heap_convert.c',
+ 'localbuf.c',
+ )
+diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
+index 55d719816f..5967955150 100644
+--- a/src/backend/storage/ipc/procarray.c
++++ b/src/backend/storage/ipc/procarray.c
+@@ -66,7 +66,7 @@
+ #include "utils/rel.h"
+ #include "utils/snapmgr.h"
+
+-#define UINT32_ACCESS_ONCE(var) ((uint32)(*((volatile uint32 *)&(var))))
++#define UINT64_ACCESS_ONCE(var) ((uint64)(*((volatile uint64 *)&(var))))
+
+ /* Our shared memory area */
+ typedef struct ProcArrayStruct
+@@ -366,8 +366,6 @@ static void ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid);
+ static void MaintainLatestCompletedXid(TransactionId latestXid);
+ static void MaintainLatestCompletedXidRecovery(TransactionId latestXid);
+
+-static inline FullTransactionId FullXidRelativeTo(FullTransactionId rel,
+- TransactionId xid);
+ static void GlobalVisUpdateApply(ComputeXidHorizonsResult *horizons);
+
+ /*
+@@ -525,7 +523,8 @@ ProcArrayAdd(PGPROC *proc)
+
+ arrayP->pgprocnos[index] = proc->pgprocno;
+ proc->pgxactoff = index;
+- ProcGlobal->xids[index] = proc->xid;
++ pg_atomic_write_u64(&ProcGlobal->xids[index],
++ pg_atomic_read_u64(&proc->xid));
+ ProcGlobal->subxidStates[index] = proc->subxidStatus;
+ ProcGlobal->statusFlags[index] = proc->statusFlags;
+
+@@ -585,7 +584,7 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
+
+ if (TransactionIdIsValid(latestXid))
+ {
+- Assert(TransactionIdIsValid(ProcGlobal->xids[myoff]));
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&ProcGlobal->xids[myoff])));
+
+ /* Advance global latestCompletedXid while holding the lock */
+ MaintainLatestCompletedXid(latestXid);
+@@ -593,17 +592,17 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
+ /* Same with xactCompletionCount */
+ ShmemVariableCache->xactCompletionCount++;
+
+- ProcGlobal->xids[myoff] = InvalidTransactionId;
++ pg_atomic_write_u64(&ProcGlobal->xids[myoff], InvalidTransactionId);
+ ProcGlobal->subxidStates[myoff].overflowed = false;
+ ProcGlobal->subxidStates[myoff].count = 0;
+ }
+ else
+ {
+ /* Shouldn't be trying to remove a live transaction here */
+- Assert(!TransactionIdIsValid(ProcGlobal->xids[myoff]));
++ Assert(!TransactionIdIsValid(pg_atomic_read_u64(&(ProcGlobal->xids[myoff]))));
+ }
+
+- Assert(!TransactionIdIsValid(ProcGlobal->xids[myoff]));
++ Assert(!TransactionIdIsValid(pg_atomic_read_u64(&(ProcGlobal->xids[myoff]))));
+ Assert(ProcGlobal->subxidStates[myoff].count == 0);
+ Assert(ProcGlobal->subxidStates[myoff].overflowed == false);
+
+@@ -649,7 +648,6 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
+ LWLockRelease(ProcArrayLock);
+ }
+
+-
+ /*
+ * ProcArrayEndTransaction -- mark a transaction as no longer running
+ *
+@@ -674,7 +672,7 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid)
+ * else is taking a snapshot. See discussion in
+ * src/backend/access/transam/README.
+ */
+- Assert(TransactionIdIsValid(proc->xid));
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&proc->xid)));
+
+ /*
+ * If we can immediately acquire ProcArrayLock, we clear our own XID
+@@ -696,12 +694,12 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid)
+ * anyone else's calculation of a snapshot. We might change their
+ * estimate of global xmin, but that's OK.
+ */
+- Assert(!TransactionIdIsValid(proc->xid));
++ Assert(!TransactionIdIsValid(pg_atomic_read_u64(&proc->xid)));
+ Assert(proc->subxidStatus.count == 0);
+ Assert(!proc->subxidStatus.overflowed);
+
+ proc->lxid = InvalidLocalTransactionId;
+- proc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&proc->xmin, InvalidTransactionId);
+
+ /* be sure this is cleared in abort */
+ proc->delayChkptFlags = 0;
+@@ -737,13 +735,14 @@ ProcArrayEndTransactionInternal(PGPROC *proc, TransactionId latestXid)
+ * processes' PGPROC entries.
+ */
+ Assert(LWLockHeldByMeInMode(ProcArrayLock, LW_EXCLUSIVE));
+- Assert(TransactionIdIsValid(ProcGlobal->xids[pgxactoff]));
+- Assert(ProcGlobal->xids[pgxactoff] == proc->xid);
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&ProcGlobal->xids[pgxactoff])));
++ Assert(pg_atomic_read_u64(&ProcGlobal->xids[pgxactoff]) ==
++ pg_atomic_read_u64(&proc->xid));
+
+- ProcGlobal->xids[pgxactoff] = InvalidTransactionId;
+- proc->xid = InvalidTransactionId;
++ pg_atomic_write_u64(&ProcGlobal->xids[pgxactoff], InvalidTransactionId);
++ pg_atomic_write_u64(&proc->xid, InvalidTransactionId);
+ proc->lxid = InvalidLocalTransactionId;
+- proc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&proc->xmin, InvalidTransactionId);
+
+ /* be sure this is cleared in abort */
+ proc->delayChkptFlags = 0;
+@@ -796,7 +795,7 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
+ uint32 wakeidx;
+
+ /* We should definitely have an XID to clear. */
+- Assert(TransactionIdIsValid(proc->xid));
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&proc->xid)));
+
+ /* Add ourselves to the list of processes needing a group XID clear. */
+ proc->procArrayGroupMember = true;
+@@ -925,11 +924,11 @@ ProcArrayClearTransaction(PGPROC *proc)
+
+ pgxactoff = proc->pgxactoff;
+
+- ProcGlobal->xids[pgxactoff] = InvalidTransactionId;
+- proc->xid = InvalidTransactionId;
++ pg_atomic_write_u64(&ProcGlobal->xids[pgxactoff], InvalidTransactionId);
++ pg_atomic_write_u64(&proc->xid, InvalidTransactionId);
+
+ proc->lxid = InvalidLocalTransactionId;
+- proc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&proc->xmin, InvalidTransactionId);
+ proc->recoveryConflictPending = false;
+
+ Assert(!(proc->statusFlags & PROC_VACUUM_STATE_MASK));
+@@ -973,8 +972,7 @@ MaintainLatestCompletedXid(TransactionId latestXid)
+
+ if (TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
+ {
+- ShmemVariableCache->latestCompletedXid =
+- FullXidRelativeTo(cur_latest, latestXid);
++ ShmemVariableCache->latestCompletedXid = FullTransactionIdFromXid(latestXid);
+ }
+
+ Assert(IsBootstrapProcessingMode() ||
+@@ -988,7 +986,6 @@ static void
+ MaintainLatestCompletedXidRecovery(TransactionId latestXid)
+ {
+ FullTransactionId cur_latest = ShmemVariableCache->latestCompletedXid;
+- FullTransactionId rel;
+
+ Assert(AmStartupProcess() || !IsUnderPostmaster);
+ Assert(LWLockHeldByMe(ProcArrayLock));
+@@ -998,14 +995,12 @@ MaintainLatestCompletedXidRecovery(TransactionId latestXid)
+ * latestCompletedXid to be initialized in recovery. But in recovery it's
+ * safe to access nextXid without a lock for the startup process.
+ */
+- rel = ShmemVariableCache->nextXid;
+ Assert(FullTransactionIdIsValid(ShmemVariableCache->nextXid));
+
+ if (!FullTransactionIdIsValid(cur_latest) ||
+ TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
+ {
+- ShmemVariableCache->latestCompletedXid =
+- FullXidRelativeTo(rel, latestXid);
++ ShmemVariableCache->latestCompletedXid = FullTransactionIdFromXid(latestXid);
+ }
+
+ Assert(FullTransactionIdIsNormal(ShmemVariableCache->latestCompletedXid));
+@@ -1383,7 +1378,7 @@ bool
+ TransactionIdIsInProgress(TransactionId xid)
+ {
+ static TransactionId *xids = NULL;
+- static TransactionId *other_xids;
++ static pg_atomic_uint64 *other_xids;
+ XidCacheStatus *other_subxidstates;
+ int nxids = 0;
+ ProcArrayStruct *arrayP = procArray;
+@@ -1479,7 +1474,7 @@ TransactionIdIsInProgress(TransactionId xid)
+ continue;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- pxid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]);
++ pxid = pg_atomic_read_u64(&(other_xids[pgxactoff]));
+
+ if (!TransactionIdIsValid(pxid))
+ continue;
+@@ -1511,7 +1506,7 @@ TransactionIdIsInProgress(TransactionId xid)
+ for (j = pxids - 1; j >= 0; j--)
+ {
+ /* Fetch xid just once - see GetNewTransactionId */
+- TransactionId cxid = UINT32_ACCESS_ONCE(proc->subxids.xids[j]);
++ TransactionId cxid = UINT64_ACCESS_ONCE(proc->subxids.xids[j]);
+
+ if (TransactionIdEquals(cxid, xid))
+ {
+@@ -1596,7 +1591,7 @@ TransactionIdIsInProgress(TransactionId xid)
+ topxid = SubTransGetTopmostTransaction(xid);
+ Assert(TransactionIdIsValid(topxid));
+ if (!TransactionIdEquals(topxid, xid) &&
+- pg_lfind32(topxid, xids, nxids))
++ pg_lfind64(topxid, xids, nxids))
+ return true;
+
+ cachedXidIsNotInProgress = xid;
+@@ -1616,7 +1611,7 @@ TransactionIdIsActive(TransactionId xid)
+ {
+ bool result = false;
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ int i;
+
+ /*
+@@ -1635,7 +1630,7 @@ TransactionIdIsActive(TransactionId xid)
+ TransactionId pxid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- pxid = UINT32_ACCESS_ONCE(other_xids[i]);
++ pxid = pg_atomic_read_u64(&(other_xids[i]));
+
+ if (!TransactionIdIsValid(pxid))
+ continue;
+@@ -1718,7 +1713,7 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ ProcArrayStruct *arrayP = procArray;
+ TransactionId kaxmin;
+ bool in_recovery = RecoveryInProgress();
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+
+ /* inferred after ProcArrayLock is released */
+ h->catalog_oldest_nonremovable = InvalidTransactionId;
+@@ -1734,7 +1729,8 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ * additions.
+ */
+ {
+- TransactionId initial;
++ TransactionId initial,
++ xid;
+
+ initial = XidFromFullTransactionId(h->latest_completed);
+ Assert(TransactionIdIsValid(initial));
+@@ -1756,8 +1752,9 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ * definition, can't be any newer changes in the temp table than
+ * latestCompletedXid.
+ */
+- if (TransactionIdIsValid(MyProc->xid))
+- h->temp_oldest_nonremovable = MyProc->xid;
++ xid = pg_atomic_read_u64(&MyProc->xid);
++ if (TransactionIdIsValid(xid))
++ h->temp_oldest_nonremovable = xid;
+ else
+ h->temp_oldest_nonremovable = initial;
+ }
+@@ -1779,8 +1776,8 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ TransactionId xmin;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
+- xmin = UINT32_ACCESS_ONCE(proc->xmin);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
++ xmin = pg_atomic_read_u64(&proc->xmin);
+
+ /*
+ * Consider both the transaction's Xmin, and its Xid.
+@@ -2106,8 +2103,8 @@ GetSnapshotDataReuse(Snapshot snapshot)
+ * requirement that concurrent GetSnapshotData() calls yield the same
+ * xmin.
+ */
+- if (!TransactionIdIsValid(MyProc->xmin))
+- MyProc->xmin = TransactionXmin = snapshot->xmin;
++ if (!TransactionIdIsValid(pg_atomic_read_u64(&MyProc->xmin)))
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = snapshot->xmin);
+
+ RecentXmin = snapshot->xmin;
+ Assert(TransactionIdPrecedesOrEquals(TransactionXmin, RecentXmin));
+@@ -2158,7 +2155,7 @@ Snapshot
+ GetSnapshotData(Snapshot snapshot)
+ {
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ TransactionId xmin;
+ TransactionId xmax;
+ int count = 0;
+@@ -2221,8 +2218,8 @@ GetSnapshotData(Snapshot snapshot)
+
+ latest_completed = ShmemVariableCache->latestCompletedXid;
+ mypgxactoff = MyProc->pgxactoff;
+- myxid = other_xids[mypgxactoff];
+- Assert(myxid == MyProc->xid);
++ myxid = pg_atomic_read_u64(&other_xids[mypgxactoff]);
++ Assert(myxid == pg_atomic_read_u64(&MyProc->xid));
+
+ oldestxid = ShmemVariableCache->oldestXid;
+ curXactCompletionCount = ShmemVariableCache->xactCompletionCount;
+@@ -2256,7 +2253,7 @@ GetSnapshotData(Snapshot snapshot)
+ for (int pgxactoff = 0; pgxactoff < numProcs; pgxactoff++)
+ {
+ /* Fetch xid just once - see GetNewTransactionId */
+- TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]);
++ TransactionId xid = pg_atomic_read_u64(&(other_xids[pgxactoff]));
+ uint8 statusFlags;
+
+ Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff);
+@@ -2393,8 +2390,8 @@ GetSnapshotData(Snapshot snapshot)
+ replication_slot_xmin = procArray->replication_slot_xmin;
+ replication_slot_catalog_xmin = procArray->replication_slot_catalog_xmin;
+
+- if (!TransactionIdIsValid(MyProc->xmin))
+- MyProc->xmin = TransactionXmin = xmin;
++ if (!TransactionIdIsValid(pg_atomic_read_u64(&MyProc->xmin)))
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = xmin);
+
+ LWLockRelease(ProcArrayLock);
+
+@@ -2406,12 +2403,7 @@ GetSnapshotData(Snapshot snapshot)
+ FullTransactionId def_vis_fxid_data;
+ FullTransactionId oldestfxid;
+
+- /*
+- * Converting oldestXid is only safe when xid horizon cannot advance,
+- * i.e. holding locks. While we don't hold the lock anymore, all the
+- * necessary data has been gathered with lock held.
+- */
+- oldestfxid = FullXidRelativeTo(latest_completed, oldestxid);
++ oldestfxid = FullTransactionIdFromXid(oldestxid);
+
+ /* Check whether there's a replication slot requiring an older xmin. */
+ def_vis_xid_data =
+@@ -2430,8 +2422,8 @@ GetSnapshotData(Snapshot snapshot)
+ def_vis_xid =
+ TransactionIdOlder(replication_slot_catalog_xmin, def_vis_xid);
+
+- def_vis_fxid = FullXidRelativeTo(latest_completed, def_vis_xid);
+- def_vis_fxid_data = FullXidRelativeTo(latest_completed, def_vis_xid_data);
++ def_vis_fxid = FullTransactionIdFromXid(def_vis_xid);
++ def_vis_fxid_data = FullTransactionIdFromXid(def_vis_xid_data);
+
+ /*
+ * Check if we can increase upper bound. As a previous
+@@ -2450,7 +2442,7 @@ GetSnapshotData(Snapshot snapshot)
+ /* See temp_oldest_nonremovable computation in ComputeXidHorizons() */
+ if (TransactionIdIsNormal(myxid))
+ GlobalVisTempRels.definitely_needed =
+- FullXidRelativeTo(latest_completed, myxid);
++ FullTransactionIdFromXid(myxid);
+ else
+ {
+ GlobalVisTempRels.definitely_needed = latest_completed;
+@@ -2557,7 +2549,7 @@ ProcArrayInstallImportedXmin(TransactionId xmin,
+ /*
+ * Likewise, let's just make real sure its xmin does cover us.
+ */
+- xid = UINT32_ACCESS_ONCE(proc->xmin);
++ xid = pg_atomic_read_u64(&proc->xmin);
+ if (!TransactionIdIsNormal(xid) ||
+ !TransactionIdPrecedesOrEquals(xid, xmin))
+ continue;
+@@ -2568,7 +2560,7 @@ ProcArrayInstallImportedXmin(TransactionId xmin,
+ * GetSnapshotData first, we'll be overwriting a valid xmin here, so
+ * we don't check that.)
+ */
+- MyProc->xmin = TransactionXmin = xmin;
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = xmin);
+
+ result = true;
+ break;
+@@ -2612,7 +2604,7 @@ ProcArrayInstallRestoredXmin(TransactionId xmin, PGPROC *proc)
+ * can't go backwards. Also, make sure it's running in the same database,
+ * so that the per-database xmin cannot go backwards.
+ */
+- xid = UINT32_ACCESS_ONCE(proc->xmin);
++ xid = pg_atomic_read_u64(&proc->xmin);
+ if (proc->databaseId == MyDatabaseId &&
+ TransactionIdIsNormal(xid) &&
+ TransactionIdPrecedesOrEquals(xid, xmin))
+@@ -2621,7 +2613,7 @@ ProcArrayInstallRestoredXmin(TransactionId xmin, PGPROC *proc)
+ * Install xmin and propagate the statusFlags that affect how the
+ * value is interpreted by vacuum.
+ */
+- MyProc->xmin = TransactionXmin = xmin;
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = xmin);
+ MyProc->statusFlags = (MyProc->statusFlags & ~PROC_XMIN_FLAGS) |
+ (proc->statusFlags & PROC_XMIN_FLAGS);
+ ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
+@@ -2672,7 +2664,7 @@ GetRunningTransactionData(void)
+ static RunningTransactionsData CurrentRunningXactsData;
+
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ RunningTransactions CurrentRunningXacts = &CurrentRunningXactsData;
+ TransactionId latestCompletedXid;
+ TransactionId oldestRunningXid;
+@@ -2731,7 +2723,7 @@ GetRunningTransactionData(void)
+ TransactionId xid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
+
+ /*
+ * We don't need to store transactions that don't have a TransactionId
+@@ -2844,7 +2836,7 @@ TransactionId
+ GetOldestActiveTransactionId(void)
+ {
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ TransactionId oldestRunningXid;
+ int index;
+
+@@ -2870,7 +2862,7 @@ GetOldestActiveTransactionId(void)
+ TransactionId xid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
+
+ if (!TransactionIdIsNormal(xid))
+ continue;
+@@ -2958,7 +2950,7 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly)
+ */
+ if (!recovery_in_progress)
+ {
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+
+ /*
+ * Spin over procArray collecting min(ProcGlobal->xids[i])
+@@ -2968,7 +2960,7 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly)
+ TransactionId xid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
+
+ if (!TransactionIdIsNormal(xid))
+ continue;
+@@ -3163,7 +3155,7 @@ BackendXidGetPid(TransactionId xid)
+ {
+ int result = 0;
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ int index;
+
+ if (xid == InvalidTransactionId) /* never match invalid xid */
+@@ -3173,7 +3165,7 @@ BackendXidGetPid(TransactionId xid)
+
+ for (index = 0; index < arrayP->numProcs; index++)
+ {
+- if (other_xids[index] == xid)
++ if (pg_atomic_read_u64(&other_xids[index]) == xid)
+ {
+ int pgprocno = arrayP->pgprocnos[index];
+ PGPROC *proc = &allProcs[pgprocno];
+@@ -3257,7 +3249,7 @@ GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0,
+ if (allDbs || proc->databaseId == MyDatabaseId)
+ {
+ /* Fetch xmin just once - might change on us */
+- TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin);
++ TransactionId pxmin = pg_atomic_read_u64(&proc->xmin);
+
+ if (excludeXmin0 && !TransactionIdIsValid(pxmin))
+ continue;
+@@ -3357,7 +3349,7 @@ GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid)
+ proc->databaseId == dbOid)
+ {
+ /* Fetch xmin just once - can't change on us, but good coding */
+- TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin);
++ TransactionId pxmin = pg_atomic_read_u64(&proc->xmin);
+
+ /*
+ * We ignore an invalid pxmin because this means that backend has
+@@ -3484,7 +3476,7 @@ MinimumActiveBackends(int min)
+ continue; /* do not count deleted entries */
+ if (proc == MyProc)
+ continue; /* do not count myself */
+- if (proc->xid == InvalidTransactionId)
++ if (pg_atomic_read_u64(&proc->xid) == InvalidTransactionId)
+ continue; /* do not count if no XID assigned */
+ if (proc->pid == 0)
+ continue; /* do not count prepared xacts */
+@@ -4071,17 +4063,13 @@ static void
+ GlobalVisUpdateApply(ComputeXidHorizonsResult *horizons)
+ {
+ GlobalVisSharedRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->shared_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->shared_oldest_nonremovable);
+ GlobalVisCatalogRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->catalog_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->catalog_oldest_nonremovable);
+ GlobalVisDataRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->data_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->data_oldest_nonremovable);
+ GlobalVisTempRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->temp_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->temp_oldest_nonremovable);
+
+ /*
+ * In longer running transactions it's possible that transactions we
+@@ -4170,15 +4158,7 @@ GlobalVisTestIsRemovableXid(GlobalVisState *state, TransactionId xid)
+ {
+ FullTransactionId fxid;
+
+- /*
+- * Convert 32 bit argument to FullTransactionId. We can do so safely
+- * because we know the xid has to, at the very least, be between
+- * [oldestXid, nextXid), i.e. within 2 billion of xid. To avoid taking a
+- * lock to determine either, we can just compare with
+- * state->definitely_needed, which was based on those value at the time
+- * the current snapshot was built.
+- */
+- fxid = FullXidRelativeTo(state->definitely_needed, xid);
++ fxid = FullTransactionIdFromXid(xid);
+
+ return GlobalVisTestIsRemovableFullXid(state, fxid);
+ }
+@@ -4241,32 +4221,6 @@ GlobalVisCheckRemovableXid(Relation rel, TransactionId xid)
+ return GlobalVisTestIsRemovableXid(state, xid);
+ }
+
+-/*
+- * Convert a 32 bit transaction id into 64 bit transaction id, by assuming it
+- * is within MaxTransactionId / 2 of XidFromFullTransactionId(rel).
+- *
+- * Be very careful about when to use this function. It can only safely be used
+- * when there is a guarantee that xid is within MaxTransactionId / 2 xids of
+- * rel. That e.g. can be guaranteed if the caller assures a snapshot is
+- * held by the backend and xid is from a table (where vacuum/freezing ensures
+- * the xid has to be within that range), or if xid is from the procarray and
+- * prevents xid wraparound that way.
+- */
+-static inline FullTransactionId
+-FullXidRelativeTo(FullTransactionId rel, TransactionId xid)
+-{
+- TransactionId rel_xid = XidFromFullTransactionId(rel);
+-
+- Assert(TransactionIdIsValid(xid));
+- Assert(TransactionIdIsValid(rel_xid));
+-
+- /* not guaranteed to find issues, but likely to catch mistakes */
+- AssertTransactionIdInAllowableRange(xid);
+-
+- return FullTransactionIdFromU64(U64FromFullTransactionId(rel)
+- + (int32) (xid - rel_xid));
+-}
+-
+
+ /* ----------------------------------------------
+ * KnownAssignedTransactionIds sub-module
+diff --git a/src/backend/storage/ipc/sinvaladt.c b/src/backend/storage/ipc/sinvaladt.c
+index 3d97c75bf1..4170653cc6 100644
+--- a/src/backend/storage/ipc/sinvaladt.c
++++ b/src/backend/storage/ipc/sinvaladt.c
+@@ -429,8 +429,8 @@ BackendIdGetTransactionIds(int backendID, TransactionId *xid,
+
+ if (proc != NULL)
+ {
+- *xid = proc->xid;
+- *xmin = proc->xmin;
++ *xid = pg_atomic_read_u64(&proc->xid);
++ *xmin = pg_atomic_read_u64(&proc->xmin);
+ *nsubxid = proc->subxidStatus.count;
+ *overflowed = proc->subxidStatus.overflowed;
+ }
+diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c
+index 9352428e99..010ab63c2f 100644
+--- a/src/backend/storage/ipc/standby.c
++++ b/src/backend/storage/ipc/standby.c
+@@ -522,8 +522,8 @@ ResolveRecoveryConflictWithSnapshotFullXid(FullTransactionId snapshotConflictHor
+ FullTransactionId nextXid = ReadNextFullTransactionId();
+ uint64 diff;
+
+- diff = U64FromFullTransactionId(nextXid) -
+- U64FromFullTransactionId(snapshotConflictHorizon);
++ diff = XidFromFullTransactionId(nextXid) -
++ XidFromFullTransactionId(snapshotConflictHorizon);
+ if (diff < MaxTransactionId / 2)
+ {
+ TransactionId truncated;
+diff --git a/src/backend/storage/lmgr/lmgr.c b/src/backend/storage/lmgr/lmgr.c
+index b447ddf11b..27dc00ac6a 100644
+--- a/src/backend/storage/lmgr/lmgr.c
++++ b/src/backend/storage/lmgr/lmgr.c
+@@ -1240,10 +1240,16 @@ DescribeLockTag(StringInfo buf, const LOCKTAG *tag)
+ tag->locktag_field1);
+ break;
+ case LOCKTAG_TRANSACTION:
+- appendStringInfo(buf,
+- _("transaction %u"),
+- tag->locktag_field1);
+- break;
++ {
++ TransactionId xid;
++
++ xid = (TransactionId) tag->locktag_field2 << 32;
++ xid += tag->locktag_field1;
++
++ appendStringInfo(buf, _("transaction %llu"),
++ (unsigned long long) xid);
++ break;
++ }
+ case LOCKTAG_VIRTUALTRANSACTION:
+ appendStringInfo(buf,
+ _("virtual transaction %d/%u"),
+diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c
+index b8c57b3e16..3e2a55e25e 100644
+--- a/src/backend/storage/lmgr/lock.c
++++ b/src/backend/storage/lmgr/lock.c
+@@ -3981,7 +3981,7 @@ GetRunningTransactionLocks(int *nlocks)
+ {
+ PGPROC *proc = proclock->tag.myProc;
+ LOCK *lock = proclock->tag.myLock;
+- TransactionId xid = proc->xid;
++ TransactionId xid = pg_atomic_read_u64(&proc->xid);
+
+ /*
+ * Don't record locks for transactions if we know they have
+@@ -4601,7 +4601,7 @@ VirtualXactLock(VirtualTransactionId vxid, bool wait)
+ * so we won't save an XID of a different VXID. It doesn't matter whether
+ * we save this before or after setting up the primary lock table entry.
+ */
+- xid = proc->xid;
++ xid = pg_atomic_read_u64(&proc->xid);
+
+ /* Done with proc->fpLockBits */
+ LWLockRelease(&proc->fpInfoLock);
+diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
+index 8bfff14a86..1fd326736a 100644
+--- a/src/backend/storage/lmgr/predicate.c
++++ b/src/backend/storage/lmgr/predicate.c
+@@ -334,9 +334,9 @@ static SlruCtlData SerialSlruCtlData;
+
+ #define SerialValue(slotno, xid) (*((SerCommitSeqNo *) \
+ (SerialSlruCtl->shared->page_buffer[slotno] + \
+- ((((uint32) (xid)) % SERIAL_ENTRIESPERPAGE) * SERIAL_ENTRYSIZE))))
++ ((((uint64) (xid)) % SERIAL_ENTRIESPERPAGE) * SERIAL_ENTRYSIZE))))
+
+-#define SerialPage(xid) (((uint32) (xid)) / SERIAL_ENTRIESPERPAGE)
++#define SerialPage(xid) ((int64) (((uint64) (xid)) / SERIAL_ENTRIESPERPAGE))
+
+ typedef struct SerialControlData
+ {
+@@ -1042,31 +1042,6 @@ CheckPointPredicate(void)
+ /*----------
+ * The SLRU is no longer needed. Truncate to head before we set head
+ * invalid.
+- *
+- * XXX: It's possible that the SLRU is not needed again until XID
+- * wrap-around has happened, so that the segment containing headPage
+- * that we leave behind will appear to be new again. In that case it
+- * won't be removed until XID horizon advances enough to make it
+- * current again.
+- *
+- * XXX: This should happen in vac_truncate_clog(), not in checkpoints.
+- * Consider this scenario, starting from a system with no in-progress
+- * transactions and VACUUM FREEZE having maximized oldestXact:
+- * - Start a SERIALIZABLE transaction.
+- * - Start, finish, and summarize a SERIALIZABLE transaction, creating
+- * one SLRU page.
+- * - Consume XIDs to reach xidStopLimit.
+- * - Finish all transactions. Due to the long-running SERIALIZABLE
+- * transaction, earlier checkpoints did not touch headPage. The
+- * next checkpoint will change it, but that checkpoint happens after
+- * the end of the scenario.
+- * - VACUUM to advance XID limits.
+- * - Consume ~2M XIDs, crossing the former xidWrapLimit.
+- * - Start, finish, and summarize a SERIALIZABLE transaction.
+- * SerialAdd() declines to create the targetPage, because headPage
+- * is not regarded as in the past relative to that targetPage. The
+- * transaction instigating the summarize fails in
+- * SimpleLruReadPage().
+ */
+ truncateCutoffPage = serialControl->headPage;
+ serialControl->headPage = -1;
+@@ -3935,7 +3910,7 @@ XidIsConcurrent(TransactionId xid)
+ if (TransactionIdFollowsOrEquals(xid, snap->xmax))
+ return true;
+
+- return pg_lfind32(xid, snap->xip, snap->xcnt);
++ return pg_lfind64(xid, snap->xip, snap->xcnt);
+ }
+
+ bool
+diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
+index b6451d9d08..cdfdc47ddb 100644
+--- a/src/backend/storage/lmgr/proc.c
++++ b/src/backend/storage/lmgr/proc.c
+@@ -203,7 +203,7 @@ InitProcGlobal(void)
+ * how hotly they are accessed.
+ */
+ ProcGlobal->xids =
+- (TransactionId *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->xids));
++ (pg_atomic_uint64 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->xids));
+ MemSet(ProcGlobal->xids, 0, TotalProcs * sizeof(*ProcGlobal->xids));
+ ProcGlobal->subxidStates = (XidCacheStatus *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->subxidStates));
+ MemSet(ProcGlobal->subxidStates, 0, TotalProcs * sizeof(*ProcGlobal->subxidStates));
+@@ -216,6 +216,8 @@ InitProcGlobal(void)
+
+ /* Common initialization for all PGPROCs, regardless of type. */
+
++ pg_atomic_init_u64(&ProcGlobal->xids[i], 0);
++
+ /*
+ * Set up per-PGPROC semaphore, latch, and fpInfoLock. Prepared xact
+ * dummy PGPROCs don't need these though - they're never associated
+@@ -377,8 +379,8 @@ InitProcess(void)
+ MyProc->lxid = InvalidLocalTransactionId;
+ MyProc->fpVXIDLock = false;
+ MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
+- MyProc->xid = InvalidTransactionId;
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_init_u64(&MyProc->xid, InvalidTransactionId);
++ pg_atomic_init_u64(&MyProc->xmin, InvalidTransactionId);
+ MyProc->pid = MyProcPid;
+ /* backendId, databaseId and roleId will be filled in later */
+ MyProc->backendId = InvalidBackendId;
+@@ -574,8 +576,8 @@ InitAuxiliaryProcess(void)
+ MyProc->lxid = InvalidLocalTransactionId;
+ MyProc->fpVXIDLock = false;
+ MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
+- MyProc->xid = InvalidTransactionId;
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_init_u64(&MyProc->xid, InvalidTransactionId);
++ pg_atomic_init_u64(&MyProc->xmin, InvalidTransactionId);
+ MyProc->backendId = InvalidBackendId;
+ MyProc->databaseId = InvalidOid;
+ MyProc->roleId = InvalidOid;
+diff --git a/src/backend/storage/page/bufpage.c b/src/backend/storage/page/bufpage.c
+index 9a302ddc30..572c6d6b63 100644
+--- a/src/backend/storage/page/bufpage.c
++++ b/src/backend/storage/page/bufpage.c
+@@ -21,11 +21,31 @@
+ #include "storage/checksum.h"
+ #include "utils/memdebug.h"
+ #include "utils/memutils.h"
++#include "utils/snapmgr.h"
+
+
+ /* GUC variable */
+ bool ignore_checksum_failure = false;
+
++/*
++ * HeapPageSpecialData used when pd_special == BLCKSZ. This is special format
++ * used when page with 32-bit xids doesn't fit HeapPageSpecialData. Then
++ * all xmin's are frozen (can do this for all live tuples after pg_upgrade),
++ * while 64-bit xmax is stored in both t_heap.t_xmin and t_heap.t_xmax.
++ * This is so-called "double xmax" format.
++ */
++static HeapPageSpecialData heapDoubleXmaxSpecialData =
++{
++ .pd_xid_base = MaxTransactionId,
++ .pd_multi_base = MaxTransactionId
++};
++HeapPageSpecial heapDoubleXmaxSpecial = &heapDoubleXmaxSpecialData;
++
++static ToastPageSpecialData toastDoubleXmaxSpecialData =
++{
++ .pd_xid_base = MaxTransactionId
++};
++ToastPageSpecial toastDoubleXmaxSpecial = &toastDoubleXmaxSpecialData;
+
+ /* ----------------------------------------------------------------
+ * Page support functions
+@@ -432,15 +452,144 @@ PageRestoreTempPage(Page tempPage, Page oldPage)
+ }
+
+ /*
+- * Tuple defrag support for PageRepairFragmentation and PageIndexMultiDelete
++ * Get minimum and maximum values of xid and multixact on "double xmax" page.
+ */
+-typedef struct itemIdCompactData
++static void
++heap_page_double_xmax_get_min_max(Page page,
++ TransactionId *xid_min,
++ TransactionId *xid_max,
++ MultiXactId *multi_min,
++ MultiXactId *multi_max)
+ {
+- uint16 offsetindex; /* linp array index */
+- int16 itemoff; /* page offset of item data */
+- uint16 alignedlen; /* MAXALIGN(item data len) */
+-} itemIdCompactData;
+-typedef itemIdCompactData *itemIdCompact;
++ bool xid_found = false,
++ multi_found = false;
++ OffsetNumber offnum,
++ maxoff;
++
++ maxoff = PageGetMaxOffsetNumber(page);
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ ItemId itemid;
++ HeapTupleHeader htup;
++ TransactionId xmax;
++
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++
++ xmax = HeapTupleHeaderGetDoubleXmax(htup);
++
++ if (!TransactionIdIsNormal(xmax))
++ continue;
++
++ if (!(htup->t_infomask & HEAP_XMAX_IS_MULTI))
++ {
++ if (!xid_found)
++ {
++ *xid_min = *xid_max = xmax;
++ xid_found = true;
++ }
++ else
++ {
++ *xid_min = Min(*xid_min, xmax);
++ *xid_max = Max(*xid_max, xmax);
++ }
++ }
++ else
++ {
++ if (!multi_found)
++ {
++ *multi_min = *multi_max = xmax;
++ multi_found = true;
++ }
++ else
++ {
++ *multi_min = Min(*multi_min, xmax);
++ *multi_max = Max(*multi_max, xmax);
++ }
++ }
++ }
++}
++
++/*
++ * Add special area to heap page, so convert from "double xmax" to normal
++ * format.
++ */
++static void
++heap_page_add_special_area(ItemIdCompact itemidbase, int nitems, Page page,
++ TransactionId xid_base, MultiXactId multi_base,
++ bool is_toast)
++{
++ char newPage[BLCKSZ];
++ PageHeader phdr = (PageHeader) page;
++ PageHeader new_phdr = (PageHeader) newPage;
++ Offset upper;
++ int i;
++
++ memcpy(newPage, page, phdr->pd_lower);
++
++ /* Add special area */
++ if (is_toast)
++ {
++ ToastPageSpecial special;
++
++ new_phdr->pd_special = PageGetPageSize(newPage) - sizeof(ToastPageSpecialData);
++ special = (ToastPageSpecial) ((Pointer) (newPage) + new_phdr->pd_special);
++ special->pd_xid_base = xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ new_phdr->pd_special = PageGetPageSize(newPage) - sizeof(HeapPageSpecialData);
++ special = (HeapPageSpecial) ((Pointer) (newPage) + new_phdr->pd_special);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
++ }
++
++ /* sort itemIdSortData array into decreasing itemoff order */
++ qsort((char *) itemidbase, nitems, sizeof(ItemIdCompactData),
++ itemoffcompare);
++
++ upper = new_phdr->pd_special;
++ for (i = 0; i < nitems; i++)
++ {
++ ItemIdCompact itemidptr = &itemidbase[i];
++ ItemId lp;
++ HeapTupleHeader old_htup;
++ HeapTupleHeader new_htup;
++ TransactionId xmax;
++
++ lp = PageGetItemId(page, itemidptr->offsetindex + 1);
++ old_htup = (HeapTupleHeader) PageGetItem(page, lp);
++ upper -= itemidptr->alignedlen;
++ memcpy((Pointer) newPage + upper,
++ (Pointer) page + itemidptr->itemoff,
++ itemidptr->alignedlen);
++ lp = PageGetItemId(newPage, itemidptr->offsetindex + 1);
++ lp->lp_off = upper;
++ new_htup = (HeapTupleHeader) PageGetItem(newPage, lp);
++
++ /* Convert xmax value */
++ new_htup->t_choice.t_heap.t_xmin = FrozenTransactionId;
++ xmax = HeapTupleHeaderGetDoubleXmax(old_htup);
++ if (!(new_htup->t_infomask & HEAP_XMAX_IS_MULTI))
++ new_htup->t_choice.t_heap.t_xmax = NormalTransactionIdToShort(xid_base, xmax);
++ else
++ new_htup->t_choice.t_heap.t_xmax = NormalTransactionIdToShort(multi_base, xmax);
++ }
++
++ new_phdr->pd_upper = upper;
++
++ memcpy(page, newPage, PageGetPageSize(newPage));
++ elog(DEBUG2, "convert heap page from double xmax to normal format");
++}
+
+ /*
+ * After removing or marking some line pointers unused, move the tuples to
+@@ -471,21 +620,47 @@ typedef itemIdCompactData *itemIdCompact;
+ * Callers must ensure that nitems is > 0
+ */
+ static void
+-compactify_tuples(itemIdCompact itemidbase, int nitems, Page page, bool presorted)
++compactify_tuples(ItemIdCompact itemidbase, int nitems, Page page,
++ bool presorted, bool addspecial, bool is_toast)
+ {
+ PageHeader phdr = (PageHeader) page;
+ Offset upper;
+ Offset copy_tail;
+ Offset copy_head;
+- itemIdCompact itemidptr;
++ ItemIdCompact itemidptr;
+ int i;
+
+ /* Code within will not work correctly if nitems == 0 */
+ Assert(nitems > 0);
+
+- if (presorted)
++ /* Add special area to the heap page if possible */
++ if (addspecial)
+ {
++ TransactionId xid_min = FirstNormalTransactionId,
++ xid_max = FirstNormalTransactionId;
++ MultiXactId multi_min = FirstNormalTransactionId,
++ multi_max = FirstNormalTransactionId;
+
++ Assert(phdr->pd_special == PageGetPageSize(page));
++
++ heap_page_double_xmax_get_min_max(page, &xid_min, &xid_max,
++ &multi_min, &multi_max);
++
++ if (xid_max - xid_min < (TransactionId) (MaxShortTransactionId - FirstNormalTransactionId) &&
++ multi_max - multi_min < (TransactionId) (MaxShortTransactionId - FirstNormalTransactionId))
++ {
++ Assert(xid_min >= FirstNormalTransactionId);
++ Assert(multi_min >= FirstNormalTransactionId);
++ heap_page_add_special_area(itemidbase, nitems, page,
++ xid_min - FirstNormalTransactionId,
++ multi_min - FirstNormalTransactionId,
++ is_toast);
++ return;
++ }
++ }
++
++ if (presorted)
++ {
+ #ifdef USE_ASSERT_CHECKING
+ {
+ /*
+@@ -696,14 +871,14 @@ compactify_tuples(itemIdCompact itemidbase, int nitems, Page page, bool presorte
+ * the line pointer array following array truncation.
+ */
+ void
+-PageRepairFragmentation(Page page)
++PageRepairFragmentation(Page page, bool is_toast)
+ {
+ Offset pd_lower = ((PageHeader) page)->pd_lower;
+ Offset pd_upper = ((PageHeader) page)->pd_upper;
+ Offset pd_special = ((PageHeader) page)->pd_special;
+ Offset last_offset;
+- itemIdCompactData itemidbase[MaxHeapTuplesPerPage];
+- itemIdCompact itemidptr;
++ ItemIdCompactData itemidbase[MaxHeapTuplesPerPage];
++ ItemIdCompact itemidptr;
+ ItemId lp;
+ int nline,
+ nstorage,
+@@ -777,11 +952,30 @@ PageRepairFragmentation(Page page)
+ nstorage = itemidptr - itemidbase;
+ if (nstorage == 0)
+ {
++ if (pd_special == PageGetPageSize(page))
++ {
++ if (is_toast)
++ {
++ pd_special = PageGetPageSize(page) - sizeof(ToastPageSpecialData);
++ ((PageHeader) page)->pd_special = pd_special;
++ ToastPageGetSpecial(page)->pd_xid_base = 0;
++ }
++ else
++ {
++ pd_special = PageGetPageSize(page) - sizeof(HeapPageSpecialData);
++ ((PageHeader) page)->pd_special = pd_special;
++ HeapPageGetSpecial(page)->pd_xid_base = 0;
++ HeapPageGetSpecial(page)->pd_multi_base = 0;
++ }
++ }
++
+ /* Page is completely empty, so just reset it quickly */
+ ((PageHeader) page)->pd_upper = pd_special;
+ }
+ else
+ {
++ bool addspecial = false;
++
+ /* Need to compact the page the hard way */
+ if (totallen > (Size) (pd_special - pd_lower))
+ ereport(ERROR,
+@@ -789,7 +983,25 @@ PageRepairFragmentation(Page page)
+ errmsg("corrupted item lengths: total %u, available space %u",
+ (unsigned int) totallen, pd_special - pd_lower)));
+
+- compactify_tuples(itemidbase, nstorage, page, presorted);
++ /*
++ * Try to add special area to the heap page if it has enough of free
++ * space.
++ */
++ if (pd_special == PageGetPageSize(page))
++ {
++ Size special_size,
++ actual_size;
++
++ special_size = is_toast ? sizeof(ToastPageSpecialData) :
++ sizeof(HeapPageSpecialData);
++ actual_size = (Size) (pd_special - pd_lower) - totallen;
++
++ if (actual_size >= special_size)
++ addspecial = true;
++ }
++
++ compactify_tuples(itemidbase, nstorage, page, presorted, addspecial,
++ is_toast);
+ }
+
+ if (finalusedlp != nline)
+@@ -992,6 +1204,9 @@ PageGetHeapFreeSpace(Page page)
+ {
+ Size space;
+
++ if (HeapPageIsDoubleXmax(page))
++ return 0;
++
+ space = PageGetFreeSpace(page);
+ if (space > 0)
+ {
+@@ -1165,9 +1380,9 @@ PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)
+ Offset pd_upper = phdr->pd_upper;
+ Offset pd_special = phdr->pd_special;
+ Offset last_offset;
+- itemIdCompactData itemidbase[MaxIndexTuplesPerPage];
++ ItemIdCompactData itemidbase[MaxIndexTuplesPerPage];
+ ItemIdData newitemids[MaxIndexTuplesPerPage];
+- itemIdCompact itemidptr;
++ ItemIdCompact itemidptr;
+ ItemId lp;
+ int nline,
+ nused;
+@@ -1275,7 +1490,12 @@ PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)
+
+ /* and compactify the tuple data */
+ if (nused > 0)
+- compactify_tuples(itemidbase, nused, page, presorted);
++ {
++ bool is_toast;
++
++ is_toast = BLCKSZ - pd_special == sizeof(ToastPageSpecialData);
++ compactify_tuples(itemidbase, nused, page, presorted, false, is_toast);
++ }
+ else
+ phdr->pd_upper = pd_special;
+ }
+diff --git a/src/backend/utils/adt/enum.c b/src/backend/utils/adt/enum.c
+index fdfdf7d0d2..5886c60200 100644
+--- a/src/backend/utils/adt/enum.c
++++ b/src/backend/utils/adt/enum.c
+@@ -76,7 +76,7 @@ check_safe_enum_use(HeapTuple enumval_tup)
+ * Usually, a row would get hinted as committed when it's read or loaded
+ * into syscache; but just in case not, let's check the xmin directly.
+ */
+- xmin = HeapTupleHeaderGetXmin(enumval_tup->t_data);
++ xmin = HeapTupleGetXmin(enumval_tup);
+ if (!TransactionIdIsInProgress(xmin) &&
+ TransactionIdDidCommit(xmin))
+ return;
+diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
+index aa37c401e5..7b5e522465 100644
+--- a/src/backend/utils/adt/jsonfuncs.c
++++ b/src/backend/utils/adt/jsonfuncs.c
+@@ -3310,6 +3310,7 @@ populate_record(TupleDesc tupdesc,
+ tuple.t_len = HeapTupleHeaderGetDatumLength(defaultval);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = defaultval;
+
+ /* Break down the tuple into fields */
+@@ -3756,6 +3757,7 @@ populate_recordset_record(PopulateRecordsetState *state, JsObject *obj)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(tuphead);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = tuphead;
+
+ tuplestore_puttuple(state->tuple_store, &tuple);
+diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c
+index 974aa4fb43..a1e9406009 100644
+--- a/src/backend/utils/adt/lockfuncs.c
++++ b/src/backend/utils/adt/lockfuncs.c
+@@ -79,7 +79,7 @@ VXIDGetDatum(BackendId bid, LocalTransactionId lxid)
+ * The representation is "<bid>/<lxid>", decimal and unsigned decimal
+ * respectively. Note that elog.c also knows how to format a vxid.
+ */
+- char vxidstr[32];
++ char vxidstr[64];
+
+ snprintf(vxidstr, sizeof(vxidstr), "%d/%llu", bid,
+ (unsigned long long) lxid);
+@@ -293,7 +293,9 @@ pg_lock_status(PG_FUNCTION_ARGS)
+ break;
+ case LOCKTAG_TRANSACTION:
+ values[6] =
+- TransactionIdGetDatum(instance->locktag.locktag_field1);
++ TransactionIdGetDatum(
++ (TransactionId) instance->locktag.locktag_field1 |
++ ((TransactionId) instance->locktag.locktag_field2 << 32));
+ nulls[1] = true;
+ nulls[2] = true;
+ nulls[3] = true;
+@@ -305,7 +307,8 @@ pg_lock_status(PG_FUNCTION_ARGS)
+ break;
+ case LOCKTAG_VIRTUALTRANSACTION:
+ values[5] = VXIDGetDatum(instance->locktag.locktag_field1,
+- instance->locktag.locktag_field2);
++ (TransactionId) instance->locktag.locktag_field2 |
++ ((TransactionId) instance->locktag.locktag_field3 << 32));
+ nulls[1] = true;
+ nulls[2] = true;
+ nulls[3] = true;
+diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c
+index 0cea320c00..77c54f5d9f 100644
+--- a/src/backend/utils/adt/pgstatfuncs.c
++++ b/src/backend/utils/adt/pgstatfuncs.c
+@@ -15,6 +15,7 @@
+ #include "postgres.h"
+
+ #include "access/htup_details.h"
++#include "access/xact.h"
+ #include "access/xlog.h"
+ #include "access/xlogprefetcher.h"
+ #include "catalog/catalog.h"
+diff --git a/src/backend/utils/adt/rowtypes.c b/src/backend/utils/adt/rowtypes.c
+index eb8fe95933..37abb9061f 100644
+--- a/src/backend/utils/adt/rowtypes.c
++++ b/src/backend/utils/adt/rowtypes.c
+@@ -354,6 +354,7 @@ record_out(PG_FUNCTION_ARGS)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = rec;
+
+ /*
+@@ -712,6 +713,7 @@ record_send(PG_FUNCTION_ARGS)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = rec;
+
+ /*
+@@ -862,10 +864,12 @@ record_cmp(FunctionCallInfo fcinfo)
+ tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple1.t_data = record1;
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple2);
+ tuple2.t_data = record2;
+
+ /*
+@@ -1107,10 +1111,12 @@ record_eq(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
+ tuple1.t_data = record1;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
+ tuple2.t_data = record2;
++ HeapTupleSetZeroXids(&tuple2);
+
+ /*
+ * We arrange to look up the needed comparison info just once per series
+@@ -1369,10 +1375,12 @@ record_image_cmp(FunctionCallInfo fcinfo)
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
+ tuple1.t_data = record1;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
+ tuple2.t_data = record2;
++ HeapTupleSetZeroXids(&tuple2);
+
+ /*
+ * We arrange to look up the needed comparison info just once per series
+@@ -1615,10 +1623,12 @@ record_image_eq(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
+ tuple1.t_data = record1;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
+ tuple2.t_data = record2;
++ HeapTupleSetZeroXids(&tuple2);
+
+ /*
+ * We arrange to look up the needed comparison info just once per series
+@@ -1818,6 +1828,7 @@ hash_record(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = record;
++ HeapTupleSetZeroXids(&tuple);
+
+ /*
+ * We arrange to look up the needed hashing info just once per series of
+@@ -1939,6 +1950,7 @@ hash_record_extended(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = record;
++ HeapTupleSetZeroXids(&tuple);
+
+ /*
+ * We arrange to look up the needed hashing info just once per series of
+diff --git a/src/backend/utils/adt/xid.c b/src/backend/utils/adt/xid.c
+index 8ac1679c38..8e0830f4cc 100644
+--- a/src/backend/utils/adt/xid.c
++++ b/src/backend/utils/adt/xid.c
+@@ -33,7 +33,7 @@ xidin(PG_FUNCTION_ARGS)
+ char *str = PG_GETARG_CSTRING(0);
+ TransactionId result;
+
+- result = uint32in_subr(str, NULL, "xid", fcinfo->context);
++ result = uint64in_subr(str, NULL, "xid", fcinfo->context);
+ PG_RETURN_TRANSACTIONID(result);
+ }
+
+@@ -41,9 +41,9 @@ Datum
+ xidout(PG_FUNCTION_ARGS)
+ {
+ TransactionId transactionId = PG_GETARG_TRANSACTIONID(0);
+- char *result = (char *) palloc(16);
++ char *result = (char *) palloc(32);
+
+- snprintf(result, 16, "%lu", (unsigned long) transactionId);
++ snprintf(result, 32, "%llu", (unsigned long long) transactionId);
+ PG_RETURN_CSTRING(result);
+ }
+
+@@ -54,8 +54,13 @@ Datum
+ xidrecv(PG_FUNCTION_ARGS)
+ {
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
++ uint32 lo,
++ hi;
++
++ lo = (uint32) pq_getmsgint(buf, sizeof(TransactionId));
++ hi = (uint32) pq_getmsgint(buf, sizeof(TransactionId));
+
+- PG_RETURN_TRANSACTIONID((TransactionId) pq_getmsgint(buf, sizeof(TransactionId)));
++ PG_RETURN_TRANSACTIONID((uint64) lo + ((uint64) hi << 32));
+ }
+
+ /*
+@@ -66,9 +71,15 @@ xidsend(PG_FUNCTION_ARGS)
+ {
+ TransactionId arg1 = PG_GETARG_TRANSACTIONID(0);
+ StringInfoData buf;
++ uint32 lo,
++ hi;
++
++ lo = (uint32) (arg1 & 0xFFFFFFFF);
++ hi = (uint32) (arg1 >> 32);
+
+ pq_begintypsend(&buf);
+- pq_sendint32(&buf, arg1);
++ pq_sendint(&buf, lo, sizeof(lo));
++ pq_sendint(&buf, hi, sizeof(hi));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
+
+@@ -107,9 +118,9 @@ xid_age(PG_FUNCTION_ARGS)
+
+ /* Permanent XIDs are always infinitely old */
+ if (!TransactionIdIsNormal(xid))
+- PG_RETURN_INT32(INT_MAX);
++ PG_RETURN_INT64(PG_INT8_MAX);
+
+- PG_RETURN_INT32((int32) (now - xid));
++ PG_RETURN_INT64((int64) (now - xid));
+ }
+
+ /*
+@@ -122,9 +133,9 @@ mxid_age(PG_FUNCTION_ARGS)
+ MultiXactId now = ReadNextMultiXactId();
+
+ if (!MultiXactIdIsValid(xid))
+- PG_RETURN_INT32(INT_MAX);
++ PG_RETURN_INT64(PG_INT8_MAX);
+
+- PG_RETURN_INT32((int32) (now - xid));
++ PG_RETURN_INT64((int64) (now - xid));
+ }
+
+ /*
+@@ -188,7 +199,7 @@ xid8in(PG_FUNCTION_ARGS)
+ uint64 result;
+
+ result = uint64in_subr(str, NULL, "xid8", fcinfo->context);
+- PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromU64(result));
++ PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromXid(result));
+ }
+
+ Datum
+@@ -197,7 +208,7 @@ xid8out(PG_FUNCTION_ARGS)
+ FullTransactionId fxid = PG_GETARG_FULLTRANSACTIONID(0);
+ char *result = (char *) palloc(21);
+
+- snprintf(result, 21, UINT64_FORMAT, U64FromFullTransactionId(fxid));
++ snprintf(result, 21, UINT64_FORMAT, XidFromFullTransactionId(fxid));
+ PG_RETURN_CSTRING(result);
+ }
+
+@@ -208,7 +219,7 @@ xid8recv(PG_FUNCTION_ARGS)
+ uint64 value;
+
+ value = (uint64) pq_getmsgint64(buf);
+- PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromU64(value));
++ PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromXid(value));
+ }
+
+ Datum
+@@ -218,7 +229,7 @@ xid8send(PG_FUNCTION_ARGS)
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+- pq_sendint64(&buf, (uint64) U64FromFullTransactionId(arg1));
++ pq_sendint64(&buf, (uint64) XidFromFullTransactionId(arg1));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
+
+diff --git a/src/backend/utils/adt/xid8funcs.c b/src/backend/utils/adt/xid8funcs.c
+index 06ae940df6..becd220981 100644
+--- a/src/backend/utils/adt/xid8funcs.c
++++ b/src/backend/utils/adt/xid8funcs.c
+@@ -88,8 +88,7 @@ StaticAssertDecl(MAX_BACKENDS * 2 <= PG_SNAPSHOT_MAX_NXIP,
+ * It is an ERROR if the xid is in the future. Otherwise, returns true if
+ * the transaction is still new enough that we can determine whether it
+ * committed and false otherwise. If *extracted_xid is not NULL, it is set
+- * to the low 32 bits of the transaction ID (i.e. the actual XID, without the
+- * epoch).
++ * to the actual transaction ID.
+ *
+ * The caller must hold XactTruncationLock since it's dealing with arbitrary
+ * XIDs, and must continue to hold it until it's done with any clog lookups
+@@ -98,15 +97,10 @@ StaticAssertDecl(MAX_BACKENDS * 2 <= PG_SNAPSHOT_MAX_NXIP,
+ static bool
+ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
+ {
+- uint32 xid_epoch = EpochFromFullTransactionId(fxid);
+ TransactionId xid = XidFromFullTransactionId(fxid);
+- uint32 now_epoch;
+- TransactionId now_epoch_next_xid;
+ FullTransactionId now_fullxid;
+
+ now_fullxid = ReadNextFullTransactionId();
+- now_epoch_next_xid = XidFromFullTransactionId(now_fullxid);
+- now_epoch = EpochFromFullTransactionId(now_fullxid);
+
+ if (extracted_xid != NULL)
+ *extracted_xid = xid;
+@@ -123,7 +117,7 @@ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("transaction ID %llu is in the future",
+- (unsigned long long) U64FromFullTransactionId(fxid))));
++ (unsigned long long) XidFromFullTransactionId(fxid))));
+
+ /*
+ * ShmemVariableCache->oldestClogXid is protected by XactTruncationLock,
+@@ -135,48 +129,15 @@ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
+ Assert(LWLockHeldByMe(XactTruncationLock));
+
+ /*
+- * If the transaction ID has wrapped around, it's definitely too old to
+- * determine the commit status. Otherwise, we can compare it to
+- * ShmemVariableCache->oldestClogXid to determine whether the relevant
+- * CLOG entry is guaranteed to still exist.
++ * We compare xid to ShmemVariableCache->oldestClogXid to determine
++ * whether the relevant CLOG entry is guaranteed to still exist.
+ */
+- if (xid_epoch + 1 < now_epoch
+- || (xid_epoch + 1 == now_epoch && xid < now_epoch_next_xid)
+- || TransactionIdPrecedes(xid, ShmemVariableCache->oldestClogXid))
++ if (TransactionIdPrecedes(xid, ShmemVariableCache->oldestClogXid))
+ return false;
+
+ return true;
+ }
+
+-/*
+- * Convert a TransactionId obtained from a snapshot held by the caller to a
+- * FullTransactionId. Use next_fxid as a reference FullTransactionId, so that
+- * we can compute the high order bits. It must have been obtained by the
+- * caller with ReadNextFullTransactionId() after the snapshot was created.
+- */
+-static FullTransactionId
+-widen_snapshot_xid(TransactionId xid, FullTransactionId next_fxid)
+-{
+- TransactionId next_xid = XidFromFullTransactionId(next_fxid);
+- uint32 epoch = EpochFromFullTransactionId(next_fxid);
+-
+- /* Special transaction ID. */
+- if (!TransactionIdIsNormal(xid))
+- return FullTransactionIdFromEpochAndXid(0, xid);
+-
+- /*
+- * The 64 bit result must be <= next_fxid, since next_fxid hadn't been
+- * issued yet when the snapshot was created. Every TransactionId in the
+- * snapshot must therefore be from the same epoch as next_fxid, or the
+- * epoch before. We know this because next_fxid is never allow to get
+- * more than one epoch ahead of the TransactionIds in any snapshot.
+- */
+- if (xid > next_xid)
+- epoch--;
+-
+- return FullTransactionIdFromEpochAndXid(epoch, xid);
+-}
+-
+ /*
+ * txid comparator for qsort/bsearch
+ */
+@@ -303,12 +264,12 @@ parse_snapshot(const char *str, Node *escontext)
+ char *endp;
+ StringInfo buf;
+
+- xmin = FullTransactionIdFromU64(strtou64(str, &endp, 10));
++ xmin = FullTransactionIdFromXid(strtou64(str, &endp, 10));
+ if (*endp != ':')
+ goto bad_format;
+ str = endp + 1;
+
+- xmax = FullTransactionIdFromU64(strtou64(str, &endp, 10));
++ xmax = FullTransactionIdFromXid(strtou64(str, &endp, 10));
+ if (*endp != ':')
+ goto bad_format;
+ str = endp + 1;
+@@ -326,7 +287,7 @@ parse_snapshot(const char *str, Node *escontext)
+ while (*str != '\0')
+ {
+ /* read next value */
+- val = FullTransactionIdFromU64(strtou64(str, &endp, 10));
++ val = FullTransactionIdFromXid(strtou64(str, &endp, 10));
+ str = endp;
+
+ /* require the input to be in order */
+@@ -404,7 +365,6 @@ pg_current_snapshot(PG_FUNCTION_ARGS)
+ uint32 nxip,
+ i;
+ Snapshot cur;
+- FullTransactionId next_fxid = ReadNextFullTransactionId();
+
+ cur = GetActiveSnapshot();
+ if (cur == NULL)
+@@ -415,11 +375,11 @@ pg_current_snapshot(PG_FUNCTION_ARGS)
+ snap = palloc(PG_SNAPSHOT_SIZE(nxip));
+
+ /* fill */
+- snap->xmin = widen_snapshot_xid(cur->xmin, next_fxid);
+- snap->xmax = widen_snapshot_xid(cur->xmax, next_fxid);
++ snap->xmin = FullTransactionIdFromXid(cur->xmin);
++ snap->xmax = FullTransactionIdFromXid(cur->xmax);
+ snap->nxip = nxip;
+ for (i = 0; i < nxip; i++)
+- snap->xip[i] = widen_snapshot_xid(cur->xip[i], next_fxid);
++ snap->xip[i] = FullTransactionIdFromXid(cur->xip[i]);
+
+ /*
+ * We want them guaranteed to be in ascending order. This also removes
+@@ -467,16 +427,16 @@ pg_snapshot_out(PG_FUNCTION_ARGS)
+ initStringInfo(&str);
+
+ appendStringInfo(&str, UINT64_FORMAT ":",
+- U64FromFullTransactionId(snap->xmin));
++ XidFromFullTransactionId(snap->xmin));
+ appendStringInfo(&str, UINT64_FORMAT ":",
+- U64FromFullTransactionId(snap->xmax));
++ XidFromFullTransactionId(snap->xmax));
+
+ for (i = 0; i < snap->nxip; i++)
+ {
+ if (i > 0)
+ appendStringInfoChar(&str, ',');
+ appendStringInfo(&str, UINT64_FORMAT,
+- U64FromFullTransactionId(snap->xip[i]));
++ XidFromFullTransactionId(snap->xip[i]));
+ }
+
+ PG_RETURN_CSTRING(str.data);
+@@ -505,8 +465,8 @@ pg_snapshot_recv(PG_FUNCTION_ARGS)
+ if (nxip < 0 || nxip > PG_SNAPSHOT_MAX_NXIP)
+ goto bad_format;
+
+- xmin = FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
+- xmax = FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
++ xmin = FullTransactionIdFromXid((uint64) pq_getmsgint64(buf));
++ xmax = FullTransactionIdFromXid((uint64) pq_getmsgint64(buf));
+ if (!FullTransactionIdIsValid(xmin) ||
+ !FullTransactionIdIsValid(xmax) ||
+ FullTransactionIdPrecedes(xmax, xmin))
+@@ -519,7 +479,7 @@ pg_snapshot_recv(PG_FUNCTION_ARGS)
+ for (i = 0; i < nxip; i++)
+ {
+ FullTransactionId cur =
+- FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
++ FullTransactionIdFromXid((uint64) pq_getmsgint64(buf));
+
+ if (FullTransactionIdPrecedes(cur, last) ||
+ FullTransactionIdPrecedes(cur, xmin) ||
+@@ -564,10 +524,10 @@ pg_snapshot_send(PG_FUNCTION_ARGS)
+
+ pq_begintypsend(&buf);
+ pq_sendint32(&buf, snap->nxip);
+- pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xmin));
+- pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xmax));
++ pq_sendint64(&buf, (int64) XidFromFullTransactionId(snap->xmin));
++ pq_sendint64(&buf, (int64) XidFromFullTransactionId(snap->xmax));
+ for (i = 0; i < snap->nxip; i++)
+- pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xip[i]));
++ pq_sendint64(&buf, (int64) XidFromFullTransactionId(snap->xip[i]));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
+
+@@ -655,8 +615,7 @@ pg_snapshot_xip(PG_FUNCTION_ARGS)
+ * Report the status of a recent transaction ID, or null for wrapped,
+ * truncated away or otherwise too old XIDs.
+ *
+- * The passed epoch-qualified xid is treated as a normal xid, not a
+- * multixact id.
++ * The passed xid is treated as a normal xid, not a multixact id.
+ *
+ * If it points to a committed subxact the result is the subxact status even
+ * though the parent xact may still be in progress or may have aborted.
+diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
+index 2e2e4d9f1f..674e9ecd8e 100644
+--- a/src/backend/utils/cache/catcache.c
++++ b/src/backend/utils/cache/catcache.c
+@@ -1908,6 +1908,7 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, Datum *arguments,
+ memcpy((char *) ct->tuple.t_data,
+ (const char *) dtp->t_data,
+ dtp->t_len);
++ HeapTupleCopyXids(&ct->tuple, dtp);
+ MemoryContextSwitchTo(oldcxt);
+
+ if (dtp != ntp)
+diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
+index b3faccbefe..c4c1b0dbbd 100644
+--- a/src/backend/utils/cache/relcache.c
++++ b/src/backend/utils/cache/relcache.c
+@@ -2341,8 +2341,7 @@ RelationReloadIndexInfo(Relation relation)
+ relation->rd_index->indisreplident = index->indisreplident;
+
+ /* Copy xmin too, as that is needed to make sense of indcheckxmin */
+- HeapTupleHeaderSetXmin(relation->rd_indextuple->t_data,
+- HeapTupleHeaderGetXmin(tuple->t_data));
++ HeapTupleSetXmin(relation->rd_indextuple, HeapTupleGetXmin(tuple));
+
+ ReleaseSysCache(tuple);
+ }
+diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c
+index 9dfdf890c5..c3122b317c 100644
+--- a/src/backend/utils/fmgr/fmgr.c
++++ b/src/backend/utils/fmgr/fmgr.c
+@@ -526,7 +526,7 @@ lookup_C_func(HeapTuple procedureTuple)
+ NULL);
+ if (entry == NULL)
+ return NULL; /* no such entry */
+- if (entry->fn_xmin == HeapTupleHeaderGetRawXmin(procedureTuple->t_data) &&
++ if (entry->fn_xmin == HeapTupleGetRawXmin(procedureTuple) &&
+ ItemPointerEquals(&entry->fn_tid, &procedureTuple->t_self))
+ return entry; /* OK */
+ return NULL; /* entry is out of date */
+@@ -562,7 +562,7 @@ record_C_func(HeapTuple procedureTuple,
+ HASH_ENTER,
+ &found);
+ /* OID is already filled in */
+- entry->fn_xmin = HeapTupleHeaderGetRawXmin(procedureTuple->t_data);
++ entry->fn_xmin = HeapTupleGetRawXmin(procedureTuple);
+ entry->fn_tid = procedureTuple->t_self;
+ entry->user_fn = user_fn;
+ entry->inforec = inforec;
+diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
+index fd0bc11a00..0b4d2e875d 100644
+--- a/src/backend/utils/misc/guc_tables.c
++++ b/src/backend/utils/misc/guc_tables.c
+@@ -2556,65 +2556,6 @@ struct config_int ConfigureNamesInt[] =
+ NULL, NULL, NULL
+ },
+
+- {
+- {"vacuum_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Minimum age at which VACUUM should freeze a table row."),
+- NULL
+- },
+- &vacuum_freeze_min_age,
+- 50000000, 0, 1000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
+- NULL
+- },
+- &vacuum_freeze_table_age,
+- 150000000, 0, 2000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_multixact_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
+- NULL
+- },
+- &vacuum_multixact_freeze_min_age,
+- 5000000, 0, 1000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_multixact_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Multixact age at which VACUUM should scan whole table to freeze tuples."),
+- NULL
+- },
+- &vacuum_multixact_freeze_table_age,
+- 150000000, 0, 2000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
+- NULL
+- },
+- &vacuum_failsafe_age,
+- 1600000000, 0, 2100000000,
+- NULL, NULL, NULL
+- },
+- {
+- {"vacuum_multixact_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Multixact age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
+- NULL
+- },
+- &vacuum_multixact_failsafe_age,
+- 1600000000, 0, 2100000000,
+- NULL, NULL, NULL
+- },
+-
+ /*
+ * See also CheckRequiredParameterValues() if this parameter changes
+ */
+@@ -3239,28 +3180,6 @@ struct config_int ConfigureNamesInt[] =
+ 50, 0, INT_MAX,
+ NULL, NULL, NULL
+ },
+- {
+- /* see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
+- {"autovacuum_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
+- gettext_noop("Age at which to autovacuum a table to prevent transaction ID wraparound."),
+- NULL
+- },
+- &autovacuum_freeze_max_age,
+-
+- /* see vacuum_failsafe_age if you change the upper-limit value. */
+- 200000000, 100000, 2000000000,
+- NULL, NULL, NULL
+- },
+- {
+- /* see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
+- {"autovacuum_multixact_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
+- gettext_noop("Multixact age at which to autovacuum a table to prevent multixact wraparound."),
+- NULL
+- },
+- &autovacuum_multixact_freeze_max_age,
+- 400000000, 10000, 2000000000,
+- NULL, NULL, NULL
+- },
+ {
+ /* see max_connections */
+ {"autovacuum_max_workers", PGC_POSTMASTER, AUTOVACUUM,
+@@ -3528,7 +3447,6 @@ struct config_int ConfigureNamesInt[] =
+ SCRAM_SHA_256_DEFAULT_ITERATIONS, 1, INT_MAX,
+ NULL, NULL, NULL
+ },
+-
+ /* End-of-list marker */
+ {
+ {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
+@@ -3538,6 +3456,87 @@ struct config_int ConfigureNamesInt[] =
+
+ struct config_int64 ConfigureNamesInt64[] =
+ {
++ {
++ {"vacuum_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Minimum age at which VACUUM should freeze a table row."),
++ NULL
++ },
++ &vacuum_freeze_min_age,
++ INT64CONST(50000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
++ NULL
++ },
++ &vacuum_freeze_table_age,
++ INT64CONST(150000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_multixact_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
++ NULL
++ },
++ &vacuum_multixact_freeze_min_age,
++ INT64CONST(5000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_multixact_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Multixact age at which VACUUM should scan whole table to freeze tuples."),
++ NULL
++ },
++ &vacuum_multixact_freeze_table_age,
++ INT64CONST(150000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
++ NULL
++ },
++ &vacuum_failsafe_age,
++ INT64CONST(1600000000), INT64CONST(0), INT64CONST(2100000000),
++ NULL, NULL, NULL
++ },
++ {
++ {"vacuum_multixact_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Multixact age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
++ NULL
++ },
++ &vacuum_multixact_failsafe_age,
++ INT64CONST(1600000000), INT64CONST(0), INT64CONST(2100000000),
++ NULL, NULL, NULL
++ },
++ {
++ /* see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
++ {"autovacuum_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
++ gettext_noop("Age at which to autovacuum a table to prevent transaction ID wraparound."),
++ NULL
++ },
++ &autovacuum_freeze_max_age,
++
++ /* see vacuum_failsafe_age if you change the upper-limit value. */
++ INT64CONST(10000000000), INT64CONST(100000), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++ {
++ /* see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
++ {"autovacuum_multixact_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
++ gettext_noop("Multixact age at which to autovacuum a table to prevent multixact wraparound."),
++ NULL
++ },
++ &autovacuum_multixact_freeze_max_age,
++ INT64CONST(20000000000), INT64CONST(10000), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
+ /* End-of-list marker */
+ {
+ {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
+@@ -3545,6 +3544,7 @@ struct config_int64 ConfigureNamesInt64[] =
+ };
+
+
++
+ struct config_real ConfigureNamesReal[] =
+ {
+ {
+diff --git a/src/backend/utils/misc/help_config.c b/src/backend/utils/misc/help_config.c
+index 94c8a16ac1..6e2ce1e325 100644
+--- a/src/backend/utils/misc/help_config.c
++++ b/src/backend/utils/misc/help_config.c
+@@ -33,6 +33,7 @@ typedef union
+ struct config_bool _bool;
+ struct config_real real;
+ struct config_int integer;
++ struct config_int64 integer8;
+ struct config_string string;
+ struct config_enum _enum;
+ } mixedStruct;
+@@ -106,7 +107,12 @@ printMixedStruct(mixedStruct *structToPrint)
+ structToPrint->integer.min,
+ structToPrint->integer.max);
+ break;
+-
++ case PGC_INT64:
++ printf("INT64\t%lld\t%lld\t%lld\t",
++ (long long) structToPrint->integer8.reset_val,
++ (long long) structToPrint->integer8.min,
++ (long long) structToPrint->integer8.max);
++ break;
+ case PGC_REAL:
+ printf("REAL\t%g\t%g\t%g\t",
+ structToPrint->real.reset_val,
+diff --git a/src/backend/utils/misc/pg_controldata.c b/src/backend/utils/misc/pg_controldata.c
+index 7cbe700295..b0eb7cf0cf 100644
+--- a/src/backend/utils/misc/pg_controldata.c
++++ b/src/backend/utils/misc/pg_controldata.c
+@@ -118,7 +118,7 @@ pg_control_checkpoint(PG_FUNCTION_ARGS)
+ nulls[5] = false;
+
+ values[6] = CStringGetTextDatum(psprintf("%llu",
+- (unsigned long long) U64FromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
++ (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
+ nulls[6] = false;
+
+ values[7] = ObjectIdGetDatum(ControlFile->checkPointCopy.nextOid);
+diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
+index cf9f283cfe..f97bcdf264 100644
+--- a/src/backend/utils/misc/postgresql.conf.sample
++++ b/src/backend/utils/misc/postgresql.conf.sample
+@@ -653,7 +653,7 @@
+ #autovacuum_vacuum_insert_scale_factor = 0.2 # fraction of inserts over table
+ # size before insert vacuum
+ #autovacuum_analyze_scale_factor = 0.1 # fraction of table size before analyze
+-#autovacuum_freeze_max_age = 200000000 # maximum XID age before forced vacuum
++#autovacuum_freeze_max_age = 10000000000 # maximum XID age before forced vacuum
+ # (change requires restart)
+ #autovacuum_multixact_freeze_max_age = 400000000 # maximum multixact age
+ # before forced vacuum
+diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
+index 2cd508e513..97a607ab6c 100644
+--- a/src/backend/utils/sort/tuplesortvariants.c
++++ b/src/backend/utils/sort/tuplesortvariants.c
+@@ -1217,11 +1217,16 @@ writetup_cluster(Tuplesortstate *state, LogicalTape *tape, SortTuple *stup)
+ {
+ TuplesortPublic *base = TuplesortstateGetPublic(state);
+ HeapTuple tuple = (HeapTuple) stup->tuple;
+- unsigned int tuplen = tuple->t_len + sizeof(ItemPointerData) + sizeof(int);
++ unsigned int tuplen = tuple->t_len +
++ sizeof(ItemPointerData) +
++ 2 * sizeof(TransactionId) + /* tuple xmin, xmax */
++ sizeof(int);
+
+ /* We need to store t_self, but not other fields of HeapTupleData */
+ LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
+ LogicalTapeWrite(tape, &tuple->t_self, sizeof(ItemPointerData));
++ LogicalTapeWrite(tape, &tuple->t_xmin, sizeof(TransactionId));
++ LogicalTapeWrite(tape, &tuple->t_xmax, sizeof(TransactionId));
+ LogicalTapeWrite(tape, tuple->t_data, tuple->t_len);
+ if (base->sortopt & TUPLESORT_RANDOMACCESS) /* need trailing length word? */
+ LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
+@@ -1233,7 +1238,10 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
+ {
+ TuplesortPublic *base = TuplesortstateGetPublic(state);
+ TuplesortClusterArg *arg = (TuplesortClusterArg *) base->arg;
+- unsigned int t_len = tuplen - sizeof(ItemPointerData) - sizeof(int);
++ unsigned int t_len = tuplen -
++ sizeof(ItemPointerData) -
++ 2 * sizeof(TransactionId) - /* tuple xmin, xmax */
++ sizeof(int);
+ HeapTuple tuple = (HeapTuple) tuplesort_readtup_alloc(state,
+ t_len + HEAPTUPLESIZE);
+
+@@ -1241,6 +1249,8 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
+ tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
+ tuple->t_len = t_len;
+ LogicalTapeReadExact(tape, &tuple->t_self, sizeof(ItemPointerData));
++ LogicalTapeReadExact(tape, &tuple->t_xmin, sizeof(TransactionId));
++ LogicalTapeReadExact(tape, &tuple->t_xmax, sizeof(TransactionId));
+ /* We don't currently bother to reconstruct t_tableOid */
+ tuple->t_tableOid = InvalidOid;
+ /* Read in the tuple body */
+diff --git a/src/backend/utils/time/combocid.c b/src/backend/utils/time/combocid.c
+index 0e94bc93f7..f760a78072 100644
+--- a/src/backend/utils/time/combocid.c
++++ b/src/backend/utils/time/combocid.c
+@@ -101,12 +101,13 @@ static CommandId GetRealCmax(CommandId combocid);
+ */
+
+ CommandId
+-HeapTupleHeaderGetCmin(HeapTupleHeader tup)
++HeapTupleGetCmin(HeapTuple tuple)
+ {
++ HeapTupleHeader tup = tuple->t_data;
+ CommandId cid = HeapTupleHeaderGetRawCommandId(tup);
+
+ Assert(!(tup->t_infomask & HEAP_MOVED));
+- Assert(TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tup)));
++ Assert(TransactionIdIsCurrentTransactionId(HeapTupleGetXmin(tuple)));
+
+ if (tup->t_infomask & HEAP_COMBOCID)
+ return GetRealCmin(cid);
+@@ -115,8 +116,9 @@ HeapTupleHeaderGetCmin(HeapTupleHeader tup)
+ }
+
+ CommandId
+-HeapTupleHeaderGetCmax(HeapTupleHeader tup)
++HeapTupleGetCmax(HeapTuple tuple)
+ {
++ HeapTupleHeader tup = tuple->t_data;
+ CommandId cid = HeapTupleHeaderGetRawCommandId(tup);
+
+ Assert(!(tup->t_infomask & HEAP_MOVED));
+@@ -128,7 +130,7 @@ HeapTupleHeaderGetCmax(HeapTupleHeader tup)
+ * things too much.
+ */
+ Assert(CritSectionCount > 0 ||
+- TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tup)));
++ TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(tuple)));
+
+ if (tup->t_infomask & HEAP_COMBOCID)
+ return GetRealCmax(cid);
+@@ -150,9 +152,7 @@ HeapTupleHeaderGetCmax(HeapTupleHeader tup)
+ * changes the tuple in shared buffers.
+ */
+ void
+-HeapTupleHeaderAdjustCmax(HeapTupleHeader tup,
+- CommandId *cmax,
+- bool *iscombo)
++HeapTupleAdjustCmax(HeapTuple tup, CommandId *cmax, bool *iscombo)
+ {
+ /*
+ * If we're marking a tuple deleted that was inserted by (any
+@@ -160,10 +160,10 @@ HeapTupleHeaderAdjustCmax(HeapTupleHeader tup,
+ * Test for HeapTupleHeaderXminCommitted() first, because it's cheaper
+ * than a TransactionIdIsCurrentTransactionId call.
+ */
+- if (!HeapTupleHeaderXminCommitted(tup) &&
+- TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tup)))
++ if (!HeapTupleHeaderXminCommitted(tup->t_data) &&
++ TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(tup)))
+ {
+- CommandId cmin = HeapTupleHeaderGetCmin(tup);
++ CommandId cmin = HeapTupleGetCmin(tup);
+
+ *cmax = GetComboCommandId(cmin, *cmax);
+ *iscombo = true;
+diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c
+index 6a4327f917..8091b24341 100644
+--- a/src/backend/utils/time/snapmgr.c
++++ b/src/backend/utils/time/snapmgr.c
+@@ -927,15 +927,15 @@ SnapshotResetXmin(void)
+
+ if (pairingheap_is_empty(&RegisteredSnapshots))
+ {
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&MyProc->xmin, InvalidTransactionId);
+ return;
+ }
+
+ minSnapshot = pairingheap_container(SnapshotData, ph_node,
+ pairingheap_first(&RegisteredSnapshots));
+
+- if (TransactionIdPrecedes(MyProc->xmin, minSnapshot->xmin))
+- MyProc->xmin = minSnapshot->xmin;
++ if (TransactionIdPrecedes(pg_atomic_read_u64(&MyProc->xmin), minSnapshot->xmin))
++ pg_atomic_write_u64(&MyProc->xmin, minSnapshot->xmin);
+ }
+
+ /*
+@@ -1088,7 +1088,7 @@ AtEOXact_Snapshot(bool isCommit, bool resetXmin)
+ if (resetXmin)
+ SnapshotResetXmin();
+
+- Assert(resetXmin || MyProc->xmin == 0);
++ Assert(resetXmin || pg_atomic_read_u64(&MyProc->xmin) == 0);
+ }
+
+
+@@ -1153,8 +1153,9 @@ ExportSnapshot(Snapshot snapshot)
+ * Generate file path for the snapshot. We start numbering of snapshots
+ * inside the transaction from 1.
+ */
+- snprintf(path, sizeof(path), SNAPSHOT_EXPORT_DIR "/%08X-%08X-%d",
+- MyProc->backendId, MyProc->lxid, list_length(exportedSnapshots) + 1);
++ snprintf(path, sizeof(path), SNAPSHOT_EXPORT_DIR "/%08X-%08X%08X-%d",
++ MyProc->backendId, (uint32) (MyProc->lxid >> 32),
++ (uint32) MyProc->lxid, list_length(exportedSnapshots) + 1);
+
+ /*
+ * Copy the snapshot into TopTransactionContext, add it to the
+@@ -1330,7 +1331,7 @@ parseXidFromText(const char *prefix, char **s, const char *filename)
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+ ptr += prefixlen;
+- if (sscanf(ptr, "%u", &val) != 1)
++ if (sscanf(ptr, "%" INT64_MODIFIER "u", &val) != 1)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+@@ -1355,7 +1356,7 @@ parseVxidFromText(const char *prefix, char **s, const char *filename,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+ ptr += prefixlen;
+- if (sscanf(ptr, "%d/%u", &vxid->backendId, &vxid->localTransactionId) != 2)
++ if (sscanf(ptr, "%d/%" INT64_MODIFIER "u", &vxid->backendId, &vxid->localTransactionId) != 2)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+@@ -1896,7 +1897,7 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
+ if (!snapshot->suboverflowed)
+ {
+ /* we have full data, so search subxip */
+- if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
++ if (pg_lfind64(xid, snapshot->subxip, snapshot->subxcnt))
+ return true;
+
+ /* not there, fall through to search xip[] */
+@@ -1918,7 +1919,7 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
+ return false;
+ }
+
+- if (pg_lfind32(xid, snapshot->xip, snapshot->xcnt))
++ if (pg_lfind64(xid, snapshot->xip, snapshot->xcnt))
+ return true;
+ }
+ else
+@@ -1952,7 +1953,7 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
+ * indeterminate xid. We don't know whether it's top level or subxact
+ * but it doesn't matter. If it's present, the xid is visible.
+ */
+- if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
++ if (pg_lfind64(xid, snapshot->subxip, snapshot->subxcnt))
+ return true;
+ }
+
+diff --git a/src/bin/pg_amcheck/t/004_verify_heapam.pl b/src/bin/pg_amcheck/t/004_verify_heapam.pl
+index add07f7fca..a6ad931c45 100644
+--- a/src/bin/pg_amcheck/t/004_verify_heapam.pl
++++ b/src/bin/pg_amcheck/t/004_verify_heapam.pl
+@@ -8,6 +8,7 @@ use PostgreSQL::Test::Cluster;
+ use PostgreSQL::Test::Utils;
+
+ use Test::More;
++use Data::Dumper;
+
+ # This regression test demonstrates that the pg_amcheck binary correctly
+ # identifies specific kinds of corruption within pages. To test this, we need
+@@ -85,6 +86,65 @@ use Test::More;
+
+ use constant HEAPTUPLE_PACK_CODE => 'LLLSSSSSCCLLCCCCCCCCCCllLL';
+ use constant HEAPTUPLE_PACK_LENGTH => 58; # Total size
++use constant HEAPPAGE_SPECIAL_PACK_CODE => 'QQ';
++use constant HEAPPAGE_SPECIAL_PACK_LENGTH => 16;
++use constant HEAPPAGE_SIZE => 8192;
++
++# Some #define constants from access/htup_details.h for use while corrupting.
++use constant HEAP_HASNULL => 0x0001;
++use constant HEAP_XMAX_LOCK_ONLY => 0x0080;
++use constant HEAP_XMIN_COMMITTED => 0x0100;
++use constant HEAP_XMIN_INVALID => 0x0200;
++use constant HEAP_XMAX_COMMITTED => 0x0400;
++use constant HEAP_XMAX_INVALID => 0x0800;
++use constant HEAP_NATTS_MASK => 0x07FF;
++use constant HEAP_XMAX_IS_MULTI => 0x1000;
++use constant HEAP_KEYS_UPDATED => 0x2000;
++use constant HEAP_HOT_UPDATED => 0x4000;
++use constant HEAP_ONLY_TUPLE => 0x8000;
++use constant HEAP_UPDATED => 0x2000;
++
++use constant FIRST_NORMAL_TRANSACTION_ID => 3;
++
++# Read page special data
++sub read_special_data
++{
++ my ($fh, $offset) = @_;
++ my ($buffer, %special);
++
++ $offset -= $offset % HEAPPAGE_SIZE;
++ $offset += HEAPPAGE_SIZE - HEAPPAGE_SPECIAL_PACK_LENGTH;
++
++ sysseek($fh, $offset, 0)
++ or BAIL_OUT("sysseek failed: $!");
++ defined(sysread($fh, $buffer, HEAPPAGE_SPECIAL_PACK_LENGTH))
++ or BAIL_OUT("sysread failed: $!");
++
++ @_ = unpack(HEAPPAGE_SPECIAL_PACK_CODE, $buffer);
++ %special = (
++ pd_xid_base => shift,
++ pd_multi_base => shift);
++ return \%special;
++}
++
++# Write page special data
++sub write_special_data
++{
++ my ($fh, $offset, $special) = @_;
++
++ $offset -= $offset % HEAPPAGE_SIZE;
++ $offset += HEAPPAGE_SIZE - HEAPPAGE_SPECIAL_PACK_LENGTH;
++
++ my $buffer = pack(
++ HEAPPAGE_SPECIAL_PACK_CODE,
++ $special->{pd_xid_base}, $special->{pd_multi_base});
++
++ sysseek($fh, $offset, 0)
++ or BAIL_OUT("sysseek failed: $!");
++ defined(syswrite($fh, $buffer, HEAPPAGE_SPECIAL_PACK_LENGTH))
++ or BAIL_OUT("syswrite failed: $!");
++ return;
++}
+
+ # Read a tuple of our table from a heap page.
+ #
+@@ -96,8 +156,9 @@ use constant HEAPTUPLE_PACK_LENGTH => 58; # Total size
+ #
+ sub read_tuple
+ {
+- my ($fh, $offset) = @_;
++ my ($fh, $offset, $raw) = @_;
+ my ($buffer, %tup);
++
+ sysseek($fh, $offset, 0)
+ or BAIL_OUT("sysseek failed: $!");
+ defined(sysread($fh, $buffer, HEAPTUPLE_PACK_LENGTH))
+@@ -133,6 +194,18 @@ sub read_tuple
+ c_va_toastrelid => shift);
+ # Stitch together the text for column 'b'
+ $tup{b} = join('', map { chr($tup{"b_body$_"}) } (1 .. 7));
++
++ if (!$raw)
++ {
++ my $special = read_special_data($fh, $offset);
++
++ $tup{t_xmin} += $special->{pd_xid_base};
++ my $is_multi = $tup{t_infomask} & HEAP_XMAX_IS_MULTI;
++ $tup{t_xmax} += !$is_multi ?
++ $special->{pd_xid_base} :
++ $special->{pd_multi_base};
++ }
++
+ return \%tup;
+ }
+
+@@ -148,7 +221,39 @@ sub read_tuple
+ #
+ sub write_tuple
+ {
+- my ($fh, $offset, $tup) = @_;
++ my ($fh, $offset, $tup, $raw) = @_;
++
++ if (!$raw)
++ {
++ my $special = read_special_data($fh, $offset);
++
++ if ($tup->{t_xmin} >= 3)
++ {
++ my $xmin = $tup->{t_xmin} - $special->{pd_xid_base};
++ die "tuple x_min $tup->{t_xmin} is too smal for pd_xid_base $special->{pd_xid_base}"
++ if $xmin < 3;
++ $tup->{t_xmin} = $xmin;
++ }
++
++ if ($tup->{t_xmax} >= 3)
++ {
++ if (($tup->{t_infomask} & HEAP_XMAX_IS_MULTI) == 0)
++ {
++ my $xmax = $tup->{t_xmax} - $special->{pd_xid_base};
++ die "tuple x_max $tup->{t_xmax} is too smal for pd_xid_base $special->{pd_xid_base}"
++ if $xmax < 3;
++ $tup->{t_xmax} = $xmax;
++ }
++ else
++ {
++ my $xmax = $tup->{t_xmax} - $special->{pd_multi_base};
++ die "tuple multi x_max $tup->{t_xmax} is too smal for pd_multi_base $special->{pd_multi_base}"
++ if $xmax < 3;
++ $tup->{t_xmax} = $xmax;
++ }
++ }
++ }
++
+ my $buffer = pack(
+ HEAPTUPLE_PACK_CODE,
+ $tup->{t_xmin}, $tup->{t_xmax},
+@@ -171,6 +276,42 @@ sub write_tuple
+ return;
+ }
+
++# move pd_xid_base and pd_multi_base to more suitable position for tests.
++sub fixup_page
++{
++ my ($fh, $page, $xid_base, $multi_base, $lp_off) = @_;
++ my $offset = $page * HEAPPAGE_SIZE;
++ my $special = read_special_data($fh, $offset);
++
++ die "xid_base $xid_base should be lesser than existed $special->{pd_xid_base}"
++ if ($xid_base > $special->{pd_xid_base});
++ die "multi_base $multi_base should be lesser than existed $special->{pd_multi_base}"
++ if ($multi_base > $special->{pd_multi_base} && $special->{pd_multi_base} != 0);
++ return if ($xid_base == $special->{pd_xid_base} &&
++ $multi_base == $special->{pd_multi_base});
++
++ my $xid_delta = $special->{pd_xid_base} - $xid_base;
++ my $multi_delta = $special->{pd_multi_base} - $multi_base;
++
++ for my $off (@$lp_off)
++ {
++ # change only tuples on this page.
++ next if ($off < $offset && $off > $offset + HEAPPAGE_SIZE);
++ next if ($off == -1);
++
++ my $tup = read_tuple($fh, $off, 1);
++ $tup->{t_xmin} += $xid_delta;
++ my $is_multi = $tup->{t_infomask} & HEAP_XMAX_IS_MULTI;
++ $tup->{t_xmax} += !$is_multi ? $xid_delta : $multi_delta;
++ write_tuple($fh, $off, $tup, 1);
++ }
++
++ $special->{pd_xid_base} = $xid_base;
++ $special->{pd_multi_base} = $multi_base;
++
++ write_special_data($fh, $offset, $special);
++}
++
+ # Set umask so test directories and files are created with default permissions
+ umask(0077);
+
+@@ -320,6 +461,8 @@ my $relfrozenxid = $node->safe_psql('postgres',
+ q(select relfrozenxid from pg_class where relname = 'test'));
+ my $datfrozenxid = $node->safe_psql('postgres',
+ q(select datfrozenxid from pg_database where datname = 'postgres'));
++my $datminmxid = $node->safe_psql('postgres',
++ q(select datminmxid from pg_database where datname = 'postgres'));
+
+ # Sanity check that our 'test' table has a relfrozenxid newer than the
+ # datfrozenxid for the database, and that the datfrozenxid is greater than the
+@@ -377,6 +520,11 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ # Determine endianness of current platform from the 1-byte varlena header
+ $ENDIANNESS = $tup->{b_header} == 0x11 ? "little" : "big";
+ }
++
++# Set 64bit xid bases a bit in the past therefore we can set xmin/xmax a bit
++# in the past
++fixup_page($file, 0, $datfrozenxid - 100, $datminmxid, \@lp_off);
++
+ close($file)
+ or BAIL_OUT("close failed: $!");
+ $node->start;
+@@ -394,20 +542,6 @@ $node->command_ok([ 'pg_amcheck', '-p', $port, 'postgres' ],
+
+ $node->stop;
+
+-# Some #define constants from access/htup_details.h for use while corrupting.
+-use constant HEAP_HASNULL => 0x0001;
+-use constant HEAP_XMAX_LOCK_ONLY => 0x0080;
+-use constant HEAP_XMIN_COMMITTED => 0x0100;
+-use constant HEAP_XMIN_INVALID => 0x0200;
+-use constant HEAP_XMAX_COMMITTED => 0x0400;
+-use constant HEAP_XMAX_INVALID => 0x0800;
+-use constant HEAP_NATTS_MASK => 0x07FF;
+-use constant HEAP_XMAX_IS_MULTI => 0x1000;
+-use constant HEAP_KEYS_UPDATED => 0x2000;
+-use constant HEAP_HOT_UPDATED => 0x4000;
+-use constant HEAP_ONLY_TUPLE => 0x8000;
+-use constant HEAP_UPDATED => 0x2000;
+-
+ # Helper function to generate a regular expression matching the header we
+ # expect verify_heapam() to return given which fields we expect to be non-null.
+ sub header
+@@ -442,6 +576,8 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+
+ # Read tuple, if there is one.
+ my $tup = $offset == -1 ? undef : read_tuple($file, $offset);
++ # Read page special, if there is one.
++ my $special = $offset == -1 ? undef : read_special_data($file, $offset);
+
+ if ($offnum == 1)
+ {
+@@ -458,7 +594,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ elsif ($offnum == 2)
+ {
+ # Corruptly set xmin < datfrozenxid
+- my $xmin = 3;
++ my $xmin = $datfrozenxid - 12;
+ $tup->{t_xmin} = $xmin;
+ $tup->{t_infomask} &= ~HEAP_XMIN_COMMITTED;
+ $tup->{t_infomask} &= ~HEAP_XMIN_INVALID;
+@@ -468,25 +604,24 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ }
+ elsif ($offnum == 3)
+ {
+- # Corruptly set xmin < datfrozenxid, further back, noting circularity
+- # of xid comparison.
+- my $xmin = 4026531839;
++ # Corruptly set xmin > next transaction id.
++ my $xmin = $relfrozenxid + 4026531839;
+ $tup->{t_xmin} = $xmin;
+ $tup->{t_infomask} &= ~HEAP_XMIN_COMMITTED;
+ $tup->{t_infomask} &= ~HEAP_XMIN_INVALID;
+
+ push @expected,
+- qr/${$header}xmin ${xmin} precedes oldest valid transaction ID \d+/;
++ qr/${$header}xmin ${xmin} equals or exceeds next valid transaction ID \d+/;
+ }
+ elsif ($offnum == 4)
+ {
+- # Corruptly set xmax < relminmxid;
+- my $xmax = 4026531839;
++ # Corruptly set xmax > relminmxid;
++ my $xmax = $relfrozenxid + 4026531839;
+ $tup->{t_xmax} = $xmax;
+ $tup->{t_infomask} &= ~HEAP_XMAX_INVALID;
+
+ push @expected,
+- qr/${$header}xmax ${xmax} precedes oldest valid transaction ID \d+/;
++ qr/${$header}xmax ${xmax} equals or exceeds next valid transaction ID \d+/;
+ }
+ elsif ($offnum == 5)
+ {
+@@ -602,7 +737,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ $tup->{t_xmax} = 4000000000;
+
+ push @expected,
+- qr/${header}multitransaction ID 4000000000 precedes relation minimum multitransaction ID threshold 1/;
++ qr/${header}multitransaction ID 4000000000 equals or exceeds next valid multitransaction ID 1/;
+ }
+ elsif ($offnum == 16) # Last offnum must equal ROWCOUNT
+ {
+diff --git a/src/bin/pg_controldata/pg_controldata.c b/src/bin/pg_controldata/pg_controldata.c
+index 76837bc72c..6178b6f345 100644
+--- a/src/bin/pg_controldata/pg_controldata.c
++++ b/src/bin/pg_controldata/pg_controldata.c
+@@ -247,7 +247,7 @@ main(int argc, char *argv[])
+ printf(_("Latest checkpoint's full_page_writes: %s\n"),
+ ControlFile->checkPointCopy.fullPageWrites ? _("on") : _("off"));
+ printf(_("Latest checkpoint's NextXID: %llu\n"),
+- (unsigned long long) U64FromFullTransactionId(ControlFile->checkPointCopy.nextXid));
++ (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid));
+ printf(_("Latest checkpoint's NextOID: %u\n"),
+ ControlFile->checkPointCopy.nextOid);
+ printf(_("Latest checkpoint's NextMultiXactId: %llu\n"),
+diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
+index e2273ff873..41f7cb16ab 100644
+--- a/src/bin/pg_dump/pg_dump.c
++++ b/src/bin/pg_dump/pg_dump.c
+@@ -41,6 +41,7 @@
+ #include "access/attnum.h"
+ #include "access/sysattr.h"
+ #include "access/transam.h"
++#include "c.h"
+ #include "catalog/pg_aggregate_d.h"
+ #include "catalog/pg_am_d.h"
+ #include "catalog/pg_attribute_d.h"
+@@ -2985,7 +2986,7 @@ dumpDatabase(Archive *fout)
+ *datistemplate,
+ *datconnlimit,
+ *tablespace;
+- uint32 frozenxid,
++ uint64 frozenxid,
+ minmxid;
+ char *qdatname;
+
+@@ -3055,8 +3056,8 @@ dumpDatabase(Archive *fout)
+ icurules = PQgetvalue(res, 0, i_daticurules);
+ else
+ icurules = NULL;
+- frozenxid = atooid(PQgetvalue(res, 0, i_frozenxid));
+- minmxid = atooid(PQgetvalue(res, 0, i_minmxid));
++ frozenxid = strtou64(PQgetvalue(res, 0, i_frozenxid), NULL, 0);
++ minmxid = strtou64(PQgetvalue(res, 0, i_minmxid), NULL, 0);
+ dbdacl.acl = PQgetvalue(res, 0, i_datacl);
+ dbdacl.acldefault = PQgetvalue(res, 0, i_acldefault);
+ datistemplate = PQgetvalue(res, 0, i_datistemplate);
+@@ -3352,10 +3353,16 @@ dumpDatabase(Archive *fout)
+ RelFileNumber relfilenumber;
+
+ appendPQExpBuffer(loHorizonQry, "UPDATE pg_catalog.pg_class\n"
+- "SET relfrozenxid = '%u', relminmxid = '%u'\n"
++ "SET relfrozenxid = '%llu', relminmxid = '%llu'\n"
+ "WHERE oid = %u;\n",
+- atooid(PQgetvalue(lo_res, i, ii_relfrozenxid)),
+- atooid(PQgetvalue(lo_res, i, ii_relminmxid)),
++ (unsigned long long) strtou64(PQgetvalue(lo_res,
++ i,
++ ii_relfrozenxid),
++ NULL, 0),
++ (unsigned long long) strtou64(PQgetvalue(lo_res,
++ i,
++ ii_relminmxid),
++ NULL, 0),
+ atooid(PQgetvalue(lo_res, i, ii_oid)));
+
+ oid = atooid(PQgetvalue(lo_res, i, ii_oid));
+@@ -6665,11 +6672,11 @@ getTables(Archive *fout, int *numTables)
+ tblinfo[i].relreplident = *(PQgetvalue(res, i, i_relreplident));
+ tblinfo[i].rowsec = (strcmp(PQgetvalue(res, i, i_relrowsec), "t") == 0);
+ tblinfo[i].forcerowsec = (strcmp(PQgetvalue(res, i, i_relforcerowsec), "t") == 0);
+- tblinfo[i].frozenxid = atooid(PQgetvalue(res, i, i_relfrozenxid));
+- tblinfo[i].toast_frozenxid = atooid(PQgetvalue(res, i, i_toastfrozenxid));
++ tblinfo[i].frozenxid = strtou64(PQgetvalue(res, i, i_relfrozenxid), NULL, 0);
++ tblinfo[i].toast_frozenxid = strtou64(PQgetvalue(res, i, i_toastfrozenxid), NULL, 0);
+ tblinfo[i].toast_oid = atooid(PQgetvalue(res, i, i_toastoid));
+- tblinfo[i].minmxid = atooid(PQgetvalue(res, i, i_relminmxid));
+- tblinfo[i].toast_minmxid = atooid(PQgetvalue(res, i, i_toastminmxid));
++ tblinfo[i].minmxid = strtou64(PQgetvalue(res, i, i_relminmxid), NULL, 0);
++ tblinfo[i].toast_minmxid = strtou64(PQgetvalue(res, i, i_toastminmxid), NULL, 0);
+ tblinfo[i].reloptions = pg_strdup(PQgetvalue(res, i, i_reloptions));
+ if (PQgetisnull(res, i, i_checkoption))
+ tblinfo[i].checkoption = NULL;
+diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
+index 2fe3cbed9a..8a5d2eb1fa 100644
+--- a/src/bin/pg_dump/pg_dump.h
++++ b/src/bin/pg_dump/pg_dump.h
+@@ -299,11 +299,11 @@ typedef struct _tableInfo
+ bool rowsec; /* is row security enabled? */
+ bool forcerowsec; /* is row security forced? */
+ bool hasoids; /* does it have OIDs? */
+- uint32 frozenxid; /* table's relfrozenxid */
+- uint32 minmxid; /* table's relminmxid */
++ uint64 frozenxid; /* table's relfrozenxid */
++ uint64 minmxid; /* table's relminmxid */
+ Oid toast_oid; /* toast table's OID, or 0 if none */
+- uint32 toast_frozenxid; /* toast table's relfrozenxid, if any */
+- uint32 toast_minmxid; /* toast table's relminmxid */
++ uint64 toast_frozenxid; /* toast table's relfrozenxid, if any */
++ uint64 toast_minmxid; /* toast table's relminmxid */
+ int ncheck; /* # of CHECK expressions */
+ Oid reltype; /* OID of table's composite type, if any */
+ Oid reloftype; /* underlying type for typed table */
+diff --git a/src/bin/pg_resetwal/pg_resetwal.c b/src/bin/pg_resetwal/pg_resetwal.c
+index 6f0af6471e..1603977542 100644
+--- a/src/bin/pg_resetwal/pg_resetwal.c
++++ b/src/bin/pg_resetwal/pg_resetwal.c
+@@ -63,7 +63,6 @@ static ControlFileData ControlFile; /* pg_control values */
+ static XLogSegNo newXlogSegNo; /* new XLOG segment # */
+ static bool guessed = false; /* T if we had to guess at any values */
+ static const char *progname;
+-static uint32 set_xid_epoch = (uint32) -1;
+ static TransactionId set_oldest_xid = 0;
+ static TransactionId set_xid = 0;
+ static TransactionId set_oldest_commit_ts_xid = 0;
+@@ -95,7 +94,6 @@ main(int argc, char *argv[])
+ static struct option long_options[] = {
+ {"commit-timestamp-ids", required_argument, NULL, 'c'},
+ {"pgdata", required_argument, NULL, 'D'},
+- {"epoch", required_argument, NULL, 'e'},
+ {"force", no_argument, NULL, 'f'},
+ {"next-wal-file", required_argument, NULL, 'l'},
+ {"multixact-ids", required_argument, NULL, 'm'},
+@@ -137,7 +135,7 @@ main(int argc, char *argv[])
+ }
+
+
+- while ((c = getopt_long(argc, argv, "c:D:e:fl:m:no:O:u:x:", long_options, NULL)) != -1)
++ while ((c = getopt_long(argc, argv, "c:D:fl:m:no:O:u:x:", long_options, NULL)) != -1)
+ {
+ switch (c)
+ {
+@@ -153,24 +151,9 @@ main(int argc, char *argv[])
+ noupdate = true;
+ break;
+
+- case 'e':
+- errno = 0;
+- set_xid_epoch = strtoul(optarg, &endptr, 0);
+- if (endptr == optarg || *endptr != '\0' || errno != 0)
+- {
+- /*------
+- translator: the second %s is a command line argument (-e, etc) */
+- pg_log_error("invalid argument for option %s", "-e");
+- pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+- exit(1);
+- }
+- if (set_xid_epoch == -1)
+- pg_fatal("transaction ID epoch (-e) must not be -1");
+- break;
+-
+ case 'u':
+ errno = 0;
+- set_oldest_xid = strtoul(optarg, &endptr, 0);
++ set_oldest_xid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-u");
+@@ -184,7 +167,7 @@ main(int argc, char *argv[])
+
+ case 'x':
+ errno = 0;
+- set_xid = strtoul(optarg, &endptr, 0);
++ set_xid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-x");
+@@ -198,14 +181,14 @@ main(int argc, char *argv[])
+
+ case 'c':
+ errno = 0;
+- set_oldest_commit_ts_xid = strtoul(optarg, &endptr, 0);
++ set_oldest_commit_ts_xid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != ',' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-c");
+ pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+ exit(1);
+ }
+- set_newest_commit_ts_xid = strtoul(endptr + 1, &endptr2, 0);
++ set_newest_commit_ts_xid = strtou64(endptr + 1, &endptr2, 0);
+ if (endptr2 == endptr + 1 || *endptr2 != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-c");
+@@ -241,7 +224,7 @@ main(int argc, char *argv[])
+
+ case 'm':
+ errno = 0;
+- set_mxid = strtoul(optarg, &endptr, 0);
++ set_mxid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != ',' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-m");
+@@ -249,7 +232,7 @@ main(int argc, char *argv[])
+ exit(1);
+ }
+
+- set_oldestmxid = strtoul(endptr + 1, &endptr2, 0);
++ set_oldestmxid = strtou64(endptr + 1, &endptr2, 0);
+ if (endptr2 == endptr + 1 || *endptr2 != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-m");
+@@ -269,7 +252,7 @@ main(int argc, char *argv[])
+
+ case 'O':
+ errno = 0;
+- set_mxoff = strtoul(optarg, &endptr, 0);
++ set_mxoff = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-O");
+@@ -415,11 +398,6 @@ main(int argc, char *argv[])
+ * Adjust fields if required by switches. (Do this now so that printout,
+ * if any, includes these values.)
+ */
+- if (set_xid_epoch != -1)
+- ControlFile.checkPointCopy.nextXid =
+- FullTransactionIdFromEpochAndXid(set_xid_epoch,
+- XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+-
+ if (set_oldest_xid != 0)
+ {
+ ControlFile.checkPointCopy.oldestXid = set_oldest_xid;
+@@ -427,9 +405,7 @@ main(int argc, char *argv[])
+ }
+
+ if (set_xid != 0)
+- ControlFile.checkPointCopy.nextXid =
+- FullTransactionIdFromEpochAndXid(EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid),
+- set_xid);
++ ControlFile.checkPointCopy.nextXid = FullTransactionIdFromXid(set_xid);
+
+ if (set_oldest_commit_ts_xid != 0)
+ ControlFile.checkPointCopy.oldestCommitTsXid = set_oldest_commit_ts_xid;
+@@ -664,7 +640,7 @@ GuessControlValues(void)
+ ControlFile.checkPointCopy.PrevTimeLineID = 1;
+ ControlFile.checkPointCopy.fullPageWrites = false;
+ ControlFile.checkPointCopy.nextXid =
+- FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
++ FullTransactionIdFromXid(FirstNormalTransactionId);
+ ControlFile.checkPointCopy.nextOid = FirstGenbkiObjectId;
+ ControlFile.checkPointCopy.nextMulti = FirstMultiXactId;
+ ControlFile.checkPointCopy.nextMultiOffset = 0;
+@@ -715,6 +691,8 @@ GuessControlValues(void)
+ *
+ * NB: this display should be just those fields that will not be
+ * reset by RewriteControlFile().
++ *
++ * Special macros help to make translatable strings.
+ */
+ static void
+ PrintControlValues(bool guessed)
+@@ -734,8 +712,7 @@ PrintControlValues(bool guessed)
+ ControlFile.checkPointCopy.ThisTimeLineID);
+ printf(_("Latest checkpoint's full_page_writes: %s\n"),
+ ControlFile.checkPointCopy.fullPageWrites ? _("on") : _("off"));
+- printf(_("Latest checkpoint's NextXID: %u:%llu\n"),
+- EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid),
++ printf(_("Latest checkpoint's NextXID: %llu\n"),
+ (unsigned long long) XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+ printf(_("Latest checkpoint's NextOID: %u\n"),
+ ControlFile.checkPointCopy.nextOid);
+@@ -833,12 +810,6 @@ PrintNewControlValues(void)
+ ControlFile.checkPointCopy.oldestXidDB);
+ }
+
+- if (set_xid_epoch != -1)
+- {
+- printf(_("NextXID epoch: %u\n"),
+- EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+- }
+-
+ if (set_oldest_commit_ts_xid != 0)
+ {
+ printf(_("oldestCommitTsXid: %llu\n"),
+diff --git a/src/bin/pg_resetwal/t/001_basic.pl b/src/bin/pg_resetwal/t/001_basic.pl
+index 18d0882cb1..471503c6b3 100644
+--- a/src/bin/pg_resetwal/t/001_basic.pl
++++ b/src/bin/pg_resetwal/t/001_basic.pl
+@@ -95,15 +95,6 @@ command_fails_like(
+ [ 'pg_resetwal', '-c', '10,1', $node->data_dir ],
+ qr/greater than/,
+ 'fails with -c value 1 part 2');
+-# -e
+-command_fails_like(
+- [ 'pg_resetwal', '-e', 'foo', $node->data_dir ],
+- qr/error: invalid argument for option -e/,
+- 'fails with incorrect -e option');
+-command_fails_like(
+- [ 'pg_resetwal', '-e', '-1', $node->data_dir ],
+- qr/must not be -1/,
+- 'fails with -e value -1');
+ # -l
+ command_fails_like(
+ [ 'pg_resetwal', '-l', 'foo', $node->data_dir ],
+@@ -181,7 +172,6 @@ my $blcksz = $1;
+ my @cmd = ('pg_resetwal', '-D', $node->data_dir);
+
+ # some not-so-critical hardcoded values
+-push @cmd, '-e', 1;
+ push @cmd, '-l', '00000001000000320000004B';
+ push @cmd, '-o', 100_000;
+ push @cmd, '--wal-segsize', 1;
+@@ -205,8 +195,10 @@ push @cmd,
+ '-c',
+ sprintf("%d,%d", hex($files[0]) == 0 ? 3 : hex($files[0]), hex($files[-1]));
+
++my $A = 2;
++my $B = 1;
+ @files = get_slru_files('pg_multixact/offsets');
+-$mult = 32 * $blcksz / 4;
++$mult = $A * $blcksz / $B;
+ # -m argument is "new,old"
+ push @cmd, '-m',
+ sprintf("%d,%d",
+@@ -214,11 +206,11 @@ push @cmd, '-m',
+ hex($files[0]) == 0 ? 1 : hex($files[0] * $mult));
+
+ @files = get_slru_files('pg_multixact/members');
+-$mult = 32 * int($blcksz / 20) * 4;
++$mult = $A * int($blcksz / 20) * $B;
+ push @cmd, '-O', (hex($files[-1]) + 1) * $mult;
+
+ @files = get_slru_files('pg_xact');
+-$mult = 32 * $blcksz * 4;
++$mult = $A * $blcksz * $B;
+ push @cmd,
+ '-u', (hex($files[0]) == 0 ? 3 : hex($files[0]) * $mult),
+ '-x', ((hex($files[-1]) + 1) * $mult);
+diff --git a/src/bin/pg_upgrade/Makefile b/src/bin/pg_upgrade/Makefile
+index bde91e2beb..6de46f8c2d 100644
+--- a/src/bin/pg_upgrade/Makefile
++++ b/src/bin/pg_upgrade/Makefile
+@@ -23,6 +23,7 @@ OBJS = \
+ parallel.o \
+ pg_upgrade.o \
+ relfilenumber.o \
++ segresize.o \
+ server.o \
+ tablespace.o \
+ util.o \
+diff --git a/src/bin/pg_upgrade/check.c b/src/bin/pg_upgrade/check.c
+index fa52aa2c22..3d34681699 100644
+--- a/src/bin/pg_upgrade/check.c
++++ b/src/bin/pg_upgrade/check.c
+@@ -35,6 +35,8 @@ static void check_for_new_tablespace_dir(void);
+ static void check_for_user_defined_encoding_conversions(ClusterInfo *cluster);
+ static void check_new_cluster_logical_replication_slots(void);
+ static void check_old_cluster_for_valid_slots(bool live_check);
++static void check_for_32bit_xid_usage(ClusterInfo *cluster);
++static bool is_xid_wraparound(ClusterInfo *cluster);
+
+
+ /*
+@@ -84,7 +86,7 @@ output_check_banner(bool live_check)
+
+
+ void
+-check_and_dump_old_cluster(bool live_check)
++check_and_dump_old_cluster(bool live_check, bool *is_wraparound)
+ {
+ /* -- OLD -- */
+
+@@ -197,6 +199,17 @@ check_and_dump_old_cluster(bool live_check)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 903)
+ old_9_3_check_for_line_data_type_usage(&old_cluster);
+
++ /* Prepare for 64bit xid */
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER)
++ {
++ /* Check if 32-bit xid type is used in tables */
++ check_for_32bit_xid_usage(&old_cluster);
++ /* Check indexes to be upgraded */
++ invalidate_spgist_indexes(&old_cluster, true);
++ invalidate_gin_indexes(&old_cluster, true);
++ invalidate_external_indexes(&old_cluster, true);
++ }
++
+ /*
+ * While not a check option, we do this now because this is the only time
+ * the old server is running.
+@@ -204,6 +217,8 @@ check_and_dump_old_cluster(bool live_check)
+ if (!user_opts.check)
+ generate_old_dump();
+
++ *is_wraparound = is_xid_wraparound(&old_cluster);
++
+ if (!live_check)
+ stop_postmaster(false);
+ }
+@@ -274,6 +289,17 @@ issue_warnings_and_set_wal_level(void)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 906)
+ old_9_6_invalidate_hash_indexes(&new_cluster, false);
+
++ /* Raindex for 64bit xid */
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER)
++ {
++ /* Check if 32-bit xid type is used in tables */
++ check_for_32bit_xid_usage(&old_cluster);
++ /* Check indexes to be upgraded */
++ invalidate_spgist_indexes(&old_cluster, true);
++ invalidate_gin_indexes(&old_cluster, true);
++ invalidate_external_indexes(&old_cluster, true);
++ }
++
+ report_extension_updates(&new_cluster);
+
+ stop_postmaster(false);
+@@ -1613,3 +1639,124 @@ check_old_cluster_for_valid_slots(bool live_check)
+
+ check_ok();
+ }
++
++/*
++ * check_for_32bit_xid_usage()
++ *
++ * Postgres Pro Enterprise changes xid storage format to 64-bit. Check if
++ * xid type is used in tables.
++ */
++static void
++check_for_32bit_xid_usage(ClusterInfo *cluster)
++{
++ int dbnum;
++ FILE *script = NULL;
++ bool found = false;
++ char output_path[MAXPGPATH];
++
++ prep_status("Checking for incompatible \"xid\" data type");
++
++ snprintf(output_path, sizeof(output_path), "tables_using_xid.txt");
++
++ for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
++ {
++ PGresult *res;
++ bool db_used = false;
++ int ntups;
++ int rowno;
++ int i_nspname,
++ i_relname,
++ i_attname;
++ DbInfo *active_db = &cluster->dbarr.dbs[dbnum];
++ PGconn *conn = connectToServer(cluster, active_db->db_name);
++
++ /*
++ * While several relkinds don't store any data, e.g. views, they can
++ * be used to define data types of other columns, so we check all
++ * relkinds.
++ */
++ res = executeQueryOrDie(conn,
++ "SELECT n.nspname, c.relname, a.attname "
++ "FROM pg_catalog.pg_class c, "
++ " pg_catalog.pg_namespace n, "
++ " pg_catalog.pg_attribute a "
++ "WHERE c.oid = a.attrelid AND "
++ " a.attnum >= 1 AND "
++ " a.atttypid = 'pg_catalog.xid'::pg_catalog.regtype AND "
++ " c.relnamespace = n.oid AND "
++ /* exclude possible orphaned temp tables */
++ " n.nspname !~ '^pg_temp_' AND "
++ " n.nspname NOT IN ('pg_catalog', 'information_schema')");
++
++ ntups = PQntuples(res);
++ i_nspname = PQfnumber(res, "nspname");
++ i_relname = PQfnumber(res, "relname");
++ i_attname = PQfnumber(res, "attname");
++ for (rowno = 0; rowno < ntups; rowno++)
++ {
++ found = true;
++ if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
++ pg_fatal("could not open file \"%s\": %s\n",
++ output_path, strerror(errno));
++ if (!db_used)
++ {
++ fprintf(script, "Database: %s\n", active_db->db_name);
++ db_used = true;
++ }
++ fprintf(script, " %s.%s.%s\n",
++ PQgetvalue(res, rowno, i_nspname),
++ PQgetvalue(res, rowno, i_relname),
++ PQgetvalue(res, rowno, i_attname));
++ }
++
++ PQclear(res);
++
++ PQfinish(conn);
++ }
++
++ if (script)
++ fclose(script);
++
++ if (found)
++ {
++ pg_log(PG_REPORT, "fatal");
++ pg_fatal("Your installation contains the \"xid\" data type in user tables.\n"
++ "The internal format of \"xid\" changed in Postgres Pro Enterprise so this cluster\n"
++ "cannot currently be upgraded. Note that even dropped attributes cause a problem.\n"
++ "You can remove the problem tables and restart the upgrade.\n"
++ "A list of the problem columns is in the file:\n"
++ " %s", output_path);
++ }
++ else
++ check_ok();
++}
++
++/*
++ * is_xid_wraparound()
++ *
++ * Return true if 32-xid cluster had wraparound.
++ */
++static bool
++is_xid_wraparound(ClusterInfo *cluster)
++{
++ PGconn *conn;
++ PGresult *res;
++ bool is_wraparound;
++
++ conn = connectToServer(cluster, "template1");
++
++ /*
++ * txid_current is extended with an "epoch" counter, so to check
++ * wraparound in old 32-xid cluster we cut epoch by casting to int4.
++ */
++ res = executeQueryOrDie(conn,
++ "SELECT 1 "
++ "FROM pg_catalog.pg_database, txid_current() tx "
++ "WHERE (tx %% 4294967295)::bigint <= datfrozenxid::text::bigint "
++ "LIMIT 1");
++ is_wraparound = PQntuples(res) ? true : false;
++ PQclear(res);
++ PQfinish(conn);
++
++ return is_wraparound;
++}
+diff --git a/src/bin/pg_upgrade/controldata.c b/src/bin/pg_upgrade/controldata.c
+index 8ef6204137..eb6b8a1027 100644
+--- a/src/bin/pg_upgrade/controldata.c
++++ b/src/bin/pg_upgrade/controldata.c
+@@ -288,6 +288,8 @@ get_control_data(ClusterInfo *cluster, bool live_check)
+ xid.value = strtou64(p, NULL, 10);
+
+ /*
++ * Try to read 32-bit XID format 'epoch:xid'.
++ *
+ * Delimiter changed from '/' to ':' in 9.6. We don't test for
+ * the catalog version of the change because the catalog version
+ * is pulled from pg_controldata too, and it isn't worth adding an
+@@ -303,8 +305,7 @@ get_control_data(ClusterInfo *cluster, bool live_check)
+ if (p == NULL)
+ {
+ /* FullTransactionId representation */
+- cluster->controldata.chkpnt_nxtxid = XidFromFullTransactionId(xid);
+- cluster->controldata.chkpnt_nxtepoch = EpochFromFullTransactionId(xid);
++ cluster->controldata.chkpnt_nxtxid = xid.value;
+ }
+ else
+ {
+@@ -313,8 +314,8 @@ get_control_data(ClusterInfo *cluster, bool live_check)
+
+ /* Epoch:Xid representation */
+ p++; /* remove '/' or ':' char */
+- cluster->controldata.chkpnt_nxtxid = str2uint(p);
+- cluster->controldata.chkpnt_nxtepoch = (TransactionId) XidFromFullTransactionId(xid);
++ cluster->controldata.chkpnt_nxtxid = (XidFromFullTransactionId(xid)) << 32 |
++ (TransactionId) str2uint(p);
+ }
+
+ got_xid = true;
+@@ -338,7 +339,7 @@ get_control_data(ClusterInfo *cluster, bool live_check)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_nxtmulti = str2uint(p);
++ cluster->controldata.chkpnt_nxtmulti = strtou64(p, NULL, 10);
+ got_multi = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's oldestXID:")) != NULL)
+@@ -349,7 +350,7 @@ get_control_data(ClusterInfo *cluster, bool live_check)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_oldstxid = str2uint(p);
++ cluster->controldata.chkpnt_oldstxid = strtou64(p, NULL, 10);
+ got_oldestxid = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's oldestMultiXid:")) != NULL)
+@@ -360,7 +361,7 @@ get_control_data(ClusterInfo *cluster, bool live_check)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_oldstMulti = str2uint(p);
++ cluster->controldata.chkpnt_oldstMulti = strtou64(p, NULL, 10);
+ got_oldestmulti = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's NextMultiOffset:")) != NULL)
+@@ -371,7 +372,7 @@ get_control_data(ClusterInfo *cluster, bool live_check)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_nxtmxoff = str2uint(p);
++ cluster->controldata.chkpnt_nxtmxoff = strtou64(p, NULL, 10);
+ got_mxoff = true;
+ }
+ else if ((p = strstr(bufin, "First log segment after reset:")) != NULL)
+diff --git a/src/bin/pg_upgrade/file.c b/src/bin/pg_upgrade/file.c
+index d173602882..ae00f4674f 100644
+--- a/src/bin/pg_upgrade/file.c
++++ b/src/bin/pg_upgrade/file.c
+@@ -174,7 +174,8 @@ linkFile(const char *src, const char *dst,
+ */
+ void
+ rewriteVisibilityMap(const char *fromfile, const char *tofile,
+- const char *schemaName, const char *relName)
++ const char *schemaName, const char *relName,
++ bool update_version)
+ {
+ int src_fd;
+ int dst_fd;
+@@ -290,6 +291,11 @@ rewriteVisibilityMap(const char *fromfile, const char *tofile,
+ if (old_lastpart && empty)
+ break;
+
++ if (update_version)
++ PageSetPageSizeAndVersion((Page) new_vmbuf.data,
++ PageGetPageSize((Page) new_vmbuf.data),
++ PG_PAGE_LAYOUT_VERSION);
++
+ /* Set new checksum for visibility map page, if enabled */
+ if (new_cluster.controldata.data_checksum_version != 0)
+ ((PageHeader) new_vmbuf.data)->pd_checksum =
+@@ -316,6 +322,97 @@ rewriteVisibilityMap(const char *fromfile, const char *tofile,
+ close(src_fd);
+ }
+
++/*
++ * updateSegmentVersion()
++ *
++ * Transform a segment file, copying from src to dst.
++ * schemaName/relName are relation's SQL name (used for error messages only).
++ *
++ * Read segment pages one by one and set version to PG_PAGE_LAYOUT_VERSION.
++ *
++ * Although FSM and MV formats does not change while switch to 64-bit XIDs, we
++ * must upgrade pages version in order to avoid lazy conversion on first read.
++ */
++void
++updateSegmentPagesVersion(const char *fromfile, const char *tofile,
++ const char *schemaName, const char *relName)
++{
++ int src_fd;
++ int dst_fd;
++ struct stat statbuf;
++ ssize_t src_filesize;
++ ssize_t totalBytesRead;
++ ssize_t bytesRead;
++ BlockNumber blkno;
++ PGAlignedBlock buf;
++
++ if ((src_fd = open(fromfile, O_RDONLY | PG_BINARY, 0)) < 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not open file \"%s\": %s",
++ schemaName, relName, fromfile, strerror(errno));
++
++ if (fstat(src_fd, &statbuf) != 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not stat file \"%s\": %s",
++ schemaName, relName, fromfile, strerror(errno));
++
++ if ((dst_fd = open(tofile, O_RDWR | O_CREAT | O_EXCL | PG_BINARY,
++ pg_file_create_mode)) < 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not create file \"%s\": %s",
++ schemaName, relName, tofile, strerror(errno));
++
++ /* Save old file size */
++ src_filesize = statbuf.st_size;
++ totalBytesRead = 0;
++ blkno = 0;
++
++ while (totalBytesRead < src_filesize)
++ {
++ errno = 0;
++ if ((bytesRead = read(src_fd, buf.data, BLCKSZ)) != BLCKSZ)
++ {
++ if (bytesRead < 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not read file \"%s\": %s",
++ schemaName, relName, fromfile, strerror(errno));
++ else
++ pg_fatal("error while copying relation \"%s.%s\": partial page found in file \"%s\"",
++ schemaName, relName, fromfile);
++ }
++
++ totalBytesRead += BLCKSZ;
++ PageSetPageSizeAndVersion((Page) buf.data,
++ PageGetPageSize((Page) buf.data),
++ PG_PAGE_LAYOUT_VERSION);
++
++ /* Set new checksum for page, if enabled */
++ if (new_cluster.controldata.data_checksum_version != 0)
++ ((PageHeader) buf.data)->pd_checksum =
++ pg_checksum_page(buf.data, blkno);
++
++ /*
++ * We dealing here only with FSM and VM pages.
++ */
++ if (((PageHeader) buf.data)->pd_lower != SizeOfPageHeaderData ||
++ ((PageHeader) buf.data)->pd_upper != BLCKSZ)
++ pg_fatal("error while copying relation \"%s.%s\": unknown page format found in file \"%s\"",
++ schemaName, relName, fromfile);
++
++ errno = 0;
++ if (write(dst_fd, buf.data, BLCKSZ) != BLCKSZ)
++ {
++ /* if write didn't set errno, assume problem is no disk space */
++ if (errno == 0)
++ errno = ENOSPC;
++ pg_fatal("error while copying relation \"%s.%s\": could not write file \"%s\": %s",
++ schemaName, relName, tofile, strerror(errno));
++ }
++
++ blkno++;
++ }
++
++ /* Clean up */
++ close(dst_fd);
++ close(src_fd);
++}
++
+ void
+ check_file_clone(void)
+ {
+diff --git a/src/bin/pg_upgrade/meson.build b/src/bin/pg_upgrade/meson.build
+index 3e8a08e062..12243fd4f3 100644
+--- a/src/bin/pg_upgrade/meson.build
++++ b/src/bin/pg_upgrade/meson.build
+@@ -12,6 +12,7 @@ pg_upgrade_sources = files(
+ 'parallel.c',
+ 'pg_upgrade.c',
+ 'relfilenumber.c',
++ 'segresize.c',
+ 'server.c',
+ 'tablespace.c',
+ 'util.c',
+diff --git a/src/bin/pg_upgrade/pg_upgrade.c b/src/bin/pg_upgrade/pg_upgrade.c
+index c4ab30c773..f36e769f0a 100644
+--- a/src/bin/pg_upgrade/pg_upgrade.c
++++ b/src/bin/pg_upgrade/pg_upgrade.c
+@@ -44,6 +44,9 @@
+ #include <langinfo.h>
+ #endif
+
++#include "access/multixact.h"
++#include "access/transam.h"
++#include "access/xlog_internal.h"
+ #include "catalog/pg_class_d.h"
+ #include "common/file_perm.h"
+ #include "common/logging.h"
+@@ -54,7 +57,7 @@
+ static void set_locale_and_encoding(void);
+ static void prepare_new_cluster(void);
+ static void prepare_new_globals(void);
+-static void create_new_objects(void);
++static void create_new_objects(bool is_wraparound);
+ static void copy_xact_xlog_xid(void);
+ static void set_frozenxids(bool minmxid_only);
+ static void make_outputdirs(char *pgdata);
+@@ -82,6 +85,7 @@ main(int argc, char **argv)
+ {
+ char *deletion_script_file_name = NULL;
+ bool live_check = false;
++ bool is_wraparound = false;
+
+ /*
+ * pg_upgrade doesn't currently use common/logging.c, but initialize it
+@@ -127,7 +131,7 @@ main(int argc, char **argv)
+
+ check_cluster_compatibility(live_check);
+
+- check_and_dump_old_cluster(live_check);
++ check_and_dump_old_cluster(live_check, &is_wraparound);
+
+
+ /* -- NEW -- */
+@@ -160,7 +164,7 @@ main(int argc, char **argv)
+
+ prepare_new_globals();
+
+- create_new_objects();
++ create_new_objects(is_wraparound);
+
+ stop_postmaster(false);
+
+@@ -510,7 +514,7 @@ prepare_new_globals(void)
+
+
+ static void
+-create_new_objects(void)
++create_new_objects(bool is_wraparound)
+ {
+ int dbnum;
+
+@@ -602,11 +606,23 @@ create_new_objects(void)
+ check_ok();
+
+ /*
+- * We don't have minmxids for databases or relations in pre-9.3 clusters,
+- * so set those after we have restored the schema.
++ * Refix datfrozenxid and datminmxid
+ */
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 902)
+ set_frozenxids(true);
++ else if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ {
++ /*
++ * During upgrade from 32-bit to 64-bit xids save relfrozenxids if
++ * there was no wraparound in old cluster. Otherwise, reset them to
++ * FirstNormalTransactionId value.
++ */
++ if (is_wraparound)
++ set_frozenxids(false);
++ else
++ set_frozenxids(true);
++ }
+
+ /* update new_cluster info now that we have objects in the databases */
+ get_db_rel_and_slot_infos(&new_cluster, false);
+@@ -660,14 +676,37 @@ copy_subdir_files(const char *old_subdir, const char *new_subdir)
+ static void
+ copy_xact_xlog_xid(void)
+ {
+- /*
+- * Copy old commit logs to new data dir. pg_clog has been renamed to
+- * pg_xact in post-10 clusters.
+- */
+- copy_subdir_files(GET_MAJOR_VERSION(old_cluster.major_version) <= 906 ?
+- "pg_clog" : "pg_xact",
+- GET_MAJOR_VERSION(new_cluster.major_version) <= 906 ?
+- "pg_clog" : "pg_xact");
++ TransactionId next_xid;
++
++#define GetClogDirName(cluster) \
++ GET_MAJOR_VERSION(cluster.major_version) <= 906 ? "pg_clog" : "pg_xact"
++
++ /* Set next xid to 2^32 if we're upgrading from 32 bit postgres */
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ next_xid = ((TransactionId) 1 << 32);
++ else
++ next_xid = old_cluster.controldata.chkpnt_nxtxid;
++
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ {
++ /* Convert commit logs and copy to the new data dir */
++ prep_status("Transforming commit log segments");
++ convert_xact(psprintf("%s/%s", old_cluster.pgdata, GetClogDirName(old_cluster)),
++ psprintf("%s/%s", new_cluster.pgdata, GetClogDirName(new_cluster)));
++ check_ok();
++ }
++ else
++ {
++ /*
++ * Copy old commit logs to new data dir. pg_clog has been renamed to
++ * pg_xact in post-10 clusters.
++ */
++ prep_status("Copying commit log segments");
++ copy_subdir_files(GetClogDirName(old_cluster), GetClogDirName(new_cluster));
++ check_ok();
++ }
+
+ prep_status("Setting oldest XID for new cluster");
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+@@ -681,19 +720,20 @@ copy_xact_xlog_xid(void)
+ prep_status("Setting next transaction ID and epoch for new cluster");
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -x %llu \"%s\"",
+- new_cluster.bindir,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
++ new_cluster.bindir, (unsigned long long) next_xid,
+ new_cluster.pgdata);
++#ifdef NOT_USED
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -e %u \"%s\"",
+ new_cluster.bindir, old_cluster.controldata.chkpnt_nxtepoch,
+ new_cluster.pgdata);
++#endif
+ /* must reset commit timestamp limits also */
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -c %llu,%llu \"%s\"",
+ new_cluster.bindir,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
++ (unsigned long long) next_xid,
++ (unsigned long long) next_xid,
+ new_cluster.pgdata);
+ check_ok();
+
+@@ -706,8 +746,48 @@ copy_xact_xlog_xid(void)
+ if (old_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER &&
+ new_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER)
+ {
+- copy_subdir_files("pg_multixact/offsets", "pg_multixact/offsets");
+- copy_subdir_files("pg_multixact/members", "pg_multixact/members");
++ uint64 oldest_mxid = old_cluster.controldata.chkpnt_oldstMulti;
++ uint64 next_mxid = old_cluster.controldata.chkpnt_nxtmulti;
++ uint64 next_mxoff = old_cluster.controldata.chkpnt_nxtmxoff;
++
++ if (old_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ {
++ copy_subdir_files("pg_multixact/offsets", "pg_multixact/offsets");
++ copy_subdir_files("pg_multixact/members", "pg_multixact/members");
++ }
++ else
++ {
++ MultiXactOffset oldest_mxoff;
++
++ remove_new_subdir("pg_multixact/offsets", false);
++ oldest_mxoff = convert_multixact_offsets("pg_multixact/offsets", "pg_multixact/offsets");
++
++ remove_new_subdir("pg_multixact/members", false);
++ convert_multixact_members("pg_multixact/members", "pg_multixact/members", oldest_mxoff);
++
++ /*
++ * Handle wraparound if we're upgrading from 32 bit postgres.
++ * Invalid 0 mxids/offsets are skipped, so 1 becomes 2^32.
++ */
++ if (oldest_mxoff)
++ {
++ if (next_mxid < oldest_mxid)
++ next_mxid += ((MultiXactId) 1 << 32) - FirstMultiXactId;
++
++ if (next_mxoff < oldest_mxoff)
++ next_mxoff += ((MultiXactOffset) 1 << 32) - 1;
++
++ /* Offsets and members were rewritten, oldest_mxoff = 1 */
++ next_mxoff -= oldest_mxoff - 1;
++ oldest_mxoff = 1;
++
++ /*
++ * Save converted next_mxid for possible usage in
++ * set_frozenxids()
++ */
++ old_cluster.controldata.chkpnt_nxtmulti = next_mxid;
++ }
++ }
+
+ prep_status("Setting next multixact ID and offset for new cluster");
+
+@@ -718,9 +798,9 @@ copy_xact_xlog_xid(void)
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -O %llu -m %llu,%llu \"%s\"",
+ new_cluster.bindir,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmxoff,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti,
+- (unsigned long long) old_cluster.controldata.chkpnt_oldstMulti,
++ (unsigned long long) next_mxoff,
++ (unsigned long long) next_mxid,
++ (unsigned long long) oldest_mxid,
+ new_cluster.pgdata);
+ check_ok();
+ }
+@@ -794,6 +874,8 @@ set_frozenxids(bool minmxid_only)
+ int ntups;
+ int i_datname;
+ int i_datallowconn;
++ TransactionId frozen_xid;
++ MultiXactId minmxid;
+
+ if (!minmxid_only)
+ prep_status("Setting frozenxid and minmxid counters in new cluster");
+@@ -802,18 +884,26 @@ set_frozenxids(bool minmxid_only)
+
+ conn_template1 = connectToServer(&new_cluster, "template1");
+
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ frozen_xid = FirstNormalTransactionId;
++ else
++ frozen_xid = old_cluster.controldata.chkpnt_nxtxid;
++
++ minmxid = old_cluster.controldata.chkpnt_nxtmulti;
++
+ if (!minmxid_only)
+ /* set pg_database.datfrozenxid */
+ PQclear(executeQueryOrDie(conn_template1,
+ "UPDATE pg_catalog.pg_database "
+ "SET datfrozenxid = '%llu'",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid));
++ (unsigned long long) frozen_xid));
+
+ /* set pg_database.datminmxid */
+ PQclear(executeQueryOrDie(conn_template1,
+ "UPDATE pg_catalog.pg_database "
+ "SET datminmxid = '%llu'",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti));
++ (unsigned long long) minmxid));
+
+ /* get database names */
+ dbres = executeQueryOrDie(conn_template1,
+@@ -853,7 +943,7 @@ set_frozenxids(bool minmxid_only)
+ CppAsString2(RELKIND_RELATION) ", "
+ CppAsString2(RELKIND_MATVIEW) ", "
+ CppAsString2(RELKIND_TOASTVALUE) ")",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid));
++ (unsigned long long) frozen_xid));
+
+ /* set pg_class.relminmxid */
+ PQclear(executeQueryOrDie(conn,
+@@ -864,7 +954,7 @@ set_frozenxids(bool minmxid_only)
+ CppAsString2(RELKIND_RELATION) ", "
+ CppAsString2(RELKIND_MATVIEW) ", "
+ CppAsString2(RELKIND_TOASTVALUE) ")",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti));
++ (unsigned long long) minmxid));
+ PQfinish(conn);
+
+ /* Reset datallowconn flag */
+diff --git a/src/bin/pg_upgrade/pg_upgrade.h b/src/bin/pg_upgrade/pg_upgrade.h
+index a710f325de..ad09f67710 100644
+--- a/src/bin/pg_upgrade/pg_upgrade.h
++++ b/src/bin/pg_upgrade/pg_upgrade.h
+@@ -115,6 +115,11 @@ extern char *output_files[];
+ */
+ #define MULTIXACT_FORMATCHANGE_CAT_VER 201301231
+
++/*
++ * xid format changed from 32-bit to 64-bit.
++ */
++#define XID_FORMATCHANGE_CAT_VER 999999999
++
+ /*
+ * large object chunk size added to pg_controldata,
+ * commit 5f93c37805e7485488480916b4585e098d3cc883
+@@ -225,13 +230,13 @@ typedef struct
+ uint32 ctrl_ver;
+ uint32 cat_ver;
+ char nextxlogfile[25];
+- uint32 chkpnt_nxtxid;
+- uint32 chkpnt_nxtepoch;
++ uint64 chkpnt_nxtxid;
++ uint32 chkpnt_nxtepoch; /* for 32bit xids only */
+ uint32 chkpnt_nxtoid;
+- uint32 chkpnt_nxtmulti;
+- uint32 chkpnt_nxtmxoff;
+- uint32 chkpnt_oldstMulti;
+- uint32 chkpnt_oldstxid;
++ uint64 chkpnt_nxtmulti;
++ uint64 chkpnt_nxtmxoff;
++ uint64 chkpnt_oldstMulti;
++ uint64 chkpnt_oldstxid;
+ uint32 align;
+ uint32 blocksz;
+ uint32 largesz;
+@@ -361,7 +366,7 @@ extern OSInfo os_info;
+ /* check.c */
+
+ void output_check_banner(bool live_check);
+-void check_and_dump_old_cluster(bool live_check);
++void check_and_dump_old_cluster(bool live_check, bool *is_wraparound);
+ void check_new_cluster(void);
+ void report_clusters_compatible(void);
+ void issue_warnings_and_set_wal_level(void);
+@@ -402,7 +407,10 @@ void copyFile(const char *src, const char *dst,
+ void linkFile(const char *src, const char *dst,
+ const char *schemaName, const char *relName);
+ void rewriteVisibilityMap(const char *fromfile, const char *tofile,
+- const char *schemaName, const char *relName);
++ const char *schemaName, const char *relName,
++ bool update_version);
++void updateSegmentPagesVersion(const char *fromfile, const char *tofile,
++ const char *schemaName, const char *relName);
+ void check_file_clone(void);
+ void check_hard_link(void);
+
+@@ -485,6 +493,10 @@ void old_9_6_invalidate_hash_indexes(ClusterInfo *cluster,
+ void old_11_check_for_sql_identifier_data_type_usage(ClusterInfo *cluster);
+ void report_extension_updates(ClusterInfo *cluster);
+
++void invalidate_spgist_indexes(ClusterInfo *cluster, bool check_mode);
++void invalidate_gin_indexes(ClusterInfo *cluster, bool check_mode);
++void invalidate_external_indexes(ClusterInfo *cluster, bool check_mode);
++
+ /* parallel.c */
+ void parallel_exec_prog(const char *log_file, const char *opt_log_file,
+ const char *fmt,...) pg_attribute_printf(3, 4);
+@@ -492,3 +504,9 @@ void parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr
+ char *old_pgdata, char *new_pgdata,
+ char *old_tablespace);
+ bool reap_child(bool wait_for_child);
++
++/* segresize.c */
++void convert_xact(const char *olddir, const char *newdir);
++MultiXactOffset convert_multixact_offsets(const char *olddir, const char *newdir);
++void convert_multixact_members(const char *olddir, const char *newdir,
++ MultiXactOffset oldest_mxoff);
+diff --git a/src/bin/pg_upgrade/relfilenumber.c b/src/bin/pg_upgrade/relfilenumber.c
+index 34bc9c1504..a0e10047ed 100644
+--- a/src/bin/pg_upgrade/relfilenumber.c
++++ b/src/bin/pg_upgrade/relfilenumber.c
+@@ -16,7 +16,8 @@
+ #include "pg_upgrade.h"
+
+ static void transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace);
+-static void transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_frozenbit);
++static void transfer_relfile(FileNameMap *map, const char *type_suffix,
++ bool vm_must_add_frozenbit, bool update_version);
+
+
+ /*
+@@ -136,6 +137,7 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+ {
+ int mapnum;
+ bool vm_must_add_frozenbit = false;
++ bool update_version = false;
+
+ /*
+ * Do we need to rewrite visibilitymap?
+@@ -144,19 +146,28 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+ new_cluster.controldata.cat_ver >= VISIBILITY_MAP_FROZEN_BIT_CAT_VER)
+ vm_must_add_frozenbit = true;
+
++ /*
++ * Need to update FSM and VM pages version to avoid lazy conversion.
++ */
++ if (old_cluster.controldata.cat_ver < new_cluster.controldata.cat_ver)
++ update_version = true;
++
+ for (mapnum = 0; mapnum < size; mapnum++)
+ {
+ if (old_tablespace == NULL ||
+ strcmp(maps[mapnum].old_tablespace, old_tablespace) == 0)
+ {
+ /* transfer primary file */
+- transfer_relfile(&maps[mapnum], "", vm_must_add_frozenbit);
++ transfer_relfile(&maps[mapnum], "", vm_must_add_frozenbit,
++ update_version);
+
+ /*
+ * Copy/link any fsm and vm files, if they exist
+ */
+- transfer_relfile(&maps[mapnum], "_fsm", vm_must_add_frozenbit);
+- transfer_relfile(&maps[mapnum], "_vm", vm_must_add_frozenbit);
++ transfer_relfile(&maps[mapnum], "_fsm", vm_must_add_frozenbit,
++ update_version);
++ transfer_relfile(&maps[mapnum], "_vm", vm_must_add_frozenbit,
++ update_version);
+ }
+ }
+ }
+@@ -170,7 +181,8 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+ * mode.
+ */
+ static void
+-transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_frozenbit)
++transfer_relfile(FileNameMap *map, const char *type_suffix,
++ bool vm_must_add_frozenbit, bool update_version)
+ {
+ char old_file[MAXPGPATH];
+ char new_file[MAXPGPATH];
+@@ -235,7 +247,17 @@ transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_fro
+ /* Need to rewrite visibility map format */
+ pg_log(PG_VERBOSE, "rewriting \"%s\" to \"%s\"",
+ old_file, new_file);
+- rewriteVisibilityMap(old_file, new_file, map->nspname, map->relname);
++ rewriteVisibilityMap(old_file, new_file, map->nspname,
++ map->relname, update_version);
++ }
++ else if ((update_version && strcmp(type_suffix, "_vm") == 0) ||
++ (update_version && strcmp(type_suffix, "_fsm") == 0))
++ {
++ /* Need to update pages version */
++ pg_log(PG_VERBOSE, "rewriting \"%s\" to \"%s\"",
++ old_file, new_file);
++ updateSegmentPagesVersion(old_file, new_file, map->nspname,
++ map->relname);
+ }
+ else
+ switch (user_opts.transfer_mode)
+diff --git a/src/bin/pg_upgrade/segresize.c b/src/bin/pg_upgrade/segresize.c
+new file mode 100644
+index 0000000000..1b14637c81
+--- /dev/null
++++ b/src/bin/pg_upgrade/segresize.c
+@@ -0,0 +1,586 @@
++/*-------------------------------------------------------------------------
++ *
++ * segresize.c
++ * SLRU segment resize utility from 32bit to 64bit xid format
++ *
++ * Copyright (c) 2015-2022, Postgres Professional
++ *
++ * IDENTIFICATION
++ * src/bin/pg_upgrade/segresize.c
++ *
++ *-------------------------------------------------------------------------
++ */
++
++#include "postgres_fe.h"
++
++#include "pg_upgrade.h"
++#include "access/multixact.h"
++#include "access/transam.h"
++
++#define SLRU_PAGES_PER_SEGMENT_OLD 32
++#define SLRU_PAGES_PER_SEGMENT 32 /* Should be equal to value from slru.h */
++
++#define CLOG_BITS_PER_XACT 2
++#define CLOG_XACTS_PER_BYTE 4
++#define CLOG_XACTS_PER_PAGE (BLCKSZ * CLOG_XACTS_PER_BYTE)
++
++typedef uint32 MultiXactId32;
++typedef uint32 MultiXactOffset32;
++typedef uint32 TransactionId32;
++
++#define MaxTransactionId32 ((TransactionId32) 0xFFFFFFFF)
++#define MaxMultiXactId32 ((MultiXactId32) 0xFFFFFFFF)
++#define MaxMultiXactOffset32 ((MultiXactOffset32) 0xFFFFFFFF)
++
++#define MULTIXACT_OFFSETS_PER_PAGE_OLD (BLCKSZ / sizeof(MultiXactOffset32))
++#define MULTIXACT_OFFSETS_PER_PAGE (BLCKSZ / sizeof(MultiXactOffset))
++
++#define MXACT_MEMBER_FLAGS_PER_BYTE 1
++
++/* 64xid */
++#define MULTIXACT_FLAGBYTES_PER_GROUP 8
++#define MULTIXACT_MEMBERS_PER_MEMBERGROUP \
++ (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
++/* size in bytes of a complete group */
++#define MULTIXACT_MEMBERGROUP_SIZE \
++ (sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)
++#define MULTIXACT_MEMBERGROUPS_PER_PAGE (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)
++
++/* 32xid */
++#define MULTIXACT_FLAGBYTES_PER_GROUP_OLD 4
++#define MULTIXACT_MEMBERS_PER_MEMBERGROUP_OLD \
++ (MULTIXACT_FLAGBYTES_PER_GROUP_OLD * MXACT_MEMBER_FLAGS_PER_BYTE)
++/* size in bytes of a complete group */
++#define MULTIXACT_MEMBERGROUP_SIZE_OLD \
++ (sizeof(TransactionId32) * MULTIXACT_MEMBERS_PER_MEMBERGROUP_OLD + MULTIXACT_FLAGBYTES_PER_GROUP_OLD)
++#define MULTIXACT_MEMBERGROUPS_PER_PAGE_OLD (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE_OLD)
++#define MULTIXACT_MEMBERS_PER_PAGE_OLD \
++ (MULTIXACT_MEMBERGROUPS_PER_PAGE_OLD * MULTIXACT_MEMBERS_PER_MEMBERGROUP_OLD)
++
++typedef struct SLRUSegmentState
++{
++ const char *dir;
++ FILE *file;
++ int64 segno;
++ int64 pageno;
++ bool is_empty_segment;
++} SLRUSegmentState;
++
++static char *
++slru_filename_old(const char *path, int64 segno)
++{
++ Assert(segno <= PG_INT32_MAX);
++ return psprintf("%s/%04X", path, (int) segno);
++}
++
++static char *
++slru_filename_new(const char *path, int64 segno)
++{
++ return psprintf("%s/%012llX", path, (long long) segno);
++}
++
++static inline FILE *
++open_file(SLRUSegmentState *state,
++ char * (filename_fn)(const char *path, int64 segno),
++ char *mode, char *fatal_msg)
++{
++ char *filename = filename_fn(state->dir, state->segno);
++ FILE *fd = fopen(filename, mode);
++
++ if (!fd)
++ pg_fatal(fatal_msg, filename);
++
++ pfree(filename);
++
++ return fd;
++}
++
++static void
++close_file(SLRUSegmentState *state,
++ char * (filename_fn)(const char *path, int64 segno))
++{
++ if (state->file != NULL)
++ {
++ if (fclose(state->file) != 0)
++ pg_fatal("could not close file \"%s\": %m",
++ filename_fn(state->dir, state->segno));
++ state->file = NULL;
++ }
++}
++
++static inline int
++read_file(SLRUSegmentState *state, void *buf)
++{
++ size_t n = fread(buf, sizeof(char), BLCKSZ, state->file);
++
++ if (n != 0)
++ return n;
++
++ if (ferror(state->file))
++ pg_fatal("could not read file \"%s\": %m",
++ slru_filename_old(state->dir, state->segno));
++
++ if (!feof(state->file))
++ pg_fatal("unknown file read state \"%s\": %m",
++ slru_filename_old(state->dir, state->segno));
++
++ close_file(state, slru_filename_old);
++
++ return 0;
++}
++
++static int
++read_old_segment_page(SLRUSegmentState *state, void *buf, bool *is_empty)
++{
++ int n;
++
++ /* Open next segment file, if needed */
++ if (!state->file)
++ {
++ state->file = open_file(state, slru_filename_old, "rb",
++ "could not open source file \"%s\": %m");
++
++ /* Set position to the needed page */
++ if (fseek(state->file, state->pageno * BLCKSZ, SEEK_SET))
++ close_file(state, slru_filename_old);
++
++ /*
++ * Skip segment conversion if segment file doesn't exist.
++ * First segment file should exist in any case.
++ */
++ if (state->segno != 0)
++ state->is_empty_segment = true;
++ }
++
++ if (state->file)
++ {
++ /* Segment file does exist, read page from it */
++ state->is_empty_segment = false;
++
++ /* Try to read BLCKSZ bytes */
++ n = read_file(state, buf);
++ *is_empty = (n == 0);
++
++ /* Zeroing buf tail if needed */
++ if (n)
++ memset((char *) buf + n, 0, BLCKSZ - n);
++ }
++ else
++ {
++ n = state->is_empty_segment ?
++ BLCKSZ : /* Skip empty block at the end of segment */
++ 0; /* We reached the last segment */
++ *is_empty = true;
++
++ if (n)
++ memset((char *) buf, 0, BLCKSZ);
++ }
++
++ state->pageno++;
++
++ if (state->pageno >= SLRU_PAGES_PER_SEGMENT_OLD)
++ {
++ /* Start new segment */
++ state->segno++;
++ state->pageno = 0;
++ close_file(state, slru_filename_old);
++ }
++
++ return n;
++}
++
++static void
++write_new_segment_page(SLRUSegmentState *state, void *buf, bool is_empty)
++{
++ /*
++ * Create a new segment file if we still didn't. Creation is postponed
++ * until the first non-empty page is found. This helps not to create
++ * completely empty segments.
++ */
++ if (!state->file && !is_empty)
++ {
++ state->file = open_file(state, slru_filename_new, "wb",
++ "could not open target file \"%s\": %m");
++
++ /* Write zeroes to the previously skipped prefix */
++ if (state->pageno > 0)
++ {
++ char zerobuf[BLCKSZ] = {0};
++
++ for (int64 i = 0; i < state->pageno; i++)
++ {
++ if (fwrite(zerobuf, sizeof(char), BLCKSZ, state->file) != BLCKSZ)
++ pg_fatal("could not write file \"%s\": %m",
++ slru_filename_new(state->dir, state->segno));
++ }
++ }
++
++ }
++
++ /* Write page to the new segment (if it was created) */
++ if (state->file)
++ {
++ if (fwrite(buf, sizeof(char), BLCKSZ, state->file) != BLCKSZ)
++ pg_fatal("could not write file \"%s\": %m",
++ slru_filename_new(state->dir, state->segno));
++ }
++
++ state->pageno++;
++
++ /*
++ * Did we reach the maximum page number? Then close segment file and
++ * create a new one on the next iteration
++ */
++ if (state->pageno >= SLRU_PAGES_PER_SEGMENT)
++ {
++ state->segno++;
++ state->pageno = 0;
++ close_file(state, slru_filename_new);
++ }
++}
++
++/*
++ * Convert pg_xact segments.
++ */
++void
++convert_xact(const char *old_subdir, const char *new_subdir)
++{
++ SLRUSegmentState oldseg = {0};
++ SLRUSegmentState newseg = {0};
++ TransactionId oldest_xid = old_cluster.controldata.chkpnt_oldstxid;
++ TransactionId next_xid = old_cluster.controldata.chkpnt_nxtxid;
++ TransactionId xid;
++ int64 pageno;
++ char buf[BLCKSZ] = {0};
++
++ oldseg.dir = old_subdir;
++ newseg.dir = new_subdir;
++
++ pageno = oldest_xid / CLOG_XACTS_PER_PAGE;
++
++ oldseg.segno = pageno / SLRU_PAGES_PER_SEGMENT_OLD;
++ oldseg.pageno = pageno % SLRU_PAGES_PER_SEGMENT_OLD;
++
++ newseg.segno = pageno / SLRU_PAGES_PER_SEGMENT;
++ newseg.pageno = pageno % SLRU_PAGES_PER_SEGMENT;
++
++ if (next_xid < oldest_xid)
++ next_xid += (TransactionId) 1 << 32; /* wraparound */
++
++ /* Copy xid flags reading only needed segment pages */
++ for (xid = oldest_xid & ~(CLOG_XACTS_PER_PAGE - 1);
++ xid <= ((next_xid - 1) & ~(CLOG_XACTS_PER_PAGE - 1));
++ xid += CLOG_XACTS_PER_PAGE)
++ {
++ bool is_empty;
++
++ /* Handle possible segment wraparound */
++ if (oldseg.segno > MaxTransactionId32 / CLOG_XACTS_PER_PAGE / SLRU_PAGES_PER_SEGMENT_OLD)
++ {
++ pageno = (MaxTransactionId32 + 1) / CLOG_XACTS_PER_PAGE;
++
++ Assert(oldseg.segno == pageno / SLRU_PAGES_PER_SEGMENT_OLD);
++ Assert(!oldseg.pageno);
++ Assert(!oldseg.file);
++ oldseg.segno = 0;
++
++ Assert(newseg.segno == pageno / SLRU_PAGES_PER_SEGMENT);
++ Assert(!newseg.pageno);
++ Assert(!newseg.file);
++ newseg.segno = 0;
++ }
++
++ read_old_segment_page(&oldseg, buf, &is_empty);
++ write_new_segment_page(&newseg, buf, is_empty);
++ }
++
++ /* Release resources */
++ close_file(&oldseg, slru_filename_old);
++ close_file(&newseg, slru_filename_new);
++}
++
++static inline SLRUSegmentState
++create_slru_segment_state(MultiXactId mxid,
++ int offsets_per_page,
++ int pages_per_segment,
++ char *dir)
++{
++ SLRUSegmentState seg = {0};
++ int64 n;
++
++ n = mxid / offsets_per_page;
++ seg.pageno = n % pages_per_segment;
++ seg.segno = n / pages_per_segment;
++ seg.dir = dir;
++
++ return seg;
++}
++
++/*
++ * Convert pg_multixact/offsets segments and return oldest mxid offset.
++ */
++MultiXactOffset
++convert_multixact_offsets(const char *old_subdir, const char *new_subdir)
++{
++ SLRUSegmentState oldseg,
++ newseg;
++ MultiXactOffset32 oldbuf[MULTIXACT_OFFSETS_PER_PAGE_OLD] = {0};
++ MultiXactOffset newbuf[MULTIXACT_OFFSETS_PER_PAGE] = {0};
++ MultiXactOffset32 oldest_mxoff = 0;
++ MultiXactId oldest_mxid,
++ next_mxid,
++ mxid;
++ uint64 old_entry,
++ new_entry;
++ bool oldest_mxoff_known = false;
++
++ StaticAssertStmt((sizeof(oldbuf) == BLCKSZ && sizeof(newbuf) == BLCKSZ),
++ "buf should be BLCKSZ");
++
++ oldest_mxid = old_cluster.controldata.chkpnt_oldstMulti;
++
++ oldseg = create_slru_segment_state(oldest_mxid,
++ MULTIXACT_OFFSETS_PER_PAGE_OLD,
++ SLRU_PAGES_PER_SEGMENT_OLD,
++ psprintf("%s/%s", old_cluster.pgdata,
++ old_subdir));
++
++ newseg = create_slru_segment_state(oldest_mxid,
++ MULTIXACT_OFFSETS_PER_PAGE,
++ SLRU_PAGES_PER_SEGMENT,
++ psprintf("%s/%s", new_cluster.pgdata,
++ new_subdir));
++
++ old_entry = oldest_mxid % MULTIXACT_OFFSETS_PER_PAGE_OLD;
++ new_entry = oldest_mxid % MULTIXACT_OFFSETS_PER_PAGE;
++
++ next_mxid = old_cluster.controldata.chkpnt_nxtmulti;
++ if (next_mxid < oldest_mxid)
++ next_mxid += (MultiXactId) 1 << 32; /* wraparound */
++
++ prep_status("Converting old %s to new format", old_subdir);
++
++ /* Copy mxid offsets reading only needed segment pages */
++ for (mxid = oldest_mxid; mxid < next_mxid; old_entry = 0)
++ {
++ int oldlen;
++ bool is_empty;
++
++ /* Handle possible segment wraparound */
++ if (oldseg.segno > MaxMultiXactId32 / MULTIXACT_OFFSETS_PER_PAGE_OLD / SLRU_PAGES_PER_SEGMENT_OLD) /* 0xFFFF */
++ oldseg.segno = 0;
++
++ oldlen = read_old_segment_page(&oldseg, oldbuf, &is_empty);
++
++ if (oldlen == 0 || is_empty)
++ pg_fatal("cannot read page %lld from segment: %s\n",
++ (long long) oldseg.pageno,
++ slru_filename_old(oldseg.dir, oldseg.segno));
++
++ /* Save oldest mxid offset */
++ if (!oldest_mxoff_known)
++ {
++ oldest_mxoff = oldbuf[old_entry];
++ oldest_mxoff_known = true;
++ }
++
++ /* Skip wrapped-around invalid MultiXactIds */
++ if (mxid == (MultiXactId) 1 << 32)
++ {
++ Assert(oldseg.segno == 0);
++ Assert(oldseg.pageno == 1);
++ Assert(old_entry == 0);
++ mxid += FirstMultiXactId;
++ old_entry = FirstMultiXactId;
++ }
++
++ /* Copy entries to the new page */
++ for (; mxid < next_mxid && old_entry < MULTIXACT_OFFSETS_PER_PAGE_OLD;
++ mxid++, old_entry++)
++ {
++ MultiXactOffset mxoff = oldbuf[old_entry];
++
++ /* Handle possible offset wraparound (1 becomes 2^32) */
++ if (mxoff < oldest_mxoff)
++ mxoff += ((MultiXactOffset) 1 << 32) - 1;
++
++ /* Subtract oldest_mxoff, so new offsets will start from 1 */
++ newbuf[new_entry++] = mxoff - oldest_mxoff + 1;
++
++ if (new_entry >= MULTIXACT_OFFSETS_PER_PAGE)
++ {
++ /* Write new page */
++ write_new_segment_page(&newseg, newbuf, false);
++ new_entry = 0;
++ }
++ }
++ }
++
++ /* Write the last incomplete page */
++ if (new_entry > 0 || oldest_mxid == next_mxid)
++ {
++ memset(&newbuf[new_entry], 0,
++ sizeof(newbuf[0]) * (MULTIXACT_OFFSETS_PER_PAGE - new_entry));
++ write_new_segment_page(&newseg, newbuf, false);
++ }
++
++ /* Use next_mxoff as oldest_mxoff, if oldest_mxid == next_mxid */
++ if (!oldest_mxoff_known)
++ {
++ Assert(oldest_mxid == next_mxid);
++ oldest_mxoff = (MultiXactOffset) old_cluster.controldata.chkpnt_nxtmxoff;
++ }
++
++ /* Release resources */
++ close_file(&oldseg, slru_filename_old);
++ close_file(&newseg, slru_filename_new);
++
++ pfree((char *) oldseg.dir);
++ pfree((char *) newseg.dir);
++
++ check_ok();
++
++ return oldest_mxoff;
++}
++
++/*
++ * Convert pg_multixact/members segments, offsets will start from 1.
++ */
++void
++convert_multixact_members(const char *old_subdir, const char *new_subdir,
++ MultiXactOffset oldest_mxoff)
++{
++ MultiXactOffset next_mxoff,
++ mxoff;
++ SLRUSegmentState oldseg,
++ newseg;
++ char oldbuf[BLCKSZ] = {0},
++ newbuf[BLCKSZ] = {0};
++ int newgroup,
++ newmember;
++ char *newflag = newbuf;
++ TransactionId *newxid;
++ int oldidx,
++ newidx;
++
++ prep_status("Converting old %s to new format", old_subdir);
++
++ next_mxoff = (MultiXactOffset) old_cluster.controldata.chkpnt_nxtmxoff;
++ if (next_mxoff < oldest_mxoff)
++ next_mxoff += (MultiXactOffset) 1 << 32;
++
++ newxid = (TransactionId *) (newflag + MXACT_MEMBER_FLAGS_PER_BYTE * MULTIXACT_MEMBERS_PER_MEMBERGROUP);
++
++ /* Initialize old starting position */
++ oldidx = oldest_mxoff % MULTIXACT_MEMBERS_PER_PAGE_OLD;
++ oldseg = create_slru_segment_state(oldest_mxoff,
++ MULTIXACT_MEMBERS_PER_PAGE_OLD,
++ SLRU_PAGES_PER_SEGMENT_OLD,
++ psprintf("%s/%s", old_cluster.pgdata,
++ old_subdir));
++
++ /* Initialize empty new segment */
++ newseg = create_slru_segment_state(0, 1, 1,
++ psprintf("%s/%s", new_cluster.pgdata,
++ new_subdir));
++
++ /* Initialize new starting position (skip invalid zero offset) */
++ newgroup = 0;
++ newidx = 1;
++ newmember = 1;
++ newflag++;
++ newxid++;
++
++ /* Iterate through the original directory */
++ for (mxoff = oldest_mxoff; mxoff < next_mxoff; oldidx = 0)
++ {
++ bool old_is_empty;
++ int oldlen;
++ int ngroups;
++ int oldgroup;
++ int oldmember;
++
++ oldlen = read_old_segment_page(&oldseg, oldbuf, &old_is_empty);
++
++ if (oldlen == 0 || old_is_empty)
++ pg_fatal("cannot read page %lld from segment: %s\n",
++ (long long) oldseg.pageno,
++ slru_filename_old(oldseg.dir, oldseg.segno));
++
++ ngroups = oldlen / MULTIXACT_MEMBERGROUP_SIZE_OLD;
++
++ /* Iterate through old member groups */
++ for (oldgroup = oldidx / MULTIXACT_MEMBERS_PER_MEMBERGROUP_OLD,
++ oldmember = oldidx % MULTIXACT_MEMBERS_PER_MEMBERGROUP_OLD;
++ oldgroup < ngroups && mxoff < next_mxoff;
++ oldgroup++, oldmember = 0)
++ {
++ char *oldflag = (char *) oldbuf + oldgroup * MULTIXACT_MEMBERGROUP_SIZE_OLD;
++ TransactionId32 *oldxid = (TransactionId32 *) (oldflag + MULTIXACT_FLAGBYTES_PER_GROUP_OLD);
++
++ oldxid += oldmember;
++ oldflag += oldmember;
++
++ /* Iterate through old members */
++ for (int i = oldidx % MULTIXACT_MEMBERS_PER_MEMBERGROUP_OLD;
++ i < MULTIXACT_MEMBERS_PER_MEMBERGROUP_OLD && mxoff < next_mxoff;
++ i++)
++ {
++ /* Copy member's xid and flags to the new page */
++ *newflag++ = *oldflag++;
++ *newxid++ = (TransactionId) * oldxid++;
++
++ newidx++;
++ oldidx++;
++ mxoff++;
++
++ if (++newmember >= MULTIXACT_MEMBERS_PER_MEMBERGROUP)
++ {
++ /* Start next member group */
++ newmember = 0;
++
++ if (++newgroup >= MULTIXACT_MEMBERGROUPS_PER_PAGE)
++ {
++ /* Write current page and start new */
++ newgroup = 0;
++ newidx = 0;
++ write_new_segment_page(&newseg, newbuf, false);
++ memset(newbuf, 0, BLCKSZ);
++ }
++
++ newflag = (char *) newbuf + newgroup * MULTIXACT_MEMBERGROUP_SIZE;
++ newxid = (TransactionId *) (newflag + MXACT_MEMBER_FLAGS_PER_BYTE * MULTIXACT_MEMBERS_PER_MEMBERGROUP);
++ }
++
++ /* Handle offset wraparound */
++ if (mxoff > MaxMultiXactOffset32)
++ {
++ Assert(mxoff == (MultiXactOffset) 1 << 32);
++ Assert(oldseg.segno == MaxMultiXactOffset32 / MULTIXACT_MEMBERS_PER_PAGE_OLD / SLRU_PAGES_PER_SEGMENT_OLD);
++ Assert(oldseg.pageno == MaxMultiXactOffset32 / MULTIXACT_MEMBERS_PER_PAGE_OLD % SLRU_PAGES_PER_SEGMENT_OLD);
++ Assert(oldmember == MaxMultiXactOffset32 % MULTIXACT_MEMBERS_PER_PAGE_OLD);
++
++ /* Switch to segment 0000 */
++ close_file(&oldseg, slru_filename_old);
++ oldseg.segno = 0;
++ oldseg.pageno = 0;
++
++ oldidx = 1; /* skip invalid zero mxid offset */
++ }
++ }
++ }
++ }
++
++ /* Write last page, unless it is empty */
++ if (newflag > (char *) newbuf || oldest_mxoff == next_mxoff)
++ write_new_segment_page(&newseg, newbuf, false);
++
++ /* Release resources */
++ close_file(&oldseg, slru_filename_old);
++ close_file(&newseg, slru_filename_new);
++
++ pfree((char *) oldseg.dir);
++ pfree((char *) newseg.dir);
++
++ check_ok();
++}
+diff --git a/src/bin/pg_upgrade/t/002_pg_upgrade.pl b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
+index 997963082b..7a64c6d302 100644
+--- a/src/bin/pg_upgrade/t/002_pg_upgrade.pl
++++ b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
+@@ -260,6 +260,14 @@ if (defined($ENV{oldinstall}))
+ }
+ }
+
++$oldnode->safe_psql('regression',
++ "CREATE TABLE t1 (id SERIAL NOT NULL PRIMARY KEY, plt text, pln NUMERIC(8, 4));
++ INSERT INTO t1 (plt, pln) SELECT md5(random()::text), random() * 9999 FROM generate_series(1, 1000);");
++my $relfrozenxid = $oldnode->safe_psql('regression',
++ "SELECT relfrozenxid FROM pg_class WHERE relname = 't1';");
++my $relminmxid = $oldnode->safe_psql('regression',
++ "SELECT relminmxid FROM pg_class WHERE relname = 't1';");
++
+ # Take a dump before performing the upgrade as a base comparison. Note
+ # that we need to use pg_dumpall from the new node here.
+ my @dump_command = (
+@@ -399,6 +407,16 @@ ok( !-d $newnode->data_dir . "/pg_upgrade_output.d",
+
+ $newnode->start;
+
++my $relfrozenxid_new = $newnode->safe_psql('regression',
++ "SELECT relfrozenxid FROM pg_class WHERE relname = 't1';");
++
++is($relfrozenxid_new, $relfrozenxid, 'old and new relfrozenxid match after pg_upgrade');
++
++my $relminmxid_new = $newnode->safe_psql('regression',
++ "SELECT relminmxid FROM pg_class WHERE relname = 't1';");
++
++is($relminmxid_new, $relminmxid, 'old and new relminmxid match after pg_upgrade');
++
+ # Check if there are any logs coming from pg_upgrade, that would only be
+ # retained on failure.
+ my $log_path = $newnode->data_dir . "/pg_upgrade_output.d";
+diff --git a/src/bin/pg_upgrade/version.c b/src/bin/pg_upgrade/version.c
+index 403a6d7cfa..2bf9d5dac4 100644
+--- a/src/bin/pg_upgrade/version.c
++++ b/src/bin/pg_upgrade/version.c
+@@ -9,6 +9,7 @@
+
+ #include "postgres_fe.h"
+
++#include "access/transam.h"
+ #include "catalog/pg_class_d.h"
+ #include "fe_utils/string_utils.h"
+ #include "pg_upgrade.h"
+@@ -242,19 +243,21 @@ old_9_6_check_for_unknown_data_type_usage(ClusterInfo *cluster)
+ }
+
+ /*
+- * old_9_6_invalidate_hash_indexes()
+- * 9.6 -> 10
+- * Hash index binary format has changed from 9.6->10.0
++ * invalidate_indexes()
++ * Invalidates all indexes satisfying given predicate.
+ */
+-void
+-old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
++static void
++invalidate_indexes(ClusterInfo *cluster, bool check_mode,
++ const char *name, const char *pred)
+ {
+ int dbnum;
+ FILE *script = NULL;
+ bool found = false;
+- char *output_path = "reindex_hash.sql";
++ char output_path[MAXPGPATH];
++
++ snprintf(output_path, sizeof(output_path), "reindex_%s.sql", name);
+
+- prep_status("Checking for hash indexes");
++ prep_status("Checking for %s indexes", name);
+
+ for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
+ {
+@@ -267,9 +270,16 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ DbInfo *active_db = &cluster->dbarr.dbs[dbnum];
+ PGconn *conn = connectToServer(cluster, active_db->db_name);
+
+- /* find hash indexes */
+- res = executeQueryOrDie(conn,
+- "SELECT n.nspname, c.relname "
++
++ /*
++ * Find indexes satisfying predicate.
++ *
++ * System indexes (with oids < FirstNormalObjectId) are excluded from
++ * the search as they are recreated in the new cluster during initdb.
++ */
++ res = executeQueryOrDie(
++ conn,
++ "SELECT n.nspname, c.relname, i.indexrelid "
+ "FROM pg_catalog.pg_class c, "
+ " pg_catalog.pg_index i, "
+ " pg_catalog.pg_am a, "
+@@ -277,8 +287,11 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ "WHERE i.indexrelid = c.oid AND "
+ " c.relam = a.oid AND "
+ " c.relnamespace = n.oid AND "
+- " a.amname = 'hash'"
+- );
++ " i.indexrelid >= '%u'::pg_catalog.oid AND "
++ " %s "
++ "ORDER BY i.indexrelid ASC",
++ FirstNormalObjectId,
++ pred);
+
+ ntups = PQntuples(res);
+ i_nspname = PQfnumber(res, "nspname");
+@@ -311,8 +324,14 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+
+ if (!check_mode && db_used)
+ {
+- /* mark hash indexes as invalid */
+- PQclear(executeQueryOrDie(conn,
++ /*
++ * Mark indexes satisfying predicate as invalid.
++ *
++ * System indexes (with oids < FirstNormalObjectId) are excluded
++ * from the search (see above).
++ */
++ PQclear(executeQueryOrDie(
++ conn,
+ "UPDATE pg_catalog.pg_index i "
+ "SET indisvalid = false "
+ "FROM pg_catalog.pg_class c, "
+@@ -321,7 +340,10 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ "WHERE i.indexrelid = c.oid AND "
+ " c.relam = a.oid AND "
+ " c.relnamespace = n.oid AND "
+- " a.amname = 'hash'"));
++ " i.indexrelid >= '%u'::pg_catalog.oid AND "
++ " %s",
++ FirstNormalObjectId,
++ pred));
+ }
+
+ PQfinish(conn);
+@@ -335,24 +357,37 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ report_status(PG_WARNING, "warning");
+ if (check_mode)
+ pg_log(PG_WARNING, "\n"
+- "Your installation contains hash indexes. These indexes have different\n"
++ "Your installation contains %s indexes. These indexes have different\n"
+ "internal formats between your old and new clusters, so they must be\n"
+ "reindexed with the REINDEX command. After upgrading, you will be given\n"
+- "REINDEX instructions.");
++ "REINDEX instructions.",
++ name);
+ else
+ pg_log(PG_WARNING, "\n"
+- "Your installation contains hash indexes. These indexes have different\n"
++ "Your installation contains %s indexes. These indexes have different\n"
+ "internal formats between your old and new clusters, so they must be\n"
+ "reindexed with the REINDEX command. The file\n"
+ " %s\n"
+ "when executed by psql by the database superuser will recreate all invalid\n"
+ "indexes; until then, none of these indexes will be used.",
++ name,
+ output_path);
+ }
+ else
+ check_ok();
+ }
+
++/*
++ * old_9_6_invalidate_hash_indexes()
++ * 9.6 -> 10
++ * Hash index binary format has changed from 9.6->10.0
++ */
++void
++old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "hash", "a.amname = 'hash'");
++}
++
+ /*
+ * old_11_check_for_sql_identifier_data_type_usage()
+ * 11 -> 12
+@@ -459,3 +494,36 @@ report_extension_updates(ClusterInfo *cluster)
+ else
+ check_ok();
+ }
++
++/*
++ * invalidate_spgist_indexes()
++ * 32bit -> 64bit
++ * SP-GIST contains xids.
++ */
++void
++invalidate_spgist_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "spgist", "a.amname = 'spgist'");
++}
++
++/*
++ * invalidate_gin_indexes()
++ * 32bit -> 64bit
++ * Gin indexes contains xids in deleted pages.
++ */
++void
++invalidate_gin_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "gin", "a.amname = 'gin'");
++}
++
++/*
++ * invalidate_external_indexes()
++ * Generate script to REINDEX non standard external indexes (like RUM etc)
++ */
++void
++invalidate_external_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "external",
++ "NOT a.amname IN ('btree', 'hash', 'gist', 'gin', 'spgist', 'brin')");
++}
+diff --git a/src/bin/pg_waldump/pg_waldump.c b/src/bin/pg_waldump/pg_waldump.c
+index 319c44c2b2..dea4dac02b 100644
+--- a/src/bin/pg_waldump/pg_waldump.c
++++ b/src/bin/pg_waldump/pg_waldump.c
+@@ -1050,7 +1050,7 @@ main(int argc, char **argv)
+ config.filter_by_fpw = true;
+ break;
+ case 'x':
+- if (sscanf(optarg, "%u", &config.filter_by_xid) != 1)
++ if (sscanf(optarg, "%" INT64_MODIFIER "u", &config.filter_by_xid) != 1)
+ {
+ pg_log_error("invalid transaction ID specification: \"%s\"",
+ optarg);
+diff --git a/src/bin/pg_waldump/t/001_basic.pl b/src/bin/pg_waldump/t/001_basic.pl
+index 029a0d0521..8e6c7b5b09 100644
+--- a/src/bin/pg_waldump/t/001_basic.pl
++++ b/src/bin/pg_waldump/t/001_basic.pl
+@@ -47,7 +47,8 @@ BRIN
+ CommitTs
+ ReplicationOrigin
+ Generic
+-LogicalMessage$/,
++LogicalMessage
++Heap3$/,
+ 'rmgr list');
+
+
+diff --git a/src/include/access/ginblock.h b/src/include/access/ginblock.h
+index c59790ec5a..4b655baf73 100644
+--- a/src/include/access/ginblock.h
++++ b/src/include/access/ginblock.h
+@@ -133,8 +133,15 @@ typedef struct GinMetaPageData
+ * We should reclaim deleted page only once every transaction started before
+ * its deletion is over.
+ */
+-#define GinPageGetDeleteXid(page) ( ((PageHeader) (page))->pd_prune_xid )
+-#define GinPageSetDeleteXid(page, xid) ( ((PageHeader) (page))->pd_prune_xid = xid)
++#define GinPageGetDeleteXid(page) ( \
++ (((PageHeader) (page))->pd_upper == BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId)) ? \
++ *((TransactionId *) ((char *) (page) + BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId))) : \
++ InvalidTransactionId )
++#define GinPageSetDeleteXid(page, xid) \
++ do { \
++ ((PageHeader) (page))->pd_upper = BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId); \
++ *((TransactionId *) ((char *) (page) + BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId))) = xid; \
++ } while (false)
+ extern bool GinPageIsRecyclable(Page page);
+
+ /*
+diff --git a/src/include/access/gist.h b/src/include/access/gist.h
+index 0235716c06..2996cdd486 100644
+--- a/src/include/access/gist.h
++++ b/src/include/access/gist.h
+@@ -223,7 +223,7 @@ GistPageGetDeleteXid(Page page)
+ return ((GISTDeletedPageContents *) PageGetContents(page))->deleteXid;
+ }
+ else
+- return FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
++ return FullTransactionIdFromXid(FirstNormalTransactionId);
+ }
+
+ /*
+diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
+index a2d7a0ea72..d7e3ebbc81 100644
+--- a/src/include/access/heapam.h
++++ b/src/include/access/heapam.h
+@@ -76,6 +76,8 @@ typedef struct HeapScanDescData
+ int rs_cindex; /* current tuple's index in vistuples */
+ int rs_ntuples; /* number of visible tuples on page */
+ OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]; /* their offsets */
++ TransactionId rs_xmin[MaxHeapTuplesPerPage]; /* their xmins */
++ TransactionId rs_xmax[MaxHeapTuplesPerPage]; /* their xmaxs */
+ } HeapScanDescData;
+ typedef struct HeapScanDescData *HeapScanDesc;
+
+@@ -272,6 +274,8 @@ extern void ReleaseBulkInsertStatePin(BulkInsertState bistate);
+
+ extern void heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ int options, BulkInsertState bistate);
++extern void rewrite_page_prepare_for_xid(Page page, HeapTuple tup,
++ bool is_toast);
+ extern void heap_multi_insert(Relation relation, struct TupleTableSlot **slots,
+ int ntuples, CommandId cid, int options,
+ BulkInsertState bistate);
+@@ -291,21 +295,21 @@ extern TM_Result heap_lock_tuple(Relation relation, HeapTuple tuple,
+ Buffer *buffer, struct TM_FailureData *tmfd);
+
+ extern void heap_inplace_update(Relation relation, HeapTuple tuple);
+-extern bool heap_prepare_freeze_tuple(HeapTupleHeader tuple,
++extern bool heap_prepare_freeze_tuple(HeapTuple tuple,
+ const struct VacuumCutoffs *cutoffs,
+ HeapPageFreeze *pagefrz,
+ HeapTupleFreeze *frz, bool *totally_frozen);
+ extern void heap_freeze_execute_prepared(Relation rel, Buffer buffer,
+ TransactionId snapshotConflictHorizon,
+ HeapTupleFreeze *tuples, int ntuples);
+-extern bool heap_freeze_tuple(HeapTupleHeader tuple,
++extern bool heap_freeze_tuple(HeapTuple tuple,
+ TransactionId relfrozenxid, TransactionId relminmxid,
+ TransactionId FreezeLimit, TransactionId MultiXactCutoff);
+-extern bool heap_tuple_should_freeze(HeapTupleHeader tuple,
++extern bool heap_tuple_should_freeze(HeapTuple htup,
+ const struct VacuumCutoffs *cutoffs,
+ TransactionId *NoFreezePageRelfrozenXid,
+ MultiXactId *NoFreezePageRelminMxid);
+-extern bool heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple);
++extern bool heap_tuple_needs_eventual_freeze(HeapTuple htup);
+
+ extern void simple_heap_insert(Relation relation, HeapTuple tup);
+ extern void simple_heap_delete(Relation relation, ItemPointer tid);
+@@ -321,12 +325,16 @@ extern void heap_page_prune_opt(Relation relation, Buffer buffer);
+ extern void heap_page_prune(Relation relation, Buffer buffer,
+ struct GlobalVisState *vistest,
+ PruneResult *presult,
+- OffsetNumber *off_loc);
++ OffsetNumber *off_loc,
++ bool repairFragmentation);
+ extern void heap_page_prune_execute(Buffer buffer,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *nowdead, int ndead,
+- OffsetNumber *nowunused, int nunused);
+-extern void heap_get_root_tuples(Page page, OffsetNumber *root_offsets);
++ OffsetNumber *nowunused, int nunused,
++ bool repairFragmentation,
++ bool is_toast);
++extern void heap_get_root_tuples(Relation relation, Buffer buffer, Page page,
++ OffsetNumber *root_offsets);
+
+ /* in heap/vacuumlazy.c */
+ struct VacuumParams;
+@@ -344,7 +352,7 @@ extern HTSV_Result HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer
+ TransactionId *dead_after);
+ extern void HeapTupleSetHintBits(HeapTupleHeader tuple, Buffer buffer,
+ uint16 infomask, TransactionId xid);
+-extern bool HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple);
++extern bool HeapTupleIsOnlyLocked(HeapTuple htup);
+ extern bool HeapTupleIsSurelyDead(HeapTuple htup,
+ struct GlobalVisState *vistest);
+
+diff --git a/src/include/access/heapam_xlog.h b/src/include/access/heapam_xlog.h
+index a038450787..ba911404e7 100644
+--- a/src/include/access/heapam_xlog.h
++++ b/src/include/access/heapam_xlog.h
+@@ -59,6 +59,8 @@
+ #define XLOG_HEAP2_LOCK_UPDATED 0x60
+ #define XLOG_HEAP2_NEW_CID 0x70
+
++#define XLOG_HEAP3_BASE_SHIFT 0x00
++
+ /*
+ * xl_heap_insert/xl_heap_multi_insert flag values, 8 bits are available.
+ */
+@@ -98,6 +100,7 @@
+ #define XLH_DELETE_CONTAINS_OLD_KEY (1<<2)
+ #define XLH_DELETE_IS_SUPER (1<<3)
+ #define XLH_DELETE_IS_PARTITION_MOVE (1<<4)
++#define XLH_DELETE_PAGE_ON_TOAST_RELATION (1<<5)
+
+ /* convenience macro for checking whether any form of old tuple was logged */
+ #define XLH_DELETE_CONTAINS_OLD \
+@@ -240,6 +243,9 @@ typedef struct xl_heap_update
+ *
+ * Acquires a full cleanup lock.
+ */
++#define XLH_PRUNE_ON_TOAST_RELATION 0x01
++#define XLH_PRUNE_REPAIR_FRAGMENTATION 0x02
++
+ typedef struct xl_heap_prune
+ {
+ TransactionId snapshotConflictHorizon;
+@@ -247,10 +253,11 @@ typedef struct xl_heap_prune
+ uint16 ndead;
+ bool isCatalogRel; /* to handle recovery conflict during logical
+ * decoding on standby */
++ uint8 flags;
+ /* OFFSET NUMBERS are in the block reference 0 */
+ } xl_heap_prune;
+
+-#define SizeOfHeapPrune (offsetof(xl_heap_prune, isCatalogRel) + sizeof(bool))
++#define SizeOfHeapPrune (offsetof(xl_heap_prune, flags) + sizeof(uint8))
+
+ /*
+ * The vacuum page record is similar to the prune record, but can only mark
+@@ -342,19 +349,22 @@ typedef struct xl_heap_freeze_plan
+ * Each such page offset number array corresponds to a single freeze plan
+ * (REDO routine freezes corresponding heap tuples using freeze plan).
+ */
++#define XLH_FREEZE_PAGE_ON_TOAST_RELATION 0x01
++
+ typedef struct xl_heap_freeze_page
+ {
+ TransactionId snapshotConflictHorizon;
+ uint16 nplans;
+ bool isCatalogRel; /* to handle recovery conflict during logical
+ * decoding on standby */
++ uint8 flags;
+
+ /*
+ * In payload of blk 0 : FREEZE PLANS and OFFSET NUMBER ARRAY
+ */
+ } xl_heap_freeze_page;
+
+-#define SizeOfHeapFreezePage (offsetof(xl_heap_freeze_page, isCatalogRel) + sizeof(bool))
++#define SizeOfHeapFreezePage (offsetof(xl_heap_freeze_page, flags) + sizeof(uint8))
+
+ /*
+ * This is what we need to know about setting a visibility map bit
+@@ -401,7 +411,19 @@ typedef struct xl_heap_rewrite_mapping
+ XLogRecPtr start_lsn; /* Insert LSN at begin of rewrite */
+ } xl_heap_rewrite_mapping;
+
+-extern void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
++#define XLH_BASE_SHIFT_ON_TOAST_RELATION 0x01
++
++/* shift the base of xids on heap page */
++typedef struct xl_heap_base_shift
++{
++ int64 delta; /* delta value to shift the base */
++ bool multi; /* true to shift multixact base */
++ uint8 flags;
++} xl_heap_base_shift;
++
++#define SizeOfHeapBaseShift (offsetof(xl_heap_base_shift, flags) + sizeof(uint8))
++
++extern void HeapTupleHeaderAdvanceConflictHorizon(HeapTuple tuple,
+ TransactionId *snapshotConflictHorizon);
+
+ extern void heap_redo(XLogReaderState *record);
+@@ -411,6 +433,9 @@ extern void heap_mask(char *pagedata, BlockNumber blkno);
+ extern void heap2_redo(XLogReaderState *record);
+ extern void heap2_desc(StringInfo buf, XLogReaderState *record);
+ extern const char *heap2_identify(uint8 info);
++extern void heap3_redo(XLogReaderState *record);
++extern void heap3_desc(StringInfo buf, XLogReaderState *record);
++extern const char *heap3_identify(uint8 info);
+ extern void heap_xlog_logical_rewrite(XLogReaderState *r);
+
+ extern XLogRecPtr log_heap_visible(Relation rel, Buffer heap_buffer,
+diff --git a/src/include/access/heaptoast.h b/src/include/access/heaptoast.h
+index 5c0a796f66..f9c781abbe 100644
+--- a/src/include/access/heaptoast.h
++++ b/src/include/access/heaptoast.h
+@@ -20,10 +20,19 @@
+ /*
+ * Find the maximum size of a tuple if there are to be N tuples per page.
+ */
++#if MAXIMUM_ALIGNOF == 8
+ #define MaximumBytesPerTuple(tuplesPerPage) \
+ MAXALIGN_DOWN((BLCKSZ - \
+- MAXALIGN(SizeOfPageHeaderData + (tuplesPerPage) * sizeof(ItemIdData))) \
++ MAXALIGN(SizeOfPageHeaderData + (tuplesPerPage) * sizeof(ItemIdData)) - MAXALIGN(sizeof(HeapPageSpecialData))) \
+ / (tuplesPerPage))
++#elif MAXIMUM_ALIGNOF == 4
++#define MaximumBytesPerTuple(tuplesPerPage) \
++ MAXALIGN_DOWN((BLCKSZ - \
++ MAXALIGN(SizeOfPageHeaderData + (tuplesPerPage) * sizeof(ItemIdData)) - MAXALIGN(sizeof(ToastPageSpecialData))) \
++ / (tuplesPerPage))
++#else
++#error "unknown arch bitness"
++#endif
+
+ /*
+ * These symbols control toaster activation. If a tuple is larger than
+diff --git a/src/include/access/htup.h b/src/include/access/htup.h
+index a8f7ff5dfe..063d9ac4c4 100644
+--- a/src/include/access/htup.h
++++ b/src/include/access/htup.h
+@@ -54,6 +54,12 @@ typedef MinimalTupleData *MinimalTuple;
+ * this can't be told apart from case #1 by inspection; code setting up
+ * or destroying this representation has to know what it's doing.
+ *
++ * t_xmin and t_xmax are TransactionId values stored in heap tuple header.
++ * Normally they are calculated from ShortTransactionId-sized on-disk tuple
++ * xmin/xmax representation:
++ * t_data->t_choice.t_heap.t_xmin/t_data->t_choice.t_heap.t_xmin
++ * and pd_xid_base and pd_multi_base commmon values for all tuples on a page.
++ *
+ * t_len should always be valid, except in the pointer-to-nothing case.
+ * t_self and t_tableOid should be valid if the HeapTupleData points to
+ * a disk buffer, or if it represents a copy of a tuple on disk. They
+@@ -61,10 +67,12 @@ typedef MinimalTupleData *MinimalTuple;
+ */
+ typedef struct HeapTupleData
+ {
++ TransactionId t_xmin; /* calculated tuple xmin */
++ TransactionId t_xmax; /* calculated tuple xmax */
+ uint32 t_len; /* length of *t_data */
+ ItemPointerData t_self; /* SelfItemPointer */
+ Oid t_tableOid; /* table the tuple came from */
+-#define FIELDNO_HEAPTUPLEDATA_DATA 3
++#define FIELDNO_HEAPTUPLEDATA_DATA 5
+ HeapTupleHeader t_data; /* -> tuple header and data */
+ } HeapTupleData;
+
+@@ -78,12 +86,11 @@ typedef HeapTupleData *HeapTuple;
+ #define HeapTupleIsValid(tuple) PointerIsValid(tuple)
+
+ /* HeapTupleHeader functions implemented in utils/time/combocid.c */
+-extern CommandId HeapTupleHeaderGetCmin(HeapTupleHeader tup);
+-extern CommandId HeapTupleHeaderGetCmax(HeapTupleHeader tup);
+-extern void HeapTupleHeaderAdjustCmax(HeapTupleHeader tup,
+- CommandId *cmax, bool *iscombo);
++extern CommandId HeapTupleGetCmin(HeapTuple tup);
++extern CommandId HeapTupleGetCmax(HeapTuple tup);
++extern void HeapTupleAdjustCmax(HeapTuple tup, CommandId *cmax, bool *iscombo);
+
+ /* Prototype for HeapTupleHeader accessors in heapam.c */
+-extern TransactionId HeapTupleGetUpdateXid(HeapTupleHeader tuple);
++extern TransactionId HeapTupleGetUpdateXid(HeapTuple tuple);
+
+ #endif /* HTUP_H */
+diff --git a/src/include/access/htup_details.h b/src/include/access/htup_details.h
+index 6fd87dc108..a99bb70906 100644
+--- a/src/include/access/htup_details.h
++++ b/src/include/access/htup_details.h
+@@ -19,6 +19,7 @@
+ #include "access/tupdesc.h"
+ #include "access/tupmacs.h"
+ #include "storage/bufpage.h"
++#include "storage/bufmgr.h"
+ #include "varatt.h"
+
+ /*
+@@ -121,13 +122,13 @@
+
+ typedef struct HeapTupleFields
+ {
+- TransactionId t_xmin; /* inserting xact ID */
+- TransactionId t_xmax; /* deleting or locking xact ID */
++ ShortTransactionId t_xmin; /* inserting xact ID */
++ ShortTransactionId t_xmax; /* deleting or locking xact ID */
+
+ union
+ {
+ CommandId t_cid; /* inserting or deleting command ID, or both */
+- TransactionId t_xvac; /* old-style VACUUM FULL xact ID */
++ ShortTransactionId t_xvac; /* old-style VACUUM FULL xact ID */
+ } t_field3;
+ } HeapTupleFields;
+
+@@ -223,7 +224,7 @@ struct HeapTupleHeaderData
+ * HEAP_XMAX_LOCK_ONLY bit is set; or, for pg_upgrade's sake, if the Xmax is
+ * not a multi and the EXCL_LOCK bit is set.
+ *
+- * See also HeapTupleHeaderIsOnlyLocked, which also checks for a possible
++ * See also HeapTupleIsOnlyLocked, which also checks for a possible
+ * aborted updater transaction.
+ *
+ * Beware of multiple evaluations of the argument.
+@@ -299,29 +300,81 @@ struct HeapTupleHeaderData
+ */
+
+ /*
+- * HeapTupleHeaderGetRawXmin returns the "raw" xmin field, which is the xid
++ * HeapTupleGetRawXmin returns the "raw" xmin field, which is the xid
+ * originally used to insert the tuple. However, the tuple might actually
+- * be frozen (via HeapTupleHeaderSetXminFrozen) in which case the tuple's xmin
++ * be frozen (via HeapTupleHeaderStoreXminFrozen) in which case the tuple's xmin
+ * is visible to every snapshot. Prior to PostgreSQL 9.4, we actually changed
+ * the xmin to FrozenTransactionId, and that value may still be encountered
+ * on disk.
+ */
+-#define HeapTupleHeaderGetRawXmin(tup) \
++#define HeapTupleGetRawXmin(tup) \
+ ( \
+- (tup)->t_choice.t_heap.t_xmin \
++ ((tup)->t_xmin) \
+ )
+
+-#define HeapTupleHeaderGetXmin(tup) \
++#define HeapTupleGetXmin(tup) \
+ ( \
+- HeapTupleHeaderXminFrozen(tup) ? \
+- FrozenTransactionId : HeapTupleHeaderGetRawXmin(tup) \
++ HeapTupleHeaderXminFrozen((tup)->t_data) ? \
++ FrozenTransactionId : HeapTupleGetRawXmin(tup) \
+ )
+
+-#define HeapTupleHeaderSetXmin(tup, xid) \
++#define HeapTupleSetXmin(tup, xid) \
+ ( \
+- (tup)->t_choice.t_heap.t_xmin = (xid) \
++ ((tup)->t_xmin = (xid)) \
+ )
+
++/*
++ * Functions for accessing "double xmax". On pg_upgraded instances, it might
++ * happend that we can't fit new special area to the page. But we still
++ * might neep to write xmax of tuples for updates and deletes. The trick is
++ * that we actually don't need xmin field. After pg_upgrade (wich implies
++ * restart) no insertions went to this page yet (otherwise special area could
++ * fit). So, if tuple is visible (othewise it would be deleted), then it's
++ * visible for everybody. Thus, t_xmin isn't needed. Therefore, we can use
++ * both t_xmin and t_xmax to store 64-bit xmax.
++ *
++ * See heap_convert.c for details.
++ */
++static inline TransactionId
++HeapTupleHeaderGetDoubleXmax(HeapTupleHeader htup)
++{
++ TransactionId xmax;
++
++ xmax = htup->t_choice.t_heap.t_xmin;
++ xmax <<= 32;
++ xmax += htup->t_choice.t_heap.t_xmax;
++
++ return xmax;
++}
++
++static inline void
++HeapTupleHeaderSetDoubleXmax(HeapTupleHeader htup, TransactionId xid)
++{
++ htup->t_choice.t_heap.t_xmax = xid & 0xFFFFFFFF;
++ htup->t_choice.t_heap.t_xmin = (xid >> 32) & 0xFFFFFFFF;
++}
++
++static inline void
++HeapTupleHeaderStoreXmin(Page page, HeapTuple htup, bool is_toast)
++{
++ TransactionId base;
++
++ Assert(!HeapPageIsDoubleXmax(page));
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial((page))->pd_xid_base;
++ htup->t_data->t_choice.t_heap.t_xmin =
++ NormalTransactionIdToShort(base, htup->t_xmin);
++}
++
++static inline void
++HeapTupleAndHeaderSetXmin(Page page, HeapTuple tup, TransactionId xid,
++ bool is_toast)
++{
++ HeapTupleSetXmin(tup, xid);
++ HeapTupleHeaderStoreXmin(page, tup, is_toast);
++}
++
+ #define HeapTupleHeaderXminCommitted(tup) \
+ ( \
+ ((tup)->t_infomask & HEAP_XMIN_COMMITTED) != 0 \
+@@ -338,6 +391,12 @@ struct HeapTupleHeaderData
+ ((tup)->t_infomask & (HEAP_XMIN_FROZEN)) == HEAP_XMIN_FROZEN \
+ )
+
++#define HeapTupleHeaderStoreXminFrozen(tup) \
++( \
++ AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
++ ((tup)->t_infomask |= HEAP_XMIN_FROZEN) \
++)
++
+ #define HeapTupleHeaderSetXminCommitted(tup) \
+ ( \
+ AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
+@@ -363,30 +422,80 @@ struct HeapTupleHeaderData
+ * to resolve the MultiXactId if necessary. This might involve multixact I/O,
+ * so it should only be used if absolutely necessary.
+ */
+-#define HeapTupleHeaderGetUpdateXid(tup) \
++#define HeapTupleGetUpdateXidAny(tup) \
+ ( \
+- (!((tup)->t_infomask & HEAP_XMAX_INVALID) && \
+- ((tup)->t_infomask & HEAP_XMAX_IS_MULTI) && \
+- !((tup)->t_infomask & HEAP_XMAX_LOCK_ONLY)) ? \
++ (!((tup)->t_data->t_infomask & HEAP_XMAX_INVALID) && \
++ ((tup)->t_data->t_infomask & HEAP_XMAX_IS_MULTI) && \
++ !((tup)->t_data->t_infomask & HEAP_XMAX_LOCK_ONLY)) ? \
+ HeapTupleGetUpdateXid(tup) \
+ : \
+- HeapTupleHeaderGetRawXmax(tup) \
++ HeapTupleGetRawXmax(tup) \
+ )
+
+-#define HeapTupleHeaderGetRawXmax(tup) \
+-( \
+- (tup)->t_choice.t_heap.t_xmax \
+-)
++static inline TransactionId
++HeapTupleHeaderGetRawXmax(Page page, HeapTupleHeader htup)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return HeapTupleHeaderGetDoubleXmax(htup);
+
+-#define HeapTupleHeaderSetXmax(tup, xid) \
++ base = (htup->t_infomask & HEAP_XMAX_IS_MULTI) ?
++ HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++ return ShortTransactionIdToNormal(base,
++ htup->t_choice.t_heap.t_xmax);
++}
++
++#define HeapTupleGetRawXmax(tup) \
+ ( \
+- (tup)->t_choice.t_heap.t_xmax = (xid) \
++ ((tup)->t_xmax) \
+ )
+
++#define HeapTupleSetXmax(tup, xid) \
++do { \
++ (tup)->t_xmax = (xid); \
++} while (0)
++
++/*
++ * Set xid as xmax for HeapTupleHeader.
++ */
++static inline void
++HeapTupleHeaderStoreXmax(Page page, HeapTuple htup, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ HeapTupleHeaderSetDoubleXmax(htup->t_data, htup->t_xmax);
++ return;
++ }
++
++ if (is_toast)
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ else
++ base = (htup->t_data->t_infomask & HEAP_XMAX_IS_MULTI) != 0 ?
++ HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++ htup->t_data->t_choice.t_heap.t_xmax =
++ NormalTransactionIdToShort(base, htup->t_xmax);
++}
++
++/*
++ * Set xid as xmax for HeadTuple and HeapTupleHeader.
++ */
++static inline void
++HeapTupleAndHeaderSetXmax(Page page, HeapTuple htup, TransactionId xid,
++ bool is_toast)
++{
++ HeapTupleSetXmax(htup, xid);
++ HeapTupleHeaderStoreXmax(page, htup, is_toast);
++}
++
+ /*
+ * HeapTupleHeaderGetRawCommandId will give you what's in the header whether
+- * it is useful or not. Most code should use HeapTupleHeaderGetCmin or
+- * HeapTupleHeaderGetCmax instead, but note that those Assert that you can
++ * it is useful or not. Most code should use HeapTupleGetCmin or
++ * HeapTupleGetCmax instead, but note that those Assert that you can
+ * get a legitimate result, ie you are in the originating transaction!
+ */
+ #define HeapTupleHeaderGetRawCommandId(tup) \
+@@ -402,7 +511,7 @@ do { \
+ (tup)->t_infomask &= ~HEAP_COMBOCID; \
+ } while (0)
+
+-/* SetCmax must be used after HeapTupleHeaderAdjustCmax; see combocid.c */
++/* SetCmax must be used after HeapTupleAdjustCmax; see combocid.c */
+ #define HeapTupleHeaderSetCmax(tup, cid, iscombo) \
+ do { \
+ Assert(!((tup)->t_infomask & HEAP_MOVED)); \
+@@ -559,8 +668,16 @@ StaticAssertDecl(MaxOffsetNumber < SpecTokenOffsetNumber,
+ * an otherwise-empty page can indeed hold a tuple of this size. Because
+ * ItemIds and tuples have different alignment requirements, don't assume that
+ * you can, say, fit 2 tuples of size MaxHeapTupleSize/2 on the same page.
++ *
++ * On shift to 64-bit XIDs MaxHeapTupleSize decreased by sizeof(HeapPageSpecialData).
++ * Extant tuples with length over new MaxHeapTupleSize are inherited on DoubleXmax
++ * pages. They could be read, but can not be updated unless their length decreases
++ * to fit MaxHeapTupleSize. Vacuum full will also copy these double xmax pages
++ * without change.
+ */
+-#define MaxHeapTupleSize (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))
++
++#define MaxHeapTupleSize (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)) - MAXALIGN(sizeof(HeapPageSpecialData)))
++#define MaxHeapTupleSize_32 (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))
+ #define MinHeapTupleSize MAXALIGN(SizeofHeapTupleHeader)
+
+ /*
+@@ -694,6 +811,112 @@ struct MinimalTupleData
+ #define HeapTupleClearHeapOnly(tuple) \
+ HeapTupleHeaderClearHeapOnly((tuple)->t_data)
+
++/*
++ * Copy base values for xid and multixacts from one heap tuple to heap tuple.
++ * Should be called on tuple copy or making desc tuple on the base on src tuple
++ * saving visibility information.
++ */
++static inline void
++HeapTupleCopyXids(HeapTuple dest, HeapTuple src)
++{
++ dest->t_xmin = src->t_xmin;
++ dest->t_xmax = src->t_xmax;
++}
++
++/*
++ * Set base values for tuple xids/multixacts to zero. Used when visibility
++ * infromation is negligible or will be set later.
++ */
++static inline void
++HeapTupleSetZeroXids(HeapTuple htup)
++{
++ htup->t_xmin = 0;
++ htup->t_xmax = 0;
++}
++
++/*
++ * Copy HeapTupleHeader xmin/xmax in raw way ???
++ */
++static inline void
++HeapTupleCopyHeaderXids(HeapTuple htup) \
++{
++ htup->t_xmin = htup->t_data->t_choice.t_heap.t_xmin;
++ htup->t_xmax = htup->t_data->t_choice.t_heap.t_xmax;
++}
++
++static inline void
++HeapTupleCopyXminFromPage(HeapTuple tup, Page page, bool is_toast)
++{
++ TransactionId base;
++ ShortTransactionId xmin; /* short xmin from tuple header */
++
++ if (HeapTupleHeaderXminFrozen(tup->t_data))
++ {
++ tup->t_xmin = FrozenTransactionId;
++ return;
++ }
++
++ xmin = tup->t_data->t_choice.t_heap.t_xmin;
++
++ if (!TransactionIdIsNormal(xmin))
++ base = 0;
++ else if (is_toast)
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ else
++ base = HeapPageGetSpecial(page)->pd_xid_base;
++
++ tup->t_xmin = ShortTransactionIdToNormal(base, xmin);
++}
++
++static inline void
++HeapTupleCopyXmaxFromPage(HeapTuple tup, Page page, bool is_toast)
++{
++ TransactionId base;
++ ShortTransactionId xmax; /* short xmax from tuple header */
++
++ xmax = tup->t_data->t_choice.t_heap.t_xmax;
++
++ if (!TransactionIdIsNormal(xmax))
++ base = 0;
++ else if (is_toast)
++ /*
++ * Toast page is not expected to have multixacts in chunks and
++ * has shorter special.
++ */
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ else if (tup->t_data->t_infomask & HEAP_XMAX_IS_MULTI)
++ base = HeapPageGetSpecial(page)->pd_multi_base;
++ else
++ base = HeapPageGetSpecial(page)->pd_xid_base;
++
++ tup->t_xmax = ShortTransactionIdToNormal(base, xmax);
++}
++
++/*
++ * Copy base values for xid and multixacts from page to heap tuple. Should be
++ * called each time tuple is read from page. Otherwise, it would be impossible
++ * to correctly read tuple xmin and xmax.
++ */
++static inline void
++HeapTupleCopyXidsFromPage(Buffer buffer, HeapTuple tup, Page page,
++ bool is_toast)
++{
++ Assert(IsBufferLocked(buffer));
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ /*
++ * On double xmax pages, xmax is extracted from tuple header.
++ */
++ tup->t_xmin = FrozenTransactionId;
++ tup->t_xmax = HeapTupleHeaderGetDoubleXmax(tup->t_data);
++ return;
++ }
++
++ HeapTupleCopyXminFromPage(tup, page, is_toast);
++ HeapTupleCopyXmaxFromPage(tup, page, is_toast);
++}
++
+ /* prototypes for functions in common/heaptuple.c */
+ extern Size heap_compute_data_size(TupleDesc tupleDesc,
+ const Datum *values, const bool *isnull);
+diff --git a/src/include/access/multixact.h b/src/include/access/multixact.h
+index 0be1355892..b84eb12710 100644
+--- a/src/include/access/multixact.h
++++ b/src/include/access/multixact.h
+@@ -18,16 +18,16 @@
+
+ /*
+ * The first two MultiXactId values are reserved to store the truncation Xid
+- * and epoch of the first segment, so we start assigning multixact values from
++ * and base of the first segment, so we start assigning multixact values from
+ * 2.
+ */
+-#define InvalidMultiXactId ((MultiXactId) 0)
+-#define FirstMultiXactId ((MultiXactId) 1)
+-#define MaxMultiXactId ((MultiXactId) 0xFFFFFFFF)
++#define InvalidMultiXactId UINT64CONST(0)
++#define FirstMultiXactId UINT64CONST(1)
++#define MaxMultiXactId UINT64CONST(0xFFFFFFFFFFFFFFFF)
+
+ #define MultiXactIdIsValid(multi) ((multi) != InvalidMultiXactId)
+
+-#define MaxMultiXactOffset ((MultiXactOffset) 0xFFFFFFFF)
++#define MaxMultiXactOffset UINT64CONST(0xFFFFFFFFFFFFFFFF)
+
+ /* Number of SLRU buffers to use for multixact */
+ #define NUM_MULTIXACTOFFSET_BUFFERS 8
+@@ -147,7 +147,6 @@ extern void MultiXactSetNextMXact(MultiXactId nextMulti,
+ extern void MultiXactAdvanceNextMXact(MultiXactId minMulti,
+ MultiXactOffset minMultiOffset);
+ extern void MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB);
+-extern int MultiXactMemberFreezeThreshold(void);
+
+ extern void multixact_twophase_recover(TransactionId xid, uint16 info,
+ void *recdata, uint32 len);
+diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
+index 7bfbf3086c..d579aabee1 100644
+--- a/src/include/access/nbtree.h
++++ b/src/include/access/nbtree.h
+@@ -62,8 +62,10 @@ typedef uint16 BTCycleId;
+ typedef struct BTPageOpaqueData
+ {
+ BlockNumber btpo_prev; /* left sibling, or P_NONE if leftmost */
++ /* ... or next transaction ID (lower part) */
+ BlockNumber btpo_next; /* right sibling, or P_NONE if rightmost */
+ uint32 btpo_level; /* tree level --- zero for leaf pages */
++ /* ... or next transaction ID (lower part) */
+ uint16 btpo_flags; /* flag bits, see below */
+ BTCycleId btpo_cycleid; /* vacuum cycle ID of latest split */
+ } BTPageOpaqueData;
+@@ -92,6 +94,14 @@ typedef BTPageOpaqueData *BTPageOpaque;
+ */
+ #define MAX_BT_CYCLE_ID 0xFF7F
+
++/* Macros for access xact */
++#define BTP_GET_XACT(opaque) (((uint64) ((BTPageOpaque) opaque)->btpo_prev << 32) | \
++ (uint64) ((BTPageOpaque) opaque)->btpo_level)
++#define BTP_SET_XACT(opaque, xact) \
++do { \
++ ((BTPageOpaque) opaque)->btpo_prev = (uint32) (xact >> 32); \
++ ((BTPageOpaque) opaque)->btpo_level = (uint32) xact; \
++} while (0)
+
+ /*
+ * The Meta page is always the first page in the btree index.
+diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h
+index 1ad1352036..58d460fc03 100644
+--- a/src/include/access/reloptions.h
++++ b/src/include/access/reloptions.h
+@@ -110,7 +110,7 @@ typedef struct relopt_int64
+ int64 default_val;
+ int64 min;
+ int64 max;
+-} relopt_int64;
++} relopt_int64;
+
+ typedef struct relopt_real
+ {
+diff --git a/src/include/access/rewriteheap.h b/src/include/access/rewriteheap.h
+index 1125457053..c0f0d456da 100644
+--- a/src/include/access/rewriteheap.h
++++ b/src/include/access/rewriteheap.h
+@@ -51,7 +51,7 @@ typedef struct LogicalRewriteMappingData
+ * 6) xid of the xact performing the mapping
+ * ---
+ */
+-#define LOGICAL_REWRITE_FORMAT "map-%x-%x-%X_%X-%x-%x"
+-extern void CheckPointLogicalRewriteHeap(void);
++#define LOGICAL_REWRITE_FORMAT "map-%x-%x-%X_%X-%x_%x-%x_%x"
++extern void CheckPointLogicalRewriteHeap(void);
+
+ #endif /* REWRITE_HEAP_H */
+diff --git a/src/include/access/rmgrlist.h b/src/include/access/rmgrlist.h
+index 463bcb67c5..4bafc98190 100644
+--- a/src/include/access/rmgrlist.h
++++ b/src/include/access/rmgrlist.h
+@@ -47,3 +47,4 @@ PG_RMGR(RM_COMMIT_TS_ID, "CommitTs", commit_ts_redo, commit_ts_desc, commit_ts_i
+ PG_RMGR(RM_REPLORIGIN_ID, "ReplicationOrigin", replorigin_redo, replorigin_desc, replorigin_identify, NULL, NULL, NULL, NULL)
+ PG_RMGR(RM_GENERIC_ID, "Generic", generic_redo, generic_desc, generic_identify, NULL, NULL, generic_mask, NULL)
+ PG_RMGR(RM_LOGICALMSG_ID, "LogicalMessage", logicalmsg_redo, logicalmsg_desc, logicalmsg_identify, NULL, NULL, NULL, logicalmsg_decode)
++PG_RMGR(RM_HEAP3_ID, "Heap3", heap3_redo, heap3_desc, heap3_identify, NULL, NULL, heap_mask, NULL)
+diff --git a/src/include/access/slru.h b/src/include/access/slru.h
+index 091e2202c9..982b716b44 100644
+--- a/src/include/access/slru.h
++++ b/src/include/access/slru.h
+@@ -21,15 +21,7 @@
+ /*
+ * Define SLRU segment size. A page is the same BLCKSZ as is used everywhere
+ * else in Postgres. The segment size can be chosen somewhat arbitrarily;
+- * we make it 32 pages by default, or 256Kb, i.e. 1M transactions for CLOG
+- * or 64K transactions for SUBTRANS.
+- *
+- * Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF,
+- * page numbering also wraps around at 0xFFFFFFFF/xxxx_XACTS_PER_PAGE (where
+- * xxxx is CLOG or SUBTRANS, respectively), and segment numbering at
+- * 0xFFFFFFFF/xxxx_XACTS_PER_PAGE/SLRU_PAGES_PER_SEGMENT. We need
+- * take no explicit notice of that fact in slru.c, except when comparing
+- * segment and page numbers in SimpleLruTruncate (see PagePrecedes()).
++ * we make it 32 pages by default.
+ */
+ #define SLRU_PAGES_PER_SEGMENT 32
+
+diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
+index 87227d8bd2..5caf4760e8 100644
+--- a/src/include/access/tableam.h
++++ b/src/include/access/tableam.h
+@@ -134,7 +134,7 @@ typedef enum TU_UpdateIndexes
+ * cmax is the outdating command's CID, but only when the failure code is
+ * TM_SelfModified (i.e., something in the current transaction outdated the
+ * tuple); otherwise cmax is zero. (We make this restriction because
+- * HeapTupleHeaderGetCmax doesn't work for tuples outdated in other
++ * HeapTupleGetCmax doesn't work for tuples outdated in other
+ * transactions.)
+ */
+ typedef struct TM_FailureData
+diff --git a/src/include/access/transam.h b/src/include/access/transam.h
+index f5af6d3055..af9cb645a5 100644
+--- a/src/include/access/transam.h
++++ b/src/include/access/transam.h
+@@ -17,6 +17,10 @@
+ #include "access/xlogdefs.h"
+
+
++#ifndef FRONTEND
++#include "utils/elog.h"
++#endif
++
+ /* ----------------
+ * Special transaction ID values
+ *
+@@ -28,11 +32,12 @@
+ * Note: if you need to change it, you must change pg_class.h as well.
+ * ----------------
+ */
+-#define InvalidTransactionId ((TransactionId) 0)
+-#define BootstrapTransactionId ((TransactionId) 1)
+-#define FrozenTransactionId ((TransactionId) 2)
+-#define FirstNormalTransactionId ((TransactionId) 3)
+-#define MaxTransactionId ((TransactionId) 0xFFFFFFFF)
++#define InvalidTransactionId UINT64CONST(0)
++#define BootstrapTransactionId UINT64CONST(1)
++#define FrozenTransactionId UINT64CONST(2)
++#define FirstNormalTransactionId UINT64CONST(3)
++#define MaxTransactionId UINT64CONST(0xFFFFFFFFFFFFFFFF)
++#define MaxShortTransactionId ((TransactionId) 0x7FFFFFFF)
+
+ /* ----------------
+ * transaction ID manipulation macros
+@@ -44,8 +49,40 @@
+ #define TransactionIdStore(xid, dest) (*(dest) = (xid))
+ #define StoreInvalidTransactionId(dest) (*(dest) = InvalidTransactionId)
+
+-#define EpochFromFullTransactionId(x) ((uint32) ((x).value >> 32))
+-#define XidFromFullTransactionId(x) ((uint32) (x).value)
++/*
++ * Convert short xid from/to full xid. Assertion should fail if we full xid
++ * doesn't fit to xid base.
++ */
++static inline TransactionId
++ShortTransactionIdToNormal(TransactionId base, ShortTransactionId xid)
++{
++ if (!TransactionIdIsNormal(xid))
++ return (TransactionId) xid;
++
++#ifndef FRONTEND
++ /* xid + base should not overflow TransactionId */
++ Assert(xid + base >= base);
++#endif
++
++ return (TransactionId) (xid + base);
++}
++
++static inline ShortTransactionId
++NormalTransactionIdToShort(TransactionId base, TransactionId xid)
++{
++ if (!TransactionIdIsNormal(xid))
++ return (ShortTransactionId) (xid);
++
++#ifndef FRONTEND
++ /* xid should fit ShortTransactionId */
++ Assert(xid >= base + FirstNormalTransactionId &&
++ xid <= base + MaxShortTransactionId);
++#endif
++
++ return (ShortTransactionId) (xid - base);
++}
++
++#define XidFromFullTransactionId(x) ((x).value)
+ #define U64FromFullTransactionId(x) ((x).value)
+ #define FullTransactionIdEquals(a, b) ((a).value == (b).value)
+ #define FullTransactionIdPrecedes(a, b) ((a).value < (b).value)
+@@ -53,8 +90,8 @@
+ #define FullTransactionIdFollows(a, b) ((a).value > (b).value)
+ #define FullTransactionIdFollowsOrEquals(a, b) ((a).value >= (b).value)
+ #define FullTransactionIdIsValid(x) TransactionIdIsValid(XidFromFullTransactionId(x))
+-#define InvalidFullTransactionId FullTransactionIdFromEpochAndXid(0, InvalidTransactionId)
+-#define FirstNormalFullTransactionId FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId)
++#define InvalidFullTransactionId FullTransactionIdFromXid(InvalidTransactionId)
++#define FirstNormalFullTransactionId FullTransactionIdFromXid(FirstNormalTransactionId)
+ #define FullTransactionIdIsNormal(x) FullTransactionIdFollowsOrEquals(x, FirstNormalFullTransactionId)
+
+ /*
+@@ -68,21 +105,11 @@ typedef struct FullTransactionId
+ } FullTransactionId;
+
+ static inline FullTransactionId
+-FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)
++FullTransactionIdFromXid(TransactionId xid)
+ {
+ FullTransactionId result;
+
+- result.value = ((uint64) epoch) << 32 | xid;
+-
+- return result;
+-}
+-
+-static inline FullTransactionId
+-FullTransactionIdFromU64(uint64 value)
+-{
+- FullTransactionId result;
+-
+- result.value = value;
++ result.value = xid;
+
+ return result;
+ }
+@@ -91,8 +118,7 @@ FullTransactionIdFromU64(uint64 value)
+ #define TransactionIdAdvance(dest) \
+ do { \
+ (dest)++; \
+- if ((dest) < FirstNormalTransactionId) \
+- (dest) = FirstNormalTransactionId; \
++ Assert(TransactionIdIsNormal(dest)); \
+ } while(0)
+
+ /*
+@@ -140,18 +166,19 @@ FullTransactionIdAdvance(FullTransactionId *dest)
+ /* back up a transaction ID variable, handling wraparound correctly */
+ #define TransactionIdRetreat(dest) \
+ do { \
++ Assert(TransactionIdIsNormal(dest)); \
+ (dest)--; \
+- } while ((dest) < FirstNormalTransactionId)
++ } while(0)
+
+ /* compare two XIDs already known to be normal; this is a macro for speed */
+ #define NormalTransactionIdPrecedes(id1, id2) \
+ (AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
+- (int32) ((id1) - (id2)) < 0)
++ (int64) ((id1) - (id2)) < 0)
+
+ /* compare two XIDs already known to be normal; this is a macro for speed */
+ #define NormalTransactionIdFollows(id1, id2) \
+ (AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
+- (int32) ((id1) - (id2)) > 0)
++ (int64) ((id1) - (id2)) > 0)
+
+ /* ----------
+ * Object ID (OID) zero is InvalidOid.
+@@ -201,10 +228,6 @@ FullTransactionIdAdvance(FullTransactionId *dest)
+ * OID and XID assignment state. For largely historical reasons, there is
+ * just one struct with different fields that are protected by different
+ * LWLocks.
+- *
+- * Note: xidWrapLimit and oldestXidDB are not "active" values, but are
+- * used just to generate useful messages when xidWarnLimit or xidStopLimit
+- * are exceeded.
+ */
+ typedef struct VariableCacheData
+ {
+@@ -221,9 +244,6 @@ typedef struct VariableCacheData
+
+ TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
+ TransactionId xidVacLimit; /* start forcing autovacuums here */
+- TransactionId xidWarnLimit; /* start complaining here */
+- TransactionId xidStopLimit; /* refuse to advance nextXid beyond here */
+- TransactionId xidWrapLimit; /* where the world ends */
+ Oid oldestXidDB; /* database with minimum datfrozenxid */
+
+ /*
+@@ -276,10 +296,6 @@ extern bool TransactionIdDidAbort(TransactionId transactionId);
+ extern void TransactionIdCommitTree(TransactionId xid, int nxids, TransactionId *xids);
+ extern void TransactionIdAsyncCommitTree(TransactionId xid, int nxids, TransactionId *xids, XLogRecPtr lsn);
+ extern void TransactionIdAbortTree(TransactionId xid, int nxids, TransactionId *xids);
+-extern bool TransactionIdPrecedes(TransactionId id1, TransactionId id2);
+-extern bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2);
+-extern bool TransactionIdFollows(TransactionId id1, TransactionId id2);
+-extern bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2);
+ extern TransactionId TransactionIdLatest(TransactionId mainxid,
+ int nxids, const TransactionId *xids);
+ extern XLogRecPtr TransactionIdGetCommitLSN(TransactionId xid);
+@@ -319,7 +335,7 @@ ReadNextTransactionId(void)
+
+ /* return transaction ID backed up by amount, handling wraparound correctly */
+ static inline TransactionId
+-TransactionIdRetreatedBy(TransactionId xid, uint32 amount)
++TransactionIdRetreatedBy(TransactionId xid, uint64 amount)
+ {
+ xid -= amount;
+
+diff --git a/src/include/access/tupmacs.h b/src/include/access/tupmacs.h
+index 3414446597..83c1adcd6c 100644
+--- a/src/include/access/tupmacs.h
++++ b/src/include/access/tupmacs.h
+@@ -131,10 +131,11 @@ fetch_att(const void *T, bool attbyval, int attlen)
+ ((attalign) == TYPALIGN_INT) ? INTALIGN(cur_offset) : \
+ (((attalign) == TYPALIGN_CHAR) ? (uintptr_t) (cur_offset) : \
+ (((attalign) == TYPALIGN_DOUBLE) ? DOUBLEALIGN(cur_offset) : \
++ (((attalign) == TYPALIGN_XID) ? MAXALIGN(cur_offset) : \
+ ( \
+ AssertMacro((attalign) == TYPALIGN_SHORT), \
+ SHORTALIGN(cur_offset) \
+- ))) \
++ )))) \
+ )
+
+ /*
+diff --git a/src/include/access/xact.h b/src/include/access/xact.h
+index cb90f227ce..f002edd469 100644
+--- a/src/include/access/xact.h
++++ b/src/include/access/xact.h
+@@ -249,7 +249,7 @@ typedef struct xl_xact_xinfo
+ * Commit records can be large, so copying large portions isn't
+ * attractive.
+ */
+- uint32 xinfo;
++ uint64 xinfo;
+ } xl_xact_xinfo;
+
+ typedef struct xl_xact_dbinfo
+@@ -302,7 +302,12 @@ typedef struct xl_xact_invals
+
+ typedef struct xl_xact_twophase
+ {
+- TransactionId xid;
++ /*
++ * TransactionId is split into 32-bit parts because xl_xact_twophase is
++ * only int-aligned.
++ */
++ uint32 xid_lo;
++ uint32 xid_hi;
+ } xl_xact_twophase;
+
+ typedef struct xl_xact_origin
+@@ -321,7 +326,7 @@ typedef struct xl_xact_commit
+ /* xl_xact_relfilelocators follows if XINFO_HAS_RELFILELOCATORS */
+ /* xl_xact_stats_items follows if XINFO_HAS_DROPPED_STATS */
+ /* xl_xact_invals follows if XINFO_HAS_INVALS */
+- /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE */
++ /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE (xid is int-aligned!) */
+ /* twophase_gid follows if XINFO_HAS_GID. As a null-terminated string. */
+ /* xl_xact_origin follows if XINFO_HAS_ORIGIN, stored unaligned! */
+ } xl_xact_commit;
+@@ -337,7 +342,7 @@ typedef struct xl_xact_abort
+ /* xl_xact_relfilelocators follows if XINFO_HAS_RELFILELOCATORS */
+ /* xl_xact_stats_items follows if XINFO_HAS_DROPPED_STATS */
+ /* No invalidation messages needed. */
+- /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE */
++ /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE (xid is int-aligned!) */
+ /* twophase_gid follows if XINFO_HAS_GID. As a null-terminated string. */
+ /* xl_xact_origin follows if XINFO_HAS_ORIGIN, stored unaligned! */
+ } xl_xact_abort;
+diff --git a/src/include/access/xloginsert.h b/src/include/access/xloginsert.h
+index cace867497..87fad76eba 100644
+--- a/src/include/access/xloginsert.h
++++ b/src/include/access/xloginsert.h
+@@ -38,6 +38,7 @@
+ #define REGBUF_KEEP_DATA 0x10 /* include data even if a full-page image
+ * is taken */
+ #define REGBUF_NO_CHANGE 0x20 /* intentionally register clean buffer */
++#define REGBUF_CONVERTED 0x40 /* buffer had format convertion */
+
+ /* prototypes for public functions in xloginsert.c: */
+ extern void XLogBeginInsert(void);
+diff --git a/src/include/access/xlogreader.h b/src/include/access/xlogreader.h
+index 0813722715..07f3af146c 100644
+--- a/src/include/access/xlogreader.h
++++ b/src/include/access/xlogreader.h
+@@ -427,10 +427,6 @@ extern bool DecodeXLogRecord(XLogReaderState *state,
+ #define XLogRecHasBlockData(decoder, block_id) \
+ ((decoder)->record->blocks[block_id].has_data)
+
+-#ifndef FRONTEND
+-extern FullTransactionId XLogRecGetFullXid(XLogReaderState *record);
+-#endif
+-
+ extern bool RestoreBlockImage(XLogReaderState *record, uint8 block_id, char *page);
+ extern char *XLogRecGetBlockData(XLogReaderState *record, uint8 block_id, Size *len);
+ extern void XLogRecGetBlockTag(XLogReaderState *record, uint8 block_id,
+diff --git a/src/include/access/xlogrecord.h b/src/include/access/xlogrecord.h
+index ec9a3c802a..4e58d9be61 100644
+--- a/src/include/access/xlogrecord.h
++++ b/src/include/access/xlogrecord.h
+@@ -41,18 +41,17 @@
+ typedef struct XLogRecord
+ {
+ uint32 xl_tot_len; /* total len of entire record */
++ pg_crc32c xl_crc; /* CRC for this record */
+ TransactionId xl_xid; /* xact id */
+ XLogRecPtr xl_prev; /* ptr to previous record in log */
+ uint8 xl_info; /* flag bits, see below */
+ RmgrId xl_rmid; /* resource manager for this record */
+- /* 2 bytes of padding here, initialize to zero */
+- pg_crc32c xl_crc; /* CRC for this record */
+
+ /* XLogRecordBlockHeaders and XLogRecordDataHeader follow, no padding */
+
+ } XLogRecord;
+
+-#define SizeOfXLogRecord (offsetof(XLogRecord, xl_crc) + sizeof(pg_crc32c))
++#define SizeOfXLogRecord (offsetof(XLogRecord, xl_rmid) + sizeof(RmgrId))
+
+ /*
+ * The high 4 bits in xl_info may be used freely by rmgr. The
+diff --git a/src/include/c.h b/src/include/c.h
+index 82f8e9d4c7..e2420738f2 100644
+--- a/src/include/c.h
++++ b/src/include/c.h
+@@ -638,19 +638,29 @@ typedef double float8;
+ typedef Oid regproc;
+ typedef regproc RegProcedure;
+
+-typedef uint32 TransactionId;
++typedef uint64 TransactionId;
+
+-typedef uint32 LocalTransactionId;
++extern bool TransactionIdPrecedes(TransactionId id1, TransactionId id2);
++extern bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2);
++extern bool TransactionIdFollows(TransactionId id1, TransactionId id2);
++extern bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2);
+
+-typedef uint32 SubTransactionId;
++typedef uint32 ShortTransactionId;
++typedef uint64 LocalTransactionId;
++typedef uint64 SubTransactionId;
+
+-#define InvalidSubTransactionId ((SubTransactionId) 0)
+-#define TopSubTransactionId ((SubTransactionId) 1)
++#define InvalidSubTransactionId ((SubTransactionId) 0)
++#define TopSubTransactionId ((SubTransactionId) 1)
+
+ /* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
+ typedef TransactionId MultiXactId;
+
+-typedef uint32 MultiXactOffset;
++typedef uint64 MultiXactOffset;
++
++#define MAX_START_XID UINT64CONST(0x3FFFFFFFFFFFFFFF) /* 2^62 - 1 */
++#define StartTransactionIdIsValid(xid) ((xid) <= MAX_START_XID)
++#define StartMultiXactIdIsValid(mxid) ((mxid) <= MAX_START_XID)
++#define StartMultiXactOffsetIsValid(mxoff) ((mxoff) <= MAX_START_XID)
+
+ typedef uint32 CommandId;
+
+@@ -824,7 +834,6 @@ typedef NameData *Name;
+ /* we don't currently need wider versions of the other ALIGN macros */
+ #define MAXALIGN64(LEN) TYPEALIGN64(MAXIMUM_ALIGNOF, (LEN))
+
+-
+ /* ----------------------------------------------------------------
+ * Section 6: assertions
+ * ----------------------------------------------------------------
+diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h
+index a06a8f0b23..9f5f3637f0 100644
+--- a/src/include/catalog/catversion.h
++++ b/src/include/catalog/catversion.h
+@@ -57,6 +57,7 @@
+ */
+
+ /* yyyymmddN */
+-#define CATALOG_VERSION_NO 202312071
++/* XXX: should de changed to actual version on commit */
++#define CATALOG_VERSION_NO 999999999
+
+ #endif
+diff --git a/src/include/catalog/pg_amproc.dat b/src/include/catalog/pg_amproc.dat
+index 4c70da41de..b64d64e194 100644
+--- a/src/include/catalog/pg_amproc.dat
++++ b/src/include/catalog/pg_amproc.dat
+@@ -401,9 +401,9 @@
+ amprocrighttype => 'bytea', amprocnum => '2',
+ amproc => 'hashvarlenaextended' },
+ { amprocfamily => 'hash/xid_ops', amproclefttype => 'xid',
+- amprocrighttype => 'xid', amprocnum => '1', amproc => 'hashint4' },
++ amprocrighttype => 'xid', amprocnum => '1', amproc => 'hashint8' },
+ { amprocfamily => 'hash/xid_ops', amproclefttype => 'xid',
+- amprocrighttype => 'xid', amprocnum => '2', amproc => 'hashint4extended' },
++ amprocrighttype => 'xid', amprocnum => '2', amproc => 'hashint8extended' },
+ { amprocfamily => 'hash/xid8_ops', amproclefttype => 'xid8',
+ amprocrighttype => 'xid8', amprocnum => '1', amproc => 'hashint8' },
+ { amprocfamily => 'hash/xid8_ops', amproclefttype => 'xid8',
+diff --git a/src/include/catalog/pg_operator.dat b/src/include/catalog/pg_operator.dat
+index b2cdea66c4..f9feefb013 100644
+--- a/src/include/catalog/pg_operator.dat
++++ b/src/include/catalog/pg_operator.dat
+@@ -183,16 +183,16 @@
+ oprresult => 'bool', oprcom => '=(xid,xid)', oprnegate => '<>(xid,xid)',
+ oprcode => 'xideq', oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+ { oid => '353', descr => 'equal',
+- oprname => '=', oprleft => 'xid', oprright => 'int4', oprresult => 'bool',
+- oprnegate => '<>(xid,int4)', oprcode => 'xideqint4', oprrest => 'eqsel',
++ oprname => '=', oprleft => 'xid', oprright => 'int8', oprresult => 'bool',
++ oprnegate => '<>(xid,int8)', oprcode => 'xideqint8', oprrest => 'eqsel',
+ oprjoin => 'eqjoinsel' },
+ { oid => '3315', descr => 'not equal',
+ oprname => '<>', oprleft => 'xid', oprright => 'xid', oprresult => 'bool',
+ oprcom => '<>(xid,xid)', oprnegate => '=(xid,xid)', oprcode => 'xidneq',
+ oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+ { oid => '3316', descr => 'not equal',
+- oprname => '<>', oprleft => 'xid', oprright => 'int4', oprresult => 'bool',
+- oprnegate => '=(xid,int4)', oprcode => 'xidneqint4', oprrest => 'neqsel',
++ oprname => '<>', oprleft => 'xid', oprright => 'int8', oprresult => 'bool',
++ oprnegate => '=(xid,int8)', oprcode => 'xidneqint8', oprrest => 'neqsel',
+ oprjoin => 'neqjoinsel' },
+ { oid => '5068', descr => 'equal',
+ oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'xid8',
+diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
+index 77e8b13764..f0b02b5599 100644
+--- a/src/include/catalog/pg_proc.dat
++++ b/src/include/catalog/pg_proc.dat
+@@ -2397,10 +2397,10 @@
+ { oid => '1181',
+ descr => 'age of a transaction ID, in transactions before current transaction',
+ proname => 'age', provolatile => 's', proparallel => 'r',
+- prorettype => 'int4', proargtypes => 'xid', prosrc => 'xid_age' },
++ prorettype => 'int8', proargtypes => 'xid', prosrc => 'xid_age' },
+ { oid => '3939',
+ descr => 'age of a multi-transaction ID, in multi-transactions before current multi-transaction',
+- proname => 'mxid_age', provolatile => 's', prorettype => 'int4',
++ proname => 'mxid_age', provolatile => 's', prorettype => 'int8',
+ proargtypes => 'xid', prosrc => 'mxid_age' },
+
+ { oid => '1188',
+@@ -2751,11 +2751,11 @@
+ prosrc => 'bpcharlen' },
+
+ { oid => '1319',
+- proname => 'xideqint4', proleakproof => 't', prorettype => 'bool',
+- proargtypes => 'xid int4', prosrc => 'xideq' },
++ proname => 'xideqint8', proleakproof => 't', prorettype => 'bool',
++ proargtypes => 'xid int8', prosrc => 'xideq' },
+ { oid => '3309',
+- proname => 'xidneqint4', proleakproof => 't', prorettype => 'bool',
+- proargtypes => 'xid int4', prosrc => 'xidneq' },
++ proname => 'xidneqint8', proleakproof => 't', prorettype => 'bool',
++ proargtypes => 'xid int8', prosrc => 'xidneq' },
+
+ { oid => '1326',
+ proname => 'interval_div', prorettype => 'interval',
+diff --git a/src/include/catalog/pg_type.dat b/src/include/catalog/pg_type.dat
+index f6110a850d..25eb0079cd 100644
+--- a/src/include/catalog/pg_type.dat
++++ b/src/include/catalog/pg_type.dat
+@@ -95,9 +95,9 @@
+ typinput => 'tidin', typoutput => 'tidout', typreceive => 'tidrecv',
+ typsend => 'tidsend', typalign => 's' },
+ { oid => '28', array_type_oid => '1011', descr => 'transaction id',
+- typname => 'xid', typlen => '4', typbyval => 't', typcategory => 'U',
++ typname => 'xid', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typcategory => 'U',
+ typinput => 'xidin', typoutput => 'xidout', typreceive => 'xidrecv',
+- typsend => 'xidsend', typalign => 'i' },
++ typsend => 'xidsend', typalign => 'x' },
+ { oid => '29', array_type_oid => '1012',
+ descr => 'command identifier type, sequence in transaction id',
+ typname => 'cid', typlen => '4', typbyval => 't', typcategory => 'U',
+diff --git a/src/include/catalog/pg_type.h b/src/include/catalog/pg_type.h
+index 508ba7b0f7..e9bb5c3b26 100644
+--- a/src/include/catalog/pg_type.h
++++ b/src/include/catalog/pg_type.h
+@@ -300,6 +300,11 @@ DECLARE_UNIQUE_INDEX(pg_type_typname_nsp_index, 2704, TypeNameNspIndexId, pg_typ
+ #define TYPALIGN_SHORT 's' /* short alignment (typically 2 bytes) */
+ #define TYPALIGN_INT 'i' /* int alignment (typically 4 bytes) */
+ #define TYPALIGN_DOUBLE 'd' /* double alignment (often 8 bytes) */
++/*
++ * We need to use alignment sutable for 8-byte XID values.
++ * On system like AIX double alignment (4 bytes) is not enough.
++ */
++#define TYPALIGN_XID 'x'
+
+ #define TYPSTORAGE_PLAIN 'p' /* type not prepared for toasting */
+ #define TYPSTORAGE_EXTERNAL 'e' /* toastable, don't try to compress */
+diff --git a/src/include/commands/vacuum.h b/src/include/commands/vacuum.h
+index 4af02940c5..121dec1079 100644
+--- a/src/include/commands/vacuum.h
++++ b/src/include/commands/vacuum.h
+@@ -215,12 +215,12 @@ typedef enum VacOptValue
+ */
+ typedef struct VacuumParams
+ {
+- bits32 options; /* bitmask of VACOPT_* */
+- int freeze_min_age; /* min freeze age, -1 to use default */
+- int freeze_table_age; /* age at which to scan whole table */
+- int multixact_freeze_min_age; /* min multixact freeze age, -1 to
++ bits32 options; /* bitmask of VacuumOption */
++ int64 freeze_min_age; /* min freeze age, -1 to use default */
++ int64 freeze_table_age; /* age at which to scan whole table */
++ int64 multixact_freeze_min_age; /* min multixact freeze age, -1 to
+ * use default */
+- int multixact_freeze_table_age; /* multixact age at which to scan
++ int64 multixact_freeze_table_age; /* multixact age at which to scan
+ * whole table */
+ bool is_wraparound; /* force a for-wraparound vacuum */
+ int log_min_duration; /* minimum execution threshold in ms at
+@@ -293,12 +293,12 @@ typedef struct VacDeadItems
+
+ /* GUC parameters */
+ extern PGDLLIMPORT int default_statistics_target; /* PGDLLIMPORT for PostGIS */
+-extern PGDLLIMPORT int vacuum_freeze_min_age;
+-extern PGDLLIMPORT int vacuum_freeze_table_age;
+-extern PGDLLIMPORT int vacuum_multixact_freeze_min_age;
+-extern PGDLLIMPORT int vacuum_multixact_freeze_table_age;
+-extern PGDLLIMPORT int vacuum_failsafe_age;
+-extern PGDLLIMPORT int vacuum_multixact_failsafe_age;
++extern PGDLLIMPORT int64 vacuum_freeze_min_age;
++extern PGDLLIMPORT int64 vacuum_freeze_table_age;
++extern PGDLLIMPORT int64 vacuum_multixact_freeze_min_age;
++extern PGDLLIMPORT int64 vacuum_multixact_freeze_table_age;
++extern PGDLLIMPORT int64 vacuum_failsafe_age;
++extern PGDLLIMPORT int64 vacuum_multixact_failsafe_age;
+
+ /*
+ * Maximum value for default_statistics_target and per-column statistics
+diff --git a/src/include/fmgr.h b/src/include/fmgr.h
+index edf61e53f3..3469edd160 100644
+--- a/src/include/fmgr.h
++++ b/src/include/fmgr.h
+@@ -281,6 +281,7 @@ extern struct varlena *pg_detoast_datum_packed(struct varlena *datum);
+ #define PG_GETARG_FLOAT4(n) DatumGetFloat4(PG_GETARG_DATUM(n))
+ #define PG_GETARG_FLOAT8(n) DatumGetFloat8(PG_GETARG_DATUM(n))
+ #define PG_GETARG_INT64(n) DatumGetInt64(PG_GETARG_DATUM(n))
++#define PG_GETARG_TRANSACTIONID(n) DatumGetTransactionId(PG_GETARG_DATUM(n))
+ /* use this if you want the raw, possibly-toasted input datum: */
+ #define PG_GETARG_RAW_VARLENA_P(n) ((struct varlena *) PG_GETARG_POINTER(n))
+ /* use this if you want the input datum de-toasted: */
+@@ -367,6 +368,7 @@ extern struct varlena *pg_detoast_datum_packed(struct varlena *datum);
+ #define PG_RETURN_FLOAT8(x) return Float8GetDatum(x)
+ #define PG_RETURN_INT64(x) return Int64GetDatum(x)
+ #define PG_RETURN_UINT64(x) return UInt64GetDatum(x)
++#define PG_RETURN_TRANSACTIONID(x) return TransactionIdGetDatum(x)
+ /* RETURN macros for other pass-by-ref types will typically look like this: */
+ #define PG_RETURN_BYTEA_P(x) PG_RETURN_POINTER(x)
+ #define PG_RETURN_TEXT_P(x) PG_RETURN_POINTER(x)
+diff --git a/src/include/nodes/pg_list.h b/src/include/nodes/pg_list.h
+index 529a382d28..a687303dae 100644
+--- a/src/include/nodes/pg_list.h
++++ b/src/include/nodes/pg_list.h
+@@ -46,6 +46,7 @@ typedef union ListCell
+ {
+ void *ptr_value;
+ int int_value;
++ int64 int64_value;
+ Oid oid_value;
+ TransactionId xid_value;
+ } ListCell;
+@@ -171,6 +172,7 @@ list_length(const List *l)
+ */
+ #define lfirst(lc) ((lc)->ptr_value)
+ #define lfirst_int(lc) ((lc)->int_value)
++#define lfirst_int64(lc) ((lc)->int64_value)
+ #define lfirst_oid(lc) ((lc)->oid_value)
+ #define lfirst_xid(lc) ((lc)->xid_value)
+ #define lfirst_node(type,lc) castNode(type, lfirst(lc))
+@@ -197,6 +199,7 @@ list_length(const List *l)
+
+ #define llast(l) lfirst(list_last_cell(l))
+ #define llast_int(l) lfirst_int(list_last_cell(l))
++#define llast_int64(l) lfirst_int64(list_last_cell(l))
+ #define llast_oid(l) lfirst_oid(list_last_cell(l))
+ #define llast_xid(l) lfirst_xid(list_last_cell(l))
+ #define llast_node(type,l) castNode(type, llast(l))
+@@ -559,6 +562,7 @@ extern List *list_make5_impl(NodeTag t, ListCell datum1, ListCell datum2,
+
+ extern pg_nodiscard List *lappend(List *list, void *datum);
+ extern pg_nodiscard List *lappend_int(List *list, int datum);
++extern pg_nodiscard List *lappend_int64(List *list, int64 datum);
+ extern pg_nodiscard List *lappend_oid(List *list, Oid datum);
+ extern pg_nodiscard List *lappend_xid(List *list, TransactionId datum);
+
+diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in
+index 5f16918243..4651e61aca 100644
+--- a/src/include/pg_config.h.in
++++ b/src/include/pg_config.h.in
+@@ -771,6 +771,9 @@
+ # endif
+ #endif
+
++/* Postgres Pro use 64bit xids */
++#undef XID_IS_64BIT
++
+ /* Size of a WAL file block. This need have no particular relation to BLCKSZ.
+ XLOG_BLCKSZ must be a power of 2, and if your system supports O_DIRECT I/O,
+ XLOG_BLCKSZ must be a multiple of the alignment requirement for direct-I/O
+diff --git a/src/include/port/pg_lfind.h b/src/include/port/pg_lfind.h
+index 59aa8245ed..f9e0ebaddc 100644
+--- a/src/include/port/pg_lfind.h
++++ b/src/include/port/pg_lfind.h
+@@ -81,35 +81,21 @@ pg_lfind8_le(uint8 key, uint8 *base, uint32 nelem)
+ }
+
+ /*
+- * pg_lfind32
++ * pg_lfind64
+ *
+ * Return true if there is an element in 'base' that equals 'key', otherwise
+ * return false.
+ */
+ static inline bool
+-pg_lfind32(uint32 key, uint32 *base, uint32 nelem)
++pg_lfind64(uint64 key, uint64 *base, uint32 nelem)
+ {
+- uint32 i = 0;
+-
+-#ifndef USE_NO_SIMD
+-
+- /*
+- * For better instruction-level parallelism, each loop iteration operates
+- * on a block of four registers. Testing for SSE2 has showed this is ~40%
+- * faster than using a block of two registers.
+- */
+- const Vector32 keys = vector32_broadcast(key); /* load copies of key */
+- const uint32 nelem_per_vector = sizeof(Vector32) / sizeof(uint32);
+- const uint32 nelem_per_iteration = 4 * nelem_per_vector;
+-
+- /* round down to multiple of elements per iteration */
+- const uint32 tail_idx = nelem & ~(nelem_per_iteration - 1);
+-
++ uint32 i,
++ iterations;
+ #if defined(USE_ASSERT_CHECKING)
+ bool assert_result = false;
+
+ /* pre-compute the result for assert checking */
+- for (i = 0; i < nelem; i++)
++ for (i = 0; i < nelem; ++i)
+ {
+ if (key == base[i])
+ {
+@@ -119,62 +105,127 @@ pg_lfind32(uint32 key, uint32 *base, uint32 nelem)
+ }
+ #endif
+
+- for (i = 0; i < tail_idx; i += nelem_per_iteration)
++#define UNROLL_FACTOR 8
++ StaticAssertStmt((UNROLL_FACTOR & (UNROLL_FACTOR - 1)) == 0,
++ "Loop unroll factor must be power of 2");
++ iterations = nelem & ~(UNROLL_FACTOR - 1);
++ for (i = 0; i < iterations; i += UNROLL_FACTOR)
+ {
+- Vector32 vals1,
+- vals2,
+- vals3,
+- vals4,
+- result1,
+- result2,
+- result3,
+- result4,
+- tmp1,
+- tmp2,
+- result;
+-
+- /* load the next block into 4 registers */
+- vector32_load(&vals1, &base[i]);
+- vector32_load(&vals2, &base[i + nelem_per_vector]);
+- vector32_load(&vals3, &base[i + nelem_per_vector * 2]);
+- vector32_load(&vals4, &base[i + nelem_per_vector * 3]);
+-
+- /* compare each value to the key */
+- result1 = vector32_eq(keys, vals1);
+- result2 = vector32_eq(keys, vals2);
+- result3 = vector32_eq(keys, vals3);
+- result4 = vector32_eq(keys, vals4);
+-
+- /* combine the results into a single variable */
+- tmp1 = vector32_or(result1, result2);
+- tmp2 = vector32_or(result3, result4);
+- result = vector32_or(tmp1, tmp2);
+-
+- /* see if there was a match */
+- if (vector32_is_highbit_set(result))
++ if (base[0] == key || base[1] == key || base[2] == key ||
++ base[3] == key || base[4] == key || base[5] == key ||
++ base[6] == key || base[7] == key)
+ {
++#if defined(USE_ASSERT_CHECKING)
+ Assert(assert_result == true);
++#endif
+ return true;
+ }
++ base += UNROLL_FACTOR;
+ }
+-#endif /* ! USE_NO_SIMD */
+
+ /* Process the remaining elements one at a time. */
+- for (; i < nelem; i++)
++ iterations = nelem & (UNROLL_FACTOR - 1);
++ for (i = 0; i < iterations; ++i)
+ {
+- if (key == base[i])
++ if (key == *base++)
+ {
+-#ifndef USE_NO_SIMD
++#if defined(USE_ASSERT_CHECKING)
+ Assert(assert_result == true);
+ #endif
+ return true;
+ }
+ }
+
+-#ifndef USE_NO_SIMD
++#if defined(USE_ASSERT_CHECKING)
+ Assert(assert_result == false);
+ #endif
+ return false;
++// uint32 i = 0;
++//
++//#ifndef USE_NO_SIMD
++//
++// /*
++// * For better instruction-level parallelism, each loop iteration operates
++// * on a block of four registers. Testing for SSE2 has showed this is ~40%
++// * faster than using a block of two registers.
++// */
++// const Vector32 keys = vector32_broadcast(key); /* load copies of key */
++// const uint32 nelem_per_vector = sizeof(Vector32) / sizeof(uint32);
++// const uint32 nelem_per_iteration = 4 * nelem_per_vector;
++//
++// /* round down to multiple of elements per iteration */
++// const uint32 tail_idx = nelem & ~(nelem_per_iteration - 1);
++//
++//#if defined(USE_ASSERT_CHECKING)
++// bool assert_result = false;
++//
++// /* pre-compute the result for assert checking */
++// for (i = 0; i < nelem; i++)
++// {
++// if (key == base[i])
++// {
++// assert_result = true;
++// break;
++// }
++// }
++//#endif
++//
++// for (i = 0; i < tail_idx; i += nelem_per_iteration)
++// {
++// Vector32 vals1,
++// vals2,
++// vals3,
++// vals4,
++// result1,
++// result2,
++// result3,
++// result4,
++// tmp1,
++// tmp2,
++// result;
++//
++// /* load the next block into 4 registers */
++// vector32_load(&vals1, &base[i]);
++// vector32_load(&vals2, &base[i + nelem_per_vector]);
++// vector32_load(&vals3, &base[i + nelem_per_vector * 2]);
++// vector32_load(&vals4, &base[i + nelem_per_vector * 3]);
++//
++// /* compare each value to the key */
++// result1 = vector32_eq(keys, vals1);
++// result2 = vector32_eq(keys, vals2);
++// result3 = vector32_eq(keys, vals3);
++// result4 = vector32_eq(keys, vals4);
++//
++// /* combine the results into a single variable */
++// tmp1 = vector32_or(result1, result2);
++// tmp2 = vector32_or(result3, result4);
++// result = vector32_or(tmp1, tmp2);
++//
++// /* see if there was a match */
++// if (vector32_is_highbit_set(result))
++// {
++// Assert(assert_result == true);
++// return true;
++// }
++// }
++//#endif /* ! USE_NO_SIMD */
++//
++// /* Process the remaining elements one at a time. */
++// for (; i < nelem; i++)
++// {
++// if (key == base[i])
++// {
++//#ifndef USE_NO_SIMD
++// Assert(assert_result == true);
++//#endif
++// return true;
++// }
++// }
++//
++//#ifndef USE_NO_SIMD
++// Assert(assert_result == false);
++//#endif
++// return false;
+ }
+
+ #endif /* PG_LFIND_H */
+diff --git a/src/include/postgres.h b/src/include/postgres.h
+index 8a028ff789..5baa6b278c 100644
+--- a/src/include/postgres.h
++++ b/src/include/postgres.h
+@@ -80,6 +80,9 @@ typedef struct NullableDatum
+
+ #define SIZEOF_DATUM SIZEOF_VOID_P
+
++static uint64 DatumGetUInt64(Datum X);
++static Datum UInt64GetDatum(uint64 X);
++
+ /*
+ * DatumGetBool
+ * Returns boolean value of a datum.
+@@ -261,7 +264,7 @@ ObjectIdGetDatum(Oid X)
+ static inline TransactionId
+ DatumGetTransactionId(Datum X)
+ {
+- return (TransactionId) X;
++ return DatumGetUInt64(X);
+ }
+
+ /*
+@@ -271,7 +274,7 @@ DatumGetTransactionId(Datum X)
+ static inline Datum
+ TransactionIdGetDatum(TransactionId X)
+ {
+- return (Datum) X;
++ return UInt64GetDatum(X);
+ }
+
+ /*
+@@ -281,7 +284,7 @@ TransactionIdGetDatum(TransactionId X)
+ static inline Datum
+ MultiXactIdGetDatum(MultiXactId X)
+ {
+- return (Datum) X;
++ return UInt64GetDatum(X);
+ }
+
+ /*
+diff --git a/src/include/postmaster/autovacuum.h b/src/include/postmaster/autovacuum.h
+index c9ef31ae66..55d0615746 100644
+--- a/src/include/postmaster/autovacuum.h
++++ b/src/include/postmaster/autovacuum.h
+@@ -37,8 +37,8 @@ extern PGDLLIMPORT int autovacuum_vac_ins_thresh;
+ extern PGDLLIMPORT double autovacuum_vac_ins_scale;
+ extern PGDLLIMPORT int autovacuum_anl_thresh;
+ extern PGDLLIMPORT double autovacuum_anl_scale;
+-extern PGDLLIMPORT int autovacuum_freeze_max_age;
+-extern PGDLLIMPORT int autovacuum_multixact_freeze_max_age;
++extern PGDLLIMPORT int64 autovacuum_freeze_max_age;
++extern PGDLLIMPORT int64 autovacuum_multixact_freeze_max_age;
+ extern PGDLLIMPORT double autovacuum_vac_cost_delay;
+ extern PGDLLIMPORT int autovacuum_vac_cost_limit;
+
+diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
+index 2c4fd92e39..c34040bd2c 100644
+--- a/src/include/storage/buf_internals.h
++++ b/src/include/storage/buf_internals.h
+@@ -42,10 +42,10 @@
+ */
+ #define BUF_REFCOUNT_ONE 1
+ #define BUF_REFCOUNT_MASK ((1U << 18) - 1)
+-#define BUF_USAGECOUNT_MASK 0x003C0000U
++#define BUF_USAGECOUNT_MASK 0x001C0000U
+ #define BUF_USAGECOUNT_ONE (1U << 18)
+ #define BUF_USAGECOUNT_SHIFT 18
+-#define BUF_FLAG_MASK 0xFFC00000U
++#define BUF_FLAG_MASK 0xFFE00000U
+
+ /* Get refcount and usagecount from buffer state */
+ #define BUF_STATE_GET_REFCOUNT(state) ((state) & BUF_REFCOUNT_MASK)
+@@ -57,6 +57,7 @@
+ * Note: BM_TAG_VALID essentially means that there is a buffer hashtable
+ * entry associated with the buffer's tag.
+ */
++#define BM_CONVERTED (1U << 21) /* buffer were converted to 64xid */
+ #define BM_LOCKED (1U << 22) /* buffer header is locked */
+ #define BM_DIRTY (1U << 23) /* data needs writing */
+ #define BM_VALID (1U << 24) /* data is valid */
+diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
+index 41e26d3e20..101e43d799 100644
+--- a/src/include/storage/bufmgr.h
++++ b/src/include/storage/bufmgr.h
+@@ -239,8 +239,12 @@ extern void BufferGetTag(Buffer buffer, RelFileLocator *rlocator,
+ ForkNumber *forknum, BlockNumber *blknum);
+
+ extern void MarkBufferDirtyHint(Buffer buffer, bool buffer_std);
++extern void MarkBufferConverted(Buffer buffer, bool converted);
++extern bool IsBufferConverted(Buffer buffer);
+
+ extern void UnlockBuffers(void);
++extern bool IsBufferLocked(Buffer buffer);
++extern bool IsBufferLockedExclusive(Buffer buffer);
+ extern void LockBuffer(Buffer buffer, int mode);
+ extern bool ConditionalLockBuffer(Buffer buffer);
+ extern void LockBufferForCleanup(Buffer buffer);
+@@ -266,6 +270,8 @@ extern int GetAccessStrategyBufferCount(BufferAccessStrategy strategy);
+
+ extern void FreeAccessStrategy(BufferAccessStrategy strategy);
+
++/* old tuple format support */
++extern void convert_page(Relation rel, Page orig_page, Buffer buf, BlockNumber blkno);
+
+ /* inline functions */
+
+diff --git a/src/include/storage/bufpage.h b/src/include/storage/bufpage.h
+index 424ecba028..7b8ddde76a 100644
+--- a/src/include/storage/bufpage.h
++++ b/src/include/storage/bufpage.h
+@@ -14,10 +14,13 @@
+ #ifndef BUFPAGE_H
+ #define BUFPAGE_H
+
++#include "access/transam.h"
+ #include "access/xlogdefs.h"
+ #include "storage/block.h"
+ #include "storage/item.h"
+ #include "storage/off.h"
++#include "postgres.h"
++#include "utils/rel.h"
+
+ /*
+ * A postgres disk page is an abstraction layered on top of a postgres
+@@ -163,12 +166,41 @@ typedef struct PageHeaderData
+ LocationIndex pd_upper; /* offset to end of free space */
+ LocationIndex pd_special; /* offset to start of special space */
+ uint16 pd_pagesize_version;
+- TransactionId pd_prune_xid; /* oldest prunable XID, or zero if none */
++ ShortTransactionId pd_prune_xid; /* oldest prunable XID, or zero if
++ * none */
+ ItemIdData pd_linp[FLEXIBLE_ARRAY_MEMBER]; /* line pointer array */
+ } PageHeaderData;
+
+ typedef PageHeaderData *PageHeader;
+
++
++/*
++ * HeapPageSpecialData -- data that stored at the end of each heap page.
++ *
++ * pd_xid_base - base value for transaction IDs on page
++ * pd_multi_base - base value for multixact IDs on page
++ *
++ * pd_xid_base and pd_multi_base are base values for calculation of transaction
++ * identifiers from t_xmin and t_xmax in each heap tuple header on the page.
++ */
++typedef struct HeapPageSpecialData
++{
++ TransactionId pd_xid_base; /* base value for transaction IDs on page */
++ TransactionId pd_multi_base; /* base value for multixact IDs on page */
++} HeapPageSpecialData;
++
++typedef HeapPageSpecialData *HeapPageSpecial;
++
++typedef struct ToastPageSpecialData
++{
++ TransactionId pd_xid_base; /* base value for transaction IDs on page */
++} ToastPageSpecialData;
++
++typedef ToastPageSpecialData *ToastPageSpecial;
++
++extern PGDLLIMPORT HeapPageSpecial heapDoubleXmaxSpecial;
++extern PGDLLIMPORT ToastPageSpecial toastDoubleXmaxSpecial;
++
+ /*
+ * pd_flags contains the following flag bits. Undefined bits are initialized
+ * to zero and may be used in the future.
+@@ -200,7 +232,7 @@ typedef PageHeaderData *PageHeader;
+ * As of Release 9.3, the checksum version must also be considered when
+ * handling pages.
+ */
+-#define PG_PAGE_LAYOUT_VERSION 4
++#define PG_PAGE_LAYOUT_VERSION 5
+ #define PG_DATA_CHECKSUM_VERSION 1
+
+ /* ----------------------------------------------------------------
+@@ -440,18 +472,177 @@ PageClearAllVisible(Page page)
+ }
+
+ /*
+- * These two require "access/transam.h", so left as macros.
++ * Check if page is in "double xmax" format.
+ */
+-#define PageSetPrunable(page, xid) \
+-do { \
+- Assert(TransactionIdIsNormal(xid)); \
+- if (!TransactionIdIsValid(((PageHeader) (page))->pd_prune_xid) || \
+- TransactionIdPrecedes(xid, ((PageHeader) (page))->pd_prune_xid)) \
+- ((PageHeader) (page))->pd_prune_xid = (xid); \
+-} while (0)
+-#define PageClearPrunable(page) \
+- (((PageHeader) (page))->pd_prune_xid = InvalidTransactionId)
++static inline bool
++HeapPageIsDoubleXmax(Page page)
++{
++ return ((PageHeader) (page))->pd_special == BLCKSZ;
++}
+
++/*
++ * Get pointer to HeapPageSpecialData.
++ *
++ * Can be used for non-consistent reads from non-locked pages.
++ *
++ * Return doubleXmaxSpecial when pd_special == BLCKSZ (i.e. "double xmax"
++ * format).
++ */
++static inline HeapPageSpecial
++HeapPageGetSpecialNoAssert(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return heapDoubleXmaxSpecial;
++
++ return (HeapPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Get pointer to ToastPageSpecialData.
++ *
++ * Can be used for non-consistent reads from non-locked pages.
++ *
++ * Return doubleXmaxSpecial when pd_special == BLCKSZ (i.e. "double xmax"
++ * format).
++ */
++static inline ToastPageSpecial
++ToastPageGetSpecialNoAssert(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return toastDoubleXmaxSpecial;
++
++ return (ToastPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Wrapper for HeapPageGetSpecialNoAssert for general use.
++ */
++static inline HeapPageSpecial
++HeapPageGetSpecial(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return heapDoubleXmaxSpecial;
++
++ Assert(((PageHeader) page)->pd_special ==
++ BLCKSZ - MAXALIGN(sizeof(HeapPageSpecialData)));
++
++ return (HeapPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Wrapper for ToastPageGetSpecialNoAssert for general use.
++ */
++static inline ToastPageSpecial
++ToastPageGetSpecial(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return toastDoubleXmaxSpecial;
++
++ Assert(((PageHeader) page)->pd_special ==
++ BLCKSZ - MAXALIGN(sizeof(ToastPageSpecialData)));
++
++ return (ToastPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Set pd_prune_xid.
++ */
++static inline void
++HeapPageSetPruneXid(Page page, TransactionId xid, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return;
++
++ if (!TransactionIdIsNormal(xid))
++ {
++ ((PageHeader) (page))->pd_prune_xid = xid;
++ return;
++ }
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ ((PageHeader) (page))->pd_prune_xid = NormalTransactionIdToShort(base, xid);
++ Assert(((PageHeader) (page))->pd_prune_xid <= MaxShortTransactionId);
++}
++
++static inline void
++ToastPageSetPruneXid(Page page, TransactionId xid)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return;
++
++ if (!TransactionIdIsNormal(xid))
++ {
++ ((PageHeader) (page))->pd_prune_xid = xid;
++ return;
++ }
++
++ ((PageHeader) (page))->pd_prune_xid =
++ NormalTransactionIdToShort(ToastPageGetSpecial(page)->pd_xid_base, (xid));
++
++ Assert(((PageHeader) (page))->pd_prune_xid <= MaxShortTransactionId);
++}
++
++/*
++ * Get pd_prune_xid from locked page.
++ */
++static inline TransactionId
++HeapPageGetPruneXid(Page page, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return ((PageHeader) (page))->pd_prune_xid;
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ return ShortTransactionIdToNormal(base,
++ ((PageHeader) (page))->pd_prune_xid);
++}
++
++static inline void
++PageSetPrunable(Page page, TransactionId xid, bool is_toast)
++{
++ TransactionId prune_xid;
++
++ Assert(TransactionIdIsNormal(xid));
++
++ if (HeapPageIsDoubleXmax(page))
++ return;
++
++ prune_xid = HeapPageGetPruneXid(page, is_toast);
++ if ((!TransactionIdIsValid(prune_xid) ||
++ TransactionIdPrecedes(xid, prune_xid)))
++ {
++ HeapPageSetPruneXid(page, xid, is_toast);
++ }
++}
++
++/*
++ * Get pd_prune_xid from non-locked page. May return invalid value, but doen't
++ * causes assert failures.
++ */
++static inline TransactionId
++HeapPageGetPruneXidNoAssert(Page page, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return ((PageHeader) (page))->pd_prune_xid;
++
++ base = is_toast ? ToastPageGetSpecialNoAssert(page)->pd_xid_base :
++ HeapPageGetSpecialNoAssert(page)->pd_xid_base;
++ return ShortTransactionIdToNormal(base,
++ ((PageHeader) (page))->pd_prune_xid);
++}
+
+ /* ----------------------------------------------------------------
+ * extern declarations
+@@ -485,6 +676,21 @@ do { \
+ StaticAssertDecl(BLCKSZ == ((BLCKSZ / sizeof(size_t)) * sizeof(size_t)),
+ "BLCKSZ has to be a multiple of sizeof(size_t)");
+
++/*
++ * Tuple defrag support for PageRepairFragmentation and PageIndexMultiDelete
++ */
++typedef struct ItemIdCompactData
++{
++ uint16 offsetindex; /* linp array index */
++ int16 itemoff; /* page offset of item data */
++ uint16 alignedlen; /* MAXALIGN(item data len) */
++} ItemIdCompactData;
++
++typedef ItemIdCompactData *ItemIdCompact;
++typedef RelationData *Relation;
++
++extern int itemoffcompare(const void *item1, const void *item2);
++
+ extern void PageInit(Page page, Size pageSize, Size specialSize);
+ extern bool PageIsVerifiedExtended(Page page, BlockNumber blkno, int flags);
+ extern OffsetNumber PageAddItemExtended(Page page, Item item, Size size,
+@@ -493,7 +699,7 @@ extern Page PageGetTempPage(Page page);
+ extern Page PageGetTempPageCopy(Page page);
+ extern Page PageGetTempPageCopySpecial(Page page);
+ extern void PageRestoreTempPage(Page tempPage, Page oldPage);
+-extern void PageRepairFragmentation(Page page);
++extern void PageRepairFragmentation(Page page, bool is_toast);
+ extern void PageTruncateLinePointerArray(Page page);
+ extern Size PageGetFreeSpace(Page page);
+ extern Size PageGetFreeSpaceForMultipleTuples(Page page, int ntups);
+diff --git a/src/include/storage/itemid.h b/src/include/storage/itemid.h
+index e5cfb8c3cc..e24e60981b 100644
+--- a/src/include/storage/itemid.h
++++ b/src/include/storage/itemid.h
+@@ -78,6 +78,8 @@ typedef uint16 ItemLength;
+ #define ItemIdGetRedirect(itemId) \
+ ((itemId)->lp_off)
+
++#define ItemIdGetTupleEnd(itemId) \
++ (MAXALIGN(ItemIdGetLength((itemId))) + ItemIdGetOffset((itemId)))
+ /*
+ * ItemIdIsValid
+ * True iff item identifier is valid.
+diff --git a/src/include/storage/lock.h b/src/include/storage/lock.h
+index 590c026b5b..0e58f4ccad 100644
+--- a/src/include/storage/lock.h
++++ b/src/include/storage/lock.h
+@@ -224,8 +224,8 @@ typedef struct LOCKTAG
+
+ /* ID info for a transaction is its TransactionId */
+ #define SET_LOCKTAG_TRANSACTION(locktag,xid) \
+- ((locktag).locktag_field1 = (xid), \
+- (locktag).locktag_field2 = 0, \
++ ((locktag).locktag_field1 = (uint32)((xid) & 0xFFFFFFFF), \
++ (locktag).locktag_field2 = (uint32)((xid) >> 32), \
+ (locktag).locktag_field3 = 0, \
+ (locktag).locktag_field4 = 0, \
+ (locktag).locktag_type = LOCKTAG_TRANSACTION, \
+@@ -234,8 +234,8 @@ typedef struct LOCKTAG
+ /* ID info for a virtual transaction is its VirtualTransactionId */
+ #define SET_LOCKTAG_VIRTUALTRANSACTION(locktag,vxid) \
+ ((locktag).locktag_field1 = (vxid).backendId, \
+- (locktag).locktag_field2 = (vxid).localTransactionId, \
+- (locktag).locktag_field3 = 0, \
++ (locktag).locktag_field2 = (uint32)((vxid).localTransactionId & 0xFFFFFFFF), \
++ (locktag).locktag_field3 = (uint32)((vxid).localTransactionId >> 32), \
+ (locktag).locktag_field4 = 0, \
+ (locktag).locktag_type = LOCKTAG_VIRTUALTRANSACTION, \
+ (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)
+@@ -245,9 +245,9 @@ typedef struct LOCKTAG
+ * its speculative insert counter.
+ */
+ #define SET_LOCKTAG_SPECULATIVE_INSERTION(locktag,xid,token) \
+- ((locktag).locktag_field1 = (xid), \
+- (locktag).locktag_field2 = (token), \
+- (locktag).locktag_field3 = 0, \
++ ((locktag).locktag_field1 = (uint32)((xid) & 0xFFFFFFFF), \
++ (locktag).locktag_field2 = (uint32)((xid) >> 32), \
++ (locktag).locktag_field3 = (token), \
+ (locktag).locktag_field4 = 0, \
+ (locktag).locktag_type = LOCKTAG_SPECULATIVE_TOKEN, \
+ (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)
+diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h
+index 4b25961249..371b7ffefa 100644
+--- a/src/include/storage/proc.h
++++ b/src/include/storage/proc.h
+@@ -17,6 +17,7 @@
+ #include "access/clog.h"
+ #include "access/xlogdefs.h"
+ #include "lib/ilist.h"
++#include "port/atomics.h"
+ #include "storage/latch.h"
+ #include "storage/lock.h"
+ #include "storage/pg_sema.h"
+@@ -176,12 +177,12 @@ struct PGPROC
+ Latch procLatch; /* generic latch for process */
+
+
+- TransactionId xid; /* id of top-level transaction currently being
++ pg_atomic_uint64 xid; /* id of top-level transaction currently being
+ * executed by this proc, if running and XID
+ * is assigned; else InvalidTransactionId.
+ * mirrored in ProcGlobal->xids[pgxactoff] */
+
+- TransactionId xmin; /* minimal running XID as it was when we were
++ pg_atomic_uint64 xmin; /* minimal running XID as it was when we were
+ * starting our xact, excluding LAZY VACUUM:
+ * vacuum must not remove tuples deleted by
+ * xid >= xmin ! */
+@@ -368,7 +369,7 @@ typedef struct PROC_HDR
+ PGPROC *allProcs;
+
+ /* Array mirroring PGPROC.xid for each PGPROC currently in the procarray */
+- TransactionId *xids;
++ pg_atomic_uint64 *xids;
+
+ /*
+ * Array mirroring PGPROC.subxidStatus for each PGPROC currently in the
+diff --git a/src/include/utils/combocid.h b/src/include/utils/combocid.h
+index 2b496ee634..3f49819468 100644
+--- a/src/include/utils/combocid.h
++++ b/src/include/utils/combocid.h
+@@ -15,7 +15,7 @@
+ #define COMBOCID_H
+
+ /*
+- * HeapTupleHeaderGetCmin and HeapTupleHeaderGetCmax function prototypes
++ * HeapTupleGetCmin and HeapTupleGetCmax function prototypes
+ * are in access/htup.h, because that's where the macro definitions that
+ * those functions replaced used to be.
+ */
+diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h
+index 0ad613c4b8..1d78a56161 100644
+--- a/src/include/utils/rel.h
++++ b/src/include/utils/rel.h
+@@ -311,12 +311,12 @@ typedef struct AutoVacOpts
+ int vacuum_ins_threshold;
+ int analyze_threshold;
+ int vacuum_cost_limit;
+- int freeze_min_age;
+- int freeze_max_age;
+- int freeze_table_age;
+- int multixact_freeze_min_age;
+- int multixact_freeze_max_age;
+- int multixact_freeze_table_age;
++ int64 freeze_min_age;
++ int64 freeze_max_age;
++ int64 freeze_table_age;
++ int64 multixact_freeze_min_age;
++ int64 multixact_freeze_max_age;
++ int64 multixact_freeze_table_age;
+ int log_min_duration;
+ float8 vacuum_cost_delay;
+ float8 vacuum_scale_factor;
+diff --git a/src/include/utils/xid8.h b/src/include/utils/xid8.h
+index 2f5e14baad..6401904ad2 100644
+--- a/src/include/utils/xid8.h
++++ b/src/include/utils/xid8.h
+@@ -17,13 +17,13 @@
+ static inline FullTransactionId
+ DatumGetFullTransactionId(Datum X)
+ {
+- return FullTransactionIdFromU64(DatumGetUInt64(X));
++ return FullTransactionIdFromXid(DatumGetUInt64(X));
+ }
+
+ static inline Datum
+ FullTransactionIdGetDatum(FullTransactionId X)
+ {
+- return UInt64GetDatum(U64FromFullTransactionId(X));
++ return UInt64GetDatum(XidFromFullTransactionId(X));
+ }
+
+ #define PG_GETARG_FULLTRANSACTIONID(X) DatumGetFullTransactionId(PG_GETARG_DATUM(X))
+diff --git a/src/pl/plperl/plperl.c b/src/pl/plperl/plperl.c
+index d68ad7be34..650d045b07 100644
+--- a/src/pl/plperl/plperl.c
++++ b/src/pl/plperl/plperl.c
+@@ -2680,7 +2680,7 @@ validate_plperl_function(plperl_proc_ptr *proc_ptr, HeapTuple procTup)
+ * This is needed because CREATE OR REPLACE FUNCTION can modify the
+ * function's pg_proc entry without changing its OID.
+ ************************************************************/
+- uptodate = (prodesc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ uptodate = (prodesc->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&prodesc->fn_tid, &procTup->t_self));
+
+ if (uptodate)
+@@ -2804,7 +2804,7 @@ compile_plperl_function(Oid fn_oid, bool is_trigger, bool is_event_trigger)
+ MemoryContextSetIdentifier(proc_cxt, prodesc->proname);
+ prodesc->fn_cxt = proc_cxt;
+ prodesc->fn_refcount = 0;
+- prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ prodesc->fn_xmin = HeapTupleGetRawXmin(procTup);
+ prodesc->fn_tid = procTup->t_self;
+ prodesc->nargs = procStruct->pronargs;
+ prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo));
+diff --git a/src/pl/plpgsql/src/pl_comp.c b/src/pl/plpgsql/src/pl_comp.c
+index a341cde2c1..7686841265 100644
+--- a/src/pl/plpgsql/src/pl_comp.c
++++ b/src/pl/plpgsql/src/pl_comp.c
+@@ -171,7 +171,7 @@ recheck:
+ if (function)
+ {
+ /* We have a compiled function, but is it still valid? */
+- if (function->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ if (function->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&function->fn_tid, &procTup->t_self))
+ function_valid = true;
+ else
+@@ -344,7 +344,7 @@ do_compile(FunctionCallInfo fcinfo,
+ function->fn_signature = format_procedure(fcinfo->flinfo->fn_oid);
+ MemoryContextSetIdentifier(func_cxt, function->fn_signature);
+ function->fn_oid = fcinfo->flinfo->fn_oid;
+- function->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ function->fn_xmin = HeapTupleGetRawXmin(procTup);
+ function->fn_tid = procTup->t_self;
+ function->fn_input_collation = fcinfo->fncollation;
+ function->fn_cxt = func_cxt;
+diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c
+index f8c7f48747..2ae9a58484 100644
+--- a/src/pl/plpgsql/src/pl_exec.c
++++ b/src/pl/plpgsql/src/pl_exec.c
+@@ -7394,6 +7394,7 @@ deconstruct_composite_datum(Datum value, HeapTupleData *tmptup)
+ tmptup->t_len = HeapTupleHeaderGetDatumLength(td);
+ ItemPointerSetInvalid(&(tmptup->t_self));
+ tmptup->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tmptup);
+ tmptup->t_data = td;
+
+ /* Extract rowtype info and find a tupdesc */
+@@ -7568,6 +7569,7 @@ exec_move_row_from_datum(PLpgSQL_execstate *estate,
+ tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tmptup);
+ tmptup.t_data = td;
+
+ /* Extract rowtype info */
+diff --git a/src/pl/plpython/plpy_procedure.c b/src/pl/plpython/plpy_procedure.c
+index 79b6ef6a44..f89d909104 100644
+--- a/src/pl/plpython/plpy_procedure.c
++++ b/src/pl/plpython/plpy_procedure.c
+@@ -178,7 +178,7 @@ PLy_procedure_create(HeapTuple procTup, Oid fn_oid, bool is_trigger)
+ proc->proname = pstrdup(NameStr(procStruct->proname));
+ MemoryContextSetIdentifier(cxt, proc->proname);
+ proc->pyname = pstrdup(procName);
+- proc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ proc->fn_xmin = HeapTupleGetRawXmin(procTup);
+ proc->fn_tid = procTup->t_self;
+ proc->fn_readonly = (procStruct->provolatile != PROVOLATILE_VOLATILE);
+ proc->is_setof = procStruct->proretset;
+@@ -417,7 +417,7 @@ PLy_procedure_valid(PLyProcedure *proc, HeapTuple procTup)
+ return false;
+
+ /* If the pg_proc tuple has changed, it's not valid */
+- if (!(proc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ if (!(proc->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&proc->fn_tid, &procTup->t_self)))
+ return false;
+
+diff --git a/src/pl/tcl/pltcl.c b/src/pl/tcl/pltcl.c
+index 6187e15781..485331a134 100644
+--- a/src/pl/tcl/pltcl.c
++++ b/src/pl/tcl/pltcl.c
+@@ -1428,7 +1428,7 @@ compile_pltcl_function(Oid fn_oid, Oid tgreloid,
+ * function's pg_proc entry without changing its OID.
+ ************************************************************/
+ if (prodesc != NULL &&
+- prodesc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ prodesc->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&prodesc->fn_tid, &procTup->t_self))
+ {
+ /* It's still up-to-date, so we can use it */
+@@ -1494,7 +1494,7 @@ compile_pltcl_function(Oid fn_oid, Oid tgreloid,
+ prodesc->internal_proname = pstrdup(internal_proname);
+ prodesc->fn_cxt = proc_cxt;
+ prodesc->fn_refcount = 0;
+- prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ prodesc->fn_xmin = HeapTupleGetRawXmin(procTup);
+ prodesc->fn_tid = procTup->t_self;
+ prodesc->nargs = procStruct->pronargs;
+ prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo));
+diff --git a/src/test/Makefile b/src/test/Makefile
+index dbd3192874..8e0f39289e 100644
+--- a/src/test/Makefile
++++ b/src/test/Makefile
+@@ -12,7 +12,8 @@ subdir = src/test
+ top_builddir = ../..
+ include $(top_builddir)/src/Makefile.global
+
+-SUBDIRS = perl regress isolation modules authentication recovery subscription
++SUBDIRS = perl regress isolation modules authentication recovery subscription \
++ xid-64
+
+ ifeq ($(with_icu),yes)
+ SUBDIRS += icu
+diff --git a/src/test/meson.build b/src/test/meson.build
+index 5f3c9c2ba2..e9f504c000 100644
+--- a/src/test/meson.build
++++ b/src/test/meson.build
+@@ -7,6 +7,7 @@ subdir('authentication')
+ subdir('recovery')
+ subdir('subscription')
+ subdir('modules')
++subdir('xid-64')
+
+ if ssl.found()
+ subdir('ssl')
+diff --git a/src/test/modules/test_lfind/test_lfind.c b/src/test/modules/test_lfind/test_lfind.c
+index e2e8b7389f..46553cbe89 100644
+--- a/src/test/modules/test_lfind/test_lfind.c
++++ b/src/test/modules/test_lfind/test_lfind.c
+@@ -120,29 +120,29 @@ Datum
+ test_lfind32(PG_FUNCTION_ARGS)
+ {
+ #define TEST_ARRAY_SIZE 135
+- uint32 test_array[TEST_ARRAY_SIZE] = {0};
++ uint64 test_array[TEST_ARRAY_SIZE] = {0};
+
+ test_array[8] = 1;
+ test_array[64] = 2;
+ test_array[TEST_ARRAY_SIZE - 1] = 3;
+
+- if (pg_lfind32(1, test_array, 4))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
+- if (!pg_lfind32(1, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() did not find existing element");
++ if (pg_lfind64(1, test_array, 4))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
++ if (!pg_lfind64(1, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() did not find existing element");
+
+- if (pg_lfind32(2, test_array, 32))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
+- if (!pg_lfind32(2, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() did not find existing element");
++ if (pg_lfind64(2, test_array, 32))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
++ if (!pg_lfind64(2, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() did not find existing element");
+
+- if (pg_lfind32(3, test_array, 96))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
+- if (!pg_lfind32(3, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() did not find existing element");
++ if (pg_lfind64(3, test_array, 96))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
++ if (!pg_lfind64(3, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() did not find existing element");
+
+- if (pg_lfind32(4, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
++ if (pg_lfind64(4, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
+
+ PG_RETURN_VOID();
+ }
+diff --git a/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm b/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
+index e34dfb9243..bcf4ffac55 100644
+--- a/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
++++ b/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
+@@ -119,6 +119,10 @@ sub adjust_database_contents
+ 'drop table public.gtest_normal_child2');
+ }
+
++ # Can't upgrade xid type
++ _add_st($result, 'regression',
++ 'alter table public.tab_core_types drop column xid');
++
+ # stuff not supported from release 14
+ if ($old_version < 14)
+ {
+diff --git a/src/test/recovery/t/003_recovery_targets.pl b/src/test/recovery/t/003_recovery_targets.pl
+index e882ce2077..1f2d710cf1 100644
+--- a/src/test/recovery/t/003_recovery_targets.pl
++++ b/src/test/recovery/t/003_recovery_targets.pl
+@@ -57,7 +57,7 @@ $node_primary->init(has_archiving => 1, allows_streaming => 1);
+
+ # Bump the transaction ID epoch. This is useful to stress the portability
+ # of recovery_target_xid parsing.
+-system_or_bail('pg_resetwal', '--epoch', '1', $node_primary->data_dir);
++system_or_bail('pg_resetwal', $node_primary->data_dir);
+
+ # Start it
+ $node_primary->start;
+diff --git a/src/test/recovery/t/039_end_of_wal.pl b/src/test/recovery/t/039_end_of_wal.pl
+index d2bf062bb2..d4aca99995 100644
+--- a/src/test/recovery/t/039_end_of_wal.pl
++++ b/src/test/recovery/t/039_end_of_wal.pl
+@@ -21,7 +21,7 @@ use integer; # causes / operator to use integer math
+ my $BIG_ENDIAN = pack("L", 0x12345678) eq pack("N", 0x12345678);
+
+ # Header size of record header.
+-my $RECORD_HEADER_SIZE = 24;
++my $RECORD_HEADER_SIZE = 26;
+
+ # Fields retrieved from code headers.
+ my @scan_result = scan_server_header('access/xlog_internal.h',
+@@ -131,17 +131,21 @@ sub build_record_header
+
+ # This needs to follow the structure XLogRecord:
+ # I for xl_tot_len
+- # I for xl_xid
++ # I for xl_crc
++ # II for xl_xid
+ # II for xl_prev
+ # C for xl_info
+ # C for xl_rmid
+- # BB for two bytes of padding
+- # I for xl_crc
+- return pack("IIIICCBBI",
+- $xl_tot_len, $xl_xid,
++ # BBBBBB for two bytes of padding
++ return pack("IIIIIICCBBBBBB",
++ $xl_tot_len,
++ $xl_crc,
++ $BIG_ENDIAN ? 0 : $xl_xid,
++ $BIG_ENDIAN ? $xl_xid : 0,
+ $BIG_ENDIAN ? 0 : $xl_prev,
+ $BIG_ENDIAN ? $xl_prev : 0,
+- $xl_info, $xl_rmid, 0, 0, $xl_crc);
++ $xl_info, $xl_rmid,
++ 0, 0, 0, 0, 0, 0);
+ }
+
+ # Build a fake WAL page header, based on the data given by the caller
+@@ -265,7 +269,7 @@ $node->stop('immediate');
+ my $log_size = -s $node->logfile;
+ $node->start;
+ ok( $node->log_contains(
+- "invalid record length at .*: expected at least 24, got 0", $log_size
++ "invalid record length at .*: expected at least 26, got 0", $log_size
+ ),
+ "xl_tot_len zero");
+
+@@ -277,7 +281,7 @@ write_wal($node, $TLI, $end_lsn, build_record_header(23));
+ $log_size = -s $node->logfile;
+ $node->start;
+ ok( $node->log_contains(
+- "invalid record length at .*: expected at least 24, got 23",
++ "invalid record length at .*: expected at least 26, got 23",
+ $log_size),
+ "xl_tot_len short");
+
+@@ -290,7 +294,7 @@ write_wal($node, $TLI, $end_lsn, build_record_header(1));
+ $log_size = -s $node->logfile;
+ $node->start;
+ ok( $node->log_contains(
+- "invalid record length at .*: expected at least 24, got 1", $log_size
++ "invalid record length at .*: expected at least 26, got 1", $log_size
+ ),
+ "xl_tot_len short at end-of-page");
+
+diff --git a/src/test/regress/expected/indirect_toast.out b/src/test/regress/expected/indirect_toast.out
+index 44b54dc37f..313482b866 100644
+--- a/src/test/regress/expected/indirect_toast.out
++++ b/src/test/regress/expected/indirect_toast.out
+@@ -161,6 +161,14 @@ SELECT substring(indtoasttest::text, 1, 200) FROM indtoasttest;
+ ("one-toasted,one-null, via indirect",0,1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
+ (5 rows)
+
++create or replace function random_string(len integer) returns text as $$
++select substr((select string_agg(r,'') from (select random()::text as r from generate_series(1,(len+15)/16)) s1), 1, len);
++$$ language sql;
++create table toasttest_main(t text);
++alter table toasttest_main alter column t set storage main;
++insert into toasttest_main (select random_string(len) from generate_series(7000,8000) len);
+ DROP TABLE indtoasttest;
++DROP TABLE toasttest_main;
+ DROP FUNCTION update_using_indirect();
++DROP FUNCTION random_string(integer);
+ RESET default_toast_compression;
+diff --git a/src/test/regress/expected/insert.out b/src/test/regress/expected/insert.out
+index dd4354fc7d..d52545b443 100644
+--- a/src/test/regress/expected/insert.out
++++ b/src/test/regress/expected/insert.out
+@@ -100,7 +100,7 @@ SELECT pg_size_pretty(pg_relation_size('large_tuple_test'::regclass, 'main'));
+ INSERT INTO large_tuple_test (select 3, NULL);
+ -- now this tuple won't fit on the second page, but the insert should
+ -- still succeed by extending the relation
+-INSERT INTO large_tuple_test (select 4, repeat('a', 8126));
++INSERT INTO large_tuple_test (select 4, repeat('a', 8112));
+ DROP TABLE large_tuple_test;
+ --
+ -- check indirection (field/array assignment), cf bug #14265
+@@ -980,3 +980,17 @@ insert into returningwrtest values (2, 'foo') returning returningwrtest;
+ (1 row)
+
+ drop table returningwrtest;
++-- Check for MaxHeapTupleSize
++create table maxheaptuplesize_test(value text);
++alter table maxheaptuplesize_test alter column value set storage external;
++insert into maxheaptuplesize_test values (repeat('x', 8104));
++insert into maxheaptuplesize_test values (repeat('x', 8112));
++insert into maxheaptuplesize_test values (repeat('x', 8120));
++insert into maxheaptuplesize_test values (repeat('x', 8128));
++insert into maxheaptuplesize_test values (repeat('x', 8136));
++insert into maxheaptuplesize_test values (repeat('x', 8144));
++insert into maxheaptuplesize_test values (repeat('x', 8152));
++insert into maxheaptuplesize_test values (repeat('x', 8160));
++insert into maxheaptuplesize_test values (repeat('x', 8168));
++insert into maxheaptuplesize_test values (repeat('x', 8176));
++drop table maxheaptuplesize_test;
+diff --git a/src/test/regress/expected/opr_sanity.out b/src/test/regress/expected/opr_sanity.out
+index 7610b011d6..c34bef3fb5 100644
+--- a/src/test/regress/expected/opr_sanity.out
++++ b/src/test/regress/expected/opr_sanity.out
+@@ -197,7 +197,7 @@ WHERE p1.oid != p2.oid AND
+ ORDER BY 1, 2;
+ proargtypes | proargtypes
+ -----------------------------+--------------------------
+- integer | xid
++ bigint | xid
+ timestamp without time zone | timestamp with time zone
+ bit | bit varying
+ txid_snapshot | pg_snapshot
+@@ -736,7 +736,7 @@ int8(oid)
+ tideq(tid,tid)
+ timestamptz_cmp(timestamp with time zone,timestamp with time zone)
+ interval_cmp(interval,interval)
+-xideqint4(xid,integer)
++xideqint8(xid,bigint)
+ timetz_eq(time with time zone,time with time zone)
+ timetz_ne(time with time zone,time with time zone)
+ timetz_lt(time with time zone,time with time zone)
+@@ -850,7 +850,7 @@ pg_lsn_gt(pg_lsn,pg_lsn)
+ pg_lsn_ne(pg_lsn,pg_lsn)
+ pg_lsn_cmp(pg_lsn,pg_lsn)
+ xidneq(xid,xid)
+-xidneqint4(xid,integer)
++xidneqint8(xid,bigint)
+ sha224(bytea)
+ sha256(bytea)
+ sha384(bytea)
+diff --git a/src/test/regress/expected/select_views.out b/src/test/regress/expected/select_views.out
+index 1aeed8452b..804d9914e8 100644
+--- a/src/test/regress/expected/select_views.out
++++ b/src/test/regress/expected/select_views.out
+@@ -2,9 +2,22 @@
+ -- SELECT_VIEWS
+ -- test the views defined in CREATE_VIEWS
+ --
+-SELECT * FROM street;
++SELECT * FROM street ORDER BY name COLLATE "C", thepath::text COLLATE "C", cname COLLATE "C";
+ name | thepath | cname
+ ------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------
++ 100th Ave | [(-122.1657,37.429),(-122.1647,37.432)] | Oakland
++ 107th Ave | [(-122.1555,37.403),(-122.1531,37.41)] | Oakland
++ 14th St | [(-122.299,37.147),(-122.3,37.148)] | Lafayette
++ 19th Ave | [(-122.2366,37.897),(-122.2359,37.905)] | Berkeley
++ 1st St | [(-121.75508,37.89294),(-121.753581,37.90031)] | Oakland
++ 5th St | [(-122.278,37),(-122.2792,37.005),(-122.2803,37.009)] | Lafayette
++ 5th St | [(-122.296,37.615),(-122.2953,37.598)] | Berkeley
++ 82nd Ave | [(-122.1695,37.596),(-122.1681,37.603)] | Berkeley
++ 85th Ave | [(-122.1877,37.466),(-122.186,37.476)] | Oakland
++ 89th Ave | [(-122.1822,37.459),(-122.1803,37.471)] | Oakland
++ 98th Ave | [(-122.1568,37.498),(-122.1558,37.502)] | Oakland
++ 98th Ave | [(-122.1693,37.438),(-122.1682,37.444)] | Oakland
++ 98th Ave | [(-122.2001,37.258),(-122.1974,37.27)] | Lafayette
+ Access Rd 25 | [(-121.9283,37.894),(-121.9283,37.9)] | Oakland
+ Ada St | [(-122.2487,37.398),(-122.2496,37.401)] | Lafayette
+ Agua Fria Creek | [(-121.9254,37.922),(-121.9281,37.889)] | Oakland
+@@ -22,10 +35,10 @@ SELECT * FROM street;
+ Arroyo Las Positas | [(-121.7973,37.997),(-121.7957,37.005)] | Oakland
+ Arroyo Seco | [(-121.7073,37.766),(-121.6997,37.729)] | Oakland
+ Ash St | [(-122.0408,37.31),(-122.04,37.292)] | Oakland
+- Avenue 134th | [(-122.1823,37.002),(-122.1851,37.992)] | Oakland
+ Avenue 134th | [(-122.1823,37.002),(-122.1851,37.992)] | Berkeley
+- Avenue 140th | [(-122.1656,37.003),(-122.1691,37.988)] | Oakland
++ Avenue 134th | [(-122.1823,37.002),(-122.1851,37.992)] | Oakland
+ Avenue 140th | [(-122.1656,37.003),(-122.1691,37.988)] | Berkeley
++ Avenue 140th | [(-122.1656,37.003),(-122.1691,37.988)] | Oakland
+ Avenue D | [(-122.298,37.848),(-122.3024,37.849)] | Berkeley
+ B St | [(-122.1749,37.451),(-122.1743,37.443)] | Oakland
+ Bancroft Ave | [(-122.15714,37.4242),(-122.156,37.409)] | Oakland
+@@ -37,9 +50,9 @@ SELECT * FROM street;
+ Broadmore Ave | [(-122.095,37.522),(-122.0936,37.497)] | Oakland
+ Broadway | [(-122.2409,37.586),(-122.2395,37.601)] | Berkeley
+ Buckingham Blvd | [(-122.2231,37.59),(-122.2214,37.606)] | Berkeley
++ Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Berkeley
+ Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Oakland
+ Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Oakland
+- Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Berkeley
+ C St | [(-122.1768,37.46),(-122.1749,37.435)] | Oakland
+ Calaveras Creek | [(-121.8203,37.035),(-121.8207,37.931)] | Oakland
+ Calaveras Creek | [(-121.8203,37.035),(-121.8207,37.931)] | Oakland
+@@ -60,9 +73,9 @@ SELECT * FROM street;
+ Chapman Dr | [(-122.0421,37.504),(-122.0414,37.498)] | Oakland
+ Charles St | [(-122.0255,37.505),(-122.0252,37.499)] | Oakland
+ Cherry St | [(-122.0437,37.42),(-122.0434,37.413)] | Oakland
++ Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Berkeley
+ Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Oakland
+ Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Oakland
+- Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Berkeley
+ Coliseum Way | [(-122.2001,37.47),(-122.1978,37.516)] | Oakland
+ Coliseum Way | [(-122.2113,37.626),(-122.2085,37.592),(-122.2063,37.568)] | Berkeley
+ Coolidge Ave | [(-122.2007,37.058),(-122.1992,37.06)] | Lafayette
+@@ -77,9 +90,9 @@ SELECT * FROM street;
+ Cull Canyon Road | [(-122.0536,37.435),(-122.0499,37.315)] | Oakland
+ Cull Creek | [(-122.0624,37.875),(-122.0582,37.527)] | Berkeley
+ D St | [(-122.1811,37.505),(-122.1805,37.497)] | Oakland
++ Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Berkeley
+ Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Oakland
+ Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Oakland
+- Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Berkeley
+ Deering St | [(-122.2146,37.904),(-122.2126,37.897)] | Berkeley
+ Dimond Ave | [(-122.2167,37.994),(-122.2162,37.006)] | Berkeley
+ Dimond Ave | [(-122.2167,37.994),(-122.2162,37.006)] | Lafayette
+@@ -89,9 +102,9 @@ SELECT * FROM street;
+ Driscoll Road | [(-121.9482,37.403),(-121.948451,37.39995)] | Oakland
+ E St | [(-122.1832,37.505),(-122.1826,37.498),(-122.182,37.49)] | Oakland
+ Eden Ave | [(-122.1143,37.505),(-122.1142,37.491)] | Oakland
++ Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Berkeley
+ Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Oakland
+ Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Oakland
+- Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Berkeley
+ Edgewater Dr | [(-122.201,37.379),(-122.2042,37.41)] | Lafayette
+ Enos Way | [(-121.7677,37.896),(-121.7673,37.91)] | Oakland
+ Euclid Ave | [(-122.2671,37.009),(-122.2666,37.987)] | Berkeley
+@@ -106,8 +119,8 @@ SELECT * FROM street;
+ Harris Road | [(-122.0659,37.372),(-122.0675,37.363)] | Oakland
+ Heartwood Dr | [(-122.2006,37.341),(-122.1992,37.338)] | Lafayette
+ Hegenberger Exwy | [(-122.1946,37.52),(-122.1947,37.497)] | Oakland
+- Herrier St | [(-122.1943,37.006),(-122.1936,37.998)] | Oakland
+ Herrier St | [(-122.1943,37.006),(-122.1936,37.998)] | Berkeley
++ Herrier St | [(-122.1943,37.006),(-122.1936,37.998)] | Oakland
+ Hesperian Blvd | [(-122.097,37.333),(-122.0956,37.31),(-122.0946,37.293)] | Oakland
+ Hesperian Blvd | [(-122.097,37.333),(-122.0956,37.31),(-122.0946,37.293)] | Oakland
+ Hesperian Blvd | [(-122.1132,37.6),(-122.1123,37.586)] | Berkeley
+@@ -117,10 +130,10 @@ SELECT * FROM street;
+ I- 580 | [(-121.9322,37.989),(-121.9243,37.006),(-121.9217,37.014)] | Oakland
+ I- 580 | [(-122.018,37.019),(-122.0009,37.032),(-121.9787,37.983),(-121.958,37.984),(-121.9571,37.986)] | Oakland
+ I- 580 | [(-122.018,37.019),(-122.0009,37.032),(-121.9787,37.983),(-121.958,37.984),(-121.9571,37.986)] | Oakland
+- I- 580 | [(-122.1108,37.023),(-122.1101,37.02),(-122.108103,37.00764),(-122.108,37.007),(-122.1069,37.998),(-122.1064,37.994),(-122.1053,37.982),(-122.1048,37.977),(-122.1032,37.958),(-122.1026,37.953),(-122.1013,37.938),(-122.0989,37.911),(-122.0984,37.91),(-122.098,37.908)] | Oakland
+ I- 580 | [(-122.1108,37.023),(-122.1101,37.02),(-122.108103,37.00764),(-122.108,37.007),(-122.1069,37.998),(-122.1064,37.994),(-122.1053,37.982),(-122.1048,37.977),(-122.1032,37.958),(-122.1026,37.953),(-122.1013,37.938),(-122.0989,37.911),(-122.0984,37.91),(-122.098,37.908)] | Berkeley
+- I- 580 | [(-122.1543,37.703),(-122.1535,37.694),(-122.1512,37.655),(-122.1475,37.603),(-122.1468,37.583),(-122.1472,37.569),(-122.149044,37.54874),(-122.1493,37.546),(-122.1501,37.532),(-122.1506,37.509),(-122.1495,37.482),(-122.1487,37.467),(-122.1477,37.447),(-122.1414,37.383),(-122.1404,37.376),(-122.1398,37.372),(-122.139,37.356),(-122.1388,37.353),(-122.1385,37.34),(-122.1382,37.33),(-122.1378,37.316)] | Oakland
++ I- 580 | [(-122.1108,37.023),(-122.1101,37.02),(-122.108103,37.00764),(-122.108,37.007),(-122.1069,37.998),(-122.1064,37.994),(-122.1053,37.982),(-122.1048,37.977),(-122.1032,37.958),(-122.1026,37.953),(-122.1013,37.938),(-122.0989,37.911),(-122.0984,37.91),(-122.098,37.908)] | Oakland
+ I- 580 | [(-122.1543,37.703),(-122.1535,37.694),(-122.1512,37.655),(-122.1475,37.603),(-122.1468,37.583),(-122.1472,37.569),(-122.149044,37.54874),(-122.1493,37.546),(-122.1501,37.532),(-122.1506,37.509),(-122.1495,37.482),(-122.1487,37.467),(-122.1477,37.447),(-122.1414,37.383),(-122.1404,37.376),(-122.1398,37.372),(-122.139,37.356),(-122.1388,37.353),(-122.1385,37.34),(-122.1382,37.33),(-122.1378,37.316)] | Berkeley
++ I- 580 | [(-122.1543,37.703),(-122.1535,37.694),(-122.1512,37.655),(-122.1475,37.603),(-122.1468,37.583),(-122.1472,37.569),(-122.149044,37.54874),(-122.1493,37.546),(-122.1501,37.532),(-122.1506,37.509),(-122.1495,37.482),(-122.1487,37.467),(-122.1477,37.447),(-122.1414,37.383),(-122.1404,37.376),(-122.1398,37.372),(-122.139,37.356),(-122.1388,37.353),(-122.1385,37.34),(-122.1382,37.33),(-122.1378,37.316)] | Oakland
+ I- 580 | [(-122.2197,37.99),(-122.22,37.99),(-122.222092,37.99523),(-122.2232,37.998),(-122.224146,37.99963),(-122.2261,37.003),(-122.2278,37.007),(-122.2302,37.026),(-122.2323,37.043),(-122.2344,37.059),(-122.235405,37.06427),(-122.2365,37.07)] | Berkeley
+ I- 580 | [(-122.2197,37.99),(-122.22,37.99),(-122.222092,37.99523),(-122.2232,37.998),(-122.224146,37.99963),(-122.2261,37.003),(-122.2278,37.007),(-122.2302,37.026),(-122.2323,37.043),(-122.2344,37.059),(-122.235405,37.06427),(-122.2365,37.07)] | Lafayette
+ I- 580 Ramp | [(-121.8521,37.011),(-121.8479,37.999),(-121.8476,37.999),(-121.8456,37.01),(-121.8455,37.011)] | Oakland
+@@ -136,8 +149,8 @@ SELECT * FROM street;
+ I- 580 Ramp | [(-122.0941,37.897),(-122.0943,37.902)] | Berkeley
+ I- 580 Ramp | [(-122.096,37.888),(-122.0962,37.891),(-122.0964,37.9)] | Berkeley
+ I- 580 Ramp | [(-122.101,37.898),(-122.1005,37.902),(-122.0989,37.911)] | Berkeley
+- I- 580 Ramp | [(-122.1086,37.003),(-122.1068,37.993),(-122.1066,37.992),(-122.1053,37.982)] | Oakland
+ I- 580 Ramp | [(-122.1086,37.003),(-122.1068,37.993),(-122.1066,37.992),(-122.1053,37.982)] | Berkeley
++ I- 580 Ramp | [(-122.1086,37.003),(-122.1068,37.993),(-122.1066,37.992),(-122.1053,37.982)] | Oakland
+ I- 580 Ramp | [(-122.1414,37.383),(-122.1407,37.376),(-122.1403,37.372),(-122.139,37.356)] | Oakland
+ I- 580/I-680 Ramp | ((-121.9207,37.988),(-121.9192,37.016)) | Oakland
+ I- 580/I-680 Ramp | ((-121.9207,37.988),(-121.9192,37.016)) | Oakland
+@@ -158,16 +171,16 @@ SELECT * FROM street;
+ I- 880 | ((-121.9669,37.075),(-121.9663,37.071),(-121.9656,37.065),(-121.9618,37.037),(-121.95689,37),(-121.948,37.933)) | Oakland
+ I- 880 | [(-121.948,37.933),(-121.9471,37.925),(-121.9467,37.923),(-121.946,37.918),(-121.9452,37.912),(-121.937,37.852)] | Oakland
+ I- 880 | [(-122.0219,37.466),(-122.0205,37.447),(-122.020331,37.44447),(-122.020008,37.43962),(-122.0195,37.432),(-122.0193,37.429),(-122.0164,37.393),(-122.010219,37.34771),(-122.0041,37.313)] | Oakland
+- I- 880 | [(-122.0375,37.632),(-122.0359,37.619),(-122.0358,37.616),(-122.034514,37.60409),(-122.031876,37.57965),(-122.031193,37.57332),(-122.03016,37.56375),(-122.02943,37.55698),(-122.028689,37.54929),(-122.027833,37.53908),(-122.025979,37.51698),(-122.0238,37.491)] | Oakland
+ I- 880 | [(-122.0375,37.632),(-122.0359,37.619),(-122.0358,37.616),(-122.034514,37.60409),(-122.031876,37.57965),(-122.031193,37.57332),(-122.03016,37.56375),(-122.02943,37.55698),(-122.028689,37.54929),(-122.027833,37.53908),(-122.025979,37.51698),(-122.0238,37.491)] | Berkeley
++ I- 880 | [(-122.0375,37.632),(-122.0359,37.619),(-122.0358,37.616),(-122.034514,37.60409),(-122.031876,37.57965),(-122.031193,37.57332),(-122.03016,37.56375),(-122.02943,37.55698),(-122.028689,37.54929),(-122.027833,37.53908),(-122.025979,37.51698),(-122.0238,37.491)] | Oakland
++ I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Berkeley
+ I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Oakland
+ I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Oakland
+- I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Berkeley
+ I- 880 | [(-122.0831,37.312),(-122.0819,37.296),(-122.081,37.285),(-122.0786,37.248),(-122.078,37.24),(-122.077642,37.23496),(-122.076983,37.22567),(-122.076599,37.22026),(-122.076229,37.21505),(-122.0758,37.209)] | Oakland
+ I- 880 | [(-122.0978,37.528),(-122.096,37.496),(-122.0931,37.453),(-122.09277,37.4496),(-122.090189,37.41442),(-122.0896,37.405),(-122.085,37.34)] | Oakland
+ I- 880 | [(-122.1365,37.902),(-122.1358,37.898),(-122.1333,37.881),(-122.1323,37.874),(-122.1311,37.866),(-122.1308,37.865),(-122.1307,37.864),(-122.1289,37.851),(-122.1277,37.843),(-122.1264,37.834),(-122.1231,37.812),(-122.1165,37.766),(-122.1104,37.72),(-122.109695,37.71094),(-122.109,37.702),(-122.108312,37.69168),(-122.1076,37.681)] | Berkeley
+- I- 880 | [(-122.1755,37.185),(-122.1747,37.178),(-122.1742,37.173),(-122.1692,37.126),(-122.167792,37.11594),(-122.16757,37.11435),(-122.1671,37.111),(-122.1655,37.1),(-122.165169,37.09811),(-122.1641,37.092),(-122.1596,37.061),(-122.158381,37.05275),(-122.155991,37.03657),(-122.1531,37.017),(-122.1478,37.98),(-122.1407,37.932),(-122.1394,37.924),(-122.1389,37.92),(-122.1376,37.91)] | Oakland
+ I- 880 | [(-122.1755,37.185),(-122.1747,37.178),(-122.1742,37.173),(-122.1692,37.126),(-122.167792,37.11594),(-122.16757,37.11435),(-122.1671,37.111),(-122.1655,37.1),(-122.165169,37.09811),(-122.1641,37.092),(-122.1596,37.061),(-122.158381,37.05275),(-122.155991,37.03657),(-122.1531,37.017),(-122.1478,37.98),(-122.1407,37.932),(-122.1394,37.924),(-122.1389,37.92),(-122.1376,37.91)] | Berkeley
++ I- 880 | [(-122.1755,37.185),(-122.1747,37.178),(-122.1742,37.173),(-122.1692,37.126),(-122.167792,37.11594),(-122.16757,37.11435),(-122.1671,37.111),(-122.1655,37.1),(-122.165169,37.09811),(-122.1641,37.092),(-122.1596,37.061),(-122.158381,37.05275),(-122.155991,37.03657),(-122.1531,37.017),(-122.1478,37.98),(-122.1407,37.932),(-122.1394,37.924),(-122.1389,37.92),(-122.1376,37.91)] | Oakland
+ I- 880 | [(-122.2214,37.711),(-122.2202,37.699),(-122.2199,37.695),(-122.219,37.682),(-122.2184,37.672),(-122.2173,37.652),(-122.2159,37.638),(-122.2144,37.616),(-122.2138,37.612),(-122.2135,37.609),(-122.212,37.592),(-122.2116,37.586),(-122.2111,37.581)] | Berkeley
+ I- 880 | [(-122.2707,37.975),(-122.2693,37.972),(-122.2681,37.966),(-122.267,37.962),(-122.2659,37.957),(-122.2648,37.952),(-122.2636,37.946),(-122.2625,37.935),(-122.2617,37.927),(-122.2607,37.921),(-122.2593,37.916),(-122.258,37.911),(-122.2536,37.898),(-122.2432,37.858),(-122.2408,37.845),(-122.2386,37.827),(-122.2374,37.811)] | Berkeley
+ I- 880 Ramp | [(-122.0019,37.301),(-122.002,37.293)] | Oakland
+@@ -175,12 +188,12 @@ SELECT * FROM street;
+ I- 880 Ramp | [(-122.0041,37.313),(-122.0038,37.308),(-122.0039,37.284),(-122.0013,37.287),(-121.9995,37.289)] | Oakland
+ I- 880 Ramp | [(-122.0236,37.488),(-122.0231,37.458),(-122.0227,37.458),(-122.0223,37.452),(-122.0205,37.447)] | Oakland
+ I- 880 Ramp | [(-122.0238,37.491),(-122.0215,37.483),(-122.0211,37.477),(-122.0205,37.447)] | Oakland
++ I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Berkeley
+ I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Oakland
+ I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Oakland
+- I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Berkeley
++ I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Berkeley
+ I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Oakland
+ I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Oakland
+- I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Berkeley
+ I- 880 Ramp | [(-122.085,37.34),(-122.0801,37.316),(-122.081,37.285)] | Oakland
+ I- 880 Ramp | [(-122.085,37.34),(-122.0801,37.316),(-122.081,37.285)] | Oakland
+ I- 880 Ramp | [(-122.085,37.34),(-122.0866,37.316),(-122.0819,37.296)] | Oakland
+@@ -212,26 +225,26 @@ SELECT * FROM street;
+ Livermore Ave | [(-121.7687,37.448),(-121.769,37.375)] | Oakland
+ Livermore Ave | [(-121.772719,37.99085),(-121.7728,37.001)] | Oakland
+ Livermore Ave | [(-121.772719,37.99085),(-121.7728,37.001)] | Oakland
+- Locust St | [(-122.1606,37.007),(-122.1593,37.987)] | Oakland
+ Locust St | [(-122.1606,37.007),(-122.1593,37.987)] | Berkeley
++ Locust St | [(-122.1606,37.007),(-122.1593,37.987)] | Oakland
+ Logan Ct | [(-122.0053,37.492),(-122.0061,37.484)] | Oakland
+ Magnolia St | [(-122.0971,37.5),(-122.0962,37.484)] | Oakland
+ Mandalay Road | [(-122.2322,37.397),(-122.2321,37.403)] | Lafayette
+ Marin Ave | [(-122.2741,37.894),(-122.272,37.901)] | Berkeley
+ Martin Luther King Jr Way | [(-122.2712,37.608),(-122.2711,37.599)] | Berkeley
+ Mattos Dr | [(-122.0005,37.502),(-122.000898,37.49683)] | Oakland
+- Maubert Ave | [(-122.1114,37.009),(-122.1096,37.995)] | Oakland
+ Maubert Ave | [(-122.1114,37.009),(-122.1096,37.995)] | Berkeley
+- McClure Ave | [(-122.1431,37.001),(-122.1436,37.998)] | Oakland
++ Maubert Ave | [(-122.1114,37.009),(-122.1096,37.995)] | Oakland
+ McClure Ave | [(-122.1431,37.001),(-122.1436,37.998)] | Berkeley
++ McClure Ave | [(-122.1431,37.001),(-122.1436,37.998)] | Oakland
+ Medlar Dr | [(-122.0627,37.378),(-122.0625,37.375)] | Oakland
+ Mildred Ct | [(-122.0002,37.388),(-121.9998,37.386)] | Oakland
+ Miller Road | [(-122.0902,37.645),(-122.0865,37.545)] | Berkeley
+ Miramar Ave | [(-122.1009,37.025),(-122.099089,37.03209)] | Oakland
+ Mission Blvd | [(-121.918886,37),(-121.9194,37.976),(-121.9198,37.975)] | Oakland
+ Mission Blvd | [(-121.918886,37),(-121.9194,37.976),(-121.9198,37.975)] | Oakland
+- Mission Blvd | [(-122.0006,37.896),(-121.9989,37.88)] | Oakland
+ Mission Blvd | [(-122.0006,37.896),(-121.9989,37.88)] | Berkeley
++ Mission Blvd | [(-122.0006,37.896),(-121.9989,37.88)] | Oakland
+ Moores Ave | [(-122.0087,37.301),(-122.0094,37.292)] | Oakland
+ National Ave | [(-122.1192,37.5),(-122.1281,37.489)] | Oakland
+ Navajo Ct | [(-121.8779,37.901),(-121.8783,37.9)] | Oakland
+@@ -242,49 +255,49 @@ SELECT * FROM street;
+ Parkridge Dr | [(-122.1438,37.884),(-122.1428,37.9)] | Berkeley
+ Parkside Dr | [(-122.0475,37.603),(-122.0443,37.596)] | Berkeley
+ Paseo Padre Pkwy | [(-121.9143,37.005),(-121.913522,37)] | Oakland
+- Paseo Padre Pkwy | [(-122.0021,37.639),(-121.996,37.628)] | Oakland
+ Paseo Padre Pkwy | [(-122.0021,37.639),(-121.996,37.628)] | Berkeley
++ Paseo Padre Pkwy | [(-122.0021,37.639),(-121.996,37.628)] | Oakland
+ Pearl St | [(-122.2383,37.594),(-122.2366,37.615)] | Berkeley
+ Periwinkle Road | [(-122.0451,37.301),(-122.044758,37.29844)] | Oakland
+ Pimlico Dr | [(-121.8616,37.998),(-121.8618,37.008)] | Oakland
+ Pimlico Dr | [(-121.8616,37.998),(-121.8618,37.008)] | Oakland
+ Portsmouth Ave | [(-122.1064,37.315),(-122.1064,37.308)] | Oakland
+ Proctor Ave | [(-122.2267,37.406),(-122.2251,37.386)] | Lafayette
++ Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Berkeley
+ Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Oakland
+ Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Oakland
+- Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Berkeley
++ Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Berkeley
+ Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Oakland
+ Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Oakland
+- Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Berkeley
+ Redding St | [(-122.1978,37.901),(-122.1975,37.895)] | Berkeley
+- Redwood Road | [(-122.1493,37.98),(-122.1437,37.001)] | Oakland
+ Redwood Road | [(-122.1493,37.98),(-122.1437,37.001)] | Berkeley
++ Redwood Road | [(-122.1493,37.98),(-122.1437,37.001)] | Oakland
+ Roca Dr | [(-122.0335,37.609),(-122.0314,37.599)] | Berkeley
+ Rosedale Ct | [(-121.9232,37.9),(-121.924,37.897)] | Oakland
+ Sacramento St | [(-122.2799,37.606),(-122.2797,37.597)] | Berkeley
+ Saddle Brook Dr | [(-122.1478,37.909),(-122.1454,37.904),(-122.1451,37.888)] | Berkeley
+ Saginaw Ct | [(-121.8803,37.898),(-121.8806,37.901)] | Oakland
+ San Andreas Dr | [(-122.0609,37.9),(-122.0614,37.895)] | Berkeley
++ Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Berkeley
+ Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Oakland
+ Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Oakland
+- Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Berkeley
+ Shattuck Ave | [(-122.2686,37.904),(-122.2686,37.897)] | Berkeley
+ Sheridan Road | [(-122.2279,37.425),(-122.2253,37.411),(-122.2223,37.377)] | Lafayette
+ Shoreline Dr | [(-122.2657,37.603),(-122.2648,37.6)] | Berkeley
+- Skyline Blvd | [(-122.1738,37.01),(-122.1714,37.996)] | Oakland
+ Skyline Blvd | [(-122.1738,37.01),(-122.1714,37.996)] | Berkeley
++ Skyline Blvd | [(-122.1738,37.01),(-122.1714,37.996)] | Oakland
+ Skyline Dr | [(-122.0277,37.5),(-122.0284,37.498)] | Oakland
+ Skywest Dr | [(-122.1161,37.62),(-122.1123,37.586)] | Berkeley
+ Southern Pacific Railroad | [(-122.3002,37.674),(-122.2999,37.661)] | Berkeley
+ Sp Railroad | [(-121.893564,37.99009),(-121.897,37.016)] | Oakland
+ Sp Railroad | [(-121.893564,37.99009),(-121.897,37.016)] | Oakland
+ Sp Railroad | [(-121.9565,37.898),(-121.9562,37.9)] | Oakland
++ Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Berkeley
+ Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Oakland
+ Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Oakland
+- Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Berkeley
+ Sp Railroad | [(-122.0914,37.601),(-122.087,37.56),(-122.086408,37.5551)] | Berkeley
+- Sp Railroad | [(-122.137792,37.003),(-122.1365,37.992),(-122.131257,37.94612)] | Oakland
+ Sp Railroad | [(-122.137792,37.003),(-122.1365,37.992),(-122.131257,37.94612)] | Berkeley
++ Sp Railroad | [(-122.137792,37.003),(-122.1365,37.992),(-122.131257,37.94612)] | Oakland
+ Sp Railroad | [(-122.1947,37.497),(-122.193328,37.4848)] | Oakland
+ Stanton Ave | [(-122.100392,37.0697),(-122.099513,37.06052)] | Oakland
+ State Hwy 123 | [(-122.3004,37.986),(-122.2998,37.969),(-122.2995,37.962),(-122.2992,37.952),(-122.299,37.942),(-122.2987,37.935),(-122.2984,37.924),(-122.2982,37.92),(-122.2976,37.904),(-122.297,37.88),(-122.2966,37.869),(-122.2959,37.848),(-122.2961,37.843)] | Berkeley
+@@ -316,28 +329,15 @@ SELECT * FROM street;
+ Welch Creek Road | [(-121.7695,37.386),(-121.7737,37.413)] | Oakland
+ Welch Creek Road | [(-121.7695,37.386),(-121.7737,37.413)] | Oakland
+ West Loop Road | [(-122.0576,37.604),(-122.0602,37.586)] | Berkeley
++ Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Berkeley
+ Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Oakland
+ Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Oakland
+- Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Berkeley
+ Whitlock Creek | [(-121.74683,37.91276),(-121.733107,37)] | Oakland
+ Whitlock Creek | [(-121.74683,37.91276),(-121.733107,37)] | Oakland
+ Willimet Way | [(-122.0964,37.517),(-122.0949,37.493)] | Oakland
+- Wisconsin St | [(-122.1994,37.017),(-122.1975,37.998),(-122.1971,37.994)] | Oakland
+ Wisconsin St | [(-122.1994,37.017),(-122.1975,37.998),(-122.1971,37.994)] | Berkeley
++ Wisconsin St | [(-122.1994,37.017),(-122.1975,37.998),(-122.1971,37.994)] | Oakland
+ Wp Railroad | [(-122.254,37.902),(-122.2506,37.891)] | Berkeley
+- 100th Ave | [(-122.1657,37.429),(-122.1647,37.432)] | Oakland
+- 107th Ave | [(-122.1555,37.403),(-122.1531,37.41)] | Oakland
+- 14th St | [(-122.299,37.147),(-122.3,37.148)] | Lafayette
+- 19th Ave | [(-122.2366,37.897),(-122.2359,37.905)] | Berkeley
+- 1st St | [(-121.75508,37.89294),(-121.753581,37.90031)] | Oakland
+- 5th St | [(-122.278,37),(-122.2792,37.005),(-122.2803,37.009)] | Lafayette
+- 5th St | [(-122.296,37.615),(-122.2953,37.598)] | Berkeley
+- 82nd Ave | [(-122.1695,37.596),(-122.1681,37.603)] | Berkeley
+- 85th Ave | [(-122.1877,37.466),(-122.186,37.476)] | Oakland
+- 89th Ave | [(-122.1822,37.459),(-122.1803,37.471)] | Oakland
+- 98th Ave | [(-122.1568,37.498),(-122.1558,37.502)] | Oakland
+- 98th Ave | [(-122.1693,37.438),(-122.1682,37.444)] | Oakland
+- 98th Ave | [(-122.2001,37.258),(-122.1974,37.27)] | Lafayette
+ (333 rows)
+
+ SELECT name, #thepath FROM iexit ORDER BY name COLLATE "C", 2;
+diff --git a/src/test/regress/expected/txid.out b/src/test/regress/expected/txid.out
+index 95ba66e95e..2ea4434f51 100644
+--- a/src/test/regress/expected/txid.out
++++ b/src/test/regress/expected/txid.out
+@@ -238,9 +238,11 @@ SELECT txid_snapshot '1:9223372036854775807:3';
+ (1 row)
+
+ SELECT txid_snapshot '1:9223372036854775808:3';
+-ERROR: invalid input syntax for type pg_snapshot: "1:9223372036854775808:3"
+-LINE 1: SELECT txid_snapshot '1:9223372036854775808:3';
+- ^
++ txid_snapshot
++-------------------------
++ 1:9223372036854775808:3
++(1 row)
++
+ -- test txid_current_if_assigned
+ BEGIN;
+ SELECT txid_current_if_assigned() IS NULL;
+diff --git a/src/test/regress/expected/type_sanity.out b/src/test/regress/expected/type_sanity.out
+index 88d8f6c32d..0c4b994343 100644
+--- a/src/test/regress/expected/type_sanity.out
++++ b/src/test/regress/expected/type_sanity.out
+@@ -19,7 +19,7 @@ WHERE t1.typnamespace = 0 OR
+ (t1.typlen <= 0 AND t1.typlen != -1 AND t1.typlen != -2) OR
+ (t1.typtype not in ('b', 'c', 'd', 'e', 'm', 'p', 'r')) OR
+ NOT t1.typisdefined OR
+- (t1.typalign not in ('c', 's', 'i', 'd')) OR
++ (t1.typalign not in ('c', 's', 'i', 'd', 'x')) OR
+ (t1.typstorage not in ('p', 'x', 'e', 'm'));
+ oid | typname
+ -----+---------
+@@ -32,7 +32,8 @@ WHERE t1.typbyval AND
+ (t1.typlen != 1 OR t1.typalign != 'c') AND
+ (t1.typlen != 2 OR t1.typalign != 's') AND
+ (t1.typlen != 4 OR t1.typalign != 'i') AND
+- (t1.typlen != 8 OR t1.typalign != 'd');
++ (t1.typlen != 8 OR t1.typalign != 'd') AND
++ (t1.typlen != 8 OR t1.typalign != 'x');
+ oid | typname
+ -----+---------
+ (0 rows)
+diff --git a/src/test/regress/expected/xid.out b/src/test/regress/expected/xid.out
+index 835077e9d5..0154990d1a 100644
+--- a/src/test/regress/expected/xid.out
++++ b/src/test/regress/expected/xid.out
+@@ -8,9 +8,9 @@ select '010'::xid,
+ '42'::xid8,
+ '0xffffffffffffffff'::xid8,
+ '-1'::xid8;
+- xid | xid | xid | xid | xid8 | xid8 | xid8 | xid8
+------+-----+------------+------------+------+------+----------------------+----------------------
+- 8 | 42 | 4294967295 | 4294967295 | 8 | 42 | 18446744073709551615 | 18446744073709551615
++ xid | xid | xid | xid | xid8 | xid8 | xid8 | xid8
++-----+-----+------------+----------------------+------+------+----------------------+----------------------
++ 8 | 42 | 4294967295 | 18446744073709551615 | 8 | 42 | 18446744073709551615 | 18446744073709551615
+ (1 row)
+
+ -- garbage values
+@@ -43,10 +43,10 @@ SELECT pg_input_is_valid('asdf', 'xid');
+ f
+ (1 row)
+
+-SELECT * FROM pg_input_error_info('0xffffffffff', 'xid');
+- message | detail | hint | sql_error_code
+----------------------------------------------------+--------+------+----------------
+- value "0xffffffffff" is out of range for type xid | | | 22003
++SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid');
++ message | detail | hint | sql_error_code
++-------------------------------------------------------------+--------+------+----------------
++ value "0xffffffffffffffffffff" is out of range for type xid | | | 22003
+ (1 row)
+
+ SELECT pg_input_is_valid('42', 'xid8');
+@@ -441,9 +441,11 @@ SELECT pg_snapshot '1:9223372036854775807:3';
+ (1 row)
+
+ SELECT pg_snapshot '1:9223372036854775808:3';
+-ERROR: invalid input syntax for type pg_snapshot: "1:9223372036854775808:3"
+-LINE 1: SELECT pg_snapshot '1:9223372036854775808:3';
+- ^
++ pg_snapshot
++-------------------------
++ 1:9223372036854775808:3
++(1 row)
++
+ -- test pg_current_xact_id_if_assigned
+ BEGIN;
+ SELECT pg_current_xact_id_if_assigned() IS NULL;
+diff --git a/src/test/regress/expected/xid64.out b/src/test/regress/expected/xid64.out
+new file mode 100644
+index 0000000000..c30c5b5739
+--- /dev/null
++++ b/src/test/regress/expected/xid64.out
+@@ -0,0 +1,92 @@
++---
++--- Unit test for xid64 functions
++---
++-- directory paths and dlsuffix are passed to us in environment variables
++\getenv libdir PG_LIBDIR
++\getenv dlsuffix PG_DLSUFFIX
++\set regresslib :libdir '/regress' :dlsuffix
++CREATE FUNCTION xid64_test_1(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_1' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_2(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_2' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_double_xmax(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_double_xmax' LANGUAGE C STRICT;
++---
++--- Check page consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(a int);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++INSERT INTO test_xid64_table(a) SELECT a FROM generate_series(1, 1000) AS a;
++SELECT xid64_test_1('test_xid64_table');
++INFO: test 1: page is converted to xid64 format
++ xid64_test_1
++--------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++---
++--- Check tuples consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(s serial, i int, t text);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++DO $$
++BEGIN
++ FOR j IN 1..20 LOOP
++ INSERT INTO test_xid64_table(i, t) VALUES (random()::int, md5(random()::text));
++ COMMIT;
++ END LOOP;
++END $$;
++DO $$
++BEGIN
++ FOR j IN 1..10 LOOP
++ DELETE FROM test_xid64_table WHERE ctid IN (SELECT ctid FROM test_xid64_table TABLESAMPLE BERNOULLI (5));
++ COMMIT;
++ END LOOP;
++END $$;
++SELECT xid64_test_2('test_xid64_table');
++ xid64_test_2
++--------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++---
++--- Check tuples consistency after conversion to double xmax (on full page)
++---
++CREATE UNLOGGED TABLE test_xid64_table(i int);
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table SELECT i FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++SELECT xid64_test_2('test_xid64_table');
++ xid64_test_2
++--------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++CREATE UNLOGGED TABLE test_xid64_table(i text);
++INSERT INTO test_xid64_table(i) VALUES ('NNBABCDSDFGHJKLP');
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table(i) SELECT 'A' FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++SELECT xid64_test_double_xmax('test_xid64_table');
++INFO: test double xmax: page 0 is converted into double xmax format
++INFO: test double xmax: end
++ xid64_test_double_xmax
++------------------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++DROP FUNCTION xid64_test_1(rel regclass);
++DROP FUNCTION xid64_test_2(rel regclass);
++DROP FUNCTION xid64_test_double_xmax(rel regclass);
+diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
+index f0987ff537..bfbf85a255 100644
+--- a/src/test/regress/parallel_schedule
++++ b/src/test/regress/parallel_schedule
+@@ -28,7 +28,7 @@ test: strings md5 numerology point lseg line box path polygon circle date time t
+ # geometry depends on point, lseg, line, box, path, polygon, circle
+ # horology depends on date, time, timetz, timestamp, timestamptz, interval
+ # ----------
+-test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc
++test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid xid64 mvcc
+
+ # ----------
+ # Load huge amounts of data
+diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c
+index bcbc6d910f..9bb8b541bb 100644
+--- a/src/test/regress/regress.c
++++ b/src/test/regress/regress.c
+@@ -23,6 +23,7 @@
+ #include "access/htup_details.h"
+ #include "access/transam.h"
+ #include "access/xact.h"
++#include "catalog/catalog.h"
+ #include "catalog/namespace.h"
+ #include "catalog/pg_operator.h"
+ #include "catalog/pg_type.h"
+@@ -578,6 +579,7 @@ make_tuple_indirect(PG_FUNCTION_ARGS)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = rec;
+
+ values = (Datum *) palloc(ncolumns * sizeof(Datum));
+@@ -1262,3 +1264,293 @@ get_columns_length(PG_FUNCTION_ARGS)
+
+ PG_RETURN_INT32(column_offset);
+ }
++
++#include "access/hio.h"
++#include "access/relation.h"
++#include "storage/bufmgr.h"
++#include "utils/rel.h"
++
++static void
++CheckNewPage(char *msg, Page page)
++{
++ uint16 size;
++
++ if (PageGetPageLayoutVersion(page) != PG_PAGE_LAYOUT_VERSION)
++ elog(ERROR, "%s: page version is %d, expected %d ",
++ msg, PageGetPageLayoutVersion(page), PG_PAGE_LAYOUT_VERSION);
++
++ size = PageGetSpecialSize(page);
++ if (size == MAXALIGN(sizeof(HeapPageSpecialData)))
++ elog(INFO, "%s: page is converted to xid64 format", msg);
++ else if (HeapPageIsDoubleXmax(page))
++ elog(INFO, "%s: page is converted into double xmax format", msg);
++ else
++ elog(ERROR, "%s: converted page has pageSpecial size %u, expected %llu",
++ msg, size,
++ (unsigned long long) MAXALIGN(sizeof(HeapPageSpecialData)));
++}
++
++/*
++ * Get page from relation.
++ * Make this page look like in 32-bit xid format.
++ * Convert it to 64-bit xid format.
++ * Run basic checks.
++ */
++PG_FUNCTION_INFO_V1(xid64_test_1);
++Datum
++xid64_test_1(PG_FUNCTION_ARGS)
++{
++ Oid relid;
++ Relation rel;
++ Buffer buf;
++ Page page;
++ PageHeader hdr;
++
++ relid = PG_GETARG_OID(0);
++ rel = relation_open(relid, AccessExclusiveLock);
++ buf = ReadBuffer(rel, 0);
++ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
++
++ page = BufferGetPage(buf);
++ hdr = (PageHeader) page;
++
++ if (PageGetSpecialSize(page) != MAXALIGN(sizeof(HeapPageSpecialData)))
++ elog(ERROR, "page expected in new format");
++
++ if (PageGetPageLayoutVersion(page) != PG_PAGE_LAYOUT_VERSION)
++ elog(ERROR, "unknown page version (%u)",
++ PageGetPageLayoutVersion(page));
++
++ hdr->pd_special = BLCKSZ;
++ PageSetPageSizeAndVersion(page, BLCKSZ, PG_PAGE_LAYOUT_VERSION - 1);
++
++ convert_page(rel, page, buf, 0);
++ CheckNewPage("test 1", page);
++
++ UnlockReleaseBuffer(buf);
++ relation_close(rel, AccessExclusiveLock);
++
++ PG_RETURN_VOID();
++}
++
++typedef struct TupleCheckValues
++{
++ TransactionId xmin;
++ TransactionId xmax;
++} TupleCheckValues;
++
++typedef struct RelCheckValues
++{
++ TupleCheckValues *tcv;
++ Size ntuples;
++} RelCheckValues;
++
++static RelCheckValues
++FillRelCheckValues(Relation rel, Buffer buffer, Page page)
++{
++ RelCheckValues set;
++ Size n;
++
++#define DEFAULT_SET_SIZE 64
++ n = DEFAULT_SET_SIZE;
++ set.ntuples = 0;
++ set.tcv = palloc(sizeof(set.tcv[0]) * n);
++
++ {
++ OffsetNumber maxoff,
++ offnum;
++ HeapTupleHeader tuphdr;
++ ItemId itemid;
++ HeapTupleData tuple;
++ TransactionId xmin,
++ xmax;
++
++ maxoff = PageGetMaxOffsetNumber(page);
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++ tuphdr = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_data = tuphdr;
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++
++ if (HeapPageGetSpecial(page) == heapDoubleXmaxSpecial)
++ {
++ xmin = tuphdr->t_choice.t_heap.t_xmin;
++ xmax = tuphdr->t_choice.t_heap.t_xmax;
++ }
++ else
++ {
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page,
++ IsToastRelation(rel));
++
++ xmin = HeapTupleGetRawXmin(&tuple);
++ xmax = HeapTupleGetRawXmax(&tuple);
++ }
++
++ if (set.ntuples == n)
++ {
++ n *= 2;
++ set.tcv = repalloc(set.tcv, sizeof(set.tcv[0]) * n);
++ }
++
++ set.tcv[set.ntuples].xmin = xmin;
++ set.tcv[set.ntuples].xmax = xmax;
++ set.ntuples++;
++ }
++ }
++
++ return set;
++}
++
++/*
++ * Test xmin/xmax invariant when converting page from 32bit xid to 64xid.
++ *
++ * Scenario:
++ * - enforce all relation pages to 32bit xid format, discarding pd_xid_base and
++ * pd_multi_base
++ * - store all xmin/xmax in array
++ * - convert all the pages from relation into 64xid format
++ * - store all new xmin/xmax in array
++ * - compare old and new xmin/xmax
++ *
++ * NOTE: inital xid value does not affect test as pd_xid_base/pd_multi_base
++ * discarded.
++ */
++PG_FUNCTION_INFO_V1(xid64_test_2);
++Datum
++xid64_test_2(PG_FUNCTION_ARGS)
++{
++ Oid relid;
++ Relation rel;
++ RelCheckValues before,
++ after;
++ BlockNumber pageno,
++ npages;
++ Size i;
++
++ relid = PG_GETARG_OID(0);
++ rel = relation_open(relid, AccessExclusiveLock);
++ npages = RelationGetNumberOfBlocks(rel);
++
++ for (pageno = 0; pageno != npages; ++pageno)
++ {
++ Buffer buf;
++ Page page;
++ PageHeader hdr;
++
++ /* get page */
++ buf = ReadBuffer(rel, pageno);
++ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
++ page = BufferGetPage(buf);
++ hdr = (PageHeader) page;
++
++ /* make page look like 32-bit xid page */
++ hdr->pd_special = BLCKSZ;
++ PageSetPageSizeAndVersion(page, BLCKSZ, PG_PAGE_LAYOUT_VERSION - 1);
++
++ before = FillRelCheckValues(rel, buf, page);
++ convert_page(rel, page, buf, pageno);
++ after = FillRelCheckValues(rel, buf, page);
++
++ /* check */
++ if (before.ntuples != after.ntuples)
++ elog(ERROR, "numer of tuples must be equal");
++
++ for (i = 0; i != before.ntuples; ++i)
++ {
++ if (before.tcv[i].xmin != after.tcv[i].xmin && after.tcv[i].xmin)
++ elog(ERROR, "old and new xmin does not match (%llu != %llu)",
++ (unsigned long long) before.tcv[i].xmin,
++ (unsigned long long) after.tcv[i].xmin);
++
++ if (before.tcv[i].xmax != after.tcv[i].xmax)
++ elog(ERROR, "old and new xmax does not match (%llu != %llu)",
++ (unsigned long long) before.tcv[i].xmax,
++ (unsigned long long) after.tcv[i].xmax);
++ }
++
++ Assert(npages != 0);
++ pfree(before.tcv);
++ pfree(after.tcv);
++
++ UnlockReleaseBuffer(buf);
++ }
++
++ relation_close(rel, AccessExclusiveLock);
++
++ PG_RETURN_VOID();
++}
++
++PG_FUNCTION_INFO_V1(xid64_test_double_xmax);
++Datum
++xid64_test_double_xmax(PG_FUNCTION_ARGS)
++{
++ Oid relid;
++ Relation rel;
++ BlockNumber pageno,
++ npages;
++ bool found;
++
++ relid = PG_GETARG_OID(0);
++ rel = relation_open(relid, AccessExclusiveLock);
++ npages = RelationGetNumberOfBlocks(rel);
++ found = false;
++
++ for (pageno = 0; pageno != npages; ++pageno)
++ {
++ Buffer buf;
++ Page page;
++ PageHeader hdr;
++ ItemId itemid;
++ OffsetNumber offnum;
++ HeapTupleHeader tuphdr;
++
++ buf = ReadBuffer(rel, pageno);
++ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
++ page = BufferGetPage(buf);
++ hdr = (PageHeader) page;
++
++ if (pageno == 0)
++ {
++ itemid = PageGetItemId(page, FirstOffsetNumber);
++ itemid->lp_len += 16; /* Move to overlap special */
++ }
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= PageGetMaxOffsetNumber(page);
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++ tuphdr = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuphdr->t_infomask |= HEAP_XMIN_COMMITTED;
++ }
++
++ hdr->pd_special = BLCKSZ;
++ PageSetPageSizeAndVersion(page, BLCKSZ, PG_PAGE_LAYOUT_VERSION - 1);
++
++ convert_page(rel, page, buf, pageno);
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ found = true;
++ elog(INFO, "test double xmax: page %u is converted into double xmax format",
++ pageno);
++ }
++
++ UnlockReleaseBuffer(buf);
++ }
++
++ if (!found)
++ elog(ERROR, "test double xmax: failed, no double xmax");
++
++ Assert(npages != 0);
++ elog(INFO, "test double xmax: end");
++
++ relation_close(rel, AccessExclusiveLock);
++
++ PG_RETURN_VOID();
++}
+diff --git a/src/test/regress/sql/indirect_toast.sql b/src/test/regress/sql/indirect_toast.sql
+index 3e2f6c0237..ea087b5128 100644
+--- a/src/test/regress/sql/indirect_toast.sql
++++ b/src/test/regress/sql/indirect_toast.sql
+@@ -76,7 +76,18 @@ SELECT substring(indtoasttest::text, 1, 200) FROM indtoasttest;
+ VACUUM FREEZE indtoasttest;
+ SELECT substring(indtoasttest::text, 1, 200) FROM indtoasttest;
+
++create or replace function random_string(len integer) returns text as $$
++select substr((select string_agg(r,'') from (select random()::text as r from generate_series(1,(len+15)/16)) s1), 1, len);
++$$ language sql;
++
++create table toasttest_main(t text);
++alter table toasttest_main alter column t set storage main;
++
++insert into toasttest_main (select random_string(len) from generate_series(7000,8000) len);
++
+ DROP TABLE indtoasttest;
++DROP TABLE toasttest_main;
+ DROP FUNCTION update_using_indirect();
++DROP FUNCTION random_string(integer);
+
+ RESET default_toast_compression;
+diff --git a/src/test/regress/sql/insert.sql b/src/test/regress/sql/insert.sql
+index bdcffd0314..7ada0801eb 100644
+--- a/src/test/regress/sql/insert.sql
++++ b/src/test/regress/sql/insert.sql
+@@ -55,7 +55,7 @@ INSERT INTO large_tuple_test (select 3, NULL);
+
+ -- now this tuple won't fit on the second page, but the insert should
+ -- still succeed by extending the relation
+-INSERT INTO large_tuple_test (select 4, repeat('a', 8126));
++INSERT INTO large_tuple_test (select 4, repeat('a', 8112));
+
+ DROP TABLE large_tuple_test;
+
+@@ -597,3 +597,18 @@ alter table returningwrtest2 drop c;
+ alter table returningwrtest attach partition returningwrtest2 for values in (2);
+ insert into returningwrtest values (2, 'foo') returning returningwrtest;
+ drop table returningwrtest;
++
++-- Check for MaxHeapTupleSize
++create table maxheaptuplesize_test(value text);
++alter table maxheaptuplesize_test alter column value set storage external;
++insert into maxheaptuplesize_test values (repeat('x', 8104));
++insert into maxheaptuplesize_test values (repeat('x', 8112));
++insert into maxheaptuplesize_test values (repeat('x', 8120));
++insert into maxheaptuplesize_test values (repeat('x', 8128));
++insert into maxheaptuplesize_test values (repeat('x', 8136));
++insert into maxheaptuplesize_test values (repeat('x', 8144));
++insert into maxheaptuplesize_test values (repeat('x', 8152));
++insert into maxheaptuplesize_test values (repeat('x', 8160));
++insert into maxheaptuplesize_test values (repeat('x', 8168));
++insert into maxheaptuplesize_test values (repeat('x', 8176));
++drop table maxheaptuplesize_test;
+diff --git a/src/test/regress/sql/select_views.sql b/src/test/regress/sql/select_views.sql
+index e742f13699..a94bd7259c 100644
+--- a/src/test/regress/sql/select_views.sql
++++ b/src/test/regress/sql/select_views.sql
+@@ -3,7 +3,7 @@
+ -- test the views defined in CREATE_VIEWS
+ --
+
+-SELECT * FROM street;
++SELECT * FROM street ORDER BY name COLLATE "C", thepath::text COLLATE "C", cname COLLATE "C";
+
+ SELECT name, #thepath FROM iexit ORDER BY name COLLATE "C", 2;
+
+diff --git a/src/test/regress/sql/type_sanity.sql b/src/test/regress/sql/type_sanity.sql
+index e88d6cbe49..bbc2213b54 100644
+--- a/src/test/regress/sql/type_sanity.sql
++++ b/src/test/regress/sql/type_sanity.sql
+@@ -22,7 +22,7 @@ WHERE t1.typnamespace = 0 OR
+ (t1.typlen <= 0 AND t1.typlen != -1 AND t1.typlen != -2) OR
+ (t1.typtype not in ('b', 'c', 'd', 'e', 'm', 'p', 'r')) OR
+ NOT t1.typisdefined OR
+- (t1.typalign not in ('c', 's', 'i', 'd')) OR
++ (t1.typalign not in ('c', 's', 'i', 'd', 'x')) OR
+ (t1.typstorage not in ('p', 'x', 'e', 'm'));
+
+ -- Look for "pass by value" types that can't be passed by value.
+@@ -33,7 +33,8 @@ WHERE t1.typbyval AND
+ (t1.typlen != 1 OR t1.typalign != 'c') AND
+ (t1.typlen != 2 OR t1.typalign != 's') AND
+ (t1.typlen != 4 OR t1.typalign != 'i') AND
+- (t1.typlen != 8 OR t1.typalign != 'd');
++ (t1.typlen != 8 OR t1.typalign != 'd') AND
++ (t1.typlen != 8 OR t1.typalign != 'x');
+
+ -- Look for "toastable" types that aren't varlena.
+
+diff --git a/src/test/regress/sql/xid.sql b/src/test/regress/sql/xid.sql
+index 9f716b3653..9b94cb9a4a 100644
+--- a/src/test/regress/sql/xid.sql
++++ b/src/test/regress/sql/xid.sql
+@@ -19,7 +19,7 @@ select 'asdf'::xid8;
+ -- Also try it with non-error-throwing API
+ SELECT pg_input_is_valid('42', 'xid');
+ SELECT pg_input_is_valid('asdf', 'xid');
+-SELECT * FROM pg_input_error_info('0xffffffffff', 'xid');
++SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid');
+ SELECT pg_input_is_valid('42', 'xid8');
+ SELECT pg_input_is_valid('asdf', 'xid8');
+ SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid8');
+diff --git a/src/test/regress/sql/xid64.sql b/src/test/regress/sql/xid64.sql
+new file mode 100644
+index 0000000000..caa97a0ed9
+--- /dev/null
++++ b/src/test/regress/sql/xid64.sql
+@@ -0,0 +1,84 @@
++---
++--- Unit test for xid64 functions
++---
++
++-- directory paths and dlsuffix are passed to us in environment variables
++\getenv libdir PG_LIBDIR
++\getenv dlsuffix PG_DLSUFFIX
++
++\set regresslib :libdir '/regress' :dlsuffix
++
++CREATE FUNCTION xid64_test_1(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_1' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_2(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_2' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_double_xmax(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_double_xmax' LANGUAGE C STRICT;
++
++---
++--- Check page consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(a int);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++INSERT INTO test_xid64_table(a) SELECT a FROM generate_series(1, 1000) AS a;
++SELECT xid64_test_1('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++---
++--- Check tuples consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(s serial, i int, t text);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++
++DO $$
++BEGIN
++ FOR j IN 1..20 LOOP
++ INSERT INTO test_xid64_table(i, t) VALUES (random()::int, md5(random()::text));
++ COMMIT;
++ END LOOP;
++END $$;
++
++DO $$
++BEGIN
++ FOR j IN 1..10 LOOP
++ DELETE FROM test_xid64_table WHERE ctid IN (SELECT ctid FROM test_xid64_table TABLESAMPLE BERNOULLI (5));
++ COMMIT;
++ END LOOP;
++END $$;
++
++SELECT xid64_test_2('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++---
++--- Check tuples consistency after conversion to double xmax (on full page)
++---
++CREATE UNLOGGED TABLE test_xid64_table(i int);
++
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table SELECT i FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++
++SELECT xid64_test_2('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++CREATE UNLOGGED TABLE test_xid64_table(i text);
++INSERT INTO test_xid64_table(i) VALUES ('NNBABCDSDFGHJKLP');
++
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table(i) SELECT 'A' FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++
++SELECT xid64_test_double_xmax('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++DROP FUNCTION xid64_test_1(rel regclass);
++DROP FUNCTION xid64_test_2(rel regclass);
++DROP FUNCTION xid64_test_double_xmax(rel regclass);
+diff --git a/src/test/xid-64/Makefile b/src/test/xid-64/Makefile
+new file mode 100644
+index 0000000000..3b1e50dfc0
+--- /dev/null
++++ b/src/test/xid-64/Makefile
+@@ -0,0 +1,22 @@
++#-------------------------------------------------------------------------
++#
++# Makefile for src/test/xid-64
++#
++# Copyright (c) 2018, Postgres Professional
++#
++# src/test/xid-64/Makefile
++#
++#-------------------------------------------------------------------------
++
++subdir = src/test/xid-64
++top_builddir = ../../..
++include $(top_builddir)/src/Makefile.global
++
++check:
++ $(prove_check)
++
++installcheck:
++ $(prove_installcheck)
++
++clean distclean maintainer-clean:
++ rm -rf tmp_check
+diff --git a/src/test/xid-64/README b/src/test/xid-64/README
+new file mode 100644
+index 0000000000..01c0a1a1f7
+--- /dev/null
++++ b/src/test/xid-64/README
+@@ -0,0 +1,16 @@
++src/test/xid-64/README
++
++Regression tests for 64-bit XIDs
++=============================================
++
++This directory contains a test suite for 64-bit xids.
++
++Running the tests
++=================
++
++ make check
++
++NOTE: This creates a temporary installation, and some tests may
++create one or multiple nodes.
++
++NOTE: This requires the --enable-tap-tests argument to configure.
+diff --git a/src/test/xid-64/meson.build b/src/test/xid-64/meson.build
+new file mode 100644
+index 0000000000..63a780b69e
+--- /dev/null
++++ b/src/test/xid-64/meson.build
+@@ -0,0 +1,16 @@
++tests += {
++ 'name': 'xid-64',
++ 'sd': meson.current_source_dir(),
++ 'bd': meson.current_build_dir(),
++ 'tap': {
++ 'tests': [
++ 't/001_test_large_xids.pl',
++ 't/002_test_gucs.pl',
++ 't/003_test_integrity.pl',
++ 't/004_test_relminmxid.pl',
++ 't/005_stream_subxact.pl',
++ 't/006_zeropage.pl',
++ 't/007_first_multi.pl',
++ ],
++ },
++}
+diff --git a/src/test/xid-64/t/002_test_gucs.pl b/src/test/xid-64/t/002_test_gucs.pl
+new file mode 100644
+index 0000000000..9341389233
+--- /dev/null
++++ b/src/test/xid-64/t/002_test_gucs.pl
+@@ -0,0 +1,79 @@
++# Tests for guc boundary values
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++use bigint;
++
++sub command_output
++{
++ my ($cmd) = @_;
++ my ($stdout, $stderr);
++ print("# Running: " . join(" ", @{$cmd}) . "\n");
++ my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
++ ok($result, "@$cmd exit code 0");
++ is($stderr, '', "@$cmd no stderr");
++ return $stdout;
++}
++
++sub set_guc
++{
++ my ($node, $guc, $val) = @_;
++ print("SET $guc = $val\n");
++ $node->safe_psql('postgres', "ALTER SYSTEM SET $guc = $val");
++ $node->restart();
++}
++
++sub test_pgbench
++{
++ my ($node) = @_;
++ $node->command_ok(
++ [ qw(pgbench --progress=5 --transactions=1000 --jobs=5 --client=5) ],
++ 'pgbench finished without errors');
++}
++
++my @guc_vals = (
++ [ "autovacuum_freeze_max_age", 100000, 2**63 - 1 ],
++ [ "autovacuum_multixact_freeze_max_age", 10000, 2**63 - 1 ],
++ [ "vacuum_freeze_min_age", 0, 2**63 - 1 ],
++ [ "vacuum_freeze_table_age", 0, 2**63 - 1 ],
++ [ "vacuum_multixact_freeze_min_age", 0, 2**63 - 1 ],
++ [ "vacuum_multixact_freeze_table_age", 0, 2**63 -1 ]
++);
++
++my $START_VAL = 2**32;
++my $MAX_VAL = 2**62;
++
++my $ixid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imxid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imoff = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++
++# Initialize master node
++my $node = PostgreSQL::Test::Cluster->new('master');
++$node->init;
++# Disable logging of all statements to avoid log bloat during pgbench
++$node->append_conf('postgresql.conf', "log_statement = none");
++$node->start;
++
++# Fill the test database with the pgbench data
++$node->command_ok(
++ [ qw(pgbench --initialize --scale=10) ],
++ 'pgbench finished without errors');
++
++# Test all GUCs with minimum, maximum and random value inbetween
++# (run pgbench for every configuration setting)
++foreach my $gi (0 .. $#guc_vals) {
++ print($guc_vals[$gi][0]); print("\n");
++ my $guc = $guc_vals[$gi][0];
++ my $minval = $guc_vals[$gi][1];
++ my $maxval = $guc_vals[$gi][2];
++ set_guc($node, $guc, $minval);
++ test_pgbench($node);
++ set_guc($node, $guc, $maxval);
++ test_pgbench($node);
++ set_guc($node, $guc, $minval + int(rand($maxval - $minval)));
++ test_pgbench($node);
++}
++
++done_testing();
+diff --git a/src/test/xid-64/t/003_test_integrity.pl b/src/test/xid-64/t/003_test_integrity.pl
+new file mode 100644
+index 0000000000..5b0789688e
+--- /dev/null
++++ b/src/test/xid-64/t/003_test_integrity.pl
+@@ -0,0 +1,58 @@
++# Check integrity after dump/restore with different xids
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++use File::Compare;
++
++my $tempdir = PostgreSQL::Test::Utils::tempdir;
++use bigint;
++
++my $START_VAL = 2**32;
++my $MAX_VAL = 2**62;
++
++my $ixid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imxid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imoff = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++
++# Initialize master node
++my $node = PostgreSQL::Test::Cluster->new('master');
++$node->init();
++$node->start;
++
++# Create a database and fill it with the pgbench data
++$node->safe_psql('postgres', "CREATE DATABASE pgbench_db");
++$node->command_ok(
++ [ qw(pgbench --initialize --scale=2 pgbench_db) ],
++ 'pgbench finished without errors');
++# Dump the database (cluster the main table to put data in a determined order)
++$node->safe_psql('pgbench_db', qq(
++ CREATE INDEX pa_aid_idx ON pgbench_accounts (aid);
++ CLUSTER pgbench_accounts USING pa_aid_idx));
++$node->command_ok(
++ [ "pg_dump", "-w", "--inserts", "--file=$tempdir/pgbench.sql", "pgbench_db" ],
++ 'pgdump finished without errors');
++$node->stop('fast');
++
++# Initialize second node
++my $node2 = PostgreSQL::Test::Cluster->new('master2');
++$node2->init;
++# Disable logging of all statements to avoid log bloat during restore
++$node2->append_conf('postgresql.conf', "log_statement = none");
++$node2->start;
++
++# Create a database and restore the previous dump
++$node2->safe_psql('postgres', "CREATE DATABASE pgbench_db");
++my $txid0 = $node2->safe_psql('pgbench_db', 'SELECT txid_current()');
++print("# Initial txid_current: $txid0\n");
++$node2->command_ok(["psql", "-q", "-f", "$tempdir/pgbench.sql", "pgbench_db"]);
++
++# Dump the database and compare the dumped content with the previous one
++$node2->safe_psql('pgbench_db', 'CLUSTER pgbench_accounts');
++$node2->command_ok(
++ [ "pg_dump", "-w", "--inserts", "--file=$tempdir/pgbench2.sql", "pgbench_db" ],
++ 'pgdump finished without errors');
++ok(File::Compare::compare_text("$tempdir/pgbench.sql", "$tempdir/pgbench2.sql") == 0, "no differences detected");
++
++done_testing();
+diff --git a/src/test/xid-64/t/004_test_relminmxid.pl b/src/test/xid-64/t/004_test_relminmxid.pl
+new file mode 100644
+index 0000000000..e924f9cd9a
+--- /dev/null
++++ b/src/test/xid-64/t/004_test_relminmxid.pl
+@@ -0,0 +1,90 @@
++# Check integrity after dump/restore with different xids
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++use bigint;
++
++my ($node, $rmm, $vacout);
++$node = PostgreSQL::Test::Cluster->new('master');
++$node->init;
++$node->append_conf('postgresql.conf', 'max_prepared_transactions = 2');
++$node->start;
++
++sub relminmxid
++{
++ my $rmm = $node->safe_psql("postgres", qq(
++ SELECT relminmxid
++ FROM pg_class
++ WHERE relname = 'foo';));
++ return $rmm + 0;
++}
++
++sub vacuum
++{
++ my ($rc, $stdout, $stderr) = $node->psql("postgres", "VACUUM foo;");
++ return $stdout.$stderr;
++}
++
++sub gen_multixact
++{
++ $node->safe_psql("postgres", qq(
++ BEGIN;
++ SELECT * FROM foo FOR KEY SHARE;
++ PREPARE TRANSACTION 'fooshare';
++ ));
++
++ my $xmax = $node->safe_psql("postgres", qq(
++ SELECT xmax FROM foo;
++ ));
++ isnt($xmax + 0, 0, "xmax not empty");
++
++ $node->safe_psql("postgres", qq(
++ BEGIN;
++ SELECT * FROM foo FOR KEY SHARE;
++ COMMIT;
++ COMMIT PREPARED 'fooshare';
++ ));
++
++ my $mxact = $node->safe_psql("postgres", qq(
++ SELECT xmax FROM foo;
++ ));
++ isnt($mxact + 0, 0, "mxact not empty");
++ cmp_ok($xmax, '>', $mxact, "xmax is greater than mxact");
++}
++
++# Initialize master node with the random xid-related parameters
++$node->safe_psql("postgres", "CREATE TABLE foo (a int); INSERT INTO foo VALUES (1);");
++
++is(relminmxid(), 1, "relminmxid is default");
++
++vacuum();
++is(relminmxid(), 1, "relminmxid is still default");
++
++gen_multixact();
++is(relminmxid(), 1, "relminmxid is still still default");
++
++unlike(vacuum(), qr/multixact.*before relminmxid/, "no relminmxid error");
++
++# No intentionally break relminmxid
++$node->safe_psql("postgres", qq(
++ UPDATE pg_class SET relminmxid = ((1::int8<<62) + 1)::text::xid
++ WHERE relname = 'foo'
++));
++cmp_ok(relminmxid(), '>', 2**62, "relminmxid broken (intentionally)");
++
++gen_multixact();
++like(vacuum(), qr/multixact.*before relminmxid/, "got relminmxid error");
++cmp_ok(relminmxid(), '>', 2**62, "relminmxid broken (still)");
++
++# Fix relminmxid by setting to default
++$node->safe_psql("postgres", qq(
++ UPDATE pg_class SET relminmxid = '1'
++ WHERE relname = 'foo'
++));
++is(relminmxid(), 1, "relminmxid is default again");
++
++unlike(vacuum(), qr/multixact.*before relminmxid/, "no relminmxid error again");
++
++done_testing();
+diff --git a/src/test/xid-64/t/005_stream_subxact.pl b/src/test/xid-64/t/005_stream_subxact.pl
+new file mode 100644
+index 0000000000..6765f6061c
+--- /dev/null
++++ b/src/test/xid-64/t/005_stream_subxact.pl
+@@ -0,0 +1,100 @@
++
++# Copyright (c) 2021, PostgreSQL Global Development Group
++
++# Test xids streaming of large transaction containing large subtransactions
++# near 32-bit boundary.
++#
++# Mostly it is a copy of 016_stream_subxact.pl, but with publisher xid inited
++# just before 32-bit boundary, so if xids are replicated as 32-bit values,
++# subscriber will get 0 xid value.
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++
++# Create publisher node
++my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
++$node_publisher->init(allows_streaming => 'logical');
++$node_publisher->append_conf('postgresql.conf',
++ 'logical_decoding_work_mem = 64kB');
++$node_publisher->start;
++
++# Create subscriber node
++my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
++$node_subscriber->init(allows_streaming => 'logical');
++$node_subscriber->start;
++
++# Create some preexisting content on publisher
++$node_publisher->safe_psql('postgres',
++ "CREATE TABLE test_tab (a int primary key, b varchar)");
++$node_publisher->safe_psql('postgres',
++ "INSERT INTO test_tab VALUES (1, 'foo'), (2, 'bar')");
++
++# Setup structure on subscriber
++$node_subscriber->safe_psql('postgres',
++ "CREATE TABLE test_tab (a int primary key, b text, c timestamptz DEFAULT now(), d bigint DEFAULT 999)"
++);
++
++# Setup logical replication
++my $publisher_connstr = $node_publisher->connstr . ' dbname=postgres';
++$node_publisher->safe_psql('postgres',
++ "CREATE PUBLICATION tap_pub FOR TABLE test_tab");
++
++my $appname = 'tap_sub';
++$node_subscriber->safe_psql('postgres',
++ "CREATE SUBSCRIPTION tap_sub CONNECTION '$publisher_connstr application_name=$appname' PUBLICATION tap_pub WITH (streaming = on)"
++);
++
++$node_publisher->wait_for_catchup($appname);
++
++# Also wait for initial table sync to finish
++my $synced_query =
++ "SELECT count(1) = 0 FROM pg_subscription_rel WHERE srsubstate NOT IN ('r', 's');";
++$node_subscriber->poll_query_until('postgres', $synced_query)
++ or die "Timed out while waiting for subscriber to synchronize data";
++
++my $result =
++ $node_subscriber->safe_psql('postgres',
++ "SELECT count(*), count(c), count(d = 999) FROM test_tab");
++is($result, qq(2|2|2), 'check initial data was copied to subscriber');
++
++# Insert, update and delete enough rows to exceed 64kB limit.
++$node_publisher->safe_psql(
++ 'postgres', q{
++BEGIN;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series( 3, 500) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s1;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(501, 1000) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s2;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(1001, 1500) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s3;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(1501, 2000) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s4;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(2001, 2500) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++COMMIT;
++});
++
++$node_publisher->wait_for_catchup($appname);
++
++$result =
++ $node_subscriber->safe_psql('postgres',
++ "SELECT count(*), count(c), count(d = 999) FROM test_tab");
++is($result, qq(1667|1667|1667),
++ 'check data was copied to subscriber in streaming mode and extra columns contain local defaults'
++);
++
++$node_subscriber->stop;
++$node_publisher->stop;
++
++done_testing();
+diff --git a/src/test/xid-64/t/006_zeropage.pl b/src/test/xid-64/t/006_zeropage.pl
+new file mode 100644
+index 0000000000..4b87c90edc
+--- /dev/null
++++ b/src/test/xid-64/t/006_zeropage.pl
+@@ -0,0 +1,33 @@
++use strict;
++use warnings;
++
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++
++# Check WAL for ZEROPAGE record.
++
++sub command_output
++{
++ my ($cmd) = @_;
++ my ($stdout, $stderr);
++ print("# Running: " . join(" ", @{$cmd}) . "\n");
++ my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
++ return $stdout;
++}
++
++my $node = PostgreSQL::Test::Cluster->new('main');
++$node->init;
++$node->start;
++my $pgdata = $node->data_dir;
++my $xlogfilename0 = $node->safe_psql('postgres',
++ "SELECT pg_walfile_name(pg_current_wal_lsn())");
++#$node->command_like(
++# [ 'pg_waldump', '-S', "$pgdata/pg_wal/$xlogfilename0" ],
++# qr/ZEROPAGE/,
++# 'pg_waldump prints start timestamp');
++my $wd_output = command_output(
++ [ 'pg_waldump', "$pgdata/pg_wal/$xlogfilename0" ]);
++ok($wd_output =~ qr/ZEROPAGE page 0/, "ZEROPAGE found");
++
++done_testing();
+diff --git a/src/test/xid-64/t/007_first_multi.pl b/src/test/xid-64/t/007_first_multi.pl
+new file mode 100644
+index 0000000000..eca2c39af9
+--- /dev/null
++++ b/src/test/xid-64/t/007_first_multi.pl
+@@ -0,0 +1,83 @@
++# Test for pages with first tuple has xmax multi
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++
++sub test_multixact
++{
++ my ($primary, $standby, $test_name) = @_;
++
++ $primary->safe_psql('postgres', q{
++ CREATE TABLE t (id INT, data TEXT, CONSTRAINT t_id_pk PRIMARY KEY(id));
++ INSERT INTO t SELECT 1, repeat('a', 1000);
++ });
++
++ my %psql = (
++ '1' => $primary->background_psql('postgres'),
++ '2' => $primary->background_psql('postgres'),
++ );
++
++ # Lock tuples
++ $psql{1}->query_safe(q(
++ BEGIN;
++ SELECT * FROM t FOR KEY SHARE;
++ ));
++
++ $psql{2}->query_safe(q(
++ BEGIN;
++ SELECT * FROM t FOR KEY SHARE;
++ ));
++
++ # Repeat update until we get a new page with one tuple
++ my $res;
++ my $guard = 0;
++
++ do {
++ $res = $primary->safe_psql('postgres', q{
++ UPDATE t SET data = repeat('a', 1000) RETURNING ctid;
++ });
++ # Fail if we already write around 64k and still have no new page.
++ fail("creating second page") if (++$guard == 64);
++ } until ($res eq "(1,1)");
++
++ $psql{1}->quit;
++ $psql{2}->quit;
++ $primary->wait_for_catchup($standby);
++
++ # Check results
++ my $query = q{
++ SELECT xmax, ctid, id, data = repeat('a', 1000) as data FROM t;
++ };
++ my $res_primary = $primary->safe_psql('postgres', $query);
++ my $res_standby = $standby->safe_psql('postgres', $query);
++
++ is($res_primary, $res_standby, "rows are the same in test $test_name");
++}
++
++# We should run test for full_page_writes on and off.
++foreach ('true', 'false') {
++ # Create primary
++ my $primary = PostgreSQL::Test::Cluster->new("master_$_");
++ $primary->init(allows_streaming => 1);
++ $primary->append_conf('postgresql.conf', "full_page_writes = $_");
++ $primary->start;
++
++ # Take backup
++ my $backup_name = "my_backup_$_";
++ $primary->backup($backup_name);
++
++ # Create standby from backup
++ my $standby = PostgreSQL::Test::Cluster->new("standby_$_");
++ $standby->init_from_backup($primary, $backup_name, has_streaming => 1);
++ $standby->start;
++
++ # Check
++ test_multixact($primary, $standby, "with FPW $_");
++
++ $standby->stop();
++ $primary->stop();
++}
++
++done_testing();
+diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
+index 38a86575e1..194646ef2d 100644
+--- a/src/tools/pgindent/typedefs.list
++++ b/src/tools/pgindent/typedefs.list
+@@ -3438,8 +3438,8 @@ intset_leaf_node
+ intset_node
+ intvKEY
+ io_stat_col
+-itemIdCompact
+-itemIdCompactData
++ItemIdCompact
++ItemIdCompactData
+ iterator
+ jmp_buf
+ join_search_hook_type
+--
+2.34.1
+
diff --git a/baloo/patches/func/xid64.patch b/baloo/patches/func/xid64.patch
new file mode 100644
index 00000000000..5cfda3f8f42
--- /dev/null
+++ b/baloo/patches/func/xid64.patch
@@ -0,0 +1,16689 @@
+From fa679002517e0b0081c5afb60740366af8f692ab Mon Sep 17 00:00:00 2001
+From: Evgeny Voropaev <evorop@gmail.com>
+Date: Wed, 8 Dec 2024 23:05:00 +0800
+Subject: [PATCH] Use 64-bit XIDs
+
+- change TransactionId to 64bit
+- disk tuple format (HeapTupleHeader) is (almost) unchanged: xmin and xmax remains 32bit
+ -- now 32bit xid is named ShortTransactionId
+- heap page format is changed to contain xid and multixact base value, tuple's
+ xmin and xmax are offsets from.
+ -- xid_base and multi_base are stored as a page special data. PageHeader remains unmodified.
+- in-memory tuple (HeapTuple) were enriched with precalculated 64bit xmin/xmax.
+
+Authors:
+- Alexander Korotkov <aekorotkov@gmail.com>
+- Teodor Sigaev <teodor@sigaev.ru>
+- Nikita Glukhov <n.gluhov@postgrespro.ru>
+- Maxim Orlov <orlovmg@gmail.com>
+- Pavel Borisov <pashkin.elfe@gmail.com>
+- Yura Sokolov <y.sokolov@postgrespro.ru> <funny.falcon@gmail.com>
+- Aleksander Alekseev <aleksander@timescale.com>
+- Evgeny Voropaev <evorop@gmail.com> <evgeny.voropaev@tantorlabs.ru>
+
+Discussion: https://www.postgresql.org/message-id/flat/CACG%3DezZe1NQSCnfHOr78AtAZxJZeCvxrts0ygrxYwe%3DpyyjVWA%40mail.gmail.com
+---
+ contrib/amcheck/verify_heapam.c | 119 +--
+ contrib/amcheck/verify_nbtree.c | 2 +-
+ contrib/hstore/hstore_io.c | 2 +
+ contrib/pageinspect/Makefile | 3 +-
+ contrib/pageinspect/btreefuncs.c | 18 +-
+ contrib/pageinspect/expected/btree.out | 4 +-
+ contrib/pageinspect/expected/hash_1.out | 166 ++++
+ contrib/pageinspect/expected/oldextversions.out | 10 +-
+ contrib/pageinspect/expected/page.out | 28 +-
+ contrib/pageinspect/heapfuncs.c | 10 +-
+ contrib/pageinspect/pageinspect--1.12--1.13.sql | 145 ++++
+ contrib/pageinspect/pageinspect--1.5.sql | 2 +
+ contrib/pageinspect/rawpage.c | 35 +-
+ contrib/pageinspect/sql/btree.sql | 3 +-
+ contrib/pg_surgery/heap_surgery.c | 17 +-
+ contrib/pg_visibility/pg_visibility.c | 7 +-
+ contrib/pgrowlocks/pgrowlocks.c | 2 +-
+ contrib/pgstattuple/pgstatapprox.c | 4 +
+ contrib/pgstattuple/pgstatindex.c | 2 +-
+ contrib/postgres_fdw/expected/postgres_fdw.out | 55 +-
+ contrib/postgres_fdw/postgres_fdw.c | 9 +-
+ contrib/postgres_fdw/sql/postgres_fdw.sql | 15 +-
+ src/backend/access/common/heaptuple.c | 10 +-
+ src/backend/access/heap/heapam.c | 999 +++++++++++++++++++++---
+ src/backend/access/heap/heapam_handler.c | 62 +-
+ src/backend/access/heap/heapam_visibility.c | 173 ++--
+ src/backend/access/heap/heapam_xlog.c | 161 +++-
+ src/backend/access/heap/heaptoast.c | 3 +
+ src/backend/access/heap/hio.c | 36 +-
+ src/backend/access/heap/pruneheap.c | 131 +++-
+ src/backend/access/heap/rewriteheap.c | 101 ++-
+ src/backend/access/heap/vacuumlazy.c | 144 +---
+ src/backend/access/nbtree/nbtpage.c | 2 +
+ src/backend/access/nbtree/nbtsplitloc.c | 16 +-
+ src/backend/access/rmgrdesc/gistdesc.c | 4 +-
+ src/backend/access/rmgrdesc/heapdesc.c | 34 +-
+ src/backend/access/rmgrdesc/nbtdesc.c | 4 +-
+ src/backend/access/rmgrdesc/xactdesc.c | 6 +-
+ src/backend/access/rmgrdesc/xlogdesc.c | 2 +-
+ src/backend/access/transam/clog.c | 19 +-
+ src/backend/access/transam/commit_ts.c | 19 -
+ src/backend/access/transam/multixact.c | 52 +-
+ src/backend/access/transam/slru.c | 11 +-
+ src/backend/access/transam/subtrans.c | 13 +-
+ src/backend/access/transam/transam.c | 18 +-
+ src/backend/access/transam/twophase.c | 55 +-
+ src/backend/access/transam/varsup.c | 177 +----
+ src/backend/access/transam/xact.c | 35 +-
+ src/backend/access/transam/xlog.c | 9 +-
+ src/backend/access/transam/xloginsert.c | 7 +
+ src/backend/access/transam/xlogreader.c | 34 -
+ src/backend/bootstrap/bootstrap.c | 2 +-
+ src/backend/catalog/heap.c | 8 +-
+ src/backend/catalog/pg_inherits.c | 2 +-
+ src/backend/commands/async.c | 2 +-
+ src/backend/commands/dbcommands.c | 9 +-
+ src/backend/commands/indexcmds.c | 6 +-
+ src/backend/commands/sequence.c | 30 +-
+ src/backend/commands/vacuum.c | 20 +-
+ src/backend/executor/execExprInterp.c | 1 +
+ src/backend/executor/execTuples.c | 4 +-
+ src/backend/executor/execUtils.c | 1 +
+ src/backend/executor/nodeModifyTable.c | 1 +
+ src/backend/executor/spi.c | 1 +
+ src/backend/nodes/gen_node_support.pl | 6 +-
+ src/backend/optimizer/util/plancat.c | 2 +-
+ src/backend/postmaster/autovacuum.c | 64 +-
+ src/backend/replication/logical/conflict.c | 20 +-
+ src/backend/replication/logical/decode.c | 24 +-
+ src/backend/replication/logical/proto.c | 50 +-
+ src/backend/replication/logical/reorderbuffer.c | 17 +-
+ src/backend/replication/logical/slotsync.c | 2 +-
+ src/backend/replication/logical/snapbuild.c | 4 +-
+ src/backend/replication/logical/worker.c | 2 +-
+ src/backend/replication/walreceiver.c | 28 +-
+ src/backend/replication/walsender.c | 73 +-
+ src/backend/statistics/extended_stats.c | 1 +
+ src/backend/storage/buffer/Makefile | 3 +-
+ src/backend/storage/buffer/bufmgr.c | 123 +++
+ src/backend/storage/buffer/heap_convert.c | 549 +++++++++++++
+ src/backend/storage/buffer/meson.build | 1 +
+ src/backend/storage/ipc/procarray.c | 186 ++---
+ src/backend/storage/ipc/standby.c | 4 +-
+ src/backend/storage/lmgr/lmgr.c | 14 +-
+ src/backend/storage/lmgr/lock.c | 4 +-
+ src/backend/storage/lmgr/predicate.c | 31 +-
+ src/backend/storage/lmgr/proc.c | 12 +-
+ src/backend/storage/page/bufpage.c | 254 +++++-
+ src/backend/utils/adt/enum.c | 2 +-
+ src/backend/utils/adt/jsonfuncs.c | 2 +
+ src/backend/utils/adt/lockfuncs.c | 9 +-
+ src/backend/utils/adt/pgstatfuncs.c | 1 +
+ src/backend/utils/adt/rowtypes.c | 12 +
+ src/backend/utils/adt/xid.c | 37 +-
+ src/backend/utils/adt/xid8funcs.c | 89 +--
+ src/backend/utils/cache/catcache.c | 1 +
+ src/backend/utils/cache/relcache.c | 3 +-
+ src/backend/utils/fmgr/fmgr.c | 4 +-
+ src/backend/utils/misc/guc_tables.c | 164 ++--
+ src/backend/utils/misc/help_config.c | 8 +-
+ src/backend/utils/misc/pg_controldata.c | 2 +-
+ src/backend/utils/misc/postgresql.conf.sample | 2 +-
+ src/backend/utils/sort/tuplesortvariants.c | 14 +-
+ src/backend/utils/time/combocid.c | 20 +-
+ src/backend/utils/time/snapmgr.c | 24 +-
+ src/bin/pg_amcheck/t/004_verify_heapam.pl | 185 ++++-
+ src/bin/pg_controldata/pg_controldata.c | 2 +-
+ src/bin/pg_dump/pg_dump.c | 27 +-
+ src/bin/pg_dump/pg_dump.h | 8 +-
+ src/bin/pg_resetwal/pg_resetwal.c | 53 +-
+ src/bin/pg_resetwal/t/001_basic.pl | 18 +-
+ src/bin/pg_upgrade/check.c | 149 +++-
+ src/bin/pg_upgrade/controldata.c | 17 +-
+ src/bin/pg_upgrade/file.c | 99 ++-
+ src/bin/pg_upgrade/pg_upgrade.c | 104 ++-
+ src/bin/pg_upgrade/pg_upgrade.h | 31 +-
+ src/bin/pg_upgrade/relfilenumber.c | 34 +-
+ src/bin/pg_upgrade/segresize.c | 70 ++
+ src/bin/pg_upgrade/t/002_pg_upgrade.pl | 18 +
+ src/bin/pg_upgrade/version.c | 106 ++-
+ src/bin/pg_waldump/pg_waldump.c | 2 +-
+ src/bin/pg_waldump/t/001_basic.pl | 3 +-
+ src/include/access/ginblock.h | 11 +-
+ src/include/access/gist.h | 2 +-
+ src/include/access/heapam.h | 56 +-
+ src/include/access/heapam_xlog.h | 29 +-
+ src/include/access/heaptoast.h | 11 +-
+ src/include/access/htup.h | 19 +-
+ src/include/access/htup_details.h | 306 +++++++-
+ src/include/access/multixact.h | 8 +-
+ src/include/access/nbtree.h | 10 +
+ src/include/access/reloptions.h | 2 +-
+ src/include/access/rewriteheap.h | 4 +-
+ src/include/access/rmgrlist.h | 1 +
+ src/include/access/slru.h | 10 +-
+ src/include/access/tableam.h | 2 +-
+ src/include/access/transam.h | 92 ++-
+ src/include/access/tupmacs.h | 3 +-
+ src/include/access/xact.h | 13 +-
+ src/include/access/xloginsert.h | 1 +
+ src/include/access/xlogreader.h | 4 -
+ src/include/access/xlogrecord.h | 5 +-
+ src/include/c.h | 21 +-
+ src/include/catalog/catversion.h | 3 +-
+ src/include/catalog/pg_operator.dat | 8 +-
+ src/include/catalog/pg_proc.dat | 12 +-
+ src/include/catalog/pg_type.dat | 4 +-
+ src/include/catalog/pg_type.h | 5 +
+ src/include/commands/vacuum.h | 22 +-
+ src/include/fmgr.h | 2 +
+ src/include/nodes/pg_list.h | 4 +
+ src/include/pg_config.h.in | 3 +
+ src/include/port/pg_lfind.h | 62 ++
+ src/include/postgres.h | 9 +-
+ src/include/postmaster/autovacuum.h | 4 +-
+ src/include/storage/buf_internals.h | 5 +-
+ src/include/storage/bufmgr.h | 6 +
+ src/include/storage/bufpage.h | 232 +++++-
+ src/include/storage/itemid.h | 2 +
+ src/include/storage/lock.h | 14 +-
+ src/include/storage/proc.h | 7 +-
+ src/include/utils/combocid.h | 2 +-
+ src/include/utils/xid8.h | 4 +-
+ src/pl/plperl/plperl.c | 4 +-
+ src/pl/plpgsql/src/pl_comp.c | 4 +-
+ src/pl/plpgsql/src/pl_exec.c | 2 +
+ src/pl/plpython/plpy_procedure.c | 4 +-
+ src/pl/tcl/pltcl.c | 4 +-
+ src/test/Makefile | 3 +-
+ src/test/meson.build | 1 +
+ src/test/modules/test_lfind/test_lfind.c | 30 +-
+ src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm | 4 +
+ src/test/recovery/t/003_recovery_targets.pl | 2 +-
+ src/test/recovery/t/039_end_of_wal.pl | 24 +-
+ src/test/regress/expected/indirect_toast.out | 8 +
+ src/test/regress/expected/insert.out | 16 +-
+ src/test/regress/expected/opr_sanity.out | 6 +-
+ src/test/regress/expected/select_views.out | 86 +-
+ src/test/regress/expected/txid.out | 8 +-
+ src/test/regress/expected/type_sanity.out | 5 +-
+ src/test/regress/expected/xid.out | 22 +-
+ src/test/regress/expected/xid64.out | 92 +++
+ src/test/regress/parallel_schedule | 2 +-
+ src/test/regress/regress.c | 298 +++++++
+ src/test/regress/sql/indirect_toast.sql | 11 +
+ src/test/regress/sql/insert.sql | 17 +-
+ src/test/regress/sql/select_views.sql | 2 +-
+ src/test/regress/sql/type_sanity.sql | 5 +-
+ src/test/regress/sql/xid.sql | 2 +-
+ src/test/regress/sql/xid64.sql | 84 ++
+ src/test/xid-64/.gitignore | 8 +
+ src/test/xid-64/Makefile | 22 +
+ src/test/xid-64/README | 16 +
+ src/test/xid-64/meson.build | 16 +
+ src/test/xid-64/t/002_test_gucs.pl | 79 ++
+ src/test/xid-64/t/003_test_integrity.pl | 58 ++
+ src/test/xid-64/t/004_test_relminmxid.pl | 90 +++
+ src/test/xid-64/t/005_stream_subxact.pl | 100 +++
+ src/test/xid-64/t/006_zeropage.pl | 33 +
+ src/test/xid-64/t/007_first_multi.pl | 83 ++
+ src/tools/pgindent/typedefs.list | 4 +-
+ 201 files changed, 6196 insertions(+), 1955 deletions(-)
+
+diff --git a/contrib/amcheck/verify_heapam.c b/contrib/amcheck/verify_heapam.c
+index 1ce244fab1b..c8960116835 100644
+--- a/contrib/amcheck/verify_heapam.c
++++ b/contrib/amcheck/verify_heapam.c
+@@ -19,6 +19,7 @@
+ #include "access/toast_internals.h"
+ #include "access/visibilitymap.h"
+ #include "access/xact.h"
++#include "catalog/catalog.h"
+ #include "catalog/pg_am.h"
+ #include "catalog/pg_class.h"
+ #include "funcapi.h"
+@@ -89,7 +90,7 @@ typedef struct HeapCheckContext
+ * them.
+ */
+ FullTransactionId next_fxid; /* TransamVariables->nextXid */
+- TransactionId next_xid; /* 32-bit version of next_fxid */
++ TransactionId next_xid; /* 64-bit version of next_fxid */
+ TransactionId oldest_xid; /* TransamVariables->oldestXid */
+ FullTransactionId oldest_fxid; /* 64-bit version of oldest_xid, computed
+ * relative to next_fxid */
+@@ -130,6 +131,7 @@ typedef struct HeapCheckContext
+ uint16 lp_len;
+ uint16 lp_off;
+ HeapTupleHeader tuphdr;
++ HeapTupleData tuple;
+ int natts;
+
+ /* Values for iterating over attributes within the tuple */
+@@ -173,8 +175,6 @@ static bool check_tuple_visibility(HeapCheckContext *ctx,
+ static void report_corruption(HeapCheckContext *ctx, char *msg);
+ static void report_toast_corruption(HeapCheckContext *ctx,
+ ToastedAttribute *ta, char *msg);
+-static FullTransactionId FullTransactionIdFromXidAndCtx(TransactionId xid,
+- const HeapCheckContext *ctx);
+ static void update_cached_xid_range(HeapCheckContext *ctx);
+ static void update_cached_mxid_range(HeapCheckContext *ctx);
+ static XidBoundsViolation check_mxid_in_range(MultiXactId mxid,
+@@ -398,7 +398,7 @@ verify_heapam(PG_FUNCTION_ARGS)
+ update_cached_xid_range(&ctx);
+ update_cached_mxid_range(&ctx);
+ ctx.relfrozenxid = ctx.rel->rd_rel->relfrozenxid;
+- ctx.relfrozenfxid = FullTransactionIdFromXidAndCtx(ctx.relfrozenxid, &ctx);
++ ctx.relfrozenfxid = FullTransactionIdFromXid(ctx.relfrozenxid);
+ ctx.relminmxid = ctx.rel->rd_rel->relminmxid;
+
+ if (TransactionIdIsNormal(ctx.relfrozenxid))
+@@ -559,6 +559,12 @@ verify_heapam(PG_FUNCTION_ARGS)
+ ctx.tuphdr = (HeapTupleHeader) PageGetItem(ctx.page, ctx.itemid);
+ ctx.natts = HeapTupleHeaderGetNatts(ctx.tuphdr);
+
++ ctx.tuple.t_data = ctx.tuphdr;
++ ctx.tuple.t_len = ItemIdGetLength(ctx.itemid);
++ ctx.tuple.t_tableOid = RelationGetRelid(ctx.rel);
++ HeapTupleCopyXidsFromPage(ctx.buffer, &ctx.tuple, ctx.page,
++ IsToastRelation(ctx.rel));
++
+ /* Ok, ready to check this next tuple */
+ check_tuple(&ctx,
+ &xmin_commit_status_ok[ctx.offnum],
+@@ -592,6 +598,8 @@ verify_heapam(PG_FUNCTION_ARGS)
+ TransactionId curr_xmax;
+ TransactionId next_xmin;
+ OffsetNumber nextoffnum = successor[ctx.offnum];
++ HeapTupleData curr_tup;
++ HeapTupleData next_tup;
+
+ /*
+ * The current line pointer may not have a successor, either
+@@ -654,9 +662,13 @@ verify_heapam(PG_FUNCTION_ARGS)
+ if (ItemIdIsRedirected(next_lp))
+ continue;
+ curr_htup = (HeapTupleHeader) PageGetItem(ctx.page, curr_lp);
+- curr_xmax = HeapTupleHeaderGetUpdateXid(curr_htup);
++ curr_tup.t_data = curr_htup;
++ HeapTupleCopyXidsFromPage(ctx.buffer, &curr_tup, ctx.page, false);
++ curr_xmax = HeapTupleGetUpdateXidAny(&curr_tup);
+ next_htup = (HeapTupleHeader) PageGetItem(ctx.page, next_lp);
+- next_xmin = HeapTupleHeaderGetXmin(next_htup);
++ next_tup.t_data = next_htup;
++ HeapTupleCopyXidsFromPage(ctx.buffer, &next_tup, ctx.page, false);
++ next_xmin = HeapTupleGetXmin(&next_tup);
+ if (!TransactionIdIsValid(curr_xmax) ||
+ !TransactionIdEquals(curr_xmax, next_xmin))
+ continue;
+@@ -710,7 +722,7 @@ verify_heapam(PG_FUNCTION_ARGS)
+ * xmin. This should be safe because the xmin itself can't have
+ * changed, only its commit status.
+ */
+- curr_xmin = HeapTupleHeaderGetXmin(curr_htup);
++ curr_xmin = HeapTupleGetXmin(&curr_tup);
+ if (xmin_commit_status_ok[ctx.offnum] &&
+ xmin_commit_status[ctx.offnum] == XID_IN_PROGRESS &&
+ xmin_commit_status_ok[nextoffnum] &&
+@@ -908,7 +920,7 @@ check_tuple_header(HeapCheckContext *ctx)
+ {
+ HeapTupleHeader tuphdr = ctx->tuphdr;
+ uint16 infomask = tuphdr->t_infomask;
+- TransactionId curr_xmax = HeapTupleHeaderGetUpdateXid(tuphdr);
++ TransactionId curr_xmax = HeapTupleGetUpdateXidAny(&ctx->tuple);
+ bool result = true;
+ unsigned expected_hoff;
+
+@@ -1026,13 +1038,14 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ XidCommitStatus xmin_status;
+ XidCommitStatus xvac_status;
+ XidCommitStatus xmax_status;
++ HeapTuple tuple = &ctx->tuple;
+ HeapTupleHeader tuphdr = ctx->tuphdr;
+
+ ctx->tuple_could_be_pruned = true; /* have not yet proven otherwise */
+ *xmin_commit_status_ok = false; /* have not yet proven otherwise */
+
+ /* If xmin is normal, it should be within valid range */
+- xmin = HeapTupleHeaderGetXmin(tuphdr);
++ xmin = HeapTupleGetXmin(tuple);
+ switch (get_xid_status(xmin, ctx, &xmin_status))
+ {
+ case XID_INVALID:
+@@ -1046,19 +1059,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("xmin %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmin,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("xmin %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmin,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("xmin %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmin,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ }
+
+@@ -1084,19 +1097,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes relation freeze threshold %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved off tuple precedes oldest valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1150,19 +1163,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes relation freeze threshold %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("old-style VACUUM FULL transaction ID %llu for moved in tuple precedes oldest valid transaction ID %llu",
+ (unsigned long long) xvac,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1239,7 +1252,7 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ * HEAP_XMAX_IS_LOCKED_ONLY is true, but for now we err on the side of
+ * avoiding possibly-bogus complaints about missing TOAST entries.
+ */
+- xmax = HeapTupleHeaderGetRawXmax(tuphdr);
++ xmax = HeapTupleGetRawXmax(tuple);
+ switch (check_mxid_valid_in_rel(xmax, ctx))
+ {
+ case XID_INVALID:
+@@ -1298,7 +1311,7 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ * We already checked above that this multixact is within limits for
+ * this table. Now check the update xid from this multixact.
+ */
+- xmax = HeapTupleGetUpdateXid(tuphdr);
++ xmax = HeapTupleGetUpdateXid(tuple);
+ switch (get_xid_status(xmax, ctx, &xmax_status))
+ {
+ case XID_INVALID:
+@@ -1310,19 +1323,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("update xid %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return true;
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("update xid %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return true;
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("update xid %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return true;
+ case XID_BOUNDS_OK:
+ break;
+@@ -1362,7 +1375,7 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ }
+
+ /* xmax is an XID, not a MXID. Sanity check it. */
+- xmax = HeapTupleHeaderGetRawXmax(tuphdr);
++ xmax = HeapTupleGetRawXmax(tuple);
+ switch (get_xid_status(xmax, ctx, &xmax_status))
+ {
+ case XID_INVALID:
+@@ -1372,19 +1385,19 @@ check_tuple_visibility(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ report_corruption(ctx,
+ psprintf("xmax %llu equals or exceeds next valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->next_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->next_fxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_RELMIN:
+ report_corruption(ctx,
+ psprintf("xmax %llu precedes relation freeze threshold %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->relfrozenfxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->relfrozenfxid)));
+ return false; /* corrupt */
+ case XID_PRECEDES_CLUSTERMIN:
+ report_corruption(ctx,
+ psprintf("xmax %llu precedes oldest valid transaction ID %llu",
+ (unsigned long long) xmax,
+- (unsigned long long) U64FromFullTransactionId(ctx->oldest_fxid)));
++ (unsigned long long) XidFromFullTransactionId(ctx->oldest_fxid)));
+ return false; /* corrupt */
+ case XID_BOUNDS_OK:
+ break;
+@@ -1863,50 +1876,6 @@ check_tuple(HeapCheckContext *ctx, bool *xmin_commit_status_ok,
+ ctx->attnum = -1;
+ }
+
+-/*
+- * Convert a TransactionId into a FullTransactionId using our cached values of
+- * the valid transaction ID range. It is the caller's responsibility to have
+- * already updated the cached values, if necessary.
+- */
+-static FullTransactionId
+-FullTransactionIdFromXidAndCtx(TransactionId xid, const HeapCheckContext *ctx)
+-{
+- uint64 nextfxid_i;
+- int32 diff;
+- FullTransactionId fxid;
+-
+- Assert(TransactionIdIsNormal(ctx->next_xid));
+- Assert(FullTransactionIdIsNormal(ctx->next_fxid));
+- Assert(XidFromFullTransactionId(ctx->next_fxid) == ctx->next_xid);
+-
+- if (!TransactionIdIsNormal(xid))
+- return FullTransactionIdFromEpochAndXid(0, xid);
+-
+- nextfxid_i = U64FromFullTransactionId(ctx->next_fxid);
+-
+- /* compute the 32bit modulo difference */
+- diff = (int32) (ctx->next_xid - xid);
+-
+- /*
+- * In cases of corruption we might see a 32bit xid that is before epoch 0.
+- * We can't represent that as a 64bit xid, due to 64bit xids being
+- * unsigned integers, without the modulo arithmetic of 32bit xid. There's
+- * no really nice way to deal with that, but it works ok enough to use
+- * FirstNormalFullTransactionId in that case, as a freshly initdb'd
+- * cluster already has a newer horizon.
+- */
+- if (diff > 0 && (nextfxid_i - FirstNormalTransactionId) < (int64) diff)
+- {
+- Assert(EpochFromFullTransactionId(ctx->next_fxid) == 0);
+- fxid = FirstNormalFullTransactionId;
+- }
+- else
+- fxid = FullTransactionIdFromU64(nextfxid_i - diff);
+-
+- Assert(FullTransactionIdIsNormal(fxid));
+- return fxid;
+-}
+-
+ /*
+ * Update our cached range of valid transaction IDs.
+ */
+@@ -1920,8 +1889,8 @@ update_cached_xid_range(HeapCheckContext *ctx)
+ LWLockRelease(XidGenLock);
+
+ /* And compute alternate versions of the same */
++ ctx->oldest_fxid = FullTransactionIdFromXid(ctx->oldest_xid);
+ ctx->next_xid = XidFromFullTransactionId(ctx->next_fxid);
+- ctx->oldest_fxid = FullTransactionIdFromXidAndCtx(ctx->oldest_xid, ctx);
+ }
+
+ /*
+@@ -2020,7 +1989,7 @@ get_xid_status(TransactionId xid, HeapCheckContext *ctx,
+ }
+
+ /* Check if the xid is within bounds */
+- fxid = FullTransactionIdFromXidAndCtx(xid, ctx);
++ fxid = FullTransactionIdFromXid(xid);
+ if (!fxid_in_cached_range(fxid, ctx))
+ {
+ /*
+@@ -2029,7 +1998,6 @@ get_xid_status(TransactionId xid, HeapCheckContext *ctx,
+ * performed the full xid conversion, reconvert.
+ */
+ update_cached_xid_range(ctx);
+- fxid = FullTransactionIdFromXidAndCtx(xid, ctx);
+ }
+
+ if (FullTransactionIdPrecedesOrEquals(ctx->next_fxid, fxid))
+@@ -2053,8 +2021,7 @@ get_xid_status(TransactionId xid, HeapCheckContext *ctx,
+ *status = XID_COMMITTED;
+ LWLockAcquire(XactTruncationLock, LW_SHARED);
+ clog_horizon =
+- FullTransactionIdFromXidAndCtx(TransamVariables->oldestClogXid,
+- ctx);
++ FullTransactionIdFromXid(TransamVariables->oldestClogXid);
+ if (FullTransactionIdPrecedesOrEquals(clog_horizon, fxid))
+ {
+ if (TransactionIdIsCurrentTransactionId(xid))
+diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
+index ffe4f721672..8d8a134f302 100644
+--- a/contrib/amcheck/verify_nbtree.c
++++ b/contrib/amcheck/verify_nbtree.c
+@@ -581,7 +581,7 @@ bt_check_every_level(Relation rel, Relation heaprel, bool heapkeyspace,
+ * avoid this.
+ */
+ if (IsolationUsesXactSnapshot() && rel->rd_index->indcheckxmin &&
+- !TransactionIdPrecedes(HeapTupleHeaderGetXmin(rel->rd_indextuple->t_data),
++ !TransactionIdPrecedes(HeapTupleGetXmin(rel->rd_indextuple),
+ snapshot->xmin))
+ ereport(ERROR,
+ (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
+diff --git a/contrib/hstore/hstore_io.c b/contrib/hstore/hstore_io.c
+index 2125436e40c..9fe4254e72e 100644
+--- a/contrib/hstore/hstore_io.c
++++ b/contrib/hstore/hstore_io.c
+@@ -914,6 +914,7 @@ hstore_from_record(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = rec;
++ HeapTupleSetZeroXids(&tuple);
+
+ values = (Datum *) palloc(ncolumns * sizeof(Datum));
+ nulls = (bool *) palloc(ncolumns * sizeof(bool));
+@@ -1067,6 +1068,7 @@ hstore_populate_record(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = rec;
++ HeapTupleSetZeroXids(&tuple);
+ }
+
+ /*
+diff --git a/contrib/pageinspect/Makefile b/contrib/pageinspect/Makefile
+index 95e030b3969..446721018e4 100644
+--- a/contrib/pageinspect/Makefile
++++ b/contrib/pageinspect/Makefile
+@@ -13,7 +13,8 @@ OBJS = \
+ rawpage.o
+
+ EXTENSION = pageinspect
+-DATA = pageinspect--1.11--1.12.sql pageinspect--1.10--1.11.sql \
++DATA = pageinspect--1.12--1.13.sql \
++ pageinspect--1.11--1.12.sql pageinspect--1.10--1.11.sql \
+ pageinspect--1.9--1.10.sql pageinspect--1.8--1.9.sql \
+ pageinspect--1.7--1.8.sql pageinspect--1.6--1.7.sql \
+ pageinspect--1.5.sql pageinspect--1.5--1.6.sql \
+diff --git a/contrib/pageinspect/btreefuncs.c b/contrib/pageinspect/btreefuncs.c
+index afa1947fad6..a810be45308 100644
+--- a/contrib/pageinspect/btreefuncs.c
++++ b/contrib/pageinspect/btreefuncs.c
+@@ -122,6 +122,9 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+
+ stat->page_size = PageGetPageSize(page);
+
++ stat->btpo_prev = opaque->btpo_prev;
++ stat->btpo_level = opaque->btpo_level;
++
+ /* page type (flags) */
+ if (P_ISDELETED(opaque))
+ {
+@@ -143,11 +146,18 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+ FullTransactionId safexid = BTPageGetDeleteXid(page);
+
+ elog(DEBUG2, "deleted page from block %u has safexid %llu",
+- blkno, (unsigned long long) U64FromFullTransactionId(safexid));
++ blkno, (unsigned long long) XidFromFullTransactionId(safexid));
+ }
+ else
+- elog(DEBUG2, "deleted page from block %u has safexid %llu",
+- blkno, (unsigned long long) opaque->btpo_level);
++ {
++ ShortTransactionId safexid = BTP_GET_XACT(opaque);
++
++ stat->btpo_prev = 0;
++ stat->btpo_level = 0;
++
++ elog(DEBUG2, "deleted page from block %u has safexid %u",
++ blkno, safexid);
++ }
+
+ /* Don't interpret BTDeletedPageData as index tuples */
+ maxoff = InvalidOffsetNumber;
+@@ -162,9 +172,7 @@ GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
+ stat->type = 'i';
+
+ /* btpage opaque data */
+- stat->btpo_prev = opaque->btpo_prev;
+ stat->btpo_next = opaque->btpo_next;
+- stat->btpo_level = opaque->btpo_level;
+ stat->btpo_flags = opaque->btpo_flags;
+ stat->btpo_cycleid = opaque->btpo_cycleid;
+
+diff --git a/contrib/pageinspect/expected/btree.out b/contrib/pageinspect/expected/btree.out
+index 0aa5d73322f..f5b05dbc063 100644
+--- a/contrib/pageinspect/expected/btree.out
++++ b/contrib/pageinspect/expected/btree.out
+@@ -207,8 +207,8 @@ SELECT bt_page_items('aaa'::bytea);
+ ERROR: invalid page size
+ -- invalid special area size
+ CREATE INDEX test1_a_brin ON test1 USING brin(a);
+-SELECT bt_page_items(get_raw_page('test1', 0));
+-ERROR: input page is not a valid btree page
++-- XXX: false positive in 64xids due to equal sizes of BTPageOpaque and HeapPageSpecialData
++-- SELECT bt_page_items(get_raw_page('test1', 0));
+ SELECT bt_page_items(get_raw_page('test1_a_brin', 0));
+ ERROR: input page is not a valid btree page
+ \set VERBOSITY default
+diff --git a/contrib/pageinspect/expected/hash_1.out b/contrib/pageinspect/expected/hash_1.out
+new file mode 100644
+index 00000000000..5e64eb92602
+--- /dev/null
++++ b/contrib/pageinspect/expected/hash_1.out
+@@ -0,0 +1,166 @@
++CREATE TABLE test_hash (a int, b text);
++INSERT INTO test_hash VALUES (1, 'one');
++CREATE INDEX test_hash_a_idx ON test_hash USING hash (a);
++\x
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 0));
++-[ RECORD 1 ]--+---------
++hash_page_type | metapage
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 1));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 2));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 3));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 4));
++-[ RECORD 1 ]--+-------
++hash_page_type | bucket
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 5));
++-[ RECORD 1 ]--+-------
++hash_page_type | bitmap
++
++SELECT hash_page_type(get_raw_page('test_hash_a_idx', 6));
++ERROR: block number 6 is out of range for relation "test_hash_a_idx"
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', -1);
++ERROR: invalid block number
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 0);
++ERROR: invalid overflow block number 0
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 1);
++ERROR: invalid overflow block number 1
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 2);
++ERROR: invalid overflow block number 2
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 3);
++ERROR: invalid overflow block number 3
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 4);
++ERROR: invalid overflow block number 4
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 5);
++ERROR: invalid overflow block number 5
++SELECT * FROM hash_bitmap_info('test_hash_a_idx', 6);
++ERROR: block number 6 is out of range for relation "test_hash_a_idx"
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 0));
++-[ RECORD 1 ]--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
++magic | 105121344
++version | 4
++ntuples | 1
++bsize | 8156
++bmsize | 4096
++bmshift | 15
++maxbucket | 3
++highmask | 7
++lowmask | 3
++ovflpoint | 2
++firstfree | 0
++nmaps | 1
++procid | 450
++spares | {0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
++mapp | {5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
++
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 1));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 2));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 3));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 4));
++ERROR: page is not a hash meta page
++SELECT magic, version, ntuples, bsize, bmsize, bmshift, maxbucket, highmask,
++lowmask, ovflpoint, firstfree, nmaps, procid, spares, mapp FROM
++hash_metapage_info(get_raw_page('test_hash_a_idx', 5));
++ERROR: page is not a hash meta page
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 0));
++ERROR: page is not a hash bucket or overflow page
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 1));
++-[ RECORD 1 ]---+-----------
++live_items | 0
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 0
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 2));
++-[ RECORD 1 ]---+-----------
++live_items | 0
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 1
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 3));
++-[ RECORD 1 ]---+-----------
++live_items | 1
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 2
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 4));
++-[ RECORD 1 ]---+-----------
++live_items | 0
++dead_items | 0
++page_size | 8192
++hasho_prevblkno | 3
++hasho_nextblkno | 4294967295
++hasho_bucket | 3
++hasho_flag | 2
++hasho_page_id | 65408
++
++SELECT live_items, dead_items, page_size, hasho_prevblkno, hasho_nextblkno,
++hasho_bucket, hasho_flag, hasho_page_id FROM
++hash_page_stats(get_raw_page('test_hash_a_idx', 5));
++ERROR: page is not a hash bucket or overflow page
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 0));
++ERROR: page is not a hash bucket or overflow page
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 1));
++(0 rows)
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 2));
++(0 rows)
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 3));
++-[ RECORD 1 ]----------
++itemoffset | 1
++ctid | (0,1)
++data | 2389907270
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 4));
++(0 rows)
++
++SELECT * FROM hash_page_items(get_raw_page('test_hash_a_idx', 5));
++ERROR: page is not a hash bucket or overflow page
++DROP TABLE test_hash;
+diff --git a/contrib/pageinspect/expected/oldextversions.out b/contrib/pageinspect/expected/oldextversions.out
+index f5c4b61bd79..00323d392d6 100644
+--- a/contrib/pageinspect/expected/oldextversions.out
++++ b/contrib/pageinspect/expected/oldextversions.out
+@@ -40,16 +40,16 @@ SELECT * FROM bt_page_items('test1_a_idx', 1);
+ -- pagesize in pageinspect >= 1.10.
+ ALTER EXTENSION pageinspect UPDATE TO '1.9';
+ \df page_header
+- List of functions
+- Schema | Name | Result data type | Argument data types | Type
+---------+-------------+------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------
+- public | page_header | record | page bytea, OUT lsn pg_lsn, OUT checksum smallint, OUT flags smallint, OUT lower smallint, OUT upper smallint, OUT special smallint, OUT pagesize smallint, OUT version smallint, OUT prune_xid xid | func
++ List of functions
++ Schema | Name | Result data type | Argument data types | Type
++--------+-------------+------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------
++ public | page_header | record | page bytea, OUT lsn pg_lsn, OUT checksum smallint, OUT flags smallint, OUT lower smallint, OUT upper smallint, OUT special smallint, OUT pagesize smallint, OUT version smallint, OUT xid_base xid, OUT multi_base xid, OUT prune_xid xid | func
+ (1 row)
+
+ SELECT pagesize, version FROM page_header(get_raw_page('test1', 0));
+ pagesize | version
+ ----------+---------
+- 8192 | 4
++ 8192 | 5
+ (1 row)
+
+ DROP TABLE test1;
+diff --git a/contrib/pageinspect/expected/page.out b/contrib/pageinspect/expected/page.out
+index 3fd3869c82a..be612aeb0a0 100644
+--- a/contrib/pageinspect/expected/page.out
++++ b/contrib/pageinspect/expected/page.out
+@@ -49,7 +49,7 @@ SELECT get_raw_page('test1', 0) = get_raw_page('test1', 'main', 0);
+ SELECT pagesize, version FROM page_header(get_raw_page('test1', 0));
+ pagesize | version
+ ----------+---------
+- 8192 | 4
++ 8192 | 5
+ (1 row)
+
+ SELECT page_checksum(get_raw_page('test1', 0), 0) IS NOT NULL AS silly_checksum_test;
+@@ -70,19 +70,19 @@ SELECT tuple_data_split('test1'::regclass, t_data, t_infomask, t_infomask2, t_bi
+ SELECT * FROM fsm_page_contents(get_raw_page('test1', 'fsm', 0));
+ fsm_page_contents
+ -------------------
+- 0: 254 +
+- 1: 254 +
+- 3: 254 +
+- 7: 254 +
+- 15: 254 +
+- 31: 254 +
+- 63: 254 +
+- 127: 254 +
+- 255: 254 +
+- 511: 254 +
+- 1023: 254 +
+- 2047: 254 +
+- 4095: 254 +
++ 0: 253 +
++ 1: 253 +
++ 3: 253 +
++ 7: 253 +
++ 15: 253 +
++ 31: 253 +
++ 63: 253 +
++ 127: 253 +
++ 255: 253 +
++ 511: 253 +
++ 1023: 253 +
++ 2047: 253 +
++ 4095: 253 +
+ fp_next_slot: 0 +
+
+ (1 row)
+diff --git a/contrib/pageinspect/heapfuncs.c b/contrib/pageinspect/heapfuncs.c
+index 3dc705e43f7..aee72915218 100644
+--- a/contrib/pageinspect/heapfuncs.c
++++ b/contrib/pageinspect/heapfuncs.c
+@@ -32,6 +32,7 @@
+ #include "funcapi.h"
+ #include "mb/pg_wchar.h"
+ #include "miscadmin.h"
++#include "pageinspect.h"
+ #include "port/pg_bitutils.h"
+ #include "utils/array.h"
+ #include "utils/builtins.h"
+@@ -162,7 +163,7 @@ heap_page_items(PG_FUNCTION_ARGS)
+ inter_call_data->tupd = tupdesc;
+
+ inter_call_data->offset = FirstOffsetNumber;
+- inter_call_data->page = VARDATA(raw_page);
++ inter_call_data->page = get_page_from_raw(raw_page);
+
+ fctx->max_calls = PageGetMaxOffsetNumber(inter_call_data->page);
+ fctx->user_fctx = inter_call_data;
+@@ -210,6 +211,7 @@ heap_page_items(PG_FUNCTION_ARGS)
+ lp_offset == MAXALIGN(lp_offset) &&
+ lp_offset + lp_len <= raw_page_size)
+ {
++ HeapTupleData tup;
+ HeapTupleHeader tuphdr;
+ bytea *tuple_data_bytea;
+ int tuple_data_len;
+@@ -217,9 +219,11 @@ heap_page_items(PG_FUNCTION_ARGS)
+ /* Extract information from the tuple header */
+
+ tuphdr = (HeapTupleHeader) PageGetItem(page, id);
++ tup.t_data = tuphdr;
++ HeapTupleCopyXidsFromPage(InvalidBuffer, &tup, page, false);
+
+- values[4] = UInt32GetDatum(HeapTupleHeaderGetRawXmin(tuphdr));
+- values[5] = UInt32GetDatum(HeapTupleHeaderGetRawXmax(tuphdr));
++ values[4] = TransactionIdGetDatum(HeapTupleGetXmin(&tup));
++ values[5] = TransactionIdGetDatum(HeapTupleGetRawXmax(&tup));
+ /* shared with xvac */
+ values[6] = UInt32GetDatum(HeapTupleHeaderGetRawCommandId(tuphdr));
+ values[7] = PointerGetDatum(&tuphdr->t_ctid);
+diff --git a/contrib/pageinspect/pageinspect--1.12--1.13.sql b/contrib/pageinspect/pageinspect--1.12--1.13.sql
+new file mode 100644
+index 00000000000..a2e0232a103
+--- /dev/null
++++ b/contrib/pageinspect/pageinspect--1.12--1.13.sql
+@@ -0,0 +1,145 @@
++/* contrib/pageinspect/pageinspect--1.12--1.13.sql */
++
++-- complain if script is sourced in psql, rather than via ALTER EXTENSION
++\echo Use "ALTER EXTENSION pageinspect UPDATE TO '1.13'" to load this file. \quit
++
++--
++-- gist_page_opaque_info()
++--
++DROP FUNCTION gist_page_opaque_info(bytea);
++CREATE FUNCTION gist_page_opaque_info(IN page bytea,
++ OUT lsn pg_lsn,
++ OUT nsn pg_lsn,
++ OUT rightlink bigint,
++ OUT flags text[])
++AS 'MODULE_PATHNAME', 'gist_page_opaque_info'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++
++--
++-- gist_page_items_bytea()
++--
++DROP FUNCTION gist_page_items_bytea(bytea);
++CREATE FUNCTION gist_page_items_bytea(IN page bytea,
++ OUT itemoffset smallint,
++ OUT ctid tid,
++ OUT itemlen smallint,
++ OUT dead boolean,
++ OUT key_data bytea)
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'gist_page_items_bytea'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- gist_page_items()
++--
++DROP FUNCTION gist_page_items(bytea, regclass);
++CREATE FUNCTION gist_page_items(IN page bytea,
++ IN index_oid regclass,
++ OUT itemoffset smallint,
++ OUT ctid tid,
++ OUT itemlen smallint,
++ OUT dead boolean,
++ OUT keys text)
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'gist_page_items'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- get_raw_page()
++--
++DROP FUNCTION get_raw_page(text, int8);
++DROP FUNCTION IF EXISTS get_raw_page(text, int4);
++CREATE FUNCTION get_raw_page(text, int8)
++RETURNS bytea
++AS 'MODULE_PATHNAME', 'get_raw_page_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++DROP FUNCTION get_raw_page(text, text, int8);
++DROP FUNCTION IF EXISTS get_raw_page(text, text, int4);
++CREATE FUNCTION get_raw_page(text, text, int8)
++RETURNS bytea
++AS 'MODULE_PATHNAME', 'get_raw_page_fork_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- page_checksum()
++--
++DROP FUNCTION page_checksum(IN page bytea, IN blkno int8);
++DROP FUNCTION IF EXISTS page_checksum(IN page bytea, IN blkno int4);
++CREATE FUNCTION page_checksum(IN page bytea, IN blkno int8)
++RETURNS smallint
++AS 'MODULE_PATHNAME', 'page_checksum_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- bt_metap()
++--
++DROP FUNCTION bt_metap(text);
++CREATE FUNCTION bt_metap(IN relname text,
++ OUT magic int4,
++ OUT version int4,
++ OUT root int8,
++ OUT level int8,
++ OUT fastroot int8,
++ OUT fastlevel int8,
++ OUT last_cleanup_num_delpages int8,
++ OUT last_cleanup_num_tuples float8,
++ OUT allequalimage boolean)
++AS 'MODULE_PATHNAME', 'bt_metap'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- bt_page_stats()
++--
++DROP FUNCTION bt_page_stats(text, int8);
++DROP FUNCTION IF EXISTS bt_page_stats(text, int4);
++CREATE FUNCTION bt_page_stats(IN relname text, IN blkno int8,
++ OUT blkno int8,
++ OUT type "char",
++ OUT live_items int4,
++ OUT dead_items int4,
++ OUT avg_item_size int4,
++ OUT page_size int4,
++ OUT free_size int4,
++ OUT btpo_prev int8,
++ OUT btpo_next int8,
++ OUT btpo_level int8,
++ OUT btpo_flags int4)
++AS 'MODULE_PATHNAME', 'bt_page_stats_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- bt_page_items()
++--
++DROP FUNCTION bt_page_items(text, int8);
++DROP FUNCTION IF EXISTS bt_page_items(text, int4);
++CREATE FUNCTION bt_page_items(IN relname text, IN blkno int8,
++ OUT itemoffset smallint,
++ OUT ctid tid,
++ OUT itemlen smallint,
++ OUT nulls bool,
++ OUT vars bool,
++ OUT data text,
++ OUT dead boolean,
++ OUT htid tid,
++ OUT tids tid[])
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'bt_page_items_1_9'
++LANGUAGE C STRICT PARALLEL SAFE;
++
++--
++-- brin_page_items()
++--
++DROP FUNCTION brin_page_items(IN page bytea, IN index_oid regclass);
++CREATE FUNCTION brin_page_items(IN page bytea, IN index_oid regclass,
++ OUT itemoffset int,
++ OUT blknum int8,
++ OUT attnum int,
++ OUT allnulls bool,
++ OUT hasnulls bool,
++ OUT placeholder bool,
++ OUT value text)
++RETURNS SETOF record
++AS 'MODULE_PATHNAME', 'brin_page_items'
++LANGUAGE C STRICT PARALLEL SAFE;
+diff --git a/contrib/pageinspect/pageinspect--1.5.sql b/contrib/pageinspect/pageinspect--1.5.sql
+index 1e40c3c97e2..fdbd2995a22 100644
+--- a/contrib/pageinspect/pageinspect--1.5.sql
++++ b/contrib/pageinspect/pageinspect--1.5.sql
+@@ -28,6 +28,8 @@ CREATE FUNCTION page_header(IN page bytea,
+ OUT special smallint,
+ OUT pagesize smallint,
+ OUT version smallint,
++ OUT xid_base xid,
++ OUT multi_base xid,
+ OUT prune_xid xid)
+ AS 'MODULE_PATHNAME', 'page_header'
+ LANGUAGE C STRICT PARALLEL SAFE;
+diff --git a/contrib/pageinspect/rawpage.c b/contrib/pageinspect/rawpage.c
+index 2800ebd62f5..a359b04e585 100644
+--- a/contrib/pageinspect/rawpage.c
++++ b/contrib/pageinspect/rawpage.c
+@@ -17,6 +17,7 @@
+
+ #include "access/htup_details.h"
+ #include "access/relation.h"
++#include "commands/sequence.h"
+ #include "catalog/namespace.h"
+ #include "catalog/pg_type.h"
+ #include "funcapi.h"
+@@ -251,8 +252,9 @@ page_header(PG_FUNCTION_ARGS)
+
+ Datum result;
+ HeapTuple tuple;
+- Datum values[9];
+- bool nulls[9];
++ Datum values[11];
++ bool nulls[11];
++ bool is_toast;
+
+ Page page;
+ PageHeader pageheader;
+@@ -314,12 +316,37 @@ page_header(PG_FUNCTION_ARGS)
+ }
+
+ values[7] = UInt16GetDatum(PageGetPageLayoutVersion(page));
+- values[8] = TransactionIdGetDatum(pageheader->pd_prune_xid);
++ is_toast = PageGetSpecialSize(page) ==
++ MAXALIGN(sizeof(ToastPageSpecialData));
++ values[8] = TransactionIdGetDatum(HeapPageGetPruneXidNoAssert((Page) page,
++ is_toast));
+
+ /* Build and return the tuple. */
+-
+ memset(nulls, 0, sizeof(nulls));
+
++ if (PageGetSpecialSize(page) == MAXALIGN(sizeof(HeapPageSpecialData)))
++ {
++ /* Heap page */
++ HeapPageSpecial pageSpecial = HeapPageGetSpecial((Page) page);
++
++ values[9] = TransactionIdGetDatum(pageSpecial->pd_xid_base);
++ values[10] = TransactionIdGetDatum(pageSpecial->pd_multi_base);
++ }
++ else if (PageGetSpecialSize(page) == MAXALIGN(sizeof(ToastPageSpecialData)))
++ {
++ /* TOAST page */
++ ToastPageSpecial pageSpecial = ToastPageGetSpecial((Page) page);
++
++ values[9] = TransactionIdGetDatum(pageSpecial->pd_xid_base);
++ nulls[10] = true;
++ }
++ else
++ {
++ /* Double xmax page */
++ nulls[9] = true;
++ nulls[10] = true;
++ }
++
+ tuple = heap_form_tuple(tupdesc, values, nulls);
+ result = HeapTupleGetDatum(tuple);
+
+diff --git a/contrib/pageinspect/sql/btree.sql b/contrib/pageinspect/sql/btree.sql
+index 102ebdefe3c..87f202fb9f4 100644
+--- a/contrib/pageinspect/sql/btree.sql
++++ b/contrib/pageinspect/sql/btree.sql
+@@ -51,7 +51,8 @@ SELECT bt_page_items(get_raw_page('test1_b_gist', 0));
+ SELECT bt_page_items('aaa'::bytea);
+ -- invalid special area size
+ CREATE INDEX test1_a_brin ON test1 USING brin(a);
+-SELECT bt_page_items(get_raw_page('test1', 0));
++-- XXX: false positive in 64xids due to equal sizes of BTPageOpaque and HeapPageSpecialData
++-- SELECT bt_page_items(get_raw_page('test1', 0));
+ SELECT bt_page_items(get_raw_page('test1_a_brin', 0));
+ \set VERBOSITY default
+
+diff --git a/contrib/pg_surgery/heap_surgery.c b/contrib/pg_surgery/heap_surgery.c
+index 1513d76e4b5..5469ae4c407 100644
+--- a/contrib/pg_surgery/heap_surgery.c
++++ b/contrib/pg_surgery/heap_surgery.c
+@@ -16,6 +16,7 @@
+ #include "access/relation.h"
+ #include "access/visibilitymap.h"
+ #include "access/xloginsert.h"
++#include "catalog/catalog.h"
+ #include "catalog/pg_am_d.h"
+ #include "miscadmin.h"
+ #include "storage/bufmgr.h"
+@@ -272,11 +273,20 @@ heap_force_common(FunctionCallInfo fcinfo, HeapTupleForceOption heap_force_opt)
+ else
+ {
+ HeapTupleHeader htup;
++ HeapTupleData tuple;
++ bool is_toast;
+
+ Assert(heap_force_opt == HEAP_FORCE_FREEZE);
+
++ is_toast = IsToastRelation(rel);
++
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
+
++ tuple.t_data = htup;
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, is_toast);
++
+ /*
+ * Reset all visibility-related fields of the tuple. This
+ * logic should mimic heap_execute_freeze_tuple(), but we
+@@ -284,8 +294,11 @@ heap_force_common(FunctionCallInfo fcinfo, HeapTupleForceOption heap_force_opt)
+ * potentially-garbled data is left behind.
+ */
+ ItemPointerSet(&htup->t_ctid, blkno, curoff);
+- HeapTupleHeaderSetXmin(htup, FrozenTransactionId);
+- HeapTupleHeaderSetXmax(htup, InvalidTransactionId);
++ HeapTupleAndHeaderSetXmin(page, &tuple, FrozenTransactionId,
++ is_toast);
++ HeapTupleAndHeaderSetXmax(page, &tuple, InvalidTransactionId,
++ is_toast);
++
+ if (htup->t_infomask & HEAP_MOVED)
+ {
+ if (htup->t_infomask & HEAP_MOVED_OFF)
+diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
+index 5d0deaba61e..227bde0a168 100644
+--- a/contrib/pg_visibility/pg_visibility.c
++++ b/contrib/pg_visibility/pg_visibility.c
+@@ -14,6 +14,7 @@
+ #include "access/htup_details.h"
+ #include "access/visibilitymap.h"
+ #include "access/xloginsert.h"
++#include "catalog/catalog.h"
+ #include "catalog/pg_type.h"
+ #include "catalog/storage_xlog.h"
+ #include "funcapi.h"
+@@ -794,6 +795,8 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = relid;
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page,
++ IsToastRelation(rel));
+
+ /*
+ * If we're checking whether the page is all-visible, we expect
+@@ -837,7 +840,7 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
+ */
+ if (check_frozen)
+ {
+- if (heap_tuple_needs_eventual_freeze(tuple.t_data))
++ if (heap_tuple_needs_eventual_freeze(&tuple))
+ record_corrupt_item(items, &tuple.t_self);
+ }
+ }
+@@ -903,7 +906,7 @@ tuple_all_visible(HeapTuple tup, TransactionId OldestXmin, Buffer buffer)
+ * be set here. So just check the xmin.
+ */
+
+- xmin = HeapTupleHeaderGetXmin(tup->t_data);
++ xmin = HeapTupleGetXmin(tup);
+ if (!TransactionIdPrecedes(xmin, OldestXmin))
+ return false; /* xmin not old enough for all to see */
+
+diff --git a/contrib/pgrowlocks/pgrowlocks.c b/contrib/pgrowlocks/pgrowlocks.c
+index b11b8750c32..5470d61e250 100644
+--- a/contrib/pgrowlocks/pgrowlocks.c
++++ b/contrib/pgrowlocks/pgrowlocks.c
+@@ -130,7 +130,7 @@ pgrowlocks(PG_FUNCTION_ARGS)
+ htsu = HeapTupleSatisfiesUpdate(tuple,
+ GetCurrentCommandId(false),
+ hscan->rs_cbuf);
+- xmax = HeapTupleHeaderGetRawXmax(tuple->t_data);
++ xmax = HeapTupleGetRawXmax(tuple);
+ infomask = tuple->t_data->t_infomask;
+
+ /*
+diff --git a/contrib/pgstattuple/pgstatapprox.c b/contrib/pgstattuple/pgstatapprox.c
+index 3a5aad30ae2..d122b00bab6 100644
+--- a/contrib/pgstattuple/pgstatapprox.c
++++ b/contrib/pgstattuple/pgstatapprox.c
+@@ -16,6 +16,9 @@
+ #include "access/htup_details.h"
+ #include "access/relation.h"
+ #include "access/visibilitymap.h"
++#include "access/xact.h"
++#include "catalog/catalog.h"
++#include "catalog/namespace.h"
+ #include "catalog/pg_am_d.h"
+ #include "commands/vacuum.h"
+ #include "funcapi.h"
+@@ -140,6 +143,7 @@ statapprox_heap(Relation rel, output_type *stat)
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, IsToastRelation(rel));
+
+ /*
+ * We follow VACUUM's lead in counting INSERT_IN_PROGRESS tuples
+diff --git a/contrib/pgstattuple/pgstatindex.c b/contrib/pgstattuple/pgstatindex.c
+index 4b9d76ec4e4..bcb612f3d90 100644
+--- a/contrib/pgstattuple/pgstatindex.c
++++ b/contrib/pgstattuple/pgstatindex.c
+@@ -627,7 +627,7 @@ pgstathashindex(PG_FUNCTION_ARGS)
+ metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
+ metap = HashPageGetMeta(BufferGetPage(metabuf));
+ stats.version = metap->hashm_version;
+- stats.space_per_page = metap->hashm_bsize;
++ stats.space_per_page = BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(HashPageOpaqueData));
+ _hash_relbuf(rel, metabuf);
+
+ /* Get the current relation length */
+diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
+index f2bcd6aa98c..18eb21d0147 100644
+--- a/contrib/postgres_fdw/expected/postgres_fdw.out
++++ b/contrib/postgres_fdw/expected/postgres_fdw.out
+@@ -4995,16 +4995,24 @@ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *; -- can be pushed down
+- QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------------------
+- Update on public.ft2
+- Output: c1, c2, c3, c4, c5, c6, c7, c8
+- -> Foreign Update on public.ft2
+- Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7') WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+-(4 rows)
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1; -- can be pushed down
++ QUERY PLAN
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------
++ Sort
++ Output: t.c1, t.c2, t.c3, t.c4, t.c5, t.c6, t.c7, t.c8
++ Sort Key: t.c1
++ CTE t
++ -> Update on public.ft2
++ Output: ft2.c1, ft2.c2, ft2.c3, ft2.c4, ft2.c5, ft2.c6, ft2.c7, ft2.c8
++ -> Foreign Update on public.ft2
++ Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7') WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
++ -> CTE Scan on t
++ Output: t.c1, t.c2, t.c3, t.c4, t.c5, t.c6, t.c7, t.c8
++(10 rows)
+
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+ c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8
+ ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
+ 7 | 407 | 00007_update7 | Thu Jan 08 00:00:00 1970 PST | Thu Jan 08 00:00:00 1970 | 7 | 7 | foo
+@@ -5124,16 +5132,24 @@ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
+ EXPLAIN (verbose, costs off)
+- DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4; -- can be pushed down
+- QUERY PLAN
+---------------------------------------------------------------------------------------------
+- Delete on public.ft2
+- Output: c1, c4
+- -> Foreign Delete on public.ft2
+- Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
+-(4 rows)
++ WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++ SELECT * FROM t ORDER BY c1; -- can be pushed down
++ QUERY PLAN
++----------------------------------------------------------------------------------------------------
++ Sort
++ Output: t.c1, t.c4
++ Sort Key: t.c1
++ CTE t
++ -> Delete on public.ft2
++ Output: ft2.c1, ft2.c4
++ -> Foreign Delete on public.ft2
++ Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
++ -> CTE Scan on t
++ Output: t.c1, t.c4
++(10 rows)
+
+-DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
++WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++SELECT * FROM t ORDER BY c1;
+ c1 | c4
+ ------+------------------------------
+ 5 | Tue Jan 06 00:00:00 1970 PST
+@@ -6394,7 +6410,8 @@ INSERT INTO ft2 (c1,c2,c3,c6) VALUES (1218, 818, 'ggg', '(--;') RETURNING *;
+ 1218 | 818 | ggg_trig_update | | | (--; | ft2 |
+ (1 row)
+
+-UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+ c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8
+ ------+-----+------------------------+------------------------------+--------------------------+----+------------+-----
+ 8 | 608 | 00008_trig_update | Fri Jan 09 00:00:00 1970 PST | Fri Jan 09 00:00:00 1970 | 8 | 8 | foo
+diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
+index c0810fbd7c8..e1db0d3a284 100644
+--- a/contrib/postgres_fdw/postgres_fdw.c
++++ b/contrib/postgres_fdw/postgres_fdw.c
+@@ -4838,8 +4838,8 @@ apply_returning_filter(PgFdwDirectModifyState *dmstate,
+ * Note: no need to care about tableoid here because it will be
+ * initialized in ExecProcessReturning().
+ */
+- HeapTupleHeaderSetXmin(resultTup->t_data, InvalidTransactionId);
+- HeapTupleHeaderSetXmax(resultTup->t_data, InvalidTransactionId);
++ HeapTupleSetXmin(resultTup, InvalidTransactionId);
++ HeapTupleSetXmax(resultTup, InvalidTransactionId);
+ HeapTupleHeaderSetCmin(resultTup->t_data, InvalidTransactionId);
+ }
+
+@@ -7695,6 +7695,7 @@ make_tuple_from_result_row(PGresult *res,
+ */
+ if (ctid)
+ tuple->t_self = tuple->t_data->t_ctid = *ctid;
++ HeapTupleSetZeroXids(tuple);
+
+ /*
+ * Stomp on the xmin, xmax, and cmin fields from the tuple created by
+@@ -7704,8 +7705,8 @@ make_tuple_from_result_row(PGresult *res,
+ * assumption. If we don't do this then, for example, the tuple length
+ * ends up in the xmin field, which isn't what we want.
+ */
+- HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId);
+- HeapTupleHeaderSetXmin(tuple->t_data, InvalidTransactionId);
++ HeapTupleSetXmax(tuple, InvalidTransactionId);
++ HeapTupleSetXmin(tuple, InvalidTransactionId);
+ HeapTupleHeaderSetCmin(tuple->t_data, InvalidTransactionId);
+
+ /* Clean up */
+diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql
+index 372fe6dad15..7f7f214f6d4 100644
+--- a/contrib/postgres_fdw/sql/postgres_fdw.sql
++++ b/contrib/postgres_fdw/sql/postgres_fdw.sql
+@@ -1475,16 +1475,20 @@ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3; -- can be pushed down
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *; -- can be pushed down
+-UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1; -- can be pushed down
++WITH t AS (UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9; -- can be pushed down
+ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
+ FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
+ EXPLAIN (verbose, costs off)
+- DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4; -- can be pushed down
+-DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
++ WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++ SELECT * FROM t ORDER BY c1; -- can be pushed down
++WITH t AS (DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4)
++SELECT * FROM t ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2; -- can be pushed down
+ DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
+@@ -1591,7 +1595,8 @@ CREATE TRIGGER t1_br_insert BEFORE INSERT OR UPDATE
+
+ INSERT INTO ft2 (c1,c2,c3) VALUES (1208, 818, 'fff') RETURNING *;
+ INSERT INTO ft2 (c1,c2,c3,c6) VALUES (1218, 818, 'ggg', '(--;') RETURNING *;
+-UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *;
++WITH t AS (UPDATE ft2 SET c2 = c2 + 600 WHERE c1 % 10 = 8 AND c1 < 1200 RETURNING *)
++SELECT * FROM t ORDER BY c1;
+
+ -- Test errors thrown on remote side during update
+ ALTER TABLE "S 1"."T 1" ADD CONSTRAINT c2positive CHECK (c2 >= 0);
+diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
+index 9e3407bf987..7a9b09dfeda 100644
+--- a/src/backend/access/common/heaptuple.c
++++ b/src/backend/access/common/heaptuple.c
+@@ -736,10 +736,10 @@ heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
+ result = PointerGetDatum(&(tup->t_self));
+ break;
+ case MinTransactionIdAttributeNumber:
+- result = TransactionIdGetDatum(HeapTupleHeaderGetRawXmin(tup->t_data));
++ result = TransactionIdGetDatum(HeapTupleGetRawXmin(tup));
+ break;
+ case MaxTransactionIdAttributeNumber:
+- result = TransactionIdGetDatum(HeapTupleHeaderGetRawXmax(tup->t_data));
++ result = TransactionIdGetDatum(HeapTupleGetRawXmax(tup));
+ break;
+ case MinCommandIdAttributeNumber:
+ case MaxCommandIdAttributeNumber:
+@@ -784,6 +784,7 @@ heap_copytuple(HeapTuple tuple)
+ newTuple->t_len = tuple->t_len;
+ newTuple->t_self = tuple->t_self;
+ newTuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(newTuple, tuple);
+ newTuple->t_data = (HeapTupleHeader) ((char *) newTuple + HEAPTUPLESIZE);
+ memcpy((char *) newTuple->t_data, (char *) tuple->t_data, tuple->t_len);
+ return newTuple;
+@@ -810,6 +811,7 @@ heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest)
+ dest->t_len = src->t_len;
+ dest->t_self = src->t_self;
+ dest->t_tableOid = src->t_tableOid;
++ HeapTupleCopyXids(dest, src);
+ dest->t_data = (HeapTupleHeader) palloc(src->t_len);
+ memcpy((char *) dest->t_data, (char *) src->t_data, src->t_len);
+ }
+@@ -1173,6 +1175,7 @@ heap_form_tuple(TupleDesc tupleDescriptor,
+ tuple->t_len = len;
+ ItemPointerSetInvalid(&(tuple->t_self));
+ tuple->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tuple);
+
+ HeapTupleHeaderSetDatumLength(td, len);
+ HeapTupleHeaderSetTypeId(td, tupleDescriptor->tdtypeid);
+@@ -1257,6 +1260,7 @@ heap_modify_tuple(HeapTuple tuple,
+ newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
+ newTuple->t_self = tuple->t_self;
+ newTuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(newTuple, tuple);
+
+ return newTuple;
+ }
+@@ -1320,6 +1324,7 @@ heap_modify_tuple_by_cols(HeapTuple tuple,
+ newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
+ newTuple->t_self = tuple->t_self;
+ newTuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(newTuple, tuple);
+
+ return newTuple;
+ }
+@@ -1560,6 +1565,7 @@ heap_tuple_from_minimal_tuple(MinimalTuple mtup)
+ result->t_len = len;
+ ItemPointerSetInvalid(&(result->t_self));
+ result->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(result);
+ result->t_data = (HeapTupleHeader) ((char *) result + HEAPTUPLESIZE);
+ memcpy((char *) result->t_data + MINIMAL_TUPLE_OFFSET, mtup, mtup->t_len);
+ memset(result->t_data, 0, offsetof(HeapTupleHeaderData, t_infomask2));
+diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
+index b76dca4ef41..10e8ae02c24 100644
+--- a/src/backend/access/heap/heapam.c
++++ b/src/backend/access/heap/heapam.c
+@@ -42,9 +42,13 @@
+ #include "access/xloginsert.h"
+ #include "catalog/pg_database.h"
+ #include "catalog/pg_database_d.h"
++#include "access/xlogutils.h"
++#include "catalog/index.h"
++#include "catalog/namespace.h"
+ #include "commands/vacuum.h"
+ #include "pgstat.h"
+ #include "port/pg_bitutils.h"
++#include "storage/buf_internals.h"
+ #include "storage/lmgr.h"
+ #include "storage/predicate.h"
+ #include "storage/procarray.h"
+@@ -52,9 +56,8 @@
+ #include "utils/inval.h"
+ #include "utils/spccache.h"
+
+-
+ static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup,
+- TransactionId xid, CommandId cid, int options);
++ CommandId cid, int options);
+ static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf,
+ Buffer newbuf, HeapTuple oldtup,
+ HeapTuple newtup, HeapTuple old_key_tuple,
+@@ -102,6 +105,8 @@ static int bottomup_sort_and_shrink(TM_IndexDeleteOp *delstate);
+ static XLogRecPtr log_heap_new_cid(Relation relation, HeapTuple tup);
+ static HeapTuple ExtractReplicaIdentity(Relation relation, HeapTuple tp, bool key_required,
+ bool *copy);
++static bool heap_page_prepare_for_xid(Relation relation, Buffer buffer,
++ TransactionId xid, bool multi);
+
+
+ /*
+@@ -452,6 +457,8 @@ page_collect_tuples(HeapScanDesc scan, Snapshot snapshot,
+ loctup.t_data = (HeapTupleHeader) PageGetItem(page, lpp);
+ loctup.t_len = ItemIdGetLength(lpp);
+ loctup.t_tableOid = RelationGetRelid(scan->rs_base.rs_rd);
++ HeapTupleCopyRawXidsFromPage(buffer, &loctup, page,
++ IsToastRelation(scan->rs_base.rs_rd));
+ ItemPointerSet(&(loctup.t_self), block, lineoff);
+
+ if (all_visible)
+@@ -466,6 +473,12 @@ page_collect_tuples(HeapScanDesc scan, Snapshot snapshot,
+ if (valid)
+ {
+ scan->rs_vistuples[ntup] = lineoff;
++ /*
++ * Since there is no lock futher and xmin or xmax may be
++ * changed while base shift, copy them here.
++ */
++ scan->rs_xmin[ntup] = loctup.t_xmin;
++ scan->rs_xmax[ntup] = loctup.t_xmax;
+ ntup++;
+ }
+ }
+@@ -879,6 +892,8 @@ continue_page:
+
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
+ tuple->t_len = ItemIdGetLength(lpp);
++ HeapTupleCopyXidsFromPage(scan->rs_cbuf, tuple, page,
++ IsToastRelation(scan->rs_base.rs_rd));
+ ItemPointerSet(&(tuple->t_self), scan->rs_cblock, lineoff);
+
+ visible = HeapTupleSatisfiesVisibility(tuple,
+@@ -958,6 +973,9 @@ heapgettup_pagemode(HeapScanDesc scan,
+ linesleft = scan->rs_cindex;
+ /* lineindex now references the next or previous visible tid */
+
++ tuple->t_xmin = scan->rs_xmin[scan->rs_cindex];
++ tuple->t_xmax = scan->rs_xmax[scan->rs_cindex];
++
+ goto continue_page;
+ }
+
+@@ -995,6 +1013,8 @@ continue_page:
+
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
+ tuple->t_len = ItemIdGetLength(lpp);
++ tuple->t_xmin = scan->rs_xmin[lineindex];
++ tuple->t_xmax = scan->rs_xmax[lineindex];
+ ItemPointerSet(&(tuple->t_self), scan->rs_cblock, lineoff);
+
+ /* skip any tuples that don't match the scan key */
+@@ -1560,6 +1580,7 @@ heap_fetch(Relation relation,
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tuple->t_len = ItemIdGetLength(lp);
+ tuple->t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, tuple, page, IsToastRelation(relation));
+
+ /*
+ * check tuple visibility, then release lock
+@@ -1568,7 +1589,7 @@ heap_fetch(Relation relation,
+
+ if (valid)
+ PredicateLockTID(relation, &(tuple->t_self), snapshot,
+- HeapTupleHeaderGetXmin(tuple->t_data));
++ HeapTupleGetXmin(tuple));
+
+ HeapCheckForSerializableConflictOut(valid, relation, tuple, buffer, snapshot);
+
+@@ -1645,6 +1666,8 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ Assert(TransactionIdIsValid(RecentXmin));
+ Assert(BufferGetBlockNumber(buffer) == blkno);
+
++ heapTuple->t_self = *tid;
++
+ /* Scan through possible multiple members of HOT-chain */
+ for (;;)
+ {
+@@ -1680,6 +1703,8 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ heapTuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ heapTuple->t_len = ItemIdGetLength(lp);
+ heapTuple->t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, heapTuple, page,
++ IsToastRelation(relation));
+ ItemPointerSet(&heapTuple->t_self, blkno, offnum);
+
+ /*
+@@ -1694,7 +1719,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ */
+ if (TransactionIdIsValid(prev_xmax) &&
+ !TransactionIdEquals(prev_xmax,
+- HeapTupleHeaderGetXmin(heapTuple->t_data)))
++ HeapTupleGetXmin(heapTuple)))
+ break;
+
+ /*
+@@ -1715,7 +1740,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ {
+ ItemPointerSetOffsetNumber(tid, offnum);
+ PredicateLockTID(relation, &heapTuple->t_self, snapshot,
+- HeapTupleHeaderGetXmin(heapTuple->t_data));
++ HeapTupleGetXmin(heapTuple));
+ if (all_dead)
+ *all_dead = false;
+ return true;
+@@ -1750,7 +1775,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
+ blkno);
+ offnum = ItemPointerGetOffsetNumber(&heapTuple->t_data->t_ctid);
+ at_chain_start = false;
+- prev_xmax = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
++ prev_xmax = HeapTupleGetUpdateXidAny(heapTuple);
+ }
+ else
+ break; /* end of chain */
+@@ -1836,13 +1861,14 @@ heap_get_latest_tid(TableScanDesc sscan,
+ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tp.t_len = ItemIdGetLength(lp);
+ tp.t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
+
+ /*
+ * After following a t_ctid link, we might arrive at an unrelated
+ * tuple. Check for XMIN match.
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(tp.t_data)))
++ !TransactionIdEquals(priorXmax, HeapTupleGetXmin(&tp)))
+ {
+ UnlockReleaseBuffer(buffer);
+ break;
+@@ -1861,7 +1887,7 @@ heap_get_latest_tid(TableScanDesc sscan,
+ * If there's a valid t_ctid link, follow it, else we're done.
+ */
+ if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
+- HeapTupleHeaderIsOnlyLocked(tp.t_data) ||
++ HeapTupleIsOnlyLocked(&tp) ||
+ HeapTupleHeaderIndicatesMovedPartitions(tp.t_data) ||
+ ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid))
+ {
+@@ -1870,7 +1896,7 @@ heap_get_latest_tid(TableScanDesc sscan,
+ }
+
+ ctid = tp.t_data->t_ctid;
+- priorXmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
++ priorXmax = HeapTupleGetUpdateXidAny(&tp);
+ UnlockReleaseBuffer(buffer);
+ } /* end of loop */
+ }
+@@ -1895,7 +1921,7 @@ heap_get_latest_tid(TableScanDesc sscan,
+ static void
+ UpdateXmaxHintBits(HeapTupleHeader tuple, Buffer buffer, TransactionId xid)
+ {
+- Assert(TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple), xid));
++ Assert(TransactionIdEquals(HeapTupleHeaderGetRawXmax(BufferGetPage(buffer), tuple), xid));
+ Assert(!(tuple->t_infomask & HEAP_XMAX_IS_MULTI));
+
+ if (!(tuple->t_infomask & (HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID)))
+@@ -1962,6 +1988,31 @@ ReleaseBulkInsertStatePin(BulkInsertState bistate)
+ bistate->last_free = InvalidBlockNumber;
+ }
+
++/*
++ * Add xid_base and multi base to the WAL record.
++ *
++ * WAL record must being constructed.
++ */
++static inline void
++xlog_register_base(Page page, bool is_toast, TransactionId *xid_base,
++ TransactionId *multi_base)
++{
++ if (is_toast)
++ {
++ *xid_base = ToastPageGetSpecial(page)->pd_xid_base;
++ *multi_base = InvalidTransactionId;
++ }
++ else
++ {
++ HeapPageSpecial special = HeapPageGetSpecial(page);
++
++ *xid_base = special->pd_xid_base;
++ *multi_base = special->pd_multi_base;
++ }
++
++ XLogRegisterData((char *) xid_base, sizeof(*xid_base));
++ XLogRegisterData((char *) multi_base, sizeof(*multi_base));
++}
+
+ /*
+ * heap_insert - insert tuple into a heap
+@@ -2001,7 +2052,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ * Note: below this point, heaptup is the data we actually intend to store
+ * into the relation; tup is the caller's original untoasted data.
+ */
+- heaptup = heap_prepare_insert(relation, tup, xid, cid, options);
++ heaptup = heap_prepare_insert(relation, tup, cid, options);
+
+ /*
+ * Find buffer to insert this tuple into. If the page is all visible,
+@@ -2029,6 +2080,9 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ */
+ CheckForSerializableConflictIn(relation, NULL, InvalidBlockNumber);
+
++ heap_page_prepare_for_xid(relation, buffer, xid, false);
++ HeapTupleSetXmin(heaptup, xid);
++
+ /* NO EREPORT(ERROR) from here till changes are logged */
+ START_CRIT_SECTION();
+
+@@ -2066,6 +2120,8 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ Page page = BufferGetPage(buffer);
+ uint8 info = XLOG_HEAP_INSERT;
+ int bufflags = 0;
++ TransactionId xid_base,
++ multi_base;
+
+ /*
+ * If this is a catalog, we need to transmit combo CIDs to properly
+@@ -2104,12 +2160,17 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ {
+ xlrec.flags |= XLH_INSERT_CONTAINS_NEW_TUPLE;
+ bufflags |= REGBUF_KEEP_DATA;
+-
+- if (IsToastRelation(relation))
+- xlrec.flags |= XLH_INSERT_ON_TOAST_RELATION;
+ }
+
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_INSERT_ON_TOAST_RELATION;
++
+ XLogBeginInsert();
++
++ if (info & XLOG_HEAP_INIT_PAGE)
++ xlog_register_base(page, IsToastRelation(relation), &xid_base,
++ &multi_base);
++
+ XLogRegisterData((char *) &xlrec, SizeOfHeapInsert);
+
+ xlhdr.t_infomask2 = heaptup->t_data->t_infomask2;
+@@ -2171,7 +2232,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ * that in any case, the header fields are also set in the original tuple.
+ */
+ static HeapTuple
+-heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
++heap_prepare_insert(Relation relation, HeapTuple tup,
+ CommandId cid, int options)
+ {
+ /*
+@@ -2188,12 +2249,12 @@ heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
+ tup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
+ tup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);
+ tup->t_data->t_infomask |= HEAP_XMAX_INVALID;
+- HeapTupleHeaderSetXmin(tup->t_data, xid);
++ HeapTupleSetXmin(tup, InvalidTransactionId);
+ if (options & HEAP_INSERT_FROZEN)
+- HeapTupleHeaderSetXminFrozen(tup->t_data);
++ HeapTupleHeaderStoreXminFrozen(tup->t_data);
+
+ HeapTupleHeaderSetCmin(tup->t_data, cid);
+- HeapTupleHeaderSetXmax(tup->t_data, 0); /* for cleanliness */
++ HeapTupleSetXmax(tup, 0); /* for cleanliness */
+ tup->t_tableOid = RelationGetRelid(relation);
+
+ /*
+@@ -2285,8 +2346,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ tuple = ExecFetchSlotHeapTuple(slots[i], true, NULL);
+ slots[i]->tts_tableOid = RelationGetRelid(relation);
+ tuple->t_tableOid = slots[i]->tts_tableOid;
+- heaptuples[i] = heap_prepare_insert(relation, tuple, xid, cid,
+- options);
++ heaptuples[i] = heap_prepare_insert(relation, tuple, cid, options);
+ }
+
+ /*
+@@ -2361,6 +2421,8 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ if (starting_with_empty_page && (options & HEAP_INSERT_FROZEN))
+ all_frozen_set = true;
+
++ heap_page_prepare_for_xid(relation, buffer, xid, false);
++
+ /* NO EREPORT(ERROR) from here till changes are logged */
+ START_CRIT_SECTION();
+
+@@ -2368,6 +2430,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ * RelationGetBufferForTuple has ensured that the first tuple fits.
+ * Put that on the page, and then as many other tuples as fit.
+ */
++ HeapTupleSetXmin(heaptuples[ndone], xid);
+ RelationPutHeapTuple(relation, buffer, heaptuples[ndone], false);
+
+ /*
+@@ -2384,6 +2447,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ if (PageGetHeapFreeSpace(page) < MAXALIGN(heaptup->t_len) + saveFreeSpace)
+ break;
+
++ HeapTupleSetXmin(heaptup, xid);
+ RelationPutHeapTuple(relation, buffer, heaptup, false);
+
+ /*
+@@ -2429,6 +2493,8 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ char *scratchptr = scratch.data;
+ bool init;
+ int bufflags = 0;
++ TransactionId xid_base,
++ multi_base;
+
+ /*
+ * If the page was previously empty, we can reinit the page
+@@ -2519,6 +2585,11 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
+ bufflags |= REGBUF_KEEP_DATA;
+
+ XLogBeginInsert();
++
++ if (info & XLOG_HEAP_INIT_PAGE)
++ xlog_register_base(page, IsToastRelation(relation), &xid_base,
++ &multi_base);
++
+ XLogRegisterData((char *) xlrec, tupledata - scratch.data);
+ XLogRegisterBuffer(0, buffer, REGBUF_STANDARD | bufflags);
+
+@@ -2726,6 +2797,7 @@ heap_delete(Relation relation, ItemPointer tid,
+ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tp.t_len = ItemIdGetLength(lp);
+ tp.t_self = *tid;
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
+
+ l1:
+
+@@ -2757,7 +2829,7 @@ l1:
+ uint16 infomask;
+
+ /* must copy state data before unlocking buffer */
+- xwait = HeapTupleHeaderGetRawXmax(tp.t_data);
++ xwait = HeapTupleGetRawXmax(&tp);
+ infomask = tp.t_data->t_infomask;
+
+ /*
+@@ -2796,6 +2868,10 @@ l1:
+ NULL);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+
++ /* Copy possibly updated xid base after relocking */
++ HeapTupleCopyXidsFromPage(buffer, &tp, page,
++ IsToastRelation(relation));
++
+ /*
+ * If xwait had just locked the tuple then some other xact
+ * could update this tuple before we get to this point. Check
+@@ -2806,7 +2882,7 @@ l1:
+ */
+ if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
+ xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tp.t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(&tp),
+ xwait))
+ goto l1;
+ }
+@@ -2833,6 +2909,10 @@ l1:
+ XactLockTableWait(xwait, relation, &(tp.t_self), XLTW_Delete);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+
++ /* Copy possibly updated xid base after relocking */
++ HeapTupleCopyXidsFromPage(buffer, &tp, page,
++ IsToastRelation(relation));
++
+ /*
+ * xwait is done, but if xwait had just locked the tuple then some
+ * other xact could update this tuple before we get to this point.
+@@ -2843,7 +2923,7 @@ l1:
+ */
+ if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
+ xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tp.t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(&tp),
+ xwait))
+ goto l1;
+
+@@ -2857,7 +2937,7 @@ l1:
+ */
+ if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
+ HEAP_XMAX_IS_LOCKED_ONLY(tp.t_data->t_infomask) ||
+- HeapTupleHeaderIsOnlyLocked(tp.t_data))
++ HeapTupleIsOnlyLocked(&tp))
+ result = TM_Ok;
+ else if (!ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid))
+ result = TM_Updated;
+@@ -2887,9 +2967,9 @@ l1:
+ if (result != TM_Ok)
+ {
+ tmfd->ctid = tp.t_data->t_ctid;
+- tmfd->xmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
++ tmfd->xmax = HeapTupleGetUpdateXidAny(&tp);
+ if (result == TM_SelfModified)
+- tmfd->cmax = HeapTupleHeaderGetCmax(tp.t_data);
++ tmfd->cmax = HeapTupleGetCmax(&tp);
+ else
+ tmfd->cmax = InvalidCommandId;
+ UnlockReleaseBuffer(buffer);
+@@ -2912,7 +2992,7 @@ l1:
+ CheckForSerializableConflictIn(relation, tid, BufferGetBlockNumber(buffer));
+
+ /* replace cid with a combo CID if necessary */
+- HeapTupleHeaderAdjustCmax(tp.t_data, &cid, &iscombo);
++ HeapTupleAdjustCmax(&tp, &cid, &iscombo);
+
+ /*
+ * Compute replica identity tuple before entering the critical section so
+@@ -2930,11 +3010,20 @@ l1:
+ */
+ MultiXactIdSetOldestMember();
+
+- compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(tp.t_data),
++ compute_new_xmax_infomask(HeapTupleGetRawXmax(&tp),
+ tp.t_data->t_infomask, tp.t_data->t_infomask2,
+ xid, LockTupleExclusive, true,
+ &new_xmax, &new_infomask, &new_infomask2);
+
++#ifdef USE_ASSERT_CHECKING
++ if (IsToastRelation(relation))
++ Assert((new_infomask & HEAP_XMAX_IS_MULTI) == 0);
++#endif
++
++ heap_page_prepare_for_xid(relation, buffer, new_xmax,
++ (new_infomask & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
++
+ START_CRIT_SECTION();
+
+ /*
+@@ -2944,7 +3033,7 @@ l1:
+ * the subsequent page pruning will be a no-op and the hint will be
+ * cleared.
+ */
+- PageSetPrunable(page, xid);
++ PageSetPrunable(page, xid, IsToastRelation(relation));
+
+ if (PageIsAllVisible(page))
+ {
+@@ -2960,7 +3049,7 @@ l1:
+ tp.t_data->t_infomask |= new_infomask;
+ tp.t_data->t_infomask2 |= new_infomask2;
+ HeapTupleHeaderClearHotUpdated(tp.t_data);
+- HeapTupleHeaderSetXmax(tp.t_data, new_xmax);
++ HeapTupleAndHeaderSetXmax(page, &tp, new_xmax, IsToastRelation(relation));
+ HeapTupleHeaderSetCmax(tp.t_data, cid, iscombo);
+ /* Make sure there is no forward chain link in t_ctid */
+ tp.t_data->t_ctid = tp.t_self;
+@@ -2999,6 +3088,8 @@ l1:
+ tp.t_data->t_infomask2);
+ xlrec.offnum = ItemPointerGetOffsetNumber(&tp.t_self);
+ xlrec.xmax = new_xmax;
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_DELETE_PAGE_ON_TOAST_RELATION;
+
+ if (old_key_tuple != NULL)
+ {
+@@ -3156,7 +3247,8 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
+ HeapTuple heaptup;
+ HeapTuple old_key_tuple = NULL;
+ bool old_key_copied = false;
+- Page page;
++ Page page,
++ newpage;
+ BlockNumber block;
+ MultiXactStatus mxact_status;
+ Buffer buffer,
+@@ -3183,6 +3275,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
+ infomask_new_tuple,
+ infomask2_new_tuple;
+
++ Assert(!IsToastRelation(relation));
+ Assert(ItemPointerIsValid(otid));
+
+ /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
+@@ -3258,6 +3351,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
+ oldtup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ oldtup.t_len = ItemIdGetLength(lp);
+ oldtup.t_self = *otid;
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+
+ /* the new tuple is ready, except for this: */
+ newtup->t_tableOid = RelationGetRelid(relation);
+@@ -3351,7 +3445,7 @@ l2:
+ */
+
+ /* must copy state data before unlocking buffer */
+- xwait = HeapTupleHeaderGetRawXmax(oldtup.t_data);
++ xwait = HeapTupleGetRawXmax(&oldtup);
+ infomask = oldtup.t_data->t_infomask;
+
+ /*
+@@ -3402,6 +3496,7 @@ l2:
+ checked_lockers = true;
+ locker_remains = remain != 0;
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+
+ /*
+ * If xwait had just locked the tuple then some other xact
+@@ -3410,7 +3505,7 @@ l2:
+ */
+ if (xmax_infomask_changed(oldtup.t_data->t_infomask,
+ infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(oldtup.t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(&oldtup),
+ xwait))
+ goto l2;
+ }
+@@ -3436,7 +3531,7 @@ l2:
+ * subxact aborts.
+ */
+ if (!HEAP_XMAX_IS_LOCKED_ONLY(oldtup.t_data->t_infomask))
+- update_xact = HeapTupleGetUpdateXid(oldtup.t_data);
++ update_xact = HeapTupleGetUpdateXid(&oldtup);
+ else
+ update_xact = InvalidTransactionId;
+
+@@ -3483,7 +3578,7 @@ l2:
+ XLTW_Update);
+ checked_lockers = true;
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+-
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+ /*
+ * xwait is done, but if xwait had just locked the tuple then some
+ * other xact could update this tuple before we get to this point.
+@@ -3491,7 +3586,7 @@ l2:
+ */
+ if (xmax_infomask_changed(oldtup.t_data->t_infomask, infomask) ||
+ !TransactionIdEquals(xwait,
+- HeapTupleHeaderGetRawXmax(oldtup.t_data)))
++ HeapTupleGetRawXmax(&oldtup)))
+ goto l2;
+
+ /* Otherwise check if it committed or aborted */
+@@ -3530,9 +3625,9 @@ l2:
+ if (result != TM_Ok)
+ {
+ tmfd->ctid = oldtup.t_data->t_ctid;
+- tmfd->xmax = HeapTupleHeaderGetUpdateXid(oldtup.t_data);
++ tmfd->xmax = HeapTupleGetUpdateXidAny(&oldtup);
+ if (result == TM_SelfModified)
+- tmfd->cmax = HeapTupleHeaderGetCmax(oldtup.t_data);
++ tmfd->cmax = HeapTupleGetCmax(&oldtup);
+ else
+ tmfd->cmax = InvalidCommandId;
+ UnlockReleaseBuffer(buffer);
+@@ -3565,6 +3660,7 @@ l2:
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ visibilitymap_pin(relation, block, &vmbuffer);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+ goto l2;
+ }
+
+@@ -3574,7 +3670,7 @@ l2:
+ * If the tuple we're updating is locked, we need to preserve the locking
+ * info in the old tuple's Xmax. Prepare a new Xmax value for this.
+ */
+- compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
++ compute_new_xmax_infomask(HeapTupleGetRawXmax(&oldtup),
+ oldtup.t_data->t_infomask,
+ oldtup.t_data->t_infomask2,
+ xid, *lockmode, true,
+@@ -3593,7 +3689,7 @@ l2:
+ (checked_lockers && !locker_remains))
+ xmax_new_tuple = InvalidTransactionId;
+ else
+- xmax_new_tuple = HeapTupleHeaderGetRawXmax(oldtup.t_data);
++ xmax_new_tuple = HeapTupleGetRawXmax(&oldtup);
+
+ if (!TransactionIdIsValid(xmax_new_tuple))
+ {
+@@ -3626,17 +3722,15 @@ l2:
+ */
+ newtup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
+ newtup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);
+- HeapTupleHeaderSetXmin(newtup->t_data, xid);
+ HeapTupleHeaderSetCmin(newtup->t_data, cid);
+ newtup->t_data->t_infomask |= HEAP_UPDATED | infomask_new_tuple;
+ newtup->t_data->t_infomask2 |= infomask2_new_tuple;
+- HeapTupleHeaderSetXmax(newtup->t_data, xmax_new_tuple);
+
+ /*
+ * Replace cid with a combo CID if necessary. Note that we already put
+ * the plain cid into the new tuple.
+ */
+- HeapTupleHeaderAdjustCmax(oldtup.t_data, &cid, &iscombo);
++ HeapTupleAdjustCmax(&oldtup, &cid, &iscombo);
+
+ /*
+ * If the toaster needs to be activated, OR if the new tuple will not fit
+@@ -3666,7 +3760,7 @@ l2:
+
+ newtupsize = MAXALIGN(newtup->t_len);
+
+- if (need_toast || newtupsize > pagefree)
++ if (need_toast || newtupsize > pagefree || HeapPageIsDoubleXmax(page))
+ {
+ TransactionId xmax_lock_old_tuple;
+ uint16 infomask_lock_old_tuple,
+@@ -3691,7 +3785,7 @@ l2:
+ * updating, because the potentially created multixact would otherwise
+ * be wrong.
+ */
+- compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
++ compute_new_xmax_infomask(HeapTupleGetRawXmax(&oldtup),
+ oldtup.t_data->t_infomask,
+ oldtup.t_data->t_infomask2,
+ xid, *lockmode, false,
+@@ -3700,6 +3794,10 @@ l2:
+
+ Assert(HEAP_XMAX_IS_LOCKED_ONLY(infomask_lock_old_tuple));
+
++ heap_page_prepare_for_xid(relation, buffer, xmax_lock_old_tuple,
++ (infomask_lock_old_tuple & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
++
+ START_CRIT_SECTION();
+
+ /* Clear obsolete visibility flags ... */
+@@ -3708,9 +3806,9 @@ l2:
+ HeapTupleClearHotUpdated(&oldtup);
+ /* ... and store info about transaction updating this tuple */
+ Assert(TransactionIdIsValid(xmax_lock_old_tuple));
+- HeapTupleHeaderSetXmax(oldtup.t_data, xmax_lock_old_tuple);
+ oldtup.t_data->t_infomask |= infomask_lock_old_tuple;
+ oldtup.t_data->t_infomask2 |= infomask2_lock_old_tuple;
++ HeapTupleAndHeaderSetXmax(page, &oldtup, xmax_lock_old_tuple, false);
+ HeapTupleHeaderSetCmax(oldtup.t_data, cid, iscombo);
+
+ /* temporarily make it look not-updated, but locked */
+@@ -3793,7 +3891,11 @@ l2:
+ */
+ for (;;)
+ {
+- if (newtupsize > pagefree)
++ /*
++ * We can't fit new tuple to "double xmax" page, since it's
++ * impossible to set xmin there.
++ */
++ if (newtupsize > pagefree || HeapPageIsDoubleXmax(page))
+ {
+ /* It doesn't fit, must use RelationGetBufferForTuple. */
+ newbuf = RelationGetBufferForTuple(relation, heaptup->t_len,
+@@ -3827,6 +3929,9 @@ l2:
+ break;
+ }
+ }
++
++ /* Copy possibly updated xid base to old tuple after relocking */
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+ }
+ else
+ {
+@@ -3898,6 +4003,33 @@ l2:
+ id_has_external,
+ &old_key_copied);
+
++ newpage = BufferGetPage(newbuf);
++
++ /*
++ * Prepare pages for the current xid, that witten to the new tuple's Xmax
++ * and old page's pd_prune_xid.
++ */
++ heap_page_prepare_for_xid(relation, buffer, xid, false);
++ if (newbuf != buffer)
++ heap_page_prepare_for_xid(relation, newbuf, xid, false);
++
++ /* Prepare pages for tuple's Xmax */
++ heap_page_prepare_for_xid(relation, buffer, xmax_old_tuple,
++ (infomask_old_tuple & HEAP_XMAX_IS_MULTI) != 0);
++ heap_page_prepare_for_xid(relation, newbuf, xmax_new_tuple,
++ (heaptup->t_data->t_infomask & HEAP_XMAX_IS_MULTI) != 0);
++
++ /* Copy possibly updated Xid bases to the both tuples. */
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
++
++ /*
++ * Set new tuple's Xmin/Xmax, old tuple's Xmin/Xmax were already shifted.
++ */
++ HeapTupleAndHeaderSetXmin(newpage, heaptup, xid,
++ IsToastRelation(relation));
++ HeapTupleAndHeaderSetXmax(newpage, heaptup, xmax_new_tuple,
++ IsToastRelation(relation));
++
+ /* NO EREPORT(ERROR) from here till changes are logged */
+ START_CRIT_SECTION();
+
+@@ -3913,7 +4045,7 @@ l2:
+ * not to optimize for aborts. Note that heap_xlog_update must be kept in
+ * sync if this decision changes.
+ */
+- PageSetPrunable(page, xid);
++ PageSetPrunable(page, xid, false);
+
+ if (use_hot_update)
+ {
+@@ -3940,10 +4072,11 @@ l2:
+ oldtup.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+ /* ... and store info about transaction updating this tuple */
+ Assert(TransactionIdIsValid(xmax_old_tuple));
+- HeapTupleHeaderSetXmax(oldtup.t_data, xmax_old_tuple);
+ oldtup.t_data->t_infomask |= infomask_old_tuple;
+ oldtup.t_data->t_infomask2 |= infomask2_old_tuple;
++ HeapTupleAndHeaderSetXmax(page, &oldtup, xmax_old_tuple, false);
+ HeapTupleHeaderSetCmax(oldtup.t_data, cid, iscombo);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, false);
+
+ /* record address of new tuple in t_ctid of old one */
+ oldtup.t_data->t_ctid = heaptup->t_self;
+@@ -3997,6 +4130,18 @@ l2:
+
+ END_CRIT_SECTION();
+
++ if (newtup != heaptup)
++ {
++ /*
++ * Set new tuple's Xmin/Xmax only after both xid base preparations.
++ * Old tuple's Xmin/Xmax were already shifted because old tuple is on
++ * the page.
++ */
++ Assert(!IsToastRelation(relation));
++ HeapTupleAndHeaderSetXmin(newpage, heaptup, xid, false);
++ HeapTupleAndHeaderSetXmax(newpage, newtup, xmax_new_tuple, false);
++ }
++
+ if (newbuf != buffer)
+ LockBuffer(newbuf, BUFFER_LOCK_UNLOCK);
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+@@ -4466,6 +4611,7 @@ heap_lock_tuple(Relation relation, HeapTuple tuple,
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tuple->t_len = ItemIdGetLength(lp);
+ tuple->t_tableOid = RelationGetRelid(relation);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ l3:
+ result = HeapTupleSatisfiesUpdate(tuple, cid, *buffer);
+@@ -4492,7 +4638,7 @@ l3:
+ ItemPointerData t_ctid;
+
+ /* must copy state data before unlocking buffer */
+- xwait = HeapTupleHeaderGetRawXmax(tuple->t_data);
++ xwait = HeapTupleGetRawXmax(tuple);
+ infomask = tuple->t_data->t_infomask;
+ infomask2 = tuple->t_data->t_infomask2;
+ ItemPointerCopy(&tuple->t_data->t_ctid, &t_ctid);
+@@ -4650,11 +4796,13 @@ l3:
+ result = res;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+ }
+
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /*
+ * Make sure it's still an appropriate lock, else start over.
+@@ -4663,7 +4811,7 @@ l3:
+ * now need to follow the update chain to lock the new
+ * versions.
+ */
+- if (!HeapTupleHeaderIsOnlyLocked(tuple->t_data) &&
++ if (!HeapTupleIsOnlyLocked(tuple) &&
+ ((tuple->t_data->t_infomask2 & HEAP_KEYS_UPDATED) ||
+ !updated))
+ goto l3;
+@@ -4690,6 +4838,7 @@ l3:
+ !HEAP_XMAX_IS_EXCL_LOCKED(infomask))
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /*
+ * Make sure it's still an appropriate lock, else start over.
+@@ -4718,8 +4867,10 @@ l3:
+ * meantime, start over.
+ */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
++
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+
+@@ -4730,10 +4881,11 @@ l3:
+ else if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask))
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /* if the xmax changed in the meantime, start over */
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+ /* otherwise, we're good */
+@@ -4758,8 +4910,10 @@ l3:
+ {
+ /* ... but if the xmax changed in the meantime, start over */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
++
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+ Assert(HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask));
+@@ -4780,6 +4934,7 @@ l3:
+ if (require_sleep && (result == TM_Updated || result == TM_Deleted))
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+ else if (require_sleep)
+@@ -4805,6 +4960,7 @@ l3:
+ result = TM_WouldBlock;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+
+@@ -4831,6 +4987,8 @@ l3:
+ result = TM_WouldBlock;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page,
++ false);
+ goto failed;
+ }
+ break;
+@@ -4871,6 +5029,8 @@ l3:
+ result = TM_WouldBlock;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page,
++ false);
+ goto failed;
+ }
+ break;
+@@ -4897,11 +5057,13 @@ l3:
+ result = res;
+ /* recovery code expects to have buffer lock held */
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto failed;
+ }
+ }
+
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+
+ /*
+ * xwait is done, but if xwait had just locked the tuple then some
+@@ -4909,7 +5071,7 @@ l3:
+ * Check for xmax change, and start over if so.
+ */
+ if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
+- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
++ !TransactionIdEquals(HeapTupleGetRawXmax(tuple),
+ xwait))
+ goto l3;
+
+@@ -4937,7 +5099,7 @@ l3:
+ if (!require_sleep ||
+ (tuple->t_data->t_infomask & HEAP_XMAX_INVALID) ||
+ HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask) ||
+- HeapTupleHeaderIsOnlyLocked(tuple->t_data))
++ HeapTupleIsOnlyLocked(tuple))
+ result = TM_Ok;
+ else if (!ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid))
+ result = TM_Updated;
+@@ -4963,9 +5125,9 @@ failed:
+ Assert(result != TM_Updated ||
+ !ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid));
+ tmfd->ctid = tuple->t_data->t_ctid;
+- tmfd->xmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
++ tmfd->xmax = HeapTupleGetUpdateXidAny(tuple);
+ if (result == TM_SelfModified)
+- tmfd->cmax = HeapTupleHeaderGetCmax(tuple->t_data);
++ tmfd->cmax = HeapTupleGetCmax(tuple);
+ else
+ tmfd->cmax = InvalidCommandId;
+ goto out_locked;
+@@ -4985,10 +5147,11 @@ failed:
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
+ visibilitymap_pin(relation, block, &vmbuffer);
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
+ goto l3;
+ }
+
+- xmax = HeapTupleHeaderGetRawXmax(tuple->t_data);
++ xmax = HeapTupleGetRawXmax(tuple);
+ old_infomask = tuple->t_data->t_infomask;
+
+ /*
+@@ -5010,6 +5173,10 @@ failed:
+ GetCurrentTransactionId(), mode, false,
+ &xid, &new_infomask, &new_infomask2);
+
++ heap_page_prepare_for_xid(relation, *buffer, xid,
++ (new_infomask & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(*buffer, tuple, page, false);
++
+ START_CRIT_SECTION();
+
+ /*
+@@ -5028,7 +5195,8 @@ failed:
+ tuple->t_data->t_infomask2 |= new_infomask2;
+ if (HEAP_XMAX_IS_LOCKED_ONLY(new_infomask))
+ HeapTupleHeaderClearHotUpdated(tuple->t_data);
+- HeapTupleHeaderSetXmax(tuple->t_data, xid);
++ Assert(!IsToastRelation(relation));
++ HeapTupleAndHeaderSetXmax(page, tuple, xid, false);
+
+ /*
+ * Make sure there is no forward chain link in t_ctid. Note that in the
+@@ -5622,12 +5790,19 @@ l4:
+ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+ }
+
++ /*
++ * Copy xid base after buffer relocking, it could have changed since
++ * heap_fetch().
++ */
++ HeapTupleCopyXidsFromPage(buf, &mytup, BufferGetPage(buf),
++ IsToastRelation(rel));
++
+ /*
+ * Check the tuple XMIN against prior XMAX, if any. If we reached the
+ * end of the chain, we're done, so return success.
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(HeapTupleHeaderGetXmin(mytup.t_data),
++ !TransactionIdEquals(HeapTupleGetXmin(&mytup),
+ priorXmax))
+ {
+ result = TM_Ok;
+@@ -5639,7 +5814,7 @@ l4:
+ * (sub)transaction, then we already locked the last live one in the
+ * chain, thus we're done, so return success.
+ */
+- if (TransactionIdDidAbort(HeapTupleHeaderGetXmin(mytup.t_data)))
++ if (TransactionIdDidAbort(HeapTupleGetXmin(&mytup)))
+ {
+ result = TM_Ok;
+ goto out_locked;
+@@ -5647,7 +5822,7 @@ l4:
+
+ old_infomask = mytup.t_data->t_infomask;
+ old_infomask2 = mytup.t_data->t_infomask2;
+- xmax = HeapTupleHeaderGetRawXmax(mytup.t_data);
++ xmax = HeapTupleGetRawXmax(&mytup);
+
+ /*
+ * If this tuple version has been updated or locked by some concurrent
+@@ -5660,7 +5835,7 @@ l4:
+ TransactionId rawxmax;
+ bool needwait;
+
+- rawxmax = HeapTupleHeaderGetRawXmax(mytup.t_data);
++ rawxmax = HeapTupleGetRawXmax(&mytup);
+ if (old_infomask & HEAP_XMAX_IS_MULTI)
+ {
+ int nmembers;
+@@ -5801,14 +5976,25 @@ l4:
+ VISIBILITYMAP_ALL_FROZEN))
+ cleared_all_frozen = true;
+
++#ifdef USE_ASSERT_CHECKING
++ if (IsToastRelation(rel))
++ Assert((new_infomask & HEAP_XMAX_IS_MULTI) == 0);
++#endif
++
++ heap_page_prepare_for_xid(rel, buf, new_xmax,
++ (new_infomask & HEAP_XMAX_IS_MULTI) != 0);
++ HeapTupleCopyXidsFromPage(buf, &mytup, BufferGetPage(buf),
++ IsToastRelation(rel));
++
+ START_CRIT_SECTION();
+
+ /* ... and set them */
+- HeapTupleHeaderSetXmax(mytup.t_data, new_xmax);
+ mytup.t_data->t_infomask &= ~HEAP_XMAX_BITS;
+ mytup.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+ mytup.t_data->t_infomask |= new_infomask;
+ mytup.t_data->t_infomask2 |= new_infomask2;
++ Assert(!IsToastRelation(rel));
++ HeapTupleAndHeaderSetXmax(BufferGetPage(buf), &mytup, new_xmax, false);
+
+ MarkBufferDirty(buf);
+
+@@ -5842,14 +6028,14 @@ next:
+ if (mytup.t_data->t_infomask & HEAP_XMAX_INVALID ||
+ HeapTupleHeaderIndicatesMovedPartitions(mytup.t_data) ||
+ ItemPointerEquals(&mytup.t_self, &mytup.t_data->t_ctid) ||
+- HeapTupleHeaderIsOnlyLocked(mytup.t_data))
++ HeapTupleIsOnlyLocked(&mytup))
+ {
+ result = TM_Ok;
+ goto out_locked;
+ }
+
+ /* tail recursion */
+- priorXmax = HeapTupleHeaderGetUpdateXid(mytup.t_data);
++ priorXmax = HeapTupleGetUpdateXidAny(&mytup);
+ ItemPointerCopy(&(mytup.t_data->t_ctid), &tupid);
+ UnlockReleaseBuffer(buf);
+ }
+@@ -6051,12 +6237,13 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ tp.t_len = ItemIdGetLength(lp);
+ tp.t_self = *tid;
++ HeapTupleCopyXidsFromPage(buffer, &tp, page, IsToastRelation(relation));
+
+ /*
+ * Sanity check that the tuple really is a speculatively inserted tuple,
+ * inserted by us.
+ */
+- if (tp.t_data->t_choice.t_heap.t_xmin != xid)
++ if (HeapTupleGetRawXmin(&tp) != xid)
+ elog(ERROR, "attempted to kill a tuple inserted by another transaction");
+ if (!(IsToastRelation(relation) || HeapTupleHeaderIsSpeculative(tp.t_data)))
+ elog(ERROR, "attempted to kill a non-speculative tuple");
+@@ -6089,7 +6276,9 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ prune_xid = relfrozenxid;
+ else
+ prune_xid = TransactionXmin;
+- PageSetPrunable(page, prune_xid);
++ Assert(TransactionIdIsValid(prune_xid));
++ heap_page_prepare_for_xid(relation, buffer, prune_xid, false);
++ PageSetPrunable(page, prune_xid, IsToastRelation(relation));
+ }
+
+ /* store transaction information of xact deleting the tuple */
+@@ -6099,9 +6288,12 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ /*
+ * Set the tuple header xmin to InvalidTransactionId. This makes the
+ * tuple immediately invisible everyone. (In particular, to any
+- * transactions waiting on the speculative token, woken up later.)
++ * transactions waiting on the speculative token, woken up later.) Don't
++ * need to reload xid base from page because InvalidTransactionId doesn't
++ * require xid base to be valid.
+ */
+- HeapTupleHeaderSetXmin(tp.t_data, InvalidTransactionId);
++ HeapTupleAndHeaderSetXmin(page, &tp, InvalidTransactionId,
++ IsToastRelation(relation));
+
+ /* Clear the speculative insertion token too */
+ tp.t_data->t_ctid = tp.t_self;
+@@ -6120,6 +6312,8 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
+ XLogRecPtr recptr;
+
+ xlrec.flags = XLH_DELETE_IS_SUPER;
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_DELETE_PAGE_ON_TOAST_RELATION;
+ xlrec.infobits_set = compute_infobits(tp.t_data->t_infomask,
+ tp.t_data->t_infomask2);
+ xlrec.offnum = ItemPointerGetOffsetNumber(&tp.t_self);
+@@ -6207,6 +6401,7 @@ heap_inplace_lock(Relation relation,
+ HeapTupleData oldtup = *oldtup_ptr; /* minimize diff vs. heap_update() */
+ TM_Result result;
+ bool ret;
++ Page page;
+
+ #ifdef USE_ASSERT_CHECKING
+ if (RelationGetRelid(relation) == RelationRelationId)
+@@ -6228,6 +6423,8 @@ heap_inplace_lock(Relation relation,
+
+ LockTuple(relation, &oldtup.t_self, InplaceUpdateTupleLock);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
++ page = (Page) BufferGetPage(buffer);
++ HeapTupleCopyXidsFromPage(buffer, &oldtup, page, IsToastRelation(relation));
+
+ /*----------
+ * Interpret HeapTupleSatisfiesUpdate() like heap_update() does, except:
+@@ -6265,7 +6462,7 @@ heap_inplace_lock(Relation relation,
+ TransactionId xwait;
+ uint16 infomask;
+
+- xwait = HeapTupleHeaderGetRawXmax(oldtup.t_data);
++ xwait = HeapTupleGetRawXmax(&oldtup);
+ infomask = oldtup.t_data->t_infomask;
+
+ if (infomask & HEAP_XMAX_IS_MULTI)
+@@ -6616,7 +6813,7 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ * been pruned away instead, since updater XID is < OldestXmin).
+ * Just remove xmax.
+ */
+- if (TransactionIdDidCommit(update_xact))
++ if (!TransactionIdDidAbort(update_xact))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg_internal("multixact %llu contains non-aborted update XID %llu from before removable cutoff %llu",
+@@ -6714,7 +6911,7 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ * even member XIDs >= OldestXmin often won't be kept by second pass.
+ */
+ nnewmembers = 0;
+- newmembers = palloc(sizeof(MultiXactMember) * nmembers);
++ newmembers = palloc0(sizeof(MultiXactMember) * nmembers);
+ has_lockers = false;
+ update_xid = InvalidTransactionId;
+ update_committed = false;
+@@ -6900,7 +7097,7 @@ FreezeMultiXactId(MultiXactId multi, uint16 t_infomask,
+ * then caller had better have an exclusive lock on it already.
+ */
+ bool
+-heap_prepare_freeze_tuple(HeapTupleHeader tuple,
++heap_prepare_freeze_tuple(HeapTuple htup,
+ const struct VacuumCutoffs *cutoffs,
+ HeapPageFreeze *pagefrz,
+ HeapTupleFreeze *frz, bool *totally_frozen)
+@@ -6912,8 +7109,9 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ replace_xmax = false,
+ freeze_xmax = false;
+ TransactionId xid;
++ HeapTupleHeader tuple = htup->t_data;
+
+- frz->xmax = HeapTupleHeaderGetRawXmax(tuple);
++ frz->xmax = HeapTupleGetRawXmax(htup);
+ frz->t_infomask2 = tuple->t_infomask2;
+ frz->t_infomask = tuple->t_infomask;
+ frz->frzflags = 0;
+@@ -6924,7 +7122,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ * will become frozen iff our freeze plan is executed by caller (could be
+ * neither).
+ */
+- xid = HeapTupleHeaderGetXmin(tuple);
++ xid = HeapTupleGetXmin(htup);
+ if (!TransactionIdIsNormal(xid))
+ xmin_already_frozen = true;
+ else
+@@ -7066,6 +7264,15 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ /* MultiXactId processing forces freezing (barring FRM_NOOP case) */
+ Assert(pagefrz->freeze_required || (!freeze_xmax && !replace_xmax));
+ }
++ else if ((tuple->t_infomask & HEAP_XMAX_INVALID) &&
++ TransactionIdIsNormal(xid))
++ {
++ /*
++ * To reset xmax without reading clog.
++ * This prevent excess growth of xmax.
++ */
++ freeze_xmax = true;
++ }
+ else if (TransactionIdIsNormal(xid))
+ {
+ /* Raw xmax is normal XID */
+@@ -7087,7 +7294,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ if (freeze_xmax && !HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ frz->checkflags |= HEAP_FREEZE_CHECK_XMAX_ABORTED;
+ }
+- else if (!TransactionIdIsValid(xid))
++ else if (!TransactionIdIsValid(HeapTupleGetRawXmax(htup)))
+ {
+ /* Raw xmax is InvalidTransactionId XID */
+ Assert((tuple->t_infomask & HEAP_XMAX_IS_MULTI) == 0);
+@@ -7157,7 +7364,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ * Does this tuple force caller to freeze the entire page?
+ */
+ pagefrz->freeze_required =
+- heap_tuple_should_freeze(tuple, cutoffs,
++ heap_tuple_should_freeze(htup, cutoffs,
+ &pagefrz->NoFreezePageRelfrozenXid,
+ &pagefrz->NoFreezePageRelminMxid);
+ }
+@@ -7175,7 +7382,7 @@ heap_prepare_freeze_tuple(HeapTupleHeader tuple,
+ * successive VACUUMs that each decide against freezing the same page.
+ */
+ void
+-heap_pre_freeze_checks(Buffer buffer,
++heap_pre_freeze_checks(Relation rel, Buffer buffer,
+ HeapTupleFreeze *tuples, int ntuples)
+ {
+ Page page = BufferGetPage(buffer);
+@@ -7184,34 +7391,31 @@ heap_pre_freeze_checks(Buffer buffer,
+ {
+ HeapTupleFreeze *frz = tuples + i;
+ ItemId itemid = PageGetItemId(page, frz->offset);
+- HeapTupleHeader htup;
++ HeapTupleData tuple;
+
+- htup = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page, IsToastRelation(rel));
+
+ /* Deliberately avoid relying on tuple hint bits here */
+ if (frz->checkflags & HEAP_FREEZE_CHECK_XMIN_COMMITTED)
+ {
+- TransactionId xmin = HeapTupleHeaderGetRawXmin(htup);
++ TransactionId xmin = HeapTupleGetXmin(&tuple);
+
+- Assert(!HeapTupleHeaderXminFrozen(htup));
++ Assert(!HeapTupleHeaderXminFrozen(tuple.t_data));
+ if (unlikely(!TransactionIdDidCommit(xmin)))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg_internal("uncommitted xmin %llu needs to be frozen",
+ (unsigned long long) xmin)));
+ }
+-
+- /*
+- * TransactionIdDidAbort won't work reliably in the presence of XIDs
+- * left behind by transactions that were in progress during a crash,
+- * so we can only check that xmax didn't commit
+- */
+ if (frz->checkflags & HEAP_FREEZE_CHECK_XMAX_ABORTED)
+ {
+- TransactionId xmax = HeapTupleHeaderGetRawXmax(htup);
++ TransactionId xmax = HeapTupleGetRawXmax(&tuple);
+
+ Assert(TransactionIdIsNormal(xmax));
+- if (unlikely(TransactionIdDidCommit(xmax)))
++ if (unlikely(!TransactionIdDidAbort(xmax)))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg_internal("cannot freeze non-aborted xmax %llu",
+@@ -7228,7 +7432,7 @@ heap_pre_freeze_checks(Buffer buffer,
+ * if needed, emits WAL.
+ */
+ void
+-heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
++heap_freeze_prepared_tuples(Relation rel, Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
+ {
+ Page page = BufferGetPage(buffer);
+
+@@ -7239,7 +7443,9 @@ heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
+ HeapTupleHeader htup;
+
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
+- heap_execute_freeze_tuple(htup, frz);
++ heap_execute_freeze_tuple_page(page, htup, frz,
++ IsToastRelation(rel));
++
+ }
+ }
+
+@@ -7250,7 +7456,7 @@ heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
+ * Useful for callers like CLUSTER that perform their own WAL logging.
+ */
+ bool
+-heap_freeze_tuple(HeapTupleHeader tuple,
++heap_freeze_tuple(HeapTuple tuple,
+ TransactionId relfrozenxid, TransactionId relminmxid,
+ TransactionId FreezeLimit, TransactionId MultiXactCutoff)
+ {
+@@ -7427,10 +7633,10 @@ MultiXactIdGetUpdateXid(TransactionId xmax, uint16 t_infomask)
+ * checking the hint bits.
+ */
+ TransactionId
+-HeapTupleGetUpdateXid(HeapTupleHeader tuple)
++HeapTupleGetUpdateXid(HeapTuple tuple)
+ {
+- return MultiXactIdGetUpdateXid(HeapTupleHeaderGetRawXmax(tuple),
+- tuple->t_infomask);
++ return MultiXactIdGetUpdateXid(HeapTupleGetRawXmax(tuple),
++ tuple->t_data->t_infomask);
+ }
+
+ /*
+@@ -7656,15 +7862,18 @@ ConditionalMultiXactIdWait(MultiXactId multi, MultiXactStatus status,
+ * will eventually require freezing (if tuple isn't removed by pruning first).
+ */
+ bool
+-heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
++heap_tuple_needs_eventual_freeze(HeapTuple htup)
+ {
+ TransactionId xid;
++ HeapTupleHeader tuple;
++
++ tuple = htup->t_data;
+
+ /*
+ * If xmin is a normal transaction ID, this tuple is definitely not
+ * frozen.
+ */
+- xid = HeapTupleHeaderGetXmin(tuple);
++ xid = HeapTupleGetXmin(htup);
+ if (TransactionIdIsNormal(xid))
+ return true;
+
+@@ -7675,13 +7884,13 @@ heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
+ {
+ MultiXactId multi;
+
+- multi = HeapTupleHeaderGetRawXmax(tuple);
++ multi = HeapTupleGetRawXmax(htup);
+ if (MultiXactIdIsValid(multi))
+ return true;
+ }
+ else
+ {
+- xid = HeapTupleHeaderGetRawXmax(tuple);
++ xid = HeapTupleGetRawXmax(htup);
+ if (TransactionIdIsNormal(xid))
+ return true;
+ }
+@@ -7711,17 +7920,18 @@ heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
+ * point that it fully commits to not freezing the tuple/page in question.
+ */
+ bool
+-heap_tuple_should_freeze(HeapTupleHeader tuple,
++heap_tuple_should_freeze(HeapTuple htup,
+ const struct VacuumCutoffs *cutoffs,
+ TransactionId *NoFreezePageRelfrozenXid,
+ MultiXactId *NoFreezePageRelminMxid)
+ {
+ TransactionId xid;
+ MultiXactId multi;
++ HeapTupleHeader tuple = htup->t_data;
+ bool freeze = false;
+
+ /* First deal with xmin */
+- xid = HeapTupleHeaderGetXmin(tuple);
++ xid = HeapTupleGetXmin(htup);
+ if (TransactionIdIsNormal(xid))
+ {
+ Assert(TransactionIdPrecedesOrEquals(cutoffs->relfrozenxid, xid));
+@@ -7735,9 +7945,9 @@ heap_tuple_should_freeze(HeapTupleHeader tuple,
+ xid = InvalidTransactionId;
+ multi = InvalidMultiXactId;
+ if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
+- multi = HeapTupleHeaderGetRawXmax(tuple);
++ multi = HeapTupleGetRawXmax(htup);
+ else
+- xid = HeapTupleHeaderGetRawXmax(tuple);
++ xid = HeapTupleGetRawXmax(htup);
+
+ if (TransactionIdIsNormal(xid))
+ {
+@@ -7748,6 +7958,14 @@ heap_tuple_should_freeze(HeapTupleHeader tuple,
+ if (TransactionIdPrecedes(xid, cutoffs->FreezeLimit))
+ freeze = true;
+ }
++ else if ((tuple->t_infomask & HEAP_XMAX_INVALID) &&
++ TransactionIdIsNormal(xid))
++ {
++ /*
++ * To reset xmax without reading clog.
++ */
++ freeze = true;
++ }
+ else if (!MultiXactIdIsValid(multi))
+ {
+ /* xmax is a permanent XID or invalid MultiXactId/XID */
+@@ -7819,14 +8037,14 @@ heap_tuple_should_freeze(HeapTupleHeader tuple,
+ * caller's WAL record) by REDO routine when it replays caller's operation.
+ */
+ void
+-HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
++HeapTupleHeaderAdvanceConflictHorizon(HeapTuple tuple,
+ TransactionId *snapshotConflictHorizon)
+ {
+- TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
+- TransactionId xmax = HeapTupleHeaderGetUpdateXid(tuple);
+- TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
++ TransactionId xmin = HeapTupleGetXmin(tuple);
++ TransactionId xmax = HeapTupleGetUpdateXidAny(tuple);
++ TransactionId xvac = HeapTupleHeaderGetXvac(tuple->t_data);
+
+- if (tuple->t_infomask & HEAP_MOVED)
++ if (tuple->t_data->t_infomask & HEAP_MOVED)
+ {
+ if (TransactionIdPrecedes(*snapshotConflictHorizon, xvac))
+ *snapshotConflictHorizon = xvac;
+@@ -7838,8 +8056,8 @@ HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
+ *
+ * Look for a committed hint bit, or if no xmin bit is set, check clog.
+ */
+- if (HeapTupleHeaderXminCommitted(tuple) ||
+- (!HeapTupleHeaderXminInvalid(tuple) && TransactionIdDidCommit(xmin)))
++ if (HeapTupleHeaderXminCommitted(tuple->t_data) ||
++ (!HeapTupleHeaderXminInvalid(tuple->t_data) && TransactionIdDidCommit(xmin)))
+ {
+ if (xmax != xmin &&
+ TransactionIdFollows(xmax, *snapshotConflictHorizon))
+@@ -8187,7 +8405,7 @@ heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
+ for (;;)
+ {
+ ItemId lp;
+- HeapTupleHeader htup;
++ HeapTupleData htup;
+
+ /* Sanity check (pure paranoia) */
+ if (offnum < FirstOffsetNumber)
+@@ -8224,16 +8442,18 @@ heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
+ if (!ItemIdIsNormal(lp))
+ break;
+
+- htup = (HeapTupleHeader) PageGetItem(page, lp);
++ htup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
++ htup.t_len = ItemIdGetLength(lp);
++ HeapTupleCopyXidsFromPage(buf, &htup, page, IsToastRelation(rel));
+
+ /*
+ * Check the tuple XMIN against prior XMAX, if any
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(HeapTupleHeaderGetXmin(htup), priorXmax))
++ !TransactionIdEquals(HeapTupleGetXmin(&htup), priorXmax))
+ break;
+
+- HeapTupleHeaderAdvanceConflictHorizon(htup,
++ HeapTupleHeaderAdvanceConflictHorizon(&htup,
+ &snapshotConflictHorizon);
+
+ /*
+@@ -8242,13 +8462,13 @@ heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
+ * chain (they get their own index entries) -- just move on to
+ * next htid from index AM caller.
+ */
+- if (!HeapTupleHeaderIsHotUpdated(htup))
++ if (!HeapTupleHeaderIsHotUpdated(htup.t_data))
+ break;
+
+ /* Advance to next HOT chain member */
+- Assert(ItemPointerGetBlockNumber(&htup->t_ctid) == blkno);
+- offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ Assert(ItemPointerGetBlockNumber(&htup.t_data->t_ctid) == blkno);
++ offnum = ItemPointerGetOffsetNumber(&htup.t_data->t_ctid);
++ priorXmax = HeapTupleGetUpdateXidAny(&htup);
+ }
+
+ /* Enable further/final shrinking of deltids for caller */
+@@ -8690,6 +8910,8 @@ log_heap_update(Relation reln, Buffer oldbuf,
+ bool all_visible_cleared, bool new_all_visible_cleared)
+ {
+ xl_heap_update xlrec;
++ TransactionId xid_base,
++ multi_base;
+ xl_heap_header xlhdr;
+ xl_heap_header xlhdr_idx;
+ uint8 info;
+@@ -8798,13 +9020,13 @@ log_heap_update(Relation reln, Buffer oldbuf,
+
+ /* Prepare WAL data for the old page */
+ xlrec.old_offnum = ItemPointerGetOffsetNumber(&oldtup->t_self);
+- xlrec.old_xmax = HeapTupleHeaderGetRawXmax(oldtup->t_data);
++ xlrec.old_xmax = HeapTupleGetRawXmax(oldtup);
+ xlrec.old_infobits_set = compute_infobits(oldtup->t_data->t_infomask,
+ oldtup->t_data->t_infomask2);
+
+ /* Prepare WAL data for the new page */
+ xlrec.new_offnum = ItemPointerGetOffsetNumber(&newtup->t_self);
+- xlrec.new_xmax = HeapTupleHeaderGetRawXmax(newtup->t_data);
++ xlrec.new_xmax = HeapTupleGetRawXmax(newtup);
+
+ bufflags = REGBUF_STANDARD;
+ if (init)
+@@ -8816,6 +9038,17 @@ log_heap_update(Relation reln, Buffer oldbuf,
+ if (oldbuf != newbuf)
+ XLogRegisterBuffer(1, oldbuf, REGBUF_STANDARD);
+
++ if (info & XLOG_HEAP_INIT_PAGE)
++ {
++ HeapPageSpecial special = HeapPageGetSpecial(page);
++
++ Assert(!IsToastRelation(reln));
++ xid_base = special->pd_xid_base;
++ multi_base = special->pd_multi_base;
++ XLogRegisterData((char *) &xid_base, sizeof(xid_base));
++ XLogRegisterData((char *) &multi_base, sizeof(multi_base));
++ }
++
+ XLogRegisterData((char *) &xlrec, SizeOfHeapUpdate);
+
+ /*
+@@ -8928,8 +9161,8 @@ log_heap_new_cid(Relation relation, HeapTuple tup)
+ {
+ Assert(!(hdr->t_infomask & HEAP_XMAX_INVALID));
+ Assert(!HeapTupleHeaderXminInvalid(hdr));
+- xlrec.cmin = HeapTupleHeaderGetCmin(hdr);
+- xlrec.cmax = HeapTupleHeaderGetCmax(hdr);
++ xlrec.cmin = HeapTupleGetCmin(tup);
++ xlrec.cmax = HeapTupleGetCmax(tup);
+ xlrec.combocid = HeapTupleHeaderGetRawCommandId(hdr);
+ }
+ /* No combo CID, so only cmin or cmax can be set by this TX */
+@@ -9118,14 +9351,14 @@ HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+ case HEAPTUPLE_LIVE:
+ if (visible)
+ return;
+- xid = HeapTupleHeaderGetXmin(tuple->t_data);
++ xid = HeapTupleGetXmin(tuple);
+ break;
+ case HEAPTUPLE_RECENTLY_DEAD:
+ case HEAPTUPLE_DELETE_IN_PROGRESS:
+ if (visible)
+- xid = HeapTupleHeaderGetUpdateXid(tuple->t_data);
++ xid = HeapTupleGetUpdateXidAny(tuple);
+ else
+- xid = HeapTupleHeaderGetXmin(tuple->t_data);
++ xid = HeapTupleGetXmin(tuple);
+
+ if (TransactionIdPrecedes(xid, TransactionXmin))
+ {
+@@ -9135,7 +9368,7 @@ HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+ }
+ break;
+ case HEAPTUPLE_INSERT_IN_PROGRESS:
+- xid = HeapTupleHeaderGetXmin(tuple->t_data);
++ xid = HeapTupleGetXmin(tuple);
+ break;
+ case HEAPTUPLE_DEAD:
+ Assert(!visible);
+@@ -9173,3 +9406,511 @@ HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+
+ CheckForSerializableConflictOut(relation, xid, snapshot);
+ }
++
++static void
++xid_min_max(ShortTransactionId *min, ShortTransactionId *max,
++ ShortTransactionId xid,
++ bool *found)
++{
++ Assert(TransactionIdIsNormal(xid));
++ Assert(xid <= MaxShortTransactionId);
++
++ if (!*found)
++ {
++ *min = *max = xid;
++ *found = true;
++ }
++ else
++ {
++ *min = Min(*min, xid);
++ *max = Max(*max, xid);
++ }
++}
++
++/*
++ * Find minimum and maximum short transaction ids which occurs in the page.
++ *
++ * Works for multi and non multi transaction. Which is defined by "multi"
++ * argument.
++ */
++static bool
++heap_page_xid_min_max(Page page, bool multi,
++ ShortTransactionId *min, ShortTransactionId *max,
++ bool is_toast)
++{
++ bool found;
++ OffsetNumber offnum,
++ maxoff;
++ ItemId itemid;
++ HeapTupleHeader htup;
++
++ maxoff = PageGetMaxOffsetNumber(page);
++ found = false;
++
++ Assert(!multi || !is_toast);
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++
++ if (!multi)
++ {
++ /*
++ * For non multi transactions we should see inside the tuple for
++ * update transaction.
++ */
++ Assert(!is_toast || !(htup->t_infomask & HEAP_XMAX_IS_MULTI));
++
++ if (TransactionIdIsNormal(htup->t_choice.t_heap.t_xmin) &&
++ !HeapTupleHeaderXminFrozen(htup))
++ {
++ xid_min_max(min, max, htup->t_choice.t_heap.t_xmin, &found);
++ }
++
++ if ((htup->t_infomask & HEAP_XMAX_IS_MULTI) &&
++ (!(htup->t_infomask & HEAP_XMAX_LOCK_ONLY)))
++ {
++ TransactionId update_xid;
++ ShortTransactionId xid;
++
++ Assert(!is_toast);
++ update_xid = MultiXactIdGetUpdateXid(HeapTupleHeaderGetRawXmax(page, htup),
++ htup->t_infomask);
++ xid = NormalTransactionIdToShort(HeapPageGetSpecial(page)->pd_xid_base,
++ update_xid);
++
++ xid_min_max(min, max, xid, &found);
++ }
++ }
++
++ if (!TransactionIdIsNormal(htup->t_choice.t_heap.t_xmax))
++ continue;
++
++ if (multi != ((htup->t_infomask & HEAP_XMAX_IS_MULTI) != 0))
++ continue;
++
++ xid_min_max(min, max, htup->t_choice.t_heap.t_xmax, &found);
++ }
++
++ Assert(!found || (*min > InvalidTransactionId && *max <= MaxShortTransactionId));
++
++ return found;
++}
++
++/*
++ * Shift xid base in the page. WAL-logged if buffer is specified.
++ */
++static void
++heap_page_shift_base(Relation relation, Buffer buffer, Page page,
++ bool multi, int64 delta, bool is_toast)
++{
++ TransactionId *xid_base,
++ *multi_base;
++ OffsetNumber offnum,
++ maxoff;
++ ItemId itemid;
++ HeapTupleHeader htup;
++
++ Assert(IsBufferLockedExclusive(buffer));
++
++ START_CRIT_SECTION();
++
++ if (is_toast)
++ {
++ Assert(!multi);
++ xid_base = &ToastPageGetSpecial(page)->pd_xid_base;
++ multi_base = NULL;
++ }
++ else
++ {
++ HeapPageSpecial special = HeapPageGetSpecial(page);
++
++ xid_base = &special->pd_xid_base;
++ multi_base = &special->pd_multi_base;
++ }
++
++ /* Iterate over page items */
++ maxoff = PageGetMaxOffsetNumber(page);
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++
++ /* Apply xid shift to heap tuple */
++ if (!multi)
++ {
++ /* shift xmin */
++ if (TransactionIdIsNormal(htup->t_choice.t_heap.t_xmin) &&
++ !HeapTupleHeaderXminFrozen(htup))
++ {
++ Assert(htup->t_choice.t_heap.t_xmin - delta >= FirstNormalTransactionId);
++ Assert(htup->t_choice.t_heap.t_xmin - delta <= MaxShortTransactionId);
++ htup->t_choice.t_heap.t_xmin -= delta;
++ }
++ }
++
++ /* shift xmax */
++ if (!TransactionIdIsNormal(htup->t_choice.t_heap.t_xmax))
++ continue;
++
++ if (multi != (bool) (htup->t_infomask & HEAP_XMAX_IS_MULTI))
++ continue;
++
++ Assert(htup->t_choice.t_heap.t_xmax - delta >= FirstNormalTransactionId);
++ Assert(htup->t_choice.t_heap.t_xmax - delta <= MaxShortTransactionId);
++ htup->t_choice.t_heap.t_xmax -= delta;
++ }
++
++ /* Apply xid shift to base as well */
++ if (!multi)
++ *xid_base += delta;
++ else
++ *multi_base += delta;
++
++ if (BufferIsValid(buffer))
++ MarkBufferDirty(buffer);
++
++ /* Write WAL record if needed */
++ if (relation && RelationNeedsWAL(relation) && maxoff != 0)
++ {
++ XLogRecPtr recptr;
++ xl_heap_base_shift xlrec;
++
++ xlrec.delta = delta;
++ xlrec.multi = multi;
++ xlrec.flags = 0;
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLH_BASE_SHIFT_ON_TOAST_RELATION;
++
++ XLogBeginInsert();
++ XLogRegisterData((char *) &xlrec, SizeOfHeapBaseShift);
++ XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
++
++ recptr = XLogInsert(RM_HEAP3_ID, XLOG_HEAP3_BASE_SHIFT);
++
++ PageSetLSN(page, recptr);
++ }
++
++ END_CRIT_SECTION();
++}
++
++/*
++ * Freeze xids in the single heap page. Useful when we can't fit new xid even
++ * with base shift.
++ */
++static void
++freeze_single_heap_page(Relation relation, Buffer buffer)
++{
++ OffsetNumber offnum;
++ GlobalVisState *vistest;
++ VacuumParams params = {0};
++ struct VacuumCutoffs cutoffs = {0};
++ TransactionId new_relfrozen_xid;
++ MultiXactId new_relmin_mxid;
++ PruneFreezeResult presult;
++
++ vacuum_get_cutoffs(relation, ¶ms, &cutoffs);
++ new_relfrozen_xid = cutoffs.FreezeLimit;
++ new_relmin_mxid = cutoffs.MultiXactCutoff;
++
++ vistest = GlobalVisTestFor(relation);
++ heap_page_prune_and_freeze(relation, buffer, vistest, HEAP_PAGE_PRUNE_FREEZE,
++ NULL, &presult, PRUNE_ON_ACCESS, &offnum, &new_relfrozen_xid, &new_relmin_mxid, false);
++
++ if (presult.ndeleted > presult.nnewlpdead)
++ pgstat_update_heap_dead_tuples(relation,
++ presult.ndeleted - presult.nnewlpdead);
++}
++
++/*
++ * Check if xid still fits on a page with given base and delta.
++ */
++static inline bool
++is_delta_fits_heap_page(TransactionId xid, TransactionId base, int64 delta)
++{
++ return xid >= base + delta + FirstNormalTransactionId &&
++ xid <= base + delta + MaxShortTransactionId;
++}
++
++/*
++ * Check if xid fits on a page with given base.
++ */
++static inline bool
++is_xid_fits_heap_page(TransactionId xid, TransactionId base)
++{
++ return xid >= base + FirstNormalTransactionId &&
++ xid <= base + MaxShortTransactionId;
++}
++
++/*
++ * Check if delta fits on a page.
++ *
++ * If delta does not fits, never return.
++ */
++static void
++heap_page_check_delta(Buffer buffer,
++ TransactionId xid, TransactionId base,
++ ShortTransactionId min, ShortTransactionId max,
++ int64 delta, int64 *freeDelta, int64 *requiredDelta)
++{
++ BufferDesc *buf;
++ char *path;
++ ProcNumber backend;
++
++ Assert((freeDelta == NULL) == (requiredDelta == NULL));
++
++ /*
++ * If delta fits the page, we good to go ...
++ */
++ if (is_delta_fits_heap_page(xid, base, delta))
++ return;
++
++ /*
++ * ... otherwise handle the error.
++ */
++ if (buffer == InvalidBuffer)
++ return;
++
++ if (BufferIsLocal(buffer))
++ {
++ buf = GetLocalBufferDescriptor(-buffer - 1);
++ backend = MyProcNumber;
++ }
++ else
++ {
++ buf = GetBufferDescriptor(buffer - 1);
++ backend = INVALID_PROC_NUMBER;
++ }
++
++ path = relpathbackend(BufTagGetRelFileLocator(&buf->tag), backend,
++ buf->tag.forkNum);
++
++ if (freeDelta == NULL)
++ elog(FATAL, "Fatal xid base calculation error: xid = %llu, base = %llu, min = %u, max = %u, delta = %lld (rel=%s, blockNum=%u)",
++ (unsigned long long) xid, (unsigned long long) base,
++ min, max,
++ (long long) delta,
++ path, buf->tag.blockNum);
++
++ elog(FATAL, "Fatal xid base calculation error: xid = %llu, base = %llu, min = %u, max = %u, freeDelta = %lld, requiredDelta = %lld, delta = %lld (rel=%s, blockNum=%u)",
++ (unsigned long long) xid, (unsigned long long) base,
++ min, max,
++ (long long) *freeDelta, (long long) *requiredDelta,
++ (long long) delta,
++ path, buf->tag.blockNum);
++}
++
++/*
++ * Shift page base.
++ */
++static void
++heap_page_apply_delta(Relation relation, Buffer buffer, Page page,
++ TransactionId xid, bool multi,
++ TransactionId base, int64 delta, bool is_toast)
++{
++ Assert(is_delta_fits_heap_page(xid, base, delta));
++
++ heap_page_shift_base(relation, buffer, page, multi, delta, is_toast);
++
++#ifdef USE_ASSERT_CHECKING
++ if (is_toast)
++ {
++ Assert(!multi);
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ }
++ else
++ base = multi ? HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ Assert(is_xid_fits_heap_page(xid, base));
++#endif /* USE_ASSERT_CHECKING */
++}
++
++/*
++ * Try to fit xid on a page.
++ */
++static int
++heap_page_try_prepare_for_xid(Relation relation, Buffer buffer, Page page,
++ TransactionId xid, bool multi, bool is_toast)
++{
++ TransactionId base;
++ ShortTransactionId min = InvalidTransactionId,
++ max = InvalidTransactionId;
++ int64 delta,
++ freeDelta,
++ requiredDelta;
++
++ if (is_toast)
++ {
++ Assert(!multi);
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ }
++ else
++ base = multi ? HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ /* If xid fits the page no action needed. */
++ if (is_xid_fits_heap_page(xid, base))
++ return 0;
++
++ /* No items on the page? */
++ if (!heap_page_xid_min_max(page, multi, &min, &max, is_toast))
++ {
++ delta = (int64) (xid - FirstNormalTransactionId) - (int64) base;
++ heap_page_check_delta(buffer, xid, base, min, max, delta, NULL, NULL);
++ heap_page_apply_delta(relation, buffer, page, xid, multi, base, delta,
++ is_toast);
++ return 0;
++ }
++
++ /* Can we just shift base on the page? */
++ if (xid < base + FirstNormalTransactionId)
++ {
++ freeDelta = MaxShortTransactionId - max;
++ requiredDelta = (base + FirstNormalTransactionId) - xid;
++ /* Shouldn't consider setting base less than 0 */
++ freeDelta = Min(freeDelta, base);
++
++ if (requiredDelta > freeDelta)
++ return -1;
++
++ delta = -(freeDelta + requiredDelta) / 2;
++ }
++ else
++ {
++ freeDelta = min - FirstNormalTransactionId;
++ requiredDelta = xid - (base + MaxShortTransactionId);
++
++ if (requiredDelta > freeDelta)
++ return -1;
++
++ delta = (freeDelta + requiredDelta) / 2;
++ }
++
++ heap_page_check_delta(buffer, xid, base, min, max,
++ delta, &freeDelta, &requiredDelta);
++ heap_page_apply_delta(relation, buffer, page, xid, multi, base,
++ delta, is_toast);
++
++ return 0;
++}
++
++static void
++heap_xlog_base_shift(XLogReaderState *record)
++{
++ XLogRecPtr lsn = record->EndRecPtr;
++ xl_heap_base_shift *xlrec = (xl_heap_base_shift *) XLogRecGetData(record);
++ Buffer buffer;
++ Page page;
++ BlockNumber blkno;
++ RelFileLocator target_node;
++
++ XLogRecGetBlockTag(record, 0, &target_node, NULL, &blkno);
++
++ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
++ {
++ page = BufferGetPage(buffer);
++ heap_page_shift_base(NULL, InvalidBuffer, page, xlrec->multi,
++ xlrec->delta,
++ xlrec->flags & XLH_BASE_SHIFT_ON_TOAST_RELATION);
++ PageSetLSN(page, lsn);
++ MarkBufferDirty(buffer);
++ }
++
++ if (BufferIsValid(buffer))
++ UnlockReleaseBuffer(buffer);
++}
++
++/*
++ * Ensure that given xid fits base of given page.
++ */
++static bool
++heap_page_prepare_for_xid(Relation relation, Buffer buffer,
++ TransactionId xid, bool multi)
++{
++ Page page = BufferGetPage(buffer);
++ int res;
++
++ /* "Double xmax" page format doesn't require any preparation */
++ if (HeapPageIsDoubleXmax(page))
++ return false;
++
++ if (!TransactionIdIsNormal(xid))
++ return false;
++
++ res = heap_page_try_prepare_for_xid(relation, buffer, page, xid, multi,
++ IsToastRelation(relation));
++ if (res != -1)
++ return res == 1;
++
++ /* Have to try freeing the page... */
++ freeze_single_heap_page(relation, buffer);
++
++ res = heap_page_try_prepare_for_xid(relation, buffer, page, xid, multi,
++ IsToastRelation(relation));
++ if (res != -1)
++ return res == 1;
++
++ elog(ERROR, "could not fit xid into page");
++
++ return false;
++}
++
++/*
++ * Ensure that given xid fits base of given page.
++ */
++void
++rewrite_page_prepare_for_xid(Page page, HeapTuple tup, bool is_toast)
++{
++ TransactionId xid;
++ int res;
++
++ /* xmin */
++ xid = HeapTupleGetXmin(tup);
++ if (TransactionIdIsNormal(xid))
++ {
++ res = heap_page_try_prepare_for_xid(NULL, InvalidBuffer, page, xid,
++ false, is_toast);
++ if (res == -1)
++ elog(ERROR, "could not fit xid into page");
++ }
++
++ /* xmax */
++ xid = HeapTupleGetRawXmax(tup);
++ if (TransactionIdIsNormal(xid))
++ {
++ res = heap_page_try_prepare_for_xid(NULL, InvalidBuffer, page, xid,
++ tup->t_data->t_infomask & HEAP_XMAX_IS_MULTI,
++ is_toast);
++ if (res == -1)
++ elog(ERROR, "could not fit xid into page");
++ }
++}
++
++void
++heap3_redo(XLogReaderState *record)
++{
++ uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
++
++ switch (info & XLOG_HEAP_OPMASK)
++ {
++ case XLOG_HEAP3_BASE_SHIFT:
++ heap_xlog_base_shift(record);
++ break;
++ default:
++ elog(PANIC, "heap3_redo: unknown op code %u", info);
++ }
++}
+diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
+index 765e0d48c42..8de5dfa4fc6 100644
+--- a/src/backend/access/heap/heapam_handler.c
++++ b/src/backend/access/heap/heapam_handler.c
+@@ -423,7 +423,7 @@ tuple_lock_retry:
+ * changes in an existing tuple, except to invalid or
+ * frozen, and neither of those can match priorXmax.)
+ */
+- if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
++ if (!TransactionIdEquals(HeapTupleGetXmin(tuple),
+ priorXmax))
+ {
+ ReleaseBuffer(buffer);
+@@ -483,7 +483,7 @@ tuple_lock_retry:
+ * variable instead of doing HeapTupleHeaderGetXmin again.
+ */
+ if (TransactionIdIsCurrentTransactionId(priorXmax) &&
+- HeapTupleHeaderGetCmin(tuple->t_data) >= cid)
++ HeapTupleGetCmin(tuple) >= cid)
+ {
+ tmfd->xmax = priorXmax;
+
+@@ -491,7 +491,7 @@ tuple_lock_retry:
+ * Cmin is the problematic value, so store that. See
+ * above.
+ */
+- tmfd->cmax = HeapTupleHeaderGetCmin(tuple->t_data);
++ tmfd->cmax = HeapTupleGetCmin(tuple);
+ ReleaseBuffer(buffer);
+ return TM_SelfModified;
+ }
+@@ -517,7 +517,7 @@ tuple_lock_retry:
+ /*
+ * As above, if xmin isn't what we're expecting, do nothing.
+ */
+- if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
++ if (!TransactionIdEquals(HeapTupleGetXmin(tuple),
+ priorXmax))
+ {
+ ReleaseBuffer(buffer);
+@@ -548,7 +548,7 @@ tuple_lock_retry:
+ /* updated, so look at the updated row */
+ *tid = tuple->t_data->t_ctid;
+ /* updated row should have xmin matching this xmax */
+- priorXmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
++ priorXmax = HeapTupleGetUpdateXidAny(tuple);
+ ReleaseBuffer(buffer);
+ /* loop back to fetch next in chain */
+ }
+@@ -859,7 +859,7 @@ heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap,
+ * case we had better copy it.
+ */
+ if (!is_system_catalog &&
+- !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tuple->t_data)))
++ !TransactionIdIsCurrentTransactionId(HeapTupleGetXmin(tuple)))
+ elog(WARNING, "concurrent insert in progress within table \"%s\"",
+ RelationGetRelationName(OldHeap));
+ /* treat as live */
+@@ -871,7 +871,7 @@ heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap,
+ * Similar situation to INSERT_IN_PROGRESS case.
+ */
+ if (!is_system_catalog &&
+- !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple->t_data)))
++ !TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(tuple)))
+ elog(WARNING, "concurrent delete in progress within table \"%s\"",
+ RelationGetRelationName(OldHeap));
+ /* treat as recently dead */
+@@ -1064,6 +1064,8 @@ heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin,
+ targtuple->t_tableOid = RelationGetRelid(scan->rs_rd);
+ targtuple->t_data = (HeapTupleHeader) PageGetItem(targpage, itemid);
+ targtuple->t_len = ItemIdGetLength(itemid);
++ HeapTupleCopyXidsFromPage(hscan->rs_cbuf, targtuple, targpage,
++ IsToastRelation(scan->rs_rd));
+
+ switch (HeapTupleSatisfiesVacuum(targtuple, OldestXmin,
+ hscan->rs_cbuf))
+@@ -1099,7 +1101,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin,
+ * numbers we report to the cumulative stats system to make
+ * this come out right.)
+ */
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(targtuple->t_data)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetXmin(targtuple)))
+ {
+ sample_it = true;
+ *liverows += 1;
+@@ -1130,7 +1132,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin,
+ * but not the post-image. We also get sane results if the
+ * concurrent transaction never commits.
+ */
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(targtuple->t_data)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(targtuple)))
+ *deadrows += 1;
+ else
+ {
+@@ -1379,7 +1381,8 @@ heapam_index_build_range_scan(Relation heapRelation,
+ Page page = BufferGetPage(hscan->rs_cbuf);
+
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
+- heap_get_root_tuples(page, root_offsets);
++ heap_get_root_tuples(heapRelation, hscan->rs_cbuf, page,
++ root_offsets);
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+
+ root_blkno = hscan->rs_cblock;
+@@ -1472,7 +1475,7 @@ heapam_index_build_range_scan(Relation heapRelation,
+ * before commit there. Give a warning if neither case
+ * applies.
+ */
+- xwait = HeapTupleHeaderGetXmin(heapTuple->t_data);
++ xwait = HeapTupleGetXmin(heapTuple);
+ if (!TransactionIdIsCurrentTransactionId(xwait))
+ {
+ if (!is_system_catalog)
+@@ -1531,7 +1534,7 @@ heapam_index_build_range_scan(Relation heapRelation,
+ break;
+ }
+
+- xwait = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
++ xwait = HeapTupleGetUpdateXidAny(heapTuple);
+ if (!TransactionIdIsCurrentTransactionId(xwait))
+ {
+ if (!is_system_catalog)
+@@ -1676,7 +1679,8 @@ heapam_index_build_range_scan(Relation heapRelation,
+ Page page = BufferGetPage(hscan->rs_cbuf);
+
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
+- heap_get_root_tuples(page, root_offsets);
++ heap_get_root_tuples(heapRelation, hscan->rs_cbuf, page,
++ root_offsets);
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+ }
+
+@@ -1842,7 +1846,8 @@ heapam_index_validate_scan(Relation heapRelation,
+ Page page = BufferGetPage(hscan->rs_cbuf);
+
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
+- heap_get_root_tuples(page, root_offsets);
++ heap_get_root_tuples(heapRelation, hscan->rs_cbuf, page,
++ root_offsets);
+ LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+
+ memset(in_index, 0, sizeof(in_index));
+@@ -2223,7 +2228,12 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
+ ItemPointerSet(&tid, block, offnum);
+ if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot,
+ &heapTuple, NULL, true))
+- hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
++ {
++ hscan->rs_vistuples[ntup] = ItemPointerGetOffsetNumber(&tid);
++ hscan->rs_xmin[ntup] = heapTuple.t_xmin;
++ hscan->rs_xmax[ntup] = heapTuple.t_xmax;
++ ++ntup;
++ }
+ }
+ }
+ else
+@@ -2248,13 +2258,18 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
+ loctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ loctup.t_len = ItemIdGetLength(lp);
+ loctup.t_tableOid = scan->rs_rd->rd_id;
++ HeapTupleCopyXidsFromPage(hscan->rs_cbuf, &loctup, page,
++ IsToastRelation(scan->rs_rd));
+ ItemPointerSet(&loctup.t_self, block, offnum);
+ valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
+ if (valid)
+ {
+- hscan->rs_vistuples[ntup++] = offnum;
++ hscan->rs_vistuples[ntup] = offnum;
++ hscan->rs_xmin[ntup] = loctup.t_xmin;
++ hscan->rs_xmax[ntup] = loctup.t_xmax;
++ ++ntup;
+ PredicateLockTID(scan->rs_rd, &loctup.t_self, snapshot,
+- HeapTupleHeaderGetXmin(loctup.t_data));
++ HeapTupleGetXmin(&loctup));
+ }
+ HeapCheckForSerializableConflictOut(valid, scan->rs_rd, &loctup,
+ buffer, snapshot);
+@@ -2314,6 +2329,8 @@ heapam_scan_bitmap_next_tuple(TableScanDesc scan,
+ hscan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ hscan->rs_ctup.t_len = ItemIdGetLength(lp);
+ hscan->rs_ctup.t_tableOid = scan->rs_rd->rd_id;
++ hscan->rs_ctup.t_xmin = hscan->rs_xmin[hscan->rs_cindex];
++ hscan->rs_ctup.t_xmax = hscan->rs_xmax[hscan->rs_cindex];
+ ItemPointerSet(&hscan->rs_ctup.t_self, hscan->rs_cblock, targoffset);
+
+ pgstat_count_heap_fetch(scan->rs_rd);
+@@ -2470,8 +2487,17 @@ heapam_scan_sample_next_tuple(TableScanDesc scan, SampleScanState *scanstate,
+
+ tuple->t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple->t_len = ItemIdGetLength(itemid);
+- ItemPointerSet(&(tuple->t_self), blockno, tupoffset);
+
++ if (pagemode)
++ {
++ tuple->t_xmin = InvalidTransactionId;
++ tuple->t_xmax = InvalidTransactionId;
++ }
++ else
++ HeapTupleCopyXidsFromPage(hscan->rs_cbuf, tuple, page,
++ IsToastRelation(scan->rs_rd));
++
++ ItemPointerSet(&(tuple->t_self), blockno, tupoffset);
+
+ if (all_visible)
+ visible = true;
+diff --git a/src/backend/access/heap/heapam_visibility.c b/src/backend/access/heap/heapam_visibility.c
+index 9243feed01f..23ad2665fe5 100644
+--- a/src/backend/access/heap/heapam_visibility.c
++++ b/src/backend/access/heap/heapam_visibility.c
+@@ -218,7 +218,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return true;
+@@ -230,7 +230,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -242,7 +242,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ return false;
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -252,11 +252,11 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+
+ return false;
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ return false;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -285,7 +285,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -300,17 +300,17 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ return true;
+ }
+
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+ return false;
+ }
+
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return true;
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -328,7 +328,7 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
+ }
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ return false;
+ }
+
+@@ -417,7 +417,7 @@ HeapTupleSatisfiesToast(HeapTuple htup, Snapshot snapshot,
+ * is canceled by super-deleting the tuple. This also applies to
+ * TOAST tuples created during speculative insertion.
+ */
+- else if (!TransactionIdIsValid(HeapTupleHeaderGetXmin(tuple)))
++ else if (!TransactionIdIsValid(HeapTupleGetXmin(htup)))
+ return false;
+ }
+
+@@ -507,9 +507,9 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+- if (HeapTupleHeaderGetCmin(tuple) >= curcid)
++ if (HeapTupleGetCmin(htup) >= curcid)
+ return TM_Invisible; /* inserted after scan started */
+
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+@@ -519,7 +519,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleHeaderGetRawXmax(tuple);
++ xmax = HeapTupleGetRawXmax(htup);
+
+ /*
+ * Careful here: even though this tuple was created by our own
+@@ -550,7 +550,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -558,21 +558,21 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ /* deleting subtransaction must have aborted */
+ if (!TransactionIdIsCurrentTransactionId(xmax))
+ {
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple),
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup),
+ false))
+ return TM_BeingModified;
+ return TM_Ok;
+ }
+ else
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -580,16 +580,16 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ return TM_Ok;
+ }
+
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ return TM_Invisible;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -623,17 +623,17 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ {
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), true))
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), true))
+ return TM_BeingModified;
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
+ return TM_Ok;
+ }
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+ if (!TransactionIdIsValid(xmax))
+ {
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ return TM_BeingModified;
+ }
+
+@@ -642,13 +642,13 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+
+ if (TransactionIdIsCurrentTransactionId(xmax))
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+
+- if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ if (MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ return TM_BeingModified;
+
+ if (TransactionIdDidCommit(xmax))
+@@ -664,7 +664,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ * what about the other members?
+ */
+
+- if (!MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ if (!MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ {
+ /*
+ * There's no member, even just a locker, alive anymore, so we can
+@@ -681,20 +681,20 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ }
+ }
+
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return TM_BeingModified;
+- if (HeapTupleHeaderGetCmax(tuple) >= curcid)
++ if (HeapTupleGetCmax(htup) >= curcid)
+ return TM_SelfModified; /* updated after scan started */
+ else
+ return TM_Invisible; /* updated before scan started */
+ }
+
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return TM_BeingModified;
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -712,7 +712,7 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
+ }
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ if (!ItemPointerEquals(&htup->t_self, &tuple->t_ctid))
+ return TM_Updated; /* updated by other */
+ else
+@@ -795,7 +795,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return true;
+@@ -807,7 +807,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -819,7 +819,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ return false;
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -829,7 +829,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+
+ return false;
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ {
+ /*
+ * Return the speculative token to caller. Caller can worry about
+@@ -845,13 +845,13 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ Assert(snapshot->speculativeToken != 0);
+ }
+
+- snapshot->xmin = HeapTupleHeaderGetRawXmin(tuple);
++ snapshot->xmin = HeapTupleGetRawXmin(htup);
+ /* XXX shouldn't we fall through to look at xmax? */
+ return true; /* in insertion by other */
+ }
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -880,7 +880,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -898,21 +898,21 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ return true;
+ }
+
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+ return true;
+ return false;
+ }
+
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ {
+ if (!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
+- snapshot->xmax = HeapTupleHeaderGetRawXmax(tuple);
++ snapshot->xmax = HeapTupleGetRawXmax(htup);
+ return true;
+ }
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -930,7 +930,7 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
+ }
+
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ return false; /* updated by other */
+ }
+
+@@ -1009,9 +1009,9 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ }
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+- if (HeapTupleHeaderGetCmin(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmin(htup) >= snapshot->curcid)
+ return false; /* inserted after scan started */
+
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+@@ -1024,7 +1024,7 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ {
+ TransactionId xmax;
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -1032,13 +1032,13 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ /* updating subtransaction must have aborted */
+ if (!TransactionIdIsCurrentTransactionId(xmax))
+ return true;
+- else if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ else if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* updated after scan started */
+ else
+ return false; /* updated before scan started */
+ }
+
+- if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+ /* deleting subtransaction must have aborted */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -1046,16 +1046,16 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ return true;
+ }
+
+- if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* deleted after scan started */
+ else
+ return false; /* deleted before scan started */
+ }
+- else if (XidInMVCCSnapshot(HeapTupleHeaderGetRawXmin(tuple), snapshot))
++ else if (XidInMVCCSnapshot(HeapTupleGetRawXmin(htup), snapshot))
+ return false;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /* it must have aborted or crashed */
+@@ -1068,7 +1068,7 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ {
+ /* xmin is committed, but maybe not according to our snapshot */
+ if (!HeapTupleHeaderXminFrozen(tuple) &&
+- XidInMVCCSnapshot(HeapTupleHeaderGetRawXmin(tuple), snapshot))
++ XidInMVCCSnapshot(HeapTupleGetRawXmin(htup), snapshot))
+ return false; /* treat as still in progress */
+ }
+
+@@ -1087,14 +1087,14 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+ /* already checked above */
+ Assert(!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask));
+
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+
+ if (TransactionIdIsCurrentTransactionId(xmax))
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* deleted after scan started */
+ else
+ return false; /* deleted before scan started */
+@@ -1109,18 +1109,18 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+
+ if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
+ {
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmax(htup)))
+ {
+- if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
++ if (HeapTupleGetCmax(htup) >= snapshot->curcid)
+ return true; /* deleted after scan started */
+ else
+ return false; /* deleted before scan started */
+ }
+
+- if (XidInMVCCSnapshot(HeapTupleHeaderGetRawXmax(tuple), snapshot))
++ if (XidInMVCCSnapshot(HeapTupleGetRawXmax(htup), snapshot))
+ return true;
+
+- if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ {
+ /* it must have aborted or crashed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+@@ -1130,12 +1130,12 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
+
+ /* xmax transaction committed */
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ }
+ else
+ {
+ /* xmax is committed, but maybe not according to our snapshot */
+- if (XidInMVCCSnapshot(HeapTupleHeaderGetRawXmax(tuple), snapshot))
++ if (XidInMVCCSnapshot(HeapTupleGetRawXmax(htup), snapshot))
+ return true; /* treat as still in progress */
+ }
+
+@@ -1250,21 +1250,21 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ return HEAPTUPLE_DEAD;
+ }
+ }
+- else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(htup)))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ /* only locked? run infomask-only check first, for performance */
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask) ||
+- HeapTupleHeaderIsOnlyLocked(tuple))
++ HeapTupleIsOnlyLocked(htup))
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ /* inserted and then deleted by same xact */
+- if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple)))
++ if (TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(htup)))
+ return HEAPTUPLE_DELETE_IN_PROGRESS;
+ /* deleting subtransaction must have aborted */
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ }
+- else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdIsInProgress(HeapTupleGetRawXmin(htup)))
+ {
+ /*
+ * It'd be possible to discern between INSERT/DELETE in progress
+@@ -1276,9 +1276,9 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ */
+ return HEAPTUPLE_INSERT_IN_PROGRESS;
+ }
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmin(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
+- HeapTupleHeaderGetRawXmin(tuple));
++ HeapTupleGetRawXmin(htup));
+ else
+ {
+ /*
+@@ -1320,14 +1320,14 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ * possibly be running; otherwise have to check.
+ */
+ if (!HEAP_LOCKED_UPGRADED(tuple->t_infomask) &&
+- MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple),
++ MultiXactIdIsRunning(HeapTupleGetRawXmax(htup),
+ true))
+ return HEAPTUPLE_LIVE;
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
+ }
+ else
+ {
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return HEAPTUPLE_LIVE;
+ SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
+ InvalidTransactionId);
+@@ -1345,7 +1345,7 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+
+ if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
+ {
+- TransactionId xmax = HeapTupleGetUpdateXid(tuple);
++ TransactionId xmax = HeapTupleGetUpdateXid(htup);
+
+ /* already checked above */
+ Assert(!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask));
+@@ -1368,7 +1368,7 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ *dead_after = xmax;
+ return HEAPTUPLE_RECENTLY_DEAD;
+ }
+- else if (!MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
++ else if (!MultiXactIdIsRunning(HeapTupleGetRawXmax(htup), false))
+ {
+ /*
+ * Not in Progress, Not Committed, so either Aborted or crashed.
+@@ -1382,11 +1382,11 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+
+ if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
+ {
+- if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
++ if (TransactionIdIsInProgress(HeapTupleGetRawXmax(htup)))
+ return HEAPTUPLE_DELETE_IN_PROGRESS;
+- else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
++ else if (TransactionIdDidCommit(HeapTupleGetRawXmax(htup)))
+ SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ else
+ {
+ /*
+@@ -1408,7 +1408,7 @@ HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *de
+ * Deleter committed, allow caller to check if it was recent enough that
+ * some open transactions could still see the tuple.
+ */
+- *dead_after = HeapTupleHeaderGetRawXmax(tuple);
++ *dead_after = HeapTupleGetRawXmax(htup);
+ return HEAPTUPLE_RECENTLY_DEAD;
+ }
+
+@@ -1504,7 +1504,7 @@ HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
+
+ /* Deleter committed, so tuple is dead if the XID is old enough. */
+ return GlobalVisTestIsRemovableXid(vistest,
+- HeapTupleHeaderGetRawXmax(tuple));
++ HeapTupleGetRawXmax(htup));
+ }
+
+ /*
+@@ -1517,8 +1517,9 @@ HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
+ * at the top of this file.
+ */
+ bool
+-HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
++HeapTupleIsOnlyLocked(HeapTuple htup)
+ {
++ HeapTupleHeader tuple = htup->t_data;
+ TransactionId xmax;
+
+ /* if there's no valid Xmax, then there's obviously no update either */
+@@ -1529,7 +1530,7 @@ HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
+ return true;
+
+ /* invalid xmax means no update */
+- if (!TransactionIdIsValid(HeapTupleHeaderGetRawXmax(tuple)))
++ if (!TransactionIdIsValid(HeapTupleGetRawXmax(htup)))
+ return true;
+
+ /*
+@@ -1540,7 +1541,7 @@ HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
+ return false;
+
+ /* ... but if it's a multi, then perhaps the updating Xid aborted. */
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+
+ /* not LOCKED_ONLY, so it has to have an xmax */
+ Assert(TransactionIdIsValid(xmax));
+@@ -1588,8 +1589,8 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
+ Buffer buffer)
+ {
+ HeapTupleHeader tuple = htup->t_data;
+- TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
+- TransactionId xmax = HeapTupleHeaderGetRawXmax(tuple);
++ TransactionId xmin = HeapTupleGetXmin(htup);
++ TransactionId xmax = HeapTupleGetRawXmax(htup);
+
+ Assert(ItemPointerIsValid(&htup->t_self));
+ Assert(htup->t_tableOid != InvalidOid);
+@@ -1689,7 +1690,7 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
+ */
+ else if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
+ {
+- xmax = HeapTupleGetUpdateXid(tuple);
++ xmax = HeapTupleGetUpdateXid(htup);
+ }
+
+ /* check if it's one of our txids, toplevel is also in there */
+diff --git a/src/backend/access/heap/heapam_xlog.c b/src/backend/access/heap/heapam_xlog.c
+index c5208f3df61..b1ace89bfc6 100644
+--- a/src/backend/access/heap/heapam_xlog.c
++++ b/src/backend/access/heap/heapam_xlog.c
+@@ -106,7 +106,10 @@ heap_xlog_prune_freeze(XLogReaderState *record)
+ (xlrec.flags & XLHP_CLEANUP_LOCK) == 0,
+ redirected, nredirected,
+ nowdead, ndead,
+- nowunused, nunused);
++ nowunused, nunused,
++ (xlrec.flags & XLHP_REPAIR_FRAGMENTATION) != 0,
++ (xlrec.flags & XLHP_ON_TOAST_RELATION) != 0);
++
+
+ /* Freeze tuples */
+ for (int p = 0; p < nplans; p++)
+@@ -127,11 +130,14 @@ heap_xlog_prune_freeze(XLogReaderState *record)
+ {
+ OffsetNumber offset = *(frz_offsets++);
+ ItemId lp;
+- HeapTupleHeader tuple;
++ HeapTupleData tp;
+
+ lp = PageGetItemId(page, offset);
+- tuple = (HeapTupleHeader) PageGetItem(page, lp);
+- heap_execute_freeze_tuple(tuple, &frz);
++ tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
++ tp.t_len = ItemIdGetLength(lp);
++ HeapTupleCopyXidsFromPage(buffer, &tp, page,
++ (xlrec.flags & XLHP_ON_TOAST_RELATION) != 0);
++ heap_execute_freeze_tuple(&tp, &frz);
+ }
+ }
+
+@@ -371,6 +377,8 @@ heap_xlog_delete(XLogReaderState *record)
+
+ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = BufferGetPage(buffer);
+
+ if (PageGetMaxOffsetNumber(page) >= xlrec->offnum)
+@@ -386,14 +394,19 @@ heap_xlog_delete(XLogReaderState *record)
+ HeapTupleHeaderClearHotUpdated(htup);
+ fix_infomask_from_infobits(xlrec->infobits_set,
+ &htup->t_infomask, &htup->t_infomask2);
++ tuple.t_data = htup;
+ if (!(xlrec->flags & XLH_DELETE_IS_SUPER))
+- HeapTupleHeaderSetXmax(htup, xlrec->xmax);
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->xmax,
++ (xlrec->flags & XLH_DELETE_PAGE_ON_TOAST_RELATION) != 0);
+ else
+- HeapTupleHeaderSetXmin(htup, InvalidTransactionId);
++ HeapTupleAndHeaderSetXmin(page, &tuple, InvalidTransactionId,
++ (xlrec->flags & XLH_DELETE_PAGE_ON_TOAST_RELATION) != 0);
++
+ HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
+
+ /* Mark the page as a candidate for pruning */
+- PageSetPrunable(page, XLogRecGetXid(record));
++ PageSetPrunable(page, XLogRecGetXid(record),
++ (xlrec->flags & XLH_DELETE_PAGE_ON_TOAST_RELATION) != 0);
+
+ if (xlrec->flags & XLH_DELETE_ALL_VISIBLE_CLEARED)
+ PageClearAllVisible(page);
+@@ -417,7 +430,7 @@ static void
+ heap_xlog_insert(XLogReaderState *record)
+ {
+ XLogRecPtr lsn = record->EndRecPtr;
+- xl_heap_insert *xlrec = (xl_heap_insert *) XLogRecGetData(record);
++ xl_heap_insert *xlrec;
+ Buffer buffer;
+ Page page;
+ union
+@@ -433,6 +446,20 @@ heap_xlog_insert(XLogReaderState *record)
+ BlockNumber blkno;
+ ItemPointerData target_tid;
+ XLogRedoAction action;
++ bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(record);
++ TransactionId xid_base = InvalidTransactionId;
++ TransactionId multi_base = InvalidTransactionId;
++
++ if (isinit)
++ {
++ xid_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ multi_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ }
++
++ xlrec = (xl_heap_insert *) rec_data;
+
+ XLogRecGetBlockTag(record, 0, &target_locator, NULL, &blkno);
+ ItemPointerSetBlockNumber(&target_tid, blkno);
+@@ -457,11 +484,28 @@ heap_xlog_insert(XLogReaderState *record)
+ * If we inserted the first and only tuple on the page, re-initialize the
+ * page from scratch.
+ */
+- if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
++ if (isinit)
+ {
+ buffer = XLogInitBufferForRedo(record, 0);
+ page = BufferGetPage(buffer);
+- PageInit(page, BufferGetPageSize(buffer), 0);
++
++ if (xlrec->flags & XLH_INSERT_ON_TOAST_RELATION)
++ {
++ PageInit(page, BufferGetPageSize(buffer),
++ sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ PageInit(page, BufferGetPageSize(buffer),
++ sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
++ }
++
+ action = BLK_NEEDS_REDO;
+ }
+ else
+@@ -470,6 +514,7 @@ heap_xlog_insert(XLogReaderState *record)
+ {
+ Size datalen;
+ char *data;
++ HeapTupleData tuple;
+
+ page = BufferGetPage(buffer);
+
+@@ -493,7 +538,9 @@ heap_xlog_insert(XLogReaderState *record)
+ htup->t_infomask2 = xlhdr.t_infomask2;
+ htup->t_infomask = xlhdr.t_infomask;
+ htup->t_hoff = xlhdr.t_hoff;
+- HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmin(page, &tuple, XLogRecGetXid(record),
++ (xlrec->flags & XLH_INSERT_ON_TOAST_RELATION) != 0);
+ HeapTupleHeaderSetCmin(htup, FirstCommandId);
+ htup->t_ctid = target_tid;
+
+@@ -553,12 +600,22 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ int i;
+ bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
+ XLogRedoAction action;
++ TransactionId xid_base = InvalidTransactionId,
++ multi_base = InvalidTransactionId;
++ Pointer rec_data = (Pointer) XLogRecGetData(record);
+
+ /*
+ * Insertion doesn't overwrite MVCC data, so no conflict processing is
+ * required.
+ */
+- xlrec = (xl_heap_multi_insert *) XLogRecGetData(record);
++ if (isinit)
++ {
++ xid_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ multi_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ }
++ xlrec = (xl_heap_multi_insert *) rec_data;
+
+ XLogRecGetBlockTag(record, 0, &rlocator, NULL, &blkno);
+
+@@ -585,7 +642,22 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ {
+ buffer = XLogInitBufferForRedo(record, 0);
+ page = BufferGetPage(buffer);
+- PageInit(page, BufferGetPageSize(buffer), 0);
++
++ if ((xlrec->flags & XLH_INSERT_ON_TOAST_RELATION) != 0)
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ PageInit(page, BufferGetPageSize(buffer), sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
++ }
++
+ action = BLK_NEEDS_REDO;
+ }
+ else
+@@ -606,6 +678,7 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ {
+ OffsetNumber offnum;
+ xl_multi_insert_tuple *xlhdr;
++ HeapTupleData tuple;
+
+ /*
+ * If we're reinitializing the page, the tuples are stored in
+@@ -636,7 +709,9 @@ heap_xlog_multi_insert(XLogReaderState *record)
+ htup->t_infomask2 = xlhdr->t_infomask2;
+ htup->t_infomask = xlhdr->t_infomask;
+ htup->t_hoff = xlhdr->t_hoff;
+- HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmin(page, &tuple, XLogRecGetXid(record),
++ false);
+ HeapTupleHeaderSetCmin(htup, FirstCommandId);
+ ItemPointerSetBlockNumber(&htup->t_ctid, blkno);
+ ItemPointerSetOffsetNumber(&htup->t_ctid, offnum);
+@@ -684,8 +759,8 @@ static void
+ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ {
+ XLogRecPtr lsn = record->EndRecPtr;
+- xl_heap_update *xlrec = (xl_heap_update *) XLogRecGetData(record);
+ RelFileLocator rlocator;
++ xl_heap_update *xlrec;
+ BlockNumber oldblk;
+ BlockNumber newblk;
+ ItemPointerData newtid;
+@@ -709,6 +784,20 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ Size freespace = 0;
+ XLogRedoAction oldaction;
+ XLogRedoAction newaction;
++ bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(record);
++ TransactionId xid_base = InvalidTransactionId,
++ multi_base = InvalidTransactionId;
++
++ if (isinit)
++ {
++ xid_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ multi_base = *((TransactionId *) rec_data);
++ rec_data += sizeof(TransactionId);
++ }
++
++ xlrec = (xl_heap_update *) rec_data;
+
+ /* initialize to keep the compiler quiet */
+ oldtup.t_data = NULL;
+@@ -755,6 +844,8 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ &obuffer);
+ if (oldaction == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = BufferGetPage(obuffer);
+ offnum = xlrec->old_offnum;
+ if (PageGetMaxOffsetNumber(page) >= offnum)
+@@ -767,6 +858,8 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+
+ oldtup.t_data = htup;
+ oldtup.t_len = ItemIdGetLength(lp);
++ /* Toast tuples are never updated. */
++ HeapTupleCopyXidsFromPage(obuffer, &oldtup, page, false);
+
+ htup->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
+ htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+@@ -776,13 +869,15 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ HeapTupleHeaderClearHotUpdated(htup);
+ fix_infomask_from_infobits(xlrec->old_infobits_set, &htup->t_infomask,
+ &htup->t_infomask2);
+- HeapTupleHeaderSetXmax(htup, xlrec->old_xmax);
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->old_xmax, false);
+ HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
+ /* Set forward chain link in t_ctid */
+ htup->t_ctid = newtid;
+
+ /* Mark the page as a candidate for pruning */
+- PageSetPrunable(page, XLogRecGetXid(record));
++ /* Toast tuples are never updated. */
++ PageSetPrunable(page, XLogRecGetXid(record), false);
+
+ if (xlrec->flags & XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED)
+ PageClearAllVisible(page);
+@@ -799,11 +894,18 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ nbuffer = obuffer;
+ newaction = oldaction;
+ }
+- else if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
++ else if (isinit)
+ {
++ HeapPageSpecial special;
++
+ nbuffer = XLogInitBufferForRedo(record, 0);
+ page = (Page) BufferGetPage(nbuffer);
+- PageInit(page, BufferGetPageSize(nbuffer), 0);
++
++ /* Toast tuples are never updated. */
++ PageInit(page, BufferGetPageSize(nbuffer), sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
+ newaction = BLK_NEEDS_REDO;
+ }
+ else
+@@ -831,6 +933,7 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ char *recdata_end;
+ Size datalen;
+ Size tuplen;
++ HeapTupleData tuple;
+
+ recdata = XLogRecGetBlockData(record, 0, &datalen);
+ recdata_end = recdata + datalen;
+@@ -909,9 +1012,10 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
+ htup->t_infomask = xlhdr.t_infomask;
+ htup->t_hoff = xlhdr.t_hoff;
+
+- HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmin(page, &tuple, XLogRecGetXid(record), false);
+ HeapTupleHeaderSetCmin(htup, FirstCommandId);
+- HeapTupleHeaderSetXmax(htup, xlrec->new_xmax);
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->new_xmax, false);
+ /* Make sure there is no forward chain link in t_ctid */
+ htup->t_ctid = newtid;
+
+@@ -1028,6 +1132,8 @@ heap_xlog_lock(XLogReaderState *record)
+
+ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = (Page) BufferGetPage(buffer);
+
+ offnum = xlrec->offnum;
+@@ -1056,7 +1162,9 @@ heap_xlog_lock(XLogReaderState *record)
+ BufferGetBlockNumber(buffer),
+ offnum);
+ }
+- HeapTupleHeaderSetXmax(htup, xlrec->xmax);
++
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->xmax, false);
+ HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
+ PageSetLSN(page, lsn);
+ MarkBufferDirty(buffer);
+@@ -1104,6 +1212,8 @@ heap_xlog_lock_updated(XLogReaderState *record)
+
+ if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
+ {
++ HeapTupleData tuple;
++
+ page = BufferGetPage(buffer);
+
+ offnum = xlrec->offnum;
+@@ -1119,7 +1229,8 @@ heap_xlog_lock_updated(XLogReaderState *record)
+ htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
+ fix_infomask_from_infobits(xlrec->infobits_set, &htup->t_infomask,
+ &htup->t_infomask2);
+- HeapTupleHeaderSetXmax(htup, xlrec->xmax);
++ tuple.t_data = htup;
++ HeapTupleAndHeaderSetXmax(page, &tuple, xlrec->xmax, false);
+
+ PageSetLSN(page, lsn);
+ MarkBufferDirty(buffer);
+@@ -1272,6 +1383,10 @@ heap_mask(char *pagedata, BlockNumber blkno)
+ mask_page_lsn_and_checksum(page);
+
+ mask_page_hint_bits(page);
++
++ /* Ignore prune_xid (it's like a hint-bit) */
++ HeapPageSetPruneXid(page, InvalidTransactionId, false);
++
+ mask_unused_space(page);
+
+ for (off = 1; off <= PageGetMaxOffsetNumber(page); off++)
+diff --git a/src/backend/access/heap/heaptoast.c b/src/backend/access/heap/heaptoast.c
+index a420e165304..75def55a8f1 100644
+--- a/src/backend/access/heap/heaptoast.c
++++ b/src/backend/access/heap/heaptoast.c
+@@ -307,6 +307,7 @@ heap_toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup,
+ result_tuple->t_len = new_tuple_len;
+ result_tuple->t_self = newtup->t_self;
+ result_tuple->t_tableOid = newtup->t_tableOid;
++ HeapTupleCopyXids(result_tuple, newtup);
+ new_data = (HeapTupleHeader) ((char *) result_tuple + HEAPTUPLESIZE);
+ result_tuple->t_data = new_data;
+
+@@ -395,6 +396,7 @@ toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)
+ */
+ new_tuple->t_self = tup->t_self;
+ new_tuple->t_tableOid = tup->t_tableOid;
++ HeapTupleCopyXids(new_tuple, tup);
+
+ new_tuple->t_data->t_choice = tup->t_data->t_choice;
+ new_tuple->t_data->t_ctid = tup->t_data->t_ctid;
+@@ -467,6 +469,7 @@ toast_flatten_tuple_to_datum(HeapTupleHeader tup,
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
+ tmptup.t_data = tup;
++ HeapTupleSetZeroXids(&tmptup);
+
+ /*
+ * Break down the tuple into fields.
+diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c
+index 7c662cdf46e..e0a248b6c27 100644
+--- a/src/backend/access/heap/hio.c
++++ b/src/backend/access/heap/hio.c
+@@ -19,6 +19,7 @@
+ #include "access/hio.h"
+ #include "access/htup_details.h"
+ #include "access/visibilitymap.h"
++#include "catalog/catalog.h"
+ #include "storage/bufmgr.h"
+ #include "storage/freespace.h"
+ #include "storage/lmgr.h"
+@@ -58,6 +59,9 @@ RelationPutHeapTuple(Relation relation,
+ /* Add the tuple to the page */
+ pageHeader = BufferGetPage(buffer);
+
++ HeapTupleHeaderStoreXmin(pageHeader, tuple, IsToastRelation(relation));
++ HeapTupleHeaderStoreXmax(pageHeader, tuple, IsToastRelation(relation));
++
+ offnum = PageAddItem(pageHeader, (Item) tuple->t_data,
+ tuple->t_len, InvalidOffsetNumber, false, true);
+
+@@ -360,7 +364,17 @@ RelationAddBlocks(Relation relation, BulkInsertState bistate,
+ first_block,
+ RelationGetRelationName(relation));
+
+- PageInit(page, BufferGetPageSize(buffer), 0);
++ if (IsToastRelation(relation))
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++ else
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(HeapPageSpecialData));
++ HeapPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++
+ MarkBufferDirty(buffer);
+
+ /*
+@@ -393,7 +407,7 @@ RelationAddBlocks(Relation relation, BulkInsertState bistate,
+ if (use_fsm && i >= not_in_fsm_pages)
+ {
+ Size freespace = BufferGetPageSize(victim_buffers[i]) -
+- SizeOfPageHeaderData;
++ SizeOfPageHeaderData - MAXALIGN(sizeof(HeapPageSpecialData));
+
+ RecordPageWithFreeSpace(relation, curBlock, freespace);
+ }
+@@ -684,6 +698,9 @@ loop:
+ /*
+ * Now we can check to see if there's enough free space here. If so,
+ * we're done.
++ *
++ * "Double xmax" page is not suitable for any new tuple, since xmin
++ * can't be set there.
+ */
+ page = BufferGetPage(buffer);
+
+@@ -695,12 +712,23 @@ loop:
+ */
+ if (PageIsNew(page))
+ {
+- PageInit(page, BufferGetPageSize(buffer), 0);
++ if (IsToastRelation(relation))
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(ToastPageSpecialData));
++ ToastPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++ else
++ {
++ PageInit(page, BufferGetPageSize(buffer), sizeof(HeapPageSpecialData));
++ HeapPageGetSpecial(page)->pd_xid_base = RecentXmin - FirstNormalTransactionId;
++ }
++
+ MarkBufferDirty(buffer);
+ }
+
+ pageFreeSpace = PageGetHeapFreeSpace(page);
+- if (targetFreeSpace <= pageFreeSpace)
++ if (targetFreeSpace <= pageFreeSpace &&
++ !HeapPageIsDoubleXmax(page))
+ {
+ /* use this page as future insert target, too */
+ RelationSetTargetBlock(relation, targetBlock);
+diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c
+index 869d82ad667..4683d0a9ce2 100644
+--- a/src/backend/access/heap/pruneheap.c
++++ b/src/backend/access/heap/pruneheap.c
+@@ -157,7 +157,7 @@ static HTSV_Result heap_prune_satisfies_vacuum(PruneState *prstate,
+ HeapTuple tup,
+ Buffer buffer);
+ static inline HTSV_Result htsv_get_valid_status(int status);
+-static void heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
++static void heap_prune_chain(Relation relation, Buffer buffer, Page page, BlockNumber blockno, OffsetNumber maxoff,
+ OffsetNumber rootoffnum, PruneState *prstate);
+ static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid);
+ static void heap_prune_record_redirect(PruneState *prstate,
+@@ -170,12 +170,23 @@ static void heap_prune_record_dead_or_unused(PruneState *prstate, OffsetNumber o
+ static void heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum, bool was_normal);
+
+ static void heap_prune_record_unchanged_lp_unused(Page page, PruneState *prstate, OffsetNumber offnum);
+-static void heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumber offnum);
++static void heap_prune_record_unchanged_lp_normal(Relation relation, Buffer buffer, Page page, PruneState *prstate, OffsetNumber offnum);
+ static void heap_prune_record_unchanged_lp_dead(Page page, PruneState *prstate, OffsetNumber offnum);
+ static void heap_prune_record_unchanged_lp_redirect(PruneState *prstate, OffsetNumber offnum);
+
+ static void page_verify_redirects(Page page);
+
++static inline bool
++XidFitsPage(Page page, TransactionId xid, bool is_toast)
++{
++ TransactionId base;
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ return xid >= base + FirstNormalTransactionId &&
++ xid <= base + MaxShortTransactionId;
++}
+
+ /*
+ * Optionally prune and repair fragmentation in the specified page.
+@@ -210,7 +221,8 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
+ * determining the appropriate horizon is a waste if there's no prune_xid
+ * (i.e. no updates/deletes left potentially dead tuples around).
+ */
+- prune_xid = ((PageHeader) page)->pd_prune_xid;
++ prune_xid = HeapPageGetPruneXidNoAssert(page, IsToastRelation(relation));
++
+ if (!TransactionIdIsValid(prune_xid))
+ return;
+
+@@ -261,7 +273,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
+ * that during on-access pruning with the current implementation.
+ */
+ heap_page_prune_and_freeze(relation, buffer, vistest, 0,
+- NULL, &presult, PRUNE_ON_ACCESS, &dummy_off_loc, NULL, NULL);
++ NULL, &presult, PRUNE_ON_ACCESS, &dummy_off_loc, NULL, NULL, false);
+
+ /*
+ * Report the number of tuples reclaimed to pgstats. This is
+@@ -355,7 +367,8 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ PruneReason reason,
+ OffsetNumber *off_loc,
+ TransactionId *new_relfrozen_xid,
+- MultiXactId *new_relmin_mxid)
++ MultiXactId *new_relmin_mxid,
++ bool repairFragmentation)
+ {
+ Page page = BufferGetPage(buffer);
+ BlockNumber blockno = BufferGetBlockNumber(buffer);
+@@ -540,6 +553,8 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ htup = (HeapTupleHeader) PageGetItem(page, itemid);
+ tup.t_data = htup;
+ tup.t_len = ItemIdGetLength(itemid);
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+ ItemPointerSet(&tup.t_self, blockno, offnum);
+
+ prstate.htsv[offnum] = heap_prune_satisfies_vacuum(&prstate, &tup,
+@@ -580,7 +595,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ *off_loc = offnum;
+
+ /* Process this item or chain of items */
+- heap_prune_chain(page, blockno, maxoff, offnum, &prstate);
++ heap_prune_chain(relation, buffer, page, blockno, maxoff, offnum, &prstate);
+ }
+
+ /*
+@@ -614,10 +629,15 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ {
+ ItemId itemid = PageGetItemId(page, offnum);
+ HeapTupleHeader htup = (HeapTupleHeader) PageGetItem(page, itemid);
++ tup.t_data = htup;
++ tup.t_len = ItemIdGetLength(itemid);
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
++ ItemPointerSet(&tup.t_self, blockno, offnum);
+
+ if (likely(!HeapTupleHeaderIsHotUpdated(htup)))
+ {
+- HeapTupleHeaderAdvanceConflictHorizon(htup,
++ HeapTupleHeaderAdvanceConflictHorizon(&tup,
+ &prstate.latest_xid_removed);
+ heap_prune_record_unused(&prstate, offnum, true);
+ }
+@@ -636,7 +656,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ }
+ }
+ else
+- heap_prune_record_unchanged_lp_normal(page, &prstate, offnum);
++ heap_prune_record_unchanged_lp_normal(relation, buffer, page, &prstate, offnum);
+ }
+
+ /* We should now have processed every tuple exactly once */
+@@ -663,7 +683,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ * pd_prune_xid field or the page was marked full, we will update the hint
+ * bit.
+ */
+- do_hint = ((PageHeader) page)->pd_prune_xid != prstate.new_prune_xid ||
++ do_hint = HeapPageGetPruneXid(page, IsToastRelation(relation)) != prstate.new_prune_xid ||
+ PageIsFull(page);
+
+ /*
+@@ -727,7 +747,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ * Validate the tuples we will be freezing before entering the
+ * critical section.
+ */
+- heap_pre_freeze_checks(buffer, prstate.frozen, prstate.nfrozen);
++ heap_pre_freeze_checks(relation, buffer, prstate.frozen, prstate.nfrozen);
+ }
+ else if (prstate.nfrozen > 0)
+ {
+@@ -759,7 +779,7 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ * Update the page's pd_prune_xid field to either zero, or the lowest
+ * XID of any soon-prunable tuple.
+ */
+- ((PageHeader) page)->pd_prune_xid = prstate.new_prune_xid;
++ HeapPageSetPruneXid(page, prstate.new_prune_xid, IsToastRelation(relation));
+
+ /*
+ * Also clear the "page is full" flag, since there's no point in
+@@ -785,11 +805,13 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ heap_page_prune_execute(buffer, false,
+ prstate.redirected, prstate.nredirected,
+ prstate.nowdead, prstate.ndead,
+- prstate.nowunused, prstate.nunused);
++ prstate.nowunused, prstate.nunused,
++ repairFragmentation,
++ IsToastRelation(relation));
+ }
+
+ if (do_freeze)
+- heap_freeze_prepared_tuples(buffer, prstate.frozen, prstate.nfrozen);
++ heap_freeze_prepared_tuples(relation, buffer, prstate.frozen, prstate.nfrozen);
+
+ MarkBufferDirty(buffer);
+
+@@ -840,7 +862,8 @@ heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ prstate.frozen, prstate.nfrozen,
+ prstate.redirected, prstate.nredirected,
+ prstate.nowdead, prstate.ndead,
+- prstate.nowunused, prstate.nunused);
++ prstate.nowunused, prstate.nunused,
++ repairFragmentation);
+ }
+ }
+
+@@ -996,7 +1019,7 @@ htsv_get_valid_status(int status)
+ * based on that outcome.
+ */
+ static void
+-heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
++heap_prune_chain(Relation relation, Buffer buffer, Page page, BlockNumber blockno, OffsetNumber maxoff,
+ OffsetNumber rootoffnum, PruneState *prstate)
+ {
+ TransactionId priorXmax = InvalidTransactionId;
+@@ -1010,6 +1033,9 @@ heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
+ */
+ int ndeadchain = 0,
+ nchain = 0;
++ HeapTupleData tup;
++
++ tup.t_tableOid = RelationGetRelid(relation);
+
+ rootlp = PageGetItemId(page, rootoffnum);
+
+@@ -1065,11 +1091,17 @@ heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
+
+ htup = (HeapTupleHeader) PageGetItem(page, lp);
+
++ tup.t_data = htup;
++ tup.t_len = ItemIdGetLength(lp);
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
++ ItemPointerSet(&(tup.t_self), BufferGetBlockNumber(buffer), offnum);
++
+ /*
+ * Check the tuple XMIN against prior XMAX, if any
+ */
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(HeapTupleHeaderGetXmin(htup), priorXmax))
++ !TransactionIdEquals(HeapTupleGetXmin(&tup), priorXmax))
+ break;
+
+ /*
+@@ -1083,7 +1115,7 @@ heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
+
+ /* Remember the last DEAD tuple seen */
+ ndeadchain = nchain;
+- HeapTupleHeaderAdvanceConflictHorizon(htup,
++ HeapTupleHeaderAdvanceConflictHorizon(&tup,
+ &prstate->latest_xid_removed);
+ /* Advance to next chain member */
+ break;
+@@ -1133,7 +1165,7 @@ heap_prune_chain(Page page, BlockNumber blockno, OffsetNumber maxoff,
+ */
+ Assert(ItemPointerGetBlockNumber(&htup->t_ctid) == blockno);
+ offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ priorXmax = HeapTupleGetUpdateXidAny(&tup);
+ }
+
+ if (ItemIdIsRedirected(rootlp) && nchain < 2)
+@@ -1166,7 +1198,7 @@ process_chain:
+ i++;
+ }
+ for (; i < nchain; i++)
+- heap_prune_record_unchanged_lp_normal(page, prstate, chainitems[i]);
++ heap_prune_record_unchanged_lp_normal(relation, buffer, page, prstate, chainitems[i]);
+ }
+ else if (ndeadchain == nchain)
+ {
+@@ -1192,7 +1224,7 @@ process_chain:
+
+ /* the rest of tuples in the chain are normal, unchanged tuples */
+ for (int i = ndeadchain; i < nchain; i++)
+- heap_prune_record_unchanged_lp_normal(page, prstate, chainitems[i]);
++ heap_prune_record_unchanged_lp_normal(relation, buffer, page, prstate, chainitems[i]);
+ }
+ }
+
+@@ -1327,9 +1359,9 @@ heap_prune_record_unchanged_lp_unused(Page page, PruneState *prstate, OffsetNumb
+ * update bookkeeping of tuple counts and page visibility.
+ */
+ static void
+-heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumber offnum)
++heap_prune_record_unchanged_lp_normal(Relation relation, Buffer buffer, Page page, PruneState *prstate, OffsetNumber offnum)
+ {
+- HeapTupleHeader htup;
++ HeapTupleData tup;
+
+ Assert(!prstate->processed[offnum]);
+ prstate->processed[offnum] = true;
+@@ -1356,7 +1388,9 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * will violate this optimistic assumption, but the overall impact of that
+ * should be negligible.)
+ */
+- htup = (HeapTupleHeader) PageGetItem(page, PageGetItemId(page, offnum));
++ tup.t_data = (HeapTupleHeader) PageGetItem(page, PageGetItemId(page, offnum));
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+
+ switch (prstate->htsv[offnum])
+ {
+@@ -1378,9 +1412,7 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ */
+ if (prstate->all_visible)
+ {
+- TransactionId xmin;
+-
+- if (!HeapTupleHeaderXminCommitted(htup))
++ if (!HeapTupleHeaderXminCommitted(tup.t_data))
+ {
+ prstate->all_visible = false;
+ break;
+@@ -1393,7 +1425,6 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * there is a snapshot that considers this xid to still be
+ * running, and if so, we don't consider the page all-visible.
+ */
+- xmin = HeapTupleHeaderGetXmin(htup);
+
+ /*
+ * For now always use prstate->cutoffs for this test, because
+@@ -1402,16 +1433,16 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * non-freezing caller wanted to set the VM bit.
+ */
+ Assert(prstate->cutoffs);
+- if (!TransactionIdPrecedes(xmin, prstate->cutoffs->OldestXmin))
++ if (!TransactionIdPrecedes(tup.t_xmin, prstate->cutoffs->OldestXmin))
+ {
+ prstate->all_visible = false;
+ break;
+ }
+
+ /* Track newest xmin on page. */
+- if (TransactionIdFollows(xmin, prstate->visibility_cutoff_xid) &&
+- TransactionIdIsNormal(xmin))
+- prstate->visibility_cutoff_xid = xmin;
++ if (TransactionIdFollows(tup.t_xmin, prstate->visibility_cutoff_xid) &&
++ TransactionIdIsNormal(tup.t_xmin))
++ prstate->visibility_cutoff_xid = tup.t_xmin;
+ }
+ break;
+
+@@ -1424,7 +1455,7 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * that the page is reconsidered for pruning in future.
+ */
+ heap_prune_record_prunable(prstate,
+- HeapTupleHeaderGetUpdateXid(htup));
++ HeapTupleGetUpdateXidAny(&tup));
+ break;
+
+ case HEAPTUPLE_INSERT_IN_PROGRESS:
+@@ -1461,7 +1492,7 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ * the page is reconsidered for pruning in future.
+ */
+ heap_prune_record_prunable(prstate,
+- HeapTupleHeaderGetUpdateXid(htup));
++ HeapTupleGetUpdateXidAny(&tup));
+ break;
+
+ default:
+@@ -1480,7 +1511,7 @@ heap_prune_record_unchanged_lp_normal(Page page, PruneState *prstate, OffsetNumb
+ {
+ bool totally_frozen;
+
+- if ((heap_prepare_freeze_tuple(htup,
++ if ((heap_prepare_freeze_tuple(&tup,
+ prstate->cutoffs,
+ &prstate->pagefrz,
+ &prstate->frozen[prstate->nfrozen],
+@@ -1561,7 +1592,9 @@ void
+ heap_page_prune_execute(Buffer buffer, bool lp_truncate_only,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *nowdead, int ndead,
+- OffsetNumber *nowunused, int nunused)
++ OffsetNumber *nowunused, int nunused,
++ bool repairFragmentation,
++ bool is_toast)
+ {
+ Page page = (Page) BufferGetPage(buffer);
+ OffsetNumber *offnum;
+@@ -1709,7 +1742,8 @@ heap_page_prune_execute(Buffer buffer, bool lp_truncate_only,
+ * Finally, repair any fragmentation, and update the page's hint bit
+ * about whether it has free pointers.
+ */
+- PageRepairFragmentation(page);
++ if (repairFragmentation)
++ PageRepairFragmentation(page, is_toast);
+
+ /*
+ * Now that the page has been modified, assert that redirect items
+@@ -1782,7 +1816,8 @@ page_verify_redirects(Page page)
+ * and reused by a completely unrelated tuple.
+ */
+ void
+-heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
++heap_get_root_tuples(Relation relation, Buffer buffer, Page page,
++ OffsetNumber *root_offsets)
+ {
+ OffsetNumber offnum,
+ maxoff;
+@@ -1797,6 +1832,7 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ HeapTupleHeader htup;
+ OffsetNumber nextoffnum;
+ TransactionId priorXmax;
++ HeapTupleData tup;
+
+ /* skip unused and dead items */
+ if (!ItemIdIsUsed(lp) || ItemIdIsDead(lp))
+@@ -1805,6 +1841,9 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ if (ItemIdIsNormal(lp))
+ {
+ htup = (HeapTupleHeader) PageGetItem(page, lp);
++ tup.t_data = htup;
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+
+ /*
+ * Check if this tuple is part of a HOT-chain rooted at some other
+@@ -1826,7 +1865,7 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+
+ /* Set up to scan the HOT-chain */
+ nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ priorXmax = HeapTupleGetUpdateXidAny(&tup);
+ }
+ else
+ {
+@@ -1865,9 +1904,12 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ break;
+
+ htup = (HeapTupleHeader) PageGetItem(page, lp);
++ tup.t_data = htup;
++ HeapTupleCopyXidsFromPage(buffer, &tup, page,
++ IsToastRelation(relation));
+
+ if (TransactionIdIsValid(priorXmax) &&
+- !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(htup)))
++ !TransactionIdEquals(priorXmax, HeapTupleGetXmin(&tup)))
+ break;
+
+ /* Remember the root line pointer for this item */
+@@ -1881,7 +1923,7 @@ heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
+ Assert(!HeapTupleHeaderIndicatesMovedPartitions(htup));
+
+ nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
+- priorXmax = HeapTupleHeaderGetUpdateXid(htup);
++ priorXmax = HeapTupleGetUpdateXidAny(&tup);
+ }
+ }
+ }
+@@ -2057,7 +2099,8 @@ log_heap_prune_and_freeze(Relation relation, Buffer buffer,
+ HeapTupleFreeze *frozen, int nfrozen,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *dead, int ndead,
+- OffsetNumber *unused, int nunused)
++ OffsetNumber *unused, int nunused,
++ bool repairFragmentation)
+ {
+ xl_heap_prune xlrec;
+ XLogRecPtr recptr;
+@@ -2073,6 +2116,12 @@ log_heap_prune_and_freeze(Relation relation, Buffer buffer,
+
+ xlrec.flags = 0;
+
++ if (IsToastRelation(relation))
++ xlrec.flags |= XLHP_ON_TOAST_RELATION;
++
++ if (repairFragmentation)
++ xlrec.flags |= XLHP_REPAIR_FRAGMENTATION;
++
+ /*
+ * Prepare data for the buffer. The arrays are not actually in the
+ * buffer, but we pretend that they are. When XLogInsert stores a full
+diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
+index 09ef2204497..090e1594679 100644
+--- a/src/backend/access/heap/rewriteheap.c
++++ b/src/backend/access/heap/rewriteheap.c
+@@ -359,6 +359,7 @@ rewrite_heap_tuple(RewriteState state,
+ &old_tuple->t_data->t_choice.t_heap,
+ sizeof(HeapTupleFields));
+
++ HeapTupleCopyXids(new_tuple, old_tuple);
+ new_tuple->t_data->t_infomask &= ~HEAP_XACT_MASK;
+ new_tuple->t_data->t_infomask2 &= ~HEAP2_XACT_MASK;
+ new_tuple->t_data->t_infomask |=
+@@ -368,7 +369,7 @@ rewrite_heap_tuple(RewriteState state,
+ * While we have our hands on the tuple, we may as well freeze any
+ * eligible xmin or xmax, so that future VACUUM effort can be saved.
+ */
+- heap_freeze_tuple(new_tuple->t_data,
++ heap_freeze_tuple(new_tuple,
+ state->rs_old_rel->rd_rel->relfrozenxid,
+ state->rs_old_rel->rd_rel->relminmxid,
+ state->rs_freeze_xid,
+@@ -384,7 +385,7 @@ rewrite_heap_tuple(RewriteState state,
+ * If the tuple has been updated, check the old-to-new mapping hash table.
+ */
+ if (!((old_tuple->t_data->t_infomask & HEAP_XMAX_INVALID) ||
+- HeapTupleHeaderIsOnlyLocked(old_tuple->t_data)) &&
++ HeapTupleIsOnlyLocked(old_tuple)) &&
+ !HeapTupleHeaderIndicatesMovedPartitions(old_tuple->t_data) &&
+ !(ItemPointerEquals(&(old_tuple->t_self),
+ &(old_tuple->t_data->t_ctid))))
+@@ -392,7 +393,7 @@ rewrite_heap_tuple(RewriteState state,
+ OldToNewMapping mapping;
+
+ memset(&hashkey, 0, sizeof(hashkey));
+- hashkey.xmin = HeapTupleHeaderGetUpdateXid(old_tuple->t_data);
++ hashkey.xmin = HeapTupleGetUpdateXidAny(old_tuple);
+ hashkey.tid = old_tuple->t_data->t_ctid;
+
+ mapping = (OldToNewMapping)
+@@ -465,7 +466,7 @@ rewrite_heap_tuple(RewriteState state,
+ * RECENTLY_DEAD if and only if the xmin is not before OldestXmin.
+ */
+ if ((new_tuple->t_data->t_infomask & HEAP_UPDATED) &&
+- !TransactionIdPrecedes(HeapTupleHeaderGetXmin(new_tuple->t_data),
++ !TransactionIdPrecedes(HeapTupleGetXmin(new_tuple),
+ state->rs_oldest_xmin))
+ {
+ /*
+@@ -474,7 +475,7 @@ rewrite_heap_tuple(RewriteState state,
+ UnresolvedTup unresolved;
+
+ memset(&hashkey, 0, sizeof(hashkey));
+- hashkey.xmin = HeapTupleHeaderGetXmin(new_tuple->t_data);
++ hashkey.xmin = HeapTupleGetXmin(new_tuple);
+ hashkey.tid = old_tid;
+
+ unresolved = hash_search(state->rs_unresolved_tups, &hashkey,
+@@ -562,7 +563,7 @@ rewrite_heap_dead_tuple(RewriteState state, HeapTuple old_tuple)
+ bool found;
+
+ memset(&hashkey, 0, sizeof(hashkey));
+- hashkey.xmin = HeapTupleHeaderGetXmin(old_tuple->t_data);
++ hashkey.xmin = HeapTupleGetXmin(old_tuple);
+ hashkey.tid = old_tuple->t_self;
+
+ unresolved = hash_search(state->rs_unresolved_tups, &hashkey,
+@@ -598,6 +599,8 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
+ Size len;
+ OffsetNumber newoff;
+ HeapTuple heaptup;
++ TransactionId xmin;
++ bool immutable_tuple;
+
+ /*
+ * If the new tuple is too big for storage or contains already toasted
+@@ -632,9 +635,19 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
+ len = MAXALIGN(heaptup->t_len); /* be conservative */
+
+ /*
+- * If we're gonna fail for oversize tuple, do it right away
++ * Due to update to 64-xid maximum plain tuple size was decreased due to adding
++ * PageSpecial to a heap page. Pages with tuple that became too large to fit,
++ * should remain in Double Xmax format (read only). Inserting plain tuples with
++ * size over new MaxHeapTupleSizs is prohibited anyway, but vaccum full will
++ * transfer this page to a rebuild relation unmodified.
+ */
+- if (len > MaxHeapTupleSize)
++ immutable_tuple = len <= MaxHeapTupleSize_32 && len > MaxHeapTupleSize;
++
++ /*
++ * If we're gonna fail for oversize tuple, do it right away. But allow to process
++ * immutable_tuple (see above).
++ */
++ if (len > MaxHeapTupleSize && !immutable_tuple)
+ ereport(ERROR,
+ (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+ errmsg("row is too big: size %zu, maximum size %zu",
+@@ -669,9 +682,41 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
+ /* Initialize a new empty page */
+ state->rs_buffer = smgr_bulk_get_buf(state->rs_bulkstate);
+ page = (Page) state->rs_buffer;
+- PageInit(page, BLCKSZ, 0);
++ if (immutable_tuple)
++ /* Initialize DoubleXmax page */
++ PageInit(page, BLCKSZ, 0);
++ else
++ {
++ Size special_size;
++
++ special_size = IsToastRelation(state->rs_new_rel) ?
++ sizeof(ToastPageSpecialData) :
++ sizeof(HeapPageSpecialData);
++ PageInit(page, BLCKSZ, special_size);
++ }
+ }
+
++ rewrite_page_prepare_for_xid(page, heaptup,
++ IsToastRelation(state->rs_new_rel));
++
++ /*
++ * Tuple with HEAP_XMIN_FROZEN in t_infomask should have xmin set
++ * to FrozenTransactionId to avoid these tuples be treated like normal.
++ */
++ xmin = HeapTupleGetXmin(heaptup);
++ HeapTupleSetXmin(heaptup, xmin);
++
++ /*
++ * Tuples on DoubleXmax page could not appear modified after they had been
++ * frozen by pg_upgrade. Just check this to be safe.
++ */
++ Assert(!immutable_tuple || xmin == FrozenTransactionId);
++
++ if (!immutable_tuple)
++ HeapTupleAndHeaderSetXmin(page, heaptup, xmin, false);
++
++ HeapTupleHeaderStoreXmax(page, heaptup, false);
++
+ /* And now we can insert the tuple into the page */
+ newoff = PageAddItem(page, (Item) heaptup->t_data, heaptup->t_len,
+ InvalidOffsetNumber, false, true);
+@@ -952,19 +997,24 @@ logical_rewrite_log_mapping(RewriteState state, TransactionId xid,
+ */
+ if (!found)
+ {
+- char path[MAXPGPATH];
+- Oid dboid;
++ char path[MAXPGPATH];
++ Oid dboid;
++ TransactionId current_xid;
+
+ if (state->rs_old_rel->rd_rel->relisshared)
+ dboid = InvalidOid;
+ else
+ dboid = MyDatabaseId;
+
++ current_xid = GetCurrentTransactionId();
+ snprintf(path, MAXPGPATH,
+ "%s/" LOGICAL_REWRITE_FORMAT,
+ PG_LOGICAL_MAPPINGS_DIR, dboid, relid,
+ LSN_FORMAT_ARGS(state->rs_begin_lsn),
+- xid, GetCurrentTransactionId());
++ (uint32) (xid >> 32),
++ (uint32) xid,
++ (uint32) (current_xid >> 32),
++ (uint32) current_xid);
+
+ dclist_init(&src->mappings);
+ src->off = 0;
+@@ -1011,9 +1061,9 @@ logical_rewrite_heap_tuple(RewriteState state, ItemPointerData old_tid,
+ if (!state->rs_logical_rewrite)
+ return;
+
+- xmin = HeapTupleHeaderGetXmin(new_tuple->t_data);
++ xmin = HeapTupleGetXmin(new_tuple);
+ /* use *GetUpdateXid to correctly deal with multixacts */
+- xmax = HeapTupleHeaderGetUpdateXid(new_tuple->t_data);
++ xmax = HeapTupleGetUpdateXidAny(new_tuple);
+
+ /*
+ * Log the mapping iff the tuple has been created recently.
+@@ -1077,14 +1127,19 @@ heap_xlog_logical_rewrite(XLogReaderState *r)
+ xl_heap_rewrite_mapping *xlrec;
+ uint32 len;
+ char *data;
++ TransactionId xid;
+
+ xlrec = (xl_heap_rewrite_mapping *) XLogRecGetData(r);
+
++ xid = XLogRecGetXid(r);
+ snprintf(path, MAXPGPATH,
+ "%s/" LOGICAL_REWRITE_FORMAT,
+ PG_LOGICAL_MAPPINGS_DIR, xlrec->mapped_db, xlrec->mapped_rel,
+ LSN_FORMAT_ARGS(xlrec->start_lsn),
+- xlrec->mapped_xid, XLogRecGetXid(r));
++ (uint32) (xlrec->mapped_xid >> 32),
++ (uint32) xlrec->mapped_xid,
++ (uint32) (xid >> 32),
++ (uint32) xid);
+
+ fd = OpenTransientFile(path,
+ O_CREAT | O_WRONLY | PG_BINARY);
+@@ -1179,10 +1234,12 @@ CheckPointLogicalRewriteHeap(void)
+ Oid dboid;
+ Oid relid;
+ XLogRecPtr lsn;
+- TransactionId rewrite_xid;
+- TransactionId create_xid;
+- uint32 hi,
+- lo;
++ uint32 lsn_hi,
++ lsn_lo,
++ rewrite_xid_hi,
++ rewrite_xid_lo,
++ create_xid_hi,
++ create_xid_lo;
+ PGFileType de_type;
+
+ if (strcmp(mapping_de->d_name, ".") == 0 ||
+@@ -1200,10 +1257,12 @@ CheckPointLogicalRewriteHeap(void)
+ continue;
+
+ if (sscanf(mapping_de->d_name, LOGICAL_REWRITE_FORMAT,
+- &dboid, &relid, &hi, &lo, &rewrite_xid, &create_xid) != 6)
++ &dboid, &relid, &lsn_hi, &lsn_lo,
++ &rewrite_xid_hi, &rewrite_xid_lo,
++ &create_xid_hi, &create_xid_lo) != 8)
+ elog(ERROR, "could not parse filename \"%s\"", mapping_de->d_name);
+
+- lsn = ((uint64) hi) << 32 | lo;
++ lsn = ((uint64) lsn_hi) << 32 | lsn_lo;
+
+ if (lsn < cutoff || cutoff == InvalidXLogRecPtr)
+ {
+diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
+index a65474060d3..e7d364d89aa 100644
+--- a/src/backend/access/heap/vacuumlazy.c
++++ b/src/backend/access/heap/vacuumlazy.c
+@@ -41,6 +41,7 @@
+ #include "access/transam.h"
+ #include "access/visibilitymap.h"
+ #include "access/xloginsert.h"
++#include "catalog/catalog.h"
+ #include "catalog/storage.h"
+ #include "commands/dbcommands.h"
+ #include "commands/progress.h"
+@@ -246,7 +247,6 @@ static void lazy_vacuum_heap_rel(LVRelState *vacrel);
+ static void lazy_vacuum_heap_page(LVRelState *vacrel, BlockNumber blkno,
+ Buffer buffer, OffsetNumber *deadoffsets,
+ int num_offsets, Buffer vmbuffer);
+-static bool lazy_check_wraparound_failsafe(LVRelState *vacrel);
+ static void lazy_cleanup_all_indexes(LVRelState *vacrel);
+ static IndexBulkDeleteResult *lazy_vacuum_one_index(Relation indrel,
+ IndexBulkDeleteResult *istat,
+@@ -485,7 +485,6 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ * ensure that parallel VACUUM won't be attempted at all when relfrozenxid
+ * is already dangerously old.)
+ */
+- lazy_check_wraparound_failsafe(vacrel);
+ dead_items_alloc(vacrel, params->nworkers);
+
+ /*
+@@ -603,7 +602,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ BufferUsage bufferusage;
+ StringInfoData buf;
+ char *msgfmt;
+- int32 diff;
++ int64 diff;
+ double read_rate = 0,
+ write_rate = 0;
+ int64 total_blks_hit;
+@@ -665,16 +664,17 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ orig_rel_pages == 0 ? 100.0 :
+ 100.0 * vacrel->scanned_pages / orig_rel_pages);
+ appendStringInfo(&buf,
+- _("tuples: %lld removed, %lld remain, %lld are dead but not yet removable\n"),
++ _("tuples: %lld removed, %lld remain, %lld are dead but not yet removable, oldest xmin: %llu\n"),
+ (long long) vacrel->tuples_deleted,
+ (long long) vacrel->new_rel_tuples,
+- (long long) vacrel->recently_dead_tuples);
++ (long long) vacrel->recently_dead_tuples,
++ (unsigned long long) vacrel->cutoffs.OldestXmin);
+ if (vacrel->missed_dead_tuples > 0)
+ appendStringInfo(&buf,
+ _("tuples missed: %lld dead from %u pages not removed due to cleanup lock contention\n"),
+ (long long) vacrel->missed_dead_tuples,
+ vacrel->missed_dead_pages);
+- diff = (int32) (ReadNextTransactionId() -
++ diff = (int64) (ReadNextTransactionId() -
+ vacrel->cutoffs.OldestXmin);
+ appendStringInfo(&buf,
+ _("removable cutoff: %llu, which was %lld XIDs old when operation ended\n"),
+@@ -682,7 +682,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ (long long) diff);
+ if (frozenxid_updated)
+ {
+- diff = (int32) (vacrel->NewRelfrozenXid -
++ diff = (int64) (vacrel->NewRelfrozenXid -
+ vacrel->cutoffs.relfrozenxid);
+ appendStringInfo(&buf,
+ _("new relfrozenxid: %llu, which is %lld XIDs ahead of previous value\n"),
+@@ -691,7 +691,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
+ }
+ if (minmulti_updated)
+ {
+- diff = (int32) (vacrel->NewRelminMxid -
++ diff = (int64) (vacrel->NewRelminMxid -
+ vacrel->cutoffs.relminmxid);
+ appendStringInfo(&buf,
+ _("new relminmxid: %llu, which is %lld MXIDs ahead of previous value\n"),
+@@ -867,18 +867,6 @@ lazy_scan_heap(LVRelState *vacrel)
+
+ vacuum_delay_point();
+
+- /*
+- * Regularly check if wraparound failsafe should trigger.
+- *
+- * There is a similar check inside lazy_vacuum_all_indexes(), but
+- * relfrozenxid might start to look dangerously old before we reach
+- * that point. This check also provides failsafe coverage for the
+- * one-pass strategy, and the two-pass strategy with the index_cleanup
+- * param set to 'off'.
+- */
+- if (vacrel->scanned_pages % FAILSAFE_EVERY_PAGES == 0)
+- lazy_check_wraparound_failsafe(vacrel);
+-
+ /*
+ * Consider if we definitely have enough space to process TIDs on page
+ * already. If we are close to overrunning the available space for
+@@ -1319,7 +1307,14 @@ lazy_scan_new_or_empty(LVRelState *vacrel, Buffer buf, BlockNumber blkno,
+
+ if (GetRecordedFreeSpace(vacrel->rel, blkno) == 0)
+ {
+- freespace = BLCKSZ - SizeOfPageHeaderData;
++ Size special_size;
++
++ special_size = IsToastRelation(vacrel->rel) ?
++ sizeof(ToastPageSpecialData) :
++ sizeof(HeapPageSpecialData);
++ freespace = BufferGetPageSize(buf)
++ - SizeOfPageHeaderData
++ - special_size;
+
+ RecordPageWithFreeSpace(vacrel->rel, blkno, freespace);
+ }
+@@ -1448,7 +1443,8 @@ lazy_scan_prune(LVRelState *vacrel,
+ heap_page_prune_and_freeze(rel, buf, vacrel->vistest, prune_options,
+ &vacrel->cutoffs, &presult, PRUNE_VACUUM_SCAN,
+ &vacrel->offnum,
+- &vacrel->NewRelfrozenXid, &vacrel->NewRelminMxid);
++ &vacrel->NewRelfrozenXid, &vacrel->NewRelminMxid,
++ true);
+
+ Assert(MultiXactIdIsValid(vacrel->NewRelminMxid));
+ Assert(TransactionIdIsValid(vacrel->NewRelfrozenXid));
+@@ -1667,7 +1663,6 @@ lazy_scan_noprune(LVRelState *vacrel,
+ recently_dead_tuples,
+ missed_dead_tuples;
+ bool hastup;
+- HeapTupleHeader tupleheader;
+ TransactionId NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid;
+ MultiXactId NoFreezePageRelminMxid = vacrel->NewRelminMxid;
+ OffsetNumber deadoffsets[MaxHeapTuplesPerPage];
+@@ -1712,8 +1707,13 @@ lazy_scan_noprune(LVRelState *vacrel,
+ }
+
+ hastup = true; /* page prevents rel truncation */
+- tupleheader = (HeapTupleHeader) PageGetItem(page, itemid);
+- if (heap_tuple_should_freeze(tupleheader, &vacrel->cutoffs,
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(vacrel->rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page,
++ IsToastRelation(vacrel->rel));
++ ItemPointerSet(&(tuple.t_self), blkno, offnum);
++ if (heap_tuple_should_freeze(&tuple, &vacrel->cutoffs,
+ &NoFreezePageRelfrozenXid,
+ &NoFreezePageRelminMxid))
+ {
+@@ -1749,6 +1749,8 @@ lazy_scan_noprune(LVRelState *vacrel,
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationGetRelid(vacrel->rel);
++ HeapTupleCopyXidsFromPage(buf, &tuple, page,
++ IsToastRelation(vacrel->rel));
+
+ switch (HeapTupleSatisfiesVacuum(&tuple, vacrel->cutoffs.OldestXmin,
+ buf))
+@@ -2010,13 +2012,6 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
+ Assert(vacrel->do_index_vacuuming);
+ Assert(vacrel->do_index_cleanup);
+
+- /* Precheck for XID wraparound emergencies */
+- if (lazy_check_wraparound_failsafe(vacrel))
+- {
+- /* Wraparound emergency -- don't even start an index scan */
+- return false;
+- }
+-
+ /*
+ * Report that we are now vacuuming indexes and the number of indexes to
+ * vacuum.
+@@ -2040,12 +2035,6 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
+ pgstat_progress_update_param(PROGRESS_VACUUM_INDEXES_PROCESSED,
+ idx + 1);
+
+- if (lazy_check_wraparound_failsafe(vacrel))
+- {
+- /* Wraparound emergency -- end current index scan */
+- allindexes = false;
+- break;
+- }
+ }
+ }
+ else
+@@ -2053,13 +2042,6 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
+ /* Outsource everything to parallel variant */
+ parallel_vacuum_bulkdel_all_indexes(vacrel->pvs, old_live_tuples,
+ vacrel->num_index_scans);
+-
+- /*
+- * Do a postcheck to consider applying wraparound failsafe now. Note
+- * that parallel VACUUM only gets the precheck and this postcheck.
+- */
+- if (lazy_check_wraparound_failsafe(vacrel))
+- allindexes = false;
+ }
+
+ /*
+@@ -2254,7 +2236,8 @@ lazy_vacuum_heap_page(LVRelState *vacrel, BlockNumber blkno, Buffer buffer,
+ NULL, 0, /* frozen */
+ NULL, 0, /* redirected */
+ NULL, 0, /* dead */
+- unused, nunused);
++ unused, nunused,
++ true); /*repair fragmentation*/
+ }
+
+ /*
+@@ -2292,68 +2275,6 @@ lazy_vacuum_heap_page(LVRelState *vacrel, BlockNumber blkno, Buffer buffer,
+ restore_vacuum_error_info(vacrel, &saved_err_info);
+ }
+
+-/*
+- * Trigger the failsafe to avoid wraparound failure when vacrel table has a
+- * relfrozenxid and/or relminmxid that is dangerously far in the past.
+- * Triggering the failsafe makes the ongoing VACUUM bypass any further index
+- * vacuuming and heap vacuuming. Truncating the heap is also bypassed.
+- *
+- * Any remaining work (work that VACUUM cannot just bypass) is typically sped
+- * up when the failsafe triggers. VACUUM stops applying any cost-based delay
+- * that it started out with.
+- *
+- * Returns true when failsafe has been triggered.
+- */
+-static bool
+-lazy_check_wraparound_failsafe(LVRelState *vacrel)
+-{
+- /* Don't warn more than once per VACUUM */
+- if (VacuumFailsafeActive)
+- return true;
+-
+- if (unlikely(vacuum_xid_failsafe_check(&vacrel->cutoffs)))
+- {
+- const int progress_index[] = {
+- PROGRESS_VACUUM_INDEXES_TOTAL,
+- PROGRESS_VACUUM_INDEXES_PROCESSED
+- };
+- int64 progress_val[2] = {0, 0};
+-
+- VacuumFailsafeActive = true;
+-
+- /*
+- * Abandon use of a buffer access strategy to allow use of all of
+- * shared buffers. We assume the caller who allocated the memory for
+- * the BufferAccessStrategy will free it.
+- */
+- vacrel->bstrategy = NULL;
+-
+- /* Disable index vacuuming, index cleanup, and heap rel truncation */
+- vacrel->do_index_vacuuming = false;
+- vacrel->do_index_cleanup = false;
+- vacrel->do_rel_truncate = false;
+-
+- /* Reset the progress counters */
+- pgstat_progress_update_multi_param(2, progress_index, progress_val);
+-
+- ereport(WARNING,
+- (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans",
+- vacrel->dbname, vacrel->relnamespace, vacrel->relname,
+- vacrel->num_index_scans),
+- errdetail("The table's relfrozenxid or relminmxid is too far in the past."),
+- errhint("Consider increasing configuration parameter \"maintenance_work_mem\" or \"autovacuum_work_mem\".\n"
+- "You might also need to consider other ways for VACUUM to keep up with the allocation of transaction IDs.")));
+-
+- /* Stop applying cost limits from this point on */
+- VacuumCostActive = false;
+- VacuumCostBalance = 0;
+-
+- return true;
+- }
+-
+- return false;
+-}
+-
+ /*
+ * lazy_cleanup_all_indexes() -- cleanup all indexes of relation.
+ */
+@@ -3010,7 +2931,8 @@ heap_page_is_all_visible(LVRelState *vacrel, Buffer buf,
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationGetRelid(vacrel->rel);
+-
++ HeapTupleCopyXidsFromPage(buf, &tuple, page,
++ IsToastRelation(vacrel->rel));
+ switch (HeapTupleSatisfiesVacuum(&tuple, vacrel->cutoffs.OldestXmin,
+ buf))
+ {
+@@ -3030,7 +2952,7 @@ heap_page_is_all_visible(LVRelState *vacrel, Buffer buf,
+ * The inserter definitely committed. But is it old enough
+ * that everyone sees it as committed?
+ */
+- xmin = HeapTupleHeaderGetXmin(tuple.t_data);
++ xmin = HeapTupleGetXmin(&tuple);
+ if (!TransactionIdPrecedes(xmin,
+ vacrel->cutoffs.OldestXmin))
+ {
+@@ -3046,7 +2968,7 @@ heap_page_is_all_visible(LVRelState *vacrel, Buffer buf,
+
+ /* Check whether this tuple is already frozen or not */
+ if (all_visible && *all_frozen &&
+- heap_tuple_needs_eventual_freeze(tuple.t_data))
++ heap_tuple_needs_eventual_freeze(&tuple))
+ *all_frozen = false;
+ }
+ break;
+diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
+index 01bbece6bfd..7c378dc4277 100644
+--- a/src/backend/access/nbtree/nbtpage.c
++++ b/src/backend/access/nbtree/nbtpage.c
+@@ -549,6 +549,7 @@ _bt_getroot(Relation rel, Relation heaprel, int access)
+ rootblkno = rootopaque->btpo_next;
+ }
+
++ /* Note: can't check btpo_level on deleted pages */
+ if (rootopaque->btpo_level != rootlevel)
+ elog(ERROR, "root page %u of index \"%s\" has level %u, expected %u",
+ rootblkno, RelationGetRelationName(rel),
+@@ -652,6 +653,7 @@ _bt_gettrueroot(Relation rel)
+ rootblkno = rootopaque->btpo_next;
+ }
+
++ /* Note: can't check btpo_level on deleted pages */
+ if (rootopaque->btpo_level != rootlevel)
+ elog(ERROR, "root page %u of index \"%s\" has level %u, expected %u",
+ rootblkno, RelationGetRelationName(rel),
+diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
+index 1f40d40263e..600b9f12cdd 100644
+--- a/src/backend/access/nbtree/nbtsplitloc.c
++++ b/src/backend/access/nbtree/nbtsplitloc.c
+@@ -140,6 +140,7 @@ _bt_findsplitloc(Relation rel,
+ olddataitemstoleft,
+ perfectpenalty,
+ leaffillfactor;
++ int maxTupleEnd PG_USED_FOR_ASSERTS_ONLY;
+ FindSplitData state;
+ FindSplitStrat strategy;
+ ItemId itemid;
+@@ -153,6 +154,7 @@ _bt_findsplitloc(Relation rel,
+
+ opaque = BTPageGetOpaque(origpage);
+ maxoff = PageGetMaxOffsetNumber(origpage);
++ maxTupleEnd = ItemIdGetTupleEnd(PageGetItemId(origpage, P_HIKEY));
+
+ /* Total free space available on a btree page, after fixed overhead */
+ leftspace = rightspace =
+@@ -214,6 +216,18 @@ _bt_findsplitloc(Relation rel,
+ itemid = PageGetItemId(origpage, offnum);
+ itemsz = MAXALIGN(ItemIdGetLength(itemid)) + sizeof(ItemIdData);
+
++#ifdef USE_ASSERT_CHECKING
++
++ /*
++ * Ending of rightmost tuple on a page can be shifted relative to left
++ * boundary of BTPageOpaqueData due to conversion from EE96, which
++ * used different BTPageOpaqueData layout. It is only checked in the
++ * assert below.
++ */
++ if (maxTupleEnd < ItemIdGetTupleEnd(itemid))
++ maxTupleEnd = ItemIdGetTupleEnd(itemid);
++#endif
++
+ /*
+ * When item offset number is not newitemoff, neither side of the
+ * split can be newitem. Record a split after the previous data item
+@@ -248,7 +262,7 @@ _bt_findsplitloc(Relation rel,
+ * (Though only when it's possible that newitem will end up alone on new
+ * right page.)
+ */
+- Assert(olddataitemstoleft == olddataitemstotal);
++ Assert(olddataitemstoleft + ((PageHeader) origpage)->pd_special - maxTupleEnd == olddataitemstotal);
+ if (newitemoff > maxoff)
+ _bt_recsplitloc(&state, newitemoff, false, olddataitemstotal, 0);
+
+diff --git a/src/backend/access/rmgrdesc/gistdesc.c b/src/backend/access/rmgrdesc/gistdesc.c
+index b5d72a8e54d..a9f4b528d65 100644
+--- a/src/backend/access/rmgrdesc/gistdesc.c
++++ b/src/backend/access/rmgrdesc/gistdesc.c
+@@ -28,7 +28,7 @@ out_gistxlogPageReuse(StringInfo buf, gistxlogPageReuse *xlrec)
+ appendStringInfo(buf, "rel %u/%u/%u; blk %u; snapshotConflictHorizon %llu, isCatalogRel %c",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber, xlrec->block,
+- (unsigned long long) U64FromFullTransactionId(xlrec->snapshotConflictHorizon),
++ (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
+ xlrec->isCatalogRel ? 'T' : 'F');
+ }
+
+@@ -52,7 +52,7 @@ static void
+ out_gistxlogPageDelete(StringInfo buf, gistxlogPageDelete *xlrec)
+ {
+ appendStringInfo(buf, "deleteXid %llu; downlink %u",
+- (unsigned long long) U64FromFullTransactionId(xlrec->deleteXid),
++ (unsigned long long) XidFromFullTransactionId(xlrec->deleteXid),
+ xlrec->downlinkOffset);
+ }
+
+diff --git a/src/backend/access/rmgrdesc/heapdesc.c b/src/backend/access/rmgrdesc/heapdesc.c
+index 67a80cf5510..dabab6b809e 100644
+--- a/src/backend/access/rmgrdesc/heapdesc.c
++++ b/src/backend/access/rmgrdesc/heapdesc.c
+@@ -285,7 +285,7 @@ heap2_desc(StringInfo buf, XLogReaderState *record)
+ memcpy(&conflict_xid, rec + SizeOfHeapPrune, sizeof(TransactionId));
+
+ /* XXX 64-bit conflict xid? - a.alekseev */
+- appendStringInfo(buf, "snapshotConflictHorizon: %u",
++ appendStringInfo(buf, "snapshotConflictHorizon: %lu",
+ conflict_xid);
+ }
+
+@@ -392,6 +392,23 @@ heap2_desc(StringInfo buf, XLogReaderState *record)
+ }
+ }
+
++void
++heap3_desc(StringInfo buf, XLogReaderState *record)
++{
++ char *rec = XLogRecGetData(record);
++ uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
++
++ info &= XLOG_HEAP_OPMASK;
++ if (info == XLOG_HEAP3_BASE_SHIFT)
++ {
++ xl_heap_base_shift *xlrec = (xl_heap_base_shift *) rec;
++
++ appendStringInfo(buf, "%s delta %lld ",
++ xlrec->multi ? "MultiXactId" : "XactId",
++ (long long) xlrec->delta);
++ }
++}
++
+ const char *
+ heap_identify(uint8 info)
+ {
+@@ -475,3 +492,18 @@ heap2_identify(uint8 info)
+
+ return id;
+ }
++
++const char *
++heap3_identify(uint8 info)
++{
++ const char *id = NULL;
++
++ switch (info & ~XLR_INFO_MASK)
++ {
++ case XLOG_HEAP3_BASE_SHIFT:
++ id = "BASE_SHIFT";
++ break;
++ }
++
++ return id;
++}
+diff --git a/src/backend/access/rmgrdesc/nbtdesc.c b/src/backend/access/rmgrdesc/nbtdesc.c
+index 3c2f38df94a..2e553017a24 100644
+--- a/src/backend/access/rmgrdesc/nbtdesc.c
++++ b/src/backend/access/rmgrdesc/nbtdesc.c
+@@ -96,7 +96,7 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+
+ appendStringInfo(buf, "left: %u, right: %u, level: %u, safexid: %llu, ",
+ xlrec->leftsib, xlrec->rightsib, xlrec->level,
+- (unsigned long long) U64FromFullTransactionId(xlrec->safexid));
++ (unsigned long long) XidFromFullTransactionId(xlrec->safexid));
+ appendStringInfo(buf, "leafleft: %u, leafright: %u, leaftopparent: %u",
+ xlrec->leafleftsib, xlrec->leafrightsib,
+ xlrec->leaftopparent);
+@@ -116,7 +116,7 @@ btree_desc(StringInfo buf, XLogReaderState *record)
+ appendStringInfo(buf, "rel: %u/%u/%u, snapshotConflictHorizon: %llu, isCatalogRel: %c",
+ xlrec->locator.spcOid, xlrec->locator.dbOid,
+ xlrec->locator.relNumber,
+- (unsigned long long) U64FromFullTransactionId(xlrec->snapshotConflictHorizon),
++ (unsigned long long) XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
+ xlrec->isCatalogRel ? 'T' : 'F');
+ break;
+ }
+diff --git a/src/backend/access/rmgrdesc/xactdesc.c b/src/backend/access/rmgrdesc/xactdesc.c
+index d8ff6be3908..0f2b417a3ea 100644
+--- a/src/backend/access/rmgrdesc/xactdesc.c
++++ b/src/backend/access/rmgrdesc/xactdesc.c
+@@ -110,7 +110,8 @@ ParseCommitRecord(uint8 info, xl_xact_commit *xlrec, xl_xact_parsed_commit *pars
+ {
+ xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
+
+- parsed->twophase_xid = xl_twophase->xid;
++ parsed->twophase_xid =
++ ((uint64) xl_twophase->xid_hi << 32) | xl_twophase->xid_lo;
+
+ data += sizeof(xl_xact_twophase);
+
+@@ -205,7 +206,8 @@ ParseAbortRecord(uint8 info, xl_xact_abort *xlrec, xl_xact_parsed_abort *parsed)
+ {
+ xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
+
+- parsed->twophase_xid = xl_twophase->xid;
++ parsed->twophase_xid =
++ ((uint64) xl_twophase->xid_hi << 32) | xl_twophase->xid_lo;
+
+ data += sizeof(xl_xact_twophase);
+
+diff --git a/src/backend/access/rmgrdesc/xlogdesc.c b/src/backend/access/rmgrdesc/xlogdesc.c
+index a6e8e3dd230..ee42d95c6bf 100644
+--- a/src/backend/access/rmgrdesc/xlogdesc.c
++++ b/src/backend/access/rmgrdesc/xlogdesc.c
+@@ -75,7 +75,7 @@ xlog_desc(StringInfo buf, XLogReaderState *record)
+ checkpoint->PrevTimeLineID,
+ checkpoint->fullPageWrites ? "true" : "false",
+ get_wal_level_string(checkpoint->wal_level),
+- (unsigned long long) U64FromFullTransactionId(checkpoint->nextXid),
++ (unsigned long long) XidFromFullTransactionId(checkpoint->nextXid),
+ checkpoint->nextOid,
+ (unsigned long long) checkpoint->nextMulti,
+ (unsigned long long) checkpoint->nextMultiOffset,
+diff --git a/src/backend/access/transam/clog.c b/src/backend/access/transam/clog.c
+index db5a86116f9..c5062e24fbd 100644
+--- a/src/backend/access/transam/clog.c
++++ b/src/backend/access/transam/clog.c
+@@ -318,7 +318,7 @@ TransactionIdSetPageStatus(TransactionId xid, int nsubxids,
+ * sub-XIDs and all of the XIDs for which we're adjusting clog should be
+ * on the same page. Check those conditions, too.
+ */
+- if (all_xact_same_page && xid == MyProc->xid &&
++ if (all_xact_same_page && xid == pg_atomic_read_u64(&MyProc->xid) &&
+ nsubxids <= THRESHOLD_SUBTRANS_CLOG_OPT &&
+ nsubxids == MyProc->subxidStatus.count &&
+ (nsubxids == 0 ||
+@@ -1032,24 +1032,11 @@ TruncateCLOG(TransactionId oldestXact, Oid oldestxid_datoid)
+ SimpleLruTruncate(XactCtl, cutoffPage);
+ }
+
+-
+ /*
+ * Decide whether a CLOG page number is "older" for truncation purposes.
+ *
+- * We need to use comparison of TransactionIds here in order to do the right
+- * thing with wraparound XID arithmetic. However, TransactionIdPrecedes()
+- * would get weird about permanent xact IDs. So, offset both such that xid1,
+- * xid2, and xid2 + CLOG_XACTS_PER_PAGE - 1 are all normal XIDs; this offset
+- * is relevant to page 0 and to the page preceding page 0.
+- *
+- * The page containing oldestXact-2^31 is the important edge case. The
+- * portion of that page equaling or following oldestXact-2^31 is expendable,
+- * but the portion preceding oldestXact-2^31 is not. When oldestXact-2^31 is
+- * the first XID of a page and segment, the entire page and segment is
+- * expendable, and we could truncate the segment. Recognizing that case would
+- * require making oldestXact, not just the page containing oldestXact,
+- * available to this callback. The benefit would be rare and small, so we
+- * don't optimize that edge case.
++ * With 64xid this function is just "<", but we left it as a function in order
++ * for its calls remain "vanilla" like.
+ */
+ static bool
+ CLOGPagePrecedes(int64 page1, int64 page2)
+diff --git a/src/backend/access/transam/commit_ts.c b/src/backend/access/transam/commit_ts.c
+index a46602f91f9..aac738aea63 100644
+--- a/src/backend/access/transam/commit_ts.c
++++ b/src/backend/access/transam/commit_ts.c
+@@ -947,25 +947,6 @@ AdvanceOldestCommitTsXid(TransactionId oldestXact)
+ /*
+ * Decide whether a commitTS page number is "older" for truncation purposes.
+ * Analogous to CLOGPagePrecedes().
+- *
+- * At default BLCKSZ, (1 << 31) % COMMIT_TS_XACTS_PER_PAGE == 128. This
+- * introduces differences compared to CLOG and the other SLRUs having (1 <<
+- * 31) % per_page == 0. This function never tests exactly
+- * TransactionIdPrecedes(x-2^31, x). When the system reaches xidStopLimit,
+- * there are two possible counts of page boundaries between oldestXact and the
+- * latest XID assigned, depending on whether oldestXact is within the first
+- * 128 entries of its page. Since this function doesn't know the location of
+- * oldestXact within page2, it returns false for one page that actually is
+- * expendable. This is a wider (yet still negligible) version of the
+- * truncation opportunity that CLOGPagePrecedes() cannot recognize.
+- *
+- * For the sake of a worked example, number entries with decimal values such
+- * that page1==1 entries range from 1.0 to 1.999. Let N+0.15 be the number of
+- * pages that 2^31 entries will span (N is an integer). If oldestXact=N+2.1,
+- * then the final safe XID assignment leaves newestXact=1.95. We keep page 2,
+- * because entry=2.85 is the border that toggles whether entries precede the
+- * last entry of the oldestXact page. While page 2 is expendable at
+- * oldestXact=N+2.1, it would be precious at oldestXact=N+2.9.
+ */
+ static bool
+ CommitTsPagePrecedes(int64 page1, int64 page2)
+diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
+index 573702dd671..8add80f60f3 100644
+--- a/src/backend/access/transam/multixact.c
++++ b/src/backend/access/transam/multixact.c
+@@ -436,6 +436,9 @@ MultiXactIdCreate(TransactionId xid1, MultiXactStatus status1,
+ /* MultiXactIdSetOldestMember() must have been called already. */
+ Assert(MultiXactIdIsValid(OldestMemberMXactId[MyProcNumber]));
+
++ /* memset members array because with 64-bit xids it has a padding hole */
++ MemSet(members, 0, sizeof(members));
++
+ /*
+ * Note: unlike MultiXactIdExpand, we don't bother to check that both XIDs
+ * are still running. In typical usage, xid2 will be our own XID and the
+@@ -551,7 +554,7 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
+ * end of the loop.
+ */
+ newMembers = (MultiXactMember *)
+- palloc(sizeof(MultiXactMember) * (nmembers + 1));
++ palloc0(sizeof(MultiXactMember) * (nmembers + 1));
+
+ for (i = 0, j = 0; i < nmembers; i++)
+ {
+@@ -955,8 +958,8 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
+ for (i = 0; i < nmembers; i++, offset++)
+ {
+ TransactionId *memberptr;
+- uint32 *flagsptr;
+- uint32 flagsval;
++ uint64 *flagsptr;
++ uint64 flagsval;
+ int bshift;
+ int flagsoff;
+ int memberoff;
+@@ -993,12 +996,12 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
+
+ *memberptr = members[i].xid;
+
+- flagsptr = (uint32 *)
++ flagsptr = (uint64 *)
+ (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
+
+ flagsval = *flagsptr;
+- flagsval &= ~(((1 << MXACT_MEMBER_BITS_PER_XACT) - 1) << bshift);
+- flagsval |= (members[i].status << bshift);
++ flagsval &= ~((uint64) ((1ULL << MXACT_MEMBER_BITS_PER_XACT) - 1) << bshift);
++ flagsval |= ((uint64) members[i].status << bshift);
+ *flagsptr = flagsval;
+
+ MultiXactMemberCtl->shared->page_dirty[slotno] = true;
+@@ -1117,8 +1120,8 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+ /* complain even if that DB has disappeared */
+ if (oldest_datname)
+ ereport(WARNING,
+- (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
+- "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
++ (errmsg_plural("database \"%s\" must be vacuumed before %lu more MultiXactId is used",
++ "database \"%s\" must be vacuumed before %lu more MultiXactIds are used",
+ multiWrapLimit - result,
+ oldest_datname,
+ multiWrapLimit - result),
+@@ -1126,8 +1129,8 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
+ "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+ else
+ ereport(WARNING,
+- (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",
+- "database with OID %u must be vacuumed before %u more MultiXactIds are used",
++ (errmsg_plural("database with OID %u must be vacuumed before %lu more MultiXactId is used",
++ "database with OID %u must be vacuumed before %lu more MultiXactIds are used",
+ multiWrapLimit - result,
+ oldest_datoid,
+ multiWrapLimit - result),
+@@ -1357,7 +1360,10 @@ retry:
+ offptr += entryno;
+ offset = *offptr;
+
+- Assert(offset != 0);
++ if (offset == 0)
++ ereport(ERROR,
++ (errmsg("found invalid zero offset in multixact %llu",
++ (unsigned long long) multi)));
+
+ /*
+ * Use the same increment rule as GetNewMultiXactId(), that is, don't
+@@ -1432,14 +1438,14 @@ retry:
+ if (slept)
+ ConditionVariableCancelSleep();
+
+- ptr = (MultiXactMember *) palloc(length * sizeof(MultiXactMember));
++ ptr = (MultiXactMember *) palloc0(length * sizeof(MultiXactMember));
+
+ truelength = 0;
+ prev_pageno = -1;
+ for (int i = 0; i < length; i++, offset++)
+ {
+ TransactionId *xactptr;
+- uint32 *flagsptr;
++ uint64 *flagsptr;
+ int flagsoff;
+ int bshift;
+ int memberoff;
+@@ -1481,7 +1487,7 @@ retry:
+
+ flagsoff = MXOffsetToFlagsOffset(offset);
+ bshift = MXOffsetToFlagsBitShift(offset);
+- flagsptr = (uint32 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
++ flagsptr = (uint64 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
+
+ ptr[truelength].xid = *xactptr;
+ ptr[truelength].status = (*flagsptr >> bshift) & MXACT_MEMBER_XACT_BITMASK;
+@@ -2363,7 +2369,7 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
+
+ /* Log the info */
+ ereport(DEBUG1,
+- (errmsg_internal("MultiXactId wrap limit is %u, limited by database with OID %u",
++ (errmsg_internal("MultiXactId wrap limit is %lu, limited by database with OID %u",
+ multiWrapLimit, oldest_datoid)));
+
+ /*
+@@ -2413,8 +2419,8 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
+
+ if (oldest_datname)
+ ereport(WARNING,
+- (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
+- "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
++ (errmsg_plural("database \"%s\" must be vacuumed before %lu more MultiXactId is used",
++ "database \"%s\" must be vacuumed before %lu more MultiXactIds are used",
+ multiWrapLimit - curMulti,
+ oldest_datname,
+ multiWrapLimit - curMulti),
+@@ -2422,8 +2428,8 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
+ "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+ else
+ ereport(WARNING,
+- (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",
+- "database with OID %u must be vacuumed before %u more MultiXactIds are used",
++ (errmsg_plural("database with OID %u must be vacuumed before %lu more MultiXactId is used",
++ "database with OID %u must be vacuumed before %lu more MultiXactIds are used",
+ multiWrapLimit - curMulti,
+ oldest_datoid,
+ multiWrapLimit - curMulti),
+@@ -2529,7 +2535,7 @@ ExtendMultiXactMember(MultiXactOffset offset, int nmembers)
+ {
+ int flagsoff;
+ int flagsbit;
+- uint32 difference;
++ uint64 difference;
+
+ /*
+ * Only zero when at first entry of a page.
+@@ -3058,7 +3064,7 @@ MultiXactOffsetPagePrecedes(int64 page1, int64 page2)
+
+ /*
+ * Decide whether a MultiXactMember page number is "older" for truncation
+- * purposes. There is no "invalid offset number" so use the numbers verbatim.
++ * purposes. There is no "invalid offset number" so use the numbers verbatim.
+ */
+ static bool
+ MultiXactMemberPagePrecedes(int64 page1, int64 page2)
+@@ -3083,7 +3089,7 @@ MultiXactMemberPagePrecedes(int64 page1, int64 page2)
+ bool
+ MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
+ {
+- int32 diff = (int32) (multi1 - multi2);
++ int64 diff = (int64) (multi1 - multi2);
+
+ return (diff < 0);
+ }
+@@ -3097,7 +3103,7 @@ MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
+ bool
+ MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
+ {
+- int32 diff = (int32) (multi1 - multi2);
++ int64 diff = (int64) (multi1 - multi2);
+
+ return (diff <= 0);
+ }
+diff --git a/src/backend/access/transam/slru.c b/src/backend/access/transam/slru.c
+index 35a930810b1..915bba1bb34 100644
+--- a/src/backend/access/transam/slru.c
++++ b/src/backend/access/transam/slru.c
+@@ -1637,7 +1637,7 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ * must not assign.
+ */
+ lhs = per_page + offset; /* skip first page to avoid non-normal XIDs */
+- rhs = lhs + (1U << 31);
++ rhs = lhs + (1ULL << 63);
+ Assert(TransactionIdPrecedes(lhs, rhs));
+ Assert(TransactionIdPrecedes(rhs, lhs));
+ Assert(!TransactionIdPrecedes(lhs - 1, rhs));
+@@ -1653,13 +1653,14 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ Assert(ctl->PagePrecedes(rhs / per_page, (lhs - 3 * per_page) / per_page));
+ Assert(ctl->PagePrecedes(rhs / per_page, (lhs - 2 * per_page) / per_page));
+ Assert(ctl->PagePrecedes(rhs / per_page, (lhs - 1 * per_page) / per_page)
+- || (1U << 31) % per_page != 0); /* See CommitTsPagePrecedes() */
++ || (1ULL << 63) % per_page != 0); /* See CommitTsPagePrecedes() */
+ Assert(ctl->PagePrecedes((lhs + 1 * per_page) / per_page, rhs / per_page)
+- || (1U << 31) % per_page != 0);
++ || (1ULL << 63) % per_page != 0);
+ Assert(ctl->PagePrecedes((lhs + 2 * per_page) / per_page, rhs / per_page));
+ Assert(ctl->PagePrecedes((lhs + 3 * per_page) / per_page, rhs / per_page));
+ Assert(!ctl->PagePrecedes(rhs / per_page, (lhs + per_page) / per_page));
+
++
+ /*
+ * GetNewTransactionId() has assigned the last XID it can safely use, and
+ * that XID is in the *LAST* page of the second segment. We must not
+@@ -1669,7 +1670,7 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ newestXact = newestPage * per_page + offset;
+ Assert(newestXact / per_page == newestPage);
+ oldestXact = newestXact + 1;
+- oldestXact -= 1U << 31;
++ oldestXact -= 1ULL << 63;
+ oldestPage = oldestXact / per_page;
+ Assert(!SlruMayDeleteSegment(ctl,
+ (newestPage -
+@@ -1685,7 +1686,7 @@ SlruPagePrecedesTestOffset(SlruCtl ctl, int per_page, uint32 offset)
+ newestXact = newestPage * per_page + offset;
+ Assert(newestXact / per_page == newestPage);
+ oldestXact = newestXact + 1;
+- oldestXact -= 1U << 31;
++ oldestXact -= 1ULL << 63;
+ oldestPage = oldestXact / per_page;
+ Assert(!SlruMayDeleteSegment(ctl,
+ (newestPage -
+diff --git a/src/backend/access/transam/subtrans.c b/src/backend/access/transam/subtrans.c
+index 9d762b75c2b..c7bb406fa16 100644
+--- a/src/backend/access/transam/subtrans.c
++++ b/src/backend/access/transam/subtrans.c
+@@ -271,12 +271,17 @@ void
+ BootStrapSUBTRANS(void)
+ {
+ int slotno;
+- LWLock *lock = SimpleLruGetBankLock(SubTransCtl, 0);
++ int64 pageno;
++ LWLock *lock;
++
++ pageno = TransactionIdToPage(XidFromFullTransactionId(TransamVariables->nextXid));
++
++ lock = SimpleLruGetBankLock(SubTransCtl, 0);
+
+ LWLockAcquire(lock, LW_EXCLUSIVE);
+
+ /* Create and zero the first page of the subtrans log */
+- slotno = ZeroSUBTRANSPage(0);
++ slotno = ZeroSUBTRANSPage(pageno);
+
+ /* Make sure it's written out */
+ SimpleLruWritePage(SubTransCtl, slotno);
+@@ -341,9 +346,6 @@ StartupSUBTRANS(TransactionId oldestActiveXID)
+ break;
+
+ startPage++;
+- /* must account for wraparound */
+- if (startPage > TransactionIdToPage(MaxTransactionId))
+- startPage = 0;
+ }
+
+ LWLockRelease(lock);
+@@ -421,6 +423,7 @@ TruncateSUBTRANS(TransactionId oldestXact)
+ * a page and oldestXact == next XID. In that case, if we didn't subtract
+ * one, we'd trigger SimpleLruTruncate's wraparound detection.
+ */
++
+ TransactionIdRetreat(oldestXact);
+ cutoffPage = TransactionIdToPage(oldestXact);
+
+diff --git a/src/backend/access/transam/transam.c b/src/backend/access/transam/transam.c
+index bf3e5ac3272..63e06177146 100644
+--- a/src/backend/access/transam/transam.c
++++ b/src/backend/access/transam/transam.c
+@@ -281,14 +281,14 @@ TransactionIdPrecedes(TransactionId id1, TransactionId id2)
+ {
+ /*
+ * If either ID is a permanent XID then we can just do unsigned
+- * comparison. If both are normal, do a modulo-2^32 comparison.
++ * comparison. If both are normal, do a modulo-2^64 comparison.
+ */
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 < id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff < 0);
+ }
+
+@@ -298,12 +298,12 @@ TransactionIdPrecedes(TransactionId id1, TransactionId id2)
+ bool
+ TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
+ {
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 <= id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff <= 0);
+ }
+
+@@ -313,12 +313,12 @@ TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
+ bool
+ TransactionIdFollows(TransactionId id1, TransactionId id2)
+ {
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 > id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff > 0);
+ }
+
+@@ -328,12 +328,12 @@ TransactionIdFollows(TransactionId id1, TransactionId id2)
+ bool
+ TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
+ {
+- int32 diff;
++ int64 diff;
+
+ if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+ return (id1 >= id2);
+
+- diff = (int32) (id1 - id2);
++ diff = (int64) (id1 - id2);
+ return (diff >= 0);
+ }
+
+diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
+index 020ed6072d9..578eff7aac2 100644
+--- a/src/backend/access/transam/twophase.c
++++ b/src/backend/access/transam/twophase.c
+@@ -458,8 +458,8 @@ MarkAsPreparingGuts(GlobalTransaction gxact, TransactionId xid, const char *gid,
+ proc->vxid.lxid = xid;
+ proc->vxid.procNumber = INVALID_PROC_NUMBER;
+ }
+- proc->xid = xid;
+- Assert(proc->xmin == InvalidTransactionId);
++ pg_atomic_write_u64(&proc->xid, xid);
++ Assert(pg_atomic_read_u64(&proc->xmin) == InvalidTransactionId);
+ proc->delayChkptFlags = 0;
+ proc->statusFlags = 0;
+ proc->pid = 0;
+@@ -774,7 +774,7 @@ pg_prepared_xact(PG_FUNCTION_ARGS)
+ * Form tuple with appropriate data.
+ */
+
+- values[0] = TransactionIdGetDatum(proc->xid);
++ values[0] = TransactionIdGetDatum(pg_atomic_read_u64(&proc->xid));
+ values[1] = CStringGetTextDatum(gxact->gid);
+ values[2] = TimestampTzGetDatum(gxact->prepared_at);
+ values[3] = ObjectIdGetDatum(gxact->owner);
+@@ -927,46 +927,8 @@ TwoPhaseGetDummyProc(TransactionId xid, bool lock_held)
+ /* State file support */
+ /************************************************************************/
+
+-/*
+- * Compute the FullTransactionId for the given TransactionId.
+- *
+- * The wrap logic is safe here because the span of active xids cannot exceed one
+- * epoch at any given time.
+- */
+-static inline FullTransactionId
+-AdjustToFullTransactionId(TransactionId xid)
+-{
+- FullTransactionId nextFullXid;
+- TransactionId nextXid;
+- uint32 epoch;
+-
+- Assert(TransactionIdIsValid(xid));
+-
+- LWLockAcquire(XidGenLock, LW_SHARED);
+- nextFullXid = TransamVariables->nextXid;
+- LWLockRelease(XidGenLock);
+-
+- nextXid = XidFromFullTransactionId(nextFullXid);
+- epoch = EpochFromFullTransactionId(nextFullXid);
+- if (unlikely(xid > nextXid))
+- {
+- /* Wraparound occurred, must be from a prev epoch. */
+- Assert(epoch > 0);
+- epoch--;
+- }
+-
+- return FullTransactionIdFromEpochAndXid(epoch, xid);
+-}
+-
+-static inline int
+-TwoPhaseFilePath(char *path, TransactionId xid)
+-{
+- FullTransactionId fxid = AdjustToFullTransactionId(xid);
+-
+- return snprintf(path, MAXPGPATH, TWOPHASE_DIR "/%08X%08X",
+- EpochFromFullTransactionId(fxid),
+- XidFromFullTransactionId(fxid));
+-}
++#define TwoPhaseFilePath(path, xid) \
++ snprintf(path, MAXPGPATH, TWOPHASE_DIR "/%016llX", (unsigned long long) xid)
+
+ /*
+ * 2PC state file format:
+@@ -1915,11 +1877,9 @@ restoreTwoPhaseData(void)
+ strspn(clde->d_name, "0123456789ABCDEF") == 16)
+ {
+ TransactionId xid;
+- FullTransactionId fxid;
+ char *buf;
+
+- fxid = FullTransactionIdFromU64(strtou64(clde->d_name, NULL, 16));
+- xid = XidFromFullTransactionId(fxid);
++ xid = (TransactionId) strtou64(clde->d_name, NULL, 16);
+
+ buf = ProcessTwoPhaseBuffer(xid, InvalidXLogRecPtr,
+ true, false, false);
+@@ -2250,7 +2210,6 @@ ProcessTwoPhaseBuffer(TransactionId xid,
+
+ if (fromdisk)
+ {
+- /* Read and validate file */
+ buf = ReadTwoPhaseFile(xid, false);
+ }
+ else
+@@ -2725,7 +2684,7 @@ IsTwoPhaseTransactionGidForSubid(Oid subid, char *gid)
+ char gid_tmp[GIDSIZE];
+
+ /* Extract the subid and xid from the given GID */
+- ret = sscanf(gid, "pg_gid_%u_%u", &subid_from_gid, &xid_from_gid);
++ ret = sscanf(gid, "pg_gid_%u_%lu", &subid_from_gid, &xid_from_gid);
+
+ /*
+ * Check that the given GID has expected format, and at least the subid
+diff --git a/src/backend/access/transam/varsup.c b/src/backend/access/transam/varsup.c
+index e595eb1ad9f..9eb88888732 100644
+--- a/src/backend/access/transam/varsup.c
++++ b/src/backend/access/transam/varsup.c
+@@ -93,9 +93,9 @@ GetNewTransactionId(bool isSubXact)
+ if (IsBootstrapProcessingMode())
+ {
+ Assert(!isSubXact);
+- MyProc->xid = BootstrapTransactionId;
+- ProcGlobal->xids[MyProc->pgxactoff] = BootstrapTransactionId;
+- return FullTransactionIdFromEpochAndXid(0, BootstrapTransactionId);
++ pg_atomic_write_u64(&MyProc->xid, BootstrapTransactionId);
++ pg_atomic_write_u64(&ProcGlobal->xids[MyProc->pgxactoff], BootstrapTransactionId);
++ return FullTransactionIdFromXid(BootstrapTransactionId);
+ }
+
+ /* safety check, we should never get this far in a HS standby */
+@@ -107,19 +107,6 @@ GetNewTransactionId(bool isSubXact)
+ full_xid = TransamVariables->nextXid;
+ xid = XidFromFullTransactionId(full_xid);
+
+- /*----------
+- * Check to see if it's safe to assign another XID. This protects against
+- * catastrophic data loss due to XID wraparound. The basic rules are:
+- *
+- * If we're past xidVacLimit, start trying to force autovacuum cycles.
+- * If we're past xidWarnLimit, start issuing warnings.
+- * If we're past xidStopLimit, refuse to execute transactions, unless
+- * we are running in single-user mode (which gives an escape hatch
+- * to the DBA who somehow got past the earlier defenses).
+- *
+- * Note that this coding also appears in GetNewMultiXactId.
+- *----------
+- */
+ if (TransactionIdFollowsOrEquals(xid, TransamVariables->xidVacLimit))
+ {
+ /*
+@@ -129,11 +116,6 @@ GetNewTransactionId(bool isSubXact)
+ * possibility of deadlock while doing get_database_name(). First,
+ * copy all the shared values we'll need in this path.
+ */
+- TransactionId xidWarnLimit = TransamVariables->xidWarnLimit;
+- TransactionId xidStopLimit = TransamVariables->xidStopLimit;
+- TransactionId xidWrapLimit = TransamVariables->xidWrapLimit;
+- Oid oldest_datoid = TransamVariables->oldestXidDB;
+-
+ LWLockRelease(XidGenLock);
+
+ /*
+@@ -144,48 +126,6 @@ GetNewTransactionId(bool isSubXact)
+ if (IsUnderPostmaster && (xid % 65536) == 0)
+ SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+
+- if (IsUnderPostmaster &&
+- TransactionIdFollowsOrEquals(xid, xidStopLimit))
+- {
+- char *oldest_datname = get_database_name(oldest_datoid);
+-
+- /* complain even if that DB has disappeared */
+- if (oldest_datname)
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("database is not accepting commands that assign new transaction IDs to avoid wraparound data loss in database \"%s\"",
+- oldest_datname),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(ERROR,
+- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+- errmsg("database is not accepting commands that assign new transaction IDs to avoid wraparound data loss in database with OID %u",
+- oldest_datoid),
+- errhint("Execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+- else if (TransactionIdFollowsOrEquals(xid, xidWarnLimit))
+- {
+- char *oldest_datname = get_database_name(oldest_datoid);
+-
+- /* complain even if that DB has disappeared */
+- if (oldest_datname)
+- ereport(WARNING,
+- (errmsg("database \"%s\" must be vacuumed within %llu transactions",
+- oldest_datname,
+- (unsigned long long) xidWrapLimit - xid),
+- errhint("To avoid transaction ID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(WARNING,
+- (errmsg("database with OID %u must be vacuumed within %llu transactions",
+- oldest_datoid,
+- (unsigned long long) xidWrapLimit - xid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+-
+ /* Re-acquire lock and start over */
+ LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
+ full_xid = TransamVariables->nextXid;
+@@ -255,8 +195,8 @@ GetNewTransactionId(bool isSubXact)
+ Assert(!MyProc->subxidStatus.overflowed);
+
+ /* LWLockRelease acts as barrier */
+- MyProc->xid = xid;
+- ProcGlobal->xids[MyProc->pgxactoff] = xid;
++ pg_atomic_write_u64(&MyProc->xid, xid);
++ pg_atomic_write_u64(&ProcGlobal->xids[MyProc->pgxactoff], xid);
+ }
+ else
+ {
+@@ -297,7 +237,7 @@ ReadNextFullTransactionId(void)
+ }
+
+ /*
+- * Advance nextXid to the value after a given xid. The epoch is inferred.
++ * Advance nextXid to the value after a given xid.
+ * This must only be called during recovery or from two-phase start-up code.
+ */
+ void
+@@ -305,7 +245,6 @@ AdvanceNextFullTransactionIdPastXid(TransactionId xid)
+ {
+ FullTransactionId newNextFullXid;
+ TransactionId next_xid;
+- uint32 epoch;
+
+ /*
+ * It is safe to read nextXid without a lock, because this is only called
+@@ -319,19 +258,9 @@ AdvanceNextFullTransactionIdPastXid(TransactionId xid)
+ if (!TransactionIdFollowsOrEquals(xid, next_xid))
+ return;
+
+- /*
+- * Compute the FullTransactionId that comes after the given xid. To do
+- * this, we preserve the existing epoch, but detect when we've wrapped
+- * into a new epoch. This is necessary because WAL records and 2PC state
+- * currently contain 32 bit xids. The wrap logic is safe in those cases
+- * because the span of active xids cannot exceed one epoch at any given
+- * point in the WAL stream.
+- */
++ /* Compute the FullTransactionId that comes after the given xid. */
+ TransactionIdAdvance(xid);
+- epoch = EpochFromFullTransactionId(TransamVariables->nextXid);
+- if (unlikely(xid < next_xid))
+- ++epoch;
+- newNextFullXid = FullTransactionIdFromEpochAndXid(epoch, xid);
++ newNextFullXid = FullTransactionIdFromXid(xid);
+
+ /*
+ * We still need to take a lock to modify the value when there are
+@@ -372,61 +301,14 @@ void
+ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+ {
+ TransactionId xidVacLimit;
+- TransactionId xidWarnLimit;
+- TransactionId xidStopLimit;
+- TransactionId xidWrapLimit;
+ TransactionId curXid;
+
+ Assert(TransactionIdIsNormal(oldest_datfrozenxid));
+
+- /*
+- * The place where we actually get into deep trouble is halfway around
+- * from the oldest potentially-existing XID. (This calculation is
+- * probably off by one or two counts, because the special XIDs reduce the
+- * size of the loop a little bit. But we throw in plenty of slop below,
+- * so it doesn't matter.)
+- */
+- xidWrapLimit = oldest_datfrozenxid + (MaxTransactionId >> 1);
+- if (xidWrapLimit < FirstNormalTransactionId)
+- xidWrapLimit += FirstNormalTransactionId;
+-
+- /*
+- * We'll refuse to continue assigning XIDs in interactive mode once we get
+- * within 3M transactions of data loss. This leaves lots of room for the
+- * DBA to fool around fixing things in a standalone backend, while not
+- * being significant compared to total XID space. (VACUUM requires an XID
+- * if it truncates at wal_level!=minimal. "VACUUM (ANALYZE)", which a DBA
+- * might do by reflex, assigns an XID. Hence, we had better be sure
+- * there's lots of XIDs left...) Also, at default BLCKSZ, this leaves two
+- * completely-idle segments. In the event of edge-case bugs involving
+- * page or segment arithmetic, idle segments render the bugs unreachable
+- * outside of single-user mode.
+- */
+- xidStopLimit = xidWrapLimit - 3000000;
+- if (xidStopLimit < FirstNormalTransactionId)
+- xidStopLimit -= FirstNormalTransactionId;
+-
+- /*
+- * We'll start complaining loudly when we get within 40M transactions of
+- * data loss. This is kind of arbitrary, but if you let your gas gauge
+- * get down to 2% of full, would you be looking for the next gas station?
+- * We need to be fairly liberal about this number because there are lots
+- * of scenarios where most transactions are done by automatic clients that
+- * won't pay attention to warnings. (No, we're not gonna make this
+- * configurable. If you know enough to configure it, you know enough to
+- * not get in this kind of trouble in the first place.)
+- */
+- xidWarnLimit = xidWrapLimit - 40000000;
+- if (xidWarnLimit < FirstNormalTransactionId)
+- xidWarnLimit -= FirstNormalTransactionId;
+-
+ /*
+ * We'll start trying to force autovacuums when oldest_datfrozenxid gets
+ * to be more than autovacuum_freeze_max_age transactions old.
+ *
+- * Note: guc.c ensures that autovacuum_freeze_max_age is in a sane range,
+- * so that xidVacLimit will be well before xidWarnLimit.
+- *
+ * Note: autovacuum_freeze_max_age is a PGC_POSTMASTER parameter so that
+ * we don't have to worry about dealing with on-the-fly changes in its
+ * value. It doesn't look practical to update shared state from a GUC
+@@ -443,18 +325,10 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+ LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
+ TransamVariables->oldestXid = oldest_datfrozenxid;
+ TransamVariables->xidVacLimit = xidVacLimit;
+- TransamVariables->xidWarnLimit = xidWarnLimit;
+- TransamVariables->xidStopLimit = xidStopLimit;
+- TransamVariables->xidWrapLimit = xidWrapLimit;
+ TransamVariables->oldestXidDB = oldest_datoid;
+ curXid = XidFromFullTransactionId(TransamVariables->nextXid);
+ LWLockRelease(XidGenLock);
+
+- /* Log the info */
+- ereport(DEBUG1,
+- (errmsg_internal("transaction ID wrap limit is %llu, limited by database with OID %u",
+- (unsigned long long) xidWrapLimit, oldest_datoid)));
+-
+ /*
+ * If past the autovacuum force point, immediately signal an autovac
+ * request. The reason for this is that autovac only processes one
+@@ -465,41 +339,6 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
+ if (TransactionIdFollowsOrEquals(curXid, xidVacLimit) &&
+ IsUnderPostmaster && !InRecovery)
+ SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
+-
+- /* Give an immediate warning if past the wrap warn point */
+- if (TransactionIdFollowsOrEquals(curXid, xidWarnLimit) && !InRecovery)
+- {
+- char *oldest_datname;
+-
+- /*
+- * We can be called when not inside a transaction, for example during
+- * StartupXLOG(). In such a case we cannot do database access, so we
+- * must just report the oldest DB's OID.
+- *
+- * Note: it's also possible that get_database_name fails and returns
+- * NULL, for example because the database just got dropped. We'll
+- * still warn, even though the warning might now be unnecessary.
+- */
+- if (IsTransactionState())
+- oldest_datname = get_database_name(oldest_datoid);
+- else
+- oldest_datname = NULL;
+-
+- if (oldest_datname)
+- ereport(WARNING,
+- (errmsg("database \"%s\" must be vacuumed within %llu transactions",
+- oldest_datname,
+- (unsigned long long) xidWrapLimit - curXid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- else
+- ereport(WARNING,
+- (errmsg("database with OID %u must be vacuumed within %llu transactions",
+- oldest_datoid,
+- (unsigned long long) xidWrapLimit - curXid),
+- errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
+- "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
+- }
+ }
+
+
+diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
+index 946f79b59da..51e28a5d8f3 100644
+--- a/src/backend/access/transam/xact.c
++++ b/src/backend/access/transam/xact.c
+@@ -5866,6 +5866,17 @@ XactLogCommitRecord(TimestampTz commit_time,
+ xl_subxacts.nsubxacts = nsubxacts;
+ }
+
++ if (TransactionIdIsValid(twophase_xid))
++ {
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
++ xl_twophase.xid_lo = (uint32) (twophase_xid & 0xFFFFFFFF);
++ xl_twophase.xid_hi = (uint32) (twophase_xid >> 32);
++ Assert(twophase_gid != NULL);
++
++ if (XLogLogicalInfoActive())
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
++ }
++
+ if (nrels > 0)
+ {
+ xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
+@@ -5885,16 +5896,6 @@ XactLogCommitRecord(TimestampTz commit_time,
+ xl_invals.nmsgs = nmsgs;
+ }
+
+- if (TransactionIdIsValid(twophase_xid))
+- {
+- xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
+- xl_twophase.xid = twophase_xid;
+- Assert(twophase_gid != NULL);
+-
+- if (XLogLogicalInfoActive())
+- xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
+- }
+-
+ /* dump transaction origin information */
+ if (replorigin_session_origin != InvalidRepOriginId)
+ {
+@@ -6015,6 +6016,17 @@ XactLogAbortRecord(TimestampTz abort_time,
+ xl_subxacts.nsubxacts = nsubxacts;
+ }
+
++ if (TransactionIdIsValid(twophase_xid))
++ {
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
++ xl_twophase.xid_lo = (uint32) (twophase_xid & 0xFFFFFFFF);
++ xl_twophase.xid_hi = (uint32) (twophase_xid >> 32);
++ Assert(twophase_gid != NULL);
++
++ if (XLogLogicalInfoActive())
++ xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
++ }
++
+ if (nrels > 0)
+ {
+ xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
+@@ -6031,7 +6043,8 @@ XactLogAbortRecord(TimestampTz abort_time,
+ if (TransactionIdIsValid(twophase_xid))
+ {
+ xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
+- xl_twophase.xid = twophase_xid;
++ xl_twophase.xid_lo = (uint32) (twophase_xid & 0xFFFFFFFF);
++ xl_twophase.xid_hi = (uint32) (twophase_xid >> 32);
+ Assert(twophase_gid != NULL);
+
+ if (XLogLogicalInfoActive())
+diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
+index 6f58412bcab..51cc3bd62aa 100644
+--- a/src/backend/access/transam/xlog.c
++++ b/src/backend/access/transam/xlog.c
+@@ -5079,8 +5079,7 @@ BootStrapXLOG(uint32 data_checksum_version)
+ checkPoint.PrevTimeLineID = BootstrapTimeLineID;
+ checkPoint.fullPageWrites = fullPageWrites;
+ checkPoint.wal_level = wal_level;
+- checkPoint.nextXid =
+- FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
++ checkPoint.nextXid = FullTransactionIdFromXid(FirstNormalTransactionId);
+ checkPoint.nextOid = FirstGenbkiObjectId;
+ checkPoint.nextMulti = FirstMultiXactId;
+ checkPoint.nextMultiOffset = 0;
+@@ -7268,7 +7267,7 @@ CreateCheckPoint(int flags)
+ UpdateControlFile();
+ LWLockRelease(ControlFileLock);
+
+- /* Update shared-memory copy of checkpoint XID/epoch */
++ /* Update shared-memory copy of checkpoint XID/base */
+ SpinLockAcquire(&XLogCtl->info_lck);
+ XLogCtl->ckptFullXid = checkPoint.nextXid;
+ SpinLockRelease(&XLogCtl->info_lck);
+@@ -8342,7 +8341,7 @@ xlog_redo(XLogReaderState *record)
+ ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
+ LWLockRelease(ControlFileLock);
+
+- /* Update shared-memory copy of checkpoint XID/epoch */
++ /* Update shared-memory copy of checkpoint XID/base */
+ SpinLockAcquire(&XLogCtl->info_lck);
+ XLogCtl->ckptFullXid = checkPoint.nextXid;
+ SpinLockRelease(&XLogCtl->info_lck);
+@@ -8403,7 +8402,7 @@ xlog_redo(XLogReaderState *record)
+ ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
+ LWLockRelease(ControlFileLock);
+
+- /* Update shared-memory copy of checkpoint XID/epoch */
++ /* Update shared-memory copy of checkpoint XID/base */
+ SpinLockAcquire(&XLogCtl->info_lck);
+ XLogCtl->ckptFullXid = checkPoint.nextXid;
+ SpinLockRelease(&XLogCtl->info_lck);
+diff --git a/src/backend/access/transam/xloginsert.c b/src/backend/access/transam/xloginsert.c
+index f92d0626082..0625e420724 100644
+--- a/src/backend/access/transam/xloginsert.c
++++ b/src/backend/access/transam/xloginsert.c
+@@ -273,6 +273,11 @@ XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
+ BufferGetTag(buffer, ®buf->rlocator, ®buf->forkno, ®buf->block);
+ regbuf->page = BufferGetPage(buffer);
+ regbuf->flags = flags;
++ if (IsBufferConverted(buffer))
++ {
++ regbuf->flags |= REGBUF_CONVERTED;
++ MarkBufferConverted(buffer, false);
++ }
+ regbuf->rdata_tail = (XLogRecData *) ®buf->rdata_head;
+ regbuf->rdata_len = 0;
+
+@@ -606,6 +611,8 @@ XLogRecordAssemble(RmgrId rmid, uint8 info,
+ needs_backup = true;
+ else if (regbuf->flags & REGBUF_NO_IMAGE)
+ needs_backup = false;
++ else if (regbuf->flags & REGBUF_CONVERTED)
++ needs_backup = true;
+ else if (!doPageWrites)
+ needs_backup = false;
+ else
+diff --git a/src/backend/access/transam/xlogreader.c b/src/backend/access/transam/xlogreader.c
+index 0c5e040a946..556e815655e 100644
+--- a/src/backend/access/transam/xlogreader.c
++++ b/src/backend/access/transam/xlogreader.c
+@@ -2157,37 +2157,3 @@ RestoreBlockImage(XLogReaderState *record, uint8 block_id, char *page)
+
+ return true;
+ }
+-
+-#ifndef FRONTEND
+-
+-/*
+- * Extract the FullTransactionId from a WAL record.
+- */
+-FullTransactionId
+-XLogRecGetFullXid(XLogReaderState *record)
+-{
+- TransactionId xid,
+- next_xid;
+- uint32 epoch;
+-
+- /*
+- * This function is only safe during replay, because it depends on the
+- * replay state. See AdvanceNextFullTransactionIdPastXid() for more.
+- */
+- Assert(AmStartupProcess() || !IsUnderPostmaster);
+-
+- xid = XLogRecGetXid(record);
+- next_xid = XidFromFullTransactionId(TransamVariables->nextXid);
+- epoch = EpochFromFullTransactionId(TransamVariables->nextXid);
+-
+- /*
+- * If xid is numerically greater than next_xid, it has to be from the last
+- * epoch.
+- */
+- if (unlikely(xid > next_xid))
+- --epoch;
+-
+- return FullTransactionIdFromEpochAndXid(epoch, xid);
+-}
+-
+-#endif
+diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c
+index a5217773ffc..261b834e484 100644
+--- a/src/backend/bootstrap/bootstrap.c
++++ b/src/backend/bootstrap/bootstrap.c
+@@ -115,7 +115,7 @@ static const struct typinfo TypInfo[] = {
+ F_OIDIN, F_OIDOUT},
+ {"tid", TIDOID, 0, 6, false, TYPALIGN_SHORT, TYPSTORAGE_PLAIN, InvalidOid,
+ F_TIDIN, F_TIDOUT},
+- {"xid", XIDOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
++ {"xid", XIDOID, 0, 8, FLOAT8PASSBYVAL, TYPALIGN_XID, TYPSTORAGE_PLAIN, InvalidOid,
+ F_XIDIN, F_XIDOUT},
+ {"cid", CIDOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
+ F_CIDIN, F_CIDOUT},
+diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
+index d7b88b61dcc..466e2544e0e 100644
+--- a/src/backend/catalog/heap.c
++++ b/src/backend/catalog/heap.c
+@@ -160,8 +160,8 @@ static const FormData_pg_attribute a2 = {
+ .attnum = MinTransactionIdAttributeNumber,
+ .attcacheoff = -1,
+ .atttypmod = -1,
+- .attbyval = true,
+- .attalign = TYPALIGN_INT,
++ .attbyval = FLOAT8PASSBYVAL,
++ .attalign = TYPALIGN_XID,
+ .attstorage = TYPSTORAGE_PLAIN,
+ .attnotnull = true,
+ .attislocal = true,
+@@ -188,8 +188,8 @@ static const FormData_pg_attribute a4 = {
+ .attnum = MaxTransactionIdAttributeNumber,
+ .attcacheoff = -1,
+ .atttypmod = -1,
+- .attbyval = true,
+- .attalign = TYPALIGN_INT,
++ .attbyval = FLOAT8PASSBYVAL,
++ .attalign = TYPALIGN_XID,
+ .attstorage = TYPSTORAGE_PLAIN,
+ .attnotnull = true,
+ .attislocal = true,
+diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
+index 836b4bfd894..03756402272 100644
+--- a/src/backend/catalog/pg_inherits.c
++++ b/src/backend/catalog/pg_inherits.c
+@@ -145,7 +145,7 @@ find_inheritance_children_extended(Oid parentrelId, bool omit_detached,
+ TransactionId xmin;
+ Snapshot snap;
+
+- xmin = HeapTupleHeaderGetXmin(inheritsTuple->t_data);
++ xmin = HeapTupleGetXmin(inheritsTuple);
+ snap = GetActiveSnapshot();
+
+ if (!XidInMVCCSnapshot(xmin, snap))
+diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
+index 8ed503e1c1b..029fbed1c12 100644
+--- a/src/backend/commands/async.c
++++ b/src/backend/commands/async.c
+@@ -184,7 +184,7 @@ typedef struct AsyncQueueEntry
+ } AsyncQueueEntry;
+
+ /* Currently, no field of AsyncQueueEntry requires more than int alignment */
+-#define QUEUEALIGN(len) INTALIGN(len)
++#define QUEUEALIGN(len) TYPEALIGN(8, len)
+
+ #define AsyncQueueEntryEmptySize (offsetof(AsyncQueueEntry, data) + 2)
+
+diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c
+index aa91a396967..6ebc8b7483c 100644
+--- a/src/backend/commands/dbcommands.c
++++ b/src/backend/commands/dbcommands.c
+@@ -129,7 +129,8 @@ static void CreateDatabaseUsingWalLog(Oid src_dboid, Oid dst_dboid, Oid src_tsid
+ static List *ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath);
+ static List *ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid,
+ Oid dbid, char *srcpath,
+- List *rlocatorlist, Snapshot snapshot);
++ List *rlocatorlist, Snapshot snapshot,
++ bool is_toast);
+ static CreateDBRelInfo *ScanSourceDatabasePgClassTuple(HeapTupleData *tuple,
+ Oid tbid, Oid dbid,
+ char *srcpath);
+@@ -307,9 +308,10 @@ ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath)
+ }
+
+ /* Append relevant pg_class tuples for current page to rlocatorlist. */
++ /* No toast is expected in sys tables */
+ rlocatorlist = ScanSourceDatabasePgClassPage(page, buf, tbid, dbid,
+ srcpath, rlocatorlist,
+- snapshot);
++ snapshot, false);
+
+ UnlockReleaseBuffer(buf);
+ }
+@@ -327,7 +329,7 @@ ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath)
+ static List *
+ ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid, Oid dbid,
+ char *srcpath, List *rlocatorlist,
+- Snapshot snapshot)
++ Snapshot snapshot, bool is_toast)
+ {
+ BlockNumber blkno = BufferGetBlockNumber(buf);
+ OffsetNumber offnum;
+@@ -357,6 +359,7 @@ ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid, Oid dbid,
+ tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
+ tuple.t_len = ItemIdGetLength(itemid);
+ tuple.t_tableOid = RelationRelationId;
++ HeapTupleCopyXidsFromPage(buf, &tuple, page, is_toast);
+
+ /* Skip tuples that are not visible to this snapshot. */
+ if (HeapTupleSatisfiesVisibility(&tuple, snapshot, buf))
+diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
+index 4049ce1a10f..0c1d634348f 100644
+--- a/src/backend/commands/indexcmds.c
++++ b/src/backend/commands/indexcmds.c
+@@ -1758,7 +1758,7 @@ DefineIndex(Oid tableId,
+ set_indexsafe_procflags();
+
+ /* We should now definitely not be advertising any xmin. */
+- Assert(MyProc->xmin == InvalidTransactionId);
++ Assert(pg_atomic_read_u64(&MyProc->xmin) == InvalidTransactionId);
+
+ /*
+ * The index is now valid in the sense that it contains all currently
+@@ -4593,8 +4593,8 @@ set_indexsafe_procflags(void)
+ * This should only be called before installing xid or xmin in MyProc;
+ * otherwise, concurrent processes could see an Xmin that moves backwards.
+ */
+- Assert(MyProc->xid == InvalidTransactionId &&
+- MyProc->xmin == InvalidTransactionId);
++ Assert(pg_atomic_read_u64(&MyProc->xid) == InvalidTransactionId &&
++ pg_atomic_read_u64(&MyProc->xmin) == InvalidTransactionId);
+
+ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
+ MyProc->statusFlags |= PROC_IN_SAFE_IC;
+diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
+index 0188e8bbd5b..1855b2ef4ef 100644
+--- a/src/backend/commands/sequence.c
++++ b/src/backend/commands/sequence.c
+@@ -49,6 +49,25 @@
+ #include "utils/syscache.h"
+ #include "utils/varlena.h"
+
++static inline void
++SeqTupleSetXmin(HeapTuple htup, TransactionId xid)
++{
++ htup->t_xmin = xid;
++ htup->t_data->t_choice.t_heap.t_xmin = xid;
++}
++
++static inline void
++SeqTupleSetXmax(HeapTuple htup, TransactionId xid)
++{
++ htup->t_xmin = xid;
++ htup->t_data->t_choice.t_heap.t_xmax = xid;
++}
++
++static inline TransactionId
++SeqTupleHeaderGetRawXmax(HeapTupleHeader htup)
++{
++ return htup->t_choice.t_heap.t_xmax;
++}
+
+ /*
+ * We don't want to log each fetching of a value from a sequence,
+@@ -384,10 +403,10 @@ fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNumber forkNum)
+ * because if the current transaction aborts, no other xact will ever
+ * examine the sequence tuple anyway.
+ */
+- HeapTupleHeaderSetXmin(tuple->t_data, FrozenTransactionId);
+- HeapTupleHeaderSetXminFrozen(tuple->t_data);
++ SeqTupleSetXmin(tuple, FrozenTransactionId);
++ HeapTupleHeaderStoreXminFrozen(tuple->t_data);
+ HeapTupleHeaderSetCmin(tuple->t_data, FirstCommandId);
+- HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId);
++ SeqTupleSetXmax(tuple, InvalidTransactionId);
+ tuple->t_data->t_infomask |= HEAP_XMAX_INVALID;
+ ItemPointerSet(&tuple->t_data->t_ctid, 0, FirstOffsetNumber);
+
+@@ -1210,6 +1229,7 @@ read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple)
+ /* Note we currently only bother to set these two fields of *seqdatatuple */
+ seqdatatuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
+ seqdatatuple->t_len = ItemIdGetLength(lp);
++ HeapTupleCopyHeaderXids(seqdatatuple);
+
+ /*
+ * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE on
+@@ -1220,9 +1240,9 @@ read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple)
+ * this again if the update gets lost.
+ */
+ Assert(!(seqdatatuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI));
+- if (HeapTupleHeaderGetRawXmax(seqdatatuple->t_data) != InvalidTransactionId)
++ if (SeqTupleHeaderGetRawXmax(seqdatatuple->t_data) != InvalidTransactionId)
+ {
+- HeapTupleHeaderSetXmax(seqdatatuple->t_data, InvalidTransactionId);
++ SeqTupleSetXmax(seqdatatuple, InvalidTransactionId);
+ seqdatatuple->t_data->t_infomask &= ~HEAP_XMAX_COMMITTED;
+ seqdatatuple->t_data->t_infomask |= HEAP_XMAX_INVALID;
+ MarkBufferDirtyHint(*buf, true);
+diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
+index 42c3db546c7..5a72bd1a8ad 100644
+--- a/src/backend/commands/vacuum.c
++++ b/src/backend/commands/vacuum.c
+@@ -63,12 +63,12 @@
+ /*
+ * GUC parameters
+ */
+-int vacuum_freeze_min_age;
+-int vacuum_freeze_table_age;
+-int vacuum_multixact_freeze_min_age;
+-int vacuum_multixact_freeze_table_age;
+-int vacuum_failsafe_age;
+-int vacuum_multixact_failsafe_age;
++int64 vacuum_freeze_min_age;
++int64 vacuum_freeze_table_age;
++int64 vacuum_multixact_freeze_min_age;
++int64 vacuum_multixact_freeze_table_age;
++int64 vacuum_failsafe_age;
++int64 vacuum_multixact_failsafe_age;
+
+ /*
+ * Variables for cost-based vacuum delay. The defaults differ between
+@@ -1084,7 +1084,7 @@ bool
+ vacuum_get_cutoffs(Relation rel, const VacuumParams *params,
+ struct VacuumCutoffs *cutoffs)
+ {
+- int freeze_min_age,
++ int64 freeze_min_age,
+ multixact_freeze_min_age,
+ freeze_table_age,
+ multixact_freeze_table_age,
+@@ -1500,6 +1500,9 @@ vac_update_relstats(Relation relation,
+ futurexid = false;
+ if (frozenxid_updated)
+ *frozenxid_updated = false;
++
++ Assert(TransactionIdPrecedesOrEquals(frozenxid, ReadNextTransactionId()));
++
+ if (TransactionIdIsNormal(frozenxid) && oldfrozenxid != frozenxid)
+ {
+ bool update = false;
+@@ -1523,6 +1526,9 @@ vac_update_relstats(Relation relation,
+ futuremxid = false;
+ if (minmulti_updated)
+ *minmulti_updated = false;
++
++ Assert(MultiXactIdPrecedesOrEquals(minmulti, ReadNextMultiXactId()));
++
+ if (MultiXactIdIsValid(minmulti) && oldminmulti != minmulti)
+ {
+ bool update = false;
+diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
+index bad7b195bfb..e81d7bd4cd9 100644
+--- a/src/backend/executor/execExprInterp.c
++++ b/src/backend/executor/execExprInterp.c
+@@ -3456,6 +3456,7 @@ ExecEvalFieldStoreDeForm(ExprState *state, ExprEvalStep *op, ExprContext *econte
+ tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tmptup);
+ tmptup.t_data = tuphdr;
+
+ /*
+diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
+index 00dc3396156..101c6bc6013 100644
+--- a/src/backend/executor/execTuples.c
++++ b/src/backend/executor/execTuples.c
+@@ -389,7 +389,7 @@ tts_heap_is_current_xact_tuple(TupleTableSlot *slot)
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("don't have a storage tuple in this context")));
+
+- xmin = HeapTupleHeaderGetRawXmin(hslot->tuple->t_data);
++ xmin = HeapTupleGetRawXmin(hslot->tuple);
+
+ return TransactionIdIsCurrentTransactionId(xmin);
+ }
+@@ -793,7 +793,7 @@ tts_buffer_is_current_xact_tuple(TupleTableSlot *slot)
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("don't have a storage tuple in this context")));
+
+- xmin = HeapTupleHeaderGetRawXmin(bslot->base.tuple->t_data);
++ xmin = HeapTupleGetRawXmin(bslot->base.tuple);
+
+ return TransactionIdIsCurrentTransactionId(xmin);
+ }
+diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
+index 740e8fb1486..47a6bea20ea 100644
+--- a/src/backend/executor/execUtils.c
++++ b/src/backend/executor/execUtils.c
+@@ -1044,6 +1044,7 @@ GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)
+ tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tmptup);
+ tmptup.t_data = tuple;
+
+ result = heap_getattr(&tmptup,
+diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
+index 1161520f76b..58452cdc801 100644
+--- a/src/backend/executor/nodeModifyTable.c
++++ b/src/backend/executor/nodeModifyTable.c
+@@ -4110,6 +4110,7 @@ ExecModifyTable(PlanState *pstate)
+ HeapTupleHeaderGetDatumLength(oldtupdata.t_data);
+ ItemPointerSetInvalid(&(oldtupdata.t_self));
+ /* Historically, view triggers see invalid t_tableOid. */
++ HeapTupleCopyHeaderXids(&oldtupdata);
+ oldtupdata.t_tableOid =
+ (relkind == RELKIND_VIEW) ? InvalidOid :
+ RelationGetRelid(resultRelInfo->ri_RelationDesc);
+diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c
+index 2fb2e73604e..b9495e78e12 100644
+--- a/src/backend/executor/spi.c
++++ b/src/backend/executor/spi.c
+@@ -1156,6 +1156,7 @@ SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum,
+ mtuple->t_data->t_ctid = tuple->t_data->t_ctid;
+ mtuple->t_self = tuple->t_self;
+ mtuple->t_tableOid = tuple->t_tableOid;
++ HeapTupleCopyXids(mtuple, tuple);
+ }
+ else
+ {
+diff --git a/src/backend/nodes/gen_node_support.pl b/src/backend/nodes/gen_node_support.pl
+index 81df3bdf95f..0e5d432b17a 100644
+--- a/src/backend/nodes/gen_node_support.pl
++++ b/src/backend/nodes/gen_node_support.pl
+@@ -1027,14 +1027,14 @@ _read${n}(void)
+ elsif ($t eq 'uint32'
+ || $t eq 'bits32'
+ || $t eq 'BlockNumber'
+- || $t eq 'Index'
+- || $t eq 'SubTransactionId')
++ || $t eq 'Index')
+ {
+ print $off "\tWRITE_UINT_FIELD($f);\n";
+ print $rff "\tREAD_UINT_FIELD($f);\n" unless $no_read;
+ }
+ elsif ($t eq 'uint64'
+- || $t eq 'AclMode')
++ || $t eq 'AclMode'
++ || $t eq 'SubTransactionId')
+ {
+ print $off "\tWRITE_UINT64_FIELD($f);\n";
+ print $rff "\tREAD_UINT64_FIELD($f);\n" unless $no_read;
+diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
+index 37b0ca2e439..12198f56042 100644
+--- a/src/backend/optimizer/util/plancat.c
++++ b/src/backend/optimizer/util/plancat.c
+@@ -272,7 +272,7 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
+ * src/backend/access/heap/README.HOT for discussion.
+ */
+ if (index->indcheckxmin &&
+- !TransactionIdPrecedes(HeapTupleHeaderGetXmin(indexRelation->rd_indextuple->t_data),
++ !TransactionIdPrecedes(HeapTupleGetXmin(indexRelation->rd_indextuple),
+ TransactionXmin))
+ {
+ root->glob->transientPlan = true;
+diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
+index 63c55c13e86..add4d0f9ccd 100644
+--- a/src/backend/postmaster/autovacuum.c
++++ b/src/backend/postmaster/autovacuum.c
+@@ -124,8 +124,8 @@ int64 autovacuum_vac_ins_thresh;
+ double autovacuum_vac_ins_scale;
+ int64 autovacuum_anl_thresh;
+ double autovacuum_anl_scale;
+-int autovacuum_freeze_max_age;
+-int autovacuum_multixact_freeze_max_age;
++int64 autovacuum_freeze_max_age;
++int64 autovacuum_multixact_freeze_max_age;
+
+ double autovacuum_vac_cost_delay;
+ int autovacuum_vac_cost_limit;
+@@ -156,10 +156,10 @@ static TransactionId recentXid;
+ static MultiXactId recentMulti;
+
+ /* Default freeze ages to use for autovacuum (varies by database) */
+-static int default_freeze_min_age;
+-static int default_freeze_table_age;
+-static int default_multixact_freeze_min_age;
+-static int default_multixact_freeze_table_age;
++static int64 default_freeze_min_age;
++static int64 default_freeze_table_age;
++static int64 default_multixact_freeze_min_age;
++static int64 default_multixact_freeze_table_age;
+
+ /* Memory context for long-lived data */
+ static MemoryContext AutovacMemCxt;
+@@ -329,15 +329,15 @@ static void FreeWorkerInfo(int code, Datum arg);
+
+ static autovac_table *table_recheck_autovac(Oid relid, HTAB *table_toast_map,
+ TupleDesc pg_class_desc,
+- int effective_multixact_freeze_max_age);
++ int64 effective_multixact_freeze_max_age);
+ static void recheck_relation_needs_vacanalyze(Oid relid, AutoVacOpts *avopts,
+ Form_pg_class classForm,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ bool *dovacuum, bool *doanalyze, bool *wraparound);
+ static void relation_needs_vacanalyze(Oid relid, AutoVacOpts *relopts,
+ Form_pg_class classForm,
+ PgStat_StatTabEntry *tabentry,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ bool *dovacuum, bool *doanalyze, bool *wraparound);
+
+ static void autovacuum_do_vac_analyze(autovac_table *tab,
+@@ -1114,11 +1114,10 @@ do_start_worker(void)
+ * particular tables, but not loosened.)
+ */
+ recentXid = ReadNextTransactionId();
+- xidForceLimit = recentXid - autovacuum_freeze_max_age;
+- /* ensure it's a "normal" XID, else TransactionIdPrecedes misbehaves */
+- /* this can cause the limit to go backwards by 3, but that's OK */
+- if (xidForceLimit < FirstNormalTransactionId)
+- xidForceLimit -= FirstNormalTransactionId;
++ if (recentXid > FirstNormalTransactionId + autovacuum_freeze_max_age)
++ xidForceLimit = recentXid - autovacuum_freeze_max_age;
++ else
++ xidForceLimit = FirstNormalTransactionId;
+
+ /* Also determine the oldest datminmxid we will consider. */
+ recentMulti = ReadNextMultiXactId();
+@@ -1886,7 +1885,7 @@ do_autovacuum(void)
+ BufferAccessStrategy bstrategy;
+ ScanKeyData key;
+ TupleDesc pg_class_desc;
+- int effective_multixact_freeze_max_age;
++ int64 effective_multixact_freeze_max_age;
+ bool did_vacuum = false;
+ bool found_concurrent_worker = false;
+ int i;
+@@ -2711,7 +2710,7 @@ extract_autovac_opts(HeapTuple tup, TupleDesc pg_class_desc)
+ static autovac_table *
+ table_recheck_autovac(Oid relid, HTAB *table_toast_map,
+ TupleDesc pg_class_desc,
+- int effective_multixact_freeze_max_age)
++ int64 effective_multixact_freeze_max_age)
+ {
+ Form_pg_class classForm;
+ HeapTuple classTup;
+@@ -2750,10 +2749,10 @@ table_recheck_autovac(Oid relid, HTAB *table_toast_map,
+ /* OK, it needs something done */
+ if (doanalyze || dovacuum)
+ {
+- int freeze_min_age;
+- int freeze_table_age;
+- int multixact_freeze_min_age;
+- int multixact_freeze_table_age;
++ int64 freeze_min_age;
++ int64 freeze_table_age;
++ int64 multixact_freeze_min_age;
++ int64 multixact_freeze_table_age;
+ int log_min_duration;
+
+ /*
+@@ -2852,7 +2851,7 @@ static void
+ recheck_relation_needs_vacanalyze(Oid relid,
+ AutoVacOpts *avopts,
+ Form_pg_class classForm,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ bool *dovacuum,
+ bool *doanalyze,
+ bool *wraparound)
+@@ -2914,7 +2913,7 @@ relation_needs_vacanalyze(Oid relid,
+ AutoVacOpts *relopts,
+ Form_pg_class classForm,
+ PgStat_StatTabEntry *tabentry,
+- int effective_multixact_freeze_max_age,
++ int64 effective_multixact_freeze_max_age,
+ /* output params below */
+ bool *dovacuum,
+ bool *doanalyze,
+@@ -2943,8 +2942,8 @@ relation_needs_vacanalyze(Oid relid,
+ anltuples;
+
+ /* freeze parameters */
+- int freeze_max_age;
+- int multixact_freeze_max_age;
++ int64 freeze_max_age;
++ int64 multixact_freeze_max_age;
+ TransactionId xidForceLimit;
+ TransactionId relfrozenxid;
+ MultiXactId multiForceLimit;
+@@ -2995,9 +2994,12 @@ relation_needs_vacanalyze(Oid relid,
+ av_enabled = (relopts ? relopts->enabled : true);
+
+ /* Force vacuum if table is at risk of wraparound */
+- xidForceLimit = recentXid - freeze_max_age;
+- if (xidForceLimit < FirstNormalTransactionId)
+- xidForceLimit -= FirstNormalTransactionId;
++
++ if (recentXid > FirstNormalTransactionId + freeze_max_age)
++ xidForceLimit = recentXid - freeze_max_age;
++ else
++ xidForceLimit = FirstNormalTransactionId;
++
+ relfrozenxid = classForm->relfrozenxid;
+ force_vacuum = (TransactionIdIsNormal(relfrozenxid) &&
+ TransactionIdPrecedes(relfrozenxid, xidForceLimit));
+@@ -3005,9 +3007,11 @@ relation_needs_vacanalyze(Oid relid,
+ {
+ MultiXactId relminmxid = classForm->relminmxid;
+
+- multiForceLimit = recentMulti - multixact_freeze_max_age;
+- if (multiForceLimit < FirstMultiXactId)
+- multiForceLimit -= FirstMultiXactId;
++ if (recentMulti > FirstMultiXactId + multixact_freeze_max_age)
++ multiForceLimit = recentMulti - multixact_freeze_max_age;
++ else
++ multiForceLimit = FirstMultiXactId;
++
+ force_vacuum = MultiXactIdIsValid(relminmxid) &&
+ MultiXactIdPrecedes(relminmxid, multiForceLimit);
+ }
+diff --git a/src/backend/replication/logical/conflict.c b/src/backend/replication/logical/conflict.c
+index 5d9ff626bde..2e58d4c728a 100644
+--- a/src/backend/replication/logical/conflict.c
++++ b/src/backend/replication/logical/conflict.c
+@@ -214,11 +214,11 @@ errdetail_apply_conflict(EState *estate, ResultRelInfo *relinfo,
+ if (localts)
+ {
+ if (localorigin == InvalidRepOriginId)
+- appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified locally in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified locally in transaction %lu at %s."),
+ get_rel_name(indexoid),
+ localxmin, timestamptz_to_str(localts));
+ else if (replorigin_by_oid(localorigin, true, &origin_name))
+- appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified by origin \"%s\" in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified by origin \"%s\" in transaction %lu at %s."),
+ get_rel_name(indexoid), origin_name,
+ localxmin, timestamptz_to_str(localts));
+
+@@ -230,27 +230,27 @@ errdetail_apply_conflict(EState *estate, ResultRelInfo *relinfo,
+ * manually dropped by the user.
+ */
+ else
+- appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified by a non-existent origin in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified by a non-existent origin in transaction %lu at %s."),
+ get_rel_name(indexoid),
+ localxmin, timestamptz_to_str(localts));
+ }
+ else
+- appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified in transaction %u."),
++ appendStringInfo(&err_detail, _("Key already exists in unique index \"%s\", modified in transaction %lu."),
+ get_rel_name(indexoid), localxmin);
+
+ break;
+
+ case CT_UPDATE_ORIGIN_DIFFERS:
+ if (localorigin == InvalidRepOriginId)
+- appendStringInfo(&err_detail, _("Updating the row that was modified locally in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Updating the row that was modified locally in transaction %lu at %s."),
+ localxmin, timestamptz_to_str(localts));
+ else if (replorigin_by_oid(localorigin, true, &origin_name))
+- appendStringInfo(&err_detail, _("Updating the row that was modified by a different origin \"%s\" in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Updating the row that was modified by a different origin \"%s\" in transaction %lu at %s."),
+ origin_name, localxmin, timestamptz_to_str(localts));
+
+ /* The origin that modified this row has been removed. */
+ else
+- appendStringInfo(&err_detail, _("Updating the row that was modified by a non-existent origin in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Updating the row that was modified by a non-existent origin in transaction %lu at %s."),
+ localxmin, timestamptz_to_str(localts));
+
+ break;
+@@ -261,15 +261,15 @@ errdetail_apply_conflict(EState *estate, ResultRelInfo *relinfo,
+
+ case CT_DELETE_ORIGIN_DIFFERS:
+ if (localorigin == InvalidRepOriginId)
+- appendStringInfo(&err_detail, _("Deleting the row that was modified locally in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Deleting the row that was modified locally in transaction %lu at %s."),
+ localxmin, timestamptz_to_str(localts));
+ else if (replorigin_by_oid(localorigin, true, &origin_name))
+- appendStringInfo(&err_detail, _("Deleting the row that was modified by a different origin \"%s\" in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Deleting the row that was modified by a different origin \"%s\" in transaction %lu at %s."),
+ origin_name, localxmin, timestamptz_to_str(localts));
+
+ /* The origin that modified this row has been removed. */
+ else
+- appendStringInfo(&err_detail, _("Deleting the row that was modified by a non-existent origin in transaction %u at %s."),
++ appendStringInfo(&err_detail, _("Deleting the row that was modified by a non-existent origin in transaction %lu at %s."),
+ localxmin, timestamptz_to_str(localts));
+
+ break;
+diff --git a/src/backend/replication/logical/decode.c b/src/backend/replication/logical/decode.c
+index e73576ad12f..317618e4e24 100644
+--- a/src/backend/replication/logical/decode.c
++++ b/src/backend/replication/logical/decode.c
+@@ -896,8 +896,14 @@ DecodeInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ xl_heap_insert *xlrec;
+ ReorderBufferChange *change;
+ RelFileLocator target_locator;
++ bool isinit = (XLogRecGetInfo(r) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(r);
+
+- xlrec = (xl_heap_insert *) XLogRecGetData(r);
++ /* Bypass pd_xid_base and pd_multi_base */
++ if (isinit)
++ rec_data += sizeof(TransactionId) * 2;
++
++ xlrec = (xl_heap_insert *) rec_data;
+
+ /*
+ * Ignore insert records without new tuples (this does happen when
+@@ -953,8 +959,13 @@ DecodeUpdate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ ReorderBufferChange *change;
+ char *data;
+ RelFileLocator target_locator;
++ bool isinit = (XLogRecGetInfo(r) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(r);
+
+- xlrec = (xl_heap_update *) XLogRecGetData(r);
++ /* Bypass pd_xid_base and pd_multi_base */
++ if (isinit)
++ rec_data += sizeof(TransactionId) * 2;
++ xlrec = (xl_heap_update *) rec_data;
+
+ /* only interested in our database */
+ XLogRecGetBlockTag(r, 0, &target_locator, NULL, NULL);
+@@ -1114,8 +1125,13 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ char *tupledata;
+ Size tuplelen;
+ RelFileLocator rlocator;
++ bool isinit = (XLogRecGetInfo(r) & XLOG_HEAP_INIT_PAGE) != 0;
++ Pointer rec_data = (Pointer) XLogRecGetData(r);
+
+- xlrec = (xl_heap_multi_insert *) XLogRecGetData(r);
++ /* Bypass pd_xid_base and pd_multi_base */
++ if (isinit)
++ rec_data += sizeof(TransactionId) * 2;
++ xlrec = (xl_heap_multi_insert *) rec_data;
+
+ /*
+ * Ignore insert records without new tuples. This happens when a
+@@ -1172,6 +1188,7 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
+ * We can only figure this out after reassembling the transactions.
+ */
+ tuple->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tuple);
+
+ tuple->t_len = datalen + SizeofHeapTupleHeader;
+
+@@ -1263,6 +1280,7 @@ DecodeXLogTuple(char *data, Size len, HeapTuple tuple)
+
+ /* we can only figure this out after reassembling the transactions */
+ tuple->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tuple);
+
+ /* data is not stored aligned, copy to aligned storage */
+ memcpy((char *) &xlhdr,
+diff --git a/src/backend/replication/logical/proto.c b/src/backend/replication/logical/proto.c
+index 2c2085b2f98..39975adba0d 100644
+--- a/src/backend/replication/logical/proto.c
++++ b/src/backend/replication/logical/proto.c
+@@ -52,7 +52,7 @@ logicalrep_write_begin(StringInfo out, ReorderBufferTXN *txn)
+ /* fixed fields */
+ pq_sendint64(out, txn->final_lsn);
+ pq_sendint64(out, txn->xact_time.commit_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+ }
+
+ /*
+@@ -66,7 +66,7 @@ logicalrep_read_begin(StringInfo in, LogicalRepBeginData *begin_data)
+ if (begin_data->final_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "final_lsn not set in begin message");
+ begin_data->committime = pq_getmsgint64(in);
+- begin_data->xid = pq_getmsgint(in, 4);
++ begin_data->xid = pq_getmsgint64(in);
+ }
+
+
+@@ -120,7 +120,7 @@ logicalrep_write_begin_prepare(StringInfo out, ReorderBufferTXN *txn)
+ pq_sendint64(out, txn->final_lsn);
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, txn->xact_time.prepare_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -140,7 +140,7 @@ logicalrep_read_begin_prepare(StringInfo in, LogicalRepPreparedTxnData *begin_da
+ if (begin_data->end_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "end_lsn not set in begin prepare message");
+ begin_data->prepare_time = pq_getmsgint64(in);
+- begin_data->xid = pq_getmsgint(in, 4);
++ begin_data->xid = pq_getmsgint64(in);
+
+ /* read gid (copy it into a pre-allocated buffer) */
+ strlcpy(begin_data->gid, pq_getmsgstring(in), sizeof(begin_data->gid));
+@@ -173,7 +173,7 @@ logicalrep_write_prepare_common(StringInfo out, LogicalRepMsgType type,
+ pq_sendint64(out, prepare_lsn);
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, txn->xact_time.prepare_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -212,7 +212,7 @@ logicalrep_read_prepare_common(StringInfo in, char *msgtype,
+ if (prepare_data->end_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "end_lsn is not set in %s message", msgtype);
+ prepare_data->prepare_time = pq_getmsgint64(in);
+- prepare_data->xid = pq_getmsgint(in, 4);
++ prepare_data->xid = pq_getmsgint64(in);
+ if (prepare_data->xid == InvalidTransactionId)
+ elog(ERROR, "invalid two-phase transaction ID in %s message", msgtype);
+
+@@ -253,7 +253,7 @@ logicalrep_write_commit_prepared(StringInfo out, ReorderBufferTXN *txn,
+ pq_sendint64(out, commit_lsn);
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, txn->xact_time.commit_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -279,7 +279,7 @@ logicalrep_read_commit_prepared(StringInfo in, LogicalRepCommitPreparedTxnData *
+ if (prepare_data->end_lsn == InvalidXLogRecPtr)
+ elog(ERROR, "end_lsn is not set in commit prepared message");
+ prepare_data->commit_time = pq_getmsgint64(in);
+- prepare_data->xid = pq_getmsgint(in, 4);
++ prepare_data->xid = pq_getmsgint64(in);
+
+ /* read gid (copy it into a pre-allocated buffer) */
+ strlcpy(prepare_data->gid, pq_getmsgstring(in), sizeof(prepare_data->gid));
+@@ -311,7 +311,7 @@ logicalrep_write_rollback_prepared(StringInfo out, ReorderBufferTXN *txn,
+ pq_sendint64(out, txn->end_lsn);
+ pq_sendint64(out, prepare_time);
+ pq_sendint64(out, txn->xact_time.commit_time);
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send gid */
+ pq_sendstring(out, txn->gid);
+@@ -339,7 +339,7 @@ logicalrep_read_rollback_prepared(StringInfo in,
+ elog(ERROR, "rollback_end_lsn is not set in rollback prepared message");
+ rollback_data->prepare_time = pq_getmsgint64(in);
+ rollback_data->rollback_time = pq_getmsgint64(in);
+- rollback_data->xid = pq_getmsgint(in, 4);
++ rollback_data->xid = pq_getmsgint64(in);
+
+ /* read gid (copy it into a pre-allocated buffer) */
+ strlcpy(rollback_data->gid, pq_getmsgstring(in), sizeof(rollback_data->gid));
+@@ -407,7 +407,7 @@ logicalrep_write_insert(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -456,7 +456,7 @@ logicalrep_write_update(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -532,7 +532,7 @@ logicalrep_write_delete(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -586,7 +586,7 @@ logicalrep_write_truncate(StringInfo out,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ pq_sendint32(out, nrelids);
+
+@@ -644,7 +644,7 @@ logicalrep_write_message(StringInfo out, TransactionId xid, XLogRecPtr lsn,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ pq_sendint8(out, flags);
+ pq_sendint64(out, lsn);
+@@ -666,7 +666,7 @@ logicalrep_write_rel(StringInfo out, TransactionId xid, Relation rel,
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* use Oid as relation identifier */
+ pq_sendint32(out, RelationGetRelid(rel));
+@@ -722,7 +722,7 @@ logicalrep_write_typ(StringInfo out, TransactionId xid, Oid typoid)
+
+ /* transaction ID (if not valid, we're not streaming) */
+ if (TransactionIdIsValid(xid))
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(basetypoid));
+ if (!HeapTupleIsValid(tup))
+@@ -1053,7 +1053,7 @@ logicalrep_write_stream_start(StringInfo out,
+ Assert(TransactionIdIsValid(xid));
+
+ /* transaction ID (we're starting to stream, so must be valid) */
+- pq_sendint32(out, xid);
++ pq_sendint64(out, xid);
+
+ /* 1 if this is the first streaming segment for this xid */
+ pq_sendbyte(out, first_segment ? 1 : 0);
+@@ -1069,7 +1069,7 @@ logicalrep_read_stream_start(StringInfo in, bool *first_segment)
+
+ Assert(first_segment);
+
+- xid = pq_getmsgint(in, 4);
++ xid = pq_getmsgint64(in);
+ *first_segment = (pq_getmsgbyte(in) == 1);
+
+ return xid;
+@@ -1098,7 +1098,7 @@ logicalrep_write_stream_commit(StringInfo out, ReorderBufferTXN *txn,
+ Assert(TransactionIdIsValid(txn->xid));
+
+ /* transaction ID */
+- pq_sendint32(out, txn->xid);
++ pq_sendint64(out, txn->xid);
+
+ /* send the flags field (unused for now) */
+ pq_sendbyte(out, flags);
+@@ -1118,7 +1118,7 @@ logicalrep_read_stream_commit(StringInfo in, LogicalRepCommitData *commit_data)
+ TransactionId xid;
+ uint8 flags;
+
+- xid = pq_getmsgint(in, 4);
++ xid = pq_getmsgint64(in);
+
+ /* read flags (unused for now) */
+ flags = pq_getmsgbyte(in);
+@@ -1151,8 +1151,8 @@ logicalrep_write_stream_abort(StringInfo out, TransactionId xid,
+ Assert(TransactionIdIsValid(xid) && TransactionIdIsValid(subxid));
+
+ /* transaction ID */
+- pq_sendint32(out, xid);
+- pq_sendint32(out, subxid);
++ pq_sendint64(out, xid);
++ pq_sendint64(out, subxid);
+
+ if (write_abort_info)
+ {
+@@ -1174,8 +1174,8 @@ logicalrep_read_stream_abort(StringInfo in,
+ {
+ Assert(abort_data);
+
+- abort_data->xid = pq_getmsgint(in, 4);
+- abort_data->subxid = pq_getmsgint(in, 4);
++ abort_data->xid = pq_getmsgint64(in);
++ abort_data->subxid = pq_getmsgint64(in);
+
+ if (read_abort_info)
+ {
+diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
+index 2f6e0d41729..7dec6bf4f08 100644
+--- a/src/backend/replication/logical/reorderbuffer.c
++++ b/src/backend/replication/logical/reorderbuffer.c
+@@ -5211,8 +5211,12 @@ UpdateLogicalMappings(HTAB *tuplecid_data, Oid relid, Snapshot snapshot)
+ TransactionId f_mapped_xid;
+ TransactionId f_create_xid;
+ XLogRecPtr f_lsn;
+- uint32 f_hi,
+- f_lo;
++ uint32 f_lsn_hi,
++ f_lsn_lo,
++ f_mapped_xid_hi,
++ f_mapped_xid_lo,
++ f_create_xid_hi,
++ f_create_xid_lo;
+ RewriteMappingFile *f;
+
+ if (strcmp(mapping_de->d_name, ".") == 0 ||
+@@ -5224,11 +5228,14 @@ UpdateLogicalMappings(HTAB *tuplecid_data, Oid relid, Snapshot snapshot)
+ continue;
+
+ if (sscanf(mapping_de->d_name, LOGICAL_REWRITE_FORMAT,
+- &f_dboid, &f_relid, &f_hi, &f_lo,
+- &f_mapped_xid, &f_create_xid) != 6)
++ &f_dboid, &f_relid, &f_lsn_hi, &f_lsn_lo,
++ &f_mapped_xid_hi, &f_mapped_xid_lo,
++ &f_create_xid_hi, &f_create_xid_lo) != 8)
+ elog(ERROR, "could not parse filename \"%s\"", mapping_de->d_name);
+
+- f_lsn = ((uint64) f_hi) << 32 | f_lo;
++ f_lsn = ((uint64) f_lsn_hi) << 32 | f_lsn_lo;
++ f_mapped_xid = ((uint64) f_mapped_xid_hi) << 32 | f_mapped_xid_lo;
++ f_create_xid = ((uint64) f_create_xid_hi) << 32 | f_create_xid_lo;
+
+ /* mapping for another database */
+ if (f_dboid != dboid)
+diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
+index f4f80b23129..81367155847 100644
+--- a/src/backend/replication/logical/slotsync.c
++++ b/src/backend/replication/logical/slotsync.c
+@@ -212,7 +212,7 @@ update_local_synced_slot(RemoteSlot *remote_slot, Oid remote_dbid,
+ ereport(slot->data.persistency == RS_TEMPORARY ? LOG : DEBUG1,
+ errmsg("could not synchronize replication slot \"%s\" because remote slot precedes local slot",
+ remote_slot->name),
+- errdetail("The remote slot has LSN %X/%X and catalog xmin %u, but the local slot has LSN %X/%X and catalog xmin %u.",
++ errdetail("The remote slot has LSN %X/%X and catalog xmin %lu, but the local slot has LSN %X/%X and catalog xmin %lu.",
+ LSN_FORMAT_ARGS(remote_slot->restart_lsn),
+ remote_slot->catalog_xmin,
+ LSN_FORMAT_ARGS(slot->data.restart_lsn),
+diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c
+index 9ea9273b0f6..f474c172025 100644
+--- a/src/backend/replication/logical/snapbuild.c
++++ b/src/backend/replication/logical/snapbuild.c
+@@ -461,7 +461,7 @@ SnapBuildInitialSnapshot(SnapBuild *builder)
+ elog(ERROR, "cannot build an initial slot snapshot, not all transactions are monitored anymore");
+
+ /* so we don't overwrite the existing value */
+- if (TransactionIdIsValid(MyProc->xmin))
++ if (TransactionIdIsValid(pg_atomic_read_u64(&MyProc->xmin)))
+ elog(ERROR, "cannot build an initial slot snapshot when MyProc->xmin already is valid");
+
+ snap = SnapBuildBuildSnapshot(builder);
+@@ -483,7 +483,7 @@ SnapBuildInitialSnapshot(SnapBuild *builder)
+ elog(ERROR, "cannot build an initial slot snapshot as oldest safe xid %llu follows snapshot's xmin %llu",
+ (unsigned long long) safeXid, (unsigned long long) snap->xmin);
+
+- MyProc->xmin = snap->xmin;
++ pg_atomic_write_u64(&MyProc->xmin, snap->xmin);
+
+ /* allocate in transaction context */
+ newxip = (TransactionId *)
+diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c
+index e9f02ae3cb6..93c10427004 100644
+--- a/src/backend/replication/logical/worker.c
++++ b/src/backend/replication/logical/worker.c
+@@ -581,7 +581,7 @@ handle_streamed_transaction(LogicalRepMsgType action, StringInfo s)
+ * We should have received XID of the subxact as the first part of the
+ * message, so extract it.
+ */
+- current_xid = pq_getmsgint(s, 4);
++ current_xid = pq_getmsgint64(s);
+
+ if (!TransactionIdIsValid(current_xid))
+ ereport(ERROR,
+diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
+index 4e694e06d77..0a967e03b37 100644
+--- a/src/backend/replication/walreceiver.c
++++ b/src/backend/replication/walreceiver.c
+@@ -1170,10 +1170,6 @@ static void
+ XLogWalRcvSendHSFeedback(bool immed)
+ {
+ TimestampTz now;
+- FullTransactionId nextFullXid;
+- TransactionId nextXid;
+- uint32 xmin_epoch,
+- catalog_xmin_epoch;
+ TransactionId xmin,
+ catalog_xmin;
+
+@@ -1225,31 +1221,15 @@ XLogWalRcvSendHSFeedback(bool immed)
+ catalog_xmin = InvalidTransactionId;
+ }
+
+- /*
+- * Get epoch and adjust if nextXid and oldestXmin are different sides of
+- * the epoch boundary.
+- */
+- nextFullXid = ReadNextFullTransactionId();
+- nextXid = XidFromFullTransactionId(nextFullXid);
+- xmin_epoch = EpochFromFullTransactionId(nextFullXid);
+- catalog_xmin_epoch = xmin_epoch;
+- if (nextXid < xmin)
+- xmin_epoch--;
+- if (nextXid < catalog_xmin)
+- catalog_xmin_epoch--;
+-
+- elog(DEBUG2, "sending hot standby feedback xmin %llu epoch %u catalog_xmin %llu catalog_xmin_epoch %u",
+- (unsigned long long) xmin, xmin_epoch,
+- (unsigned long long) catalog_xmin, catalog_xmin_epoch);
++ elog(DEBUG2, "sending hot standby feedback xmin %llu catalog_xmin %llu",
++ (unsigned long long) xmin, (unsigned long long) catalog_xmin);
+
+ /* Construct the message and send it. */
+ resetStringInfo(&reply_message);
+ pq_sendbyte(&reply_message, 'h');
+ pq_sendint64(&reply_message, GetCurrentTimestamp());
+- pq_sendint32(&reply_message, xmin);
+- pq_sendint32(&reply_message, xmin_epoch);
+- pq_sendint32(&reply_message, catalog_xmin);
+- pq_sendint32(&reply_message, catalog_xmin_epoch);
++ pq_sendint64(&reply_message, xmin);
++ pq_sendint64(&reply_message, catalog_xmin);
+ walrcv_send(wrconn, reply_message.data, reply_message.len);
+ if (TransactionIdIsValid(xmin) || TransactionIdIsValid(catalog_xmin))
+ primary_has_standby_xmin = true;
+diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
+index ab8991ec2d8..509bf9fecfc 100644
+--- a/src/backend/replication/walsender.c
++++ b/src/backend/replication/walsender.c
+@@ -267,7 +267,6 @@ static void WalSndUpdateProgress(LogicalDecodingContext *ctx, XLogRecPtr lsn, Tr
+ static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+ static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+ static TimeOffset LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
+-static bool TransactionIdInRecentPast(TransactionId xid, uint32 epoch);
+
+ static void WalSndSegmentOpen(XLogReaderState *state, XLogSegNo nextSegNo,
+ TimeLineID *tli_p);
+@@ -303,7 +302,7 @@ InitWalSender(void)
+ */
+ if (MyDatabaseId == InvalidOid)
+ {
+- Assert(MyProc->xmin == InvalidTransactionId);
++ Assert(pg_atomic_read_u64(&MyProc->xmin) == InvalidTransactionId);
+ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
+ MyProc->statusFlags |= PROC_AFFECTS_ALL_HORIZONS;
+ ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
+@@ -2470,7 +2469,7 @@ PhysicalReplicationSlotNewXmin(TransactionId feedbackXmin, TransactionId feedbac
+ ReplicationSlot *slot = MyReplicationSlot;
+
+ SpinLockAcquire(&slot->mutex);
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&MyProc->xmin, InvalidTransactionId);
+
+ /*
+ * For physical replication we don't need the interlock provided by xmin
+@@ -2502,44 +2501,6 @@ PhysicalReplicationSlotNewXmin(TransactionId feedbackXmin, TransactionId feedbac
+ }
+ }
+
+-/*
+- * Check that the provided xmin/epoch are sane, that is, not in the future
+- * and not so far back as to be already wrapped around.
+- *
+- * Epoch of nextXid should be same as standby, or if the counter has
+- * wrapped, then one greater than standby.
+- *
+- * This check doesn't care about whether clog exists for these xids
+- * at all.
+- */
+-static bool
+-TransactionIdInRecentPast(TransactionId xid, uint32 epoch)
+-{
+- FullTransactionId nextFullXid;
+- TransactionId nextXid;
+- uint32 nextEpoch;
+-
+- nextFullXid = ReadNextFullTransactionId();
+- nextXid = XidFromFullTransactionId(nextFullXid);
+- nextEpoch = EpochFromFullTransactionId(nextFullXid);
+-
+- if (xid <= nextXid)
+- {
+- if (epoch != nextEpoch)
+- return false;
+- }
+- else
+- {
+- if (epoch + 1 != nextEpoch)
+- return false;
+- }
+-
+- if (!TransactionIdPrecedesOrEquals(xid, nextXid))
+- return false; /* epoch OK, but it's wrapped around */
+-
+- return true;
+-}
+-
+ /*
+ * Hot Standby feedback
+ */
+@@ -2547,9 +2508,7 @@ static void
+ ProcessStandbyHSFeedbackMessage(void)
+ {
+ TransactionId feedbackXmin;
+- uint32 feedbackEpoch;
+ TransactionId feedbackCatalogXmin;
+- uint32 feedbackCatalogEpoch;
+ TimestampTz replyTime;
+
+ /*
+@@ -2558,10 +2517,8 @@ ProcessStandbyHSFeedbackMessage(void)
+ * of this message.
+ */
+ replyTime = pq_getmsgint64(&reply_message);
+- feedbackXmin = pq_getmsgint(&reply_message, 4);
+- feedbackEpoch = pq_getmsgint(&reply_message, 4);
+- feedbackCatalogXmin = pq_getmsgint(&reply_message, 4);
+- feedbackCatalogEpoch = pq_getmsgint(&reply_message, 4);
++ feedbackXmin = pq_getmsgint64(&reply_message);
++ feedbackCatalogXmin = pq_getmsgint64(&reply_message);
+
+ if (message_level_is_interesting(DEBUG2))
+ {
+@@ -2570,11 +2527,9 @@ ProcessStandbyHSFeedbackMessage(void)
+ /* Copy because timestamptz_to_str returns a static buffer */
+ replyTimeStr = pstrdup(timestamptz_to_str(replyTime));
+
+- elog(DEBUG2, "hot standby feedback xmin %llu epoch %u, catalog_xmin %llu epoch %u reply_time %s",
++ elog(DEBUG2, "hot standby feedback xmin %llu, catalog_xmin %llu reply_time %s",
+ (unsigned long long) feedbackXmin,
+- feedbackEpoch,
+ (unsigned long long) feedbackCatalogXmin,
+- feedbackCatalogEpoch,
+ replyTimeStr);
+
+ pfree(replyTimeStr);
+@@ -2599,24 +2554,12 @@ ProcessStandbyHSFeedbackMessage(void)
+ if (!TransactionIdIsNormal(feedbackXmin)
+ && !TransactionIdIsNormal(feedbackCatalogXmin))
+ {
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&MyProc->xmin, InvalidTransactionId);
+ if (MyReplicationSlot != NULL)
+ PhysicalReplicationSlotNewXmin(feedbackXmin, feedbackCatalogXmin);
+ return;
+ }
+
+- /*
+- * Check that the provided xmin/epoch are sane, that is, not in the future
+- * and not so far back as to be already wrapped around. Ignore if not.
+- */
+- if (TransactionIdIsNormal(feedbackXmin) &&
+- !TransactionIdInRecentPast(feedbackXmin, feedbackEpoch))
+- return;
+-
+- if (TransactionIdIsNormal(feedbackCatalogXmin) &&
+- !TransactionIdInRecentPast(feedbackCatalogXmin, feedbackCatalogEpoch))
+- return;
+-
+ /*
+ * Set the WalSender's xmin equal to the standby's requested xmin, so that
+ * the xmin will be taken into account by GetSnapshotData() /
+@@ -2654,9 +2597,9 @@ ProcessStandbyHSFeedbackMessage(void)
+ {
+ if (TransactionIdIsNormal(feedbackCatalogXmin)
+ && TransactionIdPrecedes(feedbackCatalogXmin, feedbackXmin))
+- MyProc->xmin = feedbackCatalogXmin;
++ pg_atomic_write_u64(&MyProc->xmin, feedbackCatalogXmin);
+ else
+- MyProc->xmin = feedbackXmin;
++ pg_atomic_write_u64(&MyProc->xmin, feedbackXmin);
+ }
+ }
+
+diff --git a/src/backend/statistics/extended_stats.c b/src/backend/statistics/extended_stats.c
+index 99fdf208dba..abbe717aebe 100644
+--- a/src/backend/statistics/extended_stats.c
++++ b/src/backend/statistics/extended_stats.c
+@@ -2455,6 +2455,7 @@ statext_expressions_load(Oid stxoid, bool inh, int idx)
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
+ tmptup.t_data = td;
++ HeapTupleCopyHeaderXids(&tmptup);
+
+ tup = heap_copytuple(&tmptup);
+
+diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
+index fd7c40dcb08..ffcc0fc290e 100644
+--- a/src/backend/storage/buffer/Makefile
++++ b/src/backend/storage/buffer/Makefile
+@@ -17,6 +17,7 @@ OBJS = \
+ buf_table.o \
+ bufmgr.o \
+ freelist.o \
+- localbuf.o
++ localbuf.o \
++ heap_convert.o
+
+ include $(top_srcdir)/src/backend/common.mk
+diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
+index 2622221809c..a91fc9c60c4 100644
+--- a/src/backend/storage/buffer/bufmgr.c
++++ b/src/backend/storage/buffer/bufmgr.c
+@@ -1555,6 +1555,30 @@ WaitReadBuffers(ReadBuffersOperation *operation)
+ relpath(operation->smgr->smgr_rlocator, forknum))));
+ }
+
++ if (PageGetPageLayoutVersion(bufBlock) != PG_PAGE_LAYOUT_VERSION &&
++ !PageIsNew((Page) bufBlock))
++ {
++ Buffer buf = BufferDescriptorGetBuffer(bufHdr);
++
++ /*
++ * All the forks but MAIN_FORKNUM should be converted to the
++ * actual page layout version in pg_upgrade.
++ */
++ if (forknum != MAIN_FORKNUM)
++ ereport(ERROR,
++ (errcode(ERRCODE_DATA_CORRUPTED),
++ errmsg("invalid fork type (%d) in block %u of relation %s",
++ forknum, blocknum,
++ relpath(operation->smgr->smgr_rlocator, forknum))));
++
++ LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_EXCLUSIVE);
++ /* Check for no concurrent changes */
++ if (PageGetPageLayoutVersion(bufBlock) != PG_PAGE_LAYOUT_VERSION)
++ convert_page(operation->rel, bufBlock, buf, blocknum);
++
++ LWLockRelease(BufferDescriptorGetContentLock(bufHdr));
++ }
++
+ /* Terminate I/O and set BM_VALID. */
+ if (persistence == RELPERSISTENCE_TEMP)
+ {
+@@ -5117,6 +5141,64 @@ MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
+ }
+ }
+
++/*
++ * Mark buffer as converted - ie its format is changed without logical changes.
++ *
++ * It will override `full_page_write` GUC setting in XLogRecordAssemble.
++ */
++void
++MarkBufferConverted(Buffer buffer, bool converted)
++{
++ BufferDesc *bufHdr;
++ uint32 buf_state;
++ bool has_mark;
++
++ if (!BufferIsValid(buffer))
++ elog(ERROR, "bad buffer ID: %d", buffer);
++
++ Assert(!BufferIsLocal(buffer));
++
++ bufHdr = GetBufferDescriptor(buffer - 1);
++
++ Assert(GetPrivateRefCount(buffer) > 0);
++ if (converted)
++ {
++ /* here, either share or exclusive lock is OK */
++ Assert(LWLockHeldByMe(BufferDescriptorGetContentLock(bufHdr)));
++ }
++
++ buf_state = pg_atomic_read_u32(&bufHdr->state);
++ has_mark = (buf_state & BM_CONVERTED) != 0;
++ if (converted == has_mark)
++ return;
++
++ buf_state = LockBufHdr(bufHdr);
++ buf_state &= ~BM_CONVERTED;
++ if (converted)
++ buf_state |= BM_CONVERTED;
++ UnlockBufHdr(bufHdr, buf_state);
++}
++
++bool
++IsBufferConverted(Buffer buffer)
++{
++
++ BufferDesc *bufHdr;
++ uint32 buf_state;
++
++ if (!BufferIsValid(buffer))
++ elog(ERROR, "bad buffer ID: %d", buffer);
++
++ Assert(!BufferIsLocal(buffer));
++
++ bufHdr = GetBufferDescriptor(buffer - 1);
++
++ Assert(GetPrivateRefCount(buffer) > 0);
++
++ buf_state = pg_atomic_read_u32(&bufHdr->state);
++ return (buf_state & BM_CONVERTED) != 0;
++}
++
+ /*
+ * Release buffer content locks for shared buffers.
+ *
+@@ -5151,6 +5233,47 @@ UnlockBuffers(void)
+ }
+ }
+
++/*
++ * Is shared buffer is locked?
++ */
++bool
++IsBufferLocked(Buffer buffer)
++{
++ BufferDesc *buf;
++
++ if (buffer == InvalidBuffer)
++ return true;
++
++ Assert(BufferIsPinned(buffer));
++ if (BufferIsLocal(buffer))
++ return true; /* local buffers need no lock */
++
++ buf = GetBufferDescriptor(buffer - 1);
++
++ return LWLockHeldByMe(BufferDescriptorGetContentLock(buf));
++}
++
++/*
++ * Is shared buffer is locked exclusive?
++ */
++bool
++IsBufferLockedExclusive(Buffer buffer)
++{
++ BufferDesc *buf;
++
++ if (buffer == InvalidBuffer)
++ return true;
++
++ Assert(BufferIsPinned(buffer));
++ if (BufferIsLocal(buffer))
++ return true; /* local buffers need no lock */
++
++ buf = GetBufferDescriptor(buffer - 1);
++
++ return LWLockHeldByMeInMode(BufferDescriptorGetContentLock(buf),
++ LW_EXCLUSIVE);
++}
++
+ /*
+ * Acquire or release the content_lock for the buffer.
+ */
+diff --git a/src/backend/storage/buffer/heap_convert.c b/src/backend/storage/buffer/heap_convert.c
+new file mode 100644
+index 00000000000..2609f110721
+--- /dev/null
++++ b/src/backend/storage/buffer/heap_convert.c
+@@ -0,0 +1,549 @@
++/*-------------------------------------------------------------------------
++ *
++ * heap_convert.c
++ * Heap page converter from 32bit to 64bit xid format
++ *
++ * Copyright (c) 2015-2022, Postgres Professional
++ *
++ * IDENTIFICATION
++ * src/backend/storage/buffer/heap_convert.c
++ *
++ *-------------------------------------------------------------------------
++ */
++
++#include "postgres.h"
++
++#include "access/generic_xlog.h"
++#include "access/heapam.h"
++#include "access/multixact.h"
++#include "catalog/catalog.h"
++#include "storage/bufmgr.h"
++#include "storage/checksum.h"
++
++static void repack_heap_tuples(Relation rel, Page page, Buffer buf,
++ BlockNumber blkno, bool double_xmax);
++
++/*
++ * itemoffcompare
++ * Sorting support for repack_tuples()
++ */
++int
++itemoffcompare(const void *item1, const void *item2)
++{
++ /* Sort in decreasing itemoff order */
++ return ((ItemIdCompactData *) item2)->itemoff -
++ ((ItemIdCompactData *) item1)->itemoff;
++}
++
++/*
++ * Lazy page conversion from 32-bit to 64-bit XID at first read.
++ */
++void
++convert_page(Relation rel, Page page, Buffer buf, BlockNumber blkno)
++{
++ static unsigned logcnt = 0;
++ bool logit;
++ PageHeader hdr = (PageHeader) page;
++ GenericXLogState *state = NULL;
++ uint16 checksum;
++ bool try_double_xmax;
++
++ /* Not during XLog replaying */
++ Assert(rel != NULL);
++
++ /* Verify checksum */
++ if (hdr->pd_checksum)
++ {
++ checksum = pg_checksum_page((char *) page, blkno);
++ if (checksum != hdr->pd_checksum)
++ ereport(ERROR,
++ (errcode(ERRCODE_INDEX_CORRUPTED),
++ errmsg("page verification failed, calculated checksum %u but expected %u",
++ checksum, hdr->pd_checksum)));
++ }
++
++ /*
++ * We occasionally force logging of page conversion, so never-changed
++ * pages are converted in the end. FORCE_LOG_EVERY is chosen arbitrarily
++ * to log neither too much nor too little.
++ */
++#define FORCE_LOG_EVERY 128
++ logit = !RecoveryInProgress() && XLogIsNeeded() && RelationNeedsWAL(rel);
++ logit = logit && (++logcnt % FORCE_LOG_EVERY) == 0;
++ if (logit)
++ {
++ state = GenericXLogStart(rel);
++ page = GenericXLogRegisterBuffer(state, buf,
++ GENERIC_XLOG_FULL_IMAGE);
++ hdr = (PageHeader) page;
++ }
++#ifdef USE_ASSERT_CHECKING
++ else
++ {
++ /* Not already converted */
++ Assert(PageGetPageLayoutVersion(page) != PG_PAGE_LAYOUT_VERSION);
++ /* Page in 32-bit xid format should not have PageSpecial. */
++ Assert(PageGetSpecialSize(page) == 0);
++ }
++#endif
++
++ switch (rel->rd_rel->relkind)
++ {
++ case 't':
++ try_double_xmax = hdr->pd_upper - hdr->pd_lower <
++ MAXALIGN(sizeof(ToastPageSpecialData));
++ repack_heap_tuples(rel, page, buf, blkno, try_double_xmax);
++ break;
++ case 'r':
++ case 'p':
++ case 'm':
++ try_double_xmax = hdr->pd_upper - hdr->pd_lower <
++ MAXALIGN(sizeof(HeapPageSpecialData));
++ repack_heap_tuples(rel, page, buf, blkno, try_double_xmax);
++ break;
++ case 'i':
++ /* no need to convert index */
++ case 'S':
++ /* no real need to convert sequences */
++ break;
++ default:
++ ereport(ERROR,
++ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
++ errmsg("conversion for relation \"%s\" cannot be done",
++ RelationGetRelationName(rel)),
++ errdetail_relkind_not_supported(rel->rd_rel->relkind)));
++ }
++
++ hdr->pd_checksum = pg_checksum_page((char *) page, blkno);
++
++ PageSetPageSizeAndVersion(page, PageGetPageSize(page),
++ PG_PAGE_LAYOUT_VERSION);
++
++ if (logit)
++ {
++ /*
++ * Finish logging buffer conversion and mark buffer as dirty.
++ */
++ Assert(state != NULL);
++ MarkBufferDirty(buf);
++ GenericXLogFinish(state);
++ }
++ else
++ {
++ /*
++ * Otherwise, it will be logged with full-page-write record on first
++ * actual change.
++ */
++ MarkBufferConverted(buf, true);
++ }
++}
++
++/*
++ * Convert xmin and xmax in a tuple.
++ * This also considers special cases: "double xmax" page format and multixact
++ * in xmax.
++ */
++static void
++convert_heap_tuple_xids(HeapTupleHeader tuple, TransactionId xid_base,
++ MultiXactId multi_base, bool double_xmax)
++{
++ /* Convert xmin */
++ if (double_xmax)
++ {
++ /* Prepare tuple for "double xmax" page format */
++ tuple->t_infomask |= HEAP_XMIN_FROZEN;
++ tuple->t_choice.t_heap.t_xmin = 0;
++ }
++ else
++ {
++ TransactionId xmin = tuple->t_choice.t_heap.t_xmin;
++
++ if (TransactionIdIsNormal(xmin))
++ {
++ if (HeapTupleHeaderXminFrozen(tuple))
++ tuple->t_choice.t_heap.t_xmin = FrozenTransactionId;
++ else if (HeapTupleHeaderXminInvalid(tuple))
++ tuple->t_choice.t_heap.t_xmin = InvalidTransactionId;
++ else
++ {
++ Assert(xmin >= xid_base + FirstNormalTransactionId);
++ /* Subtract xid_base from normal xmin */
++ tuple->t_choice.t_heap.t_xmin = xmin - xid_base;
++ }
++ }
++ }
++
++ /* If tuple has multixact flag, handle mxid wraparound */
++ if ((tuple->t_infomask & HEAP_XMAX_IS_MULTI) &&
++ !(tuple->t_infomask & HEAP_XMAX_INVALID))
++ {
++ MultiXactId mxid = tuple->t_choice.t_heap.t_xmax;
++
++ /* Handle mxid wraparound */
++ if (mxid < multi_base)
++ {
++ mxid += ((MultiXactId) 1 << 32) - FirstMultiXactId;
++ Assert(mxid >= multi_base);
++ }
++
++ if (double_xmax)
++ {
++ /* Save converted mxid into "double xmax" format */
++ HeapTupleHeaderSetDoubleXmax(tuple, mxid);
++ }
++ else
++ {
++ /*
++ * Save converted mxid offset relative to (minmxid - 1), which
++ * will be page's mxid base.
++ */
++ Assert(mxid - multi_base + FirstMultiXactId <= PG_UINT32_MAX);
++ tuple->t_choice.t_heap.t_xmax =
++ (uint32) (mxid - multi_base + FirstMultiXactId);
++ }
++ }
++ /* Convert xmax */
++ else if (!(tuple->t_infomask & HEAP_XMAX_INVALID))
++ {
++ TransactionId xmax = tuple->t_choice.t_heap.t_xmax;
++
++ if (double_xmax)
++ {
++ /* Save converted xmax into "double xmax" format */
++ HeapTupleHeaderSetDoubleXmax(tuple, xmax);
++ }
++ else if (TransactionIdIsNormal(xmax))
++ {
++ /* Subtract xid_base from normal xmax */
++ Assert(xmax >= xid_base + FirstNormalTransactionId);
++ tuple->t_choice.t_heap.t_xmax = xmax - xid_base;
++ }
++ }
++ else
++ {
++ if (double_xmax)
++ HeapTupleHeaderSetDoubleXmax(tuple, InvalidTransactionId);
++ else
++ tuple->t_choice.t_heap.t_xmax = InvalidTransactionId;
++ }
++}
++
++/*
++ * Correct page xmin/xmax based on tuple xmin/xmax values.
++ */
++static void
++compute_xid_min_max(HeapTuple tuple, MultiXactId multi_base,
++ TransactionId *xid_min, TransactionId *xid_max,
++ MultiXactId *multi_min, MultiXactId *multi_max)
++{
++ /* xmin */
++ if (!HeapTupleHeaderXminInvalid(tuple->t_data) &&
++ !HeapTupleHeaderXminFrozen(tuple->t_data))
++ {
++ TransactionId xid = HeapTupleGetRawXmin(tuple);
++
++ if (TransactionIdIsNormal(xid))
++ {
++ *xid_max = Max(*xid_max, xid);
++ *xid_min = Min(*xid_min, xid);
++ }
++ }
++
++ /* xmax */
++ if (!(tuple->t_data->t_infomask & HEAP_XMAX_INVALID))
++ {
++ TransactionId xid;
++
++ if (tuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI)
++ {
++ MultiXactId mxid = HeapTupleGetRawXmax(tuple);
++
++ Assert(MultiXactIdIsValid(mxid));
++
++ /* Handle mxid wraparound */
++ if (mxid < multi_base)
++ {
++ mxid += ((MultiXactId) 1 << 32) - FirstMultiXactId;
++ Assert(mxid >= multi_base);
++ }
++
++ *multi_max = Max(*multi_max, mxid);
++ *multi_min = Min(*multi_min, mxid);
++
++ /*
++ * Also take into account hidden update xid, which can be
++ * extracted by the vacuum.
++ */
++ if (tuple->t_data->t_infomask & HEAP_XMAX_LOCK_ONLY)
++ xid = InvalidTransactionId;
++ else
++ xid = HeapTupleGetUpdateXid(tuple);
++ }
++ else
++ {
++ xid = HeapTupleGetRawXmax(tuple);
++ }
++
++ if (TransactionIdIsNormal(xid))
++ {
++ *xid_max = Max(*xid_max, xid);
++ *xid_min = Min(*xid_min, xid);
++ }
++ }
++}
++
++/*
++ * Returns true if both:
++ * - xid_max: an uppper boundary of xmin's and xmax'es of all tuples on a page
++ * - xid_min: a lower boundary of xmin's and xmax'es of all tuples on a page
++ * can be expressed by 32-bit number relative to page's xid_base/multi_base
++ * or invalid.
++ *
++ * True value effectively means that these tuples can be directly put on one
++ * page in 64-xid format.
++ */
++static inline bool
++xids_fit_page(TransactionId xid_min, TransactionId xid_max,
++ MultiXactId multi_min, MultiXactId multi_max)
++{
++ bool xid_max_fits = false;
++ bool multi_max_fits = false;
++
++ if (xid_max == InvalidTransactionId)
++ xid_max_fits = true;
++
++ if (xid_max - xid_min <= MaxShortTransactionId - FirstNormalTransactionId)
++ xid_max_fits = true;
++
++ if (multi_max == InvalidMultiXactId)
++ multi_max_fits = true;
++
++ if (multi_max - multi_min <= MaxShortTransactionId - FirstMultiXactId)
++ multi_max_fits = true;
++
++ return xid_max_fits && multi_max_fits;
++}
++
++/*
++ * Set "base" for page in 64-bit XID format.
++ *
++ * This should not be called for double xmax pages. They do not have place for
++ * page special.
++ */
++static inline void
++heap_page_set_base(Page page,
++ TransactionId xid_min, TransactionId xid_max,
++ MultiXactId multi_min, MultiXactId multi_max,
++ TransactionId *xid_base, MultiXactId *multi_base,
++ bool is_toast)
++{
++ PageHeader hdr = (PageHeader) page;
++
++ if (xid_max != InvalidTransactionId)
++ *xid_base = xid_min - FirstNormalTransactionId;
++ else
++ *xid_base = InvalidTransactionId;
++
++ if (multi_max != InvalidMultiXactId)
++ *multi_base = multi_min - FirstMultiXactId;
++ else
++ *multi_base = InvalidMultiXactId;
++
++ if (is_toast)
++ {
++ ToastPageSpecial special;
++
++ hdr->pd_special = BLCKSZ - MAXALIGN(sizeof(ToastPageSpecialData));
++ special = ToastPageGetSpecial(page);
++ special->pd_xid_base = *xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ hdr->pd_special = BLCKSZ - MAXALIGN(sizeof(HeapPageSpecialData));
++ special = HeapPageGetSpecial(page);
++ special->pd_xid_base = *xid_base;
++ special->pd_multi_base = *multi_base;
++ }
++}
++
++/*
++ * repack_heap_tuples
++ * Convert heap page format reusing space of dead tuples
++ */
++static void
++repack_heap_tuples(Relation rel, Page page, Buffer buf, BlockNumber blkno,
++ bool try_double_xmax)
++{
++ ItemIdCompactData items[MaxHeapTuplesPerPage];
++ ItemIdCompact itemPtr = items;
++ int nitems = 0,
++ maxoff = PageGetMaxOffsetNumber(page),
++ idx,
++ occupied_space = 0;
++ Offset upper;
++ bool double_xmax,
++ special_fits,
++ toast;
++ PageHeader hdr = (PageHeader) page,
++ new_hdr;
++ PGAlignedBlock zerobuf = {0};
++ Page new_page;
++ MultiXactId multi_base = rel->rd_rel->relminmxid,
++ multi_min = MaxMultiXactId,
++ multi_max = InvalidMultiXactId;
++ TransactionId xid_base = rel->rd_rel->relfrozenxid,
++ xid_min = MaxTransactionId,
++ xid_max = InvalidTransactionId;
++
++ toast = IsToastRelation(rel);
++
++ if (TransactionIdIsNormal(hdr->pd_prune_xid))
++ xid_min = xid_max = hdr->pd_prune_xid;
++
++ for (idx = 0; idx < maxoff; idx++)
++ {
++ HeapTupleData tuple;
++ ItemId lp;
++
++ lp = PageGetItemId(page, idx + 1);
++
++ /* Skip redirects and items without storage */
++ if (!ItemIdHasStorage(lp))
++ continue;
++
++ /* Build in-memory tuple representation */
++ tuple.t_tableOid = 1; /* doesn't matter in this case */
++ tuple.t_data = (HeapTupleHeader) PageGetItem(page, lp);
++ HeapTupleCopyHeaderXids(&tuple);
++ tuple.t_len = ItemIdGetLength(lp);
++ ItemPointerSet(&(tuple.t_self), blkno, ItemIdGetOffset(lp));
++
++ /*
++ * This is only needed to determine whether tuple is HEAPTUPLE_DEAD or
++ * HEAPTUPLE_RECENTLY_DEAD. And since this is the first time we read
++ * page after pg_upgrade, it cannot be HEAPTUPLE_RECENTLY_DEAD. See
++ * HeapTupleSatisfiesVacuum() for details
++ */
++ if (try_double_xmax &&
++ HeapTupleSatisfiesVacuum(&tuple,
++ (TransactionId) 1 << 32, buf) == HEAPTUPLE_DEAD)
++ {
++ ItemIdSetDead(lp);
++ }
++
++ if (ItemIdIsNormal(lp) && ItemIdHasStorage(lp))
++ {
++ itemPtr->offsetindex = idx;
++ itemPtr->itemoff = ItemIdGetOffset(lp);
++ if (unlikely(itemPtr->itemoff < hdr->pd_upper ||
++ itemPtr->itemoff >= hdr->pd_special))
++ {
++ ereport(ERROR,
++ (errcode(ERRCODE_DATA_CORRUPTED),
++ errmsg("corrupted item pointer: %u",
++ itemPtr->itemoff)));
++ }
++
++ itemPtr->alignedlen = MAXALIGN(ItemIdGetLength(lp));
++ occupied_space += itemPtr->alignedlen;
++ nitems++;
++ itemPtr++;
++ if (try_double_xmax)
++ {
++ HeapTupleSetXmin(&tuple, FrozenTransactionId);
++ HeapTupleHeaderStoreXminFrozen(tuple.t_data);
++ }
++
++ compute_xid_min_max(&tuple, multi_base,
++ &xid_min, &xid_max,
++ &multi_min, &multi_max);
++ }
++ }
++
++ new_page = (Page) zerobuf.data;
++ MemSet(new_page, 0, BLCKSZ);
++ /* Write new header */
++ new_hdr = (PageHeader) new_page;
++ *new_hdr = *hdr;
++ new_hdr->pd_lower = SizeOfPageHeaderData + maxoff * sizeof(ItemIdData);
++
++ if (toast)
++ special_fits = BLCKSZ - new_hdr->pd_lower - occupied_space >=
++ sizeof(ToastPageSpecialData);
++ else
++ special_fits = BLCKSZ - new_hdr->pd_lower - occupied_space >=
++ sizeof(HeapPageSpecialData);
++
++ double_xmax = !special_fits ||
++ !xids_fit_page(xid_min, xid_max, multi_min, multi_max);
++
++ if (!double_xmax)
++ {
++ Assert(xid_max == InvalidTransactionId || xid_max >= xid_min);
++ Assert(multi_max == InvalidMultiXactId || multi_max >= multi_min);
++
++ heap_page_set_base(new_page,
++ xid_min, xid_max,
++ multi_min, multi_max,
++ &xid_base, &multi_base,
++ toast);
++
++ HeapPageSetPruneXid(new_page, new_hdr->pd_prune_xid, toast);
++ }
++ else
++ {
++ /* No space for special area, switch to "double xmax" format */
++ elog(DEBUG2, "convert heap page %u of relation \"%s\" to double xmax format",
++ blkno, RelationGetRelationName(rel));
++
++ if (try_double_xmax)
++ {
++ xid_base = InvalidTransactionId;
++ multi_base = InvalidMultiXactId;
++ }
++ else
++ {
++ repack_heap_tuples(rel, page, buf, blkno, true);
++ return;
++ }
++ }
++
++ /* Copy ItemIds with an offset */
++ memcpy((char *) new_page + SizeOfPageHeaderData,
++ (char *) page + SizeOfPageHeaderData,
++ hdr->pd_lower - SizeOfPageHeaderData);
++
++ /* Move live tuples */
++ upper = new_hdr->pd_special;
++ for (idx = 0; idx < nitems; idx++)
++ {
++ HeapTupleHeader tuple;
++ ItemId lp;
++
++ itemPtr = &items[idx];
++ lp = PageGetItemId(new_page, itemPtr->offsetindex + 1);
++ upper -= itemPtr->alignedlen;
++ occupied_space -= itemPtr->alignedlen;
++
++ memcpy((char *) new_page + upper,
++ (char *) page + itemPtr->itemoff,
++ itemPtr->alignedlen);
++
++ tuple = (HeapTupleHeader) (((char *) new_page) + upper);
++
++ convert_heap_tuple_xids(tuple, xid_base, multi_base, double_xmax);
++
++ lp->lp_off = upper;
++ }
++
++ Assert(occupied_space == 0);
++
++ new_hdr->pd_upper = upper;
++ if (new_hdr->pd_lower > new_hdr->pd_upper)
++ elog(ERROR, "cannot convert block %u of relation \"%s\"",
++ blkno, RelationGetRelationName(rel));
++
++ memcpy(page, new_page, BLCKSZ);
++}
+diff --git a/src/backend/storage/buffer/meson.build b/src/backend/storage/buffer/meson.build
+index f152dbb0702..260e628af2a 100644
+--- a/src/backend/storage/buffer/meson.build
++++ b/src/backend/storage/buffer/meson.build
+@@ -5,5 +5,6 @@ backend_sources += files(
+ 'buf_table.c',
+ 'bufmgr.c',
+ 'freelist.c',
++ 'heap_convert.c',
+ 'localbuf.c',
+ )
+diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
+index 016ead28257..c1aa0bfcbe1 100644
+--- a/src/backend/storage/ipc/procarray.c
++++ b/src/backend/storage/ipc/procarray.c
+@@ -65,7 +65,7 @@
+ #include "utils/rel.h"
+ #include "utils/snapmgr.h"
+
+-#define UINT32_ACCESS_ONCE(var) ((uint32)(*((volatile uint32 *)&(var))))
++#define UINT64_ACCESS_ONCE(var) ((uint64)(*((volatile uint64 *)&(var))))
+
+ /* Our shared memory area */
+ typedef struct ProcArrayStruct
+@@ -365,8 +365,6 @@ static void ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid);
+ static void MaintainLatestCompletedXid(TransactionId latestXid);
+ static void MaintainLatestCompletedXidRecovery(TransactionId latestXid);
+
+-static inline FullTransactionId FullXidRelativeTo(FullTransactionId rel,
+- TransactionId xid);
+ static void GlobalVisUpdateApply(ComputeXidHorizonsResult *horizons);
+
+ /*
+@@ -525,7 +523,8 @@ ProcArrayAdd(PGPROC *proc)
+
+ arrayP->pgprocnos[index] = GetNumberFromPGProc(proc);
+ proc->pgxactoff = index;
+- ProcGlobal->xids[index] = proc->xid;
++ pg_atomic_write_u64(&ProcGlobal->xids[index],
++ pg_atomic_read_u64(&proc->xid));
+ ProcGlobal->subxidStates[index] = proc->subxidStatus;
+ ProcGlobal->statusFlags[index] = proc->statusFlags;
+
+@@ -585,7 +584,7 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
+
+ if (TransactionIdIsValid(latestXid))
+ {
+- Assert(TransactionIdIsValid(ProcGlobal->xids[myoff]));
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&ProcGlobal->xids[myoff])));
+
+ /* Advance global latestCompletedXid while holding the lock */
+ MaintainLatestCompletedXid(latestXid);
+@@ -593,17 +592,17 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
+ /* Same with xactCompletionCount */
+ TransamVariables->xactCompletionCount++;
+
+- ProcGlobal->xids[myoff] = InvalidTransactionId;
++ pg_atomic_write_u64(&ProcGlobal->xids[myoff], InvalidTransactionId);
+ ProcGlobal->subxidStates[myoff].overflowed = false;
+ ProcGlobal->subxidStates[myoff].count = 0;
+ }
+ else
+ {
+ /* Shouldn't be trying to remove a live transaction here */
+- Assert(!TransactionIdIsValid(ProcGlobal->xids[myoff]));
++ Assert(!TransactionIdIsValid(pg_atomic_read_u64(&(ProcGlobal->xids[myoff]))));
+ }
+
+- Assert(!TransactionIdIsValid(ProcGlobal->xids[myoff]));
++ Assert(!TransactionIdIsValid(pg_atomic_read_u64(&(ProcGlobal->xids[myoff]))));
+ Assert(ProcGlobal->subxidStates[myoff].count == 0);
+ Assert(ProcGlobal->subxidStates[myoff].overflowed == false);
+
+@@ -649,7 +648,6 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
+ LWLockRelease(ProcArrayLock);
+ }
+
+-
+ /*
+ * ProcArrayEndTransaction -- mark a transaction as no longer running
+ *
+@@ -674,7 +672,7 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid)
+ * else is taking a snapshot. See discussion in
+ * src/backend/access/transam/README.
+ */
+- Assert(TransactionIdIsValid(proc->xid));
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&proc->xid)));
+
+ /*
+ * If we can immediately acquire ProcArrayLock, we clear our own XID
+@@ -696,12 +694,12 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid)
+ * anyone else's calculation of a snapshot. We might change their
+ * estimate of global xmin, but that's OK.
+ */
+- Assert(!TransactionIdIsValid(proc->xid));
++ Assert(!TransactionIdIsValid(pg_atomic_read_u64(&proc->xid)));
+ Assert(proc->subxidStatus.count == 0);
+ Assert(!proc->subxidStatus.overflowed);
+
+ proc->vxid.lxid = InvalidLocalTransactionId;
+- proc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&proc->xmin, InvalidTransactionId);
+
+ /* be sure this is cleared in abort */
+ proc->delayChkptFlags = 0;
+@@ -737,13 +735,14 @@ ProcArrayEndTransactionInternal(PGPROC *proc, TransactionId latestXid)
+ * processes' PGPROC entries.
+ */
+ Assert(LWLockHeldByMeInMode(ProcArrayLock, LW_EXCLUSIVE));
+- Assert(TransactionIdIsValid(ProcGlobal->xids[pgxactoff]));
+- Assert(ProcGlobal->xids[pgxactoff] == proc->xid);
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&ProcGlobal->xids[pgxactoff])));
++ Assert(pg_atomic_read_u64(&ProcGlobal->xids[pgxactoff]) ==
++ pg_atomic_read_u64(&proc->xid));
+
+- ProcGlobal->xids[pgxactoff] = InvalidTransactionId;
+- proc->xid = InvalidTransactionId;
++ pg_atomic_write_u64(&ProcGlobal->xids[pgxactoff], InvalidTransactionId);
++ pg_atomic_write_u64(&proc->xid, InvalidTransactionId);
+ proc->vxid.lxid = InvalidLocalTransactionId;
+- proc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&proc->xmin, InvalidTransactionId);
+
+ /* be sure this is cleared in abort */
+ proc->delayChkptFlags = 0;
+@@ -797,7 +796,7 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
+ uint32 wakeidx;
+
+ /* We should definitely have an XID to clear. */
+- Assert(TransactionIdIsValid(proc->xid));
++ Assert(TransactionIdIsValid(pg_atomic_read_u64(&proc->xid)));
+
+ /* Add ourselves to the list of processes needing a group XID clear. */
+ proc->procArrayGroupMember = true;
+@@ -926,11 +925,11 @@ ProcArrayClearTransaction(PGPROC *proc)
+
+ pgxactoff = proc->pgxactoff;
+
+- ProcGlobal->xids[pgxactoff] = InvalidTransactionId;
+- proc->xid = InvalidTransactionId;
++ pg_atomic_write_u64(&ProcGlobal->xids[pgxactoff], InvalidTransactionId);
++ pg_atomic_write_u64(&proc->xid, InvalidTransactionId);
+
+ proc->vxid.lxid = InvalidLocalTransactionId;
+- proc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&proc->xmin, InvalidTransactionId);
+ proc->recoveryConflictPending = false;
+
+ Assert(!(proc->statusFlags & PROC_VACUUM_STATE_MASK));
+@@ -974,8 +973,7 @@ MaintainLatestCompletedXid(TransactionId latestXid)
+
+ if (TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
+ {
+- TransamVariables->latestCompletedXid =
+- FullXidRelativeTo(cur_latest, latestXid);
++ TransamVariables->latestCompletedXid = FullTransactionIdFromXid(latestXid);
+ }
+
+ Assert(IsBootstrapProcessingMode() ||
+@@ -989,7 +987,6 @@ static void
+ MaintainLatestCompletedXidRecovery(TransactionId latestXid)
+ {
+ FullTransactionId cur_latest = TransamVariables->latestCompletedXid;
+- FullTransactionId rel;
+
+ Assert(AmStartupProcess() || !IsUnderPostmaster);
+ Assert(LWLockHeldByMe(ProcArrayLock));
+@@ -999,14 +996,12 @@ MaintainLatestCompletedXidRecovery(TransactionId latestXid)
+ * latestCompletedXid to be initialized in recovery. But in recovery it's
+ * safe to access nextXid without a lock for the startup process.
+ */
+- rel = TransamVariables->nextXid;
+ Assert(FullTransactionIdIsValid(TransamVariables->nextXid));
+
+ if (!FullTransactionIdIsValid(cur_latest) ||
+ TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
+ {
+- TransamVariables->latestCompletedXid =
+- FullXidRelativeTo(rel, latestXid);
++ TransamVariables->latestCompletedXid = FullTransactionIdFromXid(latestXid);
+ }
+
+ Assert(FullTransactionIdIsNormal(TransamVariables->latestCompletedXid));
+@@ -1402,7 +1397,7 @@ bool
+ TransactionIdIsInProgress(TransactionId xid)
+ {
+ static TransactionId *xids = NULL;
+- static TransactionId *other_xids;
++ static pg_atomic_uint64 *other_xids;
+ XidCacheStatus *other_subxidstates;
+ int nxids = 0;
+ ProcArrayStruct *arrayP = procArray;
+@@ -1498,7 +1493,7 @@ TransactionIdIsInProgress(TransactionId xid)
+ continue;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- pxid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]);
++ pxid = pg_atomic_read_u64(&(other_xids[pgxactoff]));
+
+ if (!TransactionIdIsValid(pxid))
+ continue;
+@@ -1530,7 +1525,7 @@ TransactionIdIsInProgress(TransactionId xid)
+ for (j = pxids - 1; j >= 0; j--)
+ {
+ /* Fetch xid just once - see GetNewTransactionId */
+- TransactionId cxid = UINT32_ACCESS_ONCE(proc->subxids.xids[j]);
++ TransactionId cxid = UINT64_ACCESS_ONCE(proc->subxids.xids[j]);
+
+ if (TransactionIdEquals(cxid, xid))
+ {
+@@ -1615,7 +1610,7 @@ TransactionIdIsInProgress(TransactionId xid)
+ topxid = SubTransGetTopmostTransaction(xid);
+ Assert(TransactionIdIsValid(topxid));
+ if (!TransactionIdEquals(topxid, xid) &&
+- pg_lfind32(topxid, xids, nxids))
++ pg_lfind64(topxid, xids, nxids))
+ return true;
+
+ cachedXidIsNotInProgress = xid;
+@@ -1635,7 +1630,7 @@ TransactionIdIsActive(TransactionId xid)
+ {
+ bool result = false;
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ int i;
+
+ /*
+@@ -1654,7 +1649,7 @@ TransactionIdIsActive(TransactionId xid)
+ TransactionId pxid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- pxid = UINT32_ACCESS_ONCE(other_xids[i]);
++ pxid = pg_atomic_read_u64(&(other_xids[i]));
+
+ if (!TransactionIdIsValid(pxid))
+ continue;
+@@ -1737,7 +1732,7 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ ProcArrayStruct *arrayP = procArray;
+ TransactionId kaxmin;
+ bool in_recovery = RecoveryInProgress();
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+
+ /* inferred after ProcArrayLock is released */
+ h->catalog_oldest_nonremovable = InvalidTransactionId;
+@@ -1753,7 +1748,8 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ * additions.
+ */
+ {
+- TransactionId initial;
++ TransactionId initial,
++ xid;
+
+ initial = XidFromFullTransactionId(h->latest_completed);
+ Assert(TransactionIdIsValid(initial));
+@@ -1775,8 +1771,9 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ * definition, can't be any newer changes in the temp table than
+ * latestCompletedXid.
+ */
+- if (TransactionIdIsValid(MyProc->xid))
+- h->temp_oldest_nonremovable = MyProc->xid;
++ xid = pg_atomic_read_u64(&MyProc->xid);
++ if (TransactionIdIsValid(xid))
++ h->temp_oldest_nonremovable = xid;
+ else
+ h->temp_oldest_nonremovable = initial;
+ }
+@@ -1798,8 +1795,8 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
+ TransactionId xmin;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
+- xmin = UINT32_ACCESS_ONCE(proc->xmin);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
++ xmin = pg_atomic_read_u64(&proc->xmin);
+
+ /*
+ * Consider both the transaction's Xmin, and its Xid.
+@@ -2125,8 +2122,8 @@ GetSnapshotDataReuse(Snapshot snapshot)
+ * requirement that concurrent GetSnapshotData() calls yield the same
+ * xmin.
+ */
+- if (!TransactionIdIsValid(MyProc->xmin))
+- MyProc->xmin = TransactionXmin = snapshot->xmin;
++ if (!TransactionIdIsValid(pg_atomic_read_u64(&MyProc->xmin)))
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = snapshot->xmin);
+
+ RecentXmin = snapshot->xmin;
+ Assert(TransactionIdPrecedesOrEquals(TransactionXmin, RecentXmin));
+@@ -2177,7 +2174,7 @@ Snapshot
+ GetSnapshotData(Snapshot snapshot)
+ {
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ TransactionId xmin;
+ TransactionId xmax;
+ int count = 0;
+@@ -2240,8 +2237,8 @@ GetSnapshotData(Snapshot snapshot)
+
+ latest_completed = TransamVariables->latestCompletedXid;
+ mypgxactoff = MyProc->pgxactoff;
+- myxid = other_xids[mypgxactoff];
+- Assert(myxid == MyProc->xid);
++ myxid = pg_atomic_read_u64(&other_xids[mypgxactoff]);
++ Assert(myxid == pg_atomic_read_u64(&MyProc->xid));
+
+ oldestxid = TransamVariables->oldestXid;
+ curXactCompletionCount = TransamVariables->xactCompletionCount;
+@@ -2275,7 +2272,7 @@ GetSnapshotData(Snapshot snapshot)
+ for (int pgxactoff = 0; pgxactoff < numProcs; pgxactoff++)
+ {
+ /* Fetch xid just once - see GetNewTransactionId */
+- TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]);
++ TransactionId xid = pg_atomic_read_u64(&(other_xids[pgxactoff]));
+ uint8 statusFlags;
+
+ Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff);
+@@ -2412,8 +2409,8 @@ GetSnapshotData(Snapshot snapshot)
+ replication_slot_xmin = procArray->replication_slot_xmin;
+ replication_slot_catalog_xmin = procArray->replication_slot_catalog_xmin;
+
+- if (!TransactionIdIsValid(MyProc->xmin))
+- MyProc->xmin = TransactionXmin = xmin;
++ if (!TransactionIdIsValid(pg_atomic_read_u64(&MyProc->xmin)))
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = xmin);
+
+ LWLockRelease(ProcArrayLock);
+
+@@ -2425,12 +2422,7 @@ GetSnapshotData(Snapshot snapshot)
+ FullTransactionId def_vis_fxid_data;
+ FullTransactionId oldestfxid;
+
+- /*
+- * Converting oldestXid is only safe when xid horizon cannot advance,
+- * i.e. holding locks. While we don't hold the lock anymore, all the
+- * necessary data has been gathered with lock held.
+- */
+- oldestfxid = FullXidRelativeTo(latest_completed, oldestxid);
++ oldestfxid = FullTransactionIdFromXid(oldestxid);
+
+ /* Check whether there's a replication slot requiring an older xmin. */
+ def_vis_xid_data =
+@@ -2449,8 +2441,8 @@ GetSnapshotData(Snapshot snapshot)
+ def_vis_xid =
+ TransactionIdOlder(replication_slot_catalog_xmin, def_vis_xid);
+
+- def_vis_fxid = FullXidRelativeTo(latest_completed, def_vis_xid);
+- def_vis_fxid_data = FullXidRelativeTo(latest_completed, def_vis_xid_data);
++ def_vis_fxid = FullTransactionIdFromXid(def_vis_xid);
++ def_vis_fxid_data = FullTransactionIdFromXid(def_vis_xid_data);
+
+ /*
+ * Check if we can increase upper bound. As a previous
+@@ -2469,7 +2461,7 @@ GetSnapshotData(Snapshot snapshot)
+ /* See temp_oldest_nonremovable computation in ComputeXidHorizons() */
+ if (TransactionIdIsNormal(myxid))
+ GlobalVisTempRels.definitely_needed =
+- FullXidRelativeTo(latest_completed, myxid);
++ FullTransactionIdFromXid(myxid);
+ else
+ {
+ GlobalVisTempRels.definitely_needed = latest_completed;
+@@ -2581,7 +2573,7 @@ ProcArrayInstallImportedXmin(TransactionId xmin,
+ /*
+ * Likewise, let's just make real sure its xmin does cover us.
+ */
+- xid = UINT32_ACCESS_ONCE(proc->xmin);
++ xid = pg_atomic_read_u64(&proc->xmin);
+ if (!TransactionIdIsNormal(xid) ||
+ !TransactionIdPrecedesOrEquals(xid, xmin))
+ continue;
+@@ -2592,7 +2584,7 @@ ProcArrayInstallImportedXmin(TransactionId xmin,
+ * GetSnapshotData first, we'll be overwriting a valid xmin here, so
+ * we don't check that.)
+ */
+- MyProc->xmin = TransactionXmin = xmin;
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = xmin);
+
+ result = true;
+ break;
+@@ -2636,7 +2628,7 @@ ProcArrayInstallRestoredXmin(TransactionId xmin, PGPROC *proc)
+ * can't go backwards. Also, make sure it's running in the same database,
+ * so that the per-database xmin cannot go backwards.
+ */
+- xid = UINT32_ACCESS_ONCE(proc->xmin);
++ xid = pg_atomic_read_u64(&proc->xmin);
+ if (proc->databaseId == MyDatabaseId &&
+ TransactionIdIsNormal(xid) &&
+ TransactionIdPrecedesOrEquals(xid, xmin))
+@@ -2645,7 +2637,7 @@ ProcArrayInstallRestoredXmin(TransactionId xmin, PGPROC *proc)
+ * Install xmin and propagate the statusFlags that affect how the
+ * value is interpreted by vacuum.
+ */
+- MyProc->xmin = TransactionXmin = xmin;
++ pg_atomic_write_u64(&MyProc->xmin, TransactionXmin = xmin);
+ MyProc->statusFlags = (MyProc->statusFlags & ~PROC_XMIN_FLAGS) |
+ (proc->statusFlags & PROC_XMIN_FLAGS);
+ ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
+@@ -2696,7 +2688,7 @@ GetRunningTransactionData(void)
+ static RunningTransactionsData CurrentRunningXactsData;
+
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ RunningTransactions CurrentRunningXacts = &CurrentRunningXactsData;
+ TransactionId latestCompletedXid;
+ TransactionId oldestRunningXid;
+@@ -2756,7 +2748,7 @@ GetRunningTransactionData(void)
+ TransactionId xid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
+
+ /*
+ * We don't need to store transactions that don't have a TransactionId
+@@ -2884,7 +2876,7 @@ TransactionId
+ GetOldestActiveTransactionId(void)
+ {
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ TransactionId oldestRunningXid;
+ int index;
+
+@@ -2910,7 +2902,7 @@ GetOldestActiveTransactionId(void)
+ TransactionId xid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
+
+ if (!TransactionIdIsNormal(xid))
+ continue;
+@@ -2998,7 +2990,7 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly)
+ */
+ if (!recovery_in_progress)
+ {
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+
+ /*
+ * Spin over procArray collecting min(ProcGlobal->xids[i])
+@@ -3008,7 +3000,7 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly)
+ TransactionId xid;
+
+ /* Fetch xid just once - see GetNewTransactionId */
+- xid = UINT32_ACCESS_ONCE(other_xids[index]);
++ xid = pg_atomic_read_u64(&(other_xids[index]));
+
+ if (!TransactionIdIsNormal(xid))
+ continue;
+@@ -3180,8 +3172,8 @@ ProcNumberGetTransactionIds(ProcNumber procNumber, TransactionId *xid,
+
+ if (proc->pid != 0)
+ {
+- *xid = proc->xid;
+- *xmin = proc->xmin;
++ *xid = pg_atomic_read_u64(&proc->xid);
++ *xmin = pg_atomic_read_u64(&proc->xmin);
+ *nsubxid = proc->subxidStatus.count;
+ *overflowed = proc->subxidStatus.overflowed;
+ }
+@@ -3261,7 +3253,7 @@ BackendXidGetPid(TransactionId xid)
+ {
+ int result = 0;
+ ProcArrayStruct *arrayP = procArray;
+- TransactionId *other_xids = ProcGlobal->xids;
++ pg_atomic_uint64 *other_xids = ProcGlobal->xids;
+ int index;
+
+ if (xid == InvalidTransactionId) /* never match invalid xid */
+@@ -3271,7 +3263,7 @@ BackendXidGetPid(TransactionId xid)
+
+ for (index = 0; index < arrayP->numProcs; index++)
+ {
+- if (other_xids[index] == xid)
++ if (pg_atomic_read_u64(&other_xids[index]) == xid)
+ {
+ int pgprocno = arrayP->pgprocnos[index];
+ PGPROC *proc = &allProcs[pgprocno];
+@@ -3355,7 +3347,7 @@ GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0,
+ if (allDbs || proc->databaseId == MyDatabaseId)
+ {
+ /* Fetch xmin just once - might change on us */
+- TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin);
++ TransactionId pxmin = pg_atomic_read_u64(&proc->xmin);
+
+ if (excludeXmin0 && !TransactionIdIsValid(pxmin))
+ continue;
+@@ -3455,7 +3447,7 @@ GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid)
+ proc->databaseId == dbOid)
+ {
+ /* Fetch xmin just once - can't change on us, but good coding */
+- TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin);
++ TransactionId pxmin = pg_atomic_read_u64(&proc->xmin);
+
+ /*
+ * We ignore an invalid pxmin because this means that backend has
+@@ -3582,7 +3574,7 @@ MinimumActiveBackends(int min)
+ continue; /* do not count deleted entries */
+ if (proc == MyProc)
+ continue; /* do not count myself */
+- if (proc->xid == InvalidTransactionId)
++ if (pg_atomic_read_u64(&proc->xid) == InvalidTransactionId)
+ continue; /* do not count if no XID assigned */
+ if (proc->pid == 0)
+ continue; /* do not count prepared xacts */
+@@ -4172,17 +4164,13 @@ static void
+ GlobalVisUpdateApply(ComputeXidHorizonsResult *horizons)
+ {
+ GlobalVisSharedRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->shared_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->shared_oldest_nonremovable);
+ GlobalVisCatalogRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->catalog_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->catalog_oldest_nonremovable);
+ GlobalVisDataRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->data_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->data_oldest_nonremovable);
+ GlobalVisTempRels.maybe_needed =
+- FullXidRelativeTo(horizons->latest_completed,
+- horizons->temp_oldest_nonremovable);
++ FullTransactionIdFromXid(horizons->temp_oldest_nonremovable);
+
+ /*
+ * In longer running transactions it's possible that transactions we
+@@ -4271,15 +4259,7 @@ GlobalVisTestIsRemovableXid(GlobalVisState *state, TransactionId xid)
+ {
+ FullTransactionId fxid;
+
+- /*
+- * Convert 32 bit argument to FullTransactionId. We can do so safely
+- * because we know the xid has to, at the very least, be between
+- * [oldestXid, nextXid), i.e. within 2 billion of xid. To avoid taking a
+- * lock to determine either, we can just compare with
+- * state->definitely_needed, which was based on those value at the time
+- * the current snapshot was built.
+- */
+- fxid = FullXidRelativeTo(state->definitely_needed, xid);
++ fxid = FullTransactionIdFromXid(xid);
+
+ return GlobalVisTestIsRemovableFullXid(state, fxid);
+ }
+@@ -4312,32 +4292,6 @@ GlobalVisCheckRemovableXid(Relation rel, TransactionId xid)
+ return GlobalVisTestIsRemovableXid(state, xid);
+ }
+
+-/*
+- * Convert a 32 bit transaction id into 64 bit transaction id, by assuming it
+- * is within MaxTransactionId / 2 of XidFromFullTransactionId(rel).
+- *
+- * Be very careful about when to use this function. It can only safely be used
+- * when there is a guarantee that xid is within MaxTransactionId / 2 xids of
+- * rel. That e.g. can be guaranteed if the caller assures a snapshot is
+- * held by the backend and xid is from a table (where vacuum/freezing ensures
+- * the xid has to be within that range), or if xid is from the procarray and
+- * prevents xid wraparound that way.
+- */
+-static inline FullTransactionId
+-FullXidRelativeTo(FullTransactionId rel, TransactionId xid)
+-{
+- TransactionId rel_xid = XidFromFullTransactionId(rel);
+-
+- Assert(TransactionIdIsValid(xid));
+- Assert(TransactionIdIsValid(rel_xid));
+-
+- /* not guaranteed to find issues, but likely to catch mistakes */
+- AssertTransactionIdInAllowableRange(xid);
+-
+- return FullTransactionIdFromU64(U64FromFullTransactionId(rel)
+- + (int32) (xid - rel_xid));
+-}
+-
+
+ /* ----------------------------------------------
+ * KnownAssignedTransactionIds sub-module
+diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c
+index 57821c172d8..6aaea1fa349 100644
+--- a/src/backend/storage/ipc/standby.c
++++ b/src/backend/storage/ipc/standby.c
+@@ -521,8 +521,8 @@ ResolveRecoveryConflictWithSnapshotFullXid(FullTransactionId snapshotConflictHor
+ FullTransactionId nextXid = ReadNextFullTransactionId();
+ uint64 diff;
+
+- diff = U64FromFullTransactionId(nextXid) -
+- U64FromFullTransactionId(snapshotConflictHorizon);
++ diff = XidFromFullTransactionId(nextXid) -
++ XidFromFullTransactionId(snapshotConflictHorizon);
+ if (diff < MaxTransactionId / 2)
+ {
+ TransactionId truncated;
+diff --git a/src/backend/storage/lmgr/lmgr.c b/src/backend/storage/lmgr/lmgr.c
+index 9f43620e472..b16e1fb0748 100644
+--- a/src/backend/storage/lmgr/lmgr.c
++++ b/src/backend/storage/lmgr/lmgr.c
+@@ -1266,10 +1266,16 @@ DescribeLockTag(StringInfo buf, const LOCKTAG *tag)
+ tag->locktag_field1);
+ break;
+ case LOCKTAG_TRANSACTION:
+- appendStringInfo(buf,
+- _("transaction %u"),
+- tag->locktag_field1);
+- break;
++ {
++ TransactionId xid;
++
++ xid = (TransactionId) tag->locktag_field2 << 32;
++ xid += tag->locktag_field1;
++
++ appendStringInfo(buf, _("transaction %llu"),
++ (unsigned long long) xid);
++ break;
++ }
+ case LOCKTAG_VIRTUALTRANSACTION:
+ appendStringInfo(buf,
+ _("virtual transaction %d/%u"),
+diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c
+index 0576bb75b23..7700e9f8893 100644
+--- a/src/backend/storage/lmgr/lock.c
++++ b/src/backend/storage/lmgr/lock.c
+@@ -4120,7 +4120,7 @@ GetRunningTransactionLocks(int *nlocks)
+ {
+ PGPROC *proc = proclock->tag.myProc;
+ LOCK *lock = proclock->tag.myLock;
+- TransactionId xid = proc->xid;
++ TransactionId xid = pg_atomic_read_u64(&proc->xid);
+
+ /*
+ * Don't record locks for transactions if we know they have
+@@ -4740,7 +4740,7 @@ VirtualXactLock(VirtualTransactionId vxid, bool wait)
+ * so we won't save an XID of a different VXID. It doesn't matter whether
+ * we save this before or after setting up the primary lock table entry.
+ */
+- xid = proc->xid;
++ xid = pg_atomic_read_u64(&proc->xid);
+
+ /* Done with proc->fpLockBits */
+ LWLockRelease(&proc->fpInfoLock);
+diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
+index 0e147f7501a..6dad5710277 100644
+--- a/src/backend/storage/lmgr/predicate.c
++++ b/src/backend/storage/lmgr/predicate.c
+@@ -338,9 +338,9 @@ static SlruCtlData SerialSlruCtlData;
+
+ #define SerialValue(slotno, xid) (*((SerCommitSeqNo *) \
+ (SerialSlruCtl->shared->page_buffer[slotno] + \
+- ((((uint32) (xid)) % SERIAL_ENTRIESPERPAGE) * SERIAL_ENTRYSIZE))))
++ ((((uint64) (xid)) % SERIAL_ENTRIESPERPAGE) * SERIAL_ENTRYSIZE))))
+
+-#define SerialPage(xid) (((uint32) (xid)) / SERIAL_ENTRIESPERPAGE)
++#define SerialPage(xid) ((int64) (((uint64) (xid)) / SERIAL_ENTRIESPERPAGE))
+
+ typedef struct SerialControlData
+ {
+@@ -1077,31 +1077,6 @@ CheckPointPredicate(void)
+ /*----------
+ * The SLRU is no longer needed. Truncate to head before we set head
+ * invalid.
+- *
+- * XXX: It's possible that the SLRU is not needed again until XID
+- * wrap-around has happened, so that the segment containing headPage
+- * that we leave behind will appear to be new again. In that case it
+- * won't be removed until XID horizon advances enough to make it
+- * current again.
+- *
+- * XXX: This should happen in vac_truncate_clog(), not in checkpoints.
+- * Consider this scenario, starting from a system with no in-progress
+- * transactions and VACUUM FREEZE having maximized oldestXact:
+- * - Start a SERIALIZABLE transaction.
+- * - Start, finish, and summarize a SERIALIZABLE transaction, creating
+- * one SLRU page.
+- * - Consume XIDs to reach xidStopLimit.
+- * - Finish all transactions. Due to the long-running SERIALIZABLE
+- * transaction, earlier checkpoints did not touch headPage. The
+- * next checkpoint will change it, but that checkpoint happens after
+- * the end of the scenario.
+- * - VACUUM to advance XID limits.
+- * - Consume ~2M XIDs, crossing the former xidWrapLimit.
+- * - Start, finish, and summarize a SERIALIZABLE transaction.
+- * SerialAdd() declines to create the targetPage, because headPage
+- * is not regarded as in the past relative to that targetPage. The
+- * transaction instigating the summarize fails in
+- * SimpleLruReadPage().
+ */
+ truncateCutoffPage = serialControl->headPage;
+ serialControl->headPage = -1;
+@@ -3974,7 +3949,7 @@ XidIsConcurrent(TransactionId xid)
+ if (TransactionIdFollowsOrEquals(xid, snap->xmax))
+ return true;
+
+- return pg_lfind32(xid, snap->xip, snap->xcnt);
++ return pg_lfind64(xid, snap->xip, snap->xcnt);
+ }
+
+ bool
+diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
+index 720ef99ee83..512616dce37 100644
+--- a/src/backend/storage/lmgr/proc.c
++++ b/src/backend/storage/lmgr/proc.c
+@@ -217,7 +217,7 @@ InitProcGlobal(void)
+ * how hotly they are accessed.
+ */
+ ProcGlobal->xids =
+- (TransactionId *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->xids));
++ (pg_atomic_uint64 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->xids));
+ MemSet(ProcGlobal->xids, 0, TotalProcs * sizeof(*ProcGlobal->xids));
+ ProcGlobal->subxidStates = (XidCacheStatus *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->subxidStates));
+ MemSet(ProcGlobal->subxidStates, 0, TotalProcs * sizeof(*ProcGlobal->subxidStates));
+@@ -244,6 +244,8 @@ InitProcGlobal(void)
+
+ /* Common initialization for all PGPROCs, regardless of type. */
+
++ pg_atomic_init_u64(&ProcGlobal->xids[i], 0);
++
+ /*
+ * Set the fast-path lock arrays, and move the pointer. We interleave
+ * the two arrays, to (hopefully) get some locality for each backend.
+@@ -418,8 +420,8 @@ InitProcess(void)
+ MyProc->waitStatus = PROC_WAIT_STATUS_OK;
+ MyProc->fpVXIDLock = false;
+ MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
+- MyProc->xid = InvalidTransactionId;
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_init_u64(&MyProc->xid, InvalidTransactionId);
++ pg_atomic_init_u64(&MyProc->xmin, InvalidTransactionId);
+ MyProc->pid = MyProcPid;
+ MyProc->vxid.procNumber = MyProcNumber;
+ MyProc->vxid.lxid = InvalidLocalTransactionId;
+@@ -619,8 +621,8 @@ InitAuxiliaryProcess(void)
+ MyProc->waitStatus = PROC_WAIT_STATUS_OK;
+ MyProc->fpVXIDLock = false;
+ MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
+- MyProc->xid = InvalidTransactionId;
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_init_u64(&MyProc->xid, InvalidTransactionId);
++ pg_atomic_init_u64(&MyProc->xmin, InvalidTransactionId);
+ MyProc->vxid.procNumber = INVALID_PROC_NUMBER;
+ MyProc->vxid.lxid = InvalidLocalTransactionId;
+ MyProc->databaseId = InvalidOid;
+diff --git a/src/backend/storage/page/bufpage.c b/src/backend/storage/page/bufpage.c
+index aa264f61b9c..8528155ee36 100644
+--- a/src/backend/storage/page/bufpage.c
++++ b/src/backend/storage/page/bufpage.c
+@@ -21,11 +21,31 @@
+ #include "storage/checksum.h"
+ #include "utils/memdebug.h"
+ #include "utils/memutils.h"
++#include "utils/snapmgr.h"
+
+
+ /* GUC variable */
+ bool ignore_checksum_failure = false;
+
++/*
++ * HeapPageSpecialData used when pd_special == BLCKSZ. This is special format
++ * used when page with 32-bit xids doesn't fit HeapPageSpecialData. Then
++ * all xmin's are frozen (can do this for all live tuples after pg_upgrade),
++ * while 64-bit xmax is stored in both t_heap.t_xmin and t_heap.t_xmax.
++ * This is so-called "double xmax" format.
++ */
++static HeapPageSpecialData heapDoubleXmaxSpecialData =
++{
++ .pd_xid_base = MaxTransactionId,
++ .pd_multi_base = MaxTransactionId
++};
++HeapPageSpecial heapDoubleXmaxSpecial = &heapDoubleXmaxSpecialData;
++
++static ToastPageSpecialData toastDoubleXmaxSpecialData =
++{
++ .pd_xid_base = MaxTransactionId
++};
++ToastPageSpecial toastDoubleXmaxSpecial = &toastDoubleXmaxSpecialData;
+
+ /* ----------------------------------------------------------------
+ * Page support functions
+@@ -421,15 +441,144 @@ PageRestoreTempPage(Page tempPage, Page oldPage)
+ }
+
+ /*
+- * Tuple defrag support for PageRepairFragmentation and PageIndexMultiDelete
++ * Get minimum and maximum values of xid and multixact on "double xmax" page.
+ */
+-typedef struct itemIdCompactData
++static void
++heap_page_double_xmax_get_min_max(Page page,
++ TransactionId *xid_min,
++ TransactionId *xid_max,
++ MultiXactId *multi_min,
++ MultiXactId *multi_max)
+ {
+- uint16 offsetindex; /* linp array index */
+- int16 itemoff; /* page offset of item data */
+- uint16 alignedlen; /* MAXALIGN(item data len) */
+-} itemIdCompactData;
+-typedef itemIdCompactData *itemIdCompact;
++ bool xid_found = false,
++ multi_found = false;
++ OffsetNumber offnum,
++ maxoff;
++
++ maxoff = PageGetMaxOffsetNumber(page);
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ ItemId itemid;
++ HeapTupleHeader htup;
++ TransactionId xmax;
++
++ itemid = PageGetItemId(page, offnum);
++
++ if (!ItemIdIsNormal(itemid))
++ continue;
++
++ htup = (HeapTupleHeader) PageGetItem(page, itemid);
++
++ xmax = HeapTupleHeaderGetDoubleXmax(htup);
++
++ if (!TransactionIdIsNormal(xmax))
++ continue;
++
++ if (!(htup->t_infomask & HEAP_XMAX_IS_MULTI))
++ {
++ if (!xid_found)
++ {
++ *xid_min = *xid_max = xmax;
++ xid_found = true;
++ }
++ else
++ {
++ *xid_min = Min(*xid_min, xmax);
++ *xid_max = Max(*xid_max, xmax);
++ }
++ }
++ else
++ {
++ if (!multi_found)
++ {
++ *multi_min = *multi_max = xmax;
++ multi_found = true;
++ }
++ else
++ {
++ *multi_min = Min(*multi_min, xmax);
++ *multi_max = Max(*multi_max, xmax);
++ }
++ }
++ }
++}
++
++/*
++ * Add special area to heap page, so convert from "double xmax" to normal
++ * format.
++ */
++static void
++heap_page_add_special_area(ItemIdCompact itemidbase, int nitems, Page page,
++ TransactionId xid_base, MultiXactId multi_base,
++ bool is_toast)
++{
++ char newPage[BLCKSZ];
++ PageHeader phdr = (PageHeader) page;
++ PageHeader new_phdr = (PageHeader) newPage;
++ Offset upper;
++ int i;
++
++ memcpy(newPage, page, phdr->pd_lower);
++
++ /* Add special area */
++ if (is_toast)
++ {
++ ToastPageSpecial special;
++
++ new_phdr->pd_special = PageGetPageSize(newPage) - sizeof(ToastPageSpecialData);
++ special = (ToastPageSpecial) ((Pointer) (newPage) + new_phdr->pd_special);
++ special->pd_xid_base = xid_base;
++ }
++ else
++ {
++ HeapPageSpecial special;
++
++ new_phdr->pd_special = PageGetPageSize(newPage) - sizeof(HeapPageSpecialData);
++ special = (HeapPageSpecial) ((Pointer) (newPage) + new_phdr->pd_special);
++ special->pd_xid_base = xid_base;
++ special->pd_multi_base = multi_base;
++ }
++
++ /* sort itemIdSortData array into decreasing itemoff order */
++ qsort((char *) itemidbase, nitems, sizeof(ItemIdCompactData),
++ itemoffcompare);
++
++ upper = new_phdr->pd_special;
++ for (i = 0; i < nitems; i++)
++ {
++ ItemIdCompact itemidptr = &itemidbase[i];
++ ItemId lp;
++ HeapTupleHeader old_htup;
++ HeapTupleHeader new_htup;
++ TransactionId xmax;
++
++ lp = PageGetItemId(page, itemidptr->offsetindex + 1);
++ old_htup = (HeapTupleHeader) PageGetItem(page, lp);
++ upper -= itemidptr->alignedlen;
++ memcpy((Pointer) newPage + upper,
++ (Pointer) page + itemidptr->itemoff,
++ itemidptr->alignedlen);
++ lp = PageGetItemId(newPage, itemidptr->offsetindex + 1);
++ lp->lp_off = upper;
++ new_htup = (HeapTupleHeader) PageGetItem(newPage, lp);
++
++ /* Convert xmax value */
++ new_htup->t_choice.t_heap.t_xmin = FrozenTransactionId;
++ xmax = HeapTupleHeaderGetDoubleXmax(old_htup);
++ if (!(new_htup->t_infomask & HEAP_XMAX_IS_MULTI))
++ new_htup->t_choice.t_heap.t_xmax = NormalTransactionIdToShort(xid_base, xmax);
++ else
++ new_htup->t_choice.t_heap.t_xmax = NormalTransactionIdToShort(multi_base, xmax);
++ }
++
++ new_phdr->pd_upper = upper;
++
++ memcpy(page, newPage, PageGetPageSize(newPage));
++ elog(DEBUG2, "convert heap page from double xmax to normal format");
++}
+
+ /*
+ * After removing or marking some line pointers unused, move the tuples to
+@@ -460,21 +609,47 @@ typedef itemIdCompactData *itemIdCompact;
+ * Callers must ensure that nitems is > 0
+ */
+ static void
+-compactify_tuples(itemIdCompact itemidbase, int nitems, Page page, bool presorted)
++compactify_tuples(ItemIdCompact itemidbase, int nitems, Page page,
++ bool presorted, bool addspecial, bool is_toast)
+ {
+ PageHeader phdr = (PageHeader) page;
+ Offset upper;
+ Offset copy_tail;
+ Offset copy_head;
+- itemIdCompact itemidptr;
++ ItemIdCompact itemidptr;
+ int i;
+
+ /* Code within will not work correctly if nitems == 0 */
+ Assert(nitems > 0);
+
+- if (presorted)
++ /* Add special area to the heap page if possible */
++ if (addspecial)
+ {
++ TransactionId xid_min = FirstNormalTransactionId,
++ xid_max = FirstNormalTransactionId;
++ MultiXactId multi_min = FirstNormalTransactionId,
++ multi_max = FirstNormalTransactionId;
+
++ Assert(phdr->pd_special == PageGetPageSize(page));
++
++ heap_page_double_xmax_get_min_max(page, &xid_min, &xid_max,
++ &multi_min, &multi_max);
++
++ if (xid_max - xid_min < (TransactionId) (MaxShortTransactionId - FirstNormalTransactionId) &&
++ multi_max - multi_min < (TransactionId) (MaxShortTransactionId - FirstNormalTransactionId))
++ {
++ Assert(xid_min >= FirstNormalTransactionId);
++ Assert(multi_min >= FirstNormalTransactionId);
++ heap_page_add_special_area(itemidbase, nitems, page,
++ xid_min - FirstNormalTransactionId,
++ multi_min - FirstNormalTransactionId,
++ is_toast);
++ return;
++ }
++ }
++
++ if (presorted)
++ {
+ #ifdef USE_ASSERT_CHECKING
+ {
+ /*
+@@ -685,14 +860,14 @@ compactify_tuples(itemIdCompact itemidbase, int nitems, Page page, bool presorte
+ * the line pointer array following array truncation.
+ */
+ void
+-PageRepairFragmentation(Page page)
++PageRepairFragmentation(Page page, bool is_toast)
+ {
+ Offset pd_lower = ((PageHeader) page)->pd_lower;
+ Offset pd_upper = ((PageHeader) page)->pd_upper;
+ Offset pd_special = ((PageHeader) page)->pd_special;
+ Offset last_offset;
+- itemIdCompactData itemidbase[MaxHeapTuplesPerPage];
+- itemIdCompact itemidptr;
++ ItemIdCompactData itemidbase[MaxHeapTuplesPerPage];
++ ItemIdCompact itemidptr;
+ ItemId lp;
+ int nline,
+ nstorage,
+@@ -766,11 +941,30 @@ PageRepairFragmentation(Page page)
+ nstorage = itemidptr - itemidbase;
+ if (nstorage == 0)
+ {
++ if (pd_special == PageGetPageSize(page))
++ {
++ if (is_toast)
++ {
++ pd_special = PageGetPageSize(page) - sizeof(ToastPageSpecialData);
++ ((PageHeader) page)->pd_special = pd_special;
++ ToastPageGetSpecial(page)->pd_xid_base = 0;
++ }
++ else
++ {
++ pd_special = PageGetPageSize(page) - sizeof(HeapPageSpecialData);
++ ((PageHeader) page)->pd_special = pd_special;
++ HeapPageGetSpecial(page)->pd_xid_base = 0;
++ HeapPageGetSpecial(page)->pd_multi_base = 0;
++ }
++ }
++
+ /* Page is completely empty, so just reset it quickly */
+ ((PageHeader) page)->pd_upper = pd_special;
+ }
+ else
+ {
++ bool addspecial = false;
++
+ /* Need to compact the page the hard way */
+ if (totallen > (Size) (pd_special - pd_lower))
+ ereport(ERROR,
+@@ -778,7 +972,25 @@ PageRepairFragmentation(Page page)
+ errmsg("corrupted item lengths: total %u, available space %u",
+ (unsigned int) totallen, pd_special - pd_lower)));
+
+- compactify_tuples(itemidbase, nstorage, page, presorted);
++ /*
++ * Try to add special area to the heap page if it has enough of free
++ * space.
++ */
++ if (pd_special == PageGetPageSize(page))
++ {
++ Size special_size,
++ actual_size;
++
++ special_size = is_toast ? sizeof(ToastPageSpecialData) :
++ sizeof(HeapPageSpecialData);
++ actual_size = (Size) (pd_special - pd_lower) - totallen;
++
++ if (actual_size >= special_size)
++ addspecial = true;
++ }
++
++ compactify_tuples(itemidbase, nstorage, page, presorted, addspecial,
++ is_toast);
+ }
+
+ if (finalusedlp != nline)
+@@ -981,6 +1193,9 @@ PageGetHeapFreeSpace(Page page)
+ {
+ Size space;
+
++ if (HeapPageIsDoubleXmax(page))
++ return 0;
++
+ space = PageGetFreeSpace(page);
+ if (space > 0)
+ {
+@@ -1154,9 +1369,9 @@ PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)
+ Offset pd_upper = phdr->pd_upper;
+ Offset pd_special = phdr->pd_special;
+ Offset last_offset;
+- itemIdCompactData itemidbase[MaxIndexTuplesPerPage];
++ ItemIdCompactData itemidbase[MaxIndexTuplesPerPage];
+ ItemIdData newitemids[MaxIndexTuplesPerPage];
+- itemIdCompact itemidptr;
++ ItemIdCompact itemidptr;
+ ItemId lp;
+ int nline,
+ nused;
+@@ -1264,7 +1479,12 @@ PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)
+
+ /* and compactify the tuple data */
+ if (nused > 0)
+- compactify_tuples(itemidbase, nused, page, presorted);
++ {
++ bool is_toast;
++
++ is_toast = BLCKSZ - pd_special == sizeof(ToastPageSpecialData);
++ compactify_tuples(itemidbase, nused, page, presorted, false, is_toast);
++ }
+ else
+ phdr->pd_upper = pd_special;
+ }
+diff --git a/src/backend/utils/adt/enum.c b/src/backend/utils/adt/enum.c
+index d4c2aa0e7e9..61c3bca4891 100644
+--- a/src/backend/utils/adt/enum.c
++++ b/src/backend/utils/adt/enum.c
+@@ -76,7 +76,7 @@ check_safe_enum_use(HeapTuple enumval_tup)
+ * Usually, a row would get hinted as committed when it's read or loaded
+ * into syscache; but just in case not, let's check the xmin directly.
+ */
+- xmin = HeapTupleHeaderGetXmin(enumval_tup->t_data);
++ xmin = HeapTupleGetXmin(enumval_tup);
+ if (!TransactionIdIsInProgress(xmin) &&
+ TransactionIdDidCommit(xmin))
+ return;
+diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
+index 68c0a31656e..80b9bc37b80 100644
+--- a/src/backend/utils/adt/jsonfuncs.c
++++ b/src/backend/utils/adt/jsonfuncs.c
+@@ -3565,6 +3565,7 @@ populate_record(TupleDesc tupdesc,
+ tuple.t_len = HeapTupleHeaderGetDatumLength(defaultval);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = defaultval;
+
+ /* Break down the tuple into fields */
+@@ -4027,6 +4028,7 @@ populate_recordset_record(PopulateRecordsetState *state, JsObject *obj)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(tuphead);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = tuphead;
+
+ tuplestore_puttuple(state->tuple_store, &tuple);
+diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c
+index e38cf548243..b07cfbc6bb1 100644
+--- a/src/backend/utils/adt/lockfuncs.c
++++ b/src/backend/utils/adt/lockfuncs.c
+@@ -78,7 +78,7 @@ VXIDGetDatum(ProcNumber procNumber, LocalTransactionId lxid)
+ * decimal respectively. Note that elog.c also knows how to format a
+ * vxid.
+ */
+- char vxidstr[32];
++ char vxidstr[64];
+
+ snprintf(vxidstr, sizeof(vxidstr), "%d/%llu", procNumber, (unsigned long long) lxid);
+
+@@ -291,7 +291,9 @@ pg_lock_status(PG_FUNCTION_ARGS)
+ break;
+ case LOCKTAG_TRANSACTION:
+ values[6] =
+- TransactionIdGetDatum(instance->locktag.locktag_field1);
++ TransactionIdGetDatum(
++ (TransactionId) instance->locktag.locktag_field1 |
++ ((TransactionId) instance->locktag.locktag_field2 << 32));
+ nulls[1] = true;
+ nulls[2] = true;
+ nulls[3] = true;
+@@ -303,7 +305,8 @@ pg_lock_status(PG_FUNCTION_ARGS)
+ break;
+ case LOCKTAG_VIRTUALTRANSACTION:
+ values[5] = VXIDGetDatum(instance->locktag.locktag_field1,
+- instance->locktag.locktag_field2);
++ (TransactionId) instance->locktag.locktag_field2 |
++ ((TransactionId) instance->locktag.locktag_field3 << 32));
+ nulls[1] = true;
+ nulls[2] = true;
+ nulls[3] = true;
+diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c
+index 60a397dc561..44fd9e0a39b 100644
+--- a/src/backend/utils/adt/pgstatfuncs.c
++++ b/src/backend/utils/adt/pgstatfuncs.c
+@@ -15,6 +15,7 @@
+ #include "postgres.h"
+
+ #include "access/htup_details.h"
++#include "access/xact.h"
+ #include "access/xlog.h"
+ #include "access/xlogprefetcher.h"
+ #include "catalog/catalog.h"
+diff --git a/src/backend/utils/adt/rowtypes.c b/src/backend/utils/adt/rowtypes.c
+index 18bbb62e9a1..2b7b855b1af 100644
+--- a/src/backend/utils/adt/rowtypes.c
++++ b/src/backend/utils/adt/rowtypes.c
+@@ -353,6 +353,7 @@ record_out(PG_FUNCTION_ARGS)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = rec;
+
+ /*
+@@ -711,6 +712,7 @@ record_send(PG_FUNCTION_ARGS)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = rec;
+
+ /*
+@@ -861,10 +863,12 @@ record_cmp(FunctionCallInfo fcinfo)
+ tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple1.t_data = record1;
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple2);
+ tuple2.t_data = record2;
+
+ /*
+@@ -1106,10 +1110,12 @@ record_eq(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
+ tuple1.t_data = record1;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
+ tuple2.t_data = record2;
++ HeapTupleSetZeroXids(&tuple2);
+
+ /*
+ * We arrange to look up the needed comparison info just once per series
+@@ -1386,10 +1392,12 @@ record_image_cmp(FunctionCallInfo fcinfo)
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
+ tuple1.t_data = record1;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
+ tuple2.t_data = record2;
++ HeapTupleSetZeroXids(&tuple2);
+
+ /*
+ * We arrange to look up the needed comparison info just once per series
+@@ -1632,10 +1640,12 @@ record_image_eq(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple1.t_self));
+ tuple1.t_tableOid = InvalidOid;
+ tuple1.t_data = record1;
++ HeapTupleSetZeroXids(&tuple1);
+ tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
+ ItemPointerSetInvalid(&(tuple2.t_self));
+ tuple2.t_tableOid = InvalidOid;
+ tuple2.t_data = record2;
++ HeapTupleSetZeroXids(&tuple2);
+
+ /*
+ * We arrange to look up the needed comparison info just once per series
+@@ -1835,6 +1845,7 @@ hash_record(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = record;
++ HeapTupleSetZeroXids(&tuple);
+
+ /*
+ * We arrange to look up the needed hashing info just once per series of
+@@ -1956,6 +1967,7 @@ hash_record_extended(PG_FUNCTION_ARGS)
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
+ tuple.t_data = record;
++ HeapTupleSetZeroXids(&tuple);
+
+ /*
+ * We arrange to look up the needed hashing info just once per series of
+diff --git a/src/backend/utils/adt/xid.c b/src/backend/utils/adt/xid.c
+index 2f34a5dc1f0..060e0a76cdd 100644
+--- a/src/backend/utils/adt/xid.c
++++ b/src/backend/utils/adt/xid.c
+@@ -35,7 +35,7 @@ xidin(PG_FUNCTION_ARGS)
+ char *str = PG_GETARG_CSTRING(0);
+ TransactionId result;
+
+- result = uint32in_subr(str, NULL, "xid", fcinfo->context);
++ result = uint64in_subr(str, NULL, "xid", fcinfo->context);
+ PG_RETURN_TRANSACTIONID(result);
+ }
+
+@@ -43,9 +43,9 @@ Datum
+ xidout(PG_FUNCTION_ARGS)
+ {
+ TransactionId transactionId = PG_GETARG_TRANSACTIONID(0);
+- char *result = (char *) palloc(16);
++ char *result = (char *) palloc(32);
+
+- snprintf(result, 16, "%lu", (unsigned long) transactionId);
++ snprintf(result, 32, "%llu", (unsigned long long) transactionId);
+ PG_RETURN_CSTRING(result);
+ }
+
+@@ -56,8 +56,13 @@ Datum
+ xidrecv(PG_FUNCTION_ARGS)
+ {
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
++ uint32 lo,
++ hi;
++
++ lo = (uint32) pq_getmsgint(buf, sizeof(TransactionId));
++ hi = (uint32) pq_getmsgint(buf, sizeof(TransactionId));
+
+- PG_RETURN_TRANSACTIONID((TransactionId) pq_getmsgint(buf, sizeof(TransactionId)));
++ PG_RETURN_TRANSACTIONID((uint64) lo + ((uint64) hi << 32));
+ }
+
+ /*
+@@ -68,9 +73,15 @@ xidsend(PG_FUNCTION_ARGS)
+ {
+ TransactionId arg1 = PG_GETARG_TRANSACTIONID(0);
+ StringInfoData buf;
++ uint32 lo,
++ hi;
++
++ lo = (uint32) (arg1 & 0xFFFFFFFF);
++ hi = (uint32) (arg1 >> 32);
+
+ pq_begintypsend(&buf);
+- pq_sendint32(&buf, arg1);
++ pq_sendint(&buf, lo, sizeof(lo));
++ pq_sendint(&buf, hi, sizeof(hi));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
+
+@@ -121,9 +132,9 @@ xid_age(PG_FUNCTION_ARGS)
+
+ /* Permanent XIDs are always infinitely old */
+ if (!TransactionIdIsNormal(xid))
+- PG_RETURN_INT32(INT_MAX);
++ PG_RETURN_INT64(PG_INT8_MAX);
+
+- PG_RETURN_INT32((int32) (now - xid));
++ PG_RETURN_INT64((int64) (now - xid));
+ }
+
+ /*
+@@ -136,9 +147,9 @@ mxid_age(PG_FUNCTION_ARGS)
+ MultiXactId now = ReadNextMultiXactId();
+
+ if (!MultiXactIdIsValid(xid))
+- PG_RETURN_INT32(INT_MAX);
++ PG_RETURN_INT64(PG_INT8_MAX);
+
+- PG_RETURN_INT32((int32) (now - xid));
++ PG_RETURN_INT64((int64) (now - xid));
+ }
+
+ /*
+@@ -198,7 +209,7 @@ xid8in(PG_FUNCTION_ARGS)
+ uint64 result;
+
+ result = uint64in_subr(str, NULL, "xid8", fcinfo->context);
+- PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromU64(result));
++ PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromXid(result));
+ }
+
+ Datum
+@@ -207,7 +218,7 @@ xid8out(PG_FUNCTION_ARGS)
+ FullTransactionId fxid = PG_GETARG_FULLTRANSACTIONID(0);
+ char *result = (char *) palloc(21);
+
+- snprintf(result, 21, UINT64_FORMAT, U64FromFullTransactionId(fxid));
++ snprintf(result, 21, UINT64_FORMAT, XidFromFullTransactionId(fxid));
+ PG_RETURN_CSTRING(result);
+ }
+
+@@ -218,7 +229,7 @@ xid8recv(PG_FUNCTION_ARGS)
+ uint64 value;
+
+ value = (uint64) pq_getmsgint64(buf);
+- PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromU64(value));
++ PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromXid(value));
+ }
+
+ Datum
+@@ -228,7 +239,7 @@ xid8send(PG_FUNCTION_ARGS)
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+- pq_sendint64(&buf, (uint64) U64FromFullTransactionId(arg1));
++ pq_sendint64(&buf, (uint64) XidFromFullTransactionId(arg1));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
+
+diff --git a/src/backend/utils/adt/xid8funcs.c b/src/backend/utils/adt/xid8funcs.c
+index 12d20b72a03..2fe797f7769 100644
+--- a/src/backend/utils/adt/xid8funcs.c
++++ b/src/backend/utils/adt/xid8funcs.c
+@@ -86,8 +86,7 @@ StaticAssertDecl(MAX_BACKENDS * 2 <= PG_SNAPSHOT_MAX_NXIP,
+ * It is an ERROR if the xid is in the future. Otherwise, returns true if
+ * the transaction is still new enough that we can determine whether it
+ * committed and false otherwise. If *extracted_xid is not NULL, it is set
+- * to the low 32 bits of the transaction ID (i.e. the actual XID, without the
+- * epoch).
++ * to the actual transaction ID.
+ *
+ * The caller must hold XactTruncationLock since it's dealing with arbitrary
+ * XIDs, and must continue to hold it until it's done with any clog lookups
+@@ -97,15 +96,13 @@ static bool
+ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
+ {
+ TransactionId xid = XidFromFullTransactionId(fxid);
+- uint32 now_epoch;
+- TransactionId now_epoch_next_xid;
++ TransactionId next_xid;
+ FullTransactionId now_fullxid;
+ TransactionId oldest_xid;
+ FullTransactionId oldest_fxid;
+
+ now_fullxid = ReadNextFullTransactionId();
+- now_epoch_next_xid = XidFromFullTransactionId(now_fullxid);
+- now_epoch = EpochFromFullTransactionId(now_fullxid);
++ next_xid = XidFromFullTransactionId(now_fullxid);
+
+ if (extracted_xid != NULL)
+ *extracted_xid = xid;
+@@ -122,7 +119,7 @@ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("transaction ID %llu is in the future",
+- (unsigned long long) U64FromFullTransactionId(fxid))));
++ (unsigned long long) XidFromFullTransactionId(fxid))));
+
+ /*
+ * TransamVariables->oldestClogXid is protected by XactTruncationLock, but
+@@ -137,52 +134,14 @@ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
+ * If fxid is not older than TransamVariables->oldestClogXid, the relevant
+ * CLOG entry is guaranteed to still exist. Convert
+ * TransamVariables->oldestClogXid into a FullTransactionId to compare it
+- * with fxid. Determine the right epoch knowing that oldest_fxid
+- * shouldn't be more than 2^31 older than now_fullxid.
++ * with fxid.
+ */
+ oldest_xid = TransamVariables->oldestClogXid;
+- Assert(TransactionIdPrecedesOrEquals(oldest_xid, now_epoch_next_xid));
+- if (oldest_xid <= now_epoch_next_xid)
+- {
+- oldest_fxid = FullTransactionIdFromEpochAndXid(now_epoch, oldest_xid);
+- }
+- else
+- {
+- Assert(now_epoch > 0);
+- oldest_fxid = FullTransactionIdFromEpochAndXid(now_epoch - 1, oldest_xid);
+- }
++ oldest_fxid = FullTransactionIdFromXid(oldest_xid);
++ Assert(TransactionIdPrecedesOrEquals(oldest_xid, next_xid));
+ return !FullTransactionIdPrecedes(fxid, oldest_fxid);
+ }
+
+-/*
+- * Convert a TransactionId obtained from a snapshot held by the caller to a
+- * FullTransactionId. Use next_fxid as a reference FullTransactionId, so that
+- * we can compute the high order bits. It must have been obtained by the
+- * caller with ReadNextFullTransactionId() after the snapshot was created.
+- */
+-static FullTransactionId
+-widen_snapshot_xid(TransactionId xid, FullTransactionId next_fxid)
+-{
+- TransactionId next_xid = XidFromFullTransactionId(next_fxid);
+- uint32 epoch = EpochFromFullTransactionId(next_fxid);
+-
+- /* Special transaction ID. */
+- if (!TransactionIdIsNormal(xid))
+- return FullTransactionIdFromEpochAndXid(0, xid);
+-
+- /*
+- * The 64 bit result must be <= next_fxid, since next_fxid hadn't been
+- * issued yet when the snapshot was created. Every TransactionId in the
+- * snapshot must therefore be from the same epoch as next_fxid, or the
+- * epoch before. We know this because next_fxid is never allow to get
+- * more than one epoch ahead of the TransactionIds in any snapshot.
+- */
+- if (xid > next_xid)
+- epoch--;
+-
+- return FullTransactionIdFromEpochAndXid(epoch, xid);
+-}
+-
+ /*
+ * txid comparator for qsort/bsearch
+ */
+@@ -309,12 +268,12 @@ parse_snapshot(const char *str, Node *escontext)
+ char *endp;
+ StringInfo buf;
+
+- xmin = FullTransactionIdFromU64(strtou64(str, &endp, 10));
++ xmin = FullTransactionIdFromXid(strtou64(str, &endp, 10));
+ if (*endp != ':')
+ goto bad_format;
+ str = endp + 1;
+
+- xmax = FullTransactionIdFromU64(strtou64(str, &endp, 10));
++ xmax = FullTransactionIdFromXid(strtou64(str, &endp, 10));
+ if (*endp != ':')
+ goto bad_format;
+ str = endp + 1;
+@@ -332,7 +291,7 @@ parse_snapshot(const char *str, Node *escontext)
+ while (*str != '\0')
+ {
+ /* read next value */
+- val = FullTransactionIdFromU64(strtou64(str, &endp, 10));
++ val = FullTransactionIdFromXid(strtou64(str, &endp, 10));
+ str = endp;
+
+ /* require the input to be in order */
+@@ -410,7 +369,6 @@ pg_current_snapshot(PG_FUNCTION_ARGS)
+ uint32 nxip,
+ i;
+ Snapshot cur;
+- FullTransactionId next_fxid = ReadNextFullTransactionId();
+
+ cur = GetActiveSnapshot();
+ if (cur == NULL)
+@@ -421,11 +379,11 @@ pg_current_snapshot(PG_FUNCTION_ARGS)
+ snap = palloc(PG_SNAPSHOT_SIZE(nxip));
+
+ /* fill */
+- snap->xmin = widen_snapshot_xid(cur->xmin, next_fxid);
+- snap->xmax = widen_snapshot_xid(cur->xmax, next_fxid);
++ snap->xmin = FullTransactionIdFromXid(cur->xmin);
++ snap->xmax = FullTransactionIdFromXid(cur->xmax);
+ snap->nxip = nxip;
+ for (i = 0; i < nxip; i++)
+- snap->xip[i] = widen_snapshot_xid(cur->xip[i], next_fxid);
++ snap->xip[i] = FullTransactionIdFromXid(cur->xip[i]);
+
+ /*
+ * We want them guaranteed to be in ascending order. This also removes
+@@ -473,16 +431,16 @@ pg_snapshot_out(PG_FUNCTION_ARGS)
+ initStringInfo(&str);
+
+ appendStringInfo(&str, UINT64_FORMAT ":",
+- U64FromFullTransactionId(snap->xmin));
++ XidFromFullTransactionId(snap->xmin));
+ appendStringInfo(&str, UINT64_FORMAT ":",
+- U64FromFullTransactionId(snap->xmax));
++ XidFromFullTransactionId(snap->xmax));
+
+ for (i = 0; i < snap->nxip; i++)
+ {
+ if (i > 0)
+ appendStringInfoChar(&str, ',');
+ appendStringInfo(&str, UINT64_FORMAT,
+- U64FromFullTransactionId(snap->xip[i]));
++ XidFromFullTransactionId(snap->xip[i]));
+ }
+
+ PG_RETURN_CSTRING(str.data);
+@@ -511,8 +469,8 @@ pg_snapshot_recv(PG_FUNCTION_ARGS)
+ if (nxip < 0 || nxip > PG_SNAPSHOT_MAX_NXIP)
+ goto bad_format;
+
+- xmin = FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
+- xmax = FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
++ xmin = FullTransactionIdFromXid((uint64) pq_getmsgint64(buf));
++ xmax = FullTransactionIdFromXid((uint64) pq_getmsgint64(buf));
+ if (!FullTransactionIdIsValid(xmin) ||
+ !FullTransactionIdIsValid(xmax) ||
+ FullTransactionIdPrecedes(xmax, xmin))
+@@ -525,7 +483,7 @@ pg_snapshot_recv(PG_FUNCTION_ARGS)
+ for (i = 0; i < nxip; i++)
+ {
+ FullTransactionId cur =
+- FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
++ FullTransactionIdFromXid((uint64) pq_getmsgint64(buf));
+
+ if (FullTransactionIdPrecedes(cur, last) ||
+ FullTransactionIdPrecedes(cur, xmin) ||
+@@ -570,10 +528,10 @@ pg_snapshot_send(PG_FUNCTION_ARGS)
+
+ pq_begintypsend(&buf);
+ pq_sendint32(&buf, snap->nxip);
+- pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xmin));
+- pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xmax));
++ pq_sendint64(&buf, (int64) XidFromFullTransactionId(snap->xmin));
++ pq_sendint64(&buf, (int64) XidFromFullTransactionId(snap->xmax));
+ for (i = 0; i < snap->nxip; i++)
+- pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xip[i]));
++ pq_sendint64(&buf, (int64) XidFromFullTransactionId(snap->xip[i]));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
+
+@@ -661,8 +619,7 @@ pg_snapshot_xip(PG_FUNCTION_ARGS)
+ * Report the status of a recent transaction ID, or null for wrapped,
+ * truncated away or otherwise too old XIDs.
+ *
+- * The passed epoch-qualified xid is treated as a normal xid, not a
+- * multixact id.
++ * The passed xid is treated as a normal xid, not a multixact id.
+ *
+ * If it points to a committed subxact the result is the subxact status even
+ * though the parent xact may still be in progress or may have aborted.
+diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
+index ee303dc501d..3eb918fc006 100644
+--- a/src/backend/utils/cache/catcache.c
++++ b/src/backend/utils/cache/catcache.c
+@@ -2123,6 +2123,7 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, SysScanDesc scandesc,
+ memcpy((char *) ct->tuple.t_data,
+ (const char *) dtp->t_data,
+ dtp->t_len);
++ HeapTupleCopyXids(&ct->tuple, dtp);
+ MemoryContextSwitchTo(oldcxt);
+
+ if (dtp != ntp)
+diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
+index 422509f18d7..ee7cf197a8f 100644
+--- a/src/backend/utils/cache/relcache.c
++++ b/src/backend/utils/cache/relcache.c
+@@ -2325,8 +2325,7 @@ RelationReloadIndexInfo(Relation relation)
+ relation->rd_index->indisreplident = index->indisreplident;
+
+ /* Copy xmin too, as that is needed to make sense of indcheckxmin */
+- HeapTupleHeaderSetXmin(relation->rd_indextuple->t_data,
+- HeapTupleHeaderGetXmin(tuple->t_data));
++ HeapTupleSetXmin(relation->rd_indextuple, HeapTupleGetXmin(tuple));
+
+ ReleaseSysCache(tuple);
+ }
+diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c
+index e48a86be54b..31c52a8b9f4 100644
+--- a/src/backend/utils/fmgr/fmgr.c
++++ b/src/backend/utils/fmgr/fmgr.c
+@@ -526,7 +526,7 @@ lookup_C_func(HeapTuple procedureTuple)
+ NULL);
+ if (entry == NULL)
+ return NULL; /* no such entry */
+- if (entry->fn_xmin == HeapTupleHeaderGetRawXmin(procedureTuple->t_data) &&
++ if (entry->fn_xmin == HeapTupleGetRawXmin(procedureTuple) &&
+ ItemPointerEquals(&entry->fn_tid, &procedureTuple->t_self))
+ return entry; /* OK */
+ return NULL; /* entry is out of date */
+@@ -562,7 +562,7 @@ record_C_func(HeapTuple procedureTuple,
+ HASH_ENTER,
+ &found);
+ /* OID is already filled in */
+- entry->fn_xmin = HeapTupleHeaderGetRawXmin(procedureTuple->t_data);
++ entry->fn_xmin = HeapTupleGetRawXmin(procedureTuple);
+ entry->fn_tid = procedureTuple->t_self;
+ entry->user_fn = user_fn;
+ entry->inforec = inforec;
+diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
+index 08626cdaf2c..d725345b4cb 100644
+--- a/src/backend/utils/misc/guc_tables.c
++++ b/src/backend/utils/misc/guc_tables.c
+@@ -2734,65 +2734,6 @@ struct config_int ConfigureNamesInt[] =
+ NULL, NULL, NULL
+ },
+
+- {
+- {"vacuum_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Minimum age at which VACUUM should freeze a table row."),
+- NULL
+- },
+- &vacuum_freeze_min_age,
+- 50000000, 0, 1000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
+- NULL
+- },
+- &vacuum_freeze_table_age,
+- 150000000, 0, 2000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_multixact_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
+- NULL
+- },
+- &vacuum_multixact_freeze_min_age,
+- 5000000, 0, 1000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_multixact_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Multixact age at which VACUUM should scan whole table to freeze tuples."),
+- NULL
+- },
+- &vacuum_multixact_freeze_table_age,
+- 150000000, 0, 2000000000,
+- NULL, NULL, NULL
+- },
+-
+- {
+- {"vacuum_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
+- NULL
+- },
+- &vacuum_failsafe_age,
+- 1600000000, 0, 2100000000,
+- NULL, NULL, NULL
+- },
+- {
+- {"vacuum_multixact_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
+- gettext_noop("Multixact age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
+- NULL
+- },
+- &vacuum_multixact_failsafe_age,
+- 1600000000, 0, 2100000000,
+- NULL, NULL, NULL
+- },
+-
+ /*
+ * See also CheckRequiredParameterValues() if this parameter changes
+ */
+@@ -3417,28 +3358,6 @@ struct config_int ConfigureNamesInt[] =
+ 60, 1, INT_MAX / 1000,
+ NULL, NULL, NULL
+ },
+- {
+- /* see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
+- {"autovacuum_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
+- gettext_noop("Age at which to autovacuum a table to prevent transaction ID wraparound."),
+- NULL
+- },
+- &autovacuum_freeze_max_age,
+-
+- /* see vacuum_failsafe_age if you change the upper-limit value. */
+- 200000000, 100000, 2000000000,
+- NULL, NULL, NULL
+- },
+- {
+- /* see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
+- {"autovacuum_multixact_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
+- gettext_noop("Multixact age at which to autovacuum a table to prevent multixact wraparound."),
+- NULL
+- },
+- &autovacuum_multixact_freeze_max_age,
+- 400000000, 10000, 2000000000,
+- NULL, NULL, NULL
+- },
+ {
+ /* see max_connections */
+ {"autovacuum_max_workers", PGC_POSTMASTER, AUTOVACUUM,
+@@ -3706,7 +3625,6 @@ struct config_int ConfigureNamesInt[] =
+ SCRAM_SHA_256_DEFAULT_ITERATIONS, 1, INT_MAX,
+ NULL, NULL, NULL
+ },
+-
+ /* End-of-list marker */
+ {
+ {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
+@@ -3716,6 +3634,87 @@ struct config_int ConfigureNamesInt[] =
+
+ struct config_int64 ConfigureNamesInt64[] =
+ {
++ {
++ {"vacuum_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Minimum age at which VACUUM should freeze a table row."),
++ NULL
++ },
++ &vacuum_freeze_min_age,
++ INT64CONST(50000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
++ NULL
++ },
++ &vacuum_freeze_table_age,
++ INT64CONST(150000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_multixact_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
++ NULL
++ },
++ &vacuum_multixact_freeze_min_age,
++ INT64CONST(5000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_multixact_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Multixact age at which VACUUM should scan whole table to freeze tuples."),
++ NULL
++ },
++ &vacuum_multixact_freeze_table_age,
++ INT64CONST(150000000), INT64CONST(0), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
++ {
++ {"vacuum_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
++ NULL
++ },
++ &vacuum_failsafe_age,
++ INT64CONST(1600000000), INT64CONST(0), INT64CONST(2100000000),
++ NULL, NULL, NULL
++ },
++ {
++ {"vacuum_multixact_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
++ gettext_noop("Multixact age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
++ NULL
++ },
++ &vacuum_multixact_failsafe_age,
++ INT64CONST(1600000000), INT64CONST(0), INT64CONST(2100000000),
++ NULL, NULL, NULL
++ },
++ {
++ /* see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
++ {"autovacuum_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
++ gettext_noop("Age at which to autovacuum a table to prevent transaction ID wraparound."),
++ NULL
++ },
++ &autovacuum_freeze_max_age,
++
++ /* see vacuum_failsafe_age if you change the upper-limit value. */
++ INT64CONST(10000000000), INT64CONST(100000), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++ {
++ /* see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
++ {"autovacuum_multixact_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
++ gettext_noop("Multixact age at which to autovacuum a table to prevent multixact wraparound."),
++ NULL
++ },
++ &autovacuum_multixact_freeze_max_age,
++ INT64CONST(20000000000), INT64CONST(10000), INT64CONST(0x7FFFFFFFFFFFFFFF),
++ NULL, NULL, NULL
++ },
++
+ {
+ {"autovacuum_vacuum_threshold", PGC_SIGHUP, AUTOVACUUM,
+ gettext_noop("Minimum number of tuple updates or deletes prior to vacuum."),
+@@ -3750,6 +3749,7 @@ struct config_int64 ConfigureNamesInt64[] =
+ };
+
+
++
+ struct config_real ConfigureNamesReal[] =
+ {
+ {
+diff --git a/src/backend/utils/misc/help_config.c b/src/backend/utils/misc/help_config.c
+index 4729a19a132..3dce3498ee9 100644
+--- a/src/backend/utils/misc/help_config.c
++++ b/src/backend/utils/misc/help_config.c
+@@ -33,6 +33,7 @@ typedef union
+ struct config_bool _bool;
+ struct config_real real;
+ struct config_int integer;
++ struct config_int64 integer8;
+ struct config_string string;
+ struct config_enum _enum;
+ } mixedStruct;
+@@ -106,7 +107,12 @@ printMixedStruct(mixedStruct *structToPrint)
+ structToPrint->integer.min,
+ structToPrint->integer.max);
+ break;
+-
++ case PGC_INT64:
++ printf("INT64\t%lld\t%lld\t%lld\t",
++ (long long) structToPrint->integer8.reset_val,
++ (long long) structToPrint->integer8.min,
++ (long long) structToPrint->integer8.max);
++ break;
+ case PGC_REAL:
+ printf("REAL\t%g\t%g\t%g\t",
+ structToPrint->real.reset_val,
+diff --git a/src/backend/utils/misc/pg_controldata.c b/src/backend/utils/misc/pg_controldata.c
+index 1cb101fe821..a06f9c80052 100644
+--- a/src/backend/utils/misc/pg_controldata.c
++++ b/src/backend/utils/misc/pg_controldata.c
+@@ -117,7 +117,7 @@ pg_control_checkpoint(PG_FUNCTION_ARGS)
+ nulls[5] = false;
+
+ values[6] = CStringGetTextDatum(psprintf("%llu",
+- (unsigned long long) U64FromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
++ (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid)));
+ nulls[6] = false;
+
+ values[7] = ObjectIdGetDatum(ControlFile->checkPointCopy.nextOid);
+diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
+index a2ac7575ca7..1fedbdf9d44 100644
+--- a/src/backend/utils/misc/postgresql.conf.sample
++++ b/src/backend/utils/misc/postgresql.conf.sample
+@@ -675,7 +675,7 @@
+ #autovacuum_vacuum_insert_scale_factor = 0.2 # fraction of inserts over table
+ # size before insert vacuum
+ #autovacuum_analyze_scale_factor = 0.1 # fraction of table size before analyze
+-#autovacuum_freeze_max_age = 200000000 # maximum XID age before forced vacuum
++#autovacuum_freeze_max_age = 10000000000 # maximum XID age before forced vacuum
+ # (change requires restart)
+ #autovacuum_multixact_freeze_max_age = 400000000 # maximum multixact age
+ # before forced vacuum
+diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
+index e07ba4ea4b1..76ea9ac8c83 100644
+--- a/src/backend/utils/sort/tuplesortvariants.c
++++ b/src/backend/utils/sort/tuplesortvariants.c
+@@ -1342,11 +1342,16 @@ writetup_cluster(Tuplesortstate *state, LogicalTape *tape, SortTuple *stup)
+ {
+ TuplesortPublic *base = TuplesortstateGetPublic(state);
+ HeapTuple tuple = (HeapTuple) stup->tuple;
+- unsigned int tuplen = tuple->t_len + sizeof(ItemPointerData) + sizeof(int);
++ unsigned int tuplen = tuple->t_len +
++ sizeof(ItemPointerData) +
++ 2 * sizeof(TransactionId) + /* tuple xmin, xmax */
++ sizeof(int);
+
+ /* We need to store t_self, but not other fields of HeapTupleData */
+ LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
+ LogicalTapeWrite(tape, &tuple->t_self, sizeof(ItemPointerData));
++ LogicalTapeWrite(tape, &tuple->t_xmin, sizeof(TransactionId));
++ LogicalTapeWrite(tape, &tuple->t_xmax, sizeof(TransactionId));
+ LogicalTapeWrite(tape, tuple->t_data, tuple->t_len);
+ if (base->sortopt & TUPLESORT_RANDOMACCESS) /* need trailing length word? */
+ LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
+@@ -1358,7 +1363,10 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
+ {
+ TuplesortPublic *base = TuplesortstateGetPublic(state);
+ TuplesortClusterArg *arg = (TuplesortClusterArg *) base->arg;
+- unsigned int t_len = tuplen - sizeof(ItemPointerData) - sizeof(int);
++ unsigned int t_len = tuplen -
++ sizeof(ItemPointerData) -
++ 2 * sizeof(TransactionId) - /* tuple xmin, xmax */
++ sizeof(int);
+ HeapTuple tuple = (HeapTuple) tuplesort_readtup_alloc(state,
+ t_len + HEAPTUPLESIZE);
+
+@@ -1366,6 +1374,8 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
+ tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
+ tuple->t_len = t_len;
+ LogicalTapeReadExact(tape, &tuple->t_self, sizeof(ItemPointerData));
++ LogicalTapeReadExact(tape, &tuple->t_xmin, sizeof(TransactionId));
++ LogicalTapeReadExact(tape, &tuple->t_xmax, sizeof(TransactionId));
+ /* We don't currently bother to reconstruct t_tableOid */
+ tuple->t_tableOid = InvalidOid;
+ /* Read in the tuple body */
+diff --git a/src/backend/utils/time/combocid.c b/src/backend/utils/time/combocid.c
+index f85510b74ff..9b040e76bcd 100644
+--- a/src/backend/utils/time/combocid.c
++++ b/src/backend/utils/time/combocid.c
+@@ -101,12 +101,13 @@ static CommandId GetRealCmax(CommandId combocid);
+ */
+
+ CommandId
+-HeapTupleHeaderGetCmin(HeapTupleHeader tup)
++HeapTupleGetCmin(HeapTuple tuple)
+ {
++ HeapTupleHeader tup = tuple->t_data;
+ CommandId cid = HeapTupleHeaderGetRawCommandId(tup);
+
+ Assert(!(tup->t_infomask & HEAP_MOVED));
+- Assert(TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tup)));
++ Assert(TransactionIdIsCurrentTransactionId(HeapTupleGetXmin(tuple)));
+
+ if (tup->t_infomask & HEAP_COMBOCID)
+ return GetRealCmin(cid);
+@@ -115,8 +116,9 @@ HeapTupleHeaderGetCmin(HeapTupleHeader tup)
+ }
+
+ CommandId
+-HeapTupleHeaderGetCmax(HeapTupleHeader tup)
++HeapTupleGetCmax(HeapTuple tuple)
+ {
++ HeapTupleHeader tup = tuple->t_data;
+ CommandId cid = HeapTupleHeaderGetRawCommandId(tup);
+
+ Assert(!(tup->t_infomask & HEAP_MOVED));
+@@ -128,7 +130,7 @@ HeapTupleHeaderGetCmax(HeapTupleHeader tup)
+ * things too much.
+ */
+ Assert(CritSectionCount > 0 ||
+- TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tup)));
++ TransactionIdIsCurrentTransactionId(HeapTupleGetUpdateXidAny(tuple)));
+
+ if (tup->t_infomask & HEAP_COMBOCID)
+ return GetRealCmax(cid);
+@@ -150,9 +152,7 @@ HeapTupleHeaderGetCmax(HeapTupleHeader tup)
+ * changes the tuple in shared buffers.
+ */
+ void
+-HeapTupleHeaderAdjustCmax(HeapTupleHeader tup,
+- CommandId *cmax,
+- bool *iscombo)
++HeapTupleAdjustCmax(HeapTuple tup, CommandId *cmax, bool *iscombo)
+ {
+ /*
+ * If we're marking a tuple deleted that was inserted by (any
+@@ -160,10 +160,10 @@ HeapTupleHeaderAdjustCmax(HeapTupleHeader tup,
+ * Test for HeapTupleHeaderXminCommitted() first, because it's cheaper
+ * than a TransactionIdIsCurrentTransactionId call.
+ */
+- if (!HeapTupleHeaderXminCommitted(tup) &&
+- TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tup)))
++ if (!HeapTupleHeaderXminCommitted(tup->t_data) &&
++ TransactionIdIsCurrentTransactionId(HeapTupleGetRawXmin(tup)))
+ {
+- CommandId cmin = HeapTupleHeaderGetCmin(tup);
++ CommandId cmin = HeapTupleGetCmin(tup);
+
+ *cmax = GetComboCommandId(cmin, *cmax);
+ *iscombo = true;
+diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c
+index 09919ec651b..4becbe9197c 100644
+--- a/src/backend/utils/time/snapmgr.c
++++ b/src/backend/utils/time/snapmgr.c
+@@ -920,15 +920,15 @@ SnapshotResetXmin(void)
+
+ if (pairingheap_is_empty(&RegisteredSnapshots))
+ {
+- MyProc->xmin = InvalidTransactionId;
++ pg_atomic_write_u64(&MyProc->xmin, InvalidTransactionId);
+ return;
+ }
+
+ minSnapshot = pairingheap_container(SnapshotData, ph_node,
+ pairingheap_first(&RegisteredSnapshots));
+
+- if (TransactionIdPrecedes(MyProc->xmin, minSnapshot->xmin))
+- MyProc->xmin = minSnapshot->xmin;
++ if (TransactionIdPrecedes(pg_atomic_read_u64(&MyProc->xmin), minSnapshot->xmin))
++ pg_atomic_write_u64(&MyProc->xmin, minSnapshot->xmin);
+ }
+
+ /*
+@@ -1081,7 +1081,7 @@ AtEOXact_Snapshot(bool isCommit, bool resetXmin)
+ if (resetXmin)
+ SnapshotResetXmin();
+
+- Assert(resetXmin || MyProc->xmin == 0);
++ Assert(resetXmin || pg_atomic_read_u64(&MyProc->xmin) == 0);
+ }
+
+
+@@ -1146,9 +1146,9 @@ ExportSnapshot(Snapshot snapshot)
+ * Generate file path for the snapshot. We start numbering of snapshots
+ * inside the transaction from 1.
+ */
+- snprintf(path, sizeof(path), SNAPSHOT_EXPORT_DIR "/%08X-%08X-%d",
+- MyProc->vxid.procNumber, MyProc->vxid.lxid,
+- list_length(exportedSnapshots) + 1);
++ snprintf(path, sizeof(path), SNAPSHOT_EXPORT_DIR "/%08X-%08X%08X-%d",
++ MyProc->vxid.procNumber, (uint32) (MyProc->vxid.lxid >> 32),
++ (uint32) MyProc->vxid.lxid, list_length(exportedSnapshots) + 1);
+
+ /*
+ * Copy the snapshot into TopTransactionContext, add it to the
+@@ -1323,7 +1323,7 @@ parseXidFromText(const char *prefix, char **s, const char *filename)
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+ ptr += prefixlen;
+- if (sscanf(ptr, "%u", &val) != 1)
++ if (sscanf(ptr, "%" PRIu64 "u", &val) != 1)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+@@ -1348,7 +1348,7 @@ parseVxidFromText(const char *prefix, char **s, const char *filename,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+ ptr += prefixlen;
+- if (sscanf(ptr, "%d/%u", &vxid->procNumber, &vxid->localTransactionId) != 2)
++ if (sscanf(ptr, "%d/%" PRIu64 "u", &vxid->procNumber, &vxid->localTransactionId) != 2)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("invalid snapshot data in file \"%s\"", filename)));
+@@ -1889,7 +1889,7 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
+ if (!snapshot->suboverflowed)
+ {
+ /* we have full data, so search subxip */
+- if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
++ if (pg_lfind64(xid, snapshot->subxip, snapshot->subxcnt))
+ return true;
+
+ /* not there, fall through to search xip[] */
+@@ -1911,7 +1911,7 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
+ return false;
+ }
+
+- if (pg_lfind32(xid, snapshot->xip, snapshot->xcnt))
++ if (pg_lfind64(xid, snapshot->xip, snapshot->xcnt))
+ return true;
+ }
+ else
+@@ -1945,7 +1945,7 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
+ * indeterminate xid. We don't know whether it's top level or subxact
+ * but it doesn't matter. If it's present, the xid is visible.
+ */
+- if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
++ if (pg_lfind64(xid, snapshot->subxip, snapshot->subxcnt))
+ return true;
+ }
+
+diff --git a/src/bin/pg_amcheck/t/004_verify_heapam.pl b/src/bin/pg_amcheck/t/004_verify_heapam.pl
+index 250a3eb981f..02c3e12b804 100644
+--- a/src/bin/pg_amcheck/t/004_verify_heapam.pl
++++ b/src/bin/pg_amcheck/t/004_verify_heapam.pl
+@@ -8,6 +8,7 @@ use PostgreSQL::Test::Cluster;
+ use PostgreSQL::Test::Utils;
+
+ use Test::More;
++use Data::Dumper;
+
+ # This regression test demonstrates that the pg_amcheck binary correctly
+ # identifies specific kinds of corruption within pages. To test this, we need
+@@ -85,6 +86,65 @@ use Test::More;
+
+ use constant HEAPTUPLE_PACK_CODE => 'LLLSSSSSCCLLCCCCCCCCCCllLL';
+ use constant HEAPTUPLE_PACK_LENGTH => 58; # Total size
++use constant HEAPPAGE_SPECIAL_PACK_CODE => 'QQ';
++use constant HEAPPAGE_SPECIAL_PACK_LENGTH => 16;
++use constant HEAPPAGE_SIZE => 8192;
++
++# Some #define constants from access/htup_details.h for use while corrupting.
++use constant HEAP_HASNULL => 0x0001;
++use constant HEAP_XMAX_LOCK_ONLY => 0x0080;
++use constant HEAP_XMIN_COMMITTED => 0x0100;
++use constant HEAP_XMIN_INVALID => 0x0200;
++use constant HEAP_XMAX_COMMITTED => 0x0400;
++use constant HEAP_XMAX_INVALID => 0x0800;
++use constant HEAP_NATTS_MASK => 0x07FF;
++use constant HEAP_XMAX_IS_MULTI => 0x1000;
++use constant HEAP_KEYS_UPDATED => 0x2000;
++use constant HEAP_HOT_UPDATED => 0x4000;
++use constant HEAP_ONLY_TUPLE => 0x8000;
++use constant HEAP_UPDATED => 0x2000;
++
++use constant FIRST_NORMAL_TRANSACTION_ID => 3;
++
++# Read page special data
++sub read_special_data
++{
++ my ($fh, $offset) = @_;
++ my ($buffer, %special);
++
++ $offset -= $offset % HEAPPAGE_SIZE;
++ $offset += HEAPPAGE_SIZE - HEAPPAGE_SPECIAL_PACK_LENGTH;
++
++ sysseek($fh, $offset, 0)
++ or BAIL_OUT("sysseek failed: $!");
++ defined(sysread($fh, $buffer, HEAPPAGE_SPECIAL_PACK_LENGTH))
++ or BAIL_OUT("sysread failed: $!");
++
++ @_ = unpack(HEAPPAGE_SPECIAL_PACK_CODE, $buffer);
++ %special = (
++ pd_xid_base => shift,
++ pd_multi_base => shift);
++ return \%special;
++}
++
++# Write page special data
++sub write_special_data
++{
++ my ($fh, $offset, $special) = @_;
++
++ $offset -= $offset % HEAPPAGE_SIZE;
++ $offset += HEAPPAGE_SIZE - HEAPPAGE_SPECIAL_PACK_LENGTH;
++
++ my $buffer = pack(
++ HEAPPAGE_SPECIAL_PACK_CODE,
++ $special->{pd_xid_base}, $special->{pd_multi_base});
++
++ sysseek($fh, $offset, 0)
++ or BAIL_OUT("sysseek failed: $!");
++ defined(syswrite($fh, $buffer, HEAPPAGE_SPECIAL_PACK_LENGTH))
++ or BAIL_OUT("syswrite failed: $!");
++ return;
++}
+
+ # Read a tuple of our table from a heap page.
+ #
+@@ -96,8 +156,9 @@ use constant HEAPTUPLE_PACK_LENGTH => 58; # Total size
+ #
+ sub read_tuple
+ {
+- my ($fh, $offset) = @_;
++ my ($fh, $offset, $raw) = @_;
+ my ($buffer, %tup);
++
+ sysseek($fh, $offset, 0)
+ or BAIL_OUT("sysseek failed: $!");
+ defined(sysread($fh, $buffer, HEAPTUPLE_PACK_LENGTH))
+@@ -133,6 +194,18 @@ sub read_tuple
+ c_va_toastrelid => shift);
+ # Stitch together the text for column 'b'
+ $tup{b} = join('', map { chr($tup{"b_body$_"}) } (1 .. 7));
++
++ if (!$raw)
++ {
++ my $special = read_special_data($fh, $offset);
++
++ $tup{t_xmin} += $special->{pd_xid_base};
++ my $is_multi = $tup{t_infomask} & HEAP_XMAX_IS_MULTI;
++ $tup{t_xmax} += !$is_multi ?
++ $special->{pd_xid_base} :
++ $special->{pd_multi_base};
++ }
++
+ return \%tup;
+ }
+
+@@ -148,7 +221,39 @@ sub read_tuple
+ #
+ sub write_tuple
+ {
+- my ($fh, $offset, $tup) = @_;
++ my ($fh, $offset, $tup, $raw) = @_;
++
++ if (!$raw)
++ {
++ my $special = read_special_data($fh, $offset);
++
++ if ($tup->{t_xmin} >= 3)
++ {
++ my $xmin = $tup->{t_xmin} - $special->{pd_xid_base};
++ die "tuple x_min $tup->{t_xmin} is too smal for pd_xid_base $special->{pd_xid_base}"
++ if $xmin < 3;
++ $tup->{t_xmin} = $xmin;
++ }
++
++ if ($tup->{t_xmax} >= 3)
++ {
++ if (($tup->{t_infomask} & HEAP_XMAX_IS_MULTI) == 0)
++ {
++ my $xmax = $tup->{t_xmax} - $special->{pd_xid_base};
++ die "tuple x_max $tup->{t_xmax} is too smal for pd_xid_base $special->{pd_xid_base}"
++ if $xmax < 3;
++ $tup->{t_xmax} = $xmax;
++ }
++ else
++ {
++ my $xmax = $tup->{t_xmax} - $special->{pd_multi_base};
++ die "tuple multi x_max $tup->{t_xmax} is too smal for pd_multi_base $special->{pd_multi_base}"
++ if $xmax < 3;
++ $tup->{t_xmax} = $xmax;
++ }
++ }
++ }
++
+ my $buffer = pack(
+ HEAPTUPLE_PACK_CODE,
+ $tup->{t_xmin}, $tup->{t_xmax},
+@@ -171,6 +276,42 @@ sub write_tuple
+ return;
+ }
+
++# move pd_xid_base and pd_multi_base to more suitable position for tests.
++sub fixup_page
++{
++ my ($fh, $page, $xid_base, $multi_base, $lp_off) = @_;
++ my $offset = $page * HEAPPAGE_SIZE;
++ my $special = read_special_data($fh, $offset);
++
++ die "xid_base $xid_base should be lesser than existed $special->{pd_xid_base}"
++ if ($xid_base > $special->{pd_xid_base});
++ die "multi_base $multi_base should be lesser than existed $special->{pd_multi_base}"
++ if ($multi_base > $special->{pd_multi_base} && $special->{pd_multi_base} != 0);
++ return if ($xid_base == $special->{pd_xid_base} &&
++ $multi_base == $special->{pd_multi_base});
++
++ my $xid_delta = $special->{pd_xid_base} - $xid_base;
++ my $multi_delta = $special->{pd_multi_base} - $multi_base;
++
++ for my $off (@$lp_off)
++ {
++ # change only tuples on this page.
++ next if ($off < $offset && $off > $offset + HEAPPAGE_SIZE);
++ next if ($off == -1);
++
++ my $tup = read_tuple($fh, $off, 1);
++ $tup->{t_xmin} += $xid_delta;
++ my $is_multi = $tup->{t_infomask} & HEAP_XMAX_IS_MULTI;
++ $tup->{t_xmax} += !$is_multi ? $xid_delta : $multi_delta;
++ write_tuple($fh, $off, $tup, 1);
++ }
++
++ $special->{pd_xid_base} = $xid_base;
++ $special->{pd_multi_base} = $multi_base;
++
++ write_special_data($fh, $offset, $special);
++}
++
+ # Set umask so test directories and files are created with default permissions
+ umask(0077);
+
+@@ -320,6 +461,8 @@ my $relfrozenxid = $node->safe_psql('postgres',
+ q(select relfrozenxid from pg_class where relname = 'test'));
+ my $datfrozenxid = $node->safe_psql('postgres',
+ q(select datfrozenxid from pg_database where datname = 'postgres'));
++my $datminmxid = $node->safe_psql('postgres',
++ q(select datminmxid from pg_database where datname = 'postgres'));
+
+ # Sanity check that our 'test' table has a relfrozenxid newer than the
+ # datfrozenxid for the database, and that the datfrozenxid is greater than the
+@@ -378,6 +521,11 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ # Determine endianness of current platform from the 1-byte varlena header
+ $ENDIANNESS = $tup->{b_header} == 0x11 ? "little" : "big";
+ }
++
++# Set 64bit xid bases a bit in the past therefore we can set xmin/xmax a bit
++# in the past
++fixup_page($file, 0, $datfrozenxid - 100, $datminmxid, \@lp_off);
++
+ close($file)
+ or BAIL_OUT("close failed: $!");
+ $node->start;
+@@ -395,20 +543,6 @@ $node->command_ok([ 'pg_amcheck', '-p', $port, 'postgres' ],
+
+ $node->stop;
+
+-# Some #define constants from access/htup_details.h for use while corrupting.
+-use constant HEAP_HASNULL => 0x0001;
+-use constant HEAP_XMAX_LOCK_ONLY => 0x0080;
+-use constant HEAP_XMIN_COMMITTED => 0x0100;
+-use constant HEAP_XMIN_INVALID => 0x0200;
+-use constant HEAP_XMAX_COMMITTED => 0x0400;
+-use constant HEAP_XMAX_INVALID => 0x0800;
+-use constant HEAP_NATTS_MASK => 0x07FF;
+-use constant HEAP_XMAX_IS_MULTI => 0x1000;
+-use constant HEAP_KEYS_UPDATED => 0x2000;
+-use constant HEAP_HOT_UPDATED => 0x4000;
+-use constant HEAP_ONLY_TUPLE => 0x8000;
+-use constant HEAP_UPDATED => 0x2000;
+-
+ # Helper function to generate a regular expression matching the header we
+ # expect verify_heapam() to return given which fields we expect to be non-null.
+ sub header
+@@ -443,6 +577,8 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+
+ # Read tuple, if there is one.
+ my $tup = $offset == -1 ? undef : read_tuple($file, $offset);
++ # Read page special, if there is one.
++ my $special = $offset == -1 ? undef : read_special_data($file, $offset);
+
+ if ($offnum == 1)
+ {
+@@ -459,7 +595,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ elsif ($offnum == 2)
+ {
+ # Corruptly set xmin < datfrozenxid
+- my $xmin = 3;
++ my $xmin = $datfrozenxid - 12;
+ $tup->{t_xmin} = $xmin;
+ $tup->{t_infomask} &= ~HEAP_XMIN_COMMITTED;
+ $tup->{t_infomask} &= ~HEAP_XMIN_INVALID;
+@@ -469,25 +605,24 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ }
+ elsif ($offnum == 3)
+ {
+- # Corruptly set xmin < datfrozenxid, further back, noting circularity
+- # of xid comparison.
+- my $xmin = 4026531839;
++ # Corruptly set xmin > next transaction id.
++ my $xmin = $relfrozenxid + 4026531839;
+ $tup->{t_xmin} = $xmin;
+ $tup->{t_infomask} &= ~HEAP_XMIN_COMMITTED;
+ $tup->{t_infomask} &= ~HEAP_XMIN_INVALID;
+
+ push @expected,
+- qr/${$header}xmin ${xmin} precedes oldest valid transaction ID \d+/;
++ qr/${$header}xmin ${xmin} equals or exceeds next valid transaction ID \d+/;
+ }
+ elsif ($offnum == 4)
+ {
+- # Corruptly set xmax < relminmxid;
+- my $xmax = 4026531839;
++ # Corruptly set xmax > relminmxid;
++ my $xmax = $relfrozenxid + 4026531839;
+ $tup->{t_xmax} = $xmax;
+ $tup->{t_infomask} &= ~HEAP_XMAX_INVALID;
+
+ push @expected,
+- qr/${$header}xmax ${xmax} precedes oldest valid transaction ID \d+/;
++ qr/${$header}xmax ${xmax} equals or exceeds next valid transaction ID \d+/;
+ }
+ elsif ($offnum == 5)
+ {
+@@ -603,7 +738,7 @@ for (my $tupidx = 0; $tupidx < $ROWCOUNT; $tupidx++)
+ $tup->{t_xmax} = 4000000000;
+
+ push @expected,
+- qr/${header}multitransaction ID 4000000000 precedes relation minimum multitransaction ID threshold 1/;
++ qr/${header}multitransaction ID 4000000000 equals or exceeds next valid multitransaction ID 1/;
+ }
+ elsif ($offnum == 16) # Last offnum must equal ROWCOUNT
+ {
+diff --git a/src/bin/pg_controldata/pg_controldata.c b/src/bin/pg_controldata/pg_controldata.c
+index 5414b921c38..1f99bccf444 100644
+--- a/src/bin/pg_controldata/pg_controldata.c
++++ b/src/bin/pg_controldata/pg_controldata.c
+@@ -247,7 +247,7 @@ main(int argc, char *argv[])
+ printf(_("Latest checkpoint's full_page_writes: %s\n"),
+ ControlFile->checkPointCopy.fullPageWrites ? _("on") : _("off"));
+ printf(_("Latest checkpoint's NextXID: %llu\n"),
+- (unsigned long long) U64FromFullTransactionId(ControlFile->checkPointCopy.nextXid));
++ (unsigned long long) XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid));
+ printf(_("Latest checkpoint's NextOID: %u\n"),
+ ControlFile->checkPointCopy.nextOid);
+ printf(_("Latest checkpoint's NextMultiXactId: %llu\n"),
+diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
+index 8ed4f3341d6..3fcfadd7a57 100644
+--- a/src/bin/pg_dump/pg_dump.c
++++ b/src/bin/pg_dump/pg_dump.c
+@@ -41,6 +41,7 @@
+ #include "access/attnum.h"
+ #include "access/sysattr.h"
+ #include "access/transam.h"
++#include "c.h"
+ #include "catalog/pg_aggregate_d.h"
+ #include "catalog/pg_am_d.h"
+ #include "catalog/pg_attribute_d.h"
+@@ -3129,7 +3130,7 @@ dumpDatabase(Archive *fout)
+ *datistemplate,
+ *datconnlimit,
+ *tablespace;
+- uint32 frozenxid,
++ uint64 frozenxid,
+ minmxid;
+ char *qdatname;
+
+@@ -3201,8 +3202,8 @@ dumpDatabase(Archive *fout)
+ icurules = PQgetvalue(res, 0, i_daticurules);
+ else
+ icurules = NULL;
+- frozenxid = atooid(PQgetvalue(res, 0, i_frozenxid));
+- minmxid = atooid(PQgetvalue(res, 0, i_minmxid));
++ frozenxid = strtou64(PQgetvalue(res, 0, i_frozenxid), NULL, 0);
++ minmxid = strtou64(PQgetvalue(res, 0, i_minmxid), NULL, 0);
+ dbdacl.acl = PQgetvalue(res, 0, i_datacl);
+ dbdacl.acldefault = PQgetvalue(res, 0, i_acldefault);
+ datistemplate = PQgetvalue(res, 0, i_datistemplate);
+@@ -3511,10 +3512,16 @@ dumpDatabase(Archive *fout)
+ RelFileNumber relfilenumber;
+
+ appendPQExpBuffer(loHorizonQry, "UPDATE pg_catalog.pg_class\n"
+- "SET relfrozenxid = '%u', relminmxid = '%u'\n"
++ "SET relfrozenxid = '%llu', relminmxid = '%llu'\n"
+ "WHERE oid = %u;\n",
+- atooid(PQgetvalue(lo_res, i, ii_relfrozenxid)),
+- atooid(PQgetvalue(lo_res, i, ii_relminmxid)),
++ (unsigned long long) strtou64(PQgetvalue(lo_res,
++ i,
++ ii_relfrozenxid),
++ NULL, 0),
++ (unsigned long long) strtou64(PQgetvalue(lo_res,
++ i,
++ ii_relminmxid),
++ NULL, 0),
+ atooid(PQgetvalue(lo_res, i, ii_oid)));
+
+ oid = atooid(PQgetvalue(lo_res, i, ii_oid));
+@@ -7105,11 +7112,11 @@ getTables(Archive *fout, int *numTables)
+ tblinfo[i].relreplident = *(PQgetvalue(res, i, i_relreplident));
+ tblinfo[i].rowsec = (strcmp(PQgetvalue(res, i, i_relrowsec), "t") == 0);
+ tblinfo[i].forcerowsec = (strcmp(PQgetvalue(res, i, i_relforcerowsec), "t") == 0);
+- tblinfo[i].frozenxid = atooid(PQgetvalue(res, i, i_relfrozenxid));
+- tblinfo[i].toast_frozenxid = atooid(PQgetvalue(res, i, i_toastfrozenxid));
++ tblinfo[i].frozenxid = strtou64(PQgetvalue(res, i, i_relfrozenxid), NULL, 0);
++ tblinfo[i].toast_frozenxid = strtou64(PQgetvalue(res, i, i_toastfrozenxid), NULL, 0);
+ tblinfo[i].toast_oid = atooid(PQgetvalue(res, i, i_toastoid));
+- tblinfo[i].minmxid = atooid(PQgetvalue(res, i, i_relminmxid));
+- tblinfo[i].toast_minmxid = atooid(PQgetvalue(res, i, i_toastminmxid));
++ tblinfo[i].minmxid = strtou64(PQgetvalue(res, i, i_relminmxid), NULL, 0);
++ tblinfo[i].toast_minmxid = strtou64(PQgetvalue(res, i, i_toastminmxid), NULL, 0);
+ tblinfo[i].reloptions = pg_strdup(PQgetvalue(res, i, i_reloptions));
+ if (PQgetisnull(res, i, i_checkoption))
+ tblinfo[i].checkoption = NULL;
+diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
+index 2e55a0e3bbb..be24509f3a0 100644
+--- a/src/bin/pg_dump/pg_dump.h
++++ b/src/bin/pg_dump/pg_dump.h
+@@ -301,11 +301,11 @@ typedef struct _tableInfo
+ bool rowsec; /* is row security enabled? */
+ bool forcerowsec; /* is row security forced? */
+ bool hasoids; /* does it have OIDs? */
+- uint32 frozenxid; /* table's relfrozenxid */
+- uint32 minmxid; /* table's relminmxid */
++ uint64 frozenxid; /* table's relfrozenxid */
++ uint64 minmxid; /* table's relminmxid */
+ Oid toast_oid; /* toast table's OID, or 0 if none */
+- uint32 toast_frozenxid; /* toast table's relfrozenxid, if any */
+- uint32 toast_minmxid; /* toast table's relminmxid */
++ uint64 toast_frozenxid; /* toast table's relfrozenxid, if any */
++ uint64 toast_minmxid; /* toast table's relminmxid */
+ int ncheck; /* # of CHECK expressions */
+ Oid reltype; /* OID of table's composite type, if any */
+ Oid reloftype; /* underlying type for typed table */
+diff --git a/src/bin/pg_resetwal/pg_resetwal.c b/src/bin/pg_resetwal/pg_resetwal.c
+index b2f20263824..dafefe8101b 100644
+--- a/src/bin/pg_resetwal/pg_resetwal.c
++++ b/src/bin/pg_resetwal/pg_resetwal.c
+@@ -63,7 +63,6 @@ static ControlFileData ControlFile; /* pg_control values */
+ static XLogSegNo newXlogSegNo; /* new XLOG segment # */
+ static bool guessed = false; /* T if we had to guess at any values */
+ static const char *progname;
+-static uint32 set_xid_epoch = (uint32) -1;
+ static TransactionId set_oldest_xid = 0;
+ static TransactionId set_xid = 0;
+ static TransactionId set_oldest_commit_ts_xid = 0;
+@@ -96,7 +95,6 @@ main(int argc, char *argv[])
+ static struct option long_options[] = {
+ {"commit-timestamp-ids", required_argument, NULL, 'c'},
+ {"pgdata", required_argument, NULL, 'D'},
+- {"epoch", required_argument, NULL, 'e'},
+ {"force", no_argument, NULL, 'f'},
+ {"next-wal-file", required_argument, NULL, 'l'},
+ {"multixact-ids", required_argument, NULL, 'm'},
+@@ -138,7 +136,7 @@ main(int argc, char *argv[])
+ }
+
+
+- while ((c = getopt_long(argc, argv, "c:D:e:fl:m:no:O:u:x:", long_options, NULL)) != -1)
++ while ((c = getopt_long(argc, argv, "c:D:fl:m:no:O:u:x:", long_options, NULL)) != -1)
+ {
+ switch (c)
+ {
+@@ -154,24 +152,9 @@ main(int argc, char *argv[])
+ noupdate = true;
+ break;
+
+- case 'e':
+- errno = 0;
+- set_xid_epoch = strtoul(optarg, &endptr, 0);
+- if (endptr == optarg || *endptr != '\0' || errno != 0)
+- {
+- /*------
+- translator: the second %s is a command line argument (-e, etc) */
+- pg_log_error("invalid argument for option %s", "-e");
+- pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+- exit(1);
+- }
+- if (set_xid_epoch == -1)
+- pg_fatal("transaction ID epoch (-e) must not be -1");
+- break;
+-
+ case 'u':
+ errno = 0;
+- set_oldest_xid = strtoul(optarg, &endptr, 0);
++ set_oldest_xid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-u");
+@@ -185,7 +168,7 @@ main(int argc, char *argv[])
+
+ case 'x':
+ errno = 0;
+- set_xid = strtoul(optarg, &endptr, 0);
++ set_xid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-x");
+@@ -199,14 +182,14 @@ main(int argc, char *argv[])
+
+ case 'c':
+ errno = 0;
+- set_oldest_commit_ts_xid = strtoul(optarg, &endptr, 0);
++ set_oldest_commit_ts_xid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != ',' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-c");
+ pg_log_error_hint("Try \"%s --help\" for more information.", progname);
+ exit(1);
+ }
+- set_newest_commit_ts_xid = strtoul(endptr + 1, &endptr2, 0);
++ set_newest_commit_ts_xid = strtou64(endptr + 1, &endptr2, 0);
+ if (endptr2 == endptr + 1 || *endptr2 != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-c");
+@@ -242,7 +225,7 @@ main(int argc, char *argv[])
+
+ case 'm':
+ errno = 0;
+- set_mxid = strtoul(optarg, &endptr, 0);
++ set_mxid = strtou64(optarg, &endptr, 0);
+ if (endptr == optarg || *endptr != ',' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-m");
+@@ -250,7 +233,7 @@ main(int argc, char *argv[])
+ exit(1);
+ }
+
+- set_oldestmxid = strtoul(endptr + 1, &endptr2, 0);
++ set_oldestmxid = strtou64(endptr + 1, &endptr2, 0);
+ if (endptr2 == endptr + 1 || *endptr2 != '\0' || errno != 0)
+ {
+ pg_log_error("invalid argument for option %s", "-m");
+@@ -416,11 +399,6 @@ main(int argc, char *argv[])
+ * Adjust fields if required by switches. (Do this now so that printout,
+ * if any, includes these values.)
+ */
+- if (set_xid_epoch != -1)
+- ControlFile.checkPointCopy.nextXid =
+- FullTransactionIdFromEpochAndXid(set_xid_epoch,
+- XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+-
+ if (set_oldest_xid != 0)
+ {
+ ControlFile.checkPointCopy.oldestXid = set_oldest_xid;
+@@ -428,9 +406,7 @@ main(int argc, char *argv[])
+ }
+
+ if (set_xid != 0)
+- ControlFile.checkPointCopy.nextXid =
+- FullTransactionIdFromEpochAndXid(EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid),
+- set_xid);
++ ControlFile.checkPointCopy.nextXid = FullTransactionIdFromXid(set_xid);
+
+ if (set_oldest_commit_ts_xid != 0)
+ ControlFile.checkPointCopy.oldestCommitTsXid = set_oldest_commit_ts_xid;
+@@ -666,7 +642,7 @@ GuessControlValues(void)
+ ControlFile.checkPointCopy.PrevTimeLineID = 1;
+ ControlFile.checkPointCopy.fullPageWrites = false;
+ ControlFile.checkPointCopy.nextXid =
+- FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
++ FullTransactionIdFromXid(FirstNormalTransactionId);
+ ControlFile.checkPointCopy.nextOid = FirstGenbkiObjectId;
+ ControlFile.checkPointCopy.nextMulti = FirstMultiXactId;
+ ControlFile.checkPointCopy.nextMultiOffset = 0;
+@@ -717,6 +693,8 @@ GuessControlValues(void)
+ *
+ * NB: this display should be just those fields that will not be
+ * reset by RewriteControlFile().
++ *
++ * Special macros help to make translatable strings.
+ */
+ static void
+ PrintControlValues(bool guessed)
+@@ -736,8 +714,7 @@ PrintControlValues(bool guessed)
+ ControlFile.checkPointCopy.ThisTimeLineID);
+ printf(_("Latest checkpoint's full_page_writes: %s\n"),
+ ControlFile.checkPointCopy.fullPageWrites ? _("on") : _("off"));
+- printf(_("Latest checkpoint's NextXID: %u:%llu\n"),
+- EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid),
++ printf(_("Latest checkpoint's NextXID: %llu\n"),
+ (unsigned long long) XidFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+ printf(_("Latest checkpoint's NextOID: %u\n"),
+ ControlFile.checkPointCopy.nextOid);
+@@ -835,12 +812,6 @@ PrintNewControlValues(void)
+ ControlFile.checkPointCopy.oldestXidDB);
+ }
+
+- if (set_xid_epoch != -1)
+- {
+- printf(_("NextXID epoch: %u\n"),
+- EpochFromFullTransactionId(ControlFile.checkPointCopy.nextXid));
+- }
+-
+ if (set_oldest_commit_ts_xid != 0)
+ {
+ printf(_("oldestCommitTsXid: %llu\n"),
+diff --git a/src/bin/pg_resetwal/t/001_basic.pl b/src/bin/pg_resetwal/t/001_basic.pl
+index f8a8eef44d1..20a26192cd8 100644
+--- a/src/bin/pg_resetwal/t/001_basic.pl
++++ b/src/bin/pg_resetwal/t/001_basic.pl
+@@ -95,15 +95,6 @@ command_fails_like(
+ [ 'pg_resetwal', '-c', '10,1', $node->data_dir ],
+ qr/greater than/,
+ 'fails with -c value 1 part 2');
+-# -e
+-command_fails_like(
+- [ 'pg_resetwal', '-e', 'foo', $node->data_dir ],
+- qr/error: invalid argument for option -e/,
+- 'fails with incorrect -e option');
+-command_fails_like(
+- [ 'pg_resetwal', '-e', '-1', $node->data_dir ],
+- qr/must not be -1/,
+- 'fails with -e value -1');
+ # -l
+ command_fails_like(
+ [ 'pg_resetwal', '-l', 'foo', $node->data_dir ],
+@@ -181,7 +172,6 @@ my $blcksz = $1;
+ my @cmd = ('pg_resetwal', '-D', $node->data_dir);
+
+ # some not-so-critical hardcoded values
+-push @cmd, '-e', 1;
+ push @cmd, '-l', '00000001000000320000004B';
+ push @cmd, '-o', 100_000;
+ push @cmd, '--wal-segsize', 1;
+@@ -205,8 +195,10 @@ push @cmd,
+ '-c',
+ sprintf("%d,%d", hex($files[0]) == 0 ? 3 : hex($files[0]), hex($files[-1]));
+
++my $A = 2;
++my $B = 1;
+ @files = get_slru_files('pg_multixact/offsets');
+-$mult = 32 * $blcksz / 8;
++$mult = $A * $blcksz / $B;
+ # -m argument is "new,old"
+ push @cmd, '-m',
+ sprintf("%d,%d",
+@@ -214,11 +206,11 @@ push @cmd, '-m',
+ hex($files[0]) == 0 ? 1 : hex($files[0] * $mult));
+
+ @files = get_slru_files('pg_multixact/members');
+-$mult = 32 * int($blcksz / 20) * 4;
++$mult = $A * int($blcksz / 20) * $B;
+ push @cmd, '-O', (hex($files[-1]) + 1) * $mult;
+
+ @files = get_slru_files('pg_xact');
+-$mult = 32 * $blcksz * 4;
++$mult = $A * $blcksz * $B;
+ push @cmd,
+ '-u', (hex($files[0]) == 0 ? 3 : hex($files[0]) * $mult),
+ '-x', ((hex($files[-1]) + 1) * $mult);
+diff --git a/src/bin/pg_upgrade/check.c b/src/bin/pg_upgrade/check.c
+index 94164f04721..b4f45bde190 100644
+--- a/src/bin/pg_upgrade/check.c
++++ b/src/bin/pg_upgrade/check.c
+@@ -29,6 +29,8 @@ static void check_new_cluster_logical_replication_slots(void);
+ static void check_new_cluster_subscription_configuration(void);
+ static void check_old_cluster_for_valid_slots(void);
+ static void check_old_cluster_subscription_state(void);
++static void check_for_32bit_xid_usage(ClusterInfo *cluster);
++static bool is_xid_wraparound(ClusterInfo *cluster);
+
+ /*
+ * DataTypesUsageChecks - definitions of data type checks for the old cluster
+@@ -583,7 +585,7 @@ output_check_banner(void)
+
+
+ void
+-check_and_dump_old_cluster(void)
++check_and_dump_old_cluster(bool *is_wraparound)
+ {
+ /* -- OLD -- */
+
+@@ -677,6 +679,17 @@ check_and_dump_old_cluster(void)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 905)
+ check_for_pg_role_prefix(&old_cluster);
+
++ /* Prepare for 64bit xid */
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER)
++ {
++ /* Check if 32-bit xid type is used in tables */
++ check_for_32bit_xid_usage(&old_cluster);
++ /* Check indexes to be upgraded */
++ invalidate_spgist_indexes(&old_cluster, true);
++ invalidate_gin_indexes(&old_cluster, true);
++ invalidate_external_indexes(&old_cluster, true);
++ }
++
+ /*
+ * While not a check option, we do this now because this is the only time
+ * the old server is running.
+@@ -684,6 +697,8 @@ check_and_dump_old_cluster(void)
+ if (!user_opts.check)
+ generate_old_dump();
+
++ *is_wraparound = is_xid_wraparound(&old_cluster);
++
+ if (!user_opts.live_check)
+ stop_postmaster(false);
+ }
+@@ -759,6 +774,17 @@ issue_warnings_and_set_wal_level(void)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 906)
+ old_9_6_invalidate_hash_indexes(&new_cluster, false);
+
++ /* Raindex for 64bit xid */
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER)
++ {
++ /* Check if 32-bit xid type is used in tables */
++ check_for_32bit_xid_usage(&old_cluster);
++ /* Check indexes to be upgraded */
++ invalidate_spgist_indexes(&old_cluster, true);
++ invalidate_gin_indexes(&old_cluster, true);
++ invalidate_external_indexes(&old_cluster, true);
++ }
++
+ report_extension_updates(&new_cluster);
+
+ stop_postmaster(false);
+@@ -1930,6 +1956,127 @@ check_old_cluster_for_valid_slots(void)
+ check_ok();
+ }
+
++/*
++ * check_for_32bit_xid_usage()
++ *
++ * Current PG version changes xid storage format to 64-bit. Check if
++ * xid type is used in tables.
++ */
++static void
++check_for_32bit_xid_usage(ClusterInfo *cluster)
++{
++ int dbnum;
++ FILE *script = NULL;
++ bool found = false;
++ char output_path[MAXPGPATH];
++
++ prep_status("Checking for incompatible \"xid\" data type");
++
++ snprintf(output_path, sizeof(output_path), "tables_using_xid.txt");
++
++ for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
++ {
++ PGresult *res;
++ bool db_used = false;
++ int ntups;
++ int rowno;
++ int i_nspname,
++ i_relname,
++ i_attname;
++ DbInfo *active_db = &cluster->dbarr.dbs[dbnum];
++ PGconn *conn = connectToServer(cluster, active_db->db_name);
++
++ /*
++ * While several relkinds don't store any data, e.g. views, they can
++ * be used to define data types of other columns, so we check all
++ * relkinds.
++ */
++ res = executeQueryOrDie(conn,
++ "SELECT n.nspname, c.relname, a.attname "
++ "FROM pg_catalog.pg_class c, "
++ " pg_catalog.pg_namespace n, "
++ " pg_catalog.pg_attribute a "
++ "WHERE c.oid = a.attrelid AND "
++ " a.attnum >= 1 AND "
++ " a.atttypid = 'pg_catalog.xid'::pg_catalog.regtype AND "
++ " c.relnamespace = n.oid AND "
++ /* exclude possible orphaned temp tables */
++ " n.nspname !~ '^pg_temp_' AND "
++ " n.nspname NOT IN ('pg_catalog', 'information_schema')");
++
++ ntups = PQntuples(res);
++ i_nspname = PQfnumber(res, "nspname");
++ i_relname = PQfnumber(res, "relname");
++ i_attname = PQfnumber(res, "attname");
++ for (rowno = 0; rowno < ntups; rowno++)
++ {
++ found = true;
++ if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
++ pg_fatal("could not open file \"%s\": %s\n",
++ output_path, strerror(errno));
++ if (!db_used)
++ {
++ fprintf(script, "Database: %s\n", active_db->db_name);
++ db_used = true;
++ }
++ fprintf(script, " %s.%s.%s\n",
++ PQgetvalue(res, rowno, i_nspname),
++ PQgetvalue(res, rowno, i_relname),
++ PQgetvalue(res, rowno, i_attname));
++ }
++
++ PQclear(res);
++
++ PQfinish(conn);
++ }
++
++ if (script)
++ fclose(script);
++
++ if (found)
++ {
++ pg_log(PG_REPORT, "fatal");
++ pg_fatal("Your installation contains the \"xid\" data type in user tables.\n"
++ "The internal format of \"xid\" changed in Postgres Pro Enterprise so this cluster\n"
++ "cannot currently be upgraded. Note that even dropped attributes cause a problem.\n"
++ "You can remove the problem tables and restart the upgrade.\n"
++ "A list of the problem columns is in the file:\n"
++ " %s", output_path);
++ }
++ else
++ check_ok();
++}
++
++/*
++ * is_xid_wraparound()
++ *
++ * Return true if 32-xid cluster had wraparound.
++ */
++static bool
++is_xid_wraparound(ClusterInfo *cluster)
++{
++ PGconn *conn;
++ PGresult *res;
++ bool is_wraparound;
++
++ conn = connectToServer(cluster, "template1");
++
++ /*
++ * txid_current is extended with an "epoch" counter, so to check
++ * wraparound in old 32-xid cluster we cut epoch by casting to int4.
++ */
++ res = executeQueryOrDie(conn,
++ "SELECT 1 "
++ "FROM pg_catalog.pg_database, txid_current() tx "
++ "WHERE (tx %% 4294967295)::bigint <= datfrozenxid::text::bigint "
++ "LIMIT 1");
++ is_wraparound = PQntuples(res) ? true : false;
++ PQclear(res);
++ PQfinish(conn);
++
++ return is_wraparound;
++}
++
+ /*
+ * Callback function for processing results of query for
+ * check_old_cluster_subscription_state()'s UpgradeTask. If the query returned
+diff --git a/src/bin/pg_upgrade/controldata.c b/src/bin/pg_upgrade/controldata.c
+index 2ce8af0b9db..08d1ad638e4 100644
+--- a/src/bin/pg_upgrade/controldata.c
++++ b/src/bin/pg_upgrade/controldata.c
+@@ -287,6 +287,8 @@ get_control_data(ClusterInfo *cluster)
+ xid.value = strtou64(p, NULL, 10);
+
+ /*
++ * Try to read 32-bit XID format 'epoch:xid'.
++ *
+ * Delimiter changed from '/' to ':' in 9.6. We don't test for
+ * the catalog version of the change because the catalog version
+ * is pulled from pg_controldata too, and it isn't worth adding an
+@@ -302,8 +304,7 @@ get_control_data(ClusterInfo *cluster)
+ if (p == NULL)
+ {
+ /* FullTransactionId representation */
+- cluster->controldata.chkpnt_nxtxid = XidFromFullTransactionId(xid);
+- cluster->controldata.chkpnt_nxtepoch = EpochFromFullTransactionId(xid);
++ cluster->controldata.chkpnt_nxtxid = xid.value;
+ }
+ else
+ {
+@@ -312,8 +313,8 @@ get_control_data(ClusterInfo *cluster)
+
+ /* Epoch:Xid representation */
+ p++; /* remove '/' or ':' char */
+- cluster->controldata.chkpnt_nxtxid = str2uint(p);
+- cluster->controldata.chkpnt_nxtepoch = (TransactionId) XidFromFullTransactionId(xid);
++ cluster->controldata.chkpnt_nxtxid = (XidFromFullTransactionId(xid)) << 32 |
++ (TransactionId) str2uint(p);
+ }
+
+ got_xid = true;
+@@ -337,7 +338,7 @@ get_control_data(ClusterInfo *cluster)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_nxtmulti = str2uint(p);
++ cluster->controldata.chkpnt_nxtmulti = strtou64(p, NULL, 10);
+ got_multi = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's oldestXID:")) != NULL)
+@@ -348,7 +349,7 @@ get_control_data(ClusterInfo *cluster)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_oldstxid = str2uint(p);
++ cluster->controldata.chkpnt_oldstxid = strtou64(p, NULL, 10);
+ got_oldestxid = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's oldestMultiXid:")) != NULL)
+@@ -359,7 +360,7 @@ get_control_data(ClusterInfo *cluster)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_oldstMulti = str2uint(p);
++ cluster->controldata.chkpnt_oldstMulti = strtou64(p, NULL, 10);
+ got_oldestmulti = true;
+ }
+ else if ((p = strstr(bufin, "Latest checkpoint's NextMultiOffset:")) != NULL)
+@@ -370,7 +371,7 @@ get_control_data(ClusterInfo *cluster)
+ pg_fatal("%d: controldata retrieval problem", __LINE__);
+
+ p++; /* remove ':' char */
+- cluster->controldata.chkpnt_nxtmxoff = str2uint(p);
++ cluster->controldata.chkpnt_nxtmxoff = strtou64(p, NULL, 10);
+ got_mxoff = true;
+ }
+ else if ((p = strstr(bufin, "First log segment after reset:")) != NULL)
+diff --git a/src/bin/pg_upgrade/file.c b/src/bin/pg_upgrade/file.c
+index 73932504cae..e23e719e69e 100644
+--- a/src/bin/pg_upgrade/file.c
++++ b/src/bin/pg_upgrade/file.c
+@@ -214,7 +214,8 @@ linkFile(const char *src, const char *dst,
+ */
+ void
+ rewriteVisibilityMap(const char *fromfile, const char *tofile,
+- const char *schemaName, const char *relName)
++ const char *schemaName, const char *relName,
++ bool update_version)
+ {
+ int src_fd;
+ int dst_fd;
+@@ -330,6 +331,11 @@ rewriteVisibilityMap(const char *fromfile, const char *tofile,
+ if (old_lastpart && empty)
+ break;
+
++ if (update_version)
++ PageSetPageSizeAndVersion((Page) new_vmbuf.data,
++ PageGetPageSize((Page) new_vmbuf.data),
++ PG_PAGE_LAYOUT_VERSION);
++
+ /* Set new checksum for visibility map page, if enabled */
+ if (new_cluster.controldata.data_checksum_version != 0)
+ ((PageHeader) new_vmbuf.data)->pd_checksum =
+@@ -356,6 +362,97 @@ rewriteVisibilityMap(const char *fromfile, const char *tofile,
+ close(src_fd);
+ }
+
++/*
++ * updateSegmentVersion()
++ *
++ * Transform a segment file, copying from src to dst.
++ * schemaName/relName are relation's SQL name (used for error messages only).
++ *
++ * Read segment pages one by one and set version to PG_PAGE_LAYOUT_VERSION.
++ *
++ * Although FSM and MV formats does not change while switch to 64-bit XIDs, we
++ * must upgrade pages version in order to avoid lazy conversion on first read.
++ */
++void
++updateSegmentPagesVersion(const char *fromfile, const char *tofile,
++ const char *schemaName, const char *relName)
++{
++ int src_fd;
++ int dst_fd;
++ struct stat statbuf;
++ ssize_t src_filesize;
++ ssize_t totalBytesRead;
++ ssize_t bytesRead;
++ BlockNumber blkno;
++ PGAlignedBlock buf;
++
++ if ((src_fd = open(fromfile, O_RDONLY | PG_BINARY, 0)) < 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not open file \"%s\": %s",
++ schemaName, relName, fromfile, strerror(errno));
++
++ if (fstat(src_fd, &statbuf) != 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not stat file \"%s\": %s",
++ schemaName, relName, fromfile, strerror(errno));
++
++ if ((dst_fd = open(tofile, O_RDWR | O_CREAT | O_EXCL | PG_BINARY,
++ pg_file_create_mode)) < 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not create file \"%s\": %s",
++ schemaName, relName, tofile, strerror(errno));
++
++ /* Save old file size */
++ src_filesize = statbuf.st_size;
++ totalBytesRead = 0;
++ blkno = 0;
++
++ while (totalBytesRead < src_filesize)
++ {
++ errno = 0;
++ if ((bytesRead = read(src_fd, buf.data, BLCKSZ)) != BLCKSZ)
++ {
++ if (bytesRead < 0)
++ pg_fatal("error while copying relation \"%s.%s\": could not read file \"%s\": %s",
++ schemaName, relName, fromfile, strerror(errno));
++ else
++ pg_fatal("error while copying relation \"%s.%s\": partial page found in file \"%s\"",
++ schemaName, relName, fromfile);
++ }
++
++ totalBytesRead += BLCKSZ;
++ PageSetPageSizeAndVersion((Page) buf.data,
++ PageGetPageSize((Page) buf.data),
++ PG_PAGE_LAYOUT_VERSION);
++
++ /* Set new checksum for page, if enabled */
++ if (new_cluster.controldata.data_checksum_version != 0)
++ ((PageHeader) buf.data)->pd_checksum =
++ pg_checksum_page(buf.data, blkno);
++
++ /*
++ * We dealing here only with FSM and VM pages.
++ */
++ if (((PageHeader) buf.data)->pd_lower != SizeOfPageHeaderData ||
++ ((PageHeader) buf.data)->pd_upper != BLCKSZ)
++ pg_fatal("error while copying relation \"%s.%s\": unknown page format found in file \"%s\"",
++ schemaName, relName, fromfile);
++
++ errno = 0;
++ if (write(dst_fd, buf.data, BLCKSZ) != BLCKSZ)
++ {
++ /* if write didn't set errno, assume problem is no disk space */
++ if (errno == 0)
++ errno = ENOSPC;
++ pg_fatal("error while copying relation \"%s.%s\": could not write file \"%s\": %s",
++ schemaName, relName, tofile, strerror(errno));
++ }
++
++ blkno++;
++ }
++
++ /* Clean up */
++ close(dst_fd);
++ close(src_fd);
++}
++
+ void
+ check_file_clone(void)
+ {
+diff --git a/src/bin/pg_upgrade/pg_upgrade.c b/src/bin/pg_upgrade/pg_upgrade.c
+index 4d641732dcc..53c4b130ae1 100644
+--- a/src/bin/pg_upgrade/pg_upgrade.c
++++ b/src/bin/pg_upgrade/pg_upgrade.c
+@@ -40,6 +40,9 @@
+
+ #include <time.h>
+
++#include "access/multixact.h"
++#include "access/transam.h"
++#include "access/xlog_internal.h"
+ #include "catalog/pg_class_d.h"
+ #include "common/file_perm.h"
+ #include "common/logging.h"
+@@ -57,7 +60,7 @@
+ static void set_locale_and_encoding(void);
+ static void prepare_new_cluster(void);
+ static void prepare_new_globals(void);
+-static void create_new_objects(void);
++static void create_new_objects(bool is_wraparound);
+ static void copy_xact_xlog_xid(void);
+ static void set_frozenxids(bool minmxid_only);
+ static void make_outputdirs(char *pgdata);
+@@ -84,6 +87,7 @@ int
+ main(int argc, char **argv)
+ {
+ char *deletion_script_file_name = NULL;
++ bool is_wraparound = false;
+
+ /*
+ * pg_upgrade doesn't currently use common/logging.c, but initialize it
+@@ -129,7 +133,7 @@ main(int argc, char **argv)
+
+ check_cluster_compatibility();
+
+- check_and_dump_old_cluster();
++ check_and_dump_old_cluster(&is_wraparound);
+
+
+ /* -- NEW -- */
+@@ -162,7 +166,7 @@ main(int argc, char **argv)
+
+ prepare_new_globals();
+
+- create_new_objects();
++ create_new_objects(is_wraparound);
+
+ stop_postmaster(false);
+
+@@ -526,7 +530,7 @@ prepare_new_globals(void)
+
+
+ static void
+-create_new_objects(void)
++create_new_objects(bool is_wraparound)
+ {
+ int dbnum;
+ PGconn *conn_new_template1;
+@@ -648,11 +652,23 @@ create_new_objects(void)
+ check_ok();
+
+ /*
+- * We don't have minmxids for databases or relations in pre-9.3 clusters,
+- * so set those after we have restored the schema.
++ * Refix datfrozenxid and datminmxid
+ */
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 902)
+ set_frozenxids(true);
++ else if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ {
++ /*
++ * During upgrade from 32-bit to 64-bit xids save relfrozenxids if
++ * there was no wraparound in old cluster. Otherwise, reset them to
++ * FirstNormalTransactionId value.
++ */
++ if (is_wraparound)
++ set_frozenxids(false);
++ else
++ set_frozenxids(true);
++ }
+
+ /* update new_cluster info now that we have objects in the databases */
+ get_db_rel_and_slot_infos(&new_cluster);
+@@ -706,14 +722,37 @@ copy_subdir_files(const char *old_subdir, const char *new_subdir)
+ static void
+ copy_xact_xlog_xid(void)
+ {
+- /*
+- * Copy old commit logs to new data dir. pg_clog has been renamed to
+- * pg_xact in post-10 clusters.
+- */
+- copy_subdir_files(GET_MAJOR_VERSION(old_cluster.major_version) <= 906 ?
+- "pg_clog" : "pg_xact",
+- GET_MAJOR_VERSION(new_cluster.major_version) <= 906 ?
+- "pg_clog" : "pg_xact");
++ TransactionId next_xid;
++
++#define GetClogDirName(cluster) \
++ GET_MAJOR_VERSION(cluster.major_version) <= 906 ? "pg_clog" : "pg_xact"
++
++ /* Set next xid to 2^32 if we're upgrading from 32 bit postgres */
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ next_xid = ((TransactionId) 1 << 32);
++ else
++ next_xid = old_cluster.controldata.chkpnt_nxtxid;
++
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ {
++ /* Convert commit logs and copy to the new data dir */
++ prep_status("Transforming commit log segments");
++ convert_xact(psprintf("%s/%s", old_cluster.pgdata, GetClogDirName(old_cluster)),
++ psprintf("%s/%s", new_cluster.pgdata, GetClogDirName(new_cluster)));
++ check_ok();
++ }
++ else
++ {
++ /*
++ * Copy old commit logs to new data dir. pg_clog has been renamed to
++ * pg_xact in post-10 clusters.
++ */
++ prep_status("Copying commit log segments");
++ copy_subdir_files(GetClogDirName(old_cluster), GetClogDirName(new_cluster));
++ check_ok();
++ }
+
+ prep_status("Setting oldest XID for new cluster");
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+@@ -727,19 +766,20 @@ copy_xact_xlog_xid(void)
+ prep_status("Setting next transaction ID and epoch for new cluster");
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -x %llu \"%s\"",
+- new_cluster.bindir,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
++ new_cluster.bindir, (unsigned long long) next_xid,
+ new_cluster.pgdata);
++#ifdef NOT_USED
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -e %u \"%s\"",
+ new_cluster.bindir, old_cluster.controldata.chkpnt_nxtepoch,
+ new_cluster.pgdata);
++#endif
+ /* must reset commit timestamp limits also */
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -f -c %llu,%llu \"%s\"",
+ new_cluster.bindir,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid,
++ (unsigned long long) next_xid,
++ (unsigned long long) next_xid,
+ new_cluster.pgdata);
+ check_ok();
+
+@@ -752,6 +792,10 @@ copy_xact_xlog_xid(void)
+ if (old_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER &&
+ new_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER)
+ {
++ uint64 oldest_mxid = old_cluster.controldata.chkpnt_oldstMulti;
++ uint64 next_mxid = old_cluster.controldata.chkpnt_nxtmulti;
++ uint64 next_mxoff = old_cluster.controldata.chkpnt_nxtmxoff;
++
+ /*
+ * If the old server is before the MULTIXACTOFFSET_FORMATCHANGE_CAT_VER
+ * it must have 32-bit multixid offsets, thus it should be converted.
+@@ -798,9 +842,9 @@ copy_xact_xlog_xid(void)
+ exec_prog(UTILITY_LOG_FILE, NULL, true, true,
+ "\"%s/pg_resetwal\" -O %llu -m %llu,%llu \"%s\"",
+ new_cluster.bindir,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmxoff,
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti,
+- (unsigned long long) old_cluster.controldata.chkpnt_oldstMulti,
++ (unsigned long long) next_mxoff,
++ (unsigned long long) next_mxid,
++ (unsigned long long) oldest_mxid,
+ new_cluster.pgdata);
+ check_ok();
+ }
+@@ -874,6 +918,8 @@ set_frozenxids(bool minmxid_only)
+ int ntups;
+ int i_datname;
+ int i_datallowconn;
++ TransactionId frozen_xid;
++ MultiXactId minmxid;
+
+ if (!minmxid_only)
+ prep_status("Setting frozenxid and minmxid counters in new cluster");
+@@ -882,18 +928,26 @@ set_frozenxids(bool minmxid_only)
+
+ conn_template1 = connectToServer(&new_cluster, "template1");
+
++ if (old_cluster.controldata.cat_ver < XID_FORMATCHANGE_CAT_VER &&
++ new_cluster.controldata.cat_ver >= XID_FORMATCHANGE_CAT_VER)
++ frozen_xid = FirstNormalTransactionId;
++ else
++ frozen_xid = old_cluster.controldata.chkpnt_nxtxid;
++
++ minmxid = old_cluster.controldata.chkpnt_nxtmulti;
++
+ if (!minmxid_only)
+ /* set pg_database.datfrozenxid */
+ PQclear(executeQueryOrDie(conn_template1,
+ "UPDATE pg_catalog.pg_database "
+ "SET datfrozenxid = '%llu'",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid));
++ (unsigned long long) frozen_xid));
+
+ /* set pg_database.datminmxid */
+ PQclear(executeQueryOrDie(conn_template1,
+ "UPDATE pg_catalog.pg_database "
+ "SET datminmxid = '%llu'",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti));
++ (unsigned long long) minmxid));
+
+ /* get database names */
+ dbres = executeQueryOrDie(conn_template1,
+@@ -933,7 +987,7 @@ set_frozenxids(bool minmxid_only)
+ CppAsString2(RELKIND_RELATION) ", "
+ CppAsString2(RELKIND_MATVIEW) ", "
+ CppAsString2(RELKIND_TOASTVALUE) ")",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtxid));
++ (unsigned long long) frozen_xid));
+
+ /* set pg_class.relminmxid */
+ PQclear(executeQueryOrDie(conn,
+@@ -944,7 +998,7 @@ set_frozenxids(bool minmxid_only)
+ CppAsString2(RELKIND_RELATION) ", "
+ CppAsString2(RELKIND_MATVIEW) ", "
+ CppAsString2(RELKIND_TOASTVALUE) ")",
+- (unsigned long long) old_cluster.controldata.chkpnt_nxtmulti));
++ (unsigned long long) minmxid));
+ PQfinish(conn);
+
+ /* Reset datallowconn flag */
+diff --git a/src/bin/pg_upgrade/pg_upgrade.h b/src/bin/pg_upgrade/pg_upgrade.h
+index 2c85ec1e949..5beccedff89 100644
+--- a/src/bin/pg_upgrade/pg_upgrade.h
++++ b/src/bin/pg_upgrade/pg_upgrade.h
+@@ -121,6 +121,11 @@ extern char *output_files[];
+ */
+ #define MULTIXACTOFFSET_FORMATCHANGE_CAT_VER 202409041
+
++/*
++ * xid format changed from 32-bit to 64-bit.
++ */
++#define XID_FORMATCHANGE_CAT_VER 999999999
++
+ /*
+ * large object chunk size added to pg_controldata,
+ * commit 5f93c37805e7485488480916b4585e098d3cc883
+@@ -233,13 +238,13 @@ typedef struct
+ uint32 ctrl_ver;
+ uint32 cat_ver;
+ char nextxlogfile[25];
+- uint32 chkpnt_nxtxid;
+- uint32 chkpnt_nxtepoch;
++ uint64 chkpnt_nxtxid;
++ uint32 chkpnt_nxtepoch; /* for 32bit xids only */
+ uint32 chkpnt_nxtoid;
+- uint32 chkpnt_nxtmulti;
++ uint64 chkpnt_nxtmulti;
+ uint64 chkpnt_nxtmxoff;
+- uint32 chkpnt_oldstMulti;
+- uint32 chkpnt_oldstxid;
++ uint64 chkpnt_oldstMulti;
++ uint64 chkpnt_oldstxid;
+ uint32 align;
+ uint32 blocksz;
+ uint32 largesz;
+@@ -374,7 +379,7 @@ extern OSInfo os_info;
+ /* check.c */
+
+ void output_check_banner(void);
+-void check_and_dump_old_cluster(void);
++void check_and_dump_old_cluster(bool *is_wraparound);
+ void check_new_cluster(void);
+ void report_clusters_compatible(void);
+ void issue_warnings_and_set_wal_level(void);
+@@ -417,7 +422,10 @@ void copyFileByRange(const char *src, const char *dst,
+ void linkFile(const char *src, const char *dst,
+ const char *schemaName, const char *relName);
+ void rewriteVisibilityMap(const char *fromfile, const char *tofile,
+- const char *schemaName, const char *relName);
++ const char *schemaName, const char *relName,
++ bool update_version);
++void updateSegmentPagesVersion(const char *fromfile, const char *tofile,
++ const char *schemaName, const char *relName);
+ void check_file_clone(void);
+ void check_copy_file_range(void);
+ void check_hard_link(void);
+@@ -494,6 +502,10 @@ void old_9_6_invalidate_hash_indexes(ClusterInfo *cluster,
+
+ void report_extension_updates(ClusterInfo *cluster);
+
++void invalidate_spgist_indexes(ClusterInfo *cluster, bool check_mode);
++void invalidate_gin_indexes(ClusterInfo *cluster, bool check_mode);
++void invalidate_external_indexes(ClusterInfo *cluster, bool check_mode);
++
+ /* parallel.c */
+ void parallel_exec_prog(const char *log_file, const char *opt_log_file,
+ const char *fmt,...) pg_attribute_printf(3, 4);
+@@ -502,6 +514,11 @@ void parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr
+ char *old_tablespace);
+ bool reap_child(bool wait_for_child);
+
++/* segresize.c */
++
++uint64 convert_multixact_offsets(void);
++void convert_xact(const char *olddir, const char *newdir);
++
+ /* task.c */
+
+ typedef void (*UpgradeTaskProcessCB) (DbInfo *dbinfo, PGresult *res, void *arg);
+diff --git a/src/bin/pg_upgrade/relfilenumber.c b/src/bin/pg_upgrade/relfilenumber.c
+index 07baa49a025..57c3f40a930 100644
+--- a/src/bin/pg_upgrade/relfilenumber.c
++++ b/src/bin/pg_upgrade/relfilenumber.c
+@@ -14,7 +14,8 @@
+ #include "pg_upgrade.h"
+
+ static void transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace);
+-static void transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_frozenbit);
++static void transfer_relfile(FileNameMap *map, const char *type_suffix,
++ bool vm_must_add_frozenbit, bool update_version);
+
+
+ /*
+@@ -137,6 +138,7 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+ {
+ int mapnum;
+ bool vm_must_add_frozenbit = false;
++ bool update_version = false;
+
+ /*
+ * Do we need to rewrite visibilitymap?
+@@ -145,19 +147,28 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+ new_cluster.controldata.cat_ver >= VISIBILITY_MAP_FROZEN_BIT_CAT_VER)
+ vm_must_add_frozenbit = true;
+
++ /*
++ * Need to update FSM and VM pages version to avoid lazy conversion.
++ */
++ if (old_cluster.controldata.cat_ver < new_cluster.controldata.cat_ver)
++ update_version = true;
++
+ for (mapnum = 0; mapnum < size; mapnum++)
+ {
+ if (old_tablespace == NULL ||
+ strcmp(maps[mapnum].old_tablespace, old_tablespace) == 0)
+ {
+ /* transfer primary file */
+- transfer_relfile(&maps[mapnum], "", vm_must_add_frozenbit);
++ transfer_relfile(&maps[mapnum], "", vm_must_add_frozenbit,
++ update_version);
+
+ /*
+ * Copy/link any fsm and vm files, if they exist
+ */
+- transfer_relfile(&maps[mapnum], "_fsm", vm_must_add_frozenbit);
+- transfer_relfile(&maps[mapnum], "_vm", vm_must_add_frozenbit);
++ transfer_relfile(&maps[mapnum], "_fsm", vm_must_add_frozenbit,
++ update_version);
++ transfer_relfile(&maps[mapnum], "_vm", vm_must_add_frozenbit,
++ update_version);
+ }
+ }
+ }
+@@ -171,7 +182,8 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+ * mode.
+ */
+ static void
+-transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_frozenbit)
++transfer_relfile(FileNameMap *map, const char *type_suffix,
++ bool vm_must_add_frozenbit, bool update_version)
+ {
+ char old_file[MAXPGPATH];
+ char new_file[MAXPGPATH];
+@@ -235,7 +247,17 @@ transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_fro
+ /* Need to rewrite visibility map format */
+ pg_log(PG_VERBOSE, "rewriting \"%s\" to \"%s\"",
+ old_file, new_file);
+- rewriteVisibilityMap(old_file, new_file, map->nspname, map->relname);
++ rewriteVisibilityMap(old_file, new_file, map->nspname,
++ map->relname, update_version);
++ }
++ else if ((update_version && strcmp(type_suffix, "_vm") == 0) ||
++ (update_version && strcmp(type_suffix, "_fsm") == 0))
++ {
++ /* Need to update pages version */
++ pg_log(PG_VERBOSE, "rewriting \"%s\" to \"%s\"",
++ old_file, new_file);
++ updateSegmentPagesVersion(old_file, new_file, map->nspname,
++ map->relname);
+ }
+ else
+ switch (user_opts.transfer_mode)
+diff --git a/src/bin/pg_upgrade/segresize.c b/src/bin/pg_upgrade/segresize.c
+index 73064c77deb..37a4efbec34 100644
+--- a/src/bin/pg_upgrade/segresize.c
++++ b/src/bin/pg_upgrade/segresize.c
+@@ -217,6 +217,76 @@ typedef uint32 MultiXactOffsetOld;
+ #define MULTIXACT_OFFSETS_PER_PAGE_OLD (BLCKSZ / sizeof(MultiXactOffsetOld))
+ #define MULTIXACT_OFFSETS_PER_PAGE_NEW (BLCKSZ / sizeof(MultiXactOffset))
+
++/*
++ * Convert pg_xact segments.
++ */
++void
++convert_xact(const char *old_subdir, const char *new_subdir)
++{
++typedef uint32 TransactionId32;
++#define SLRU_PAGES_PER_SEGMENT_OLD 32
++#define SLRU_PAGES_PER_SEGMENT 32 /* Should be equal to value from slru.h */
++
++#define CLOG_BITS_PER_XACT 2
++#define CLOG_XACTS_PER_BYTE 4
++#define CLOG_XACTS_PER_PAGE (BLCKSZ * CLOG_XACTS_PER_BYTE)
++
++#define MaxTransactionId32 ((TransactionId32) 0xFFFFFFFF)
++
++ SlruSegState oldseg = {0};
++ SlruSegState newseg = {0};
++ TransactionId oldest_xid = old_cluster.controldata.chkpnt_oldstxid;
++ TransactionId next_xid = old_cluster.controldata.chkpnt_nxtxid;
++ TransactionId xid;
++ int64 pageno;
++ char buf[BLCKSZ] = {0};
++
++ oldseg.dir = (char *) old_subdir;
++ newseg.dir = (char *) new_subdir;
++
++ pageno = oldest_xid / CLOG_XACTS_PER_PAGE;
++
++ oldseg.segno = pageno / SLRU_PAGES_PER_SEGMENT_OLD;
++ oldseg.pageno = pageno % SLRU_PAGES_PER_SEGMENT_OLD;
++
++ newseg.segno = pageno / SLRU_PAGES_PER_SEGMENT;
++ newseg.pageno = pageno % SLRU_PAGES_PER_SEGMENT;
++
++ if (next_xid < oldest_xid)
++ next_xid += (TransactionId) 1 << 32; /* wraparound */
++
++ /* Copy xid flags reading only needed segment pages */
++ for (xid = oldest_xid & ~(CLOG_XACTS_PER_PAGE - 1);
++ xid <= ((next_xid - 1) & ~(CLOG_XACTS_PER_PAGE - 1));
++ xid += CLOG_XACTS_PER_PAGE)
++ {
++ bool is_empty;
++
++ /* Handle possible segment wraparound */
++ if (oldseg.segno > MaxTransactionId32 / CLOG_XACTS_PER_PAGE / SLRU_PAGES_PER_SEGMENT_OLD)
++ {
++ pageno = (MaxTransactionId32 + 1) / CLOG_XACTS_PER_PAGE;
++
++ Assert(oldseg.segno == pageno / SLRU_PAGES_PER_SEGMENT_OLD);
++ Assert(!oldseg.pageno);
++ Assert(!oldseg.file);
++ oldseg.segno = 0;
++
++ Assert(newseg.segno == pageno / SLRU_PAGES_PER_SEGMENT);
++ Assert(!newseg.pageno);
++ Assert(!newseg.file);
++ newseg.segno = 0;
++ }
++
++ read_old_segment_page(&oldseg, buf, &is_empty);
++ write_new_segment_page(&newseg, buf);
++ }
++
++ /* Release resources */
++ close_segment(&oldseg);
++ close_segment(&newseg);
++}
++
+ /*
+ * Convert pg_multixact/offsets segments and return oldest multi offset.
+ */
+diff --git a/src/bin/pg_upgrade/t/002_pg_upgrade.pl b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
+index 3b9cb21cbd5..a8841f6ba38 100644
+--- a/src/bin/pg_upgrade/t/002_pg_upgrade.pl
++++ b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
+@@ -315,6 +315,14 @@ if (defined($ENV{oldinstall}))
+ }
+ }
+
++$oldnode->safe_psql('regression',
++ "CREATE TABLE t1 (id SERIAL NOT NULL PRIMARY KEY, plt text, pln NUMERIC(8, 4));
++ INSERT INTO t1 (plt, pln) SELECT md5(random()::text), random() * 9999 FROM generate_series(1, 1000);");
++my $relfrozenxid = $oldnode->safe_psql('regression',
++ "SELECT relfrozenxid FROM pg_class WHERE relname = 't1';");
++my $relminmxid = $oldnode->safe_psql('regression',
++ "SELECT relminmxid FROM pg_class WHERE relname = 't1';");
++
+ # Take a dump before performing the upgrade as a base comparison. Note
+ # that we need to use pg_dumpall from the new node here.
+ my @dump_command = (
+@@ -467,6 +475,16 @@ ok( !-d $newnode->data_dir . "/pg_upgrade_output.d",
+
+ $newnode->start;
+
++my $relfrozenxid_new = $newnode->safe_psql('regression',
++ "SELECT relfrozenxid FROM pg_class WHERE relname = 't1';");
++
++is($relfrozenxid_new, $relfrozenxid, 'old and new relfrozenxid match after pg_upgrade');
++
++my $relminmxid_new = $newnode->safe_psql('regression',
++ "SELECT relminmxid FROM pg_class WHERE relname = 't1';");
++
++is($relminmxid_new, $relminmxid, 'old and new relminmxid match after pg_upgrade');
++
+ # Check if there are any logs coming from pg_upgrade, that would only be
+ # retained on failure.
+ my $log_path = $newnode->data_dir . "/pg_upgrade_output.d";
+diff --git a/src/bin/pg_upgrade/version.c b/src/bin/pg_upgrade/version.c
+index 2a3b6ebb347..3b7d67eeee2 100644
+--- a/src/bin/pg_upgrade/version.c
++++ b/src/bin/pg_upgrade/version.c
+@@ -9,6 +9,7 @@
+
+ #include "postgres_fe.h"
+
++#include "access/transam.h"
+ #include "fe_utils/string_utils.h"
+ #include "pg_upgrade.h"
+
+@@ -29,19 +30,21 @@ jsonb_9_4_check_applicable(ClusterInfo *cluster)
+ }
+
+ /*
+- * old_9_6_invalidate_hash_indexes()
+- * 9.6 -> 10
+- * Hash index binary format has changed from 9.6->10.0
++ * invalidate_indexes()
++ * Invalidates all indexes satisfying given predicate.
+ */
+-void
+-old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
++static void
++invalidate_indexes(ClusterInfo *cluster, bool check_mode,
++ const char *name, const char *pred)
+ {
+ int dbnum;
+ FILE *script = NULL;
+ bool found = false;
+- char *output_path = "reindex_hash.sql";
++ char output_path[MAXPGPATH];
++
++ snprintf(output_path, sizeof(output_path), "reindex_%s.sql", name);
+
+- prep_status("Checking for hash indexes");
++ prep_status("Checking for %s indexes", name);
+
+ for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
+ {
+@@ -54,9 +57,16 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ DbInfo *active_db = &cluster->dbarr.dbs[dbnum];
+ PGconn *conn = connectToServer(cluster, active_db->db_name);
+
+- /* find hash indexes */
+- res = executeQueryOrDie(conn,
+- "SELECT n.nspname, c.relname "
++
++ /*
++ * Find indexes satisfying predicate.
++ *
++ * System indexes (with oids < FirstNormalObjectId) are excluded from
++ * the search as they are recreated in the new cluster during initdb.
++ */
++ res = executeQueryOrDie(
++ conn,
++ "SELECT n.nspname, c.relname, i.indexrelid "
+ "FROM pg_catalog.pg_class c, "
+ " pg_catalog.pg_index i, "
+ " pg_catalog.pg_am a, "
+@@ -64,8 +74,11 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ "WHERE i.indexrelid = c.oid AND "
+ " c.relam = a.oid AND "
+ " c.relnamespace = n.oid AND "
+- " a.amname = 'hash'"
+- );
++ " i.indexrelid >= '%u'::pg_catalog.oid AND "
++ " %s "
++ "ORDER BY i.indexrelid ASC",
++ FirstNormalObjectId,
++ pred);
+
+ ntups = PQntuples(res);
+ i_nspname = PQfnumber(res, "nspname");
+@@ -97,8 +110,14 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+
+ if (!check_mode && db_used)
+ {
+- /* mark hash indexes as invalid */
+- PQclear(executeQueryOrDie(conn,
++ /*
++ * Mark indexes satisfying predicate as invalid.
++ *
++ * System indexes (with oids < FirstNormalObjectId) are excluded
++ * from the search (see above).
++ */
++ PQclear(executeQueryOrDie(
++ conn,
+ "UPDATE pg_catalog.pg_index i "
+ "SET indisvalid = false "
+ "FROM pg_catalog.pg_class c, "
+@@ -107,7 +126,10 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ "WHERE i.indexrelid = c.oid AND "
+ " c.relam = a.oid AND "
+ " c.relnamespace = n.oid AND "
+- " a.amname = 'hash'"));
++ " i.indexrelid >= '%u'::pg_catalog.oid AND "
++ " %s",
++ FirstNormalObjectId,
++ pred));
+ }
+
+ PQfinish(conn);
+@@ -121,24 +143,72 @@ old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
+ report_status(PG_WARNING, "warning");
+ if (check_mode)
+ pg_log(PG_WARNING, "\n"
+- "Your installation contains hash indexes. These indexes have different\n"
++ "Your installation contains %s indexes. These indexes have different\n"
+ "internal formats between your old and new clusters, so they must be\n"
+ "reindexed with the REINDEX command. After upgrading, you will be given\n"
+- "REINDEX instructions.");
++ "REINDEX instructions.",
++ name);
++
+ else
+ pg_log(PG_WARNING, "\n"
+- "Your installation contains hash indexes. These indexes have different\n"
++ "Your installation contains %s indexes. These indexes have different\n"
+ "internal formats between your old and new clusters, so they must be\n"
+ "reindexed with the REINDEX command. The file\n"
+ " %s\n"
+ "when executed by psql by the database superuser will recreate all invalid\n"
+ "indexes; until then, none of these indexes will be used.",
++ name,
+ output_path);
+ }
+ else
+ check_ok();
+ }
+
++/*
++ * old_9_6_invalidate_hash_indexes()
++ * 9.6 -> 10
++ * Hash index binary format has changed from 9.6->10.0
++ */
++void
++old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "hash", "a.amname = 'hash'");
++}
++
++
++/*
++ * invalidate_spgist_indexes()
++ * 32bit -> 64bit
++ * SP-GIST contains xids.
++ */
++void
++invalidate_spgist_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "spgist", "a.amname = 'spgist'");
++}
++
++/*
++ * invalidate_gin_indexes()
++ * 32bit -> 64bit
++ * Gin indexes contains xids in deleted pages.
++ */
++void
++invalidate_gin_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "gin", "a.amname = 'gin'");
++}
++
++/*
++ * invalidate_external_indexes()
++ * Generate script to REINDEX non standard external indexes (like RUM etc)
++ */
++void
++invalidate_external_indexes(ClusterInfo *cluster, bool check_mode)
++{
++ invalidate_indexes(cluster, check_mode, "external",
++ "NOT a.amname IN ('btree', 'hash', 'gist', 'gin', 'spgist', 'brin')");
++}
++
+ /*
+ * Callback function for processing results of query for
+ * report_extension_updates()'s UpgradeTask. If the query returned any rows,
+diff --git a/src/bin/pg_waldump/pg_waldump.c b/src/bin/pg_waldump/pg_waldump.c
+index ae6b138cb3d..9679db87718 100644
+--- a/src/bin/pg_waldump/pg_waldump.c
++++ b/src/bin/pg_waldump/pg_waldump.c
+@@ -1050,7 +1050,7 @@ main(int argc, char **argv)
+ config.filter_by_fpw = true;
+ break;
+ case 'x':
+- if (sscanf(optarg, "%u", &config.filter_by_xid) != 1)
++ if (sscanf(optarg, "%" PRIu64 "u", &config.filter_by_xid) != 1)
+ {
+ pg_log_error("invalid transaction ID specification: \"%s\"",
+ optarg);
+diff --git a/src/bin/pg_waldump/t/001_basic.pl b/src/bin/pg_waldump/t/001_basic.pl
+index 578e4731394..6313b4edeae 100644
+--- a/src/bin/pg_waldump/t/001_basic.pl
++++ b/src/bin/pg_waldump/t/001_basic.pl
+@@ -73,7 +73,8 @@ BRIN
+ CommitTs
+ ReplicationOrigin
+ Generic
+-LogicalMessage$/,
++LogicalMessage
++Heap3$/,
+ 'rmgr list');
+
+
+diff --git a/src/include/access/ginblock.h b/src/include/access/ginblock.h
+index b3b7daa049a..1b5e46d264a 100644
+--- a/src/include/access/ginblock.h
++++ b/src/include/access/ginblock.h
+@@ -133,8 +133,15 @@ typedef struct GinMetaPageData
+ * We should reclaim deleted page only once every transaction started before
+ * its deletion is over.
+ */
+-#define GinPageGetDeleteXid(page) ( ((PageHeader) (page))->pd_prune_xid )
+-#define GinPageSetDeleteXid(page, xid) ( ((PageHeader) (page))->pd_prune_xid = xid)
++#define GinPageGetDeleteXid(page) ( \
++ (((PageHeader) (page))->pd_upper == BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId)) ? \
++ *((TransactionId *) ((char *) (page) + BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId))) : \
++ InvalidTransactionId )
++#define GinPageSetDeleteXid(page, xid) \
++ do { \
++ ((PageHeader) (page))->pd_upper = BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId); \
++ *((TransactionId *) ((char *) (page) + BLCKSZ - sizeof(GinPageOpaqueData) - sizeof(TransactionId))) = xid; \
++ } while (false)
+ extern bool GinPageIsRecyclable(Page page);
+
+ /*
+diff --git a/src/include/access/gist.h b/src/include/access/gist.h
+index 22dd04c1418..9455beb7202 100644
+--- a/src/include/access/gist.h
++++ b/src/include/access/gist.h
+@@ -225,7 +225,7 @@ GistPageGetDeleteXid(Page page)
+ return ((GISTDeletedPageContents *) PageGetContents(page))->deleteXid;
+ }
+ else
+- return FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
++ return FullTransactionIdFromXid(FirstNormalTransactionId);
+ }
+
+ /*
+diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
+index 96cf82f97b7..5f5f9976c60 100644
+--- a/src/include/access/heapam.h
++++ b/src/include/access/heapam.h
+@@ -106,6 +106,8 @@ typedef struct HeapScanDescData
+ int rs_cindex; /* current tuple's index in vistuples */
+ int rs_ntuples; /* number of visible tuples on page */
+ OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]; /* their offsets */
++ TransactionId rs_xmin[MaxHeapTuplesPerPage]; /* their xmins */
++ TransactionId rs_xmax[MaxHeapTuplesPerPage]; /* their xmaxs */
+ } HeapScanDescData;
+ typedef struct HeapScanDescData *HeapScanDesc;
+
+@@ -319,6 +321,8 @@ extern void ReleaseBulkInsertStatePin(BulkInsertState bistate);
+
+ extern void heap_insert(Relation relation, HeapTuple tup, CommandId cid,
+ int options, BulkInsertState bistate);
++extern void rewrite_page_prepare_for_xid(Page page, HeapTuple tup,
++ bool is_toast);
+ extern void heap_multi_insert(Relation relation, struct TupleTableSlot **slots,
+ int ntuples, CommandId cid, int options,
+ BulkInsertState bistate);
+@@ -345,23 +349,23 @@ extern void heap_inplace_update_and_unlock(Relation relation,
+ Buffer buffer);
+ extern void heap_inplace_unlock(Relation relation,
+ HeapTuple oldtup, Buffer buffer);
+-extern bool heap_prepare_freeze_tuple(HeapTupleHeader tuple,
++extern bool heap_prepare_freeze_tuple(HeapTuple tuple,
+ const struct VacuumCutoffs *cutoffs,
+ HeapPageFreeze *pagefrz,
+ HeapTupleFreeze *frz, bool *totally_frozen);
+
+-extern void heap_pre_freeze_checks(Buffer buffer,
++extern void heap_pre_freeze_checks(Relation rel, Buffer buffer,
+ HeapTupleFreeze *tuples, int ntuples);
+-extern void heap_freeze_prepared_tuples(Buffer buffer,
++extern void heap_freeze_prepared_tuples(Relation rel, Buffer buffer,
+ HeapTupleFreeze *tuples, int ntuples);
+-extern bool heap_freeze_tuple(HeapTupleHeader tuple,
++extern bool heap_freeze_tuple(HeapTuple tuple,
+ TransactionId relfrozenxid, TransactionId relminmxid,
+ TransactionId FreezeLimit, TransactionId MultiXactCutoff);
+-extern bool heap_tuple_should_freeze(HeapTupleHeader tuple,
++extern bool heap_tuple_should_freeze(HeapTuple tuple,
+ const struct VacuumCutoffs *cutoffs,
+ TransactionId *NoFreezePageRelfrozenXid,
+ MultiXactId *NoFreezePageRelminMxid);
+-extern bool heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple);
++extern bool heap_tuple_needs_eventual_freeze(HeapTuple tuple);
+
+ extern void simple_heap_insert(Relation relation, HeapTuple tup);
+ extern void simple_heap_delete(Relation relation, ItemPointer tid);
+@@ -382,12 +386,19 @@ extern void heap_page_prune_and_freeze(Relation relation, Buffer buffer,
+ PruneReason reason,
+ OffsetNumber *off_loc,
+ TransactionId *new_relfrozen_xid,
+- MultiXactId *new_relmin_mxid);
++ MultiXactId *new_relmin_mxid,
++ bool repairFragmentation);
++
+ extern void heap_page_prune_execute(Buffer buffer, bool lp_truncate_only,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *nowdead, int ndead,
+- OffsetNumber *nowunused, int nunused);
+-extern void heap_get_root_tuples(Page page, OffsetNumber *root_offsets);
++ OffsetNumber *nowunused, int nunused,
++ bool repairFragmentation,
++ bool is_toast);
++
++extern void heap_get_root_tuples(Relation relation, Buffer buffer, Page page,
++ OffsetNumber *root_offsets);
++
+ extern void log_heap_prune_and_freeze(Relation relation, Buffer buffer,
+ TransactionId conflict_xid,
+ bool cleanup_lock,
+@@ -395,7 +406,8 @@ extern void log_heap_prune_and_freeze(Relation relation, Buffer buffer,
+ HeapTupleFreeze *frozen, int nfrozen,
+ OffsetNumber *redirected, int nredirected,
+ OffsetNumber *dead, int ndead,
+- OffsetNumber *unused, int nunused);
++ OffsetNumber *unused, int nunused,
++ bool repairFragmentation);
+
+ /* in heap/vacuumlazy.c */
+ struct VacuumParams;
+@@ -413,7 +425,7 @@ extern HTSV_Result HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer
+ TransactionId *dead_after);
+ extern void HeapTupleSetHintBits(HeapTupleHeader tuple, Buffer buffer,
+ uint16 infomask, TransactionId xid);
+-extern bool HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple);
++extern bool HeapTupleIsOnlyLocked(HeapTuple htup);
+ extern bool HeapTupleIsSurelyDead(HeapTuple htup,
+ struct GlobalVisState *vistest);
+
+@@ -440,18 +452,32 @@ extern void HeapCheckForSerializableConflictOut(bool visible, Relation relation,
+ * in private storage (which is what CLUSTER and friends do).
+ */
+ static inline void
+-heap_execute_freeze_tuple(HeapTupleHeader tuple, HeapTupleFreeze *frz)
++heap_execute_freeze_tuple(HeapTuple htup, HeapTupleFreeze *frz)
+ {
+- HeapTupleHeaderSetXmax(tuple, frz->xmax);
++ HeapTupleHeader tuple = htup->t_data;
++
++ tuple->t_infomask = frz->t_infomask;
++ tuple->t_infomask2 = frz->t_infomask2;
++
++ HeapTupleSetXmax(htup, frz->xmax);
+
+ if (frz->frzflags & XLH_FREEZE_XVAC)
+ HeapTupleHeaderSetXvac(tuple, FrozenTransactionId);
+
+ if (frz->frzflags & XLH_INVALID_XVAC)
+ HeapTupleHeaderSetXvac(tuple, InvalidTransactionId);
++}
+
+- tuple->t_infomask = frz->t_infomask;
+- tuple->t_infomask2 = frz->t_infomask2;
++static inline void
++heap_execute_freeze_tuple_page(Page page, HeapTupleHeader htup,
++ HeapTupleFreeze *frz, bool is_toast)
++{
++ HeapTupleData tuple;
++
++ tuple.t_data = htup;
++ heap_execute_freeze_tuple(&tuple, frz);
++
++ HeapTupleHeaderStoreXmax(page, &tuple, is_toast);
+ }
+
+ #endif /* HEAPAM_H */
+diff --git a/src/include/access/heapam_xlog.h b/src/include/access/heapam_xlog.h
+index 4591e9a918f..74648a5fe5d 100644
+--- a/src/include/access/heapam_xlog.h
++++ b/src/include/access/heapam_xlog.h
+@@ -65,6 +65,8 @@
+ #define XLOG_HEAP2_LOCK_UPDATED 0x60
+ #define XLOG_HEAP2_NEW_CID 0x70
+
++#define XLOG_HEAP3_BASE_SHIFT 0x00
++
+ /*
+ * xl_heap_insert/xl_heap_multi_insert flag values, 8 bits are available.
+ */
+@@ -104,6 +106,7 @@
+ #define XLH_DELETE_CONTAINS_OLD_KEY (1<<2)
+ #define XLH_DELETE_IS_SUPER (1<<3)
+ #define XLH_DELETE_IS_PARTITION_MOVE (1<<4)
++#define XLH_DELETE_PAGE_ON_TOAST_RELATION (1<<5)
+
+ /* convenience macro for checking whether any form of old tuple was logged */
+ #define XLH_DELETE_CONTAINS_OLD \
+@@ -282,10 +285,12 @@ typedef struct xl_heap_update
+ * other fields require only 2-byte alignment. This is also the reason that
+ * 'frz_offsets' is stored separately from the xlhp_freeze_plan structs.
+ */
++
+ typedef struct xl_heap_prune
+ {
+ uint8 reason;
+- uint8 flags;
++ uint8 padding;
++ uint16 flags;
+
+ /*
+ * If XLHP_HAS_CONFLICT_HORIZON is set, the conflict horizon XID follows,
+@@ -293,7 +298,7 @@ typedef struct xl_heap_prune
+ */
+ } xl_heap_prune;
+
+-#define SizeOfHeapPrune (offsetof(xl_heap_prune, flags) + sizeof(uint8))
++#define SizeOfHeapPrune (offsetof(xl_heap_prune, flags) + sizeof(((xl_heap_prune*)0)->flags))
+
+ /* to handle recovery conflict during logical decoding on standby */
+ #define XLHP_IS_CATALOG_REL (1 << 1)
+@@ -331,6 +336,9 @@ typedef struct xl_heap_prune
+ #define XLHP_HAS_DEAD_ITEMS (1 << 6)
+ #define XLHP_HAS_NOW_UNUSED_ITEMS (1 << 7)
+
++#define XLHP_ON_TOAST_RELATION (1 << 8)
++#define XLHP_REPAIR_FRAGMENTATION (1 << 9)
++
+ /*
+ * xlhp_freeze_plan describes how to freeze a group of one or more heap tuples
+ * (appears in xl_heap_prune's xlhp_freeze_plans sub-record)
+@@ -480,7 +488,19 @@ typedef struct xl_heap_rewrite_mapping
+ XLogRecPtr start_lsn; /* Insert LSN at begin of rewrite */
+ } xl_heap_rewrite_mapping;
+
+-extern void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
++#define XLH_BASE_SHIFT_ON_TOAST_RELATION 0x01
++
++/* shift the base of xids on heap page */
++typedef struct xl_heap_base_shift
++{
++ int64 delta; /* delta value to shift the base */
++ bool multi; /* true to shift multixact base */
++ uint8 flags;
++} xl_heap_base_shift;
++
++#define SizeOfHeapBaseShift (offsetof(xl_heap_base_shift, flags) + sizeof(uint8))
++
++extern void HeapTupleHeaderAdvanceConflictHorizon(HeapTuple tuple,
+ TransactionId *snapshotConflictHorizon);
+
+ extern void heap_redo(XLogReaderState *record);
+@@ -490,6 +510,9 @@ extern void heap_mask(char *pagedata, BlockNumber blkno);
+ extern void heap2_redo(XLogReaderState *record);
+ extern void heap2_desc(StringInfo buf, XLogReaderState *record);
+ extern const char *heap2_identify(uint8 info);
++extern void heap3_redo(XLogReaderState *record);
++extern void heap3_desc(StringInfo buf, XLogReaderState *record);
++extern const char *heap3_identify(uint8 info);
+ extern void heap_xlog_logical_rewrite(XLogReaderState *r);
+
+ extern XLogRecPtr log_heap_visible(Relation rel, Buffer heap_buffer,
+diff --git a/src/include/access/heaptoast.h b/src/include/access/heaptoast.h
+index c376dff48d7..d605a7149b7 100644
+--- a/src/include/access/heaptoast.h
++++ b/src/include/access/heaptoast.h
+@@ -20,10 +20,19 @@
+ /*
+ * Find the maximum size of a tuple if there are to be N tuples per page.
+ */
++#if MAXIMUM_ALIGNOF == 8
+ #define MaximumBytesPerTuple(tuplesPerPage) \
+ MAXALIGN_DOWN((BLCKSZ - \
+- MAXALIGN(SizeOfPageHeaderData + (tuplesPerPage) * sizeof(ItemIdData))) \
++ MAXALIGN(SizeOfPageHeaderData + (tuplesPerPage) * sizeof(ItemIdData)) - MAXALIGN(sizeof(HeapPageSpecialData))) \
+ / (tuplesPerPage))
++#elif MAXIMUM_ALIGNOF == 4
++#define MaximumBytesPerTuple(tuplesPerPage) \
++ MAXALIGN_DOWN((BLCKSZ - \
++ MAXALIGN(SizeOfPageHeaderData + (tuplesPerPage) * sizeof(ItemIdData)) - MAXALIGN(sizeof(ToastPageSpecialData))) \
++ / (tuplesPerPage))
++#else
++#error "unknown arch bitness"
++#endif
+
+ /*
+ * These symbols control toaster activation. If a tuple is larger than
+diff --git a/src/include/access/htup.h b/src/include/access/htup.h
+index 116cb1bb273..e52e98ddbd0 100644
+--- a/src/include/access/htup.h
++++ b/src/include/access/htup.h
+@@ -54,6 +54,12 @@ typedef MinimalTupleData *MinimalTuple;
+ * this can't be told apart from case #1 by inspection; code setting up
+ * or destroying this representation has to know what it's doing.
+ *
++ * t_xmin and t_xmax are TransactionId values stored in heap tuple header.
++ * Normally they are calculated from ShortTransactionId-sized on-disk tuple
++ * xmin/xmax representation:
++ * t_data->t_choice.t_heap.t_xmin/t_data->t_choice.t_heap.t_xmin
++ * and pd_xid_base and pd_multi_base commmon values for all tuples on a page.
++ *
+ * t_len should always be valid, except in the pointer-to-nothing case.
+ * t_self and t_tableOid should be valid if the HeapTupleData points to
+ * a disk buffer, or if it represents a copy of a tuple on disk. They
+@@ -61,10 +67,12 @@ typedef MinimalTupleData *MinimalTuple;
+ */
+ typedef struct HeapTupleData
+ {
++ TransactionId t_xmin; /* calculated tuple xmin */
++ TransactionId t_xmax; /* calculated tuple xmax */
+ uint32 t_len; /* length of *t_data */
+ ItemPointerData t_self; /* SelfItemPointer */
+ Oid t_tableOid; /* table the tuple came from */
+-#define FIELDNO_HEAPTUPLEDATA_DATA 3
++#define FIELDNO_HEAPTUPLEDATA_DATA 5
+ HeapTupleHeader t_data; /* -> tuple header and data */
+ } HeapTupleData;
+
+@@ -78,12 +86,11 @@ typedef HeapTupleData *HeapTuple;
+ #define HeapTupleIsValid(tuple) PointerIsValid(tuple)
+
+ /* HeapTupleHeader functions implemented in utils/time/combocid.c */
+-extern CommandId HeapTupleHeaderGetCmin(HeapTupleHeader tup);
+-extern CommandId HeapTupleHeaderGetCmax(HeapTupleHeader tup);
+-extern void HeapTupleHeaderAdjustCmax(HeapTupleHeader tup,
+- CommandId *cmax, bool *iscombo);
++extern CommandId HeapTupleGetCmin(HeapTuple tup);
++extern CommandId HeapTupleGetCmax(HeapTuple tup);
++extern void HeapTupleAdjustCmax(HeapTuple tup, CommandId *cmax, bool *iscombo);
+
+ /* Prototype for HeapTupleHeader accessors in heapam.c */
+-extern TransactionId HeapTupleGetUpdateXid(HeapTupleHeader tuple);
++extern TransactionId HeapTupleGetUpdateXid(HeapTuple tuple);
+
+ #endif /* HTUP_H */
+diff --git a/src/include/access/htup_details.h b/src/include/access/htup_details.h
+index 5e38ef86969..426b1f479a6 100644
+--- a/src/include/access/htup_details.h
++++ b/src/include/access/htup_details.h
+@@ -19,6 +19,7 @@
+ #include "access/tupdesc.h"
+ #include "access/tupmacs.h"
+ #include "storage/bufpage.h"
++#include "storage/bufmgr.h"
+ #include "varatt.h"
+
+ /*
+@@ -121,13 +122,13 @@
+
+ typedef struct HeapTupleFields
+ {
+- TransactionId t_xmin; /* inserting xact ID */
+- TransactionId t_xmax; /* deleting or locking xact ID */
++ ShortTransactionId t_xmin; /* inserting xact ID */
++ ShortTransactionId t_xmax; /* deleting or locking xact ID */
+
+ union
+ {
+ CommandId t_cid; /* inserting or deleting command ID, or both */
+- TransactionId t_xvac; /* old-style VACUUM FULL xact ID */
++ ShortTransactionId t_xvac; /* old-style VACUUM FULL xact ID */
+ } t_field3;
+ } HeapTupleFields;
+
+@@ -223,7 +224,7 @@ struct HeapTupleHeaderData
+ * HEAP_XMAX_LOCK_ONLY bit is set; or, for pg_upgrade's sake, if the Xmax is
+ * not a multi and the EXCL_LOCK bit is set.
+ *
+- * See also HeapTupleHeaderIsOnlyLocked, which also checks for a possible
++ * See also HeapTupleIsOnlyLocked, which also checks for a possible
+ * aborted updater transaction.
+ *
+ * Beware of multiple evaluations of the argument.
+@@ -299,29 +300,81 @@ struct HeapTupleHeaderData
+ */
+
+ /*
+- * HeapTupleHeaderGetRawXmin returns the "raw" xmin field, which is the xid
++ * HeapTupleGetRawXmin returns the "raw" xmin field, which is the xid
+ * originally used to insert the tuple. However, the tuple might actually
+- * be frozen (via HeapTupleHeaderSetXminFrozen) in which case the tuple's xmin
++ * be frozen (via HeapTupleHeaderStoreXminFrozen) in which case the tuple's xmin
+ * is visible to every snapshot. Prior to PostgreSQL 9.4, we actually changed
+ * the xmin to FrozenTransactionId, and that value may still be encountered
+ * on disk.
+ */
+-#define HeapTupleHeaderGetRawXmin(tup) \
++#define HeapTupleGetRawXmin(tup) \
+ ( \
+- (tup)->t_choice.t_heap.t_xmin \
++ ((tup)->t_xmin) \
+ )
+
+-#define HeapTupleHeaderGetXmin(tup) \
++#define HeapTupleGetXmin(tup) \
+ ( \
+- HeapTupleHeaderXminFrozen(tup) ? \
+- FrozenTransactionId : HeapTupleHeaderGetRawXmin(tup) \
++ HeapTupleHeaderXminFrozen((tup)->t_data) ? \
++ FrozenTransactionId : HeapTupleGetRawXmin(tup) \
+ )
+
+-#define HeapTupleHeaderSetXmin(tup, xid) \
++#define HeapTupleSetXmin(tup, xid) \
+ ( \
+- (tup)->t_choice.t_heap.t_xmin = (xid) \
++ ((tup)->t_xmin = (xid)) \
+ )
+
++/*
++ * Functions for accessing "double xmax". On pg_upgraded instances, it might
++ * happend that we can't fit new special area to the page. But we still
++ * might neep to write xmax of tuples for updates and deletes. The trick is
++ * that we actually don't need xmin field. After pg_upgrade (wich implies
++ * restart) no insertions went to this page yet (otherwise special area could
++ * fit). So, if tuple is visible (othewise it would be deleted), then it's
++ * visible for everybody. Thus, t_xmin isn't needed. Therefore, we can use
++ * both t_xmin and t_xmax to store 64-bit xmax.
++ *
++ * See heap_convert.c for details.
++ */
++static inline TransactionId
++HeapTupleHeaderGetDoubleXmax(HeapTupleHeader htup)
++{
++ TransactionId xmax;
++
++ xmax = htup->t_choice.t_heap.t_xmin;
++ xmax <<= 32;
++ xmax += htup->t_choice.t_heap.t_xmax;
++
++ return xmax;
++}
++
++static inline void
++HeapTupleHeaderSetDoubleXmax(HeapTupleHeader htup, TransactionId xid)
++{
++ htup->t_choice.t_heap.t_xmax = xid & 0xFFFFFFFF;
++ htup->t_choice.t_heap.t_xmin = (xid >> 32) & 0xFFFFFFFF;
++}
++
++static inline void
++HeapTupleHeaderStoreXmin(Page page, HeapTuple htup, bool is_toast)
++{
++ TransactionId base;
++
++ Assert(!HeapPageIsDoubleXmax(page));
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial((page))->pd_xid_base;
++ htup->t_data->t_choice.t_heap.t_xmin =
++ NormalTransactionIdToShort(base, htup->t_xmin);
++}
++
++static inline void
++HeapTupleAndHeaderSetXmin(Page page, HeapTuple tup, TransactionId xid,
++ bool is_toast)
++{
++ HeapTupleSetXmin(tup, xid);
++ HeapTupleHeaderStoreXmin(page, tup, is_toast);
++}
++
+ #define HeapTupleHeaderXminCommitted(tup) \
+ ( \
+ ((tup)->t_infomask & HEAP_XMIN_COMMITTED) != 0 \
+@@ -338,6 +391,12 @@ struct HeapTupleHeaderData
+ ((tup)->t_infomask & (HEAP_XMIN_FROZEN)) == HEAP_XMIN_FROZEN \
+ )
+
++#define HeapTupleHeaderStoreXminFrozen(tup) \
++( \
++ AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
++ ((tup)->t_infomask |= HEAP_XMIN_FROZEN) \
++)
++
+ #define HeapTupleHeaderSetXminCommitted(tup) \
+ ( \
+ AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
+@@ -363,30 +422,80 @@ struct HeapTupleHeaderData
+ * to resolve the MultiXactId if necessary. This might involve multixact I/O,
+ * so it should only be used if absolutely necessary.
+ */
+-#define HeapTupleHeaderGetUpdateXid(tup) \
++#define HeapTupleGetUpdateXidAny(tup) \
+ ( \
+- (!((tup)->t_infomask & HEAP_XMAX_INVALID) && \
+- ((tup)->t_infomask & HEAP_XMAX_IS_MULTI) && \
+- !((tup)->t_infomask & HEAP_XMAX_LOCK_ONLY)) ? \
++ (!((tup)->t_data->t_infomask & HEAP_XMAX_INVALID) && \
++ ((tup)->t_data->t_infomask & HEAP_XMAX_IS_MULTI) && \
++ !((tup)->t_data->t_infomask & HEAP_XMAX_LOCK_ONLY)) ? \
+ HeapTupleGetUpdateXid(tup) \
+ : \
+- HeapTupleHeaderGetRawXmax(tup) \
++ HeapTupleGetRawXmax(tup) \
+ )
+
+-#define HeapTupleHeaderGetRawXmax(tup) \
+-( \
+- (tup)->t_choice.t_heap.t_xmax \
+-)
++static inline TransactionId
++HeapTupleHeaderGetRawXmax(Page page, HeapTupleHeader htup)
++{
++ TransactionId base;
+
+-#define HeapTupleHeaderSetXmax(tup, xid) \
++ if (HeapPageIsDoubleXmax(page))
++ return HeapTupleHeaderGetDoubleXmax(htup);
++
++ base = (htup->t_infomask & HEAP_XMAX_IS_MULTI) ?
++ HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++ return ShortTransactionIdToNormal(base,
++ htup->t_choice.t_heap.t_xmax);
++}
++
++#define HeapTupleGetRawXmax(tup) \
+ ( \
+- (tup)->t_choice.t_heap.t_xmax = (xid) \
++ ((tup)->t_xmax) \
+ )
+
++#define HeapTupleSetXmax(tup, xid) \
++do { \
++ (tup)->t_xmax = (xid); \
++} while (0)
++
++/*
++ * Set xid as xmax for HeapTupleHeader.
++ */
++static inline void
++HeapTupleHeaderStoreXmax(Page page, HeapTuple htup, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ HeapTupleHeaderSetDoubleXmax(htup->t_data, htup->t_xmax);
++ return;
++ }
++
++ if (is_toast)
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ else
++ base = (htup->t_data->t_infomask & HEAP_XMAX_IS_MULTI) != 0 ?
++ HeapPageGetSpecial(page)->pd_multi_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++ htup->t_data->t_choice.t_heap.t_xmax =
++ NormalTransactionIdToShort(base, htup->t_xmax);
++}
++
++/*
++ * Set xid as xmax for HeadTuple and HeapTupleHeader.
++ */
++static inline void
++HeapTupleAndHeaderSetXmax(Page page, HeapTuple htup, TransactionId xid,
++ bool is_toast)
++{
++ HeapTupleSetXmax(htup, xid);
++ HeapTupleHeaderStoreXmax(page, htup, is_toast);
++}
++
+ /*
+ * HeapTupleHeaderGetRawCommandId will give you what's in the header whether
+- * it is useful or not. Most code should use HeapTupleHeaderGetCmin or
+- * HeapTupleHeaderGetCmax instead, but note that those Assert that you can
++ * it is useful or not. Most code should use HeapTupleGetCmin or
++ * HeapTupleGetCmax instead, but note that those Assert that you can
+ * get a legitimate result, ie you are in the originating transaction!
+ */
+ #define HeapTupleHeaderGetRawCommandId(tup) \
+@@ -402,7 +511,7 @@ do { \
+ (tup)->t_infomask &= ~HEAP_COMBOCID; \
+ } while (0)
+
+-/* SetCmax must be used after HeapTupleHeaderAdjustCmax; see combocid.c */
++/* SetCmax must be used after HeapTupleAdjustCmax; see combocid.c */
+ #define HeapTupleHeaderSetCmax(tup, cid, iscombo) \
+ do { \
+ Assert(!((tup)->t_infomask & HEAP_MOVED)); \
+@@ -559,8 +668,16 @@ StaticAssertDecl(MaxOffsetNumber < SpecTokenOffsetNumber,
+ * an otherwise-empty page can indeed hold a tuple of this size. Because
+ * ItemIds and tuples have different alignment requirements, don't assume that
+ * you can, say, fit 2 tuples of size MaxHeapTupleSize/2 on the same page.
++ *
++ * On shift to 64-bit XIDs MaxHeapTupleSize decreased by sizeof(HeapPageSpecialData).
++ * Extant tuples with length over new MaxHeapTupleSize are inherited on DoubleXmax
++ * pages. They could be read, but can not be updated unless their length decreases
++ * to fit MaxHeapTupleSize. Vacuum full will also copy these double xmax pages
++ * without change.
+ */
+-#define MaxHeapTupleSize (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))
++
++#define MaxHeapTupleSize (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)) - MAXALIGN(sizeof(HeapPageSpecialData)))
++#define MaxHeapTupleSize_32 (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))
+ #define MinHeapTupleSize MAXALIGN(SizeofHeapTupleHeader)
+
+ /*
+@@ -694,6 +811,139 @@ struct MinimalTupleData
+ #define HeapTupleClearHeapOnly(tuple) \
+ HeapTupleHeaderClearHeapOnly((tuple)->t_data)
+
++/*
++ * Copy base values for xid and multixacts from one heap tuple to heap tuple.
++ * Should be called on tuple copy or making desc tuple on the base on src tuple
++ * saving visibility information.
++ */
++static inline void
++HeapTupleCopyXids(HeapTuple dest, HeapTuple src)
++{
++ dest->t_xmin = src->t_xmin;
++ dest->t_xmax = src->t_xmax;
++}
++
++/*
++ * Set base values for tuple xids/multixacts to zero. Used when visibility
++ * infromation is negligible or will be set later.
++ */
++static inline void
++HeapTupleSetZeroXids(HeapTuple htup)
++{
++ htup->t_xmin = 0;
++ htup->t_xmax = 0;
++}
++
++/*
++ * Copy HeapTupleHeader xmin/xmax in raw way ???
++ */
++static inline void
++HeapTupleCopyHeaderXids(HeapTuple htup) \
++{
++ htup->t_xmin = htup->t_data->t_choice.t_heap.t_xmin;
++ htup->t_xmax = htup->t_data->t_choice.t_heap.t_xmax;
++}
++
++
++static inline void
++HeapTupleCopyRawXminFromPage(HeapTuple tup, Page page, bool is_toast)
++{
++ TransactionId base;
++ ShortTransactionId xmin; /* short xmin from tuple header */
++
++ xmin = tup->t_data->t_choice.t_heap.t_xmin;
++
++ if (!TransactionIdIsNormal(xmin))
++ base = 0;
++ else if (is_toast)
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ else
++ base = HeapPageGetSpecial(page)->pd_xid_base;
++
++ tup->t_xmin = ShortTransactionIdToNormal(base, xmin);
++}
++
++static inline void
++HeapTupleCopyXminFromPage(HeapTuple tup, Page page, bool is_toast)
++{
++ if (HeapTupleHeaderXminFrozen(tup->t_data))
++ {
++ tup->t_xmin = FrozenTransactionId;
++ return;
++ }
++
++ HeapTupleCopyRawXminFromPage(tup, page, is_toast);
++}
++
++static inline void
++HeapTupleCopyXmaxFromPage(HeapTuple tup, Page page, bool is_toast)
++{
++ TransactionId base;
++ ShortTransactionId xmax; /* short xmax from tuple header */
++
++ xmax = tup->t_data->t_choice.t_heap.t_xmax;
++
++ if (!TransactionIdIsNormal(xmax))
++ base = 0;
++ else if (is_toast)
++ /*
++ * Toast page is not expected to have multixacts in chunks and
++ * has shorter special.
++ */
++ base = ToastPageGetSpecial(page)->pd_xid_base;
++ else if (tup->t_data->t_infomask & HEAP_XMAX_IS_MULTI)
++ base = HeapPageGetSpecial(page)->pd_multi_base;
++ else
++ base = HeapPageGetSpecial(page)->pd_xid_base;
++
++ tup->t_xmax = ShortTransactionIdToNormal(base, xmax);
++}
++
++static inline void
++HeapTupleCopyRawXidsFromPage(Buffer buffer, HeapTuple tup, Page page,
++ bool is_toast)
++{
++ Assert(IsBufferLocked(buffer));
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ /*
++ * On double xmax pages, xmax is extracted from tuple header.
++ */
++ tup->t_xmin = FrozenTransactionId;
++ tup->t_xmax = HeapTupleHeaderGetDoubleXmax(tup->t_data);
++ return;
++ }
++
++ HeapTupleCopyRawXminFromPage(tup, page, is_toast);
++ HeapTupleCopyXmaxFromPage(tup, page, is_toast);
++}
++
++/*
++ * Copy base values for xid and multixacts from page to heap tuple. Should be
++ * called each time tuple is read from page. Otherwise, it would be impossible
++ * to correctly read tuple xmin and xmax.
++ */
++static inline void
++HeapTupleCopyXidsFromPage(Buffer buffer, HeapTuple tup, Page page,
++ bool is_toast)
++{
++ Assert(IsBufferLocked(buffer));
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ /*
++ * On double xmax pages, xmax is extracted from tuple header.
++ */
++ tup->t_xmin = FrozenTransactionId;
++ tup->t_xmax = HeapTupleHeaderGetDoubleXmax(tup->t_data);
++ return;
++ }
++
++ HeapTupleCopyXminFromPage(tup, page, is_toast);
++ HeapTupleCopyXmaxFromPage(tup, page, is_toast);
++}
++
+ /* prototypes for functions in common/heaptuple.c */
+ extern Size heap_compute_data_size(TupleDesc tupleDesc,
+ const Datum *values, const bool *isnull);
+diff --git a/src/include/access/multixact.h b/src/include/access/multixact.h
+index 5aefbddce3e..02922faf77f 100644
+--- a/src/include/access/multixact.h
++++ b/src/include/access/multixact.h
+@@ -18,12 +18,12 @@
+
+ /*
+ * The first two MultiXactId values are reserved to store the truncation Xid
+- * and epoch of the first segment, so we start assigning multixact values from
++ * and base of the first segment, so we start assigning multixact values from
+ * 2.
+ */
+-#define InvalidMultiXactId ((MultiXactId) 0)
+-#define FirstMultiXactId ((MultiXactId) 1)
+-#define MaxMultiXactId ((MultiXactId) 0xFFFFFFFF)
++#define InvalidMultiXactId UINT64CONST(0)
++#define FirstMultiXactId UINT64CONST(1)
++#define MaxMultiXactId UINT64CONST(0xFFFFFFFFFFFFFFFF)
+
+ #define MultiXactIdIsValid(multi) ((multi) != InvalidMultiXactId)
+
+diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
+index 123fba624db..0c4df130b01 100644
+--- a/src/include/access/nbtree.h
++++ b/src/include/access/nbtree.h
+@@ -62,8 +62,10 @@ typedef uint16 BTCycleId;
+ typedef struct BTPageOpaqueData
+ {
+ BlockNumber btpo_prev; /* left sibling, or P_NONE if leftmost */
++ /* ... or next transaction ID (lower part) */
+ BlockNumber btpo_next; /* right sibling, or P_NONE if rightmost */
+ uint32 btpo_level; /* tree level --- zero for leaf pages */
++ /* ... or next transaction ID (lower part) */
+ uint16 btpo_flags; /* flag bits, see below */
+ BTCycleId btpo_cycleid; /* vacuum cycle ID of latest split */
+ } BTPageOpaqueData;
+@@ -92,6 +94,14 @@ typedef BTPageOpaqueData *BTPageOpaque;
+ */
+ #define MAX_BT_CYCLE_ID 0xFF7F
+
++/* Macros for access xact */
++#define BTP_GET_XACT(opaque) (((uint64) ((BTPageOpaque) opaque)->btpo_prev << 32) | \
++ (uint64) ((BTPageOpaque) opaque)->btpo_level)
++#define BTP_SET_XACT(opaque, xact) \
++do { \
++ ((BTPageOpaque) opaque)->btpo_prev = (uint32) (xact >> 32); \
++ ((BTPageOpaque) opaque)->btpo_level = (uint32) xact; \
++} while (0)
+
+ /*
+ * The Meta page is always the first page in the btree index.
+diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h
+index 309c82ebf4d..bd709d26e8a 100644
+--- a/src/include/access/reloptions.h
++++ b/src/include/access/reloptions.h
+@@ -110,7 +110,7 @@ typedef struct relopt_int64
+ int64 default_val;
+ int64 min;
+ int64 max;
+-} relopt_int64;
++} relopt_int64;
+
+ typedef struct relopt_real
+ {
+diff --git a/src/include/access/rewriteheap.h b/src/include/access/rewriteheap.h
+index 5866a26bddd..e1dba997c2a 100644
+--- a/src/include/access/rewriteheap.h
++++ b/src/include/access/rewriteheap.h
+@@ -51,7 +51,7 @@ typedef struct LogicalRewriteMappingData
+ * 6) xid of the xact performing the mapping
+ * ---
+ */
+-#define LOGICAL_REWRITE_FORMAT "map-%x-%x-%X_%X-%x-%x"
+-extern void CheckPointLogicalRewriteHeap(void);
++#define LOGICAL_REWRITE_FORMAT "map-%x-%x-%X_%X-%x_%x-%x_%x"
++extern void CheckPointLogicalRewriteHeap(void);
+
+ #endif /* REWRITE_HEAP_H */
+diff --git a/src/include/access/rmgrlist.h b/src/include/access/rmgrlist.h
+index 78e6b908c6e..a368d384ffd 100644
+--- a/src/include/access/rmgrlist.h
++++ b/src/include/access/rmgrlist.h
+@@ -47,3 +47,4 @@ PG_RMGR(RM_COMMIT_TS_ID, "CommitTs", commit_ts_redo, commit_ts_desc, commit_ts_i
+ PG_RMGR(RM_REPLORIGIN_ID, "ReplicationOrigin", replorigin_redo, replorigin_desc, replorigin_identify, NULL, NULL, NULL, NULL)
+ PG_RMGR(RM_GENERIC_ID, "Generic", generic_redo, generic_desc, generic_identify, NULL, NULL, generic_mask, NULL)
+ PG_RMGR(RM_LOGICALMSG_ID, "LogicalMessage", logicalmsg_redo, logicalmsg_desc, logicalmsg_identify, NULL, NULL, NULL, logicalmsg_decode)
++PG_RMGR(RM_HEAP3_ID, "Heap3", heap3_redo, heap3_desc, heap3_identify, NULL, NULL, heap_mask, NULL)
+diff --git a/src/include/access/slru.h b/src/include/access/slru.h
+index 97e612cd100..c987e9e59a8 100644
+--- a/src/include/access/slru.h
++++ b/src/include/access/slru.h
+@@ -26,15 +26,7 @@
+ /*
+ * Define SLRU segment size. A page is the same BLCKSZ as is used everywhere
+ * else in Postgres. The segment size can be chosen somewhat arbitrarily;
+- * we make it 32 pages by default, or 256Kb, i.e. 1M transactions for CLOG
+- * or 64K transactions for SUBTRANS.
+- *
+- * Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF,
+- * page numbering also wraps around at 0xFFFFFFFF/xxxx_XACTS_PER_PAGE (where
+- * xxxx is CLOG or SUBTRANS, respectively), and segment numbering at
+- * 0xFFFFFFFF/xxxx_XACTS_PER_PAGE/SLRU_PAGES_PER_SEGMENT. We need
+- * take no explicit notice of that fact in slru.c, except when comparing
+- * segment and page numbers in SimpleLruTruncate (see PagePrecedes()).
++ * we make it 32 pages by default.
+ */
+ #define SLRU_PAGES_PER_SEGMENT 32
+
+diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
+index adb478a93ca..c31092e2fd0 100644
+--- a/src/include/access/tableam.h
++++ b/src/include/access/tableam.h
+@@ -141,7 +141,7 @@ typedef enum TU_UpdateIndexes
+ * cmax is the outdating command's CID, but only when the failure code is
+ * TM_SelfModified (i.e., something in the current transaction outdated the
+ * tuple); otherwise cmax is zero. (We make this restriction because
+- * HeapTupleHeaderGetCmax doesn't work for tuples outdated in other
++ * HeapTupleGetCmax doesn't work for tuples outdated in other
+ * transactions.)
+ */
+ typedef struct TM_FailureData
+diff --git a/src/include/access/transam.h b/src/include/access/transam.h
+index 28a2d287fd5..53d4a907365 100644
+--- a/src/include/access/transam.h
++++ b/src/include/access/transam.h
+@@ -17,6 +17,10 @@
+ #include "access/xlogdefs.h"
+
+
++#ifndef FRONTEND
++#include "utils/elog.h"
++#endif
++
+ /* ----------------
+ * Special transaction ID values
+ *
+@@ -28,11 +32,12 @@
+ * Note: if you need to change it, you must change pg_class.h as well.
+ * ----------------
+ */
+-#define InvalidTransactionId ((TransactionId) 0)
+-#define BootstrapTransactionId ((TransactionId) 1)
+-#define FrozenTransactionId ((TransactionId) 2)
+-#define FirstNormalTransactionId ((TransactionId) 3)
+-#define MaxTransactionId ((TransactionId) 0xFFFFFFFF)
++#define InvalidTransactionId UINT64CONST(0)
++#define BootstrapTransactionId UINT64CONST(1)
++#define FrozenTransactionId UINT64CONST(2)
++#define FirstNormalTransactionId UINT64CONST(3)
++#define MaxTransactionId UINT64CONST(0xFFFFFFFFFFFFFFFF)
++#define MaxShortTransactionId ((TransactionId) 0x7FFFFFFF)
+
+ /* ----------------
+ * transaction ID manipulation macros
+@@ -44,8 +49,40 @@
+ #define TransactionIdStore(xid, dest) (*(dest) = (xid))
+ #define StoreInvalidTransactionId(dest) (*(dest) = InvalidTransactionId)
+
+-#define EpochFromFullTransactionId(x) ((uint32) ((x).value >> 32))
+-#define XidFromFullTransactionId(x) ((uint32) (x).value)
++/*
++ * Convert short xid from/to full xid. Assertion should fail if we full xid
++ * doesn't fit to xid base.
++ */
++static inline TransactionId
++ShortTransactionIdToNormal(TransactionId base, ShortTransactionId xid)
++{
++ if (!TransactionIdIsNormal(xid))
++ return (TransactionId) xid;
++
++#ifndef FRONTEND
++ /* xid + base should not overflow TransactionId */
++ Assert(xid + base >= base);
++#endif
++
++ return (TransactionId) (xid + base);
++}
++
++static inline ShortTransactionId
++NormalTransactionIdToShort(TransactionId base, TransactionId xid)
++{
++ if (!TransactionIdIsNormal(xid))
++ return (ShortTransactionId) (xid);
++
++#ifndef FRONTEND
++ /* xid should fit ShortTransactionId */
++ Assert(xid >= base + FirstNormalTransactionId &&
++ xid <= base + MaxShortTransactionId);
++#endif
++
++ return (ShortTransactionId) (xid - base);
++}
++
++#define XidFromFullTransactionId(x) ((x).value)
+ #define U64FromFullTransactionId(x) ((x).value)
+ #define FullTransactionIdEquals(a, b) ((a).value == (b).value)
+ #define FullTransactionIdPrecedes(a, b) ((a).value < (b).value)
+@@ -53,8 +90,8 @@
+ #define FullTransactionIdFollows(a, b) ((a).value > (b).value)
+ #define FullTransactionIdFollowsOrEquals(a, b) ((a).value >= (b).value)
+ #define FullTransactionIdIsValid(x) TransactionIdIsValid(XidFromFullTransactionId(x))
+-#define InvalidFullTransactionId FullTransactionIdFromEpochAndXid(0, InvalidTransactionId)
+-#define FirstNormalFullTransactionId FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId)
++#define InvalidFullTransactionId FullTransactionIdFromXid(InvalidTransactionId)
++#define FirstNormalFullTransactionId FullTransactionIdFromXid(FirstNormalTransactionId)
+ #define FullTransactionIdIsNormal(x) FullTransactionIdFollowsOrEquals(x, FirstNormalFullTransactionId)
+
+ /*
+@@ -68,21 +105,11 @@ typedef struct FullTransactionId
+ } FullTransactionId;
+
+ static inline FullTransactionId
+-FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)
++FullTransactionIdFromXid(TransactionId xid)
+ {
+ FullTransactionId result;
+
+- result.value = ((uint64) epoch) << 32 | xid;
+-
+- return result;
+-}
+-
+-static inline FullTransactionId
+-FullTransactionIdFromU64(uint64 value)
+-{
+- FullTransactionId result;
+-
+- result.value = value;
++ result.value = xid;
+
+ return result;
+ }
+@@ -91,8 +118,7 @@ FullTransactionIdFromU64(uint64 value)
+ #define TransactionIdAdvance(dest) \
+ do { \
+ (dest)++; \
+- if ((dest) < FirstNormalTransactionId) \
+- (dest) = FirstNormalTransactionId; \
++ Assert(TransactionIdIsNormal(dest)); \
+ } while(0)
+
+ /*
+@@ -140,18 +166,19 @@ FullTransactionIdAdvance(FullTransactionId *dest)
+ /* back up a transaction ID variable, handling wraparound correctly */
+ #define TransactionIdRetreat(dest) \
+ do { \
++ Assert(TransactionIdIsNormal(dest)); \
+ (dest)--; \
+- } while ((dest) < FirstNormalTransactionId)
++ } while(0)
+
+ /* compare two XIDs already known to be normal; this is a macro for speed */
+ #define NormalTransactionIdPrecedes(id1, id2) \
+ (AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
+- (int32) ((id1) - (id2)) < 0)
++ (int64) ((id1) - (id2)) < 0)
+
+ /* compare two XIDs already known to be normal; this is a macro for speed */
+ #define NormalTransactionIdFollows(id1, id2) \
+ (AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
+- (int32) ((id1) - (id2)) > 0)
++ (int64) ((id1) - (id2)) > 0)
+
+ /* ----------
+ * Object ID (OID) zero is InvalidOid.
+@@ -201,10 +228,6 @@ FullTransactionIdAdvance(FullTransactionId *dest)
+ * OID and XID assignment state. For largely historical reasons, there is
+ * just one struct with different fields that are protected by different
+ * LWLocks.
+- *
+- * Note: xidWrapLimit and oldestXidDB are not "active" values, but are
+- * used just to generate useful messages when xidWarnLimit or xidStopLimit
+- * are exceeded.
+ */
+ typedef struct TransamVariablesData
+ {
+@@ -221,9 +244,6 @@ typedef struct TransamVariablesData
+
+ TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
+ TransactionId xidVacLimit; /* start forcing autovacuums here */
+- TransactionId xidWarnLimit; /* start complaining here */
+- TransactionId xidStopLimit; /* refuse to advance nextXid beyond here */
+- TransactionId xidWrapLimit; /* where the world ends */
+ Oid oldestXidDB; /* database with minimum datfrozenxid */
+
+ /*
+@@ -274,10 +294,6 @@ extern bool TransactionIdDidAbort(TransactionId transactionId);
+ extern void TransactionIdCommitTree(TransactionId xid, int nxids, TransactionId *xids);
+ extern void TransactionIdAsyncCommitTree(TransactionId xid, int nxids, TransactionId *xids, XLogRecPtr lsn);
+ extern void TransactionIdAbortTree(TransactionId xid, int nxids, TransactionId *xids);
+-extern bool TransactionIdPrecedes(TransactionId id1, TransactionId id2);
+-extern bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2);
+-extern bool TransactionIdFollows(TransactionId id1, TransactionId id2);
+-extern bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2);
+ extern TransactionId TransactionIdLatest(TransactionId mainxid,
+ int nxids, const TransactionId *xids);
+ extern XLogRecPtr TransactionIdGetCommitLSN(TransactionId xid);
+@@ -319,7 +335,7 @@ ReadNextTransactionId(void)
+
+ /* return transaction ID backed up by amount, handling wraparound correctly */
+ static inline TransactionId
+-TransactionIdRetreatedBy(TransactionId xid, uint32 amount)
++TransactionIdRetreatedBy(TransactionId xid, uint64 amount)
+ {
+ xid -= amount;
+
+diff --git a/src/include/access/tupmacs.h b/src/include/access/tupmacs.h
+index 58b3a58cfd0..a2af9d5e855 100644
+--- a/src/include/access/tupmacs.h
++++ b/src/include/access/tupmacs.h
+@@ -131,10 +131,11 @@ fetch_att(const void *T, bool attbyval, int attlen)
+ ((attalign) == TYPALIGN_INT) ? INTALIGN(cur_offset) : \
+ (((attalign) == TYPALIGN_CHAR) ? (uintptr_t) (cur_offset) : \
+ (((attalign) == TYPALIGN_DOUBLE) ? DOUBLEALIGN(cur_offset) : \
++ (((attalign) == TYPALIGN_XID) ? MAXALIGN(cur_offset) : \
+ ( \
+ AssertMacro((attalign) == TYPALIGN_SHORT), \
+ SHORTALIGN(cur_offset) \
+- ))) \
++ )))) \
+ )
+
+ /*
+diff --git a/src/include/access/xact.h b/src/include/access/xact.h
+index fb64d7413a2..fa93b167ae7 100644
+--- a/src/include/access/xact.h
++++ b/src/include/access/xact.h
+@@ -249,7 +249,7 @@ typedef struct xl_xact_xinfo
+ * Commit records can be large, so copying large portions isn't
+ * attractive.
+ */
+- uint32 xinfo;
++ uint64 xinfo;
+ } xl_xact_xinfo;
+
+ typedef struct xl_xact_dbinfo
+@@ -308,7 +308,12 @@ typedef struct xl_xact_invals
+
+ typedef struct xl_xact_twophase
+ {
+- TransactionId xid;
++ /*
++ * TransactionId is split into 32-bit parts because xl_xact_twophase is
++ * only int-aligned.
++ */
++ uint32 xid_lo;
++ uint32 xid_hi;
+ } xl_xact_twophase;
+
+ typedef struct xl_xact_origin
+@@ -327,7 +332,7 @@ typedef struct xl_xact_commit
+ /* xl_xact_relfilelocators follows if XINFO_HAS_RELFILELOCATORS */
+ /* xl_xact_stats_items follows if XINFO_HAS_DROPPED_STATS */
+ /* xl_xact_invals follows if XINFO_HAS_INVALS */
+- /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE */
++ /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE (xid is int-aligned!) */
+ /* twophase_gid follows if XINFO_HAS_GID. As a null-terminated string. */
+ /* xl_xact_origin follows if XINFO_HAS_ORIGIN, stored unaligned! */
+ } xl_xact_commit;
+@@ -343,7 +348,7 @@ typedef struct xl_xact_abort
+ /* xl_xact_relfilelocators follows if XINFO_HAS_RELFILELOCATORS */
+ /* xl_xact_stats_items follows if XINFO_HAS_DROPPED_STATS */
+ /* No invalidation messages needed. */
+- /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE */
++ /* xl_xact_twophase follows if XINFO_HAS_TWOPHASE (xid is int-aligned!) */
+ /* twophase_gid follows if XINFO_HAS_GID. As a null-terminated string. */
+ /* xl_xact_origin follows if XINFO_HAS_ORIGIN, stored unaligned! */
+ } xl_xact_abort;
+diff --git a/src/include/access/xloginsert.h b/src/include/access/xloginsert.h
+index 652f7bc9bd1..51356879fed 100644
+--- a/src/include/access/xloginsert.h
++++ b/src/include/access/xloginsert.h
+@@ -38,6 +38,7 @@
+ #define REGBUF_KEEP_DATA 0x10 /* include data even if a full-page image
+ * is taken */
+ #define REGBUF_NO_CHANGE 0x20 /* intentionally register clean buffer */
++#define REGBUF_CONVERTED 0x40 /* buffer had format convertion */
+
+ /* prototypes for public functions in xloginsert.c: */
+ extern void XLogBeginInsert(void);
+diff --git a/src/include/access/xlogreader.h b/src/include/access/xlogreader.h
+index b4fa1ef7b5a..81cd5f33ea0 100644
+--- a/src/include/access/xlogreader.h
++++ b/src/include/access/xlogreader.h
+@@ -427,10 +427,6 @@ extern bool DecodeXLogRecord(XLogReaderState *state,
+ #define XLogRecHasBlockData(decoder, block_id) \
+ ((decoder)->record->blocks[block_id].has_data)
+
+-#ifndef FRONTEND
+-extern FullTransactionId XLogRecGetFullXid(XLogReaderState *record);
+-#endif
+-
+ extern bool RestoreBlockImage(XLogReaderState *record, uint8 block_id, char *page);
+ extern char *XLogRecGetBlockData(XLogReaderState *record, uint8 block_id, Size *len);
+ extern void XLogRecGetBlockTag(XLogReaderState *record, uint8 block_id,
+diff --git a/src/include/access/xlogrecord.h b/src/include/access/xlogrecord.h
+index b9e5c59fae3..3a74c9085ae 100644
+--- a/src/include/access/xlogrecord.h
++++ b/src/include/access/xlogrecord.h
+@@ -41,18 +41,17 @@
+ typedef struct XLogRecord
+ {
+ uint32 xl_tot_len; /* total len of entire record */
++ pg_crc32c xl_crc; /* CRC for this record */
+ TransactionId xl_xid; /* xact id */
+ XLogRecPtr xl_prev; /* ptr to previous record in log */
+ uint8 xl_info; /* flag bits, see below */
+ RmgrId xl_rmid; /* resource manager for this record */
+- /* 2 bytes of padding here, initialize to zero */
+- pg_crc32c xl_crc; /* CRC for this record */
+
+ /* XLogRecordBlockHeaders and XLogRecordDataHeader follow, no padding */
+
+ } XLogRecord;
+
+-#define SizeOfXLogRecord (offsetof(XLogRecord, xl_crc) + sizeof(pg_crc32c))
++#define SizeOfXLogRecord (offsetof(XLogRecord, xl_rmid) + sizeof(RmgrId))
+
+ /*
+ * The high 4 bits in xl_info may be used freely by rmgr. The
+diff --git a/src/include/c.h b/src/include/c.h
+index b5b6b9261b0..93047be2852 100644
+--- a/src/include/c.h
++++ b/src/include/c.h
+@@ -603,20 +603,30 @@ typedef double float8;
+ typedef Oid regproc;
+ typedef regproc RegProcedure;
+
+-typedef uint32 TransactionId;
++typedef uint64 TransactionId;
+
+-typedef uint32 LocalTransactionId;
++extern bool TransactionIdPrecedes(TransactionId id1, TransactionId id2);
++extern bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2);
++extern bool TransactionIdFollows(TransactionId id1, TransactionId id2);
++extern bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2);
+
+-typedef uint32 SubTransactionId;
++typedef uint32 ShortTransactionId;
++typedef uint64 LocalTransactionId;
++typedef uint64 SubTransactionId;
+
+-#define InvalidSubTransactionId ((SubTransactionId) 0)
+-#define TopSubTransactionId ((SubTransactionId) 1)
++#define InvalidSubTransactionId ((SubTransactionId) 0)
++#define TopSubTransactionId ((SubTransactionId) 1)
+
+ /* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
+ typedef TransactionId MultiXactId;
+
+ typedef uint64 MultiXactOffset;
+
++#define MAX_START_XID UINT64CONST(0x3FFFFFFFFFFFFFFF) /* 2^62 - 1 */
++#define StartTransactionIdIsValid(xid) ((xid) <= MAX_START_XID)
++#define StartMultiXactIdIsValid(mxid) ((mxid) <= MAX_START_XID)
++#define StartMultiXactOffsetIsValid(mxoff) ((mxoff) <= MAX_START_XID)
++
+ typedef uint32 CommandId;
+
+ #define FirstCommandId ((CommandId) 0)
+@@ -789,7 +799,6 @@ typedef NameData *Name;
+ /* we don't currently need wider versions of the other ALIGN macros */
+ #define MAXALIGN64(LEN) TYPEALIGN64(MAXIMUM_ALIGNOF, (LEN))
+
+-
+ /* ----------------------------------------------------------------
+ * Section 6: assertions
+ * ----------------------------------------------------------------
+diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h
+index 3ca5dbf9e83..53b72224292 100644
+--- a/src/include/catalog/catversion.h
++++ b/src/include/catalog/catversion.h
+@@ -57,6 +57,7 @@
+ */
+
+ /* yyyymmddN */
+-#define CATALOG_VERSION_NO 202412021
++/* XXX: should de changed to actual version on commit */
++#define CATALOG_VERSION_NO 999999999
+
+ #endif
+diff --git a/src/include/catalog/pg_operator.dat b/src/include/catalog/pg_operator.dat
+index 0e7511dde1c..d26405a7b5c 100644
+--- a/src/include/catalog/pg_operator.dat
++++ b/src/include/catalog/pg_operator.dat
+@@ -183,16 +183,16 @@
+ oprresult => 'bool', oprcom => '=(xid,xid)', oprnegate => '<>(xid,xid)',
+ oprcode => 'xideq', oprrest => 'eqsel', oprjoin => 'eqjoinsel' },
+ { oid => '353', descr => 'equal',
+- oprname => '=', oprleft => 'xid', oprright => 'int4', oprresult => 'bool',
+- oprnegate => '<>(xid,int4)', oprcode => 'xideqint4', oprrest => 'eqsel',
++ oprname => '=', oprleft => 'xid', oprright => 'int8', oprresult => 'bool',
++ oprnegate => '<>(xid,int8)', oprcode => 'xideqint8', oprrest => 'eqsel',
+ oprjoin => 'eqjoinsel' },
+ { oid => '3315', descr => 'not equal',
+ oprname => '<>', oprleft => 'xid', oprright => 'xid', oprresult => 'bool',
+ oprcom => '<>(xid,xid)', oprnegate => '=(xid,xid)', oprcode => 'xidneq',
+ oprrest => 'neqsel', oprjoin => 'neqjoinsel' },
+ { oid => '3316', descr => 'not equal',
+- oprname => '<>', oprleft => 'xid', oprright => 'int4', oprresult => 'bool',
+- oprnegate => '=(xid,int4)', oprcode => 'xidneqint4', oprrest => 'neqsel',
++ oprname => '<>', oprleft => 'xid', oprright => 'int8', oprresult => 'bool',
++ oprnegate => '=(xid,int8)', oprcode => 'xidneqint8', oprrest => 'neqsel',
+ oprjoin => 'neqjoinsel' },
+ { oid => '5068', descr => 'equal',
+ oprname => '=', oprcanmerge => 't', oprcanhash => 't', oprleft => 'xid8',
+diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
+index 9575524007f..027abc3213b 100644
+--- a/src/include/catalog/pg_proc.dat
++++ b/src/include/catalog/pg_proc.dat
+@@ -2443,10 +2443,10 @@
+ { oid => '1181',
+ descr => 'age of a transaction ID, in transactions before current transaction',
+ proname => 'age', provolatile => 's', proparallel => 'r',
+- prorettype => 'int4', proargtypes => 'xid', prosrc => 'xid_age' },
++ prorettype => 'int8', proargtypes => 'xid', prosrc => 'xid_age' },
+ { oid => '3939',
+ descr => 'age of a multi-transaction ID, in multi-transactions before current multi-transaction',
+- proname => 'mxid_age', provolatile => 's', prorettype => 'int4',
++ proname => 'mxid_age', provolatile => 's', prorettype => 'int8',
+ proargtypes => 'xid', prosrc => 'mxid_age' },
+
+ { oid => '1188',
+@@ -2797,11 +2797,11 @@
+ prosrc => 'bpcharlen' },
+
+ { oid => '1319',
+- proname => 'xideqint4', proleakproof => 't', prorettype => 'bool',
+- proargtypes => 'xid int4', prosrc => 'xideq' },
++ proname => 'xideqint8', proleakproof => 't', prorettype => 'bool',
++ proargtypes => 'xid int8', prosrc => 'xideq' },
+ { oid => '3309',
+- proname => 'xidneqint4', proleakproof => 't', prorettype => 'bool',
+- proargtypes => 'xid int4', prosrc => 'xidneq' },
++ proname => 'xidneqint8', proleakproof => 't', prorettype => 'bool',
++ proargtypes => 'xid int8', prosrc => 'xidneq' },
+
+ { oid => '1326',
+ proname => 'interval_div', prorettype => 'interval',
+diff --git a/src/include/catalog/pg_type.dat b/src/include/catalog/pg_type.dat
+index ceff66ccde1..f8d98c8c85c 100644
+--- a/src/include/catalog/pg_type.dat
++++ b/src/include/catalog/pg_type.dat
+@@ -95,9 +95,9 @@
+ typinput => 'tidin', typoutput => 'tidout', typreceive => 'tidrecv',
+ typsend => 'tidsend', typalign => 's' },
+ { oid => '28', array_type_oid => '1011', descr => 'transaction id',
+- typname => 'xid', typlen => '4', typbyval => 't', typcategory => 'U',
++ typname => 'xid', typlen => '8', typbyval => 'FLOAT8PASSBYVAL', typcategory => 'U',
+ typinput => 'xidin', typoutput => 'xidout', typreceive => 'xidrecv',
+- typsend => 'xidsend', typalign => 'i' },
++ typsend => 'xidsend', typalign => 'x' },
+ { oid => '29', array_type_oid => '1012',
+ descr => 'command identifier type, sequence in transaction id',
+ typname => 'cid', typlen => '4', typbyval => 't', typcategory => 'U',
+diff --git a/src/include/catalog/pg_type.h b/src/include/catalog/pg_type.h
+index e9259697321..edd8f13bd15 100644
+--- a/src/include/catalog/pg_type.h
++++ b/src/include/catalog/pg_type.h
+@@ -303,6 +303,11 @@ MAKE_SYSCACHE(TYPENAMENSP, pg_type_typname_nsp_index, 64);
+ #define TYPALIGN_SHORT 's' /* short alignment (typically 2 bytes) */
+ #define TYPALIGN_INT 'i' /* int alignment (typically 4 bytes) */
+ #define TYPALIGN_DOUBLE 'd' /* double alignment (often 8 bytes) */
++/*
++ * We need to use alignment sutable for 8-byte XID values.
++ * On system like AIX double alignment (4 bytes) is not enough.
++ */
++#define TYPALIGN_XID 'x'
+
+ #define TYPSTORAGE_PLAIN 'p' /* type not prepared for toasting */
+ #define TYPSTORAGE_EXTERNAL 'e' /* toastable, don't try to compress */
+diff --git a/src/include/commands/vacuum.h b/src/include/commands/vacuum.h
+index 759f9a87d38..a96bdf0cc04 100644
+--- a/src/include/commands/vacuum.h
++++ b/src/include/commands/vacuum.h
+@@ -216,12 +216,12 @@ typedef enum VacOptValue
+ */
+ typedef struct VacuumParams
+ {
+- bits32 options; /* bitmask of VACOPT_* */
+- int freeze_min_age; /* min freeze age, -1 to use default */
+- int freeze_table_age; /* age at which to scan whole table */
+- int multixact_freeze_min_age; /* min multixact freeze age, -1 to
++ bits32 options; /* bitmask of VacuumOption */
++ int64 freeze_min_age; /* min freeze age, -1 to use default */
++ int64 freeze_table_age; /* age at which to scan whole table */
++ int64 multixact_freeze_min_age; /* min multixact freeze age, -1 to
+ * use default */
+- int multixact_freeze_table_age; /* multixact age at which to scan
++ int64 multixact_freeze_table_age; /* multixact age at which to scan
+ * whole table */
+ bool is_wraparound; /* force a for-wraparound vacuum */
+ int log_min_duration; /* minimum execution threshold in ms at
+@@ -290,12 +290,12 @@ typedef struct VacDeadItemsInfo
+
+ /* GUC parameters */
+ extern PGDLLIMPORT int default_statistics_target; /* PGDLLIMPORT for PostGIS */
+-extern PGDLLIMPORT int vacuum_freeze_min_age;
+-extern PGDLLIMPORT int vacuum_freeze_table_age;
+-extern PGDLLIMPORT int vacuum_multixact_freeze_min_age;
+-extern PGDLLIMPORT int vacuum_multixact_freeze_table_age;
+-extern PGDLLIMPORT int vacuum_failsafe_age;
+-extern PGDLLIMPORT int vacuum_multixact_failsafe_age;
++extern PGDLLIMPORT int64 vacuum_freeze_min_age;
++extern PGDLLIMPORT int64 vacuum_freeze_table_age;
++extern PGDLLIMPORT int64 vacuum_multixact_freeze_min_age;
++extern PGDLLIMPORT int64 vacuum_multixact_freeze_table_age;
++extern PGDLLIMPORT int64 vacuum_failsafe_age;
++extern PGDLLIMPORT int64 vacuum_multixact_failsafe_age;
+
+ /*
+ * Maximum value for default_statistics_target and per-column statistics
+diff --git a/src/include/fmgr.h b/src/include/fmgr.h
+index 1e3795de4a8..206d16b36bf 100644
+--- a/src/include/fmgr.h
++++ b/src/include/fmgr.h
+@@ -281,6 +281,7 @@ extern struct varlena *pg_detoast_datum_packed(struct varlena *datum);
+ #define PG_GETARG_FLOAT4(n) DatumGetFloat4(PG_GETARG_DATUM(n))
+ #define PG_GETARG_FLOAT8(n) DatumGetFloat8(PG_GETARG_DATUM(n))
+ #define PG_GETARG_INT64(n) DatumGetInt64(PG_GETARG_DATUM(n))
++#define PG_GETARG_TRANSACTIONID(n) DatumGetTransactionId(PG_GETARG_DATUM(n))
+ /* use this if you want the raw, possibly-toasted input datum: */
+ #define PG_GETARG_RAW_VARLENA_P(n) ((struct varlena *) PG_GETARG_POINTER(n))
+ /* use this if you want the input datum de-toasted: */
+@@ -367,6 +368,7 @@ extern struct varlena *pg_detoast_datum_packed(struct varlena *datum);
+ #define PG_RETURN_FLOAT8(x) return Float8GetDatum(x)
+ #define PG_RETURN_INT64(x) return Int64GetDatum(x)
+ #define PG_RETURN_UINT64(x) return UInt64GetDatum(x)
++#define PG_RETURN_TRANSACTIONID(x) return TransactionIdGetDatum(x)
+ /* RETURN macros for other pass-by-ref types will typically look like this: */
+ #define PG_RETURN_BYTEA_P(x) PG_RETURN_POINTER(x)
+ #define PG_RETURN_TEXT_P(x) PG_RETURN_POINTER(x)
+diff --git a/src/include/nodes/pg_list.h b/src/include/nodes/pg_list.h
+index d131350e107..9382e655ef9 100644
+--- a/src/include/nodes/pg_list.h
++++ b/src/include/nodes/pg_list.h
+@@ -46,6 +46,7 @@ typedef union ListCell
+ {
+ void *ptr_value;
+ int int_value;
++ int64 int64_value;
+ Oid oid_value;
+ TransactionId xid_value;
+ } ListCell;
+@@ -171,6 +172,7 @@ list_length(const List *l)
+ */
+ #define lfirst(lc) ((lc)->ptr_value)
+ #define lfirst_int(lc) ((lc)->int_value)
++#define lfirst_int64(lc) ((lc)->int64_value)
+ #define lfirst_oid(lc) ((lc)->oid_value)
+ #define lfirst_xid(lc) ((lc)->xid_value)
+ #define lfirst_node(type,lc) castNode(type, lfirst(lc))
+@@ -197,6 +199,7 @@ list_length(const List *l)
+
+ #define llast(l) lfirst(list_last_cell(l))
+ #define llast_int(l) lfirst_int(list_last_cell(l))
++#define llast_int64(l) lfirst_int64(list_last_cell(l))
+ #define llast_oid(l) lfirst_oid(list_last_cell(l))
+ #define llast_xid(l) lfirst_xid(list_last_cell(l))
+ #define llast_node(type,l) castNode(type, llast(l))
+@@ -610,6 +613,7 @@ extern List *list_make5_impl(NodeTag t, ListCell datum1, ListCell datum2,
+
+ extern pg_nodiscard List *lappend(List *list, void *datum);
+ extern pg_nodiscard List *lappend_int(List *list, int datum);
++extern pg_nodiscard List *lappend_int64(List *list, int64 datum);
+ extern pg_nodiscard List *lappend_oid(List *list, Oid datum);
+ extern pg_nodiscard List *lappend_xid(List *list, TransactionId datum);
+
+diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in
+index 07b2f798abd..8d94228ac52 100644
+--- a/src/include/pg_config.h.in
++++ b/src/include/pg_config.h.in
+@@ -730,6 +730,9 @@
+ # endif
+ #endif
+
++/* Postgres Pro use 64bit xids */
++#undef XID_IS_64BIT
++
+ /* Size of a WAL file block. This need have no particular relation to BLCKSZ.
+ XLOG_BLCKSZ must be a power of 2, and if your system supports O_DIRECT I/O,
+ XLOG_BLCKSZ must be a multiple of the alignment requirement for direct-I/O
+diff --git a/src/include/port/pg_lfind.h b/src/include/port/pg_lfind.h
+index 4b1431ed002..a77c0cdcb22 100644
+--- a/src/include/port/pg_lfind.h
++++ b/src/include/port/pg_lfind.h
+@@ -206,4 +206,66 @@ pg_lfind32(uint32 key, const uint32 *base, uint32 nelem)
+ #endif
+ }
+
++/*
++ * pg_lfind64
++ *
++ * Return true if there is an element in 'base' that equals 'key', otherwise
++ * return false.
++ */
++static inline bool
++pg_lfind64(uint64 key, uint64 *base, uint32 nelem)
++{
++ uint32 i,
++ iterations;
++#if defined(USE_ASSERT_CHECKING)
++ bool assert_result = false;
++
++ /* pre-compute the result for assert checking */
++ for (i = 0; i < nelem; ++i)
++ {
++ if (key == base[i])
++ {
++ assert_result = true;
++ break;
++ }
++ }
++#endif
++
++#define UNROLL_FACTOR 8
++ StaticAssertStmt((UNROLL_FACTOR & (UNROLL_FACTOR - 1)) == 0,
++ "Loop unroll factor must be power of 2");
++ iterations = nelem & ~(UNROLL_FACTOR - 1);
++ for (i = 0; i < iterations; i += UNROLL_FACTOR)
++ {
++ if (base[0] == key || base[1] == key || base[2] == key ||
++ base[3] == key || base[4] == key || base[5] == key ||
++ base[6] == key || base[7] == key)
++ {
++#if defined(USE_ASSERT_CHECKING)
++ Assert(assert_result == true);
++#endif
++ return true;
++ }
++ base += UNROLL_FACTOR;
++ }
++
++ /* Process the remaining elements one at a time. */
++ iterations = nelem & (UNROLL_FACTOR - 1);
++ for (i = 0; i < iterations; ++i)
++ {
++ if (key == *base++)
++ {
++#if defined(USE_ASSERT_CHECKING)
++ Assert(assert_result == true);
++#endif
++ return true;
++ }
++ }
++
++#if defined(USE_ASSERT_CHECKING)
++ Assert(assert_result == false);
++#endif
++ return false;
++}
++
+ #endif /* PG_LFIND_H */
+diff --git a/src/include/postgres.h b/src/include/postgres.h
+index 5d5fd7813e8..79187d93e88 100644
+--- a/src/include/postgres.h
++++ b/src/include/postgres.h
+@@ -80,6 +80,9 @@ typedef struct NullableDatum
+
+ #define SIZEOF_DATUM SIZEOF_VOID_P
+
++static uint64 DatumGetUInt64(Datum X);
++static Datum UInt64GetDatum(uint64 X);
++
+ /*
+ * DatumGetBool
+ * Returns boolean value of a datum.
+@@ -261,7 +264,7 @@ ObjectIdGetDatum(Oid X)
+ static inline TransactionId
+ DatumGetTransactionId(Datum X)
+ {
+- return (TransactionId) X;
++ return DatumGetUInt64(X);
+ }
+
+ /*
+@@ -271,7 +274,7 @@ DatumGetTransactionId(Datum X)
+ static inline Datum
+ TransactionIdGetDatum(TransactionId X)
+ {
+- return (Datum) X;
++ return UInt64GetDatum(X);
+ }
+
+ /*
+@@ -281,7 +284,7 @@ TransactionIdGetDatum(TransactionId X)
+ static inline Datum
+ MultiXactIdGetDatum(MultiXactId X)
+ {
+- return (Datum) X;
++ return UInt64GetDatum(X);
+ }
+
+ /*
+diff --git a/src/include/postmaster/autovacuum.h b/src/include/postmaster/autovacuum.h
+index 15f12ce24f9..3923715f56d 100644
+--- a/src/include/postmaster/autovacuum.h
++++ b/src/include/postmaster/autovacuum.h
+@@ -37,8 +37,8 @@ extern PGDLLIMPORT int64 autovacuum_vac_ins_thresh;
+ extern PGDLLIMPORT double autovacuum_vac_ins_scale;
+ extern PGDLLIMPORT int64 autovacuum_anl_thresh;
+ extern PGDLLIMPORT double autovacuum_anl_scale;
+-extern PGDLLIMPORT int autovacuum_freeze_max_age;
+-extern PGDLLIMPORT int autovacuum_multixact_freeze_max_age;
++extern PGDLLIMPORT int64 autovacuum_freeze_max_age;
++extern PGDLLIMPORT int64 autovacuum_multixact_freeze_max_age;
+ extern PGDLLIMPORT double autovacuum_vac_cost_delay;
+ extern PGDLLIMPORT int autovacuum_vac_cost_limit;
+
+diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
+index eda6c699212..ce812043388 100644
+--- a/src/include/storage/buf_internals.h
++++ b/src/include/storage/buf_internals.h
+@@ -41,10 +41,10 @@
+ */
+ #define BUF_REFCOUNT_ONE 1
+ #define BUF_REFCOUNT_MASK ((1U << 18) - 1)
+-#define BUF_USAGECOUNT_MASK 0x003C0000U
++#define BUF_USAGECOUNT_MASK 0x001C0000U
+ #define BUF_USAGECOUNT_ONE (1U << 18)
+ #define BUF_USAGECOUNT_SHIFT 18
+-#define BUF_FLAG_MASK 0xFFC00000U
++#define BUF_FLAG_MASK 0xFFE00000U
+
+ /* Get refcount and usagecount from buffer state */
+ #define BUF_STATE_GET_REFCOUNT(state) ((state) & BUF_REFCOUNT_MASK)
+@@ -56,6 +56,7 @@
+ * Note: BM_TAG_VALID essentially means that there is a buffer hashtable
+ * entry associated with the buffer's tag.
+ */
++#define BM_CONVERTED (1U << 21) /* buffer were converted to 64xid */
+ #define BM_LOCKED (1U << 22) /* buffer header is locked */
+ #define BM_DIRTY (1U << 23) /* data needs writing */
+ #define BM_VALID (1U << 24) /* data is valid */
+diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
+index eb0fba4230b..9db300e509c 100644
+--- a/src/include/storage/bufmgr.h
++++ b/src/include/storage/bufmgr.h
+@@ -283,8 +283,12 @@ extern void BufferGetTag(Buffer buffer, RelFileLocator *rlocator,
+ ForkNumber *forknum, BlockNumber *blknum);
+
+ extern void MarkBufferDirtyHint(Buffer buffer, bool buffer_std);
++extern void MarkBufferConverted(Buffer buffer, bool converted);
++extern bool IsBufferConverted(Buffer buffer);
+
+ extern void UnlockBuffers(void);
++extern bool IsBufferLocked(Buffer buffer);
++extern bool IsBufferLockedExclusive(Buffer buffer);
+ extern void LockBuffer(Buffer buffer, int mode);
+ extern bool ConditionalLockBuffer(Buffer buffer);
+ extern void LockBufferForCleanup(Buffer buffer);
+@@ -316,6 +320,8 @@ extern int GetAccessStrategyPinLimit(BufferAccessStrategy strategy);
+
+ extern void FreeAccessStrategy(BufferAccessStrategy strategy);
+
++/* old tuple format support */
++extern void convert_page(Relation rel, Page orig_page, Buffer buf, BlockNumber blkno);
+
+ /* inline functions */
+
+diff --git a/src/include/storage/bufpage.h b/src/include/storage/bufpage.h
+index 6222d46e535..1c7345c1d09 100644
+--- a/src/include/storage/bufpage.h
++++ b/src/include/storage/bufpage.h
+@@ -14,10 +14,13 @@
+ #ifndef BUFPAGE_H
+ #define BUFPAGE_H
+
++#include "access/transam.h"
+ #include "access/xlogdefs.h"
+ #include "storage/block.h"
+ #include "storage/item.h"
+ #include "storage/off.h"
++#include "postgres.h"
++#include "utils/rel.h"
+
+ /* GUC variable */
+ extern PGDLLIMPORT bool ignore_checksum_failure;
+@@ -166,12 +169,41 @@ typedef struct PageHeaderData
+ LocationIndex pd_upper; /* offset to end of free space */
+ LocationIndex pd_special; /* offset to start of special space */
+ uint16 pd_pagesize_version;
+- TransactionId pd_prune_xid; /* oldest prunable XID, or zero if none */
++ ShortTransactionId pd_prune_xid; /* oldest prunable XID, or zero if
++ * none */
+ ItemIdData pd_linp[FLEXIBLE_ARRAY_MEMBER]; /* line pointer array */
+ } PageHeaderData;
+
+ typedef PageHeaderData *PageHeader;
+
++
++/*
++ * HeapPageSpecialData -- data that stored at the end of each heap page.
++ *
++ * pd_xid_base - base value for transaction IDs on page
++ * pd_multi_base - base value for multixact IDs on page
++ *
++ * pd_xid_base and pd_multi_base are base values for calculation of transaction
++ * identifiers from t_xmin and t_xmax in each heap tuple header on the page.
++ */
++typedef struct HeapPageSpecialData
++{
++ TransactionId pd_xid_base; /* base value for transaction IDs on page */
++ TransactionId pd_multi_base; /* base value for multixact IDs on page */
++} HeapPageSpecialData;
++
++typedef HeapPageSpecialData *HeapPageSpecial;
++
++typedef struct ToastPageSpecialData
++{
++ TransactionId pd_xid_base; /* base value for transaction IDs on page */
++} ToastPageSpecialData;
++
++typedef ToastPageSpecialData *ToastPageSpecial;
++
++extern PGDLLIMPORT HeapPageSpecial heapDoubleXmaxSpecial;
++extern PGDLLIMPORT ToastPageSpecial toastDoubleXmaxSpecial;
++
+ /*
+ * pd_flags contains the following flag bits. Undefined bits are initialized
+ * to zero and may be used in the future.
+@@ -203,7 +235,7 @@ typedef PageHeaderData *PageHeader;
+ * As of Release 9.3, the checksum version must also be considered when
+ * handling pages.
+ */
+-#define PG_PAGE_LAYOUT_VERSION 4
++#define PG_PAGE_LAYOUT_VERSION 5
+ #define PG_DATA_CHECKSUM_VERSION 1
+
+ /* ----------------------------------------------------------------
+@@ -443,18 +475,177 @@ PageClearAllVisible(Page page)
+ }
+
+ /*
+- * These two require "access/transam.h", so left as macros.
++ * Check if page is in "double xmax" format.
+ */
+-#define PageSetPrunable(page, xid) \
+-do { \
+- Assert(TransactionIdIsNormal(xid)); \
+- if (!TransactionIdIsValid(((PageHeader) (page))->pd_prune_xid) || \
+- TransactionIdPrecedes(xid, ((PageHeader) (page))->pd_prune_xid)) \
+- ((PageHeader) (page))->pd_prune_xid = (xid); \
+-} while (0)
+-#define PageClearPrunable(page) \
+- (((PageHeader) (page))->pd_prune_xid = InvalidTransactionId)
++static inline bool
++HeapPageIsDoubleXmax(Page page)
++{
++ return ((PageHeader) (page))->pd_special == BLCKSZ;
++}
+
++/*
++ * Get pointer to HeapPageSpecialData.
++ *
++ * Can be used for non-consistent reads from non-locked pages.
++ *
++ * Return doubleXmaxSpecial when pd_special == BLCKSZ (i.e. "double xmax"
++ * format).
++ */
++static inline HeapPageSpecial
++HeapPageGetSpecialNoAssert(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return heapDoubleXmaxSpecial;
++
++ return (HeapPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Get pointer to ToastPageSpecialData.
++ *
++ * Can be used for non-consistent reads from non-locked pages.
++ *
++ * Return doubleXmaxSpecial when pd_special == BLCKSZ (i.e. "double xmax"
++ * format).
++ */
++static inline ToastPageSpecial
++ToastPageGetSpecialNoAssert(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return toastDoubleXmaxSpecial;
++
++ return (ToastPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Wrapper for HeapPageGetSpecialNoAssert for general use.
++ */
++static inline HeapPageSpecial
++HeapPageGetSpecial(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return heapDoubleXmaxSpecial;
++
++ Assert(((PageHeader) page)->pd_special ==
++ BLCKSZ - MAXALIGN(sizeof(HeapPageSpecialData)));
++
++ return (HeapPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Wrapper for ToastPageGetSpecialNoAssert for general use.
++ */
++static inline ToastPageSpecial
++ToastPageGetSpecial(Page page)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return toastDoubleXmaxSpecial;
++
++ Assert(((PageHeader) page)->pd_special ==
++ BLCKSZ - MAXALIGN(sizeof(ToastPageSpecialData)));
++
++ return (ToastPageSpecial) ((char *) page +
++ ((PageHeader) page)->pd_special);
++}
++
++/*
++ * Set pd_prune_xid.
++ */
++static inline void
++HeapPageSetPruneXid(Page page, TransactionId xid, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return;
++
++ if (!TransactionIdIsNormal(xid))
++ {
++ ((PageHeader) (page))->pd_prune_xid = xid;
++ return;
++ }
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ ((PageHeader) (page))->pd_prune_xid = NormalTransactionIdToShort(base, xid);
++ Assert(((PageHeader) (page))->pd_prune_xid <= MaxShortTransactionId);
++}
++
++static inline void
++ToastPageSetPruneXid(Page page, TransactionId xid)
++{
++ if (HeapPageIsDoubleXmax(page))
++ return;
++
++ if (!TransactionIdIsNormal(xid))
++ {
++ ((PageHeader) (page))->pd_prune_xid = xid;
++ return;
++ }
++
++ ((PageHeader) (page))->pd_prune_xid =
++ NormalTransactionIdToShort(ToastPageGetSpecial(page)->pd_xid_base, (xid));
++
++ Assert(((PageHeader) (page))->pd_prune_xid <= MaxShortTransactionId);
++}
++
++/*
++ * Get pd_prune_xid from locked page.
++ */
++static inline TransactionId
++HeapPageGetPruneXid(Page page, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return ((PageHeader) (page))->pd_prune_xid;
++
++ base = is_toast ? ToastPageGetSpecial(page)->pd_xid_base :
++ HeapPageGetSpecial(page)->pd_xid_base;
++
++ return ShortTransactionIdToNormal(base,
++ ((PageHeader) (page))->pd_prune_xid);
++}
++
++static inline void
++PageSetPrunable(Page page, TransactionId xid, bool is_toast)
++{
++ TransactionId prune_xid;
++
++ Assert(TransactionIdIsNormal(xid));
++
++ if (HeapPageIsDoubleXmax(page))
++ return;
++
++ prune_xid = HeapPageGetPruneXid(page, is_toast);
++ if ((!TransactionIdIsValid(prune_xid) ||
++ TransactionIdPrecedes(xid, prune_xid)))
++ {
++ HeapPageSetPruneXid(page, xid, is_toast);
++ }
++}
++
++/*
++ * Get pd_prune_xid from non-locked page. May return invalid value, but doen't
++ * causes assert failures.
++ */
++static inline TransactionId
++HeapPageGetPruneXidNoAssert(Page page, bool is_toast)
++{
++ TransactionId base;
++
++ if (HeapPageIsDoubleXmax(page))
++ return ((PageHeader) (page))->pd_prune_xid;
++
++ base = is_toast ? ToastPageGetSpecialNoAssert(page)->pd_xid_base :
++ HeapPageGetSpecialNoAssert(page)->pd_xid_base;
++ return ShortTransactionIdToNormal(base,
++ ((PageHeader) (page))->pd_prune_xid);
++}
+
+ /* ----------------------------------------------------------------
+ * extern declarations
+@@ -488,6 +679,21 @@ do { \
+ StaticAssertDecl(BLCKSZ == ((BLCKSZ / sizeof(size_t)) * sizeof(size_t)),
+ "BLCKSZ has to be a multiple of sizeof(size_t)");
+
++/*
++ * Tuple defrag support for PageRepairFragmentation and PageIndexMultiDelete
++ */
++typedef struct ItemIdCompactData
++{
++ uint16 offsetindex; /* linp array index */
++ int16 itemoff; /* page offset of item data */
++ uint16 alignedlen; /* MAXALIGN(item data len) */
++} ItemIdCompactData;
++
++typedef ItemIdCompactData *ItemIdCompact;
++typedef RelationData *Relation;
++
++extern int itemoffcompare(const void *item1, const void *item2);
++
+ extern void PageInit(Page page, Size pageSize, Size specialSize);
+ extern bool PageIsVerifiedExtended(Page page, BlockNumber blkno, int flags);
+ extern OffsetNumber PageAddItemExtended(Page page, Item item, Size size,
+@@ -496,7 +702,7 @@ extern Page PageGetTempPage(Page page);
+ extern Page PageGetTempPageCopy(Page page);
+ extern Page PageGetTempPageCopySpecial(Page page);
+ extern void PageRestoreTempPage(Page tempPage, Page oldPage);
+-extern void PageRepairFragmentation(Page page);
++extern void PageRepairFragmentation(Page page, bool is_toast);
+ extern void PageTruncateLinePointerArray(Page page);
+ extern Size PageGetFreeSpace(Page page);
+ extern Size PageGetFreeSpaceForMultipleTuples(Page page, int ntups);
+diff --git a/src/include/storage/itemid.h b/src/include/storage/itemid.h
+index 6d29722ec1f..2129728dc49 100644
+--- a/src/include/storage/itemid.h
++++ b/src/include/storage/itemid.h
+@@ -78,6 +78,8 @@ typedef uint16 ItemLength;
+ #define ItemIdGetRedirect(itemId) \
+ ((itemId)->lp_off)
+
++#define ItemIdGetTupleEnd(itemId) \
++ (MAXALIGN(ItemIdGetLength((itemId))) + ItemIdGetOffset((itemId)))
+ /*
+ * ItemIdIsValid
+ * True iff item identifier is valid.
+diff --git a/src/include/storage/lock.h b/src/include/storage/lock.h
+index 787f3db06a9..84f7323f606 100644
+--- a/src/include/storage/lock.h
++++ b/src/include/storage/lock.h
+@@ -224,8 +224,8 @@ typedef struct LOCKTAG
+
+ /* ID info for a transaction is its TransactionId */
+ #define SET_LOCKTAG_TRANSACTION(locktag,xid) \
+- ((locktag).locktag_field1 = (xid), \
+- (locktag).locktag_field2 = 0, \
++ ((locktag).locktag_field1 = (uint32)((xid) & 0xFFFFFFFF), \
++ (locktag).locktag_field2 = (uint32)((xid) >> 32), \
+ (locktag).locktag_field3 = 0, \
+ (locktag).locktag_field4 = 0, \
+ (locktag).locktag_type = LOCKTAG_TRANSACTION, \
+@@ -234,8 +234,8 @@ typedef struct LOCKTAG
+ /* ID info for a virtual transaction is its VirtualTransactionId */
+ #define SET_LOCKTAG_VIRTUALTRANSACTION(locktag,vxid) \
+ ((locktag).locktag_field1 = (vxid).procNumber, \
+- (locktag).locktag_field2 = (vxid).localTransactionId, \
+- (locktag).locktag_field3 = 0, \
++ (locktag).locktag_field2 = (uint32)((vxid).localTransactionId & 0xFFFFFFFF), \
++ (locktag).locktag_field3 = (uint32)((vxid).localTransactionId >> 32), \
+ (locktag).locktag_field4 = 0, \
+ (locktag).locktag_type = LOCKTAG_VIRTUALTRANSACTION, \
+ (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)
+@@ -245,9 +245,9 @@ typedef struct LOCKTAG
+ * its speculative insert counter.
+ */
+ #define SET_LOCKTAG_SPECULATIVE_INSERTION(locktag,xid,token) \
+- ((locktag).locktag_field1 = (xid), \
+- (locktag).locktag_field2 = (token), \
+- (locktag).locktag_field3 = 0, \
++ ((locktag).locktag_field1 = (uint32)((xid) & 0xFFFFFFFF), \
++ (locktag).locktag_field2 = (uint32)((xid) >> 32), \
++ (locktag).locktag_field3 = (token), \
+ (locktag).locktag_field4 = 0, \
+ (locktag).locktag_type = LOCKTAG_SPECULATIVE_TOKEN, \
+ (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)
+diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h
+index 5a3dd5d2d40..2d13925e79a 100644
+--- a/src/include/storage/proc.h
++++ b/src/include/storage/proc.h
+@@ -17,6 +17,7 @@
+ #include "access/clog.h"
+ #include "access/xlogdefs.h"
+ #include "lib/ilist.h"
++#include "port/atomics.h"
+ #include "storage/latch.h"
+ #include "storage/lock.h"
+ #include "storage/pg_sema.h"
+@@ -175,12 +176,12 @@ struct PGPROC
+ Latch procLatch; /* generic latch for process */
+
+
+- TransactionId xid; /* id of top-level transaction currently being
++ pg_atomic_uint64 xid; /* id of top-level transaction currently being
+ * executed by this proc, if running and XID
+ * is assigned; else InvalidTransactionId.
+ * mirrored in ProcGlobal->xids[pgxactoff] */
+
+- TransactionId xmin; /* minimal running XID as it was when we were
++ pg_atomic_uint64 xmin; /* minimal running XID as it was when we were
+ * starting our xact, excluding LAZY VACUUM:
+ * vacuum must not remove tuples deleted by
+ * xid >= xmin ! */
+@@ -390,7 +391,7 @@ typedef struct PROC_HDR
+ PGPROC *allProcs;
+
+ /* Array mirroring PGPROC.xid for each PGPROC currently in the procarray */
+- TransactionId *xids;
++ pg_atomic_uint64 *xids;
+
+ /*
+ * Array mirroring PGPROC.subxidStatus for each PGPROC currently in the
+diff --git a/src/include/utils/combocid.h b/src/include/utils/combocid.h
+index 00a9b561ec9..f1f4a899c4f 100644
+--- a/src/include/utils/combocid.h
++++ b/src/include/utils/combocid.h
+@@ -15,7 +15,7 @@
+ #define COMBOCID_H
+
+ /*
+- * HeapTupleHeaderGetCmin and HeapTupleHeaderGetCmax function prototypes
++ * HeapTupleGetCmin and HeapTupleGetCmax function prototypes
+ * are in access/htup.h, because that's where the macro definitions that
+ * those functions replaced used to be.
+ */
+diff --git a/src/include/utils/xid8.h b/src/include/utils/xid8.h
+index e8f887c6333..91d3f6f9a5b 100644
+--- a/src/include/utils/xid8.h
++++ b/src/include/utils/xid8.h
+@@ -17,13 +17,13 @@
+ static inline FullTransactionId
+ DatumGetFullTransactionId(Datum X)
+ {
+- return FullTransactionIdFromU64(DatumGetUInt64(X));
++ return FullTransactionIdFromXid(DatumGetUInt64(X));
+ }
+
+ static inline Datum
+ FullTransactionIdGetDatum(FullTransactionId X)
+ {
+- return UInt64GetDatum(U64FromFullTransactionId(X));
++ return UInt64GetDatum(XidFromFullTransactionId(X));
+ }
+
+ #define PG_GETARG_FULLTRANSACTIONID(X) DatumGetFullTransactionId(PG_GETARG_DATUM(X))
+diff --git a/src/pl/plperl/plperl.c b/src/pl/plperl/plperl.c
+index 1b1677e333b..770537a5437 100644
+--- a/src/pl/plperl/plperl.c
++++ b/src/pl/plperl/plperl.c
+@@ -2675,7 +2675,7 @@ validate_plperl_function(plperl_proc_ptr *proc_ptr, HeapTuple procTup)
+ * This is needed because CREATE OR REPLACE FUNCTION can modify the
+ * function's pg_proc entry without changing its OID.
+ ************************************************************/
+- uptodate = (prodesc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ uptodate = (prodesc->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&prodesc->fn_tid, &procTup->t_self));
+
+ if (uptodate)
+@@ -2799,7 +2799,7 @@ compile_plperl_function(Oid fn_oid, bool is_trigger, bool is_event_trigger)
+ MemoryContextSetIdentifier(proc_cxt, prodesc->proname);
+ prodesc->fn_cxt = proc_cxt;
+ prodesc->fn_refcount = 0;
+- prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ prodesc->fn_xmin = HeapTupleGetRawXmin(procTup);
+ prodesc->fn_tid = procTup->t_self;
+ prodesc->nargs = procStruct->pronargs;
+ prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo));
+diff --git a/src/pl/plpgsql/src/pl_comp.c b/src/pl/plpgsql/src/pl_comp.c
+index 6255a86d75b..d0ef60c0d84 100644
+--- a/src/pl/plpgsql/src/pl_comp.c
++++ b/src/pl/plpgsql/src/pl_comp.c
+@@ -170,7 +170,7 @@ recheck:
+ if (function)
+ {
+ /* We have a compiled function, but is it still valid? */
+- if (function->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ if (function->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&function->fn_tid, &procTup->t_self))
+ function_valid = true;
+ else
+@@ -343,7 +343,7 @@ do_compile(FunctionCallInfo fcinfo,
+ function->fn_signature = format_procedure(fcinfo->flinfo->fn_oid);
+ MemoryContextSetIdentifier(func_cxt, function->fn_signature);
+ function->fn_oid = fcinfo->flinfo->fn_oid;
+- function->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ function->fn_xmin = HeapTupleGetRawXmin(procTup);
+ function->fn_tid = procTup->t_self;
+ function->fn_input_collation = fcinfo->fncollation;
+ function->fn_cxt = func_cxt;
+diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c
+index e31206e7f4c..65b55c40022 100644
+--- a/src/pl/plpgsql/src/pl_exec.c
++++ b/src/pl/plpgsql/src/pl_exec.c
+@@ -7402,6 +7402,7 @@ deconstruct_composite_datum(Datum value, HeapTupleData *tmptup)
+ tmptup->t_len = HeapTupleHeaderGetDatumLength(td);
+ ItemPointerSetInvalid(&(tmptup->t_self));
+ tmptup->t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(tmptup);
+ tmptup->t_data = td;
+
+ /* Extract rowtype info and find a tupdesc */
+@@ -7576,6 +7577,7 @@ exec_move_row_from_datum(PLpgSQL_execstate *estate,
+ tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
+ ItemPointerSetInvalid(&(tmptup.t_self));
+ tmptup.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tmptup);
+ tmptup.t_data = td;
+
+ /* Extract rowtype info */
+diff --git a/src/pl/plpython/plpy_procedure.c b/src/pl/plpython/plpy_procedure.c
+index c35a3b801ab..c0377567575 100644
+--- a/src/pl/plpython/plpy_procedure.c
++++ b/src/pl/plpython/plpy_procedure.c
+@@ -175,7 +175,7 @@ PLy_procedure_create(HeapTuple procTup, Oid fn_oid, bool is_trigger)
+ proc->proname = pstrdup(NameStr(procStruct->proname));
+ MemoryContextSetIdentifier(cxt, proc->proname);
+ proc->pyname = pstrdup(procName);
+- proc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ proc->fn_xmin = HeapTupleGetRawXmin(procTup);
+ proc->fn_tid = procTup->t_self;
+ proc->fn_readonly = (procStruct->provolatile != PROVOLATILE_VOLATILE);
+ proc->is_setof = procStruct->proretset;
+@@ -415,7 +415,7 @@ PLy_procedure_valid(PLyProcedure *proc, HeapTuple procTup)
+ return false;
+
+ /* If the pg_proc tuple has changed, it's not valid */
+- if (!(proc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ if (!(proc->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&proc->fn_tid, &procTup->t_self)))
+ return false;
+
+diff --git a/src/pl/tcl/pltcl.c b/src/pl/tcl/pltcl.c
+index e2d9246a678..74feb938498 100644
+--- a/src/pl/tcl/pltcl.c
++++ b/src/pl/tcl/pltcl.c
+@@ -1455,7 +1455,7 @@ compile_pltcl_function(Oid fn_oid, Oid tgreloid,
+ ************************************************************/
+ if (prodesc != NULL &&
+ prodesc->internal_proname != NULL &&
+- prodesc->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) &&
++ prodesc->fn_xmin == HeapTupleGetRawXmin(procTup) &&
+ ItemPointerEquals(&prodesc->fn_tid, &procTup->t_self))
+ {
+ /* It's still up-to-date, so we can use it */
+@@ -1589,7 +1589,7 @@ compile_pltcl_function(Oid fn_oid, Oid tgreloid,
+ prodesc->internal_proname = pstrdup(internal_proname);
+ prodesc->fn_cxt = proc_cxt;
+ prodesc->fn_refcount = 0;
+- prodesc->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data);
++ prodesc->fn_xmin = HeapTupleGetRawXmin(procTup);
+ prodesc->fn_tid = procTup->t_self;
+ prodesc->nargs = procStruct->pronargs;
+ prodesc->arg_out_func = (FmgrInfo *) palloc0(prodesc->nargs * sizeof(FmgrInfo));
+diff --git a/src/test/Makefile b/src/test/Makefile
+index 511a72e6238..b986d0e324e 100644
+--- a/src/test/Makefile
++++ b/src/test/Makefile
+@@ -12,7 +12,8 @@ subdir = src/test
+ top_builddir = ../..
+ include $(top_builddir)/src/Makefile.global
+
+-SUBDIRS = perl postmaster regress isolation modules authentication recovery subscription
++SUBDIRS = perl postmaster regress isolation modules authentication recovery subscription \
++ xid-64
+
+ ifeq ($(with_icu),yes)
+ SUBDIRS += icu
+diff --git a/src/test/meson.build b/src/test/meson.build
+index 67376e4b7fd..11344e47add 100644
+--- a/src/test/meson.build
++++ b/src/test/meson.build
+@@ -8,6 +8,7 @@ subdir('postmaster')
+ subdir('recovery')
+ subdir('subscription')
+ subdir('modules')
++subdir('xid-64')
+
+ if ssl.found()
+ subdir('ssl')
+diff --git a/src/test/modules/test_lfind/test_lfind.c b/src/test/modules/test_lfind/test_lfind.c
+index c04bc2f6b42..3cf305f56c6 100644
+--- a/src/test/modules/test_lfind/test_lfind.c
++++ b/src/test/modules/test_lfind/test_lfind.c
+@@ -120,29 +120,29 @@ Datum
+ test_lfind32(PG_FUNCTION_ARGS)
+ {
+ #define TEST_ARRAY_SIZE 135
+- uint32 test_array[TEST_ARRAY_SIZE] = {0};
++ uint64 test_array[TEST_ARRAY_SIZE] = {0};
+
+ test_array[8] = 1;
+ test_array[64] = 2;
+ test_array[TEST_ARRAY_SIZE - 1] = 3;
+
+- if (pg_lfind32(1, test_array, 4))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
+- if (!pg_lfind32(1, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() did not find existing element");
++ if (pg_lfind64(1, test_array, 4))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
++ if (!pg_lfind64(1, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() did not find existing element");
+
+- if (pg_lfind32(2, test_array, 32))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
+- if (!pg_lfind32(2, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() did not find existing element");
++ if (pg_lfind64(2, test_array, 32))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
++ if (!pg_lfind64(2, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() did not find existing element");
+
+- if (pg_lfind32(3, test_array, 96))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
+- if (!pg_lfind32(3, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() did not find existing element");
++ if (pg_lfind64(3, test_array, 96))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
++ if (!pg_lfind64(3, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() did not find existing element");
+
+- if (pg_lfind32(4, test_array, TEST_ARRAY_SIZE))
+- elog(ERROR, "pg_lfind32() found nonexistent element");
++ if (pg_lfind64(4, test_array, TEST_ARRAY_SIZE))
++ elog(ERROR, "pg_lfind64() found nonexistent element");
+
+ PG_RETURN_VOID();
+ }
+diff --git a/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm b/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
+index 239c17aced9..83287ec6d57 100644
+--- a/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
++++ b/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
+@@ -132,6 +132,10 @@ sub adjust_database_contents
+ 'drop table public.gtest_normal_child2');
+ }
+
++ # Can't upgrade xid type
++ _add_st($result, 'regression',
++ 'alter table public.tab_core_types drop column xid');
++
+ # stuff not supported from release 14
+ if ($old_version < 14)
+ {
+diff --git a/src/test/recovery/t/003_recovery_targets.pl b/src/test/recovery/t/003_recovery_targets.pl
+index 58241a68f0a..ecd1105d1ae 100644
+--- a/src/test/recovery/t/003_recovery_targets.pl
++++ b/src/test/recovery/t/003_recovery_targets.pl
+@@ -57,7 +57,7 @@ $node_primary->init(has_archiving => 1, allows_streaming => 1);
+
+ # Bump the transaction ID epoch. This is useful to stress the portability
+ # of recovery_target_xid parsing.
+-system_or_bail('pg_resetwal', '--epoch', '1', $node_primary->data_dir);
++system_or_bail('pg_resetwal', $node_primary->data_dir);
+
+ # Start it
+ $node_primary->start;
+diff --git a/src/test/recovery/t/039_end_of_wal.pl b/src/test/recovery/t/039_end_of_wal.pl
+index 349bd44b726..4e5b0fd6e41 100644
+--- a/src/test/recovery/t/039_end_of_wal.pl
++++ b/src/test/recovery/t/039_end_of_wal.pl
+@@ -21,7 +21,7 @@ use integer; # causes / operator to use integer math
+ my $BIG_ENDIAN = pack("L", 0x12345678) eq pack("N", 0x12345678);
+
+ # Header size of record header.
+-my $RECORD_HEADER_SIZE = 24;
++my $RECORD_HEADER_SIZE = 26;
+
+ # Fields retrieved from code headers.
+ my @scan_result = scan_server_header('access/xlog_internal.h',
+@@ -131,17 +131,21 @@ sub build_record_header
+
+ # This needs to follow the structure XLogRecord:
+ # I for xl_tot_len
+- # I for xl_xid
++ # I for xl_crc
++ # II for xl_xid
+ # II for xl_prev
+ # C for xl_info
+ # C for xl_rmid
+- # BB for two bytes of padding
+- # I for xl_crc
+- return pack("IIIICCBBI",
+- $xl_tot_len, $xl_xid,
++ # BBBBBB for two bytes of padding
++ return pack("IIIIIICCBBBBBB",
++ $xl_tot_len,
++ $xl_crc,
++ $BIG_ENDIAN ? 0 : $xl_xid,
++ $BIG_ENDIAN ? $xl_xid : 0,
+ $BIG_ENDIAN ? 0 : $xl_prev,
+ $BIG_ENDIAN ? $xl_prev : 0,
+- $xl_info, $xl_rmid, 0, 0, $xl_crc);
++ $xl_info, $xl_rmid,
++ 0, 0, 0, 0, 0, 0);
+ }
+
+ # Build a fake WAL page header, based on the data given by the caller
+@@ -271,7 +275,7 @@ $node->stop('immediate');
+ my $log_size = -s $node->logfile;
+ $node->start;
+ ok( $node->log_contains(
+- "invalid record length at .*: expected at least 24, got 0", $log_size
++ "invalid record length at .*: expected at least 26, got 0", $log_size
+ ),
+ "xl_tot_len zero");
+
+@@ -283,7 +287,7 @@ write_wal($node, $TLI, $end_lsn, build_record_header(23));
+ $log_size = -s $node->logfile;
+ $node->start;
+ ok( $node->log_contains(
+- "invalid record length at .*: expected at least 24, got 23",
++ "invalid record length at .*: expected at least 26, got 23",
+ $log_size),
+ "xl_tot_len short");
+
+@@ -296,7 +300,7 @@ write_wal($node, $TLI, $end_lsn, build_record_header(1));
+ $log_size = -s $node->logfile;
+ $node->start;
+ ok( $node->log_contains(
+- "invalid record length at .*: expected at least 24, got 1", $log_size
++ "invalid record length at .*: expected at least 26, got 1", $log_size
+ ),
+ "xl_tot_len short at end-of-page");
+
+diff --git a/src/test/regress/expected/indirect_toast.out b/src/test/regress/expected/indirect_toast.out
+index 44b54dc37fd..313482b866c 100644
+--- a/src/test/regress/expected/indirect_toast.out
++++ b/src/test/regress/expected/indirect_toast.out
+@@ -161,6 +161,14 @@ SELECT substring(indtoasttest::text, 1, 200) FROM indtoasttest;
+ ("one-toasted,one-null, via indirect",0,1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
+ (5 rows)
+
++create or replace function random_string(len integer) returns text as $$
++select substr((select string_agg(r,'') from (select random()::text as r from generate_series(1,(len+15)/16)) s1), 1, len);
++$$ language sql;
++create table toasttest_main(t text);
++alter table toasttest_main alter column t set storage main;
++insert into toasttest_main (select random_string(len) from generate_series(7000,8000) len);
+ DROP TABLE indtoasttest;
++DROP TABLE toasttest_main;
+ DROP FUNCTION update_using_indirect();
++DROP FUNCTION random_string(integer);
+ RESET default_toast_compression;
+diff --git a/src/test/regress/expected/insert.out b/src/test/regress/expected/insert.out
+index cf4b5221a8d..0d40f3e3026 100644
+--- a/src/test/regress/expected/insert.out
++++ b/src/test/regress/expected/insert.out
+@@ -100,7 +100,7 @@ SELECT pg_size_pretty(pg_relation_size('large_tuple_test'::regclass, 'main'));
+ INSERT INTO large_tuple_test (select 3, NULL);
+ -- now this tuple won't fit on the second page, but the insert should
+ -- still succeed by extending the relation
+-INSERT INTO large_tuple_test (select 4, repeat('a', 8126));
++INSERT INTO large_tuple_test (select 4, repeat('a', 8112));
+ DROP TABLE large_tuple_test;
+ --
+ -- check indirection (field/array assignment), cf bug #14265
+@@ -1094,3 +1094,17 @@ insert into returningwrtest values (2, 'foo') returning returningwrtest;
+ (1 row)
+
+ drop table returningwrtest;
++-- Check for MaxHeapTupleSize
++create table maxheaptuplesize_test(value text);
++alter table maxheaptuplesize_test alter column value set storage external;
++insert into maxheaptuplesize_test values (repeat('x', 8104));
++insert into maxheaptuplesize_test values (repeat('x', 8112));
++insert into maxheaptuplesize_test values (repeat('x', 8120));
++insert into maxheaptuplesize_test values (repeat('x', 8128));
++insert into maxheaptuplesize_test values (repeat('x', 8136));
++insert into maxheaptuplesize_test values (repeat('x', 8144));
++insert into maxheaptuplesize_test values (repeat('x', 8152));
++insert into maxheaptuplesize_test values (repeat('x', 8160));
++insert into maxheaptuplesize_test values (repeat('x', 8168));
++insert into maxheaptuplesize_test values (repeat('x', 8176));
++drop table maxheaptuplesize_test;
+diff --git a/src/test/regress/expected/opr_sanity.out b/src/test/regress/expected/opr_sanity.out
+index 34a32bd11d2..298c6563aa8 100644
+--- a/src/test/regress/expected/opr_sanity.out
++++ b/src/test/regress/expected/opr_sanity.out
+@@ -197,7 +197,7 @@ WHERE p1.oid != p2.oid AND
+ ORDER BY 1, 2;
+ proargtypes | proargtypes
+ -----------------------------+--------------------------
+- integer | xid
++ bigint | xid
+ timestamp without time zone | timestamp with time zone
+ bit | bit varying
+ txid_snapshot | pg_snapshot
+@@ -736,7 +736,7 @@ int8(oid)
+ tideq(tid,tid)
+ timestamptz_cmp(timestamp with time zone,timestamp with time zone)
+ interval_cmp(interval,interval)
+-xideqint4(xid,integer)
++xideqint8(xid,bigint)
+ timetz_eq(time with time zone,time with time zone)
+ timetz_ne(time with time zone,time with time zone)
+ timetz_lt(time with time zone,time with time zone)
+@@ -850,7 +850,7 @@ pg_lsn_gt(pg_lsn,pg_lsn)
+ pg_lsn_ne(pg_lsn,pg_lsn)
+ pg_lsn_cmp(pg_lsn,pg_lsn)
+ xidneq(xid,xid)
+-xidneqint4(xid,integer)
++xidneqint8(xid,bigint)
+ sha224(bytea)
+ sha256(bytea)
+ sha384(bytea)
+diff --git a/src/test/regress/expected/select_views.out b/src/test/regress/expected/select_views.out
+index 1aeed8452bd..804d9914e8d 100644
+--- a/src/test/regress/expected/select_views.out
++++ b/src/test/regress/expected/select_views.out
+@@ -2,9 +2,22 @@
+ -- SELECT_VIEWS
+ -- test the views defined in CREATE_VIEWS
+ --
+-SELECT * FROM street;
++SELECT * FROM street ORDER BY name COLLATE "C", thepath::text COLLATE "C", cname COLLATE "C";
+ name | thepath | cname
+ ------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------
++ 100th Ave | [(-122.1657,37.429),(-122.1647,37.432)] | Oakland
++ 107th Ave | [(-122.1555,37.403),(-122.1531,37.41)] | Oakland
++ 14th St | [(-122.299,37.147),(-122.3,37.148)] | Lafayette
++ 19th Ave | [(-122.2366,37.897),(-122.2359,37.905)] | Berkeley
++ 1st St | [(-121.75508,37.89294),(-121.753581,37.90031)] | Oakland
++ 5th St | [(-122.278,37),(-122.2792,37.005),(-122.2803,37.009)] | Lafayette
++ 5th St | [(-122.296,37.615),(-122.2953,37.598)] | Berkeley
++ 82nd Ave | [(-122.1695,37.596),(-122.1681,37.603)] | Berkeley
++ 85th Ave | [(-122.1877,37.466),(-122.186,37.476)] | Oakland
++ 89th Ave | [(-122.1822,37.459),(-122.1803,37.471)] | Oakland
++ 98th Ave | [(-122.1568,37.498),(-122.1558,37.502)] | Oakland
++ 98th Ave | [(-122.1693,37.438),(-122.1682,37.444)] | Oakland
++ 98th Ave | [(-122.2001,37.258),(-122.1974,37.27)] | Lafayette
+ Access Rd 25 | [(-121.9283,37.894),(-121.9283,37.9)] | Oakland
+ Ada St | [(-122.2487,37.398),(-122.2496,37.401)] | Lafayette
+ Agua Fria Creek | [(-121.9254,37.922),(-121.9281,37.889)] | Oakland
+@@ -22,10 +35,10 @@ SELECT * FROM street;
+ Arroyo Las Positas | [(-121.7973,37.997),(-121.7957,37.005)] | Oakland
+ Arroyo Seco | [(-121.7073,37.766),(-121.6997,37.729)] | Oakland
+ Ash St | [(-122.0408,37.31),(-122.04,37.292)] | Oakland
+- Avenue 134th | [(-122.1823,37.002),(-122.1851,37.992)] | Oakland
+ Avenue 134th | [(-122.1823,37.002),(-122.1851,37.992)] | Berkeley
+- Avenue 140th | [(-122.1656,37.003),(-122.1691,37.988)] | Oakland
++ Avenue 134th | [(-122.1823,37.002),(-122.1851,37.992)] | Oakland
+ Avenue 140th | [(-122.1656,37.003),(-122.1691,37.988)] | Berkeley
++ Avenue 140th | [(-122.1656,37.003),(-122.1691,37.988)] | Oakland
+ Avenue D | [(-122.298,37.848),(-122.3024,37.849)] | Berkeley
+ B St | [(-122.1749,37.451),(-122.1743,37.443)] | Oakland
+ Bancroft Ave | [(-122.15714,37.4242),(-122.156,37.409)] | Oakland
+@@ -37,9 +50,9 @@ SELECT * FROM street;
+ Broadmore Ave | [(-122.095,37.522),(-122.0936,37.497)] | Oakland
+ Broadway | [(-122.2409,37.586),(-122.2395,37.601)] | Berkeley
+ Buckingham Blvd | [(-122.2231,37.59),(-122.2214,37.606)] | Berkeley
++ Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Berkeley
+ Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Oakland
+ Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Oakland
+- Butterfield Dr | [(-122.0838,37.002),(-122.0834,37.987)] | Berkeley
+ C St | [(-122.1768,37.46),(-122.1749,37.435)] | Oakland
+ Calaveras Creek | [(-121.8203,37.035),(-121.8207,37.931)] | Oakland
+ Calaveras Creek | [(-121.8203,37.035),(-121.8207,37.931)] | Oakland
+@@ -60,9 +73,9 @@ SELECT * FROM street;
+ Chapman Dr | [(-122.0421,37.504),(-122.0414,37.498)] | Oakland
+ Charles St | [(-122.0255,37.505),(-122.0252,37.499)] | Oakland
+ Cherry St | [(-122.0437,37.42),(-122.0434,37.413)] | Oakland
++ Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Berkeley
+ Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Oakland
+ Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Oakland
+- Claremont Pl | [(-122.0542,37.995),(-122.0542,37.008)] | Berkeley
+ Coliseum Way | [(-122.2001,37.47),(-122.1978,37.516)] | Oakland
+ Coliseum Way | [(-122.2113,37.626),(-122.2085,37.592),(-122.2063,37.568)] | Berkeley
+ Coolidge Ave | [(-122.2007,37.058),(-122.1992,37.06)] | Lafayette
+@@ -77,9 +90,9 @@ SELECT * FROM street;
+ Cull Canyon Road | [(-122.0536,37.435),(-122.0499,37.315)] | Oakland
+ Cull Creek | [(-122.0624,37.875),(-122.0582,37.527)] | Berkeley
+ D St | [(-122.1811,37.505),(-122.1805,37.497)] | Oakland
++ Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Berkeley
+ Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Oakland
+ Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Oakland
+- Decoto Road | [(-122.0159,37.006),(-122.016,37.002),(-122.0164,37.993)] | Berkeley
+ Deering St | [(-122.2146,37.904),(-122.2126,37.897)] | Berkeley
+ Dimond Ave | [(-122.2167,37.994),(-122.2162,37.006)] | Berkeley
+ Dimond Ave | [(-122.2167,37.994),(-122.2162,37.006)] | Lafayette
+@@ -89,9 +102,9 @@ SELECT * FROM street;
+ Driscoll Road | [(-121.9482,37.403),(-121.948451,37.39995)] | Oakland
+ E St | [(-122.1832,37.505),(-122.1826,37.498),(-122.182,37.49)] | Oakland
+ Eden Ave | [(-122.1143,37.505),(-122.1142,37.491)] | Oakland
++ Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Berkeley
+ Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Oakland
+ Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Oakland
+- Eden Creek | [(-122.022037,37.00675),(-122.0221,37.998)] | Berkeley
+ Edgewater Dr | [(-122.201,37.379),(-122.2042,37.41)] | Lafayette
+ Enos Way | [(-121.7677,37.896),(-121.7673,37.91)] | Oakland
+ Euclid Ave | [(-122.2671,37.009),(-122.2666,37.987)] | Berkeley
+@@ -106,8 +119,8 @@ SELECT * FROM street;
+ Harris Road | [(-122.0659,37.372),(-122.0675,37.363)] | Oakland
+ Heartwood Dr | [(-122.2006,37.341),(-122.1992,37.338)] | Lafayette
+ Hegenberger Exwy | [(-122.1946,37.52),(-122.1947,37.497)] | Oakland
+- Herrier St | [(-122.1943,37.006),(-122.1936,37.998)] | Oakland
+ Herrier St | [(-122.1943,37.006),(-122.1936,37.998)] | Berkeley
++ Herrier St | [(-122.1943,37.006),(-122.1936,37.998)] | Oakland
+ Hesperian Blvd | [(-122.097,37.333),(-122.0956,37.31),(-122.0946,37.293)] | Oakland
+ Hesperian Blvd | [(-122.097,37.333),(-122.0956,37.31),(-122.0946,37.293)] | Oakland
+ Hesperian Blvd | [(-122.1132,37.6),(-122.1123,37.586)] | Berkeley
+@@ -117,10 +130,10 @@ SELECT * FROM street;
+ I- 580 | [(-121.9322,37.989),(-121.9243,37.006),(-121.9217,37.014)] | Oakland
+ I- 580 | [(-122.018,37.019),(-122.0009,37.032),(-121.9787,37.983),(-121.958,37.984),(-121.9571,37.986)] | Oakland
+ I- 580 | [(-122.018,37.019),(-122.0009,37.032),(-121.9787,37.983),(-121.958,37.984),(-121.9571,37.986)] | Oakland
+- I- 580 | [(-122.1108,37.023),(-122.1101,37.02),(-122.108103,37.00764),(-122.108,37.007),(-122.1069,37.998),(-122.1064,37.994),(-122.1053,37.982),(-122.1048,37.977),(-122.1032,37.958),(-122.1026,37.953),(-122.1013,37.938),(-122.0989,37.911),(-122.0984,37.91),(-122.098,37.908)] | Oakland
+ I- 580 | [(-122.1108,37.023),(-122.1101,37.02),(-122.108103,37.00764),(-122.108,37.007),(-122.1069,37.998),(-122.1064,37.994),(-122.1053,37.982),(-122.1048,37.977),(-122.1032,37.958),(-122.1026,37.953),(-122.1013,37.938),(-122.0989,37.911),(-122.0984,37.91),(-122.098,37.908)] | Berkeley
+- I- 580 | [(-122.1543,37.703),(-122.1535,37.694),(-122.1512,37.655),(-122.1475,37.603),(-122.1468,37.583),(-122.1472,37.569),(-122.149044,37.54874),(-122.1493,37.546),(-122.1501,37.532),(-122.1506,37.509),(-122.1495,37.482),(-122.1487,37.467),(-122.1477,37.447),(-122.1414,37.383),(-122.1404,37.376),(-122.1398,37.372),(-122.139,37.356),(-122.1388,37.353),(-122.1385,37.34),(-122.1382,37.33),(-122.1378,37.316)] | Oakland
++ I- 580 | [(-122.1108,37.023),(-122.1101,37.02),(-122.108103,37.00764),(-122.108,37.007),(-122.1069,37.998),(-122.1064,37.994),(-122.1053,37.982),(-122.1048,37.977),(-122.1032,37.958),(-122.1026,37.953),(-122.1013,37.938),(-122.0989,37.911),(-122.0984,37.91),(-122.098,37.908)] | Oakland
+ I- 580 | [(-122.1543,37.703),(-122.1535,37.694),(-122.1512,37.655),(-122.1475,37.603),(-122.1468,37.583),(-122.1472,37.569),(-122.149044,37.54874),(-122.1493,37.546),(-122.1501,37.532),(-122.1506,37.509),(-122.1495,37.482),(-122.1487,37.467),(-122.1477,37.447),(-122.1414,37.383),(-122.1404,37.376),(-122.1398,37.372),(-122.139,37.356),(-122.1388,37.353),(-122.1385,37.34),(-122.1382,37.33),(-122.1378,37.316)] | Berkeley
++ I- 580 | [(-122.1543,37.703),(-122.1535,37.694),(-122.1512,37.655),(-122.1475,37.603),(-122.1468,37.583),(-122.1472,37.569),(-122.149044,37.54874),(-122.1493,37.546),(-122.1501,37.532),(-122.1506,37.509),(-122.1495,37.482),(-122.1487,37.467),(-122.1477,37.447),(-122.1414,37.383),(-122.1404,37.376),(-122.1398,37.372),(-122.139,37.356),(-122.1388,37.353),(-122.1385,37.34),(-122.1382,37.33),(-122.1378,37.316)] | Oakland
+ I- 580 | [(-122.2197,37.99),(-122.22,37.99),(-122.222092,37.99523),(-122.2232,37.998),(-122.224146,37.99963),(-122.2261,37.003),(-122.2278,37.007),(-122.2302,37.026),(-122.2323,37.043),(-122.2344,37.059),(-122.235405,37.06427),(-122.2365,37.07)] | Berkeley
+ I- 580 | [(-122.2197,37.99),(-122.22,37.99),(-122.222092,37.99523),(-122.2232,37.998),(-122.224146,37.99963),(-122.2261,37.003),(-122.2278,37.007),(-122.2302,37.026),(-122.2323,37.043),(-122.2344,37.059),(-122.235405,37.06427),(-122.2365,37.07)] | Lafayette
+ I- 580 Ramp | [(-121.8521,37.011),(-121.8479,37.999),(-121.8476,37.999),(-121.8456,37.01),(-121.8455,37.011)] | Oakland
+@@ -136,8 +149,8 @@ SELECT * FROM street;
+ I- 580 Ramp | [(-122.0941,37.897),(-122.0943,37.902)] | Berkeley
+ I- 580 Ramp | [(-122.096,37.888),(-122.0962,37.891),(-122.0964,37.9)] | Berkeley
+ I- 580 Ramp | [(-122.101,37.898),(-122.1005,37.902),(-122.0989,37.911)] | Berkeley
+- I- 580 Ramp | [(-122.1086,37.003),(-122.1068,37.993),(-122.1066,37.992),(-122.1053,37.982)] | Oakland
+ I- 580 Ramp | [(-122.1086,37.003),(-122.1068,37.993),(-122.1066,37.992),(-122.1053,37.982)] | Berkeley
++ I- 580 Ramp | [(-122.1086,37.003),(-122.1068,37.993),(-122.1066,37.992),(-122.1053,37.982)] | Oakland
+ I- 580 Ramp | [(-122.1414,37.383),(-122.1407,37.376),(-122.1403,37.372),(-122.139,37.356)] | Oakland
+ I- 580/I-680 Ramp | ((-121.9207,37.988),(-121.9192,37.016)) | Oakland
+ I- 580/I-680 Ramp | ((-121.9207,37.988),(-121.9192,37.016)) | Oakland
+@@ -158,16 +171,16 @@ SELECT * FROM street;
+ I- 880 | ((-121.9669,37.075),(-121.9663,37.071),(-121.9656,37.065),(-121.9618,37.037),(-121.95689,37),(-121.948,37.933)) | Oakland
+ I- 880 | [(-121.948,37.933),(-121.9471,37.925),(-121.9467,37.923),(-121.946,37.918),(-121.9452,37.912),(-121.937,37.852)] | Oakland
+ I- 880 | [(-122.0219,37.466),(-122.0205,37.447),(-122.020331,37.44447),(-122.020008,37.43962),(-122.0195,37.432),(-122.0193,37.429),(-122.0164,37.393),(-122.010219,37.34771),(-122.0041,37.313)] | Oakland
+- I- 880 | [(-122.0375,37.632),(-122.0359,37.619),(-122.0358,37.616),(-122.034514,37.60409),(-122.031876,37.57965),(-122.031193,37.57332),(-122.03016,37.56375),(-122.02943,37.55698),(-122.028689,37.54929),(-122.027833,37.53908),(-122.025979,37.51698),(-122.0238,37.491)] | Oakland
+ I- 880 | [(-122.0375,37.632),(-122.0359,37.619),(-122.0358,37.616),(-122.034514,37.60409),(-122.031876,37.57965),(-122.031193,37.57332),(-122.03016,37.56375),(-122.02943,37.55698),(-122.028689,37.54929),(-122.027833,37.53908),(-122.025979,37.51698),(-122.0238,37.491)] | Berkeley
++ I- 880 | [(-122.0375,37.632),(-122.0359,37.619),(-122.0358,37.616),(-122.034514,37.60409),(-122.031876,37.57965),(-122.031193,37.57332),(-122.03016,37.56375),(-122.02943,37.55698),(-122.028689,37.54929),(-122.027833,37.53908),(-122.025979,37.51698),(-122.0238,37.491)] | Oakland
++ I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Berkeley
+ I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Oakland
+ I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Oakland
+- I- 880 | [(-122.0612,37.003),(-122.0604,37.991),(-122.0596,37.982),(-122.0585,37.967),(-122.0583,37.961),(-122.0553,37.918),(-122.053635,37.89475),(-122.050759,37.8546),(-122.05,37.844),(-122.0485,37.817),(-122.0483,37.813),(-122.0482,37.811)] | Berkeley
+ I- 880 | [(-122.0831,37.312),(-122.0819,37.296),(-122.081,37.285),(-122.0786,37.248),(-122.078,37.24),(-122.077642,37.23496),(-122.076983,37.22567),(-122.076599,37.22026),(-122.076229,37.21505),(-122.0758,37.209)] | Oakland
+ I- 880 | [(-122.0978,37.528),(-122.096,37.496),(-122.0931,37.453),(-122.09277,37.4496),(-122.090189,37.41442),(-122.0896,37.405),(-122.085,37.34)] | Oakland
+ I- 880 | [(-122.1365,37.902),(-122.1358,37.898),(-122.1333,37.881),(-122.1323,37.874),(-122.1311,37.866),(-122.1308,37.865),(-122.1307,37.864),(-122.1289,37.851),(-122.1277,37.843),(-122.1264,37.834),(-122.1231,37.812),(-122.1165,37.766),(-122.1104,37.72),(-122.109695,37.71094),(-122.109,37.702),(-122.108312,37.69168),(-122.1076,37.681)] | Berkeley
+- I- 880 | [(-122.1755,37.185),(-122.1747,37.178),(-122.1742,37.173),(-122.1692,37.126),(-122.167792,37.11594),(-122.16757,37.11435),(-122.1671,37.111),(-122.1655,37.1),(-122.165169,37.09811),(-122.1641,37.092),(-122.1596,37.061),(-122.158381,37.05275),(-122.155991,37.03657),(-122.1531,37.017),(-122.1478,37.98),(-122.1407,37.932),(-122.1394,37.924),(-122.1389,37.92),(-122.1376,37.91)] | Oakland
+ I- 880 | [(-122.1755,37.185),(-122.1747,37.178),(-122.1742,37.173),(-122.1692,37.126),(-122.167792,37.11594),(-122.16757,37.11435),(-122.1671,37.111),(-122.1655,37.1),(-122.165169,37.09811),(-122.1641,37.092),(-122.1596,37.061),(-122.158381,37.05275),(-122.155991,37.03657),(-122.1531,37.017),(-122.1478,37.98),(-122.1407,37.932),(-122.1394,37.924),(-122.1389,37.92),(-122.1376,37.91)] | Berkeley
++ I- 880 | [(-122.1755,37.185),(-122.1747,37.178),(-122.1742,37.173),(-122.1692,37.126),(-122.167792,37.11594),(-122.16757,37.11435),(-122.1671,37.111),(-122.1655,37.1),(-122.165169,37.09811),(-122.1641,37.092),(-122.1596,37.061),(-122.158381,37.05275),(-122.155991,37.03657),(-122.1531,37.017),(-122.1478,37.98),(-122.1407,37.932),(-122.1394,37.924),(-122.1389,37.92),(-122.1376,37.91)] | Oakland
+ I- 880 | [(-122.2214,37.711),(-122.2202,37.699),(-122.2199,37.695),(-122.219,37.682),(-122.2184,37.672),(-122.2173,37.652),(-122.2159,37.638),(-122.2144,37.616),(-122.2138,37.612),(-122.2135,37.609),(-122.212,37.592),(-122.2116,37.586),(-122.2111,37.581)] | Berkeley
+ I- 880 | [(-122.2707,37.975),(-122.2693,37.972),(-122.2681,37.966),(-122.267,37.962),(-122.2659,37.957),(-122.2648,37.952),(-122.2636,37.946),(-122.2625,37.935),(-122.2617,37.927),(-122.2607,37.921),(-122.2593,37.916),(-122.258,37.911),(-122.2536,37.898),(-122.2432,37.858),(-122.2408,37.845),(-122.2386,37.827),(-122.2374,37.811)] | Berkeley
+ I- 880 Ramp | [(-122.0019,37.301),(-122.002,37.293)] | Oakland
+@@ -175,12 +188,12 @@ SELECT * FROM street;
+ I- 880 Ramp | [(-122.0041,37.313),(-122.0038,37.308),(-122.0039,37.284),(-122.0013,37.287),(-121.9995,37.289)] | Oakland
+ I- 880 Ramp | [(-122.0236,37.488),(-122.0231,37.458),(-122.0227,37.458),(-122.0223,37.452),(-122.0205,37.447)] | Oakland
+ I- 880 Ramp | [(-122.0238,37.491),(-122.0215,37.483),(-122.0211,37.477),(-122.0205,37.447)] | Oakland
++ I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Berkeley
+ I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Oakland
+ I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Oakland
+- I- 880 Ramp | [(-122.059,37.982),(-122.0577,37.984),(-122.0612,37.003)] | Berkeley
++ I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Berkeley
+ I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Oakland
+ I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Oakland
+- I- 880 Ramp | [(-122.0618,37.011),(-122.0631,37.982),(-122.0585,37.967)] | Berkeley
+ I- 880 Ramp | [(-122.085,37.34),(-122.0801,37.316),(-122.081,37.285)] | Oakland
+ I- 880 Ramp | [(-122.085,37.34),(-122.0801,37.316),(-122.081,37.285)] | Oakland
+ I- 880 Ramp | [(-122.085,37.34),(-122.0866,37.316),(-122.0819,37.296)] | Oakland
+@@ -212,26 +225,26 @@ SELECT * FROM street;
+ Livermore Ave | [(-121.7687,37.448),(-121.769,37.375)] | Oakland
+ Livermore Ave | [(-121.772719,37.99085),(-121.7728,37.001)] | Oakland
+ Livermore Ave | [(-121.772719,37.99085),(-121.7728,37.001)] | Oakland
+- Locust St | [(-122.1606,37.007),(-122.1593,37.987)] | Oakland
+ Locust St | [(-122.1606,37.007),(-122.1593,37.987)] | Berkeley
++ Locust St | [(-122.1606,37.007),(-122.1593,37.987)] | Oakland
+ Logan Ct | [(-122.0053,37.492),(-122.0061,37.484)] | Oakland
+ Magnolia St | [(-122.0971,37.5),(-122.0962,37.484)] | Oakland
+ Mandalay Road | [(-122.2322,37.397),(-122.2321,37.403)] | Lafayette
+ Marin Ave | [(-122.2741,37.894),(-122.272,37.901)] | Berkeley
+ Martin Luther King Jr Way | [(-122.2712,37.608),(-122.2711,37.599)] | Berkeley
+ Mattos Dr | [(-122.0005,37.502),(-122.000898,37.49683)] | Oakland
+- Maubert Ave | [(-122.1114,37.009),(-122.1096,37.995)] | Oakland
+ Maubert Ave | [(-122.1114,37.009),(-122.1096,37.995)] | Berkeley
+- McClure Ave | [(-122.1431,37.001),(-122.1436,37.998)] | Oakland
++ Maubert Ave | [(-122.1114,37.009),(-122.1096,37.995)] | Oakland
+ McClure Ave | [(-122.1431,37.001),(-122.1436,37.998)] | Berkeley
++ McClure Ave | [(-122.1431,37.001),(-122.1436,37.998)] | Oakland
+ Medlar Dr | [(-122.0627,37.378),(-122.0625,37.375)] | Oakland
+ Mildred Ct | [(-122.0002,37.388),(-121.9998,37.386)] | Oakland
+ Miller Road | [(-122.0902,37.645),(-122.0865,37.545)] | Berkeley
+ Miramar Ave | [(-122.1009,37.025),(-122.099089,37.03209)] | Oakland
+ Mission Blvd | [(-121.918886,37),(-121.9194,37.976),(-121.9198,37.975)] | Oakland
+ Mission Blvd | [(-121.918886,37),(-121.9194,37.976),(-121.9198,37.975)] | Oakland
+- Mission Blvd | [(-122.0006,37.896),(-121.9989,37.88)] | Oakland
+ Mission Blvd | [(-122.0006,37.896),(-121.9989,37.88)] | Berkeley
++ Mission Blvd | [(-122.0006,37.896),(-121.9989,37.88)] | Oakland
+ Moores Ave | [(-122.0087,37.301),(-122.0094,37.292)] | Oakland
+ National Ave | [(-122.1192,37.5),(-122.1281,37.489)] | Oakland
+ Navajo Ct | [(-121.8779,37.901),(-121.8783,37.9)] | Oakland
+@@ -242,49 +255,49 @@ SELECT * FROM street;
+ Parkridge Dr | [(-122.1438,37.884),(-122.1428,37.9)] | Berkeley
+ Parkside Dr | [(-122.0475,37.603),(-122.0443,37.596)] | Berkeley
+ Paseo Padre Pkwy | [(-121.9143,37.005),(-121.913522,37)] | Oakland
+- Paseo Padre Pkwy | [(-122.0021,37.639),(-121.996,37.628)] | Oakland
+ Paseo Padre Pkwy | [(-122.0021,37.639),(-121.996,37.628)] | Berkeley
++ Paseo Padre Pkwy | [(-122.0021,37.639),(-121.996,37.628)] | Oakland
+ Pearl St | [(-122.2383,37.594),(-122.2366,37.615)] | Berkeley
+ Periwinkle Road | [(-122.0451,37.301),(-122.044758,37.29844)] | Oakland
+ Pimlico Dr | [(-121.8616,37.998),(-121.8618,37.008)] | Oakland
+ Pimlico Dr | [(-121.8616,37.998),(-121.8618,37.008)] | Oakland
+ Portsmouth Ave | [(-122.1064,37.315),(-122.1064,37.308)] | Oakland
+ Proctor Ave | [(-122.2267,37.406),(-122.2251,37.386)] | Lafayette
++ Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Berkeley
+ Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Oakland
+ Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Oakland
+- Railroad Ave | [(-122.0245,37.013),(-122.0234,37.003),(-122.0223,37.993)] | Berkeley
++ Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Berkeley
+ Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Oakland
+ Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Oakland
+- Ranspot Dr | [(-122.0972,37.999),(-122.0959,37)] | Berkeley
+ Redding St | [(-122.1978,37.901),(-122.1975,37.895)] | Berkeley
+- Redwood Road | [(-122.1493,37.98),(-122.1437,37.001)] | Oakland
+ Redwood Road | [(-122.1493,37.98),(-122.1437,37.001)] | Berkeley
++ Redwood Road | [(-122.1493,37.98),(-122.1437,37.001)] | Oakland
+ Roca Dr | [(-122.0335,37.609),(-122.0314,37.599)] | Berkeley
+ Rosedale Ct | [(-121.9232,37.9),(-121.924,37.897)] | Oakland
+ Sacramento St | [(-122.2799,37.606),(-122.2797,37.597)] | Berkeley
+ Saddle Brook Dr | [(-122.1478,37.909),(-122.1454,37.904),(-122.1451,37.888)] | Berkeley
+ Saginaw Ct | [(-121.8803,37.898),(-121.8806,37.901)] | Oakland
+ San Andreas Dr | [(-122.0609,37.9),(-122.0614,37.895)] | Berkeley
++ Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Berkeley
+ Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Oakland
+ Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Oakland
+- Santa Maria Ave | [(-122.0773,37),(-122.0773,37.98)] | Berkeley
+ Shattuck Ave | [(-122.2686,37.904),(-122.2686,37.897)] | Berkeley
+ Sheridan Road | [(-122.2279,37.425),(-122.2253,37.411),(-122.2223,37.377)] | Lafayette
+ Shoreline Dr | [(-122.2657,37.603),(-122.2648,37.6)] | Berkeley
+- Skyline Blvd | [(-122.1738,37.01),(-122.1714,37.996)] | Oakland
+ Skyline Blvd | [(-122.1738,37.01),(-122.1714,37.996)] | Berkeley
++ Skyline Blvd | [(-122.1738,37.01),(-122.1714,37.996)] | Oakland
+ Skyline Dr | [(-122.0277,37.5),(-122.0284,37.498)] | Oakland
+ Skywest Dr | [(-122.1161,37.62),(-122.1123,37.586)] | Berkeley
+ Southern Pacific Railroad | [(-122.3002,37.674),(-122.2999,37.661)] | Berkeley
+ Sp Railroad | [(-121.893564,37.99009),(-121.897,37.016)] | Oakland
+ Sp Railroad | [(-121.893564,37.99009),(-121.897,37.016)] | Oakland
+ Sp Railroad | [(-121.9565,37.898),(-121.9562,37.9)] | Oakland
++ Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Berkeley
+ Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Oakland
+ Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Oakland
+- Sp Railroad | [(-122.0734,37.001),(-122.0734,37.997)] | Berkeley
+ Sp Railroad | [(-122.0914,37.601),(-122.087,37.56),(-122.086408,37.5551)] | Berkeley
+- Sp Railroad | [(-122.137792,37.003),(-122.1365,37.992),(-122.131257,37.94612)] | Oakland
+ Sp Railroad | [(-122.137792,37.003),(-122.1365,37.992),(-122.131257,37.94612)] | Berkeley
++ Sp Railroad | [(-122.137792,37.003),(-122.1365,37.992),(-122.131257,37.94612)] | Oakland
+ Sp Railroad | [(-122.1947,37.497),(-122.193328,37.4848)] | Oakland
+ Stanton Ave | [(-122.100392,37.0697),(-122.099513,37.06052)] | Oakland
+ State Hwy 123 | [(-122.3004,37.986),(-122.2998,37.969),(-122.2995,37.962),(-122.2992,37.952),(-122.299,37.942),(-122.2987,37.935),(-122.2984,37.924),(-122.2982,37.92),(-122.2976,37.904),(-122.297,37.88),(-122.2966,37.869),(-122.2959,37.848),(-122.2961,37.843)] | Berkeley
+@@ -316,28 +329,15 @@ SELECT * FROM street;
+ Welch Creek Road | [(-121.7695,37.386),(-121.7737,37.413)] | Oakland
+ Welch Creek Road | [(-121.7695,37.386),(-121.7737,37.413)] | Oakland
+ West Loop Road | [(-122.0576,37.604),(-122.0602,37.586)] | Berkeley
++ Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Berkeley
+ Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Oakland
+ Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Oakland
+- Western Pacific Railroad Spur | [(-122.0394,37.018),(-122.0394,37.961)] | Berkeley
+ Whitlock Creek | [(-121.74683,37.91276),(-121.733107,37)] | Oakland
+ Whitlock Creek | [(-121.74683,37.91276),(-121.733107,37)] | Oakland
+ Willimet Way | [(-122.0964,37.517),(-122.0949,37.493)] | Oakland
+- Wisconsin St | [(-122.1994,37.017),(-122.1975,37.998),(-122.1971,37.994)] | Oakland
+ Wisconsin St | [(-122.1994,37.017),(-122.1975,37.998),(-122.1971,37.994)] | Berkeley
++ Wisconsin St | [(-122.1994,37.017),(-122.1975,37.998),(-122.1971,37.994)] | Oakland
+ Wp Railroad | [(-122.254,37.902),(-122.2506,37.891)] | Berkeley
+- 100th Ave | [(-122.1657,37.429),(-122.1647,37.432)] | Oakland
+- 107th Ave | [(-122.1555,37.403),(-122.1531,37.41)] | Oakland
+- 14th St | [(-122.299,37.147),(-122.3,37.148)] | Lafayette
+- 19th Ave | [(-122.2366,37.897),(-122.2359,37.905)] | Berkeley
+- 1st St | [(-121.75508,37.89294),(-121.753581,37.90031)] | Oakland
+- 5th St | [(-122.278,37),(-122.2792,37.005),(-122.2803,37.009)] | Lafayette
+- 5th St | [(-122.296,37.615),(-122.2953,37.598)] | Berkeley
+- 82nd Ave | [(-122.1695,37.596),(-122.1681,37.603)] | Berkeley
+- 85th Ave | [(-122.1877,37.466),(-122.186,37.476)] | Oakland
+- 89th Ave | [(-122.1822,37.459),(-122.1803,37.471)] | Oakland
+- 98th Ave | [(-122.1568,37.498),(-122.1558,37.502)] | Oakland
+- 98th Ave | [(-122.1693,37.438),(-122.1682,37.444)] | Oakland
+- 98th Ave | [(-122.2001,37.258),(-122.1974,37.27)] | Lafayette
+ (333 rows)
+
+ SELECT name, #thepath FROM iexit ORDER BY name COLLATE "C", 2;
+diff --git a/src/test/regress/expected/txid.out b/src/test/regress/expected/txid.out
+index 95ba66e95ee..2ea4434f513 100644
+--- a/src/test/regress/expected/txid.out
++++ b/src/test/regress/expected/txid.out
+@@ -238,9 +238,11 @@ SELECT txid_snapshot '1:9223372036854775807:3';
+ (1 row)
+
+ SELECT txid_snapshot '1:9223372036854775808:3';
+-ERROR: invalid input syntax for type pg_snapshot: "1:9223372036854775808:3"
+-LINE 1: SELECT txid_snapshot '1:9223372036854775808:3';
+- ^
++ txid_snapshot
++-------------------------
++ 1:9223372036854775808:3
++(1 row)
++
+ -- test txid_current_if_assigned
+ BEGIN;
+ SELECT txid_current_if_assigned() IS NULL;
+diff --git a/src/test/regress/expected/type_sanity.out b/src/test/regress/expected/type_sanity.out
+index 88d8f6c32d6..0c4b994343f 100644
+--- a/src/test/regress/expected/type_sanity.out
++++ b/src/test/regress/expected/type_sanity.out
+@@ -19,7 +19,7 @@ WHERE t1.typnamespace = 0 OR
+ (t1.typlen <= 0 AND t1.typlen != -1 AND t1.typlen != -2) OR
+ (t1.typtype not in ('b', 'c', 'd', 'e', 'm', 'p', 'r')) OR
+ NOT t1.typisdefined OR
+- (t1.typalign not in ('c', 's', 'i', 'd')) OR
++ (t1.typalign not in ('c', 's', 'i', 'd', 'x')) OR
+ (t1.typstorage not in ('p', 'x', 'e', 'm'));
+ oid | typname
+ -----+---------
+@@ -32,7 +32,8 @@ WHERE t1.typbyval AND
+ (t1.typlen != 1 OR t1.typalign != 'c') AND
+ (t1.typlen != 2 OR t1.typalign != 's') AND
+ (t1.typlen != 4 OR t1.typalign != 'i') AND
+- (t1.typlen != 8 OR t1.typalign != 'd');
++ (t1.typlen != 8 OR t1.typalign != 'd') AND
++ (t1.typlen != 8 OR t1.typalign != 'x');
+ oid | typname
+ -----+---------
+ (0 rows)
+diff --git a/src/test/regress/expected/xid.out b/src/test/regress/expected/xid.out
+index 835077e9d57..0154990d1af 100644
+--- a/src/test/regress/expected/xid.out
++++ b/src/test/regress/expected/xid.out
+@@ -8,9 +8,9 @@ select '010'::xid,
+ '42'::xid8,
+ '0xffffffffffffffff'::xid8,
+ '-1'::xid8;
+- xid | xid | xid | xid | xid8 | xid8 | xid8 | xid8
+------+-----+------------+------------+------+------+----------------------+----------------------
+- 8 | 42 | 4294967295 | 4294967295 | 8 | 42 | 18446744073709551615 | 18446744073709551615
++ xid | xid | xid | xid | xid8 | xid8 | xid8 | xid8
++-----+-----+------------+----------------------+------+------+----------------------+----------------------
++ 8 | 42 | 4294967295 | 18446744073709551615 | 8 | 42 | 18446744073709551615 | 18446744073709551615
+ (1 row)
+
+ -- garbage values
+@@ -43,10 +43,10 @@ SELECT pg_input_is_valid('asdf', 'xid');
+ f
+ (1 row)
+
+-SELECT * FROM pg_input_error_info('0xffffffffff', 'xid');
+- message | detail | hint | sql_error_code
+----------------------------------------------------+--------+------+----------------
+- value "0xffffffffff" is out of range for type xid | | | 22003
++SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid');
++ message | detail | hint | sql_error_code
++-------------------------------------------------------------+--------+------+----------------
++ value "0xffffffffffffffffffff" is out of range for type xid | | | 22003
+ (1 row)
+
+ SELECT pg_input_is_valid('42', 'xid8');
+@@ -441,9 +441,11 @@ SELECT pg_snapshot '1:9223372036854775807:3';
+ (1 row)
+
+ SELECT pg_snapshot '1:9223372036854775808:3';
+-ERROR: invalid input syntax for type pg_snapshot: "1:9223372036854775808:3"
+-LINE 1: SELECT pg_snapshot '1:9223372036854775808:3';
+- ^
++ pg_snapshot
++-------------------------
++ 1:9223372036854775808:3
++(1 row)
++
+ -- test pg_current_xact_id_if_assigned
+ BEGIN;
+ SELECT pg_current_xact_id_if_assigned() IS NULL;
+diff --git a/src/test/regress/expected/xid64.out b/src/test/regress/expected/xid64.out
+new file mode 100644
+index 00000000000..c30c5b57399
+--- /dev/null
++++ b/src/test/regress/expected/xid64.out
+@@ -0,0 +1,92 @@
++---
++--- Unit test for xid64 functions
++---
++-- directory paths and dlsuffix are passed to us in environment variables
++\getenv libdir PG_LIBDIR
++\getenv dlsuffix PG_DLSUFFIX
++\set regresslib :libdir '/regress' :dlsuffix
++CREATE FUNCTION xid64_test_1(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_1' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_2(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_2' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_double_xmax(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_double_xmax' LANGUAGE C STRICT;
++---
++--- Check page consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(a int);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++INSERT INTO test_xid64_table(a) SELECT a FROM generate_series(1, 1000) AS a;
++SELECT xid64_test_1('test_xid64_table');
++INFO: test 1: page is converted to xid64 format
++ xid64_test_1
++--------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++---
++--- Check tuples consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(s serial, i int, t text);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++DO $$
++BEGIN
++ FOR j IN 1..20 LOOP
++ INSERT INTO test_xid64_table(i, t) VALUES (random()::int, md5(random()::text));
++ COMMIT;
++ END LOOP;
++END $$;
++DO $$
++BEGIN
++ FOR j IN 1..10 LOOP
++ DELETE FROM test_xid64_table WHERE ctid IN (SELECT ctid FROM test_xid64_table TABLESAMPLE BERNOULLI (5));
++ COMMIT;
++ END LOOP;
++END $$;
++SELECT xid64_test_2('test_xid64_table');
++ xid64_test_2
++--------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++---
++--- Check tuples consistency after conversion to double xmax (on full page)
++---
++CREATE UNLOGGED TABLE test_xid64_table(i int);
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table SELECT i FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++SELECT xid64_test_2('test_xid64_table');
++ xid64_test_2
++--------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++CREATE UNLOGGED TABLE test_xid64_table(i text);
++INSERT INTO test_xid64_table(i) VALUES ('NNBABCDSDFGHJKLP');
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table(i) SELECT 'A' FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++SELECT xid64_test_double_xmax('test_xid64_table');
++INFO: test double xmax: page 0 is converted into double xmax format
++INFO: test double xmax: end
++ xid64_test_double_xmax
++------------------------
++
++(1 row)
++
++DROP TABLE test_xid64_table;
++DROP FUNCTION xid64_test_1(rel regclass);
++DROP FUNCTION xid64_test_2(rel regclass);
++DROP FUNCTION xid64_test_double_xmax(rel regclass);
+diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
+index 81e4222d26a..881b5825892 100644
+--- a/src/test/regress/parallel_schedule
++++ b/src/test/regress/parallel_schedule
+@@ -28,7 +28,7 @@ test: strings md5 numerology point lseg line box path polygon circle date time t
+ # geometry depends on point, lseg, line, box, path, polygon, circle
+ # horology depends on date, time, timetz, timestamp, timestamptz, interval
+ # ----------
+-test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid mvcc database stats_import
++test: geometry horology tstypes regex type_sanity opr_sanity misc_sanity comments expressions unicode xid xid64 mvcc database stats_import
+
+ # ----------
+ # Load huge amounts of data
+diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c
+index 8309166f5b2..f40c3fccbde 100644
+--- a/src/test/regress/regress.c
++++ b/src/test/regress/regress.c
+@@ -21,6 +21,9 @@
+
+ #include "access/detoast.h"
+ #include "access/htup_details.h"
++#include "access/transam.h"
++#include "access/xact.h"
++#include "catalog/catalog.h"
+ #include "catalog/namespace.h"
+ #include "catalog/pg_operator.h"
+ #include "catalog/pg_type.h"
+@@ -38,6 +41,7 @@
+ #include "port/atomics.h"
+ #include "storage/spin.h"
+ #include "utils/array.h"
++#include "storage/checksum.h"
+ #include "utils/builtins.h"
+ #include "utils/geo_decls.h"
+ #include "utils/memutils.h"
+@@ -574,6 +578,7 @@ make_tuple_indirect(PG_FUNCTION_ARGS)
+ tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
+ ItemPointerSetInvalid(&(tuple.t_self));
+ tuple.t_tableOid = InvalidOid;
++ HeapTupleSetZeroXids(&tuple);
+ tuple.t_data = rec;
+
+ values = (Datum *) palloc(ncolumns * sizeof(Datum));
+@@ -1156,3 +1161,296 @@ binary_coercible(PG_FUNCTION_ARGS)
+
+ PG_RETURN_BOOL(IsBinaryCoercible(srctype, targettype));
+ }
++
++#include "access/hio.h"
++#include "access/relation.h"
++#include "storage/bufmgr.h"
++#include "utils/rel.h"
++
++static void
++CheckNewPage(char *msg, Page page)
++{
++ uint16 size;
++
++ if (PageGetPageLayoutVersion(page) != PG_PAGE_LAYOUT_VERSION)
++ elog(ERROR, "%s: page version is %d, expected %d ",
++ msg, PageGetPageLayoutVersion(page), PG_PAGE_LAYOUT_VERSION);
++
++ size = PageGetSpecialSize(page);
++ if (size == MAXALIGN(sizeof(HeapPageSpecialData)))
++ elog(INFO, "%s: page is converted to xid64 format", msg);
++ else if (HeapPageIsDoubleXmax(page))
++ elog(INFO, "%s: page is converted into double xmax format", msg);
++ else
++ elog(ERROR, "%s: converted page has pageSpecial size %u, expected %llu",
++ msg, size,
++ (unsigned long long) MAXALIGN(sizeof(HeapPageSpecialData)));
++}
++
++/*
++ * Get page from relation.
++ * Make this page look like in 32-bit xid format.
++ * Convert it to 64-bit xid format.
++ * Run basic checks.
++ */
++PG_FUNCTION_INFO_V1(xid64_test_1);
++Datum
++xid64_test_1(PG_FUNCTION_ARGS)
++{
++ Oid relid;
++ Relation rel;
++ Buffer buf;
++ Page page;
++ PageHeader hdr;
++
++ relid = PG_GETARG_OID(0);
++ rel = relation_open(relid, AccessExclusiveLock);
++ buf = ReadBuffer(rel, 0);
++ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
++
++ page = BufferGetPage(buf);
++ hdr = (PageHeader) page;
++
++ if (PageGetSpecialSize(page) != MAXALIGN(sizeof(HeapPageSpecialData)))
++ elog(ERROR, "page expected in new format");
++
++ if (PageGetPageLayoutVersion(page) != PG_PAGE_LAYOUT_VERSION)
++ elog(ERROR, "unknown page version (%u)",
++ PageGetPageLayoutVersion(page));
++
++ hdr->pd_special = BLCKSZ;
++ PageSetPageSizeAndVersion(page, BLCKSZ, PG_PAGE_LAYOUT_VERSION - 1);
++ hdr->pd_checksum = 0; //turn off check sum check performed in the convert_page
++ convert_page(rel, page, buf, 0);
++
++ CheckNewPage("test 1", page);
++
++ UnlockReleaseBuffer(buf);
++ relation_close(rel, AccessExclusiveLock);
++
++ PG_RETURN_VOID();
++}
++
++typedef struct TupleCheckValues
++{
++ TransactionId xmin;
++ TransactionId xmax;
++} TupleCheckValues;
++
++typedef struct RelCheckValues
++{
++ TupleCheckValues *tcv;
++ Size ntuples;
++} RelCheckValues;
++
++static RelCheckValues
++FillRelCheckValues(Relation rel, Buffer buffer, Page page)
++{
++ RelCheckValues set;
++ Size n;
++
++#define DEFAULT_SET_SIZE 64
++ n = DEFAULT_SET_SIZE;
++ set.ntuples = 0;
++ set.tcv = palloc(sizeof(set.tcv[0]) * n);
++
++ {
++ OffsetNumber maxoff,
++ offnum;
++ HeapTupleHeader tuphdr;
++ ItemId itemid;
++ HeapTupleData tuple;
++ TransactionId xmin,
++ xmax;
++
++ maxoff = PageGetMaxOffsetNumber(page);
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= maxoff;
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++ tuphdr = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuple.t_data = tuphdr;
++ tuple.t_len = ItemIdGetLength(itemid);
++ tuple.t_tableOid = RelationGetRelid(rel);
++
++ if (HeapPageGetSpecial(page) == heapDoubleXmaxSpecial)
++ {
++ xmin = tuphdr->t_choice.t_heap.t_xmin;
++ xmax = tuphdr->t_choice.t_heap.t_xmax;
++ }
++ else
++ {
++ HeapTupleCopyXidsFromPage(buffer, &tuple, page,
++ IsToastRelation(rel));
++
++ xmin = HeapTupleGetRawXmin(&tuple);
++ xmax = HeapTupleGetRawXmax(&tuple);
++ }
++
++ if (set.ntuples == n)
++ {
++ n *= 2;
++ set.tcv = repalloc(set.tcv, sizeof(set.tcv[0]) * n);
++ }
++
++ set.tcv[set.ntuples].xmin = xmin;
++ set.tcv[set.ntuples].xmax = xmax;
++ set.ntuples++;
++ }
++ }
++
++ return set;
++}
++
++/*
++ * Test xmin/xmax invariant when converting page from 32bit xid to 64xid.
++ *
++ * Scenario:
++ * - enforce all relation pages to 32bit xid format, discarding pd_xid_base and
++ * pd_multi_base
++ * - store all xmin/xmax in array
++ * - convert all the pages from relation into 64xid format
++ * - store all new xmin/xmax in array
++ * - compare old and new xmin/xmax
++ *
++ * NOTE: inital xid value does not affect test as pd_xid_base/pd_multi_base
++ * discarded.
++ */
++PG_FUNCTION_INFO_V1(xid64_test_2);
++Datum
++xid64_test_2(PG_FUNCTION_ARGS)
++{
++ Oid relid;
++ Relation rel;
++ RelCheckValues before,
++ after;
++ BlockNumber pageno,
++ npages;
++ Size i;
++
++ relid = PG_GETARG_OID(0);
++ rel = relation_open(relid, AccessExclusiveLock);
++ npages = RelationGetNumberOfBlocks(rel);
++
++ for (pageno = 0; pageno != npages; ++pageno)
++ {
++ Buffer buf;
++ Page page;
++ PageHeader hdr;
++
++ /* get page */
++ buf = ReadBuffer(rel, pageno);
++ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
++ page = BufferGetPage(buf);
++ hdr = (PageHeader) page;
++
++ /* make page look like 32-bit xid page */
++ hdr->pd_special = BLCKSZ;
++ PageSetPageSizeAndVersion(page, BLCKSZ, PG_PAGE_LAYOUT_VERSION - 1);
++
++ before = FillRelCheckValues(rel, buf, page);
++ hdr->pd_checksum = pg_checksum_page((char *) page, pageno);
++ convert_page(rel, page, buf, pageno);
++ after = FillRelCheckValues(rel, buf, page);
++
++ /* check */
++ if (before.ntuples != after.ntuples)
++ elog(ERROR, "numer of tuples must be equal");
++
++ for (i = 0; i != before.ntuples; ++i)
++ {
++ if (before.tcv[i].xmin != after.tcv[i].xmin && after.tcv[i].xmin)
++ elog(ERROR, "old and new xmin does not match (%llu != %llu)",
++ (unsigned long long) before.tcv[i].xmin,
++ (unsigned long long) after.tcv[i].xmin);
++
++ if (before.tcv[i].xmax != after.tcv[i].xmax)
++ elog(ERROR, "old and new xmax does not match (%llu != %llu)",
++ (unsigned long long) before.tcv[i].xmax,
++ (unsigned long long) after.tcv[i].xmax);
++ }
++
++ Assert(npages != 0);
++ pfree(before.tcv);
++ pfree(after.tcv);
++
++ UnlockReleaseBuffer(buf);
++ }
++
++ relation_close(rel, AccessExclusiveLock);
++
++ PG_RETURN_VOID();
++}
++
++PG_FUNCTION_INFO_V1(xid64_test_double_xmax);
++Datum
++xid64_test_double_xmax(PG_FUNCTION_ARGS)
++{
++ Oid relid;
++ Relation rel;
++ BlockNumber pageno,
++ npages;
++ bool found;
++
++ relid = PG_GETARG_OID(0);
++ rel = relation_open(relid, AccessExclusiveLock);
++ npages = RelationGetNumberOfBlocks(rel);
++ found = false;
++
++ for (pageno = 0; pageno != npages; ++pageno)
++ {
++ Buffer buf;
++ Page page;
++ PageHeader hdr;
++ ItemId itemid;
++ OffsetNumber offnum;
++ HeapTupleHeader tuphdr;
++
++ buf = ReadBuffer(rel, pageno);
++ LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
++ page = BufferGetPage(buf);
++ hdr = (PageHeader) page;
++
++ if (pageno == 0)
++ {
++ itemid = PageGetItemId(page, FirstOffsetNumber);
++ itemid->lp_len += 16; /* Move to overlap special */
++ }
++
++ for (offnum = FirstOffsetNumber;
++ offnum <= PageGetMaxOffsetNumber(page);
++ offnum = OffsetNumberNext(offnum))
++ {
++ itemid = PageGetItemId(page, offnum);
++ tuphdr = (HeapTupleHeader) PageGetItem(page, itemid);
++ tuphdr->t_infomask |= HEAP_XMIN_COMMITTED;
++ }
++
++ hdr->pd_special = BLCKSZ;
++ PageSetPageSizeAndVersion(page, BLCKSZ, PG_PAGE_LAYOUT_VERSION - 1);
++ hdr->pd_checksum = pg_checksum_page((char *) page, pageno);
++
++ convert_page(rel, page, buf, pageno);
++
++ if (HeapPageIsDoubleXmax(page))
++ {
++ found = true;
++ elog(INFO, "test double xmax: page %u is converted into double xmax format",
++ pageno);
++ }
++
++ UnlockReleaseBuffer(buf);
++ }
++
++ if (!found)
++ elog(ERROR, "test double xmax: failed, no double xmax");
++
++ Assert(npages != 0);
++ elog(INFO, "test double xmax: end");
++
++ relation_close(rel, AccessExclusiveLock);
++
++ PG_RETURN_VOID();
++}
+diff --git a/src/test/regress/sql/indirect_toast.sql b/src/test/regress/sql/indirect_toast.sql
+index 3e2f6c02375..ea087b51282 100644
+--- a/src/test/regress/sql/indirect_toast.sql
++++ b/src/test/regress/sql/indirect_toast.sql
+@@ -76,7 +76,18 @@ SELECT substring(indtoasttest::text, 1, 200) FROM indtoasttest;
+ VACUUM FREEZE indtoasttest;
+ SELECT substring(indtoasttest::text, 1, 200) FROM indtoasttest;
+
++create or replace function random_string(len integer) returns text as $$
++select substr((select string_agg(r,'') from (select random()::text as r from generate_series(1,(len+15)/16)) s1), 1, len);
++$$ language sql;
++
++create table toasttest_main(t text);
++alter table toasttest_main alter column t set storage main;
++
++insert into toasttest_main (select random_string(len) from generate_series(7000,8000) len);
++
+ DROP TABLE indtoasttest;
++DROP TABLE toasttest_main;
+ DROP FUNCTION update_using_indirect();
++DROP FUNCTION random_string(integer);
+
+ RESET default_toast_compression;
+diff --git a/src/test/regress/sql/insert.sql b/src/test/regress/sql/insert.sql
+index 2b086eeb6d7..d8bb0a9222e 100644
+--- a/src/test/regress/sql/insert.sql
++++ b/src/test/regress/sql/insert.sql
+@@ -55,7 +55,7 @@ INSERT INTO large_tuple_test (select 3, NULL);
+
+ -- now this tuple won't fit on the second page, but the insert should
+ -- still succeed by extending the relation
+-INSERT INTO large_tuple_test (select 4, repeat('a', 8126));
++INSERT INTO large_tuple_test (select 4, repeat('a', 8112));
+
+ DROP TABLE large_tuple_test;
+
+@@ -674,3 +674,18 @@ alter table returningwrtest2 drop c;
+ alter table returningwrtest attach partition returningwrtest2 for values in (2);
+ insert into returningwrtest values (2, 'foo') returning returningwrtest;
+ drop table returningwrtest;
++
++-- Check for MaxHeapTupleSize
++create table maxheaptuplesize_test(value text);
++alter table maxheaptuplesize_test alter column value set storage external;
++insert into maxheaptuplesize_test values (repeat('x', 8104));
++insert into maxheaptuplesize_test values (repeat('x', 8112));
++insert into maxheaptuplesize_test values (repeat('x', 8120));
++insert into maxheaptuplesize_test values (repeat('x', 8128));
++insert into maxheaptuplesize_test values (repeat('x', 8136));
++insert into maxheaptuplesize_test values (repeat('x', 8144));
++insert into maxheaptuplesize_test values (repeat('x', 8152));
++insert into maxheaptuplesize_test values (repeat('x', 8160));
++insert into maxheaptuplesize_test values (repeat('x', 8168));
++insert into maxheaptuplesize_test values (repeat('x', 8176));
++drop table maxheaptuplesize_test;
+diff --git a/src/test/regress/sql/select_views.sql b/src/test/regress/sql/select_views.sql
+index e742f136990..a94bd7259c9 100644
+--- a/src/test/regress/sql/select_views.sql
++++ b/src/test/regress/sql/select_views.sql
+@@ -3,7 +3,7 @@
+ -- test the views defined in CREATE_VIEWS
+ --
+
+-SELECT * FROM street;
++SELECT * FROM street ORDER BY name COLLATE "C", thepath::text COLLATE "C", cname COLLATE "C";
+
+ SELECT name, #thepath FROM iexit ORDER BY name COLLATE "C", 2;
+
+diff --git a/src/test/regress/sql/type_sanity.sql b/src/test/regress/sql/type_sanity.sql
+index e88d6cbe49d..bbc2213b546 100644
+--- a/src/test/regress/sql/type_sanity.sql
++++ b/src/test/regress/sql/type_sanity.sql
+@@ -22,7 +22,7 @@ WHERE t1.typnamespace = 0 OR
+ (t1.typlen <= 0 AND t1.typlen != -1 AND t1.typlen != -2) OR
+ (t1.typtype not in ('b', 'c', 'd', 'e', 'm', 'p', 'r')) OR
+ NOT t1.typisdefined OR
+- (t1.typalign not in ('c', 's', 'i', 'd')) OR
++ (t1.typalign not in ('c', 's', 'i', 'd', 'x')) OR
+ (t1.typstorage not in ('p', 'x', 'e', 'm'));
+
+ -- Look for "pass by value" types that can't be passed by value.
+@@ -33,7 +33,8 @@ WHERE t1.typbyval AND
+ (t1.typlen != 1 OR t1.typalign != 'c') AND
+ (t1.typlen != 2 OR t1.typalign != 's') AND
+ (t1.typlen != 4 OR t1.typalign != 'i') AND
+- (t1.typlen != 8 OR t1.typalign != 'd');
++ (t1.typlen != 8 OR t1.typalign != 'd') AND
++ (t1.typlen != 8 OR t1.typalign != 'x');
+
+ -- Look for "toastable" types that aren't varlena.
+
+diff --git a/src/test/regress/sql/xid.sql b/src/test/regress/sql/xid.sql
+index 9f716b3653a..9b94cb9a4a8 100644
+--- a/src/test/regress/sql/xid.sql
++++ b/src/test/regress/sql/xid.sql
+@@ -19,7 +19,7 @@ select 'asdf'::xid8;
+ -- Also try it with non-error-throwing API
+ SELECT pg_input_is_valid('42', 'xid');
+ SELECT pg_input_is_valid('asdf', 'xid');
+-SELECT * FROM pg_input_error_info('0xffffffffff', 'xid');
++SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid');
+ SELECT pg_input_is_valid('42', 'xid8');
+ SELECT pg_input_is_valid('asdf', 'xid8');
+ SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid8');
+diff --git a/src/test/regress/sql/xid64.sql b/src/test/regress/sql/xid64.sql
+new file mode 100644
+index 00000000000..caa97a0ed99
+--- /dev/null
++++ b/src/test/regress/sql/xid64.sql
+@@ -0,0 +1,84 @@
++---
++--- Unit test for xid64 functions
++---
++
++-- directory paths and dlsuffix are passed to us in environment variables
++\getenv libdir PG_LIBDIR
++\getenv dlsuffix PG_DLSUFFIX
++
++\set regresslib :libdir '/regress' :dlsuffix
++
++CREATE FUNCTION xid64_test_1(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_1' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_2(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_2' LANGUAGE C STRICT;
++CREATE FUNCTION xid64_test_double_xmax(rel regclass) RETURNS VOID
++ AS :'regresslib', 'xid64_test_double_xmax' LANGUAGE C STRICT;
++
++---
++--- Check page consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(a int);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++INSERT INTO test_xid64_table(a) SELECT a FROM generate_series(1, 1000) AS a;
++SELECT xid64_test_1('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++---
++--- Check tuples consistency after conversion
++---
++CREATE UNLOGGED TABLE test_xid64_table(s serial, i int, t text);
++ALTER TABLE test_xid64_table SET (autovacuum_enabled = false);
++
++DO $$
++BEGIN
++ FOR j IN 1..20 LOOP
++ INSERT INTO test_xid64_table(i, t) VALUES (random()::int, md5(random()::text));
++ COMMIT;
++ END LOOP;
++END $$;
++
++DO $$
++BEGIN
++ FOR j IN 1..10 LOOP
++ DELETE FROM test_xid64_table WHERE ctid IN (SELECT ctid FROM test_xid64_table TABLESAMPLE BERNOULLI (5));
++ COMMIT;
++ END LOOP;
++END $$;
++
++SELECT xid64_test_2('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++---
++--- Check tuples consistency after conversion to double xmax (on full page)
++---
++CREATE UNLOGGED TABLE test_xid64_table(i int);
++
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table SELECT i FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++
++SELECT xid64_test_2('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++CREATE UNLOGGED TABLE test_xid64_table(i text);
++INSERT INTO test_xid64_table(i) VALUES ('NNBABCDSDFGHJKLP');
++
++DO $$
++BEGIN
++ FOR j IN 1..40 LOOP
++ INSERT INTO test_xid64_table(i) SELECT 'A' FROM generate_series(1, 100) AS i;
++ COMMIT;
++ END LOOP;
++END $$;
++
++SELECT xid64_test_double_xmax('test_xid64_table');
++DROP TABLE test_xid64_table;
++
++DROP FUNCTION xid64_test_1(rel regclass);
++DROP FUNCTION xid64_test_2(rel regclass);
++DROP FUNCTION xid64_test_double_xmax(rel regclass);
+diff --git a/src/test/xid-64/.gitignore b/src/test/xid-64/.gitignore
+new file mode 100644
+index 00000000000..0d41f282aa3
+--- /dev/null
++++ b/src/test/xid-64/.gitignore
+@@ -0,0 +1,8 @@
++# Generated subdirectories
++/tmp_check/
++/results/
++/log/
++
++# Note: regression.* are only left behind on a failure; that's why they're not ignored
++#/regression.diffs
++#/regression.out
+diff --git a/src/test/xid-64/Makefile b/src/test/xid-64/Makefile
+new file mode 100644
+index 00000000000..3b1e50dfc0d
+--- /dev/null
++++ b/src/test/xid-64/Makefile
+@@ -0,0 +1,22 @@
++#-------------------------------------------------------------------------
++#
++# Makefile for src/test/xid-64
++#
++# Copyright (c) 2018, Postgres Professional
++#
++# src/test/xid-64/Makefile
++#
++#-------------------------------------------------------------------------
++
++subdir = src/test/xid-64
++top_builddir = ../../..
++include $(top_builddir)/src/Makefile.global
++
++check:
++ $(prove_check)
++
++installcheck:
++ $(prove_installcheck)
++
++clean distclean maintainer-clean:
++ rm -rf tmp_check
+diff --git a/src/test/xid-64/README b/src/test/xid-64/README
+new file mode 100644
+index 00000000000..01c0a1a1f74
+--- /dev/null
++++ b/src/test/xid-64/README
+@@ -0,0 +1,16 @@
++src/test/xid-64/README
++
++Regression tests for 64-bit XIDs
++=============================================
++
++This directory contains a test suite for 64-bit xids.
++
++Running the tests
++=================
++
++ make check
++
++NOTE: This creates a temporary installation, and some tests may
++create one or multiple nodes.
++
++NOTE: This requires the --enable-tap-tests argument to configure.
+diff --git a/src/test/xid-64/meson.build b/src/test/xid-64/meson.build
+new file mode 100644
+index 00000000000..63a780b69e8
+--- /dev/null
++++ b/src/test/xid-64/meson.build
+@@ -0,0 +1,16 @@
++tests += {
++ 'name': 'xid-64',
++ 'sd': meson.current_source_dir(),
++ 'bd': meson.current_build_dir(),
++ 'tap': {
++ 'tests': [
++ 't/001_test_large_xids.pl',
++ 't/002_test_gucs.pl',
++ 't/003_test_integrity.pl',
++ 't/004_test_relminmxid.pl',
++ 't/005_stream_subxact.pl',
++ 't/006_zeropage.pl',
++ 't/007_first_multi.pl',
++ ],
++ },
++}
+diff --git a/src/test/xid-64/t/002_test_gucs.pl b/src/test/xid-64/t/002_test_gucs.pl
+new file mode 100644
+index 00000000000..93413892336
+--- /dev/null
++++ b/src/test/xid-64/t/002_test_gucs.pl
+@@ -0,0 +1,79 @@
++# Tests for guc boundary values
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++use bigint;
++
++sub command_output
++{
++ my ($cmd) = @_;
++ my ($stdout, $stderr);
++ print("# Running: " . join(" ", @{$cmd}) . "\n");
++ my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
++ ok($result, "@$cmd exit code 0");
++ is($stderr, '', "@$cmd no stderr");
++ return $stdout;
++}
++
++sub set_guc
++{
++ my ($node, $guc, $val) = @_;
++ print("SET $guc = $val\n");
++ $node->safe_psql('postgres', "ALTER SYSTEM SET $guc = $val");
++ $node->restart();
++}
++
++sub test_pgbench
++{
++ my ($node) = @_;
++ $node->command_ok(
++ [ qw(pgbench --progress=5 --transactions=1000 --jobs=5 --client=5) ],
++ 'pgbench finished without errors');
++}
++
++my @guc_vals = (
++ [ "autovacuum_freeze_max_age", 100000, 2**63 - 1 ],
++ [ "autovacuum_multixact_freeze_max_age", 10000, 2**63 - 1 ],
++ [ "vacuum_freeze_min_age", 0, 2**63 - 1 ],
++ [ "vacuum_freeze_table_age", 0, 2**63 - 1 ],
++ [ "vacuum_multixact_freeze_min_age", 0, 2**63 - 1 ],
++ [ "vacuum_multixact_freeze_table_age", 0, 2**63 -1 ]
++);
++
++my $START_VAL = 2**32;
++my $MAX_VAL = 2**62;
++
++my $ixid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imxid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imoff = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++
++# Initialize master node
++my $node = PostgreSQL::Test::Cluster->new('master');
++$node->init;
++# Disable logging of all statements to avoid log bloat during pgbench
++$node->append_conf('postgresql.conf', "log_statement = none");
++$node->start;
++
++# Fill the test database with the pgbench data
++$node->command_ok(
++ [ qw(pgbench --initialize --scale=10) ],
++ 'pgbench finished without errors');
++
++# Test all GUCs with minimum, maximum and random value inbetween
++# (run pgbench for every configuration setting)
++foreach my $gi (0 .. $#guc_vals) {
++ print($guc_vals[$gi][0]); print("\n");
++ my $guc = $guc_vals[$gi][0];
++ my $minval = $guc_vals[$gi][1];
++ my $maxval = $guc_vals[$gi][2];
++ set_guc($node, $guc, $minval);
++ test_pgbench($node);
++ set_guc($node, $guc, $maxval);
++ test_pgbench($node);
++ set_guc($node, $guc, $minval + int(rand($maxval - $minval)));
++ test_pgbench($node);
++}
++
++done_testing();
+diff --git a/src/test/xid-64/t/003_test_integrity.pl b/src/test/xid-64/t/003_test_integrity.pl
+new file mode 100644
+index 00000000000..5b0789688ed
+--- /dev/null
++++ b/src/test/xid-64/t/003_test_integrity.pl
+@@ -0,0 +1,58 @@
++# Check integrity after dump/restore with different xids
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++use File::Compare;
++
++my $tempdir = PostgreSQL::Test::Utils::tempdir;
++use bigint;
++
++my $START_VAL = 2**32;
++my $MAX_VAL = 2**62;
++
++my $ixid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imxid = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++my $imoff = $START_VAL + int(rand($MAX_VAL - $START_VAL));
++
++# Initialize master node
++my $node = PostgreSQL::Test::Cluster->new('master');
++$node->init();
++$node->start;
++
++# Create a database and fill it with the pgbench data
++$node->safe_psql('postgres', "CREATE DATABASE pgbench_db");
++$node->command_ok(
++ [ qw(pgbench --initialize --scale=2 pgbench_db) ],
++ 'pgbench finished without errors');
++# Dump the database (cluster the main table to put data in a determined order)
++$node->safe_psql('pgbench_db', qq(
++ CREATE INDEX pa_aid_idx ON pgbench_accounts (aid);
++ CLUSTER pgbench_accounts USING pa_aid_idx));
++$node->command_ok(
++ [ "pg_dump", "-w", "--inserts", "--file=$tempdir/pgbench.sql", "pgbench_db" ],
++ 'pgdump finished without errors');
++$node->stop('fast');
++
++# Initialize second node
++my $node2 = PostgreSQL::Test::Cluster->new('master2');
++$node2->init;
++# Disable logging of all statements to avoid log bloat during restore
++$node2->append_conf('postgresql.conf', "log_statement = none");
++$node2->start;
++
++# Create a database and restore the previous dump
++$node2->safe_psql('postgres', "CREATE DATABASE pgbench_db");
++my $txid0 = $node2->safe_psql('pgbench_db', 'SELECT txid_current()');
++print("# Initial txid_current: $txid0\n");
++$node2->command_ok(["psql", "-q", "-f", "$tempdir/pgbench.sql", "pgbench_db"]);
++
++# Dump the database and compare the dumped content with the previous one
++$node2->safe_psql('pgbench_db', 'CLUSTER pgbench_accounts');
++$node2->command_ok(
++ [ "pg_dump", "-w", "--inserts", "--file=$tempdir/pgbench2.sql", "pgbench_db" ],
++ 'pgdump finished without errors');
++ok(File::Compare::compare_text("$tempdir/pgbench.sql", "$tempdir/pgbench2.sql") == 0, "no differences detected");
++
++done_testing();
+diff --git a/src/test/xid-64/t/004_test_relminmxid.pl b/src/test/xid-64/t/004_test_relminmxid.pl
+new file mode 100644
+index 00000000000..e924f9cd9ab
+--- /dev/null
++++ b/src/test/xid-64/t/004_test_relminmxid.pl
+@@ -0,0 +1,90 @@
++# Check integrity after dump/restore with different xids
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++use bigint;
++
++my ($node, $rmm, $vacout);
++$node = PostgreSQL::Test::Cluster->new('master');
++$node->init;
++$node->append_conf('postgresql.conf', 'max_prepared_transactions = 2');
++$node->start;
++
++sub relminmxid
++{
++ my $rmm = $node->safe_psql("postgres", qq(
++ SELECT relminmxid
++ FROM pg_class
++ WHERE relname = 'foo';));
++ return $rmm + 0;
++}
++
++sub vacuum
++{
++ my ($rc, $stdout, $stderr) = $node->psql("postgres", "VACUUM foo;");
++ return $stdout.$stderr;
++}
++
++sub gen_multixact
++{
++ $node->safe_psql("postgres", qq(
++ BEGIN;
++ SELECT * FROM foo FOR KEY SHARE;
++ PREPARE TRANSACTION 'fooshare';
++ ));
++
++ my $xmax = $node->safe_psql("postgres", qq(
++ SELECT xmax FROM foo;
++ ));
++ isnt($xmax + 0, 0, "xmax not empty");
++
++ $node->safe_psql("postgres", qq(
++ BEGIN;
++ SELECT * FROM foo FOR KEY SHARE;
++ COMMIT;
++ COMMIT PREPARED 'fooshare';
++ ));
++
++ my $mxact = $node->safe_psql("postgres", qq(
++ SELECT xmax FROM foo;
++ ));
++ isnt($mxact + 0, 0, "mxact not empty");
++ cmp_ok($xmax, '>', $mxact, "xmax is greater than mxact");
++}
++
++# Initialize master node with the random xid-related parameters
++$node->safe_psql("postgres", "CREATE TABLE foo (a int); INSERT INTO foo VALUES (1);");
++
++is(relminmxid(), 1, "relminmxid is default");
++
++vacuum();
++is(relminmxid(), 1, "relminmxid is still default");
++
++gen_multixact();
++is(relminmxid(), 1, "relminmxid is still still default");
++
++unlike(vacuum(), qr/multixact.*before relminmxid/, "no relminmxid error");
++
++# No intentionally break relminmxid
++$node->safe_psql("postgres", qq(
++ UPDATE pg_class SET relminmxid = ((1::int8<<62) + 1)::text::xid
++ WHERE relname = 'foo'
++));
++cmp_ok(relminmxid(), '>', 2**62, "relminmxid broken (intentionally)");
++
++gen_multixact();
++like(vacuum(), qr/multixact.*before relminmxid/, "got relminmxid error");
++cmp_ok(relminmxid(), '>', 2**62, "relminmxid broken (still)");
++
++# Fix relminmxid by setting to default
++$node->safe_psql("postgres", qq(
++ UPDATE pg_class SET relminmxid = '1'
++ WHERE relname = 'foo'
++));
++is(relminmxid(), 1, "relminmxid is default again");
++
++unlike(vacuum(), qr/multixact.*before relminmxid/, "no relminmxid error again");
++
++done_testing();
+diff --git a/src/test/xid-64/t/005_stream_subxact.pl b/src/test/xid-64/t/005_stream_subxact.pl
+new file mode 100644
+index 00000000000..6765f6061ca
+--- /dev/null
++++ b/src/test/xid-64/t/005_stream_subxact.pl
+@@ -0,0 +1,100 @@
++
++# Copyright (c) 2021, PostgreSQL Global Development Group
++
++# Test xids streaming of large transaction containing large subtransactions
++# near 32-bit boundary.
++#
++# Mostly it is a copy of 016_stream_subxact.pl, but with publisher xid inited
++# just before 32-bit boundary, so if xids are replicated as 32-bit values,
++# subscriber will get 0 xid value.
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++
++# Create publisher node
++my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
++$node_publisher->init(allows_streaming => 'logical');
++$node_publisher->append_conf('postgresql.conf',
++ 'logical_decoding_work_mem = 64kB');
++$node_publisher->start;
++
++# Create subscriber node
++my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
++$node_subscriber->init(allows_streaming => 'logical');
++$node_subscriber->start;
++
++# Create some preexisting content on publisher
++$node_publisher->safe_psql('postgres',
++ "CREATE TABLE test_tab (a int primary key, b varchar)");
++$node_publisher->safe_psql('postgres',
++ "INSERT INTO test_tab VALUES (1, 'foo'), (2, 'bar')");
++
++# Setup structure on subscriber
++$node_subscriber->safe_psql('postgres',
++ "CREATE TABLE test_tab (a int primary key, b text, c timestamptz DEFAULT now(), d bigint DEFAULT 999)"
++);
++
++# Setup logical replication
++my $publisher_connstr = $node_publisher->connstr . ' dbname=postgres';
++$node_publisher->safe_psql('postgres',
++ "CREATE PUBLICATION tap_pub FOR TABLE test_tab");
++
++my $appname = 'tap_sub';
++$node_subscriber->safe_psql('postgres',
++ "CREATE SUBSCRIPTION tap_sub CONNECTION '$publisher_connstr application_name=$appname' PUBLICATION tap_pub WITH (streaming = on)"
++);
++
++$node_publisher->wait_for_catchup($appname);
++
++# Also wait for initial table sync to finish
++my $synced_query =
++ "SELECT count(1) = 0 FROM pg_subscription_rel WHERE srsubstate NOT IN ('r', 's');";
++$node_subscriber->poll_query_until('postgres', $synced_query)
++ or die "Timed out while waiting for subscriber to synchronize data";
++
++my $result =
++ $node_subscriber->safe_psql('postgres',
++ "SELECT count(*), count(c), count(d = 999) FROM test_tab");
++is($result, qq(2|2|2), 'check initial data was copied to subscriber');
++
++# Insert, update and delete enough rows to exceed 64kB limit.
++$node_publisher->safe_psql(
++ 'postgres', q{
++BEGIN;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series( 3, 500) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s1;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(501, 1000) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s2;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(1001, 1500) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s3;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(1501, 2000) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++SAVEPOINT s4;
++INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(2001, 2500) s(i);
++UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0;
++DELETE FROM test_tab WHERE mod(a,3) = 0;
++COMMIT;
++});
++
++$node_publisher->wait_for_catchup($appname);
++
++$result =
++ $node_subscriber->safe_psql('postgres',
++ "SELECT count(*), count(c), count(d = 999) FROM test_tab");
++is($result, qq(1667|1667|1667),
++ 'check data was copied to subscriber in streaming mode and extra columns contain local defaults'
++);
++
++$node_subscriber->stop;
++$node_publisher->stop;
++
++done_testing();
+diff --git a/src/test/xid-64/t/006_zeropage.pl b/src/test/xid-64/t/006_zeropage.pl
+new file mode 100644
+index 00000000000..4b87c90edcd
+--- /dev/null
++++ b/src/test/xid-64/t/006_zeropage.pl
+@@ -0,0 +1,33 @@
++use strict;
++use warnings;
++
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++
++# Check WAL for ZEROPAGE record.
++
++sub command_output
++{
++ my ($cmd) = @_;
++ my ($stdout, $stderr);
++ print("# Running: " . join(" ", @{$cmd}) . "\n");
++ my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
++ return $stdout;
++}
++
++my $node = PostgreSQL::Test::Cluster->new('main');
++$node->init;
++$node->start;
++my $pgdata = $node->data_dir;
++my $xlogfilename0 = $node->safe_psql('postgres',
++ "SELECT pg_walfile_name(pg_current_wal_lsn())");
++#$node->command_like(
++# [ 'pg_waldump', '-S', "$pgdata/pg_wal/$xlogfilename0" ],
++# qr/ZEROPAGE/,
++# 'pg_waldump prints start timestamp');
++my $wd_output = command_output(
++ [ 'pg_waldump', "$pgdata/pg_wal/$xlogfilename0" ]);
++ok($wd_output =~ qr/ZEROPAGE page 0/, "ZEROPAGE found");
++
++done_testing();
+diff --git a/src/test/xid-64/t/007_first_multi.pl b/src/test/xid-64/t/007_first_multi.pl
+new file mode 100644
+index 00000000000..eca2c39af9e
+--- /dev/null
++++ b/src/test/xid-64/t/007_first_multi.pl
+@@ -0,0 +1,83 @@
++# Test for pages with first tuple has xmax multi
++use strict;
++use warnings;
++use PostgreSQL::Test::Cluster;
++use PostgreSQL::Test::Utils;
++use Test::More;
++
++sub test_multixact
++{
++ my ($primary, $standby, $test_name) = @_;
++
++ $primary->safe_psql('postgres', q{
++ CREATE TABLE t (id INT, data TEXT, CONSTRAINT t_id_pk PRIMARY KEY(id));
++ INSERT INTO t SELECT 1, repeat('a', 1000);
++ });
++
++ my %psql = (
++ '1' => $primary->background_psql('postgres'),
++ '2' => $primary->background_psql('postgres'),
++ );
++
++ # Lock tuples
++ $psql{1}->query_safe(q(
++ BEGIN;
++ SELECT * FROM t FOR KEY SHARE;
++ ));
++
++ $psql{2}->query_safe(q(
++ BEGIN;
++ SELECT * FROM t FOR KEY SHARE;
++ ));
++
++ # Repeat update until we get a new page with one tuple
++ my $res;
++ my $guard = 0;
++
++ do {
++ $res = $primary->safe_psql('postgres', q{
++ UPDATE t SET data = repeat('a', 1000) RETURNING ctid;
++ });
++ # Fail if we already write around 64k and still have no new page.
++ fail("creating second page") if (++$guard == 64);
++ } until ($res eq "(1,1)");
++
++ $psql{1}->quit;
++ $psql{2}->quit;
++ $primary->wait_for_catchup($standby);
++
++ # Check results
++ my $query = q{
++ SELECT xmax, ctid, id, data = repeat('a', 1000) as data FROM t;
++ };
++ my $res_primary = $primary->safe_psql('postgres', $query);
++ my $res_standby = $standby->safe_psql('postgres', $query);
++
++ is($res_primary, $res_standby, "rows are the same in test $test_name");
++}
++
++# We should run test for full_page_writes on and off.
++foreach ('true', 'false') {
++ # Create primary
++ my $primary = PostgreSQL::Test::Cluster->new("master_$_");
++ $primary->init(allows_streaming => 1);
++ $primary->append_conf('postgresql.conf', "full_page_writes = $_");
++ $primary->start;
++
++ # Take backup
++ my $backup_name = "my_backup_$_";
++ $primary->backup($backup_name);
++
++ # Create standby from backup
++ my $standby = PostgreSQL::Test::Cluster->new("standby_$_");
++ $standby->init_from_backup($primary, $backup_name, has_streaming => 1);
++ $standby->start;
++
++ # Check
++ test_multixact($primary, $standby, "with FPW $_");
++
++ $standby->stop();
++ $primary->stop();
++}
++
++done_testing();
+diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
+index ce33e55bf1d..cc10f0769a0 100644
+--- a/src/tools/pgindent/typedefs.list
++++ b/src/tools/pgindent/typedefs.list
+@@ -3584,8 +3584,8 @@ intset_node
+ intvKEY
+ io_callback_fn
+ io_stat_col
+-itemIdCompact
+-itemIdCompactData
++ItemIdCompact
++ItemIdCompactData
+ iterator
+ jmp_buf
+ join_search_hook_type
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 8de5dfa4fc6..f815371b768 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -214,6 +214,7 @@ heapam_tuple_satisfies_snapshot(Relation rel, TupleTableSlot *slot,
{
BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
bool res;
+ Page page;
Assert(TTS_IS_BUFFERTUPLE(slot));
Assert(BufferIsValid(bslot->buffer));
@@ -223,6 +224,13 @@ heapam_tuple_satisfies_snapshot(Relation rel, TupleTableSlot *slot,
* Caller should be holding pin, but not lock.
*/
LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
+ /*
+ * Need to reread min/max xids as they can be overwritten before
+ */
+ page = BufferGetPage(bslot->buffer);
+ HeapTupleCopyXidsFromPage(bslot->buffer, bslot->base.tuple, page,
+ IsToastRelation(rel));
+
res = HeapTupleSatisfiesVisibility(bslot->base.tuple, snapshot,
bslot->buffer);
LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
--
2.47.1