agora inbox for [email protected]  

help / color / mirror / Atom feed

[PATCH v15 2/8] Row pattern recognition patch (parse/analysis).
58+ messages / 2 participants
[nested] [flat]

* [PATCH v15 2/8] Row pattern recognition patch (parse/analysis).
@ 2024-03-28 10:30 Tatsuo Ishii <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Tatsuo Ishii @ 2024-03-28 10:30 UTC (permalink / raw)

---
 src/backend/parser/parse_agg.c    |   7 +
 src/backend/parser/parse_clause.c | 296 +++++++++++++++++++++++++++++-
 src/backend/parser/parse_expr.c   |   4 +
 src/backend/parser/parse_func.c   |   3 +
 4 files changed, 309 insertions(+), 1 deletion(-)

diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c
index bee7d8346a..9bc22a836a 100644
--- a/src/backend/parser/parse_agg.c
+++ b/src/backend/parser/parse_agg.c
@@ -577,6 +577,10 @@ check_agglevels_and_constraints(ParseState *pstate, Node *expr)
 			errkind = true;
 			break;
 
+		case EXPR_KIND_RPR_DEFINE:
+			errkind = true;
+			break;
+
 			/*
 			 * There is intentionally no default: case here, so that the
 			 * compiler will warn if we add a new ParseExprKind without
@@ -967,6 +971,9 @@ transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc,
 		case EXPR_KIND_CYCLE_MARK:
 			errkind = true;
 			break;
+		case EXPR_KIND_RPR_DEFINE:
+			errkind = true;
+			break;
 
 			/*
 			 * There is intentionally no default: case here, so that the
diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c
index d2ac86777c..de2e5791e3 100644
--- a/src/backend/parser/parse_clause.c
+++ b/src/backend/parser/parse_clause.c
@@ -98,7 +98,14 @@ static WindowClause *findWindowClause(List *wclist, const char *name);
 static Node *transformFrameOffset(ParseState *pstate, int frameOptions,
 								  Oid rangeopfamily, Oid rangeopcintype, Oid *inRangeFunc,
 								  Node *clause);
-
+static void transformRPR(ParseState *pstate, WindowClause *wc, WindowDef *windef,
+						 List **targetlist);
+static List *transformDefineClause(ParseState *pstate, WindowClause *wc, WindowDef *windef,
+								   List **targetlist);
+static void transformPatternClause(ParseState *pstate, WindowClause *wc,
+								   WindowDef *windef);
+static List *transformMeasureClause(ParseState *pstate, WindowClause *wc,
+									WindowDef *windef);
 
 /*
  * transformFromClause -
@@ -2948,6 +2955,10 @@ transformWindowDefinitions(ParseState *pstate,
 											 rangeopfamily, rangeopcintype,
 											 &wc->endInRangeFunc,
 											 windef->endOffset);
+
+		/* Process Row Pattern Recognition related clauses */
+		transformRPR(pstate, wc, windef, targetlist);
+
 		wc->runCondition = NIL;
 		wc->winref = winref;
 
@@ -3813,3 +3824,286 @@ transformFrameOffset(ParseState *pstate, int frameOptions,
 
 	return node;
 }
+
+/*
+ * transformRPR
+ *		Process Row Pattern Recognition related clauses
+ */
+static void
+transformRPR(ParseState *pstate, WindowClause *wc, WindowDef *windef,
+			 List **targetlist)
+{
+	/*
+	 * Window definition exists?
+	 */
+	if (windef == NULL)
+		return;
+
+	/*
+	 * Row Pattern Common Syntax clause exists?
+	 */
+	if (windef->rpCommonSyntax == NULL)
+		return;
+
+	/* Check Frame option. Frame must start at current row */
+	if ((wc->frameOptions & FRAMEOPTION_START_CURRENT_ROW) == 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_SYNTAX_ERROR),
+				 errmsg("FRAME must start at current row when row patttern recognition is used")));
+
+	/* Transform AFTER MACH SKIP TO clause */
+	wc->rpSkipTo = windef->rpCommonSyntax->rpSkipTo;
+
+	/* Transform AFTER MACH SKIP TO variable */
+	wc->rpSkipVariable = windef->rpCommonSyntax->rpSkipVariable;
+
+	/* Transform SEEK or INITIAL clause */
+	wc->initial = windef->rpCommonSyntax->initial;
+
+	/* Transform DEFINE clause into list of TargetEntry's */
+	wc->defineClause = transformDefineClause(pstate, wc, windef, targetlist);
+
+	/* Check PATTERN clause and copy to patternClause */
+	transformPatternClause(pstate, wc, windef);
+
+	/* Transform MEASURE clause */
+	transformMeasureClause(pstate, wc, windef);
+}
+
+/*
+ * transformDefineClause Process DEFINE clause and transform ResTarget into
+ *		list of TargetEntry.
+ *
+ * XXX we only support column reference in row pattern definition search
+ * condition, e.g. "price". <row pattern definition variable name>.<column
+ * reference> is not supported, e.g. "A.price".
+ */
+static List *
+transformDefineClause(ParseState *pstate, WindowClause *wc, WindowDef *windef,
+					  List **targetlist)
+{
+	/* DEFINE variable name initials */
+	static char *defineVariableInitials = "abcdefghijklmnopqrstuvwxyz";
+
+	ListCell   *lc,
+			   *l;
+	ResTarget  *restarget,
+			   *r;
+	List	   *restargets;
+	List	   *defineClause;
+	char	   *name;
+	int			initialLen;
+	int			i;
+
+	/*
+	 * If Row Definition Common Syntax exists, DEFINE clause must exist. (the
+	 * raw parser should have already checked it.)
+	 */
+	Assert(windef->rpCommonSyntax->rpDefs != NULL);
+
+	/*
+	 * Check and add "A AS A IS TRUE" if pattern variable is missing in DEFINE
+	 * per the SQL standard.
+	 */
+	restargets = NIL;
+	foreach(lc, windef->rpCommonSyntax->rpPatterns)
+	{
+		A_Expr	   *a;
+		bool		found = false;
+
+		if (!IsA(lfirst(lc), A_Expr))
+			ereport(ERROR,
+					errmsg("node type is not A_Expr"));
+
+		a = (A_Expr *) lfirst(lc);
+		name = strVal(a->lexpr);
+
+		foreach(l, windef->rpCommonSyntax->rpDefs)
+		{
+			restarget = (ResTarget *) lfirst(l);
+
+			if (!strcmp(restarget->name, name))
+			{
+				found = true;
+				break;
+			}
+		}
+
+		if (!found)
+		{
+			/*
+			 * "name" is missing. So create "name AS name IS TRUE" ResTarget
+			 * node and add it to the temporary list.
+			 */
+			A_Const    *n;
+
+			restarget = makeNode(ResTarget);
+			n = makeNode(A_Const);
+			n->val.boolval.type = T_Boolean;
+			n->val.boolval.boolval = true;
+			n->location = -1;
+			restarget->name = pstrdup(name);
+			restarget->indirection = NIL;
+			restarget->val = (Node *) n;
+			restarget->location = -1;
+			restargets = lappend((List *) restargets, restarget);
+		}
+	}
+
+	if (list_length(restargets) >= 1)
+	{
+		/* add missing DEFINEs */
+		windef->rpCommonSyntax->rpDefs =
+			list_concat(windef->rpCommonSyntax->rpDefs, restargets);
+		list_free(restargets);
+	}
+
+	/*
+	 * Check for duplicate row pattern definition variables.  The standard
+	 * requires that no two row pattern definition variable names shall be
+	 * equivalent.
+	 */
+	restargets = NIL;
+	foreach(lc, windef->rpCommonSyntax->rpDefs)
+	{
+		restarget = (ResTarget *) lfirst(lc);
+		name = restarget->name;
+
+		/*
+		 * Add DEFINE expression (Restarget->val) to the targetlist as a
+		 * TargetEntry if it does not exist yet. Planner will add the column
+		 * ref var node to the outer plan's target list later on. This makes
+		 * DEFINE expression could access the outer tuple while evaluating
+		 * PATTERN.
+		 *
+		 * XXX: adding whole expressions of DEFINE to the plan.targetlist is
+		 * not so good, because it's not necessary to evalute the expression
+		 * in the target list while running the plan. We should extract the
+		 * var nodes only then add them to the plan.targetlist.
+		 */
+		findTargetlistEntrySQL99(pstate, (Node *) restarget->val,
+								 targetlist, EXPR_KIND_RPR_DEFINE);
+
+		/*
+		 * Make sure that the row pattern definition search condition is a
+		 * boolean expression.
+		 */
+		transformWhereClause(pstate, restarget->val,
+							 EXPR_KIND_RPR_DEFINE, "DEFINE");
+
+		foreach(l, restargets)
+		{
+			char	   *n;
+
+			r = (ResTarget *) lfirst(l);
+			n = r->name;
+
+			if (!strcmp(n, name))
+				ereport(ERROR,
+						(errcode(ERRCODE_SYNTAX_ERROR),
+						 errmsg("row pattern definition variable name \"%s\" appears more than once in DEFINE clause",
+								name),
+						 parser_errposition(pstate, exprLocation((Node *) r))));
+		}
+		restargets = lappend(restargets, restarget);
+	}
+	list_free(restargets);
+
+	/*
+	 * Create list of row pattern DEFINE variable name's initial. We assign
+	 * [a-z] to them (up to 26 variable names are allowed).
+	 */
+	restargets = NIL;
+	i = 0;
+	initialLen = strlen(defineVariableInitials);
+
+	foreach(lc, windef->rpCommonSyntax->rpDefs)
+	{
+		char		initial[2];
+
+		restarget = (ResTarget *) lfirst(lc);
+		name = restarget->name;
+
+		if (i >= initialLen)
+		{
+			ereport(ERROR,
+					(errcode(ERRCODE_SYNTAX_ERROR),
+					 errmsg("number of row pattern definition variable names exceeds %d",
+							initialLen),
+					 parser_errposition(pstate,
+										exprLocation((Node *) restarget))));
+		}
+		initial[0] = defineVariableInitials[i++];
+		initial[1] = '\0';
+		wc->defineInitial = lappend(wc->defineInitial,
+									makeString(pstrdup(initial)));
+	}
+
+	defineClause = transformTargetList(pstate, windef->rpCommonSyntax->rpDefs,
+									   EXPR_KIND_RPR_DEFINE);
+
+	/* mark column origins */
+	markTargetListOrigins(pstate, defineClause);
+
+	/* mark all nodes in the DEFINE clause tree with collation information */
+	assign_expr_collations(pstate, (Node *) defineClause);
+
+	return defineClause;
+}
+
+/*
+ * transformPatternClause
+ *		Process PATTERN clause and return PATTERN clause in the raw parse tree
+ */
+static void
+transformPatternClause(ParseState *pstate, WindowClause *wc,
+					   WindowDef *windef)
+{
+	ListCell   *lc;
+
+	/*
+	 * Row Pattern Common Syntax clause exists?
+	 */
+	if (windef->rpCommonSyntax == NULL)
+		return;
+
+	wc->patternVariable = NIL;
+	wc->patternRegexp = NIL;
+	foreach(lc, windef->rpCommonSyntax->rpPatterns)
+	{
+		A_Expr	   *a;
+		char	   *name;
+		char	   *regexp;
+
+		if (!IsA(lfirst(lc), A_Expr))
+			ereport(ERROR,
+					errmsg("node type is not A_Expr"));
+
+		a = (A_Expr *) lfirst(lc);
+		name = strVal(a->lexpr);
+
+		wc->patternVariable = lappend(wc->patternVariable, makeString(pstrdup(name)));
+		regexp = strVal(lfirst(list_head(a->name)));
+
+		wc->patternRegexp = lappend(wc->patternRegexp, makeString(pstrdup(regexp)));
+	}
+}
+
+/*
+ * transformMeasureClause
+ *		Process MEASURE clause
+ *	XXX MEASURE clause is not supported yet
+ */
+static List *
+transformMeasureClause(ParseState *pstate, WindowClause *wc,
+					   WindowDef *windef)
+{
+	if (windef->rowPatternMeasures == NIL)
+		return NIL;
+
+	ereport(ERROR,
+			(errcode(ERRCODE_SYNTAX_ERROR),
+			 errmsg("%s", "MEASURE clause is not supported yet"),
+			 parser_errposition(pstate, exprLocation((Node *) windef->rowPatternMeasures))));
+	return NIL;
+}
diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index 73c83cea4a..8b0cc608bc 100644
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -578,6 +578,7 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref)
 		case EXPR_KIND_COPY_WHERE:
 		case EXPR_KIND_GENERATED_COLUMN:
 		case EXPR_KIND_CYCLE_MARK:
