agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH v4 4/7] Row pattern recognition patch (executor). 324+ messages / 2 participants [nested] [flat]
* [PATCH v4 4/7] Row pattern recognition patch (executor). @ 2023-08-09 07:56 Tatsuo Ishii <ishii@postgresql.org> 0 siblings, 0 replies; 324+ messages in thread From: Tatsuo Ishii @ 2023-08-09 07:56 UTC (permalink / raw) --- src/backend/executor/nodeWindowAgg.c | 674 ++++++++++++++++++++++++++- src/backend/utils/adt/windowfuncs.c | 38 +- src/include/catalog/pg_proc.dat | 6 + src/include/nodes/execnodes.h | 19 + src/include/windowapi.h | 8 + 5 files changed, 732 insertions(+), 13 deletions(-) diff --git a/src/backend/executor/nodeWindowAgg.c b/src/backend/executor/nodeWindowAgg.c index 310ac23e3a..5354e47045 100644 --- a/src/backend/executor/nodeWindowAgg.c +++ b/src/backend/executor/nodeWindowAgg.c @@ -36,6 +36,7 @@ #include "access/htup_details.h" #include "catalog/objectaccess.h" #include "catalog/pg_aggregate.h" +#include "catalog/pg_collation_d.h" #include "catalog/pg_proc.h" #include "executor/executor.h" #include "executor/nodeWindowAgg.h" @@ -48,6 +49,7 @@ #include "utils/acl.h" #include "utils/builtins.h" #include "utils/datum.h" +#include "utils/fmgroids.h" #include "utils/expandeddatum.h" #include "utils/lsyscache.h" #include "utils/memutils.h" @@ -182,8 +184,9 @@ static void begin_partition(WindowAggState *winstate); static void spool_tuples(WindowAggState *winstate, int64 pos); static void release_partition(WindowAggState *winstate); -static int row_is_in_frame(WindowAggState *winstate, int64 pos, +static int row_is_in_frame(WindowAggState *winstate, int64 pos, TupleTableSlot *slot); + static void update_frameheadpos(WindowAggState *winstate); static void update_frametailpos(WindowAggState *winstate); static void update_grouptailpos(WindowAggState *winstate); @@ -195,9 +198,20 @@ static Datum GetAggInitVal(Datum textInitVal, Oid transtype); static bool are_peers(WindowAggState *winstate, TupleTableSlot *slot1, TupleTableSlot *slot2); -static bool window_gettupleslot(WindowObject winobj, int64 pos, - TupleTableSlot *slot); +static void attno_map(Node *node); +static bool attno_map_walker(Node *node, void *context); +static int row_is_in_reduced_frame(WindowObject winobj, int64 pos); + +static int64 evaluate_pattern(WindowObject winobj, int64 current_pos, + char *vname, StringInfo encoded_str, bool *result); + +static bool get_slots(WindowObject winobj, int64 current_pos); + +static int search_str_set(char *pattern, StringInfo *str_set, int set_size); +static void search_str_set_recurse(char *pattern, StringInfo *str_set, int set_size, int set_index, + char *encoded_str, int *resultlen); +static char pattern_initial(WindowAggState *winstate, char *vname); /* * initialize_windowaggregate @@ -673,6 +687,9 @@ eval_windowaggregates(WindowAggState *winstate) WindowObject agg_winobj; TupleTableSlot *agg_row_slot; TupleTableSlot *temp_slot; + bool reduced_frame_set; + bool check_reduced_frame; + int num_rows_in_reduced_frame; numaggs = winstate->numaggs; if (numaggs == 0) @@ -790,6 +807,7 @@ eval_windowaggregates(WindowAggState *winstate) (winstate->frameOptions & FRAMEOPTION_EXCLUSION) || winstate->aggregatedupto <= winstate->frameheadpos) { + elog(DEBUG1, "peraggstate->restart is set"); peraggstate->restart = true; numaggs_restart++; } @@ -861,8 +879,10 @@ eval_windowaggregates(WindowAggState *winstate) * If we created a mark pointer for aggregates, keep it pushed up to frame * head, so that tuplestore can discard unnecessary rows. */ +#ifdef NOT_USED if (agg_winobj->markptr >= 0) WinSetMarkPosition(agg_winobj, winstate->frameheadpos); +#endif /* * Now restart the aggregates that require it. @@ -919,6 +939,10 @@ eval_windowaggregates(WindowAggState *winstate) ExecClearTuple(agg_row_slot); } + reduced_frame_set = false; + check_reduced_frame = false; + num_rows_in_reduced_frame = 0; + /* * Advance until we reach a row not in frame (or end of partition). * @@ -930,12 +954,18 @@ eval_windowaggregates(WindowAggState *winstate) { int ret; + elog(DEBUG1, "===== loop in frame starts: " INT64_FORMAT, winstate->aggregatedupto); + /* Fetch next row if we didn't already */ if (TupIsNull(agg_row_slot)) { if (!window_gettupleslot(agg_winobj, winstate->aggregatedupto, agg_row_slot)) + { + if (check_reduced_frame) + winstate->aggregatedupto--; break; /* must be end of partition */ + } } /* @@ -944,10 +974,47 @@ eval_windowaggregates(WindowAggState *winstate) */ ret = row_is_in_frame(winstate, winstate->aggregatedupto, agg_row_slot); if (ret < 0) + { + if (winstate->patternVariableList != NIL && check_reduced_frame) + winstate->aggregatedupto--; break; + } if (ret == 0) goto next_tuple; + if (winstate->patternVariableList != NIL) + { + if (!reduced_frame_set) + { + num_rows_in_reduced_frame = row_is_in_reduced_frame(winstate->agg_winobj, winstate->aggregatedupto); + reduced_frame_set = true; + elog(DEBUG1, "set num_rows_in_reduced_frame: %d pos: " INT64_FORMAT, + num_rows_in_reduced_frame, winstate->aggregatedupto); + + if (num_rows_in_reduced_frame <= 0) + break; + + else if (num_rows_in_reduced_frame > 0) + check_reduced_frame = true; + } + + if (check_reduced_frame) + { + elog(DEBUG1, "decrease num_rows_in_reduced_frame: %d pos: " INT64_FORMAT, + num_rows_in_reduced_frame, winstate->aggregatedupto); + num_rows_in_reduced_frame--; + if (num_rows_in_reduced_frame < 0) + { + /* + * No more rows remain in the reduced frame. Finish + * accumulating row into the aggregates. + */ + winstate->aggregatedupto--; + break; + } + } + } + /* Set tuple context for evaluation of aggregate arguments */ winstate->tmpcontext->ecxt_outertuple = agg_row_slot; @@ -976,6 +1043,8 @@ next_tuple: ExecClearTuple(agg_row_slot); } + elog(DEBUG1, "===== break loop in frame starts: " INT64_FORMAT, winstate->aggregatedupto); + /* The frame's end is not supposed to move backwards, ever */ Assert(aggregatedupto_nonrestarted <= winstate->aggregatedupto); @@ -2053,6 +2122,8 @@ ExecWindowAgg(PlanState *pstate) CHECK_FOR_INTERRUPTS(); + elog(DEBUG1, "ExecWindowAgg called. pos: " INT64_FORMAT , winstate->currentpos); + if (winstate->status == WINDOWAGG_DONE) return NULL; @@ -2388,6 +2459,9 @@ ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags) TupleDesc scanDesc; ListCell *l; + TargetEntry *te; + Expr *expr; + /* check for unsupported flags */ Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK))); @@ -2483,6 +2557,16 @@ ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags) winstate->temp_slot_2 = ExecInitExtraTupleSlot(estate, scanDesc, &TTSOpsMinimalTuple); + winstate->prev_slot = ExecInitExtraTupleSlot(estate, scanDesc, + &TTSOpsMinimalTuple); + + winstate->next_slot = ExecInitExtraTupleSlot(estate, scanDesc, + &TTSOpsMinimalTuple); + + winstate->null_slot = ExecInitExtraTupleSlot(estate, scanDesc, + &TTSOpsMinimalTuple); + winstate->null_slot = ExecStoreAllNullTuple(winstate->null_slot); + /* * create frame head and tail slots only if needed (must create slots in * exactly the same cases that update_frameheadpos and update_frametailpos @@ -2667,6 +2751,39 @@ ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags) winstate->inRangeAsc = node->inRangeAsc; winstate->inRangeNullsFirst = node->inRangeNullsFirst; + /* Set up SKIP TO type */ + winstate->rpSkipTo = node->rpSkipTo; + /* Set up row pattern recognition PATTERN clause */ + winstate->patternVariableList = node->patternVariable; + winstate->patternRegexpList = node->patternRegexp; + + /* Set up row pattern recognition DEFINE clause */ + winstate->defineInitial = node->defineInitial; + winstate->defineVariableList = NIL; + winstate->defineClauseList = NIL; + if (node->defineClause != NIL) + { + /* + * Tweak arg var of PREV/NEXT so that it refers to scan/inner slot. + */ + foreach(l, node->defineClause) + { + char *name; + ExprState *exps; + + te = lfirst(l); + name = te->resname; + expr = te->expr; + + elog(DEBUG1, "defineVariable name: %s", name); + winstate->defineVariableList = lappend(winstate->defineVariableList, + makeString(pstrdup(name))); + attno_map((Node *)expr); + exps = ExecInitExpr(expr, (PlanState *) winstate); + winstate->defineClauseList = lappend(winstate->defineClauseList, exps); + } + } + winstate->all_first = true; winstate->partition_spooled = false; winstate->more_partitions = false; @@ -2674,6 +2791,57 @@ ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags) return winstate; } +/* + * Rewrite varno of Var node that is the argument of PREV/NET so that it sees + * scan tuple (PREV) or inner tuple (NEXT). + */ +static void +attno_map(Node *node) +{ + (void) expression_tree_walker(node, attno_map_walker, NULL); +} + +static bool +attno_map_walker(Node *node, void *context) +{ + FuncExpr *func; + int nargs; + Expr *expr; + Var *var; + + if (node == NULL) + return false; + + if (IsA(node, FuncExpr)) + { + func = (FuncExpr *)node; + + if (func->funcid == F_PREV || func->funcid == F_NEXT) + { + /* sanity check */ + nargs = list_length(func->args); + if (list_length(func->args) != 1) + elog(ERROR, "PREV/NEXT must have 1 argument but function %d has %d args", func->funcid, nargs); + + expr = (Expr *) lfirst(list_head(func->args)); + if (!IsA(expr, Var)) + elog(ERROR, "PREV/NEXT's arg is not Var"); /* XXX: is it possible that arg type is Const? */ + var = (Var *)expr; + + if (func->funcid == F_PREV) + /* + * Rewrite varno from OUTER_VAR to regular var no so that the + * var references scan tuple. + */ + var->varno = var->varnosyn; + else + var->varno = INNER_VAR; + elog(DEBUG1, "PREV/NEXT's varno is rewritten to: %d", var->varno); + } + } + return expression_tree_walker(node, attno_map_walker, NULL); +} + /* ----------------- * ExecEndWindowAgg * ----------------- @@ -2691,6 +2859,8 @@ ExecEndWindowAgg(WindowAggState *node) ExecClearTuple(node->agg_row_slot); ExecClearTuple(node->temp_slot_1); ExecClearTuple(node->temp_slot_2); + ExecClearTuple(node->prev_slot); + ExecClearTuple(node->next_slot); if (node->framehead_slot) ExecClearTuple(node->framehead_slot); if (node->frametail_slot) @@ -2740,6 +2910,8 @@ ExecReScanWindowAgg(WindowAggState *node) ExecClearTuple(node->agg_row_slot); ExecClearTuple(node->temp_slot_1); ExecClearTuple(node->temp_slot_2); + ExecClearTuple(node->prev_slot); + ExecClearTuple(node->next_slot); if (node->framehead_slot) ExecClearTuple(node->framehead_slot); if (node->frametail_slot) @@ -3080,7 +3252,7 @@ are_peers(WindowAggState *winstate, TupleTableSlot *slot1, * * Returns true if successful, false if no such row */ -static bool +bool window_gettupleslot(WindowObject winobj, int64 pos, TupleTableSlot *slot) { WindowAggState *winstate = winobj->winstate; @@ -3100,7 +3272,7 @@ window_gettupleslot(WindowObject winobj, int64 pos, TupleTableSlot *slot) return false; if (pos < winobj->markpos) - elog(ERROR, "cannot fetch row before WindowObject's mark position"); + elog(ERROR, "cannot fetch row: " INT64_FORMAT " before WindowObject's mark position: " INT64_FORMAT, pos, winobj->markpos ); oldcontext = MemoryContextSwitchTo(winstate->ss.ps.ps_ExprContext->ecxt_per_query_memory); @@ -3420,14 +3592,54 @@ WinGetFuncArgInFrame(WindowObject winobj, int argno, WindowAggState *winstate; ExprContext *econtext; TupleTableSlot *slot; - int64 abs_pos; - int64 mark_pos; Assert(WindowObjectIsValid(winobj)); winstate = winobj->winstate; econtext = winstate->ss.ps.ps_ExprContext; slot = winstate->temp_slot_1; + if (WinGetSlotInFrame(winobj, slot, + relpos, seektype, set_mark, + isnull, isout) == 0) + { + econtext->ecxt_outertuple = slot; + return ExecEvalExpr((ExprState *) list_nth(winobj->argstates, argno), + econtext, isnull); + } + + if (isout) + *isout = true; + *isnull = true; + return (Datum) 0; +} + +/* + * WinGetSlotInFrame + * slot: TupleTableSlot to store the result + * relpos: signed rowcount offset from the seek position + * seektype: WINDOW_SEEK_HEAD or WINDOW_SEEK_TAIL + * set_mark: If the row is found/in frame and set_mark is true, the mark is + * moved to the row as a side-effect. + * isnull: output argument, receives isnull status of result + * isout: output argument, set to indicate whether target row position + * is out of frame (can pass NULL if caller doesn't care about this) + * + * Returns 0 if we successfullt got the slot. false if out of frame. + * (also isout is set) + */ +int +WinGetSlotInFrame(WindowObject winobj, TupleTableSlot *slot, + int relpos, int seektype, bool set_mark, + bool *isnull, bool *isout) +{ + WindowAggState *winstate; + int64 abs_pos; + int64 mark_pos; + int num_reduced_frame; + + Assert(WindowObjectIsValid(winobj)); + winstate = winobj->winstate; + switch (seektype) { case WINDOW_SEEK_CURRENT: @@ -3494,6 +3706,12 @@ WinGetFuncArgInFrame(WindowObject winobj, int argno, winstate->frameOptions); break; } + num_reduced_frame = row_is_in_reduced_frame(winobj, winstate->frameheadpos); + if (num_reduced_frame < 0) + goto out_of_frame; + else if (num_reduced_frame > 0) + if (relpos >= num_reduced_frame) + goto out_of_frame; break; case WINDOW_SEEK_TAIL: /* rejecting relpos > 0 is easy and simplifies code below */ @@ -3565,6 +3783,12 @@ WinGetFuncArgInFrame(WindowObject winobj, int argno, mark_pos = 0; /* keep compiler quiet */ break; } + + num_reduced_frame = row_is_in_reduced_frame(winobj, winstate->frameheadpos + relpos); + if (num_reduced_frame < 0) + goto out_of_frame; + else if (num_reduced_frame > 0) + abs_pos = winstate->frameheadpos + relpos + num_reduced_frame - 1; break; default: elog(ERROR, "unrecognized window seek type: %d", seektype); @@ -3583,15 +3807,13 @@ WinGetFuncArgInFrame(WindowObject winobj, int argno, *isout = false; if (set_mark) WinSetMarkPosition(winobj, mark_pos); - econtext->ecxt_outertuple = slot; - return ExecEvalExpr((ExprState *) list_nth(winobj->argstates, argno), - econtext, isnull); + return 0; out_of_frame: if (isout) *isout = true; *isnull = true; - return (Datum) 0; + return -1; } /* @@ -3622,3 +3844,433 @@ WinGetFuncArgCurrent(WindowObject winobj, int argno, bool *isnull) return ExecEvalExpr((ExprState *) list_nth(winobj->argstates, argno), econtext, isnull); } + +WindowAggState * +WinGetAggState(WindowObject winobj) +{ + return winobj->winstate; +} + +/* + * row_is_in_reduced_frame + * Determine whether a row is in the current row's reduced window frame according + * to row pattern matching + * + * The row must has been already determined that it is in a full window frame + * and fetched it into slot. + * + * Returns: + * = 0, RPR is not defined. + * >0, if the row is the first in the reduced frame. Return the number of rows in the reduced frame. + * -1, if the row is unmatched row + * -2, if the row is in the reduced frame but needed to be skipped because of + * AFTER MATCH SKIP PAST LAST ROW + */ +static +int row_is_in_reduced_frame(WindowObject winobj, int64 pos) +{ + WindowAggState *winstate = winobj->winstate; + ListCell *lc1, *lc2; + bool expression_result; + int num_matched_rows; + int64 original_pos; + bool anymatch; + StringInfo encoded_str; + StringInfo pattern_str = makeStringInfo(); + + /* + * Array of pattern variables evaluted to true. + * Each character corresponds to pattern variable. + * Example: + * str_set[0] = "AB"; + * str_set[1] = "AC"; + * In this case at row 0 A and B are true, and A and C are true in row 1. + */ + #define ENCODED_STR_ARRAY_ALLOC_SIZE 128 + StringInfo *str_set = NULL; + int str_set_index; + int str_set_size; + + if (winstate->patternVariableList == NIL) + { + /* + * RPR is not defined. Assume that we are always in the the reduced + * window frame. + */ + return 0; + } + + /* save original pos */ + original_pos = pos; + + /* + * Check whether the row speicied by pos is in the reduced frame. The + * second and subsequent rows need to be recognized as "unmatched" rows if + * AFTER MATCH SKIP PAST LAST ROW is defined. + */ + if (winstate->rpSkipTo == ST_PAST_LAST_ROW && + pos > winstate->headpos_in_reduced_frame && + pos < (winstate->headpos_in_reduced_frame + winstate->num_rows_in_reduced_frame)) + return -2; + + /* + * Loop over until none of pattern matches or encounters end of frame. + */ + for (;;) + { + int64 result_pos = -1; + + /* + * Loop over each PATTERN variable. + */ + anymatch = false; + encoded_str = makeStringInfo(); + + forboth(lc1, winstate->patternVariableList, lc2, winstate->patternRegexpList) + { + char *vname = strVal(lfirst(lc1)); + char *quantifier = strVal(lfirst(lc2)); + + elog(DEBUG1, "pos: " INT64_FORMAT " pattern vname: %s quantifier: %s", pos, vname, quantifier); + + expression_result = false; + + /* evaluate row pattern against current row */ + result_pos = evaluate_pattern(winobj, pos, vname, encoded_str, &expression_result); + if (expression_result) + { + elog(DEBUG1, "expression result is true"); + anymatch = true; + } + + /* + * If out of frame, we are done. + */ + if (result_pos < 0) + break; + } + + if (!anymatch) + { + /* none of patterns matched. */ + break; + } + + /* build encoded string array */ + if (str_set == NULL) + { + str_set_index = 0; + str_set_size = ENCODED_STR_ARRAY_ALLOC_SIZE * sizeof(StringInfo); + str_set = palloc(str_set_size); + } + + str_set[str_set_index++] = encoded_str; + + elog(DEBUG1, "pos: " INT64_FORMAT " str_set_index: %d encoded_str: %s", pos, str_set_index, encoded_str->data); + + if (str_set_index >= str_set_size) + { + str_set_size *= 2; + str_set = repalloc(str_set, str_set_size); + } + + /* move to next row */ + pos++; + + if (result_pos < 0) + { + /* out of frame */ + break; + } + } + + if (str_set == NULL) + { + /* no matches found in the first row */ + return -1; + } + + elog(DEBUG1, "pos: " INT64_FORMAT " encoded_str: %s", pos, encoded_str->data); + + /* build regular expression */ + pattern_str = makeStringInfo(); + appendStringInfoChar(pattern_str, '^'); + forboth (lc1, winstate->patternVariableList, lc2, winstate->patternRegexpList) + { + char *vname = strVal(lfirst(lc1)); + char *quantifier = strVal(lfirst(lc2)); + char initial; + + initial = pattern_initial(winstate, vname); + Assert(initial != 0); + appendStringInfoChar(pattern_str, initial); + if (quantifier[0]) + appendStringInfoChar(pattern_str, quantifier[0]); + elog(DEBUG1, "vname: %s initial: %c quantifier: %s", vname, initial, quantifier); + } + + elog(DEBUG1, "pos: " INT64_FORMAT " pattern: %s", pos, pattern_str->data); + + /* look for matching pattern variable sequence */ + num_matched_rows = search_str_set(pattern_str->data, str_set, str_set_index); + if (num_matched_rows <= 0) + return -1; + + /* + * We are at the first row in the reduced frame. Save the number of + * matched rows as the number of rows in the reduced frame. + */ + winstate->headpos_in_reduced_frame = original_pos; + winstate->num_rows_in_reduced_frame = num_matched_rows; + + return num_matched_rows; +} + +/* + * search set of encode_str. + * set_size: size of set_str array. + */ +static +int search_str_set(char *pattern, StringInfo *str_set, int set_size) +{ + char *encoded_str = palloc0(set_size+1); + int resultlen = 0; + + search_str_set_recurse(pattern, str_set, set_size, 0, encoded_str, &resultlen); + elog(DEBUG1, "search_str_set returns %d", resultlen); + return resultlen; +} + +static +void search_str_set_recurse(char *pattern, StringInfo *str_set, + int set_size, int set_index, char *encoded_str, int *resultlen) +{ + char *p; + + if (set_index >= set_size) + { + Datum d; + text *res; + char *substr; + + /* + * We first perform pattern matching using regexp_instr, then call + * textregexsubstr to get matched substring to know how log the + * matched string is. That is the number of rows in the reduced window + * frame. The reason why we can't call textregexsubstr is, it error + * out if pattern is not match. + */ + if (DatumGetInt32(DirectFunctionCall2Coll(regexp_instr, DEFAULT_COLLATION_OID, + PointerGetDatum(cstring_to_text(encoded_str)), + PointerGetDatum(cstring_to_text(pattern)))) > 0) + { + d = DirectFunctionCall2Coll(textregexsubstr, + DEFAULT_COLLATION_OID, + PointerGetDatum(cstring_to_text(encoded_str)), + PointerGetDatum(cstring_to_text(pattern))); + if (d != 0) + { + int len; + + res = DatumGetTextPP(d); + substr = text_to_cstring(res); + len = strlen(substr); + if (len > *resultlen) + /* remember the longest match */ + *resultlen = len; + } + } + return; + } + + p = str_set[set_index]->data; + while (*p) + { + encoded_str[set_index] = *p; + p++; + search_str_set_recurse(pattern, str_set, set_size, set_index + 1, encoded_str, resultlen); + } +} + + +/* + * Evaluate expression associated with PATTERN variable vname. + * relpos is relative row position in a frame (starting from 0). + * "quantifier" is the quatifier part of the PATTERN regular expression. + * Currently only '+' is allowed. + * result is out paramater representing the expression evaluation result + * is true of false. + * Return values are: + * >=0: the last match absolute row position + * other wise out of frame. + */ +static +int64 evaluate_pattern(WindowObject winobj, int64 current_pos, + char *vname, StringInfo encoded_str, bool *result) +{ + WindowAggState *winstate = winobj->winstate; + ExprContext *econtext = winstate->ss.ps.ps_ExprContext; + ListCell *lc1, *lc2, *lc3; + ExprState *pat; + Datum eval_result; + bool out_of_frame = false; + bool isnull; + + forthree (lc1, winstate->defineVariableList, lc2, winstate->defineClauseList, lc3, winstate->defineInitial) + { + char initial; + char *name = strVal(lfirst(lc1)); + + elog(DEBUG1, "evaluate_pattern: define variable: %s, pattern variable: %s", name, vname); + + if (strcmp(vname, name)) + continue; + + initial = *(strVal(lfirst(lc3))); + + /* set expression to evaluate */ + pat = lfirst(lc2); + + /* get current, previous and next tuples */ + if (!get_slots(winobj, current_pos)) + { + out_of_frame = true; + } + else + { + /* evaluate the expression */ + eval_result = ExecEvalExpr(pat, econtext, &isnull); + if (isnull) + { + /* expression is NULL */ + elog(DEBUG1, "expression for %s is NULL at row: " INT64_FORMAT, vname, current_pos); + *result = false; + } + else + { + if (!DatumGetBool(eval_result)) + { + /* expression is false */ + elog(DEBUG1, "expression for %s is false at row: " INT64_FORMAT, vname, current_pos); + *result = false; + } + else + { + /* expression is true */ + elog(DEBUG1, "expression for %s is true at row: " INT64_FORMAT, vname, current_pos); + appendStringInfoChar(encoded_str, initial); + *result = true; + } + } + break; + } + + if (out_of_frame) + { + *result = false; + return -1; + } + } + return current_pos; +} + +/* + * Get current, previous and next tuples. + * Returns false if current row is out of partition/full frame. + */ +static +bool get_slots(WindowObject winobj, int64 current_pos) +{ + WindowAggState *winstate = winobj->winstate; + TupleTableSlot *slot; + int ret; + ExprContext *econtext; + + econtext = winstate->ss.ps.ps_ExprContext; + + /* set up current row tuple slot */ + slot = winstate->temp_slot_1; + if (!window_gettupleslot(winobj, current_pos, slot)) + { + elog(DEBUG1, "current row is out of partition at:" INT64_FORMAT, current_pos); + return false; + + ret = row_is_in_frame(winstate, current_pos, slot); + if (ret <= 0) + { + elog(DEBUG1, "current row is out of frame at: " INT64_FORMAT, current_pos); + return false; + } + } + econtext->ecxt_outertuple = slot; + + /* for PREV */ + if (current_pos > 0) + { + slot = winstate->prev_slot; + if (!window_gettupleslot(winobj, current_pos - 1, slot)) + { + elog(DEBUG1, "previous row is out of partition at: " INT64_FORMAT, current_pos - 1); + econtext->ecxt_scantuple = winstate->null_slot; + } + else + { + ret = row_is_in_frame(winstate, current_pos - 1, slot); + if (ret <= 0) + { + elog(DEBUG1, "previous row is out of frame at: " INT64_FORMAT, current_pos - 1); + econtext->ecxt_scantuple = winstate->null_slot; + } + else + { + econtext->ecxt_scantuple = slot; + } + } + } + else + econtext->ecxt_scantuple = winstate->null_slot; + + /* for NEXT */ + slot = winstate->next_slot; + if (!window_gettupleslot(winobj, current_pos + 1, slot)) + { + elog(DEBUG1, "next row is out of partiton at: " INT64_FORMAT, current_pos + 1); + econtext->ecxt_innertuple = winstate->null_slot; + } + else + { + ret = row_is_in_frame(winstate, current_pos + 1, slot); + if (ret <= 0) + { + elog(DEBUG1, "next row is out of frame at: " INT64_FORMAT, current_pos + 1); + econtext->ecxt_innertuple = winstate->null_slot; + } + else + econtext->ecxt_innertuple = slot; + } + return true; +} + +/* + * Return pattern variable initial character + * matching with pattern variable name vname. + * If not found, return 0. + */ +static +char pattern_initial(WindowAggState *winstate, char *vname) +{ + char initial; + char *name; + ListCell *lc1, *lc2; + + forboth (lc1, winstate->defineVariableList, lc2, winstate->defineInitial) + { + name = strVal(lfirst(lc1)); /* DEFINE variable name */ + initial = *(strVal(lfirst(lc2))); /* DEFINE variable initial */ + + + if (!strcmp(name, vname)) + return initial; /* found */ + } + return 0; +} diff --git a/src/backend/utils/adt/windowfuncs.c b/src/backend/utils/adt/windowfuncs.c index b87a624fb2..e4cab36ec9 100644 --- a/src/backend/utils/adt/windowfuncs.c +++ b/src/backend/utils/adt/windowfuncs.c @@ -13,6 +13,9 @@ */ #include "postgres.h" +#include "catalog/pg_collation_d.h" +#include "executor/executor.h" +#include "nodes/execnodes.h" #include "nodes/supportnodes.h" #include "utils/builtins.h" #include "windowapi.h" @@ -36,11 +39,19 @@ typedef struct int64 remainder; /* (total rows) % (bucket num) */ } ntile_context; +/* + * rpr process information. + * Used for AFTER MATCH SKIP PAST LAST ROW + */ +typedef struct SkipContext +{ + int64 pos; /* last row absolute position */ +} SkipContext; + static bool rank_up(WindowObject winobj); static Datum leadlag_common(FunctionCallInfo fcinfo, bool forward, bool withoffset, bool withdefault); - /* * utility routine for *_rank functions. */ @@ -673,7 +684,7 @@ window_last_value(PG_FUNCTION_ARGS) bool isnull; result = WinGetFuncArgInFrame(winobj, 0, - 0, WINDOW_SEEK_TAIL, true, + 0, WINDOW_SEEK_TAIL, false, &isnull, NULL); if (isnull) PG_RETURN_NULL(); @@ -713,3 +724,26 @@ window_nth_value(PG_FUNCTION_ARGS) PG_RETURN_DATUM(result); } + +/* + * prev + * Dummy function to invoke RPR's navigation operator "PREV". + * This is *not* a window function. + */ +Datum +window_prev(PG_FUNCTION_ARGS) +{ + PG_RETURN_DATUM(PG_GETARG_DATUM(0)); +} + +/* + * next + * Dummy function to invoke RPR's navigation operation "NEXT". + * This is *not* a window function. + */ +Datum +window_next(PG_FUNCTION_ARGS) +{ + PG_RETURN_DATUM(PG_GETARG_DATUM(0)); +} + diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat index 6996073989..fa100b2665 100644 --- a/src/include/catalog/pg_proc.dat +++ b/src/include/catalog/pg_proc.dat @@ -10397,6 +10397,12 @@ { oid => '3114', descr => 'fetch the Nth row value', proname => 'nth_value', prokind => 'w', prorettype => 'anyelement', proargtypes => 'anyelement int4', prosrc => 'window_nth_value' }, +{ oid => '6122', descr => 'previous value', + proname => 'prev', provolatile => 's', prorettype => 'anyelement', + proargtypes => 'anyelement', prosrc => 'window_prev' }, +{ oid => '6123', descr => 'next value', + proname => 'next', provolatile => 's', prorettype => 'anyelement', + proargtypes => 'anyelement', prosrc => 'window_next' }, # functions for range types { oid => '3832', descr => 'I/O', diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index cb714f4a19..2bd6fcb5e1 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -2519,6 +2519,15 @@ typedef struct WindowAggState int64 groupheadpos; /* current row's peer group head position */ int64 grouptailpos; /* " " " " tail position (group end+1) */ + /* these fields are used in Row pattern recognition: */ + RPSkipTo rpSkipTo; /* Row Pattern Skip To type */ + List *patternVariableList; /* list of row pattern variables names (list of String) */ + List *patternRegexpList; /* list of row pattern regular expressions ('+' or ''. list of String) */ + List *defineVariableList; /* list of row pattern definition variables (list of String) */ + List *defineClauseList; /* expression for row pattern definition + * search conditions ExprState list */ + List *defineInitial; /* list of row pattern definition variable initials (list of String) */ + MemoryContext partcontext; /* context for partition-lifespan data */ MemoryContext aggcontext; /* shared context for aggregate working data */ MemoryContext curaggcontext; /* current aggregate's working data */ @@ -2555,6 +2564,16 @@ typedef struct WindowAggState TupleTableSlot *agg_row_slot; TupleTableSlot *temp_slot_1; TupleTableSlot *temp_slot_2; + + /* temporary slots for RPR */ + TupleTableSlot *prev_slot; /* PREV row navigation operator */ + TupleTableSlot *next_slot; /* NEXT row navigation operator */ + TupleTableSlot *null_slot; /* all NULL slot */ + + /* head of the reduced window frame */ + int64 headpos_in_reduced_frame; + /* number of rows in the reduced window frame */ + int64 num_rows_in_reduced_frame; } WindowAggState; /* ---------------- diff --git a/src/include/windowapi.h b/src/include/windowapi.h index b8c2c565d1..1e292648e9 100644 --- a/src/include/windowapi.h +++ b/src/include/windowapi.h @@ -58,7 +58,15 @@ extern Datum WinGetFuncArgInFrame(WindowObject winobj, int argno, int relpos, int seektype, bool set_mark, bool *isnull, bool *isout); +extern int WinGetSlotInFrame(WindowObject winobj, TupleTableSlot *slot, + int relpos, int seektype, bool set_mark, + bool *isnull, bool *isout); + extern Datum WinGetFuncArgCurrent(WindowObject winobj, int argno, bool *isnull); +extern WindowAggState *WinGetAggState(WindowObject winobj); + +extern bool window_gettupleslot(WindowObject winobj, int64 pos, TupleTableSlot *slot); + #endif /* WINDOWAPI_H */ -- 2.25.1 ----Next_Part(Wed_Aug__9_17_41_12_2023_134)-- Content-Type: Text/X-Patch; charset=us-ascii Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="v4-0005-Row-pattern-recognition-patch-docs.patch" ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
* [PATCH 4/4] Use singular "datachecksum" consistently in process names @ 2026-05-26 07:56 Kyotaro Horiguchi <horikyota.ntt@gmail.com> 0 siblings, 0 replies; 324+ messages in thread From: Kyotaro Horiguchi @ 2026-05-26 07:56 UTC (permalink / raw) 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)---- ^ permalink raw reply [nested|flat] 324+ messages in thread
end of thread, other threads:[~2026-05-26 07:56 UTC | newest] Thread overview: 324+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2023-08-09 07:56 [PATCH v4 4/7] Row pattern recognition patch (executor). Tatsuo Ishii <ishii@postgresql.org> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com> 2026-05-26 07:56 [PATCH 4/4] Use singular "datachecksum" consistently in process names Kyotaro Horiguchi <horikyota.ntt@gmail.com>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox