Thread

[PATCH 4/4] Use singular "datachecksum" consistently in process names

Kyotaro Horiguchi <horikyota.ntt@gmail.com> — 2026-05-26T07:56:01Z

datachecksum_state.c currently refers to processes as both
"datachecksum worker/launcher" and "datachecksums launcher".

Use the singular "datachecksum" form consistently for process names
instead.
---
 src/backend/access/transam/xlog.c           |   4 +-
 src/backend/postmaster/bgworker.c           |   8 +-
 src/backend/postmaster/datachecksum_state.c | 234 ++++++++++----------
 src/backend/postmaster/postmaster.c         |   4 +-
 src/backend/storage/ipc/procsignal.c        |   2 +-
 src/backend/utils/activity/pgstat_backend.c |   4 +-
 src/backend/utils/activity/pgstat_io.c      |   4 +-
 src/backend/utils/init/miscinit.c           |   2 +-
 src/backend/utils/init/postinit.c           |   2 +-
 src/include/miscadmin.h                     |  10 +-
 src/include/postmaster/datachecksum_state.h |  30 +--
 src/include/postmaster/proctypelist.h       |   4 +-
 src/include/storage/subsystemlist.h         |   2 +-
 13 files changed, 155 insertions(+), 155 deletions(-)

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index fecdf0d4b05..16f8278809e 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -9178,7 +9178,7 @@ xlog_redo(XLogReaderState *record)
 		SpinLockRelease(&XLogCtl->info_lck);
 
 		if (new_state)
-			EmitAndWaitDataChecksumsBarrier(redo_rec.data_checksum_version);
+			EmitAndWaitDataChecksumBarrier(redo_rec.data_checksum_version);
 	}
 	else if (info == XLOG_LOGICAL_DECODING_STATUS_CHANGE)
 	{
@@ -9256,7 +9256,7 @@ xlog2_redo(XLogReaderState *record)
 		 * change to checksum status. Once the barrier has been passed we can
 		 * initiate the corresponding processing.
 		 */
-		EmitAndWaitDataChecksumsBarrier(state.new_checksum_state);
+		EmitAndWaitDataChecksumBarrier(state.new_checksum_state);
 	}
 }
 
diff --git a/src/backend/postmaster/bgworker.c b/src/backend/postmaster/bgworker.c
index 2e4acad4f00..68256d90cef 100644
--- a/src/backend/postmaster/bgworker.c
+++ b/src/backend/postmaster/bgworker.c
@@ -160,12 +160,12 @@ static const struct
 		.fn_addr = TableSyncWorkerMain
 	},
 	{
-		.fn_name = "DataChecksumsWorkerLauncherMain",
-		.fn_addr = DataChecksumsWorkerLauncherMain
+		.fn_name = "DataChecksumWorkerLauncherMain",
+		.fn_addr = DataChecksumWorkerLauncherMain
 	},
 	{
-		.fn_name = "DataChecksumsWorkerMain",
-		.fn_addr = DataChecksumsWorkerMain
+		.fn_name = "DataChecksumWorkerMain",
+		.fn_addr = DataChecksumWorkerMain
 	}
 };
 
diff --git a/src/backend/postmaster/datachecksum_state.c b/src/backend/postmaster/datachecksum_state.c
index 33430147ff2..1715e506cbc 100644
--- a/src/backend/postmaster/datachecksum_state.c
+++ b/src/backend/postmaster/datachecksum_state.c
@@ -26,7 +26,7 @@
  * checksums enabled, then disabled them and updated the page while they were
  * disabled.
  *
- * The DataChecksumsWorker will compile a list of all databases at the start,
+ * The DataChecksumWorker will compile a list of all databases at the start,
  * any databases created concurrently will see the in-progress state and will
  * be checksummed automatically.  All databases from the original list MUST BE
  * successfully processed in order for data checksums to be enabled, the only
@@ -99,10 +99,10 @@
  * state will also be set to "off".
  *
  * Backends transition Bd -> Bi via a procsignalbarrier which is emitted by the
- * DataChecksumsWorkerLauncherMain.  When all backends have acknowledged the
+ * DataChecksumWorkerLauncherMain.  When all backends have acknowledged the
  * barrier then Bd will be empty and the next phase can begin: calculating and
- * writing data checksums with DataChecksumsWorkers.  When the
- * DataChecksumsWorker processes have finished writing checksums on all pages,
+ * writing data checksums with DataChecksumWorkers.  When the
+ * DataChecksumWorker processes have finished writing checksums on all pages,
  * data checksums are enabled cluster-wide via another procsignalbarrier.
  * There are four sets of backends where Bd shall be an empty set:
  *
@@ -155,7 +155,7 @@
  * found on the -hackers threads linked to in the commit message of this
  * feature.
  *
- *   * Launching datachecksumsworker for resuming operation from the startup
+ *   * Launching datachecksumworker for resuming operation from the startup
  *     process: Currently users have to restart processing manually after a
  *     restart since dynamic background worker cannot be started from the
  *     postmaster. Changing the startup process could make restarting the
@@ -280,15 +280,15 @@ static const ChecksumBarrierCondition checksum_barriers[9] =
  * Signaling between backends calling pg_enable/disable_data_checksums, the
  * checksums launcher process, and the checksums worker process.
  *
- * This struct is protected by DataChecksumsWorkerLock
+ * This struct is protected by DataChecksumWorkerLock
  */