+		case EXPR_KIND_RPR_DEFINE:
 			/* okay */
 			break;
 
@@ -1817,6 +1818,7 @@ transformSubLink(ParseState *pstate, SubLink *sublink)
 		case EXPR_KIND_VALUES:
 		case EXPR_KIND_VALUES_SINGLE:
 		case EXPR_KIND_CYCLE_MARK:
+		case EXPR_KIND_RPR_DEFINE:
 			/* okay */
 			break;
 		case EXPR_KIND_CHECK_CONSTRAINT:
@@ -3197,6 +3199,8 @@ ParseExprKindName(ParseExprKind exprKind)
 			return "GENERATED AS";
 		case EXPR_KIND_CYCLE_MARK:
 			return "CYCLE";
+		case EXPR_KIND_RPR_DEFINE:
+			return "DEFINE";
 
 			/*
 			 * There is intentionally no default: case here, so that the
diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c
index 0cbc950c95..ad982a7c17 100644
--- a/src/backend/parser/parse_func.c
+++ b/src/backend/parser/parse_func.c
@@ -2657,6 +2657,9 @@ check_srf_call_placement(ParseState *pstate, Node *last_srf, int location)
 		case EXPR_KIND_CYCLE_MARK:
 			errkind = true;
 			break;
+		case EXPR_KIND_RPR_DEFINE:
+			errkind = true;
+			break;
 
 			/*
 			 * There is intentionally no default: case here, so that the
-- 
2.25.1


----Next_Part(Thu_Mar_28_19_59_25_2024_076)--
Content-Type: Text/X-Patch; charset=us-ascii
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
 filename="v15-0003-Row-pattern-recognition-patch-rewriter.patch"



^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread

* [PATCH 2/2] Publish list of tables being repacked in shared memory
@ 2026-04-07 20:29 Álvaro Herrera <[email protected]>
  0 siblings, 0 replies; 58+ messages in thread

From: Álvaro Herrera @ 2026-04-07 20:29 UTC (permalink / raw)

Use it in autovacuum to skip processing tables that are being repacked.
This is mostly to avoid repeated attempts to process such tables, which
would fail due to the special deadlock checker behavior for repack.

Author: Álvaro Herrera <[email protected]>
Discussion: https://postgr.es/m/[email protected]
---
 src/backend/commands/repack.c                 | 195 ++++++++++++++++--
 src/backend/postmaster/autovacuum.c           |  20 ++
 .../utils/activity/wait_event_names.txt       |   1 +
 src/include/commands/repack.h                 |   2 +
 src/include/storage/lwlocklist.h              |   2 +-
 src/include/storage/subsystemlist.h           |   1 +
 src/tools/pgindent/typedefs.list              |   3 +
 7 files changed, 210 insertions(+), 14 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index a5f5df77291..ee7072dce6a 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -63,9 +63,11 @@
 #include "optimizer/optimizer.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/ipc.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/proc.h"
+#include "storage/subsystems.h"
 #include "utils/acl.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -79,6 +81,32 @@
 #include "utils/syscache.h"
 #include "utils/wait_event_types.h"
 
+
+/* Shared memory layout for REPACK */
+typedef struct RepackWorkerInfo
+{
+	bool		ri_in_use;
+	pid_t		ri_backendpid;
+	Oid			ri_dbid;
+	Oid			ri_relid;
+	Oid			ri_toastrelid;
+} RepackWorkerInfo;
+
+typedef struct
+{
+	bool		re_useless;
+	RepackWorkerInfo re_workerinfo[FLEXIBLE_ARRAY_MEMBER];
+} RepackShmemStruct;
+
+static RepackShmemStruct *RepackShmem;
+
+typedef struct RepackCleanupContext
+{
+	bool		concurrent;
+	int			workerindex;
+} RepackCleanupContext;
+
+
 /*
  * This struct is used to pass around the information on tables to be
  * clustered. We need this so we can make a list of them when invoked without
@@ -90,6 +118,7 @@ typedef struct
 	Oid			indexOid;
 } RelToCluster;
 
+
 /*
  * The first file exported by the decoding worker must contain a snapshot, the
  * following ones contain the data changes.
@@ -166,6 +195,10 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd,
 											  MemoryContext permcxt);
 static bool repack_is_permitted_for_relation(RepackCommand cmd,
 											 Oid relid, Oid userid);
+static void RepackCleanup(RepackCleanupContext *context);
+static void RepackCleanupCb(int code, Datum arg);
+static void RepackShmemRequest(void *arg);
+static void RepackShmemInit(void *arg);
 
 static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt);
 static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot,
@@ -210,6 +243,11 @@ static void ProcessRepackMessage(StringInfo msg);
 static const char *RepackCommandAsString(RepackCommand cmd);
 
 
+const ShmemCallbacks RepackShmemCallbacks = {
+	.request_fn = RepackShmemRequest,
+	.init_fn = RepackShmemInit,
+};
+
 /*
  * The repack code allows for processing multiple tables at once. Because
  * of this, we cannot just run everything on a single transaction, or we
@@ -514,6 +552,7 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 	Oid			tableOid = RelationGetRelid(OldHeap);
 	Relation	index;
 	LOCKMODE	lmode;
+	RepackCleanupContext context;
 	Oid			save_userid;
 	int			save_sec_context;
 	int			save_nestlevel;
@@ -660,24 +699,43 @@ cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid,
 		TransferPredicateLocksToHeapRelation(OldHeap);
 
 	/* rebuild_relation does all the dirty work */
