0001-Rename-some-signal-and-interrupt-handling-functions-.patch

From 0841756bc9b8108aeb5a0dc2b85fc9d0e7dbb11e Mon Sep 17 00:00:00 2001
From: Heikki Linnakangas <heikki.linnakangas@iki.fi>
Date: Mon, 3 Mar 2025 10:50:44 +0200
Subject: [PATCH 1/1] Rename some signal and interrupt handling functions for
 consistency

The usual pattern for handling a signal is that the signal handler
sets a flag and calls SetLatch(MyLatch) to wake up the process, and
CHECK_FOR_INTERRUPTS() or other code that is part of a wait loop calls
another function to deal with it. The naming of the functions involved
was a bit inconsistent, however. CHECK_FOR_INTERRUPTS() calls
ProcessInterrupts() to do the heavy-lifting, but the analogous
functions in aux processes were called HandleMainLoopInterrupts(),
HandleStartupProcInterrupts(), etc. Similarly, most subroutines of
ProcessInterrupts() were called Process*(), but some were called
Handle*().

To make things less confusing, rename all the functions that are part
of the overall signal/interrupt handling system but are not executed
in a signal handler to e.g. ProcessSomething(), rather than
HandleSomething().
---
 src/backend/access/transam/parallel.c            | 16 ++++++++--------
 src/backend/access/transam/xlogrecovery.c        | 12 ++++++------
 src/backend/postmaster/autovacuum.c              |  6 +++---
 src/backend/postmaster/bgwriter.c                |  2 +-
 src/backend/postmaster/checkpointer.c            | 10 +++++-----
 src/backend/postmaster/interrupt.c               |  6 +++---
 src/backend/postmaster/pgarch.c                  |  8 ++++----
 src/backend/postmaster/startup.c                 |  6 +++---
 src/backend/postmaster/walsummarizer.c           | 16 ++++++++--------
 src/backend/postmaster/walwriter.c               |  2 +-
 .../replication/logical/applyparallelworker.c    | 12 ++++++------
 src/backend/tcop/postgres.c                      |  4 ++--
 src/include/access/parallel.h                    |  2 +-
 src/include/postmaster/interrupt.h               |  2 +-
 src/include/postmaster/startup.h                 |  2 +-
 src/include/replication/logicalworker.h          |  2 +-
 16 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/src/backend/access/transam/parallel.c b/src/backend/access/transam/parallel.c
index f6d81d6e1fc..94db1ec3012 100644
--- a/src/backend/access/transam/parallel.c
+++ b/src/backend/access/transam/parallel.c
@@ -158,7 +158,7 @@ static const struct
 };
 
 /* Private functions. */
-static void HandleParallelMessage(ParallelContext *pcxt, int i, StringInfo msg);
+static void ProcessParallelMessage(ParallelContext *pcxt, int i, StringInfo msg);
 static void WaitForParallelWorkersToExit(ParallelContext *pcxt);
 static parallel_worker_main_type LookupParallelWorkerFunction(const char *libraryname, const char *funcname);
 static void ParallelWorkerShutdown(int code, Datum arg);
@@ -1031,7 +1031,7 @@ ParallelContextActive(void)
  *
  * Note: this is called within a signal handler!  All we can do is set
  * a flag that will cause the next CHECK_FOR_INTERRUPTS() to invoke
- * HandleParallelMessages().
+ * ProcessParallelMessages().
  */
 void
 HandleParallelMessageInterrupt(void)
@@ -1042,10 +1042,10 @@ HandleParallelMessageInterrupt(void)
 }
 
 /*
- * Handle any queued protocol messages received from parallel workers.
+ * Process any queued protocol messages received from parallel workers.
  */
 void
-HandleParallelMessages(void)
+ProcessParallelMessages(void)
 {
 	dlist_iter	iter;
 	MemoryContext oldcontext;
@@ -1068,7 +1068,7 @@ HandleParallelMessages(void)
 	 */
 	if (hpm_context == NULL)	/* first time through? */
 		hpm_context = AllocSetContextCreate(TopMemoryContext,
-											"HandleParallelMessages",
+											"ProcessParallelMessages",
 											ALLOCSET_DEFAULT_SIZES);
 	else
 		MemoryContextReset(hpm_context);
@@ -1111,7 +1111,7 @@ HandleParallelMessages(void)
 
 					initStringInfo(&msg);
 					appendBinaryStringInfo(&msg, data, nbytes);
-					HandleParallelMessage(pcxt, i, &msg);
+					ProcessParallelMessage(pcxt, i, &msg);
 					pfree(msg.data);
 				}
 				else