-typedef struct DataChecksumsStateStruct
+typedef struct DataChecksumStateStruct
 {
 	/*
 	 * These are set by pg_{enable|disable}_data_checksums, to tell the
 	 * launcher what the target state is.
 	 */
-	DataChecksumsWorkerOperation launch_operation;
+	DataChecksumWorkerOperation launch_operation;
 	int			launch_cost_delay;
 	int			launch_cost_limit;
 
@@ -315,7 +315,7 @@ typedef struct DataChecksumsStateStruct
 	 * without a lock. If multiple workers, or dynamic cost parameters, are
 	 * supported at some point then this would need to be revisited.
 	 */
-	DataChecksumsWorkerOperation operation;
+	DataChecksumWorkerOperation operation;
 	int			cost_delay;
 	int			cost_limit;
 
@@ -329,58 +329,58 @@ typedef struct DataChecksumsStateStruct
 	 */
 
 	/* result, set by worker before exiting */
-	DataChecksumsWorkerResult success;
+	DataChecksumWorkerResult success;
 
 	/*
 	 * Tells the worker process whether it should also process the shared
 	 * catalogs
 	 */
 	bool		process_shared_catalogs;
-} DataChecksumsStateStruct;
+} DataChecksumStateStruct;
 
-/* Shared memory segment for datachecksumsworker */
-static DataChecksumsStateStruct *DataChecksumState;
+/* Shared memory segment for datachecksumworker */
+static DataChecksumStateStruct *DataChecksumState;
 
-typedef struct DataChecksumsWorkerDatabase
+typedef struct DataChecksumWorkerDatabase
 {
 	Oid			dboid;
 	char	   *dbname;
-} DataChecksumsWorkerDatabase;
+} DataChecksumWorkerDatabase;
 
 /* Flag set by the interrupt handler */
 static volatile sig_atomic_t abort_requested = false;
 
 /*
- * Have we set the DataChecksumsStateStruct->launcher_running flag?
+ * Have we set the DataChecksumStateStruct->launcher_running flag?
  * If we have, we need to clear it before exiting!
  */
 static volatile sig_atomic_t launcher_running = false;
 
 /* Are we enabling data checksums, or disabling them? */
-static DataChecksumsWorkerOperation operation;
+static DataChecksumWorkerOperation operation;
 
 /* Prototypes */
-static void DataChecksumsShmemRequest(void *arg);
+static void DataChecksumShmemRequest(void *arg);
 static bool DatabaseExists(Oid dboid);
 static List *BuildDatabaseList(void);
 static List *BuildRelationList(bool temp_relations, bool include_shared);
 static void FreeDatabaseList(List *dblist);
-static DataChecksumsWorkerResult ProcessDatabase(DataChecksumsWorkerDatabase *db);
+static DataChecksumWorkerResult ProcessDatabase(DataChecksumWorkerDatabase *db);
 static bool ProcessAllDatabases(void);
 static bool ProcessSingleRelationFork(Relation reln, ForkNumber forkNum, BufferAccessStrategy strategy);
 static void launcher_cancel_handler(SIGNAL_ARGS);
 static void WaitForAllTransactionsToFinish(void);
 
-const ShmemCallbacks DataChecksumsShmemCallbacks = {
-	.request_fn = DataChecksumsShmemRequest,
+const ShmemCallbacks DataChecksumShmemCallbacks = {
+	.request_fn = DataChecksumShmemRequest,
 };
 
 #define CHECK_FOR_ABORT_REQUEST() \
 	do {															\
-		LWLockAcquire(DataChecksumsWorkerLock, LW_SHARED);			\
+		LWLockAcquire(DataChecksumWorkerLock, LW_SHARED);			\
 		if (DataChecksumState->launch_operation != operation)		\
 			abort_requested = true;									\
-		LWLockRelease(DataChecksumsWorkerLock);						\
+		LWLockRelease(DataChecksumWorkerLock);						\
 	} while (0)
 
 
@@ -389,7 +389,7 @@ const ShmemCallbacks DataChecksumsShmemCallbacks = {
  */
 
 void
-EmitAndWaitDataChecksumsBarrier(uint32 state)
+EmitAndWaitDataChecksumBarrier(uint32 state)
 {
 	uint64		barrier;
 
@@ -421,7 +421,7 @@ EmitAndWaitDataChecksumsBarrier(uint32 state)
 }
 
 /*
- * AbsorbDataChecksumsBarrier
+ * AbsorbDataChecksumBarrier
  *		Generic function for absorbing data checksum state changes
  *
  * All procsignalbarriers regarding data checksum state changes are absorbed
@@ -430,7 +430,7 @@ EmitAndWaitDataChecksumsBarrier(uint32 state)
  * used to look up the relevant entry.
  */
 bool
-AbsorbDataChecksumsBarrier(ProcSignalBarrierType barrier)
+AbsorbDataChecksumBarrier(ProcSignalBarrierType barrier)
 {
 	uint32		target_state;
 	int			current = data_checksums;
@@ -516,7 +516,7 @@ disable_data_checksums(PG_FUNCTION_ARGS)
 				errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				errmsg("must be superuser to change data checksum state"));
 
-	StartDataChecksumsWorkerLauncher(DISABLE_DATACHECKSUMS, 0, 0);
+	StartDataChecksumWorkerLauncher(DISABLE_DATACHECKSUMS, 0, 0);
 	PG_RETURN_VOID();
 }
 
@@ -548,27 +548,27 @@ enable_data_checksums(PG_FUNCTION_ARGS)
 				errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 				errmsg("cost limit must be greater than zero"));
 
-	StartDataChecksumsWorkerLauncher(ENABLE_DATACHECKSUMS, cost_delay, cost_limit);
+	StartDataChecksumWorkerLauncher(ENABLE_DATACHECKSUMS, cost_delay, cost_limit);
 
 	PG_RETURN_VOID();
 }
 
 
 /*****************************************************************************
- * Functionality for running the datachecksumsworker and associated launcher
+ * Functionality for running the datachecksum worker and associated launcher
  */
 
 /*
- * StartDataChecksumsWorkerLauncher
- *		Main entry point for datachecksumsworker launcher process
+ * StartDataChecksumWorkerLauncher
+ *		Main entry point for datachecksumworker launcher process
  *
  * The main entrypoint for starting data checksums processing for enabling as
  * well as disabling.
  */
 void