-	PG_TRY();
-	{
-		rebuild_relation(OldHeap, index, verbose, ident_idx);
-	}
-	PG_FINALLY();
+	context.concurrent = concurrent;
+
+	PG_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
 	{
 		if (concurrent)
 		{
-			/*
-			 * Since during normal operation the worker was already asked to
-			 * exit, stopping it explicitly is especially important on ERROR.
-			 * However it still seems a good practice to make sure that the
-			 * worker never survives the REPACK command.
-			 */
-			stop_repack_decoding_worker();
+			bool		freefound = false;
+
+			LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+			for (int i = 0; i < max_repack_replication_slots; i++)
+			{
+				RepackWorkerInfo *worker;
+
+				if (RepackShmem->re_workerinfo[i].ri_in_use)
+					continue;
+
+				freefound = true;
+				worker = &RepackShmem->re_workerinfo[i];
+				context.workerindex = i;
+
+				worker->ri_in_use = true;
+				worker->ri_backendpid = MyProcPid;
+				worker->ri_dbid = MyDatabaseId;
+				worker->ri_relid = RelationGetRelid(OldHeap);
+				worker->ri_toastrelid = OldHeap->rd_rel->reltoastrelid;
+				break;
+			}
+			if (!freefound)
+				elog(ERROR, "could not find free repack entry");
+			LWLockRelease(RepackLock);
 		}
+
+		rebuild_relation(OldHeap, index, verbose, ident_idx);
 	}