@@ -1131,10 +1131,10 @@ HandleParallelMessages(void)
 }
 
 /*
- * Handle a single protocol message received from a single parallel worker.
+ * Process a single protocol message received from a single parallel worker.
  */
 static void
-HandleParallelMessage(ParallelContext *pcxt, int i, StringInfo msg)
+ProcessParallelMessage(ParallelContext *pcxt, int i, StringInfo msg)
 {
 	char		msgtype;
 
diff --git a/src/backend/access/transam/xlogrecovery.c b/src/backend/access/transam/xlogrecovery.c
index 52f53fa12e0..a829a055a97 100644
--- a/src/backend/access/transam/xlogrecovery.c
+++ b/src/backend/access/transam/xlogrecovery.c
@@ -1774,7 +1774,7 @@ PerformWalRecovery(void)
 #endif
 
 			/* Handle interrupt signals of startup process */
-			HandleStartupProcInterrupts();
+			ProcessStartupProcInterrupts();
 
 			/*
 			 * Pause WAL replay, if requested by a hot-standby session via
@@ -2949,7 +2949,7 @@ recoveryPausesHere(bool endOfRecovery)
 	/* loop until recoveryPauseState is set to RECOVERY_NOT_PAUSED */
 	while (GetRecoveryPauseState() != RECOVERY_NOT_PAUSED)
 	{
-		HandleStartupProcInterrupts();
+		ProcessStartupProcInterrupts();
 		if (CheckForStandbyTrigger())
 			return;
 
@@ -3038,7 +3038,7 @@ recoveryApplyDelay(XLogReaderState *record)
 		ResetLatch(&XLogRecoveryCtl->recoveryWakeupLatch);
 
 		/* This might change recovery_min_apply_delay. */
-		HandleStartupProcInterrupts();
+		ProcessStartupProcInterrupts();
 
 		if (CheckForStandbyTrigger())
 			break;
@@ -3727,7 +3727,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 						now = GetCurrentTimestamp();
 
 						/* Handle interrupt signals of startup process */
-						HandleStartupProcInterrupts();
+						ProcessStartupProcInterrupts();
 					}
 					last_fail_time = now;
 					currentSource = XLOG_FROM_ARCHIVE;
@@ -4017,7 +4017,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 		 * This possibly-long loop needs to handle interrupts of startup
 		 * process.
 		 */
-		HandleStartupProcInterrupts();
+		ProcessStartupProcInterrupts();
 	}
 
 	return XLREAD_FAIL;			/* not reached */