-StartDataChecksumsWorkerLauncher(DataChecksumsWorkerOperation op,
-								 int cost_delay,
-								 int cost_limit)
+StartDataChecksumWorkerLauncher(DataChecksumWorkerOperation op,
+								int cost_delay,
+								int cost_limit)
 {
 	BackgroundWorker bgw;
 	BackgroundWorkerHandle *bgw_handle;
@@ -580,10 +580,10 @@ StartDataChecksumsWorkerLauncher(DataChecksumsWorkerOperation op,
 		Assert(cost_delay == 0 && cost_limit == 0);
 #endif
 
-	INJECTION_POINT("datachecksumsworker-startup-delay", NULL);
+	INJECTION_POINT("datachecksumworker-startup-delay", NULL);
 
 	/* Store the desired state in shared memory */
-	LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+	LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 
 	DataChecksumState->launch_operation = op;
 	DataChecksumState->launch_cost_delay = cost_delay;
@@ -592,7 +592,7 @@ StartDataChecksumsWorkerLauncher(DataChecksumsWorkerOperation op,
 	/* Is the launcher already running? If so, what is it doing? */
 	running = DataChecksumState->launcher_running;
 
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockRelease(DataChecksumWorkerLock);
 
 	/*
 	 * Launch a new launcher process, if it's not running already.
@@ -625,7 +625,7 @@ StartDataChecksumsWorkerLauncher(DataChecksumsWorkerOperation op,
 		bgw.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION;
 		bgw.bgw_start_time = BgWorkerStart_RecoveryFinished;
 		snprintf(bgw.bgw_library_name, BGW_MAXLEN, "postgres");
-		snprintf(bgw.bgw_function_name, BGW_MAXLEN, "DataChecksumsWorkerLauncherMain");
+		snprintf(bgw.bgw_function_name, BGW_MAXLEN, "DataChecksumWorkerLauncherMain");
 		snprintf(bgw.bgw_name, BGW_MAXLEN, "datachecksum launcher");
 		snprintf(bgw.bgw_type, BGW_MAXLEN, "datachecksum launcher");
 		bgw.bgw_restart_time = BGW_NEVER_RESTART;
@@ -715,10 +715,10 @@ ProcessSingleRelationFork(Relation reln, ForkNumber forkNum, BufferAccessStrateg
 		 * abortion will bubble up from here.
 		 */
 		Assert(operation == ENABLE_DATACHECKSUMS);
-		LWLockAcquire(DataChecksumsWorkerLock, LW_SHARED);
+		LWLockAcquire(DataChecksumWorkerLock, LW_SHARED);
 		if (DataChecksumState->launch_operation == DISABLE_DATACHECKSUMS)
 			abort_requested = true;
-		LWLockRelease(DataChecksumsWorkerLock);
+		LWLockRelease(DataChecksumWorkerLock);
 
 		if (abort_requested)
 			return false;
@@ -795,8 +795,8 @@ ProcessSingleRelationByOid(Oid relationId, BufferAccessStrategy strategy)
  * waiting for it to finish.  We have to do this in a separate worker, since
  * each process can only be connected to one database during its lifetime.
  */
-static DataChecksumsWorkerResult
-ProcessDatabase(DataChecksumsWorkerDatabase *db)
+static DataChecksumWorkerResult
+ProcessDatabase(DataChecksumWorkerDatabase *db)
 {
 	BackgroundWorker bgw;
 	BackgroundWorkerHandle *bgw_handle;
@@ -804,15 +804,15 @@ ProcessDatabase(DataChecksumsWorkerDatabase *db)
 	pid_t		pid;
 	char		activity[NAMEDATALEN + 64];
 
-	LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
-	DataChecksumState->success = DATACHECKSUMSWORKER_FAILED;
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
+	DataChecksumState->success = DATACHECKSUMWORKER_FAILED;
+	LWLockRelease(DataChecksumWorkerLock);
 
 	memset(&bgw, 0, sizeof(bgw));
 	bgw.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION;
 	bgw.bgw_start_time = BgWorkerStart_RecoveryFinished;
 	snprintf(bgw.bgw_library_name, BGW_MAXLEN, "postgres");
-	snprintf(bgw.bgw_function_name, BGW_MAXLEN, "%s", "DataChecksumsWorkerMain");
+	snprintf(bgw.bgw_function_name, BGW_MAXLEN, "%s", "DataChecksumWorkerMain");
 	snprintf(bgw.bgw_name, BGW_MAXLEN, "datachecksum worker");
 	snprintf(bgw.bgw_type, BGW_MAXLEN, "datachecksum worker");
 	bgw.bgw_restart_time = BGW_NEVER_RESTART;
@@ -830,7 +830,7 @@ ProcessDatabase(DataChecksumsWorkerDatabase *db)
 				errmsg("could not start background worker for enabling data checksums in database \"%s\"",
 					   db->dbname),
 				errhint("The \"%s\" setting might be too low.", "max_worker_processes"));
-		return DATACHECKSUMSWORKER_FAILED;
+		return DATACHECKSUMWORKER_FAILED;
 	}
 
 	status = WaitForBackgroundWorkerStartup(bgw_handle, &pid);
@@ -840,17 +840,17 @@ ProcessDatabase(DataChecksumsWorkerDatabase *db)
 		 * If the worker managed to start, and stop, before we got to waiting
 		 * for it we can see a STOPPED status here without it being a failure.
 		 */
-		LWLockAcquire(DataChecksumsWorkerLock, LW_SHARED);
-		if (DataChecksumState->success == DATACHECKSUMSWORKER_SUCCESSFUL)
+		LWLockAcquire(DataChecksumWorkerLock, LW_SHARED);
+		if (DataChecksumState->success == DATACHECKSUMWORKER_SUCCESSFUL)
 		{
-			LWLockRelease(DataChecksumsWorkerLock);
+			LWLockRelease(DataChecksumWorkerLock);
 			pgstat_report_activity(STATE_IDLE, NULL);
-			LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+			LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 			DataChecksumState->worker_pid = InvalidPid;
-			LWLockRelease(DataChecksumsWorkerLock);
+			LWLockRelease(DataChecksumWorkerLock);
 			return DataChecksumState->success;
 		}
-		LWLockRelease(DataChecksumsWorkerLock);
+		LWLockRelease(DataChecksumWorkerLock);
 
 		ereport(WARNING,
 				errmsg("could not start background worker for enabling data checksums in database \"%s\"",
@@ -862,9 +862,9 @@ ProcessDatabase(DataChecksumsWorkerDatabase *db)
 		 * treat it as not an error, else treat as fatal and error out.
 		 */
 		if (DatabaseExists(db->dboid))
-			return DATACHECKSUMSWORKER_FAILED;
+			return DATACHECKSUMWORKER_FAILED;
 		else
-			return DATACHECKSUMSWORKER_DROPDB;
+			return DATACHECKSUMWORKER_DROPDB;
 	}
 
 	/*
@@ -886,9 +886,9 @@ ProcessDatabase(DataChecksumsWorkerDatabase *db)
 				   db->dbname));
 
 	/* Save the pid of the worker so we can signal it later */
-	LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+	LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 	DataChecksumState->worker_pid = pid;
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockRelease(DataChecksumWorkerLock);
 
 	snprintf(activity, sizeof(activity) - 1,
 			 "Waiting for worker in database %s (pid %ld)", db->dbname, (long) pid);
@@ -902,17 +902,17 @@ ProcessDatabase(DataChecksumsWorkerDatabase *db)
 					   db->dbname),
 				errhint("Restart the database and restart data checksum processing by calling pg_enable_data_checksums()."));
 
-	LWLockAcquire(DataChecksumsWorkerLock, LW_SHARED);
-	if (DataChecksumState->success == DATACHECKSUMSWORKER_ABORTED)
+	LWLockAcquire(DataChecksumWorkerLock, LW_SHARED);
+	if (DataChecksumState->success == DATACHECKSUMWORKER_ABORTED)
 		ereport(LOG,
 				errmsg("data checksums processing was aborted in database \"%s\"",
 					   db->dbname));
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockRelease(DataChecksumWorkerLock);
 
 	pgstat_report_activity(STATE_IDLE, NULL);
-	LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+	LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 	DataChecksumState->worker_pid = InvalidPid;
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockRelease(DataChecksumWorkerLock);
 
 	return DataChecksumState->success;
 }
@@ -934,14 +934,14 @@ launcher_exit(int code, Datum arg)
 
 	if (launcher_running)
 	{
-		LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+		LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 		if (DataChecksumState->worker_pid != InvalidPid)
 		{
 			ereport(LOG,
 					errmsg("data checksums launcher exiting while worker is still running, signalling worker"));
 			kill(DataChecksumState->worker_pid, SIGTERM);
 		}
-		LWLockRelease(DataChecksumsWorkerLock);
+		LWLockRelease(DataChecksumWorkerLock);
 	}
 
 	/*
@@ -951,10 +951,10 @@ launcher_exit(int code, Datum arg)
 	if (DataChecksumsInProgressOn())
 		SetDataChecksumsOff();
 
-	LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+	LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 	launcher_running = false;
 	DataChecksumState->launcher_running = false;
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockRelease(DataChecksumWorkerLock);
 }
 
 /*
@@ -1044,7 +1044,7 @@ WaitForAllTransactionsToFinish(void)
 }
 
 /*
- * DataChecksumsWorkerLauncherMain
+ * DataChecksumWorkerLauncherMain
  *
  * Main function for launching dynamic background workers for processing data
  * checksums in databases. This function has the bgworker management, with
@@ -1052,11 +1052,11 @@ WaitForAllTransactionsToFinish(void)
  * initiating processing.
  */
 void
-DataChecksumsWorkerLauncherMain(Datum arg)
+DataChecksumWorkerLauncherMain(Datum arg)
 {
 
 	ereport(DEBUG1,
-			errmsg("background worker \"datachecksums launcher\" started"));
+			errmsg("background worker \"datachecksum launcher\" started"));
 
 	pqsignal(SIGTERM, die);
 	pqsignal(SIGINT, launcher_cancel_handler);
@@ -1065,19 +1065,19 @@ DataChecksumsWorkerLauncherMain(Datum arg)
 
 	BackgroundWorkerUnblockSignals();
 
-	MyBackendType = B_DATACHECKSUMSWORKER_LAUNCHER;
+	MyBackendType = B_DATACHECKSUMWORKER_LAUNCHER;
 	init_ps_display(NULL);
 
-	INJECTION_POINT("datachecksumsworker-launcher-delay", NULL);
+	INJECTION_POINT("datachecksumworker-launcher-delay", NULL);
 
-	LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+	LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 
 	if (DataChecksumState->launcher_running)
 	{
 		ereport(LOG,
-				errmsg("background worker \"datachecksums launcher\" already running, exiting"));
+				errmsg("background worker \"datachecksum launcher\" already running, exiting"));
 		/* Launcher was already running, let it finish */
-		LWLockRelease(DataChecksumsWorkerLock);
+		LWLockRelease(DataChecksumWorkerLock);
 		return;
 	}
 