-	PG_END_TRY();
+	PG_END_ENSURE_ERROR_CLEANUP(RepackCleanupCb, PointerGetDatum(&context));
+
+	RepackCleanup(&context);
 
 	/* rebuild_relation closes OldHeap, and index if valid */
 
@@ -691,6 +749,117 @@ out:
 	pgstat_progress_end_command();
 }
 
+/*
+ * Return whether any backend is running concurrent REPACK on the given table
+ * (which could be a toast table).
+ */
+bool
+is_table_under_repack(Oid databaseId, Oid relid)
+{
+	bool		retval = false;
+
+	LWLockAcquire(RepackLock, LW_SHARED);
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		RepackWorkerInfo *rworker;
+
+		if (!RepackShmem->re_workerinfo[i].ri_in_use)
+			continue;
+
+		rworker = &RepackShmem->re_workerinfo[i];
+		if (rworker->ri_dbid == MyDatabaseId &&
+			(rworker->ri_relid == relid ||
+			 rworker->ri_toastrelid == relid))
+			retval = true;
+	}
+	LWLockRelease(RepackLock);
+
+	return retval;
+}
+
+/*
+ * Remove ourselves from the workerinfo array.
+ */
+static void
+RepackCleanup(RepackCleanupContext *context)
+{
+	if (context->concurrent)
+	{
+		RepackWorkerInfo *worker;
+
+		/*
+		 * The worker would normally terminate on its own when the work is
+		 * done, but make sure we signal it just in case.
+		 */
+		stop_repack_decoding_worker();
+
+		/*
+		 * also, make sure we stop advertising the relation we were repacking,
+		 * so that autovacuum reverts to handling it normally.
+		 */
+		LWLockAcquire(RepackLock, LW_EXCLUSIVE);
+
+		worker = &RepackShmem->re_workerinfo[context->workerindex];
+		Assert(worker->ri_backendpid == MyProcPid);
+		worker->ri_in_use = false;
+		worker->ri_backendpid = 0;
+		worker->ri_dbid = InvalidOid;
+		worker->ri_relid = InvalidOid;
+		worker->ri_toastrelid = InvalidOid;
+		LWLockRelease(RepackLock);
+	}
+}
+
+/*
+ * RepackCleanup wrapped as an on_shmem_exit callback function
+ */
+static void
+RepackCleanupCb(int code, Datum arg)
+{
+	RepackCleanup((RepackCleanupContext *) DatumGetPointer(arg));
+}
+
+/*
+ * RepackShmemRequest
+ *		Register shared memory space needed for repack
+ */
+static void
+RepackShmemRequest(void *arg)
+{
+	Size		size;
+
+	/*
+	 * Need the fixed struct and the array of RepackWorkerInfo.
+	 */
+	size = sizeof(RepackShmemStruct);
+	size = MAXALIGN(size);
+	size = add_size(size, mul_size(max_repack_replication_slots,
+								   sizeof(RepackWorkerInfo)));
+
+	ShmemRequestStruct(.name = "Repack Data",
+					   .size = size,
+					   .ptr = (void **) &RepackShmem,
+		);
+}
+
+static void
+RepackShmemInit(void *arg)
+{
+	RepackWorkerInfo *reinfo;
+
+	reinfo = (RepackWorkerInfo *) ((char *) RepackShmem +
+								   MAXALIGN(sizeof(RepackShmemStruct)));
+
+	for (int i = 0; i < max_repack_replication_slots; i++)
+	{
+		reinfo[i].ri_in_use = false;
+		reinfo[i].ri_backendpid = 0;
+		reinfo[i].ri_dbid = InvalidOid;
+		reinfo[i].ri_relid = InvalidOid;
+		reinfo[i].ri_toastrelid = InvalidOid;
+	}
+}
+
 /*
  * Check if the table (and its index) still meets the requirements of
  * cluster_rel().
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index bd626a16363..080c64ea3c8 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -78,6 +78,7 @@
 #include "catalog/namespace.h"
 #include "catalog/pg_database.h"
 #include "catalog/pg_namespace.h"
+#include "commands/repack.h"
 #include "commands/vacuum.h"
 #include "common/int.h"
 #include "funcapi.h"
@@ -2422,6 +2423,25 @@ do_autovacuum(void)
 			}
 		}
 		LWLockRelease(AutovacuumLock);
+
+		/*
+		 * Similarly, if the table is being processed by concurrent repack,
+		 * skip it (but make a note of that).  We wouldn't be able to acquire
+		 * its lock anyway.
+		 */
+		if (!skipit)
+		{
+			MemoryContextSwitchTo(PortalContext);
+
+			skipit = is_table_under_repack(MyDatabaseId, relid);
+			if (skipit)
+				ereport(LOG,
+						errmsg("skipping table \"%s.%s.%s\" because it's being repacked in concurrent mode",
+							   get_database_name(MyDatabaseId),
+							   get_namespace_name(get_rel_namespace(relid)),
+							   get_rel_name(relid)));
+		}
+
 		if (skipit)
 		{
 			LWLockRelease(AutovacuumScheduleLock);
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 7bda5298558..e206304f204 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -332,6 +332,7 @@ SInvalWrite	"Waiting to add a message to the shared catalog invalidation queue."
 WALBufMapping	"Waiting to replace a page in WAL buffers."
 WALWrite	"Waiting for WAL buffers to be written to disk."
 ControlFile	"Waiting to read or update the <filename>pg_control</filename> file or create a new WAL file."
+Repack	"Waiting to read or update tables in process by concurrent repack."
 MultiXactGen	"Waiting to read or update shared multixact state."
 RelCacheInit	"Waiting to read or update a <filename>pg_internal.init</filename> relation cache initialization file."
 CheckpointerComm	"Waiting to manage fsync requests."
diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h
index fd16e74b179..be7d38b5fae 100644
--- a/src/include/commands/repack.h
+++ b/src/include/commands/repack.h
@@ -42,6 +42,8 @@ extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
 extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
 						ClusterParams *params, bool isTopLevel);
