[PATCH 4/4] Use singular "datachecksum" consistently in process names
Kyotaro Horiguchi <horikyota.ntt@gmail.com>
From: Kyotaro Horiguchi <horikyota.ntt@gmail.com>
To:
Date: 2026-05-26T07:56:01Z
Lists: pgsql-hackers
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)----