@@ -1092,7 +1092,7 @@ DataChecksumsWorkerLauncherMain(Datum arg)
 	DataChecksumState->operation = operation;
 	DataChecksumState->cost_delay = DataChecksumState->launch_cost_delay;
 	DataChecksumState->cost_limit = DataChecksumState->launch_cost_limit;
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockRelease(DataChecksumWorkerLock);
 
 	/*
 	 * The target state can change while we are busy enabling/disabling
@@ -1134,13 +1134,13 @@ again:
 			 * If the target state changed during processing then it's not a
 			 * failure, so restart processing instead.
 			 */
-			LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+			LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 			if (DataChecksumState->launch_operation != operation)
 			{
-				LWLockRelease(DataChecksumsWorkerLock);
+				LWLockRelease(DataChecksumWorkerLock);
 				goto done;
 			}
-			LWLockRelease(DataChecksumsWorkerLock);
+			LWLockRelease(DataChecksumWorkerLock);
 			ereport(ERROR,
 					errcode(ERRCODE_INSUFFICIENT_RESOURCES),
 					errmsg("unable to enable data checksums in cluster"));
@@ -1183,14 +1183,14 @@ done:
 	 * while we were running. In that case we will have to start all over
 	 * again.
 	 */
-	LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+	LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 	if (DataChecksumState->launch_operation != operation)
 	{
 		DataChecksumState->operation = DataChecksumState->launch_operation;
 		operation = DataChecksumState->launch_operation;
 		DataChecksumState->cost_delay = DataChecksumState->launch_cost_delay;
 		DataChecksumState->cost_limit = DataChecksumState->launch_cost_limit;
-		LWLockRelease(DataChecksumsWorkerLock);
+		LWLockRelease(DataChecksumWorkerLock);
 		goto again;
 	}
 
@@ -1199,7 +1199,7 @@ done:
 
 	launcher_running = false;
 	DataChecksumState->launcher_running = false;
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockRelease(DataChecksumWorkerLock);
 }
 
 /*
@@ -1217,9 +1217,9 @@ ProcessAllDatabases(void)
 	int			cumulative_total = 0;
 
 	/* Set up so first run processes shared catalogs, not once in every db */
-	LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+	LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 	DataChecksumState->process_shared_catalogs = true;
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockRelease(DataChecksumWorkerLock);
 
 	/* Get a list of all databases to process */
 	WaitForAllTransactionsToFinish();
@@ -1254,18 +1254,18 @@ ProcessAllDatabases(void)
 		pgstat_progress_update_multi_param(6, index, vals);
 	}
 