+extern bool is_table_under_repack(Oid databaseId, Oid relid);
+
 extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
 									   LOCKMODE lockmode);
 extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h
index af8553bcb6c..3f08f4a15d4 100644
--- a/src/include/storage/lwlocklist.h
+++ b/src/include/storage/lwlocklist.h
@@ -41,7 +41,7 @@ PG_LWLOCK(6, SInvalWrite)
 PG_LWLOCK(7, WALBufMapping)
 PG_LWLOCK(8, WALWrite)
 PG_LWLOCK(9, ControlFile)
-/* 10 was CheckpointLock */
+PG_LWLOCK(10, Repack)
 /* 11 was XactSLRULock */
 /* 12 was SubtransSLRULock */
 PG_LWLOCK(13, MultiXactGen)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..4e683b8b0a8 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -72,6 +72,7 @@ PG_SHMEM_SUBSYSTEM(WalSummarizerShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(PgArchShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(ApplyLauncherShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(SlotSyncShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(RepackShmemCallbacks)
 
 /* other modules that need some shared memory space */
 PG_SHMEM_SUBSYSTEM(BTreeShmemCallbacks)
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 637c669a146..d019e03aaf1 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2639,9 +2639,12 @@ ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB
 ReorderTuple
+RepackCleanupContext
 RepackCommand
 RepackDecodingState
+RepackShmemStruct
 RepackStmt
+RepackWorkerInfo
 ReparameterizeForeignPathByChild_function
 ReplOriginId
 ReplOriginXactState
-- 
2.47.3


--kdrcpfmkbkc4lqhu--





^ permalink  raw  reply  [nested|flat] 58+ messages in thread