@@ -4695,7 +4695,7 @@ RecoveryRequiresIntParameter(const char *param_name, int currValue, int minValue
 
 			while (GetRecoveryPauseState() != RECOVERY_NOT_PAUSED)
 			{
-				HandleStartupProcInterrupts();
+				ProcessStartupProcInterrupts();
 
 				if (CheckForStandbyTrigger())
 				{
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index dfb8d068ecf..800815dfbcc 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -316,7 +316,7 @@ static WorkerInfo MyWorkerInfo = NULL;
 int			AutovacuumLauncherPid = 0;
 
 static Oid	do_start_worker(void);
-static void HandleAutoVacLauncherInterrupts(void);
+static void ProcessAutoVacLauncherInterrupts(void);
 static void AutoVacLauncherShutdown(void) pg_attribute_noreturn();
 static void launcher_determine_sleep(bool canlaunch, bool recursing,
 									 struct timeval *nap);
@@ -594,7 +594,7 @@ AutoVacLauncherMain(const void *startup_data, size_t startup_data_len)
 
 		ResetLatch(MyLatch);
 
-		HandleAutoVacLauncherInterrupts();
+		ProcessAutoVacLauncherInterrupts();
 
 		/*
 		 * a worker finished, or postmaster signaled failure to start a worker
@@ -742,7 +742,7 @@ AutoVacLauncherMain(const void *startup_data, size_t startup_data_len)
  * Process any new interrupts.
  */
 static void
-HandleAutoVacLauncherInterrupts(void)
+ProcessAutoVacLauncherInterrupts(void)
 {
 	/* the normal shutdown case */
 	if (ShutdownRequestPending)
diff --git a/src/backend/postmaster/bgwriter.c b/src/backend/postmaster/bgwriter.c
index 64524d1831b..a688cc5d2a1 100644
--- a/src/backend/postmaster/bgwriter.c
+++ b/src/backend/postmaster/bgwriter.c
@@ -226,7 +226,7 @@ BackgroundWriterMain(const void *startup_data, size_t startup_data_len)
 		/* Clear any already-pending wakeups */
 		ResetLatch(MyLatch);
 
-		HandleMainLoopInterrupts();
+		ProcessMainLoopInterrupts();
 
 		/*
 		 * Do one cycle of dirty-buffer writing.
diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c
index 7acbbd3e267..0e228d143a0 100644
--- a/src/backend/postmaster/checkpointer.c
+++ b/src/backend/postmaster/checkpointer.c
@@ -157,7 +157,7 @@ static pg_time_t last_xlog_switch_time;
 
 /* Prototypes for private functions */
 
-static void HandleCheckpointerInterrupts(void);
+static void ProcessCheckpointerInterrupts(void);
 static void CheckArchiveTimeout(void);
 static bool IsCheckpointOnSchedule(double progress);
 static bool ImmediateCheckpointRequested(void);
@@ -359,7 +359,7 @@ CheckpointerMain(const void *startup_data, size_t startup_data_len)
 		 */
 		AbsorbSyncRequests();
 
-		HandleCheckpointerInterrupts();
+		ProcessCheckpointerInterrupts();
 		if (ShutdownXLOGPending || ShutdownRequestPending)
 			break;
 
@@ -536,7 +536,7 @@ CheckpointerMain(const void *startup_data, size_t startup_data_len)
 			 * We may have received an interrupt during the checkpoint and the
 			 * latch might have been reset (e.g. in CheckpointWriteDelay).
 			 */
-			HandleCheckpointerInterrupts();
+			ProcessCheckpointerInterrupts();
 			if (ShutdownXLOGPending || ShutdownRequestPending)
 				break;
 		}
@@ -615,7 +615,7 @@ CheckpointerMain(const void *startup_data, size_t startup_data_len)
 		/* Clear any already-pending wakeups */
 		ResetLatch(MyLatch);
 
-		HandleCheckpointerInterrupts();
+		ProcessCheckpointerInterrupts();
 
 		if (ShutdownRequestPending)
 			break;
@@ -634,7 +634,7 @@ CheckpointerMain(const void *startup_data, size_t startup_data_len)
  * Process any new interrupts.
  */
 static void
-HandleCheckpointerInterrupts(void)
+ProcessCheckpointerInterrupts(void)
 {
 	if (ProcSignalBarrierPending)
 		ProcessProcSignalBarrier();
diff --git a/src/backend/postmaster/interrupt.c b/src/backend/postmaster/interrupt.c
index be69e4c7136..0ae9bf906ec 100644
--- a/src/backend/postmaster/interrupt.c
+++ b/src/backend/postmaster/interrupt.c
@@ -31,7 +31,7 @@ volatile sig_atomic_t ShutdownRequestPending = false;
  * Simple interrupt handler for main loops of background processes.
  */
 void
-HandleMainLoopInterrupts(void)
+ProcessMainLoopInterrupts(void)
 {
 	if (ProcSignalBarrierPending)
 		ProcessProcSignalBarrier();
@@ -55,7 +55,7 @@ HandleMainLoopInterrupts(void)
  *
  * Normally, this handler would be used for SIGHUP. The idea is that code
  * which uses it would arrange to check the ConfigReloadPending flag at
- * convenient places inside main loops, or else call HandleMainLoopInterrupts.
+ * convenient places inside main loops, or else call ProcessMainLoopInterrupts.
  */
 void
 SignalHandlerForConfigReload(SIGNAL_ARGS)
@@ -99,7 +99,7 @@ SignalHandlerForCrashExit(SIGNAL_ARGS)
  * SIGINT or SIGTERM.
  *
  * ShutdownRequestPending should be checked at a convenient place within the
- * main loop, or else the main loop should call HandleMainLoopInterrupts.
+ * main loop, or else the main loop should call ProcessMainLoopInterrupts.
  */
 void
 SignalHandlerForShutdownRequest(SIGNAL_ARGS)
diff --git a/src/backend/postmaster/pgarch.c b/src/backend/postmaster/pgarch.c
index e6cd78679ce..dbe4e1d426b 100644
--- a/src/backend/postmaster/pgarch.c
+++ b/src/backend/postmaster/pgarch.c
@@ -147,7 +147,7 @@ static bool pgarch_archiveXlog(char *xlog);
 static bool pgarch_readyXlog(char *xlog);
 static void pgarch_archiveDone(char *xlog);
 static void pgarch_die(int code, Datum arg);
-static void HandlePgArchInterrupts(void);
+static void ProcessPgArchInterrupts(void);
 static int	ready_file_comparator(Datum a, Datum b, void *arg);
 static void LoadArchiveLibrary(void);
 static void pgarch_call_module_shutdown_cb(int code, Datum arg);
@@ -324,7 +324,7 @@ pgarch_MainLoop(void)
 		time_to_stop = ready_to_stop;
 
 		/* Check for barrier events and config update */
-		HandlePgArchInterrupts();
+		ProcessPgArchInterrupts();
 
 		/*
 		 * If we've gotten SIGTERM, we normally just sit and do nothing until
@@ -415,7 +415,7 @@ pgarch_ArchiverCopyLoop(void)
 			 * we'll adopt a new setting for archive_command as soon as
 			 * possible, even if there is a backlog of files to be archived.
 			 */
-			HandlePgArchInterrupts();
+			ProcessPgArchInterrupts();
 
 			/* Reset variables that might be set by the callback */
 			arch_module_check_errdetail_string = NULL;
@@ -856,7 +856,7 @@ pgarch_die(int code, Datum arg)
  * shutdown request is different between those loops.
  */
 static void
-HandlePgArchInterrupts(void)
+ProcessPgArchInterrupts(void)
 {
 	if (ProcSignalBarrierPending)
 		ProcessProcSignalBarrier();
diff --git a/src/backend/postmaster/startup.c b/src/backend/postmaster/startup.c
index 88eab3d0baf..27e86cf393f 100644
--- a/src/backend/postmaster/startup.c
+++ b/src/backend/postmaster/startup.c
@@ -38,7 +38,7 @@
 #ifndef USE_POSTMASTER_DEATH_SIGNAL
 /*
  * On systems that need to make a system call to find out if the postmaster has
- * gone away, we'll do so only every Nth call to HandleStartupProcInterrupts().
+ * gone away, we'll do so only every Nth call to ProcessStartupProcInterrupts().
  * This only affects how long it takes us to detect the condition while we're
  * busy replaying WAL.  Latch waits and similar which should react immediately
  * through the usual techniques.
@@ -149,9 +149,9 @@ StartupRereadConfig(void)
 		StartupRequestWalReceiverRestart();
 }
 
-/* Handle various signals that might be sent to the startup process */
+/* Process various signals that might be sent to the startup process */
 void
-HandleStartupProcInterrupts(void)
+ProcessStartupProcInterrupts(void)
 {
 #ifdef POSTMASTER_POLL_RATE_LIMIT
 	static uint32 postmaster_poll_count = 0;
diff --git a/src/backend/postmaster/walsummarizer.c b/src/backend/postmaster/walsummarizer.c
index f4d61c1f3bb..effc25bf284 100644
--- a/src/backend/postmaster/walsummarizer.c
+++ b/src/backend/postmaster/walsummarizer.c
@@ -144,7 +144,7 @@ int			wal_summary_keep_time = 10 * HOURS_PER_DAY * MINS_PER_HOUR;
 
 static void WalSummarizerShutdown(int code, Datum arg);
 static XLogRecPtr GetLatestLSN(TimeLineID *tli);
-static void HandleWalSummarizerInterrupts(void);
+static void ProcessWalSummarizerInterrupts(void);
 static XLogRecPtr SummarizeWAL(TimeLineID tli, XLogRecPtr start_lsn,
 							   bool exact, XLogRecPtr switch_lsn,
 							   XLogRecPtr maximum_lsn);
@@ -355,7 +355,7 @@ WalSummarizerMain(const void *startup_data, size_t startup_data_len)
 		MemoryContextReset(context);
 
 		/* Process any signals received recently. */
-		HandleWalSummarizerInterrupts();
+		ProcessWalSummarizerInterrupts();
 
 		/* If it's time to remove any old WAL summaries, do that now. */
 		MaybeRemoveOldWalSummaries();
@@ -855,7 +855,7 @@ GetLatestLSN(TimeLineID *tli)
  * Interrupt handler for main loop of WAL summarizer process.
  */
 static void
-HandleWalSummarizerInterrupts(void)
+ProcessWalSummarizerInterrupts(void)
 {
 	if (ProcSignalBarrierPending)
 		ProcessProcSignalBarrier();
@@ -1015,7 +1015,7 @@ SummarizeWAL(TimeLineID tli, XLogRecPtr start_lsn, bool exact,
 		XLogRecord *record;
 		uint8		rmid;
 
-		HandleWalSummarizerInterrupts();
+		ProcessWalSummarizerInterrupts();
 
 		/* We shouldn't go backward. */
 		Assert(summary_start_lsn <= xlogreader->EndRecPtr);
@@ -1502,7 +1502,7 @@ summarizer_read_local_xlog_page(XLogReaderState *state,
 	WALReadError errinfo;
 	SummarizerReadLocalXLogPrivate *private_data;
 
-	HandleWalSummarizerInterrupts();
+	ProcessWalSummarizerInterrupts();
 
 	private_data = (SummarizerReadLocalXLogPrivate *)
 		state->private_data;
@@ -1540,7 +1540,7 @@ summarizer_read_local_xlog_page(XLogReaderState *state,
 				 * current timeline, so more data might show up.  Delay here
 				 * so we don't tight-loop.
 				 */
-				HandleWalSummarizerInterrupts();
+				ProcessWalSummarizerInterrupts();
 				summarizer_wait_for_wal();
 
 				/* Recheck end-of-WAL. */
@@ -1688,7 +1688,7 @@ MaybeRemoveOldWalSummaries(void)
 		XLogRecPtr	oldest_lsn = InvalidXLogRecPtr;
 		TimeLineID	selected_tli;
 
-		HandleWalSummarizerInterrupts();
+		ProcessWalSummarizerInterrupts();
 
 		/*
 		 * Pick a timeline for which some summary files still exist on disk,
@@ -1707,7 +1707,7 @@ MaybeRemoveOldWalSummaries(void)
 		{
 			WalSummaryFile *ws = lfirst(lc);
 
-			HandleWalSummarizerInterrupts();
+			ProcessWalSummarizerInterrupts();
 
 			/* If it's not on this timeline, it's not time to consider it. */
 			if (selected_tli != ws->tli)
diff --git a/src/backend/postmaster/walwriter.c b/src/backend/postmaster/walwriter.c
index 15a71ad684d..0380601bcbb 100644
--- a/src/backend/postmaster/walwriter.c
+++ b/src/backend/postmaster/walwriter.c
@@ -239,7 +239,7 @@ WalWriterMain(const void *startup_data, size_t startup_data_len)
 		ResetLatch(MyLatch);
 
 		/* Process any signals received recently */
-		HandleMainLoopInterrupts();
+		ProcessMainLoopInterrupts();
 
 		/*
 		 * Do what we're here for; then, if XLogBackgroundFlush() found useful
diff --git a/src/backend/replication/logical/applyparallelworker.c b/src/backend/replication/logical/applyparallelworker.c
index 268b2675caa..d25085d3515 100644
--- a/src/backend/replication/logical/applyparallelworker.c
+++ b/src/backend/replication/logical/applyparallelworker.c
@@ -983,7 +983,7 @@ ParallelApplyWorkerMain(Datum main_arg)
  *
  * Note: this is called within a signal handler! All we can do is set a flag
  * that will cause the next CHECK_FOR_INTERRUPTS() to invoke
- * HandleParallelApplyMessages().
+ * ProcessParallelApplyMessages().
  */
 void
 HandleParallelApplyMessageInterrupt(void)
@@ -994,11 +994,11 @@ HandleParallelApplyMessageInterrupt(void)
 }
 
 /*
- * Handle a single protocol message received from a single parallel apply
+ * Process a single protocol message received from a single parallel apply
  * worker.
  */
 static void
-HandleParallelApplyMessage(StringInfo msg)
+ProcessParallelApplyMessage(StringInfo msg)
 {
 	char		msgtype;
 
@@ -1060,7 +1060,7 @@ HandleParallelApplyMessage(StringInfo msg)
  * Handle any queued protocol messages received from parallel apply workers.
  */
 void
-HandleParallelApplyMessages(void)
+ProcessParallelApplyMessages(void)
 {
 	ListCell   *lc;
 	MemoryContext oldcontext;
@@ -1083,7 +1083,7 @@ HandleParallelApplyMessages(void)
 	 */
 	if (!hpam_context)			/* first time through? */
 		hpam_context = AllocSetContextCreate(TopMemoryContext,
-											 "HandleParallelApplyMessages",
+											 "ProcessParallelApplyMessages",
 											 ALLOCSET_DEFAULT_SIZES);
 	else
 		MemoryContextReset(hpam_context);
@@ -1118,7 +1118,7 @@ HandleParallelApplyMessages(void)
 
 			initStringInfo(&msg);
 			appendBinaryStringInfo(&msg, data, nbytes);
-			HandleParallelApplyMessage(&msg);
+			ProcessParallelApplyMessage(&msg);
 			pfree(msg.data);
 		}
 		else
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index f2f75aa0f88..947ffb40421 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -3494,13 +3494,13 @@ ProcessInterrupts(void)
 		ProcessProcSignalBarrier();
 
 	if (ParallelMessagePending)
-		HandleParallelMessages();
+		ProcessParallelMessages();
 
 	if (LogMemoryContextPending)
 		ProcessLogMemoryContextInterrupt();
 
 	if (ParallelApplyMessagePending)
-		HandleParallelApplyMessages();
+		ProcessParallelApplyMessages();
 }
 
 /*
diff --git a/src/include/access/parallel.h b/src/include/access/parallel.h
index 8811618acb7..f37be6d5690 100644
--- a/src/include/access/parallel.h
+++ b/src/include/access/parallel.h
@@ -71,7 +71,7 @@ extern void DestroyParallelContext(ParallelContext *pcxt);
 extern bool ParallelContextActive(void);
 
 extern void HandleParallelMessageInterrupt(void);
-extern void HandleParallelMessages(void);
+extern void ProcessParallelMessages(void);
 extern void AtEOXact_Parallel(bool isCommit);
 extern void AtEOSubXact_Parallel(bool isCommit, SubTransactionId mySubId);
 extern void ParallelWorkerReportLastRecEnd(XLogRecPtr last_xlog_end);
diff --git a/src/include/postmaster/interrupt.h b/src/include/postmaster/interrupt.h
index b488a9ac67d..3bf49320846 100644
--- a/src/include/postmaster/interrupt.h
+++ b/src/include/postmaster/interrupt.h
@@ -24,7 +24,7 @@
 extern PGDLLIMPORT volatile sig_atomic_t ConfigReloadPending;
 extern PGDLLIMPORT volatile sig_atomic_t ShutdownRequestPending;
 
-extern void HandleMainLoopInterrupts(void);
+extern void ProcessMainLoopInterrupts(void);
 extern void SignalHandlerForConfigReload(SIGNAL_ARGS);
 extern void SignalHandlerForCrashExit(SIGNAL_ARGS);
 extern void SignalHandlerForShutdownRequest(SIGNAL_ARGS);
diff --git a/src/include/postmaster/startup.h b/src/include/postmaster/startup.h
index ae0f6347fc0..158f52255a6 100644
--- a/src/include/postmaster/startup.h
+++ b/src/include/postmaster/startup.h
@@ -25,7 +25,7 @@
 
 extern PGDLLIMPORT int log_startup_progress_interval;
 
-extern void HandleStartupProcInterrupts(void);
+extern void ProcessStartupProcInterrupts(void);
 extern void StartupProcessMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 extern void PreRestoreCommand(void);
 extern void PostRestoreCommand(void);
diff --git a/src/include/replication/logicalworker.h b/src/include/replication/logicalworker.h
index e62abfd8147..88912606e4d 100644
--- a/src/include/replication/logicalworker.h
+++ b/src/include/replication/logicalworker.h
@@ -24,7 +24,7 @@ extern bool IsLogicalWorker(void);
 extern bool IsLogicalParallelApplyWorker(void);
 
 extern void HandleParallelApplyMessageInterrupt(void);
-extern void HandleParallelApplyMessages(void);
+extern void ProcessParallelApplyMessages(void);
 
 extern void LogicalRepWorkersWakeupAtCommit(Oid subid);
 
-- 
2.39.5