-	foreach_ptr(DataChecksumsWorkerDatabase, db, DatabaseList)
+	foreach_ptr(DataChecksumWorkerDatabase, db, DatabaseList)
 	{
-		DataChecksumsWorkerResult result;
+		DataChecksumWorkerResult result;
 
 		result = ProcessDatabase(db);
 
 #ifdef USE_INJECTION_POINTS
 		/* Allow a test process to alter the result of the operation */
-		if (IS_INJECTION_POINT_ATTACHED("datachecksumsworker-fail-db-result"))
+		if (IS_INJECTION_POINT_ATTACHED("datachecksumworker-fail-db-result"))
 		{
-			result = DATACHECKSUMSWORKER_FAILED;
-			INJECTION_POINT_CACHED("datachecksumsworker-fail-db-result",
+			result = DATACHECKSUMWORKER_FAILED;
+			INJECTION_POINT_CACHED("datachecksumworker-fail-db-result",
 								   db->dbname);
 		}
 #endif
@@ -1273,7 +1273,7 @@ ProcessAllDatabases(void)
 		pgstat_progress_update_param(PROGRESS_DATACHECKSUMS_DBS_DONE,
 									 ++cumulative_total);
 
-		if (result == DATACHECKSUMSWORKER_FAILED)
+		if (result == DATACHECKSUMWORKER_FAILED)
 		{
 			/*
 			 * Disable checksums on cluster, because we failed one of the
@@ -1285,7 +1285,7 @@ ProcessAllDatabases(void)
 					errmsg("data checksums failed to get enabled in all databases, aborting"),
 					errhint("The server log might have more information on the cause of the error."));
 		}
-		else if (result == DATACHECKSUMSWORKER_ABORTED || abort_requested)
+		else if (result == DATACHECKSUMWORKER_ABORTED || abort_requested)
 		{
 			/* Abort flag set, so exit the whole process */
 			return false;
@@ -1295,9 +1295,9 @@ ProcessAllDatabases(void)
 		 * When one database has completed, it will have done shared catalogs
 		 * so we don't have to process them again.
 		 */
-		LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+		LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 		DataChecksumState->process_shared_catalogs = false;
-		LWLockRelease(DataChecksumsWorkerLock);
+		LWLockRelease(DataChecksumWorkerLock);
 	}
 
 	FreeDatabaseList(DatabaseList);
@@ -1308,14 +1308,14 @@ ProcessAllDatabases(void)
 }
 
 /*
- * DataChecksumsShmemRequest
- *		Request datachecksumsworker-related shared memory
+ * DataChecksumShmemRequest
+ *		Request datachecksumworker-related shared memory
  */
 static void
-DataChecksumsShmemRequest(void *arg)
+DataChecksumShmemRequest(void *arg)
 {
-	ShmemRequestStruct(.name = "DataChecksumsWorker Data",
-					   .size = sizeof(DataChecksumsStateStruct),
+	ShmemRequestStruct(.name = "DataChecksumWorker Data",
+					   .size = sizeof(DataChecksumStateStruct),
 					   .ptr = (void **) &DataChecksumState,
 		);
 }
@@ -1370,7 +1370,7 @@ DatabaseExists(Oid dboid)
  * BuildDatabaseList
  *		Compile a list of all currently available databases in the cluster
  *
- * This creates the list of databases for the datachecksumsworker workers to
+ * This creates the list of databases for the datachecksum workers to
  * add checksums to. If the caller wants to ensure that no concurrently
  * running CREATE DATABASE calls exist, this needs to be preceded by a call
  * to WaitForAllTransactionsToFinish().
@@ -1393,11 +1393,11 @@ BuildDatabaseList(void)
 	while (HeapTupleIsValid(tup = heap_getnext(scan, ForwardScanDirection)))
 	{
 		Form_pg_database pgdb = (Form_pg_database) GETSTRUCT(tup);
-		DataChecksumsWorkerDatabase *db;
+		DataChecksumWorkerDatabase *db;
 
 		oldctx = MemoryContextSwitchTo(ctx);
 
-		db = (DataChecksumsWorkerDatabase *) palloc0(sizeof(DataChecksumsWorkerDatabase));
+		db = (DataChecksumWorkerDatabase *) palloc0(sizeof(DataChecksumWorkerDatabase));
 
 		db->dboid = pgdb->oid;
 		db->dbname = pstrdup(NameStr(pgdb->datname));
@@ -1421,7 +1421,7 @@ FreeDatabaseList(List *dblist)
 	if (!dblist)
 		return;
 
-	foreach_ptr(DataChecksumsWorkerDatabase, db, dblist)
+	foreach_ptr(DataChecksumWorkerDatabase, db, dblist)
 	{
 		if (db->dbname != NULL)
 			pfree(db->dbname);
@@ -1496,7 +1496,7 @@ BuildRelationList(bool temp_relations, bool include_shared)
 }
 
 /*
- * DataChecksumsWorkerMain
+ * DataChecksumWorkerMain
  *
  * Main function for enabling checksums in a single database. This is the
  * function set as the bgw_function_name in the dynamic background worker
@@ -1507,7 +1507,7 @@ BuildRelationList(bool temp_relations, bool include_shared)
  * existing temporary relations with data checksums.
  */
 void
-DataChecksumsWorkerMain(Datum arg)
+DataChecksumWorkerMain(Datum arg)
 {
 	Oid			dboid = DatumGetObjectId(arg);
 	List	   *RelationList = NIL;
@@ -1526,7 +1526,7 @@ DataChecksumsWorkerMain(Datum arg)
 
 	BackgroundWorkerUnblockSignals();
 
-	MyBackendType = B_DATACHECKSUMSWORKER_WORKER;
+	MyBackendType = B_DATACHECKSUMWORKER_WORKER;
 	init_ps_display(NULL);
 
 	BackgroundWorkerInitializeConnectionByOid(dboid, InvalidOid,
@@ -1606,7 +1606,7 @@ DataChecksumsWorkerMain(Datum arg)
 		 * to reflect the new values and signal that the access strategy needs
 		 * to be refreshed.
 		 */
-		LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
+		LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
 		if ((DataChecksumState->launch_cost_delay != DataChecksumState->cost_delay)
 			|| (DataChecksumState->launch_cost_limit != DataChecksumState->cost_limit))
 		{
@@ -1620,7 +1620,7 @@ DataChecksumsWorkerMain(Datum arg)
 		}
 		else
 			costs_updated = false;
-		LWLockRelease(DataChecksumsWorkerLock);
+		LWLockRelease(DataChecksumWorkerLock);
 
 		if (costs_updated)
 		{
@@ -1634,9 +1634,9 @@ DataChecksumsWorkerMain(Datum arg)
 
 	if (aborted || abort_requested)
 	{
-		LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
-		DataChecksumState->success = DATACHECKSUMSWORKER_ABORTED;
-		LWLockRelease(DataChecksumsWorkerLock);
+		LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
+		DataChecksumState->success = DATACHECKSUMWORKER_ABORTED;
+		LWLockRelease(DataChecksumWorkerLock);
 		ereport(DEBUG1,
 				errmsg("data checksum processing aborted in database OID %u",
 					   dboid));
@@ -1669,7 +1669,7 @@ DataChecksumsWorkerMain(Datum arg)
 		list_free(CurrentTempTables);
 
 #ifdef USE_INJECTION_POINTS
-		if (IS_INJECTION_POINT_ATTACHED("datachecksumsworker-fake-temptable-wait"))
+		if (IS_INJECTION_POINT_ATTACHED("datachecksumworker-fake-temptable-wait"))
 		{
 			/* Make sure to just cause one retry */
 			if (!retried && numleft == 0)
@@ -1677,7 +1677,7 @@ DataChecksumsWorkerMain(Datum arg)
 				numleft = 1;
 				retried = true;
 
-				INJECTION_POINT_CACHED("datachecksumsworker-fake-temptable-wait", NULL);
+				INJECTION_POINT_CACHED("datachecksumworker-fake-temptable-wait", NULL);
 			}
 		}
 #endif
@@ -1706,9 +1706,9 @@ DataChecksumsWorkerMain(Datum arg)
 
 		if (aborted || abort_requested)
 		{
-			LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
-			DataChecksumState->success = DATACHECKSUMSWORKER_ABORTED;
-			LWLockRelease(DataChecksumsWorkerLock);
+			LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
+			DataChecksumState->success = DATACHECKSUMWORKER_ABORTED;
+			LWLockRelease(DataChecksumWorkerLock);
 			ereport(LOG,
 					errmsg("data checksum processing aborted in database OID %u",
 						   dboid));
@@ -1721,7 +1721,7 @@ DataChecksumsWorkerMain(Datum arg)
 	/* worker done */
 	pgstat_progress_end_command();
 
-	LWLockAcquire(DataChecksumsWorkerLock, LW_EXCLUSIVE);
-	DataChecksumState->success = DATACHECKSUMSWORKER_SUCCESSFUL;
-	LWLockRelease(DataChecksumsWorkerLock);
+	LWLockAcquire(DataChecksumWorkerLock, LW_EXCLUSIVE);
+	DataChecksumState->success = DATACHECKSUMWORKER_SUCCESSFUL;
+	LWLockRelease(DataChecksumWorkerLock);
 }
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index 90c7c4528e8..0debcb18991 100644
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -3010,8 +3010,8 @@ PostmasterStateMachine(void)
 
 			/* also add data checksums processes */
 			remainMask = btmask_add(remainMask,
-									B_DATACHECKSUMSWORKER_LAUNCHER,
-									B_DATACHECKSUMSWORKER_WORKER);
+									B_DATACHECKSUMWORKER_LAUNCHER,
+									B_DATACHECKSUMWORKER_WORKER);
 
 			/* All types should be included in targetMask or remainMask */
 			Assert((remainMask.mask | targetMask.mask) == BTYPE_MASK_ALL.mask);
diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index 1397f65f67b..0e0c7acf0df 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -596,7 +596,7 @@ ProcessProcSignalBarrier(void)
 					case PROCSIGNAL_BARRIER_CHECKSUM_ON:
 					case PROCSIGNAL_BARRIER_CHECKSUM_INPROGRESS_OFF:
 					case PROCSIGNAL_BARRIER_CHECKSUM_OFF:
-						processed = AbsorbDataChecksumsBarrier(type);
+						processed = AbsorbDataChecksumBarrier(type);
 						break;
 				}
 
diff --git a/src/backend/utils/activity/pgstat_backend.c b/src/backend/utils/activity/pgstat_backend.c
index 73461c9bca5..bccf6f27121 100644
--- a/src/backend/utils/activity/pgstat_backend.c
+++ b/src/backend/utils/activity/pgstat_backend.c
@@ -381,8 +381,8 @@ pgstat_tracks_backend_bktype(BackendType bktype)
 		case B_CHECKPOINTER:
 		case B_IO_WORKER:
 		case B_STARTUP:
-		case B_DATACHECKSUMSWORKER_LAUNCHER:
-		case B_DATACHECKSUMSWORKER_WORKER:
+		case B_DATACHECKSUMWORKER_LAUNCHER:
+		case B_DATACHECKSUMWORKER_WORKER:
 			return false;
 
 		case B_AUTOVAC_WORKER:
diff --git a/src/backend/utils/activity/pgstat_io.c b/src/backend/utils/activity/pgstat_io.c
index 13a5d8e6440..49f0466040b 100644
--- a/src/backend/utils/activity/pgstat_io.c
+++ b/src/backend/utils/activity/pgstat_io.c
@@ -362,8 +362,8 @@ pgstat_tracks_io_bktype(BackendType bktype)
 		case B_LOGGER:
 			return false;
 
-		case B_DATACHECKSUMSWORKER_LAUNCHER:
-		case B_DATACHECKSUMSWORKER_WORKER:
+		case B_DATACHECKSUMWORKER_LAUNCHER:
+		case B_DATACHECKSUMWORKER_WORKER:
 		case B_AUTOVAC_LAUNCHER:
 		case B_AUTOVAC_WORKER:
 		case B_BACKEND:
diff --git a/src/backend/utils/init/miscinit.c b/src/backend/utils/init/miscinit.c
index 7ffc808073a..42a0e896f1d 100644
--- a/src/backend/utils/init/miscinit.c
+++ b/src/backend/utils/init/miscinit.c
@@ -846,7 +846,7 @@ InitializeSessionUserIdStandalone(void)
 	 */
 	Assert(!IsUnderPostmaster || AmAutoVacuumWorkerProcess() ||
 		   AmLogicalSlotSyncWorkerProcess() || AmBackgroundWorkerProcess() ||
-		   AmDataChecksumsWorkerProcess());
+		   AmDataChecksumWorkerProcess());
 
 	/* call only once */
 	Assert(!OidIsValid(AuthenticatedUserId));
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 2460e550f96..9acd984da42 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -921,7 +921,7 @@ InitPostgres(const char *in_dbname, Oid dboid,
 					 errhint("You should immediately run CREATE USER \"%s\" SUPERUSER;.",
 							 username != NULL ? username : "postgres")));
 	}
-	else if (AmBackgroundWorkerProcess() || AmDataChecksumsWorkerProcess())
+	else if (AmBackgroundWorkerProcess() || AmDataChecksumWorkerProcess())
 	{
 		if (username == NULL && !OidIsValid(useroid))
 		{
diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
index 7de0a115402..bc538ac212e 100644
--- a/src/include/miscadmin.h
+++ b/src/include/miscadmin.h
@@ -370,8 +370,8 @@ typedef enum BackendType
 	B_WAL_SUMMARIZER,
 	B_WAL_WRITER,
 
-	B_DATACHECKSUMSWORKER_LAUNCHER,
-	B_DATACHECKSUMSWORKER_WORKER,
+	B_DATACHECKSUMWORKER_LAUNCHER,
+	B_DATACHECKSUMWORKER_WORKER,
 
 	/*
 	 * Logger is not connected to shared memory and does not have a PGPROC
@@ -398,9 +398,9 @@ extern PGDLLIMPORT BackendType MyBackendType;
 #define AmWalSummarizerProcess()	(MyBackendType == B_WAL_SUMMARIZER)
 #define AmWalWriterProcess()		(MyBackendType == B_WAL_WRITER)
 #define AmIoWorkerProcess()			(MyBackendType == B_IO_WORKER)
-#define AmDataChecksumsWorkerProcess() \
-	(MyBackendType == B_DATACHECKSUMSWORKER_LAUNCHER || \
-	 MyBackendType == B_DATACHECKSUMSWORKER_WORKER)
+#define AmDataChecksumWorkerProcess() \
+	(MyBackendType == B_DATACHECKSUMWORKER_LAUNCHER || \
+	 MyBackendType == B_DATACHECKSUMWORKER_WORKER)
 
 #define AmSpecialWorkerProcess() \
 	(AmAutoVacuumLauncherProcess() || \
diff --git a/src/include/postmaster/datachecksum_state.h b/src/include/postmaster/datachecksum_state.h
index 2a1ae10d55d..4426f9dc622 100644
--- a/src/include/postmaster/datachecksum_state.h
+++ b/src/include/postmaster/datachecksum_state.h
@@ -17,12 +17,12 @@
 
 #include "storage/procsignal.h"
 
-/* Possible operations the DataChecksumsWorker can perform */
-typedef enum DataChecksumsWorkerOperation
+/* Possible operations the DataChecksumWorker can perform */
+typedef enum DataChecksumWorkerOperation
 {
 	ENABLE_DATACHECKSUMS,
 	DISABLE_DATACHECKSUMS,
-} DataChecksumsWorkerOperation;
+} DataChecksumWorkerOperation;
 
 /*
  * Possible states for a database entry which has been processed. Exported
@@ -30,25 +30,25 @@ typedef enum DataChecksumsWorkerOperation
  */
 typedef enum
 {
-	DATACHECKSUMSWORKER_SUCCESSFUL = 0,
-	DATACHECKSUMSWORKER_ABORTED,
-	DATACHECKSUMSWORKER_FAILED,
-	DATACHECKSUMSWORKER_DROPDB,
-} DataChecksumsWorkerResult;
+	DATACHECKSUMWORKER_SUCCESSFUL = 0,
+	DATACHECKSUMWORKER_ABORTED,
+	DATACHECKSUMWORKER_FAILED,
+	DATACHECKSUMWORKER_DROPDB,
+} DataChecksumWorkerResult;
 
 /* Prototypes for data checksum state manipulation */
-bool		AbsorbDataChecksumsBarrier(ProcSignalBarrierType barrier);
-void		EmitAndWaitDataChecksumsBarrier(uint32 state);
+bool		AbsorbDataChecksumBarrier(ProcSignalBarrierType barrier);
+void		EmitAndWaitDataChecksumBarrier(uint32 state);
 
 /* Prototypes for data checksum background worker */
 
 /* Start the background processes for enabling or disabling checksums */
-void		StartDataChecksumsWorkerLauncher(DataChecksumsWorkerOperation op,
-											 int cost_delay,
-											 int cost_limit);
+void		StartDataChecksumWorkerLauncher(DataChecksumWorkerOperation op,
+											int cost_delay,
+											int cost_limit);
 
 /* Background worker entrypoints */
-void		DataChecksumsWorkerLauncherMain(Datum arg);
-void		DataChecksumsWorkerMain(Datum arg);
+void		DataChecksumWorkerLauncherMain(Datum arg);
+void		DataChecksumWorkerMain(Datum arg);
 
 #endif							/* DATACHECKSUM_STATE_H */
diff --git a/src/include/postmaster/proctypelist.h b/src/include/postmaster/proctypelist.h
index b3477e6f17a..ec84860a613 100644
--- a/src/include/postmaster/proctypelist.h
+++ b/src/include/postmaster/proctypelist.h
@@ -38,8 +38,8 @@ PG_PROCTYPE(B_BACKEND, "backend", gettext_noop("client backend"), BackendMain, t
 PG_PROCTYPE(B_BG_WORKER, "bgworker", gettext_noop("background worker"), BackgroundWorkerMain, true)
 PG_PROCTYPE(B_BG_WRITER, "bgwriter", gettext_noop("background writer"), BackgroundWriterMain, true)
 PG_PROCTYPE(B_CHECKPOINTER, "checkpointer", gettext_noop("checkpointer"), CheckpointerMain, true)
-PG_PROCTYPE(B_DATACHECKSUMSWORKER_LAUNCHER, "checksums", gettext_noop("datachecksum launcher"), NULL, false)
-PG_PROCTYPE(B_DATACHECKSUMSWORKER_WORKER, "checksums", gettext_noop("datachecksum worker"), NULL, false)
+PG_PROCTYPE(B_DATACHECKSUMWORKER_LAUNCHER, "checksums", gettext_noop("datachecksum launcher"), NULL, false)
+PG_PROCTYPE(B_DATACHECKSUMWORKER_WORKER, "checksums", gettext_noop("datachecksum worker"), NULL, false)
 PG_PROCTYPE(B_DEAD_END_BACKEND, "backend", gettext_noop("dead-end client backend"), BackendMain, true)
 PG_PROCTYPE(B_INVALID, "postmaster", gettext_noop("unrecognized"), NULL, false)
 PG_PROCTYPE(B_IO_WORKER, "ioworker", gettext_noop("io worker"), IoWorkerMain, true)
diff --git a/src/include/storage/subsystemlist.h b/src/include/storage/subsystemlist.h
index 9ad619080be..e9bd1ce0681 100644
--- a/src/include/storage/subsystemlist.h
+++ b/src/include/storage/subsystemlist.h
@@ -84,7 +84,7 @@ PG_SHMEM_SUBSYSTEM(InjectionPointShmemCallbacks)
 #endif
 PG_SHMEM_SUBSYSTEM(WaitLSNShmemCallbacks)
 PG_SHMEM_SUBSYSTEM(LogicalDecodingCtlShmemCallbacks)
-PG_SHMEM_SUBSYSTEM(DataChecksumsShmemCallbacks)
+PG_SHMEM_SUBSYSTEM(DataChecksumShmemCallbacks)
 
 /* AIO subsystem. This delegates to the method-specific callbacks */
 PG_SHMEM_SUBSYSTEM(AioShmemCallbacks)
-- 
2.47.3


----Next_Part(Thu_May_28_12_16_22_2026_214)----