PostgreSQL Source Code  git master
guc.h File Reference
#include "nodes/parsenodes.h"
#include "tcop/dest.h"
#include "utils/array.h"
Include dependency graph for guc.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  ConfigVariable
 
struct  config_enum_entry
 

Macros

#define MAX_KILOBYTES   (INT_MAX / 1024)
 
#define PG_AUTOCONF_FILENAME   "postgresql.auto.conf"
 
#define GUC_QUALIFIER_SEPARATOR   '.'
 
#define GUC_LIST_INPUT   0x000001 /* input can be list format */
 
#define GUC_LIST_QUOTE   0x000002 /* double-quote list elements */
 
#define GUC_NO_SHOW_ALL   0x000004 /* exclude from SHOW ALL */
 
#define GUC_NO_RESET   0x000008 /* disallow RESET and SAVE */
 
#define GUC_NO_RESET_ALL   0x000010 /* exclude from RESET ALL */
 
#define GUC_EXPLAIN   0x000020 /* include in EXPLAIN */
 
#define GUC_REPORT   0x000040 /* auto-report changes to client */
 
#define GUC_NOT_IN_SAMPLE   0x000080 /* not in postgresql.conf.sample */
 
#define GUC_DISALLOW_IN_FILE   0x000100 /* can't set in postgresql.conf */
 
#define GUC_CUSTOM_PLACEHOLDER   0x000200 /* placeholder for custom variable */
 
#define GUC_SUPERUSER_ONLY   0x000400 /* show only to superusers */
 
#define GUC_IS_NAME   0x000800 /* limit string to NAMEDATALEN-1 */
 
#define GUC_NOT_WHILE_SEC_REST   0x001000 /* can't set if security restricted */
 
#define GUC_DISALLOW_IN_AUTO_FILE    0x002000 /* can't set in PG_AUTOCONF_FILENAME */
 
#define GUC_RUNTIME_COMPUTED   0x004000 /* delay processing in 'postgres -C' */
 
#define GUC_UNIT_KB   0x01000000 /* value is in kilobytes */
 
#define GUC_UNIT_BLOCKS   0x02000000 /* value is in blocks */
 
#define GUC_UNIT_XBLOCKS   0x03000000 /* value is in xlog blocks */
 
#define GUC_UNIT_MB   0x04000000 /* value is in megabytes */
 
#define GUC_UNIT_BYTE   0x05000000 /* value is in bytes */
 
#define GUC_UNIT_MEMORY   0x0F000000 /* mask for size-related units */
 
#define GUC_UNIT_MS   0x10000000 /* value is in milliseconds */
 
#define GUC_UNIT_S   0x20000000 /* value is in seconds */
 
#define GUC_UNIT_MIN   0x30000000 /* value is in minutes */
 
#define GUC_UNIT_TIME   0x70000000 /* mask for time-related units */
 
#define GUC_UNIT   (GUC_UNIT_MEMORY | GUC_UNIT_TIME)
 
#define EmitWarningsOnPlaceholders(className)   MarkGUCPrefixReserved(className)
 
#define GUC_check_errmsg
 
#define GUC_check_errdetail
 
#define GUC_check_errhint
 

Typedefs

typedef struct ConfigVariable ConfigVariable
 
typedef bool(* GucBoolCheckHook) (bool *newval, void **extra, GucSource source)
 
typedef bool(* GucIntCheckHook) (int *newval, void **extra, GucSource source)
 
typedef bool(* GucRealCheckHook) (double *newval, void **extra, GucSource source)
 
typedef bool(* GucStringCheckHook) (char **newval, void **extra, GucSource source)
 
typedef bool(* GucEnumCheckHook) (int *newval, void **extra, GucSource source)
 
typedef void(* GucBoolAssignHook) (bool newval, void *extra)
 
typedef void(* GucIntAssignHook) (int newval, void *extra)
 
typedef void(* GucRealAssignHook) (double newval, void *extra)
 
typedef void(* GucStringAssignHook) (const char *newval, void *extra)
 
typedef void(* GucEnumAssignHook) (int newval, void *extra)
 
typedef const char *(* GucShowHook) (void)
 

Enumerations

enum  GucContext {
  PGC_INTERNAL , PGC_POSTMASTER , PGC_SIGHUP , PGC_SU_BACKEND ,
  PGC_BACKEND , PGC_SUSET , PGC_USERSET
}
 
enum  GucSource {
  PGC_S_DEFAULT , PGC_S_DYNAMIC_DEFAULT , PGC_S_ENV_VAR , PGC_S_FILE ,
  PGC_S_ARGV , PGC_S_GLOBAL , PGC_S_DATABASE , PGC_S_USER ,
  PGC_S_DATABASE_USER , PGC_S_CLIENT , PGC_S_OVERRIDE , PGC_S_INTERACTIVE ,
  PGC_S_TEST , PGC_S_SESSION
}
 
enum  GucAction { GUC_ACTION_SET , GUC_ACTION_LOCAL , GUC_ACTION_SAVE }
 

Functions

bool ParseConfigFile (const char *config_file, bool strict, const char *calling_file, int calling_lineno, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
 
bool ParseConfigFp (FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
 
bool ParseConfigDirectory (const char *includedir, const char *calling_file, int calling_lineno, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
 
void FreeConfigVariables (ConfigVariable *list)
 
char * DeescapeQuotedString (const char *s)
 
void SetConfigOption (const char *name, const char *value, GucContext context, GucSource source)
 
void DefineCustomBoolVariable (const char *name, const char *short_desc, const char *long_desc, bool *valueAddr, bool bootValue, GucContext context, int flags, GucBoolCheckHook check_hook, GucBoolAssignHook assign_hook, GucShowHook show_hook) pg_attribute_nonnull(1
 
void void DefineCustomIntVariable (const char *name, const char *short_desc, const char *long_desc, int *valueAddr, int bootValue, int minValue, int maxValue, GucContext context, int flags, GucIntCheckHook check_hook, GucIntAssignHook assign_hook, GucShowHook show_hook) pg_attribute_nonnull(1
 
void void void DefineCustomRealVariable (const char *name, const char *short_desc, const char *long_desc, double *valueAddr, double bootValue, double minValue, double maxValue, GucContext context, int flags, GucRealCheckHook check_hook, GucRealAssignHook assign_hook, GucShowHook show_hook) pg_attribute_nonnull(1
 
void void void void DefineCustomStringVariable (const char *name, const char *short_desc, const char *long_desc, char **valueAddr, const char *bootValue, GucContext context, int flags, GucStringCheckHook check_hook, GucStringAssignHook assign_hook, GucShowHook show_hook) pg_attribute_nonnull(1
 
void void void void void DefineCustomEnumVariable (const char *name, const char *short_desc, const char *long_desc, int *valueAddr, int bootValue, const struct config_enum_entry *options, GucContext context, int flags, GucEnumCheckHook check_hook, GucEnumAssignHook assign_hook, GucShowHook show_hook) pg_attribute_nonnull(1
 
void void void void void void MarkGUCPrefixReserved (const char *className)
 
const char * GetConfigOption (const char *name, bool missing_ok, bool restrict_privileged)
 
const char * GetConfigOptionResetString (const char *name)
 
int GetConfigOptionFlags (const char *name, bool missing_ok)
 
void ProcessConfigFile (GucContext context)
 
char * convert_GUC_name_for_parameter_acl (const char *name)
 
bool check_GUC_name_for_parameter_acl (const char *name)
 
void InitializeGUCOptions (void)
 
bool SelectConfigFiles (const char *userDoption, const char *progname)
 
void ResetAllOptions (void)
 
void AtStart_GUC (void)
 
int NewGUCNestLevel (void)
 
void AtEOXact_GUC (bool isCommit, int nestLevel)
 
void BeginReportingGUCOptions (void)
 
void ReportChangedGUCOptions (void)
 
void ParseLongOption (const char *string, char **name, char **value)
 
const char * get_config_unit_name (int flags)
 
bool parse_int (const char *value, int *result, int flags, const char **hintmsg)
 
bool parse_real (const char *value, double *result, int flags, const char **hintmsg)
 
int set_config_option (const char *name, const char *value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)
 
int set_config_option_ext (const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
 
void AlterSystemSetConfigFile (AlterSystemStmt *altersysstmt)
 
char * GetConfigOptionByName (const char *name, const char **varname, bool missing_ok)
 
void ProcessGUCArray (ArrayType *array, ArrayType *usersetArray, GucContext context, GucSource source, GucAction action)
 
ArrayTypeGUCArrayAdd (ArrayType *array, ArrayType **usersetArray, const char *name, const char *value, bool user_set)
 
ArrayTypeGUCArrayDelete (ArrayType *array, ArrayType **usersetArray, const char *name)
 
ArrayTypeGUCArrayReset (ArrayType *array, ArrayType **usersetArray)
 
void * guc_malloc (int elevel, size_t size)
 
pg_nodiscard void * guc_realloc (int elevel, void *old, size_t size)
 
char * guc_strdup (int elevel, const char *src)
 
void guc_free (void *ptr)
 
Size EstimateGUCStateSpace (void)
 
void SerializeGUCState (Size maxsize, char *start_address)
 
void RestoreGUCState (void *gucstate)
 
void ExecSetVariableStmt (VariableSetStmt *stmt, bool isTopLevel)
 
char * ExtractSetVariableArgs (VariableSetStmt *stmt)
 
void SetPGVariable (const char *name, List *args, bool is_local)
 
void GetPGVariable (const char *name, DestReceiver *dest)
 
TupleDesc GetPGVariableResultDesc (const char *name)
 
void GUC_check_errcode (int sqlerrcode)
 

Variables

PGDLLIMPORT bool Debug_print_plan
 
PGDLLIMPORT bool Debug_print_parse
 
PGDLLIMPORT bool Debug_print_rewritten
 
PGDLLIMPORT bool Debug_pretty_print
 
PGDLLIMPORT bool log_parser_stats
 
PGDLLIMPORT bool log_planner_stats
 
PGDLLIMPORT bool log_executor_stats
 
PGDLLIMPORT bool log_statement_stats
 
PGDLLIMPORT bool log_btree_build_stats
 
PGDLLIMPORT bool check_function_bodies
 
PGDLLIMPORT bool session_auth_is_superuser
 
PGDLLIMPORT bool log_duration
 
PGDLLIMPORT int log_parameter_max_length
 
PGDLLIMPORT int log_parameter_max_length_on_error
 
PGDLLIMPORT int log_min_error_statement
 
PGDLLIMPORT int log_min_messages
 
PGDLLIMPORT int client_min_messages
 
PGDLLIMPORT int log_min_duration_sample
 
PGDLLIMPORT int log_min_duration_statement
 
PGDLLIMPORT int log_temp_files
 
PGDLLIMPORT double log_statement_sample_rate
 
PGDLLIMPORT double log_xact_sample_rate
 
PGDLLIMPORT char * backtrace_functions
 
PGDLLIMPORT int temp_file_limit
 
PGDLLIMPORT int num_temp_buffers
 
PGDLLIMPORT char * cluster_name
 
PGDLLIMPORT char * ConfigFileName
 
PGDLLIMPORT char * HbaFileName
 
PGDLLIMPORT char * IdentFileName
 
PGDLLIMPORT char * external_pid_file
 
PGDLLIMPORT char * application_name
 
PGDLLIMPORT int tcp_keepalives_idle
 
PGDLLIMPORT int tcp_keepalives_interval
 
PGDLLIMPORT int tcp_keepalives_count
 
PGDLLIMPORT int tcp_user_timeout
 
PGDLLIMPORT char * GUC_check_errmsg_string
 
PGDLLIMPORT char * GUC_check_errdetail_string
 
PGDLLIMPORT char * GUC_check_errhint_string
 

Macro Definition Documentation

◆ EmitWarningsOnPlaceholders

#define EmitWarningsOnPlaceholders (   className)    MarkGUCPrefixReserved(className)

Definition at line 358 of file guc.h.

◆ GUC_check_errdetail

#define GUC_check_errdetail
Value:
GUC_check_errdetail_string = format_elog_string
void pre_format_elog_string(int errnumber, const char *domain)
Definition: elog.c:1627
char * format_elog_string(const char *fmt,...)
Definition: elog.c:1636
#define TEXTDOMAIN
Definition: elog.h:152

Definition at line 437 of file guc.h.

◆ GUC_check_errhint

#define GUC_check_errhint
Value:
GUC_check_errhint_string = format_elog_string

Definition at line 441 of file guc.h.

◆ GUC_check_errmsg

#define GUC_check_errmsg
Value:
GUC_check_errmsg_string = format_elog_string

Definition at line 433 of file guc.h.

◆ GUC_CUSTOM_PLACEHOLDER

#define GUC_CUSTOM_PLACEHOLDER   0x000200 /* placeholder for custom variable */

Definition at line 217 of file guc.h.

◆ GUC_DISALLOW_IN_AUTO_FILE

#define GUC_DISALLOW_IN_AUTO_FILE    0x002000 /* can't set in PG_AUTOCONF_FILENAME */

Definition at line 221 of file guc.h.

◆ GUC_DISALLOW_IN_FILE

#define GUC_DISALLOW_IN_FILE   0x000100 /* can't set in postgresql.conf */

Definition at line 216 of file guc.h.

◆ GUC_EXPLAIN

#define GUC_EXPLAIN   0x000020 /* include in EXPLAIN */

Definition at line 213 of file guc.h.

◆ GUC_IS_NAME

#define GUC_IS_NAME   0x000800 /* limit string to NAMEDATALEN-1 */

Definition at line 219 of file guc.h.

◆ GUC_LIST_INPUT

#define GUC_LIST_INPUT   0x000001 /* input can be list format */

Definition at line 208 of file guc.h.

◆ GUC_LIST_QUOTE

#define GUC_LIST_QUOTE   0x000002 /* double-quote list elements */

Definition at line 209 of file guc.h.

◆ GUC_NO_RESET

#define GUC_NO_RESET   0x000008 /* disallow RESET and SAVE */

Definition at line 211 of file guc.h.

◆ GUC_NO_RESET_ALL

#define GUC_NO_RESET_ALL   0x000010 /* exclude from RESET ALL */

Definition at line 212 of file guc.h.

◆ GUC_NO_SHOW_ALL

#define GUC_NO_SHOW_ALL   0x000004 /* exclude from SHOW ALL */

Definition at line 210 of file guc.h.

◆ GUC_NOT_IN_SAMPLE

#define GUC_NOT_IN_SAMPLE   0x000080 /* not in postgresql.conf.sample */

Definition at line 215 of file guc.h.

◆ GUC_NOT_WHILE_SEC_REST

#define GUC_NOT_WHILE_SEC_REST   0x001000 /* can't set if security restricted */

Definition at line 220 of file guc.h.

◆ GUC_QUALIFIER_SEPARATOR

#define GUC_QUALIFIER_SEPARATOR   '.'

Definition at line 202 of file guc.h.

◆ GUC_REPORT

#define GUC_REPORT   0x000040 /* auto-report changes to client */

Definition at line 214 of file guc.h.

◆ GUC_RUNTIME_COMPUTED

#define GUC_RUNTIME_COMPUTED   0x004000 /* delay processing in 'postgres -C' */

Definition at line 223 of file guc.h.

◆ GUC_SUPERUSER_ONLY

#define GUC_SUPERUSER_ONLY   0x000400 /* show only to superusers */

Definition at line 218 of file guc.h.

◆ GUC_UNIT

#define GUC_UNIT   (GUC_UNIT_MEMORY | GUC_UNIT_TIME)

Definition at line 237 of file guc.h.

◆ GUC_UNIT_BLOCKS

#define GUC_UNIT_BLOCKS   0x02000000 /* value is in blocks */

Definition at line 226 of file guc.h.

◆ GUC_UNIT_BYTE

#define GUC_UNIT_BYTE   0x05000000 /* value is in bytes */

Definition at line 229 of file guc.h.

◆ GUC_UNIT_KB

#define GUC_UNIT_KB   0x01000000 /* value is in kilobytes */

Definition at line 225 of file guc.h.

◆ GUC_UNIT_MB

#define GUC_UNIT_MB   0x04000000 /* value is in megabytes */

Definition at line 228 of file guc.h.

◆ GUC_UNIT_MEMORY

#define GUC_UNIT_MEMORY   0x0F000000 /* mask for size-related units */

Definition at line 230 of file guc.h.

◆ GUC_UNIT_MIN

#define GUC_UNIT_MIN   0x30000000 /* value is in minutes */

Definition at line 234 of file guc.h.

◆ GUC_UNIT_MS

#define GUC_UNIT_MS   0x10000000 /* value is in milliseconds */

Definition at line 232 of file guc.h.

◆ GUC_UNIT_S

#define GUC_UNIT_S   0x20000000 /* value is in seconds */

Definition at line 233 of file guc.h.

◆ GUC_UNIT_TIME

#define GUC_UNIT_TIME   0x70000000 /* mask for time-related units */

Definition at line 235 of file guc.h.

◆ GUC_UNIT_XBLOCKS

#define GUC_UNIT_XBLOCKS   0x03000000 /* value is in xlog blocks */

Definition at line 227 of file guc.h.

◆ MAX_KILOBYTES

#define MAX_KILOBYTES   (INT_MAX / 1024)

Definition at line 25 of file guc.h.

◆ PG_AUTOCONF_FILENAME

#define PG_AUTOCONF_FILENAME   "postgresql.auto.conf"

Definition at line 33 of file guc.h.

Typedef Documentation

◆ ConfigVariable

◆ GucBoolAssignHook

typedef void(* GucBoolAssignHook) (bool newval, void *extra)

Definition at line 183 of file guc.h.

◆ GucBoolCheckHook

typedef bool(* GucBoolCheckHook) (bool *newval, void **extra, GucSource source)

Definition at line 177 of file guc.h.

◆ GucEnumAssignHook

typedef void(* GucEnumAssignHook) (int newval, void *extra)

Definition at line 187 of file guc.h.

◆ GucEnumCheckHook

typedef bool(* GucEnumCheckHook) (int *newval, void **extra, GucSource source)

Definition at line 181 of file guc.h.

◆ GucIntAssignHook

typedef void(* GucIntAssignHook) (int newval, void *extra)

Definition at line 184 of file guc.h.

◆ GucIntCheckHook

typedef bool(* GucIntCheckHook) (int *newval, void **extra, GucSource source)

Definition at line 178 of file guc.h.

◆ GucRealAssignHook

typedef void(* GucRealAssignHook) (double newval, void *extra)

Definition at line 185 of file guc.h.

◆ GucRealCheckHook

typedef bool(* GucRealCheckHook) (double *newval, void **extra, GucSource source)

Definition at line 179 of file guc.h.

◆ GucShowHook

typedef const char*(* GucShowHook) (void)

Definition at line 189 of file guc.h.

◆ GucStringAssignHook

typedef void(* GucStringAssignHook) (const char *newval, void *extra)

Definition at line 186 of file guc.h.

◆ GucStringCheckHook

typedef bool(* GucStringCheckHook) (char **newval, void **extra, GucSource source)

Definition at line 180 of file guc.h.

Enumeration Type Documentation

◆ GucAction

enum GucAction
Enumerator
GUC_ACTION_SET 
GUC_ACTION_LOCAL 
GUC_ACTION_SAVE 

Definition at line 194 of file guc.h.

195 {
196  /* Types of set_config_option actions */
197  GUC_ACTION_SET, /* regular SET command */
198  GUC_ACTION_LOCAL, /* SET LOCAL command */
199  GUC_ACTION_SAVE /* function SET option, or temp assignment */
200 } GucAction;
GucAction
Definition: guc.h:195
@ GUC_ACTION_SAVE
Definition: guc.h:199
@ GUC_ACTION_SET
Definition: guc.h:197
@ GUC_ACTION_LOCAL
Definition: guc.h:198

◆ GucContext

enum GucContext
Enumerator
PGC_INTERNAL 
PGC_POSTMASTER 
PGC_SIGHUP 
PGC_SU_BACKEND 
PGC_BACKEND 
PGC_SUSET 
PGC_USERSET 

Definition at line 67 of file guc.h.

68 {
71  PGC_SIGHUP,
74  PGC_SUSET,
76 } GucContext;
GucContext
Definition: guc.h:68
@ PGC_SUSET
Definition: guc.h:74
@ PGC_INTERNAL
Definition: guc.h:69
@ PGC_USERSET
Definition: guc.h:75
@ PGC_SU_BACKEND
Definition: guc.h:72
@ PGC_POSTMASTER
Definition: guc.h:70
@ PGC_SIGHUP
Definition: guc.h:71
@ PGC_BACKEND
Definition: guc.h:73

◆ GucSource

enum GucSource
Enumerator
PGC_S_DEFAULT 
PGC_S_DYNAMIC_DEFAULT 
PGC_S_ENV_VAR 
PGC_S_FILE 
PGC_S_ARGV 
PGC_S_GLOBAL 
PGC_S_DATABASE 
PGC_S_USER 
PGC_S_DATABASE_USER 
PGC_S_CLIENT 
PGC_S_OVERRIDE 
PGC_S_INTERACTIVE 
PGC_S_TEST 
PGC_S_SESSION 

Definition at line 107 of file guc.h.

108 {
109  PGC_S_DEFAULT, /* hard-wired default ("boot_val") */
110  PGC_S_DYNAMIC_DEFAULT, /* default computed during initialization */
111  PGC_S_ENV_VAR, /* postmaster environment variable */
112  PGC_S_FILE, /* postgresql.conf */
113  PGC_S_ARGV, /* postmaster command line */
114  PGC_S_GLOBAL, /* global in-database setting */
115  PGC_S_DATABASE, /* per-database setting */
116  PGC_S_USER, /* per-user setting */
117  PGC_S_DATABASE_USER, /* per-user-and-database setting */
118  PGC_S_CLIENT, /* from client connection request */
119  PGC_S_OVERRIDE, /* special case to forcibly set default */
120  PGC_S_INTERACTIVE, /* dividing line for error reporting */
121  PGC_S_TEST, /* test per-database or per-user setting */
122  PGC_S_SESSION /* SET command */
123 } GucSource;
GucSource
Definition: guc.h:108
@ PGC_S_DEFAULT
Definition: guc.h:109
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:110
@ PGC_S_FILE
Definition: guc.h:112
@ PGC_S_GLOBAL
Definition: guc.h:114
@ PGC_S_DATABASE
Definition: guc.h:115
@ PGC_S_OVERRIDE
Definition: guc.h:119
@ PGC_S_ARGV
Definition: guc.h:113
@ PGC_S_SESSION
Definition: guc.h:122
@ PGC_S_CLIENT
Definition: guc.h:118
@ PGC_S_DATABASE_USER
Definition: guc.h:117
@ PGC_S_ENV_VAR
Definition: guc.h:111
@ PGC_S_USER
Definition: guc.h:116
@ PGC_S_TEST
Definition: guc.h:121
@ PGC_S_INTERACTIVE
Definition: guc.h:120

Function Documentation

◆ AlterSystemSetConfigFile()

void AlterSystemSetConfigFile ( AlterSystemStmt altersysstmt)

Definition at line 4431 of file guc.c.

4432 {
4433  char *name;
4434  char *value;
4435  bool resetall = false;
4436  ConfigVariable *head = NULL;
4437  ConfigVariable *tail = NULL;
4438  volatile int Tmpfd;
4439  char AutoConfFileName[MAXPGPATH];
4440  char AutoConfTmpFileName[MAXPGPATH];
4441 
4442  /*
4443  * Extract statement arguments
4444  */
4445  name = altersysstmt->setstmt->name;
4446 
4447  switch (altersysstmt->setstmt->kind)
4448  {
4449  case VAR_SET_VALUE:
4450  value = ExtractSetVariableArgs(altersysstmt->setstmt);
4451  break;
4452 
4453  case VAR_SET_DEFAULT:
4454  case VAR_RESET:
4455  value = NULL;
4456  break;
4457 
4458  case VAR_RESET_ALL:
4459  value = NULL;
4460  resetall = true;
4461  break;
4462 
4463  default:
4464  elog(ERROR, "unrecognized alter system stmt type: %d",
4465  altersysstmt->setstmt->kind);
4466  break;
4467  }
4468 
4469  /*
4470  * Check permission to run ALTER SYSTEM on the target variable
4471  */
4472  if (!superuser())
4473  {
4474  if (resetall)
4475  ereport(ERROR,
4476  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4477  errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4478  else
4479  {
4480  AclResult aclresult;
4481 
4482  aclresult = pg_parameter_aclcheck(name, GetUserId(),
4484  if (aclresult != ACLCHECK_OK)
4485  ereport(ERROR,
4486  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4487  errmsg("permission denied to set parameter \"%s\"",
4488  name)));
4489  }
4490  }
4491 
4492  /*
4493  * Unless it's RESET_ALL, validate the target variable and value
4494  */
4495  if (!resetall)
4496  {
4497  struct config_generic *record;
4498 
4499  record = find_option(name, false, false, ERROR);
4500  Assert(record != NULL);
4501 
4502  /*
4503  * Don't allow parameters that can't be set in configuration files to
4504  * be set in PG_AUTOCONF_FILENAME file.
4505  */
4506  if ((record->context == PGC_INTERNAL) ||
4507  (record->flags & GUC_DISALLOW_IN_FILE) ||
4508  (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
4509  ereport(ERROR,
4510  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4511  errmsg("parameter \"%s\" cannot be changed",
4512  name)));
4513 
4514  /*
4515  * If a value is specified, verify that it's sane.
4516  */
4517  if (value)
4518  {
4519  union config_var_val newval;
4520  void *newextra = NULL;
4521 
4522  /* Check that it's acceptable for the indicated parameter */
4523  if (!parse_and_validate_value(record, name, value,
4524  PGC_S_FILE, ERROR,
4525  &newval, &newextra))
4526  ereport(ERROR,
4527  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4528  errmsg("invalid value for parameter \"%s\": \"%s\"",
4529  name, value)));
4530 
4531  if (record->vartype == PGC_STRING && newval.stringval != NULL)
4532  guc_free(newval.stringval);
4533  guc_free(newextra);
4534 
4535  /*
4536  * We must also reject values containing newlines, because the
4537  * grammar for config files doesn't support embedded newlines in
4538  * string literals.
4539  */
4540  if (strchr(value, '\n'))
4541  ereport(ERROR,
4542  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4543  errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4544  }
4545  }
4546 
4547  /*
4548  * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4549  * the data directory, so we can reference them by simple relative paths.
4550  */
4551  snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4553  snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4554  AutoConfFileName,
4555  "tmp");
4556 
4557  /*
4558  * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4559  * time. Use AutoFileLock to ensure that. We must hold the lock while
4560  * reading the old file contents.
4561  */
4562  LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4563 
4564  /*
4565  * If we're going to reset everything, then no need to open or parse the
4566  * old file. We'll just write out an empty list.
4567  */
4568  if (!resetall)
4569  {
4570  struct stat st;
4571 
4572  if (stat(AutoConfFileName, &st) == 0)
4573  {
4574  /* open old file PG_AUTOCONF_FILENAME */
4575  FILE *infile;
4576 
4577  infile = AllocateFile(AutoConfFileName, "r");
4578  if (infile == NULL)
4579  ereport(ERROR,
4581  errmsg("could not open file \"%s\": %m",
4582  AutoConfFileName)));
4583 
4584  /* parse it */
4585  if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4586  LOG, &head, &tail))
4587  ereport(ERROR,
4588  (errcode(ERRCODE_CONFIG_FILE_ERROR),
4589  errmsg("could not parse contents of file \"%s\"",
4590  AutoConfFileName)));
4591 
4592  FreeFile(infile);
4593  }
4594 
4595  /*
4596  * Now, replace any existing entry with the new value, or add it if
4597  * not present.
4598  */
4599  replace_auto_config_value(&head, &tail, name, value);
4600  }
4601 
4602  /*
4603  * Invoke the post-alter hook for setting this GUC variable. GUCs
4604  * typically do not have corresponding entries in pg_parameter_acl, so we
4605  * call the hook using the name rather than a potentially-non-existent
4606  * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4607  * context can be distinguished from others. (Note that "name" will be
4608  * NULL in the RESET ALL case.)
4609  *
4610  * We do this here rather than at the end, because ALTER SYSTEM is not
4611  * transactional. If the hook aborts our transaction, it will be cleaner
4612  * to do so before we touch any files.
4613  */
4614  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4616  altersysstmt->setstmt->kind,
4617  false);
4618 
4619  /*
4620  * To ensure crash safety, first write the new file data to a temp file,
4621  * then atomically rename it into place.
4622  *
4623  * If there is a temp file left over due to a previous crash, it's okay to
4624  * truncate and reuse it.
4625  */
4626  Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4627  O_CREAT | O_RDWR | O_TRUNC);
4628  if (Tmpfd < 0)
4629  ereport(ERROR,
4631  errmsg("could not open file \"%s\": %m",
4632  AutoConfTmpFileName)));
4633 
4634  /*
4635  * Use a TRY block to clean up the file if we fail. Since we need a TRY
4636  * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4637  */
4638  PG_TRY();
4639  {
4640  /* Write and sync the new contents to the temporary file */
4641  write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4642 
4643  /* Close before renaming; may be required on some platforms */
4644  close(Tmpfd);
4645  Tmpfd = -1;
4646 
4647  /*
4648  * As the rename is atomic operation, if any problem occurs after this
4649  * at worst it can lose the parameters set by last ALTER SYSTEM
4650  * command.
4651  */
4652  durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4653  }
4654  PG_CATCH();
4655  {
4656  /* Close file first, else unlink might fail on some platforms */
4657  if (Tmpfd >= 0)
4658  close(Tmpfd);
4659 
4660  /* Unlink, but ignore any error */
4661  (void) unlink(AutoConfTmpFileName);
4662 
4663  PG_RE_THROW();
4664  }
4665  PG_END_TRY();
4666 
4667  FreeConfigVariables(head);
4668 
4669  LWLockRelease(AutoFileLock);
4670 }
AclResult
Definition: acl.h:183
@ ACLCHECK_OK
Definition: acl.h:184
AclResult pg_parameter_aclcheck(const char *name, Oid roleid, AclMode mode)
Definition: aclchk.c:4773
#define CONF_FILE_START_DEPTH
Definition: conffiles.h:17
int errcode_for_file_access(void)
Definition: elog.c:881
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define LOG
Definition: elog.h:31
#define PG_RE_THROW()
Definition: elog.h:411
#define PG_TRY(...)
Definition: elog.h:370
#define PG_END_TRY(...)
Definition: elog.h:395
#define ERROR
Definition: elog.h:39
#define PG_CATCH(...)
Definition: elog.h:380
#define ereport(elevel,...)
Definition: elog.h:149
const char * name
Definition: encode.c:561
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2383
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:688
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:993
int FreeFile(FILE *file)
Definition: fd.c:2581
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1162
static bool parse_and_validate_value(struct config_generic *record, const char *name, const char *value, GucSource source, int elevel, union config_var_val *newval, void **newextra)
Definition: guc.c:3064
void guc_free(void *ptr)
Definition: guc.c:681
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head)
Definition: guc.c:4293
#define newval
static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
Definition: guc.c:4361
#define PG_AUTOCONF_FILENAME
Definition: guc.h:33
void FreeConfigVariables(ConfigVariable *list)
bool ParseConfigFp(FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
#define GUC_DISALLOW_IN_FILE
Definition: guc.h:216
#define GUC_DISALLOW_IN_AUTO_FILE
Definition: guc.h:221
char * ExtractSetVariableArgs(VariableSetStmt *stmt)
Definition: guc_funcs.c:167
@ PGC_STRING
Definition: guc_tables.h:28
static struct @143 value
#define close(a)
Definition: win32.h:12
Assert(fmt[strlen(fmt) - 1] !='\n')
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1194
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1802
@ LW_EXCLUSIVE
Definition: lwlock.h:112
Oid GetUserId(void)
Definition: miscinit.c:497
#define InvokeObjectPostAlterHookArgStr(classId, objectName, subId, auxiliaryId, is_internal)
Definition: objectaccess.h:247
@ VAR_SET_DEFAULT
Definition: parsenodes.h:2245
@ VAR_RESET
Definition: parsenodes.h:2248
@ VAR_SET_VALUE
Definition: parsenodes.h:2244
@ VAR_RESET_ALL
Definition: parsenodes.h:2249
#define ACL_ALTER_SYSTEM
Definition: parsenodes.h:96
#define MAXPGPATH
#define snprintf
Definition: port.h:238
VariableSetStmt * setstmt
Definition: parsenodes.h:3450
VariableSetKind kind
Definition: parsenodes.h:2255
GucContext context
Definition: guc_tables.h:156
enum config_type vartype
Definition: guc_tables.h:162
bool superuser(void)
Definition: superuser.c:46
#define stat
Definition: win32_port.h:286
static void infile(const char *name)
Definition: zic.c:1243

References ACL_ALTER_SYSTEM, ACLCHECK_OK, AllocateFile(), Assert(), BasicOpenFile(), close, CONF_FILE_START_DEPTH, config_generic::context, durable_rename(), elog(), ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, ExtractSetVariableArgs(), find_option(), config_generic::flags, FreeConfigVariables(), FreeFile(), GetUserId(), GUC_DISALLOW_IN_AUTO_FILE, GUC_DISALLOW_IN_FILE, guc_free(), infile(), InvokeObjectPostAlterHookArgStr, VariableSetStmt::kind, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAXPGPATH, name, VariableSetStmt::name, newval, parse_and_validate_value(), ParseConfigFp(), PG_AUTOCONF_FILENAME, PG_CATCH, PG_END_TRY, pg_parameter_aclcheck(), PG_RE_THROW, PG_TRY, PGC_INTERNAL, PGC_S_FILE, PGC_STRING, replace_auto_config_value(), AlterSystemStmt::setstmt, snprintf, stat, superuser(), value, VAR_RESET, VAR_RESET_ALL, VAR_SET_DEFAULT, VAR_SET_VALUE, config_generic::vartype, and write_auto_conf_file().

Referenced by standard_ProcessUtility().

◆ AtEOXact_GUC()

void AtEOXact_GUC ( bool  isCommit,
int  nestLevel 
)

Definition at line 2196 of file guc.c.

2197 {
2198  slist_mutable_iter iter;
2199 
2200  /*
2201  * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
2202  * abort, if there is a failure during transaction start before
2203  * AtStart_GUC is called.
2204  */
2205  Assert(nestLevel > 0 &&
2206  (nestLevel <= GUCNestLevel ||
2207  (nestLevel == GUCNestLevel + 1 && !isCommit)));
2208 
2209  /* We need only process GUCs having nonempty stacks */
2211  {
2212  struct config_generic *gconf = slist_container(struct config_generic,
2213  stack_link, iter.cur);
2214  GucStack *stack;
2215 
2216  /*
2217  * Process and pop each stack entry within the nest level. To simplify
2218  * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
2219  * we allow failure exit from code that uses a local nest level to be
2220  * recovered at the surrounding transaction or subtransaction abort;
2221  * so there could be more than one stack entry to pop.
2222  */
2223  while ((stack = gconf->stack) != NULL &&
2224  stack->nest_level >= nestLevel)
2225  {
2226  GucStack *prev = stack->prev;
2227  bool restorePrior = false;
2228  bool restoreMasked = false;
2229  bool changed;
2230 
2231  /*
2232  * In this next bit, if we don't set either restorePrior or
2233  * restoreMasked, we must "discard" any unwanted fields of the
2234  * stack entries to avoid leaking memory. If we do set one of
2235  * those flags, unused fields will be cleaned up after restoring.
2236  */
2237  if (!isCommit) /* if abort, always restore prior value */
2238  restorePrior = true;
2239  else if (stack->state == GUC_SAVE)
2240  restorePrior = true;
2241  else if (stack->nest_level == 1)
2242  {
2243  /* transaction commit */
2244  if (stack->state == GUC_SET_LOCAL)
2245  restoreMasked = true;
2246  else if (stack->state == GUC_SET)
2247  {
2248  /* we keep the current active value */
2249  discard_stack_value(gconf, &stack->prior);
2250  }
2251  else /* must be GUC_LOCAL */
2252  restorePrior = true;
2253  }
2254  else if (prev == NULL ||
2255  prev->nest_level < stack->nest_level - 1)
2256  {
2257  /* decrement entry's level and do not pop it */
2258  stack->nest_level--;
2259  continue;
2260  }
2261  else
2262  {
2263  /*
2264  * We have to merge this stack entry into prev. See README for
2265  * discussion of this bit.
2266  */
2267  switch (stack->state)
2268  {
2269  case GUC_SAVE:
2270  Assert(false); /* can't get here */
2271  break;
2272 
2273  case GUC_SET:
2274  /* next level always becomes SET */
2275  discard_stack_value(gconf, &stack->prior);
2276  if (prev->state == GUC_SET_LOCAL)
2277  discard_stack_value(gconf, &prev->masked);
2278  prev->state = GUC_SET;
2279  break;
2280 
2281  case GUC_LOCAL:
2282  if (prev->state == GUC_SET)
2283  {
2284  /* LOCAL migrates down */
2285  prev->masked_scontext = stack->scontext;
2286  prev->masked_srole = stack->srole;
2287  prev->masked = stack->prior;
2288  prev->state = GUC_SET_LOCAL;
2289  }
2290  else
2291  {
2292  /* else just forget this stack level */
2293  discard_stack_value(gconf, &stack->prior);
2294  }
2295  break;
2296 
2297  case GUC_SET_LOCAL:
2298  /* prior state at this level no longer wanted */
2299  discard_stack_value(gconf, &stack->prior);
2300  /* copy down the masked state */
2302  prev->masked_srole = stack->masked_srole;
2303  if (prev->state == GUC_SET_LOCAL)
2304  discard_stack_value(gconf, &prev->masked);
2305  prev->masked = stack->masked;
2306  prev->state = GUC_SET_LOCAL;
2307  break;
2308  }
2309  }
2310 
2311  changed = false;
2312 
2313  if (restorePrior || restoreMasked)
2314  {
2315  /* Perform appropriate restoration of the stacked value */
2316  config_var_value newvalue;
2317  GucSource newsource;
2318  GucContext newscontext;
2319  Oid newsrole;
2320 
2321  if (restoreMasked)
2322  {
2323  newvalue = stack->masked;
2324  newsource = PGC_S_SESSION;
2325  newscontext = stack->masked_scontext;
2326  newsrole = stack->masked_srole;
2327  }
2328  else
2329  {
2330  newvalue = stack->prior;
2331  newsource = stack->source;
2332  newscontext = stack->scontext;
2333  newsrole = stack->srole;
2334  }
2335 
2336  switch (gconf->vartype)
2337  {
2338  case PGC_BOOL:
2339  {
2340  struct config_bool *conf = (struct config_bool *) gconf;
2341  bool newval = newvalue.val.boolval;
2342  void *newextra = newvalue.extra;
2343 
2344  if (*conf->variable != newval ||
2345  conf->gen.extra != newextra)
2346  {
2347  if (conf->assign_hook)
2348  conf->assign_hook(newval, newextra);
2349  *conf->variable = newval;
2350  set_extra_field(&conf->gen, &conf->gen.extra,
2351  newextra);
2352  changed = true;
2353  }
2354  break;
2355  }
2356  case PGC_INT:
2357  {
2358  struct config_int *conf = (struct config_int *) gconf;
2359  int newval = newvalue.val.intval;
2360  void *newextra = newvalue.extra;
2361 
2362  if (*conf->variable != newval ||
2363  conf->gen.extra != newextra)
2364  {
2365  if (conf->assign_hook)
2366  conf->assign_hook(newval, newextra);
2367  *conf->variable = newval;
2368  set_extra_field(&conf->gen, &conf->gen.extra,
2369  newextra);
2370  changed = true;
2371  }
2372  break;
2373  }
2374  case PGC_REAL:
2375  {
2376  struct config_real *conf = (struct config_real *) gconf;
2377  double newval = newvalue.val.realval;
2378  void *newextra = newvalue.extra;
2379 
2380  if (*conf->variable != newval ||
2381  conf->gen.extra != newextra)
2382  {
2383  if (conf->assign_hook)
2384  conf->assign_hook(newval, newextra);
2385  *conf->variable = newval;
2386  set_extra_field(&conf->gen, &conf->gen.extra,
2387  newextra);
2388  changed = true;
2389  }
2390  break;
2391  }
2392  case PGC_STRING:
2393  {
2394  struct config_string *conf = (struct config_string *) gconf;
2395  char *newval = newvalue.val.stringval;
2396  void *newextra = newvalue.extra;
2397 
2398  if (*conf->variable != newval ||
2399  conf->gen.extra != newextra)
2400  {
2401  if (conf->assign_hook)
2402  conf->assign_hook(newval, newextra);
2403  set_string_field(conf, conf->variable, newval);
2404  set_extra_field(&conf->gen, &conf->gen.extra,
2405  newextra);
2406  changed = true;
2407  }
2408 
2409  /*
2410  * Release stacked values if not used anymore. We
2411  * could use discard_stack_value() here, but since
2412  * we have type-specific code anyway, might as
2413  * well inline it.
2414  */
2415  set_string_field(conf, &stack->prior.val.stringval, NULL);
2416  set_string_field(conf, &stack->masked.val.stringval, NULL);
2417  break;
2418  }
2419  case PGC_ENUM:
2420  {
2421  struct config_enum *conf = (struct config_enum *) gconf;
2422  int newval = newvalue.val.enumval;
2423  void *newextra = newvalue.extra;
2424 
2425  if (*conf->variable != newval ||
2426  conf->gen.extra != newextra)
2427  {
2428  if (conf->assign_hook)
2429  conf->assign_hook(newval, newextra);
2430  *conf->variable = newval;
2431  set_extra_field(&conf->gen, &conf->gen.extra,
2432  newextra);
2433  changed = true;
2434  }
2435  break;
2436  }
2437  }
2438 
2439  /*
2440  * Release stacked extra values if not used anymore.
2441  */
2442  set_extra_field(gconf, &(stack->prior.extra), NULL);
2443  set_extra_field(gconf, &(stack->masked.extra), NULL);
2444 
2445  /* And restore source information */
2446  set_guc_source(gconf, newsource);
2447  gconf->scontext = newscontext;
2448  gconf->srole = newsrole;
2449  }
2450 
2451  /*
2452  * Pop the GUC's state stack; if it's now empty, remove the GUC
2453  * from guc_stack_list.
2454  */
2455  gconf->stack = prev;
2456  if (prev == NULL)
2457  slist_delete_current(&iter);
2458  pfree(stack);
2459 
2460  /* Report new value if we changed it */
2461  if (changed && (gconf->flags & GUC_REPORT) &&
2462  !(gconf->status & GUC_NEEDS_REPORT))
2463  {
2464  gconf->status |= GUC_NEEDS_REPORT;
2466  }
2467  } /* end of stack-popping loop */
2468  }
2469 
2470  /* Update nesting level */
2471  GUCNestLevel = nestLevel - 1;
2472 }
static slist_head guc_report_list
Definition: guc.c:221
static void set_string_field(struct config_string *conf, char **field, char *newval)
Definition: guc.c:723
static int GUCNestLevel
Definition: guc.c:226
static void discard_stack_value(struct config_generic *gconf, config_var_value *val)
Definition: guc.c:838
static slist_head guc_stack_list
Definition: guc.c:219
static void set_guc_source(struct config_generic *gconf, GucSource newsource)
Definition: guc.c:2058
static void set_extra_field(struct config_generic *gconf, void **field, void *newval)
Definition: guc.c:784
#define GUC_REPORT
Definition: guc.h:214
@ GUC_SET_LOCAL
Definition: guc_tables.h:113
@ GUC_SET
Definition: guc_tables.h:111
@ GUC_SAVE
Definition: guc_tables.h:110
@ GUC_LOCAL
Definition: guc_tables.h:112
#define GUC_NEEDS_REPORT
Definition: guc_tables.h:192
@ PGC_BOOL
Definition: guc_tables.h:25
@ PGC_ENUM
Definition: guc_tables.h:29
@ PGC_REAL
Definition: guc_tables.h:27
@ PGC_INT
Definition: guc_tables.h:26
static void slist_delete_current(slist_mutable_iter *iter)
Definition: ilist.h:1021
#define slist_foreach_modify(iter, lhead)
Definition: ilist.h:1085
static void slist_push_head(slist_head *head, slist_node *node)
Definition: ilist.h:943
#define slist_container(type, membername, ptr)
Definition: ilist.h:1043
void pfree(void *pointer)
Definition: mcxt.c:1306
unsigned int Oid
Definition: postgres_ext.h:31
struct config_generic gen
Definition: guc_tables.h:199
bool * variable
Definition: guc_tables.h:201
GucBoolAssignHook assign_hook
Definition: guc_tables.h:204
int * variable
Definition: guc_tables.h:261
GucEnumAssignHook assign_hook
Definition: guc_tables.h:265
struct config_generic gen
Definition: guc_tables.h:259
GucContext scontext
Definition: guc_tables.h:166
slist_node stack_link
Definition: guc_tables.h:174
GucStack * stack
Definition: guc_tables.h:170
slist_node report_link
Definition: guc_tables.h:176
GucIntAssignHook assign_hook
Definition: guc_tables.h:220
int * variable
Definition: guc_tables.h:215
struct config_generic gen
Definition: guc_tables.h:213
GucRealAssignHook assign_hook
Definition: guc_tables.h:236
double * variable
Definition: guc_tables.h:231
struct config_generic gen
Definition: guc_tables.h:229
struct config_generic gen
Definition: guc_tables.h:245
GucStringAssignHook assign_hook
Definition: guc_tables.h:250
char ** variable
Definition: guc_tables.h:247
union config_var_val val
Definition: guc_tables.h:47
struct guc_stack * prev
Definition: guc_tables.h:118
Oid masked_srole
Definition: guc_tables.h:126
int nest_level
Definition: guc_tables.h:119
config_var_value masked
Definition: guc_tables.h:128
config_var_value prior
Definition: guc_tables.h:127
GucContext scontext
Definition: guc_tables.h:123
GucStackState state
Definition: guc_tables.h:120
GucSource source
Definition: guc_tables.h:121
GucContext masked_scontext
Definition: guc_tables.h:124
slist_node * cur
Definition: ilist.h:274
double realval
Definition: guc_tables.h:36
char * stringval
Definition: guc_tables.h:37

References Assert(), config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_var_val::boolval, slist_mutable_iter::cur, discard_stack_value(), config_var_val::enumval, config_var_value::extra, config_generic::extra, config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_LOCAL, GUC_NEEDS_REPORT, GUC_REPORT, guc_report_list, GUC_SAVE, GUC_SET, GUC_SET_LOCAL, guc_stack_list, GUCNestLevel, config_var_val::intval, guc_stack::masked, guc_stack::masked_scontext, guc_stack::masked_srole, guc_stack::nest_level, newval, pfree(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_SESSION, PGC_STRING, guc_stack::prev, guc_stack::prior, config_var_val::realval, config_generic::report_link, guc_stack::scontext, config_generic::scontext, set_extra_field(), set_guc_source(), set_string_field(), slist_container, slist_delete_current(), slist_foreach_modify, slist_push_head(), guc_stack::source, guc_stack::srole, config_generic::srole, config_generic::stack, config_generic::stack_link, guc_stack::state, config_generic::status, config_var_val::stringval, config_var_value::val, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by AbortSubTransaction(), AbortTransaction(), brin_summarize_range(), bt_index_check_internal(), cluster_rel(), CommitSubTransaction(), CommitTransaction(), ComputeIndexAttrs(), DefineIndex(), do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), PrepareTransaction(), ProcedureCreate(), reindex_index(), ReindexRelationConcurrently(), reset_transmission_modes(), restoreLocalGucs(), RI_Initial_Check(), RI_PartitionRemove_Check(), vacuum_rel(), and validate_index().

◆ AtStart_GUC()

void AtStart_GUC ( void  )

Definition at line 2162 of file guc.c.

2163 {
2164  /*
2165  * The nest level should be 0 between transactions; if it isn't, somebody
2166  * didn't call AtEOXact_GUC, or called it with the wrong nestLevel. We
2167  * throw a warning but make no other effort to clean up.
2168  */
2169  if (GUCNestLevel != 0)
2170  elog(WARNING, "GUC nest level = %d at transaction start",
2171  GUCNestLevel);
2172  GUCNestLevel = 1;
2173 }
#define WARNING
Definition: elog.h:36

References elog(), GUCNestLevel, and WARNING.

Referenced by StartTransaction().

◆ BeginReportingGUCOptions()

void BeginReportingGUCOptions ( void  )

Definition at line 2480 of file guc.c.

2481 {
2483  GUCHashEntry *hentry;
2484 
2485  /*
2486  * Don't do anything unless talking to an interactive frontend.
2487  */
2489  return;
2490 
2491  reporting_enabled = true;
2492 
2493  /*
2494  * Hack for in_hot_standby: set the GUC value true if appropriate. This
2495  * is kind of an ugly place to do it, but there's few better options.
2496  *
2497  * (This could be out of date by the time we actually send it, in which
2498  * case the next ReportChangedGUCOptions call will send a duplicate
2499  * report.)
2500  */
2501  if (RecoveryInProgress())
2502  SetConfigOption("in_hot_standby", "true",
2504 
2505  /* Transmit initial values of interesting variables */
2507  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
2508  {
2509  struct config_generic *conf = hentry->gucvar;
2510 
2511  if (conf->flags & GUC_REPORT)
2512  ReportGUCOption(conf);
2513  }
2514 }
@ DestRemote
Definition: dest.h:91
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1431
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1421
static void ReportGUCOption(struct config_generic *record)
Definition: guc.c:2568
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4157
static HTAB * guc_hashtab
Definition: guc.c:207
static bool reporting_enabled
Definition: guc.c:224
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:225
CommandDest whereToSendOutput
Definition: postgres.c:85
struct config_generic * gucvar
Definition: guc.c:204
bool RecoveryInProgress(void)
Definition: xlog.c:5912

References DestRemote, config_generic::flags, guc_hashtab, GUC_REPORT, GUCHashEntry::gucvar, hash_seq_init(), hash_seq_search(), PGC_INTERNAL, PGC_S_OVERRIDE, RecoveryInProgress(), ReportGUCOption(), reporting_enabled, SetConfigOption(), status(), and whereToSendOutput.

Referenced by PostgresMain().

◆ check_GUC_name_for_parameter_acl()

bool check_GUC_name_for_parameter_acl ( const char *  name)

Definition at line 1374 of file guc.c.

1375 {
1376  /* OK if the GUC exists. */
1377  if (find_option(name, false, true, DEBUG1) != NULL)
1378  return true;
1379  /* Otherwise, it'd better be a valid custom GUC name. */
1381  return true;
1382  return false;
1383 }
#define DEBUG1
Definition: elog.h:30
static bool valid_custom_variable_name(const char *name)
Definition: guc.c:1068

References DEBUG1, find_option(), name, and valid_custom_variable_name().

Referenced by ParameterAclCreate().

◆ convert_GUC_name_for_parameter_acl()

char* convert_GUC_name_for_parameter_acl ( const char *  name)

Definition at line 1338 of file guc.c.

1339 {
1340  char *result;
1341 
1342  /* Apply old-GUC-name mapping. */
1343  for (int i = 0; map_old_guc_names[i] != NULL; i += 2)
1344  {
1346  {
1347  name = map_old_guc_names[i + 1];
1348  break;
1349  }
1350  }
1351 
1352  /* Apply case-folding that matches guc_name_compare(). */
1353  result = pstrdup(name);
1354  for (char *ptr = result; *ptr != '\0'; ptr++)
1355  {
1356  char ch = *ptr;
1357 
1358  if (ch >= 'A' && ch <= 'Z')
1359  {
1360  ch += 'a' - 'A';
1361  *ptr = ch;
1362  }
1363  }
1364 
1365  return result;
1366 }
static const char *const map_old_guc_names[]
Definition: guc.c:186
int guc_name_compare(const char *namea, const char *nameb)
Definition: guc.c:1264
int i
Definition: isn.c:73
char * pstrdup(const char *in)
Definition: mcxt.c:1483

References guc_name_compare(), i, map_old_guc_names, name, and pstrdup().

Referenced by ParameterAclCreate(), ParameterAclLookup(), and pg_parameter_aclmask().

◆ DeescapeQuotedString()

char* DeescapeQuotedString ( const char *  s)

◆ DefineCustomBoolVariable()

void DefineCustomBoolVariable ( const char *  name,
const char *  short_desc,
const char *  long_desc,
bool valueAddr,
bool  bootValue,
GucContext  context,
int  flags,
GucBoolCheckHook  check_hook,
GucBoolAssignHook  assign_hook,
GucShowHook  show_hook 
)

◆ DefineCustomEnumVariable()

void void void void void DefineCustomEnumVariable ( const char *  name,
const char *  short_desc,
const char *  long_desc,
int *  valueAddr,
int  bootValue,
const struct config_enum_entry options,
GucContext  context,
int  flags,
GucEnumCheckHook  check_hook,
GucEnumAssignHook  assign_hook,
GucShowHook  show_hook 
)

◆ DefineCustomIntVariable()

void void DefineCustomIntVariable ( const char *  name,
const char *  short_desc,
const char *  long_desc,
int *  valueAddr,
int  bootValue,
int  minValue,
int  maxValue,
GucContext  context,
int  flags,
GucIntCheckHook  check_hook,
GucIntAssignHook  assign_hook,
GucShowHook  show_hook 
)

◆ DefineCustomRealVariable()

void void void DefineCustomRealVariable ( const char *  name,
const char *  short_desc,
const char *  long_desc,
double *  valueAddr,
double  bootValue,
double  minValue,
double  maxValue,
GucContext  context,
int  flags,
GucRealCheckHook  check_hook,
GucRealAssignHook  assign_hook,
GucShowHook  show_hook 
)

◆ DefineCustomStringVariable()

void void void void DefineCustomStringVariable ( const char *  name,
const char *  short_desc,
const char *  long_desc,
char **  valueAddr,
const char *  bootValue,
GucContext  context,
int  flags,
GucStringCheckHook  check_hook,
GucStringAssignHook  assign_hook,
GucShowHook  show_hook 
)

◆ EstimateGUCStateSpace()

Size EstimateGUCStateSpace ( void  )

Definition at line 5755 of file guc.c.

5756 {
5757  Size size;
5758  dlist_iter iter;
5759 
5760  /* Add space reqd for saving the data size of the guc state */
5761  size = sizeof(Size);
5762 
5763  /*
5764  * Add up the space needed for each GUC variable.
5765  *
5766  * We need only process non-default GUCs.
5767  */
5769  {
5770  struct config_generic *gconf = dlist_container(struct config_generic,
5771  nondef_link, iter.cur);
5772 
5773  size = add_size(size, estimate_variable_size(gconf));
5774  }
5775 
5776  return size;
5777 }
size_t Size
Definition: c.h:541
static dlist_head guc_nondef_list
Definition: guc.c:217
static Size estimate_variable_size(struct config_generic *gconf)
Definition: guc.c:5655
#define dlist_foreach(iter, lhead)
Definition: ilist.h:573
#define dlist_container(type, membername, ptr)
Definition: ilist.h:543
Size add_size(Size s1, Size s2)
Definition: shmem.c:502
dlist_node nondef_link
Definition: guc_tables.h:172
dlist_node * cur
Definition: ilist.h:179

References add_size(), dlist_iter::cur, dlist_container, dlist_foreach, estimate_variable_size(), guc_nondef_list, and config_generic::nondef_link.

Referenced by InitializeParallelDSM().

◆ ExecSetVariableStmt()

void ExecSetVariableStmt ( VariableSetStmt stmt,
bool  isTopLevel 
)

Definition at line 43 of file guc_funcs.c.

44 {
46 
47  /*
48  * Workers synchronize these parameters at the start of the parallel
49  * operation; then, we block SET during the operation.
50  */
51  if (IsInParallelMode())
52  ereport(ERROR,
53  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
54  errmsg("cannot set parameters during a parallel operation")));
55 
56  switch (stmt->kind)
57  {
58  case VAR_SET_VALUE:
59  case VAR_SET_CURRENT:
60  if (stmt->is_local)
61  WarnNoTransactionBlock(isTopLevel, "SET LOCAL");
62  (void) set_config_option(stmt->name,
66  action, true, 0, false);
67  break;
68  case VAR_SET_MULTI:
69 
70  /*
71  * Special-case SQL syntaxes. The TRANSACTION and SESSION
72  * CHARACTERISTICS cases effectively set more than one variable
73  * per statement. TRANSACTION SNAPSHOT only takes one argument,
74  * but we put it here anyway since it's a special case and not
75  * related to any GUC variable.
76  */
77  if (strcmp(stmt->name, "TRANSACTION") == 0)
78  {
79  ListCell *head;
80 
81  WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION");
82 
83  foreach(head, stmt->args)
84  {
85  DefElem *item = (DefElem *) lfirst(head);
86 
87  if (strcmp(item->defname, "transaction_isolation") == 0)
88  SetPGVariable("transaction_isolation",
89  list_make1(item->arg), stmt->is_local);
90  else if (strcmp(item->defname, "transaction_read_only") == 0)
91  SetPGVariable("transaction_read_only",
92  list_make1(item->arg), stmt->is_local);
93  else if (strcmp(item->defname, "transaction_deferrable") == 0)
94  SetPGVariable("transaction_deferrable",
95  list_make1(item->arg), stmt->is_local);
96  else
97  elog(ERROR, "unexpected SET TRANSACTION element: %s",
98  item->defname);
99  }
100  }
101  else if (strcmp(stmt->name, "SESSION CHARACTERISTICS") == 0)
102  {
103  ListCell *head;
104 
105  foreach(head, stmt->args)
106  {
107  DefElem *item = (DefElem *) lfirst(head);
108 
109  if (strcmp(item->defname, "transaction_isolation") == 0)
110  SetPGVariable("default_transaction_isolation",
111  list_make1(item->arg), stmt->is_local);
112  else if (strcmp(item->defname, "transaction_read_only") == 0)
113  SetPGVariable("default_transaction_read_only",
114  list_make1(item->arg), stmt->is_local);
115  else if (strcmp(item->defname, "transaction_deferrable") == 0)
116  SetPGVariable("default_transaction_deferrable",
117  list_make1(item->arg), stmt->is_local);
118  else
119  elog(ERROR, "unexpected SET SESSION element: %s",
120  item->defname);
121  }
122  }
123  else if (strcmp(stmt->name, "TRANSACTION SNAPSHOT") == 0)
124  {
125  A_Const *con = linitial_node(A_Const, stmt->args);
126 
127  if (stmt->is_local)
128  ereport(ERROR,
129  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
130  errmsg("SET LOCAL TRANSACTION SNAPSHOT is not implemented")));
131 
132  WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION");
133  ImportSnapshot(strVal(&con->val));
134  }
135  else
136  elog(ERROR, "unexpected SET MULTI element: %s",
137  stmt->name);
138  break;
139  case VAR_SET_DEFAULT:
140  if (stmt->is_local)
141  WarnNoTransactionBlock(isTopLevel, "SET LOCAL");
142  /* fall through */
143  case VAR_RESET:
144  (void) set_config_option(stmt->name,
145  NULL,
148  action, true, 0, false);
149  break;
150  case VAR_RESET_ALL:
151  ResetAllOptions();
152  break;
153  }
154 
155  /* Invoke the post-alter hook for setting this GUC variable, by name. */
156  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, stmt->name,
157  ACL_SET, stmt->kind, false);
158 }
void ResetAllOptions(void)
Definition: guc.c:1950
int set_config_option(const char *name, const char *value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3265
void SetPGVariable(const char *name, List *args, bool is_local)
Definition: guc_funcs.c:325
#define ACL_SET
Definition: parsenodes.h:95
@ VAR_SET_MULTI
Definition: parsenodes.h:2247
@ VAR_SET_CURRENT
Definition: parsenodes.h:2246
#define lfirst(lc)
Definition: pg_list.h:170
#define linitial_node(type, l)
Definition: pg_list.h:179
#define list_make1(x1)
Definition: pg_list.h:210
void ImportSnapshot(const char *idstr)
Definition: snapmgr.c:1396
union ValUnion val
Definition: parsenodes.h:329
char * defname
Definition: parsenodes.h:779
Node * arg
Definition: parsenodes.h:780
#define strVal(v)
Definition: value.h:82
void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3531
bool IsInParallelMode(void)
Definition: xact.c:1068

References ACL_SET, generate_unaccent_rules::action, DefElem::arg, VariableSetStmt::args, DefElem::defname, elog(), ereport, errcode(), errmsg(), ERROR, ExtractSetVariableArgs(), GUC_ACTION_LOCAL, GUC_ACTION_SET, ImportSnapshot(), InvokeObjectPostAlterHookArgStr, VariableSetStmt::is_local, IsInParallelMode(), VariableSetStmt::kind, lfirst, linitial_node, list_make1, VariableSetStmt::name, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, ResetAllOptions(), set_config_option(), SetPGVariable(), strVal, superuser(), A_Const::val, VAR_RESET, VAR_RESET_ALL, VAR_SET_CURRENT, VAR_SET_DEFAULT, VAR_SET_MULTI, VAR_SET_VALUE, and WarnNoTransactionBlock().

Referenced by standard_ProcessUtility().

◆ ExtractSetVariableArgs()

char* ExtractSetVariableArgs ( VariableSetStmt stmt)

Definition at line 167 of file guc_funcs.c.

168 {
169 
170  switch (stmt->kind)
171  {
172  case VAR_SET_VALUE:
173  return flatten_set_variable_args(stmt->name, stmt->args);
174  case VAR_SET_CURRENT:
175  {
176  struct config_generic *record;
177  char *result;
178 
179  result = GetConfigOptionByName(stmt->name, NULL, false);
180  record = find_option(stmt->name, false, false, ERROR);
181  stmt->user_set = (record->scontext == PGC_USERSET);
182 
183  return result;
184  }
185  default:
186  return NULL;
187  }
188 }
char * GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
Definition: guc.c:5234
static char * flatten_set_variable_args(const char *name, List *args)
Definition: guc_funcs.c:202

References VariableSetStmt::args, ERROR, find_option(), flatten_set_variable_args(), GetConfigOptionByName(), VariableSetStmt::kind, VariableSetStmt::name, PGC_USERSET, config_generic::scontext, VariableSetStmt::user_set, VAR_SET_CURRENT, and VAR_SET_VALUE.

Referenced by AlterSetting(), AlterSystemSetConfigFile(), ExecSetVariableStmt(), and update_proconfig_value().

◆ FreeConfigVariables()

void FreeConfigVariables ( ConfigVariable list)

◆ get_config_unit_name()

const char* get_config_unit_name ( int  flags)

Definition at line 2748 of file guc.c.

2749 {
2750  switch (flags & (GUC_UNIT_MEMORY | GUC_UNIT_TIME))
2751  {
2752  case 0:
2753  return NULL; /* GUC has no units */
2754  case GUC_UNIT_BYTE:
2755  return "B";
2756  case GUC_UNIT_KB:
2757  return "kB";
2758  case GUC_UNIT_MB:
2759  return "MB";
2760  case GUC_UNIT_BLOCKS:
2761  {
2762  static char bbuf[8];
2763 
2764  /* initialize if first time through */
2765  if (bbuf[0] == '\0')
2766  snprintf(bbuf, sizeof(bbuf), "%dkB", BLCKSZ / 1024);
2767  return bbuf;
2768  }
2769  case GUC_UNIT_XBLOCKS:
2770  {
2771  static char xbuf[8];
2772 
2773  /* initialize if first time through */
2774  if (xbuf[0] == '\0')
2775  snprintf(xbuf, sizeof(xbuf), "%dkB", XLOG_BLCKSZ / 1024);
2776  return xbuf;
2777  }
2778  case GUC_UNIT_MS:
2779  return "ms";
2780  case GUC_UNIT_S:
2781  return "s";
2782  case GUC_UNIT_MIN:
2783  return "min";
2784  default:
2785  elog(ERROR, "unrecognized GUC units value: %d",
2786  flags & (GUC_UNIT_MEMORY | GUC_UNIT_TIME));
2787  return NULL;
2788  }
2789 }
#define GUC_UNIT_MB
Definition: guc.h:228
#define GUC_UNIT_TIME
Definition: guc.h:235
#define GUC_UNIT_MS
Definition: guc.h:232
#define GUC_UNIT_BLOCKS
Definition: guc.h:226
#define GUC_UNIT_XBLOCKS
Definition: guc.h:227
#define GUC_UNIT_BYTE
Definition: guc.h:229
#define GUC_UNIT_S
Definition: guc.h:233
#define GUC_UNIT_KB
Definition: guc.h:225
#define GUC_UNIT_MIN
Definition: guc.h:234
#define GUC_UNIT_MEMORY
Definition: guc.h:230

References elog(), ERROR, config_generic::flags, GUC_UNIT_BLOCKS, GUC_UNIT_BYTE, GUC_UNIT_KB, GUC_UNIT_MB, GUC_UNIT_MEMORY, GUC_UNIT_MIN, GUC_UNIT_MS, GUC_UNIT_S, GUC_UNIT_TIME, GUC_UNIT_XBLOCKS, and snprintf.

Referenced by GetConfigOptionValues(), and parse_and_validate_value().

◆ GetConfigOption()

const char* GetConfigOption ( const char *  name,
bool  missing_ok,
bool  restrict_privileged 
)

Definition at line 4181 of file guc.c.

4182 {
4183  struct config_generic *record;
4184  static char buffer[256];
4185 
4186  record = find_option(name, false, missing_ok, ERROR);
4187  if (record == NULL)
4188  return NULL;
4189  if (restrict_privileged &&
4190  (record->flags & GUC_SUPERUSER_ONLY) &&
4191  !has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_SETTINGS))
4192  ereport(ERROR,
4193  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4194  errmsg("must be superuser or have privileges of pg_read_all_settings to examine \"%s\"",
4195  name)));
4196 
4197  switch (record->vartype)
4198  {
4199  case PGC_BOOL:
4200  return *((struct config_bool *) record)->variable ? "on" : "off";
4201 
4202  case PGC_INT:
4203  snprintf(buffer, sizeof(buffer), "%d",
4204  *((struct config_int *) record)->variable);
4205  return buffer;
4206 
4207  case PGC_REAL:
4208  snprintf(buffer, sizeof(buffer), "%g",
4209  *((struct config_real *) record)->variable);
4210  return buffer;
4211 
4212  case PGC_STRING:
4213  return *((struct config_string *) record)->variable;
4214 
4215  case PGC_ENUM:
4216  return config_enum_lookup_by_value((struct config_enum *) record,
4217  *((struct config_enum *) record)->variable);
4218  }
4219  return NULL;
4220 }
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:4949
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:2957
#define GUC_SUPERUSER_ONLY
Definition: guc.h:218

References config_enum_lookup_by_value(), ereport, errcode(), errmsg(), ERROR, find_option(), config_generic::flags, GetUserId(), GUC_SUPERUSER_ONLY, has_privs_of_role(), name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, snprintf, and config_generic::vartype.

Referenced by applyRemoteGucs(), be_tls_init(), PostmasterMain(), and ProcessConfigFileInternal().

◆ GetConfigOptionByName()

char* GetConfigOptionByName ( const char *  name,
const char **  varname,
bool  missing_ok 
)

Definition at line 5234 of file guc.c.

5235 {
5236  struct config_generic *record;
5237 
5238  record = find_option(name, false, missing_ok, ERROR);
5239  if (record == NULL)
5240  {
5241  if (varname)
5242  *varname = NULL;
5243  return NULL;
5244  }
5245 
5246  if ((record->flags & GUC_SUPERUSER_ONLY) &&
5247  !has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_SETTINGS))
5248  ereport(ERROR,
5249  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
5250  errmsg("must be superuser or have privileges of pg_read_all_settings to examine \"%s\"",
5251  name)));
5252 
5253  if (varname)
5254  *varname = record->name;
5255 
5256  return ShowGUCOption(record, true);
5257 }
char * ShowGUCOption(struct config_generic *record, bool use_units)
Definition: guc.c:5267
const char * name
Definition: guc_tables.h:155

References ereport, errcode(), errmsg(), ERROR, find_option(), config_generic::flags, GetUserId(), GUC_SUPERUSER_ONLY, has_privs_of_role(), name, config_generic::name, and ShowGUCOption().

Referenced by ExplainPrintSettings(), ExtractSetVariableArgs(), GetPGVariableResultDesc(), set_config_by_name(), show_config_by_name(), show_config_by_name_missing_ok(), and ShowGUCConfigOption().

◆ GetConfigOptionFlags()

int GetConfigOptionFlags ( const char *  name,
bool  missing_ok 
)

Definition at line 4276 of file guc.c.

4277 {
4278  struct config_generic *record;
4279 
4280  record = find_option(name, false, missing_ok, ERROR);
4281  if (record == NULL)
4282  return 0;
4283  return record->flags;
4284 }

References ERROR, find_option(), config_generic::flags, and name.

Referenced by pg_get_functiondef(), and PostmasterMain().

◆ GetConfigOptionResetString()

const char* GetConfigOptionResetString ( const char *  name)

Definition at line 4230 of file guc.c.

4231 {
4232  struct config_generic *record;
4233  static char buffer[256];
4234 
4235  record = find_option(name, false, false, ERROR);
4236  Assert(record != NULL);
4237  if ((record->flags & GUC_SUPERUSER_ONLY) &&
4238  !has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_SETTINGS))
4239  ereport(ERROR,
4240  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4241  errmsg("must be superuser or have privileges of pg_read_all_settings to examine \"%s\"",
4242  name)));
4243 
4244  switch (record->vartype)
4245  {
4246  case PGC_BOOL:
4247  return ((struct config_bool *) record)->reset_val ? "on" : "off";
4248 
4249  case PGC_INT:
4250  snprintf(buffer, sizeof(buffer), "%d",
4251  ((struct config_int *) record)->reset_val);
4252  return buffer;
4253 
4254  case PGC_REAL:
4255  snprintf(buffer, sizeof(buffer), "%g",
4256  ((struct config_real *) record)->reset_val);
4257  return buffer;
4258 
4259  case PGC_STRING:
4260  return ((struct config_string *) record)->reset_val;
4261 
4262  case PGC_ENUM:
4263  return config_enum_lookup_by_value((struct config_enum *) record,
4264  ((struct config_enum *) record)->reset_val);
4265  }
4266  return NULL;
4267 }

References Assert(), config_enum_lookup_by_value(), ereport, errcode(), errmsg(), ERROR, find_option(), config_generic::flags, GetUserId(), GUC_SUPERUSER_ONLY, has_privs_of_role(), name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, snprintf, and config_generic::vartype.

Referenced by check_datestyle().

◆ GetPGVariable()

void GetPGVariable ( const char *  name,
DestReceiver dest 
)

Definition at line 392 of file guc_funcs.c.

393 {
394  if (guc_name_compare(name, "all") == 0)
396  else
398 }
static void ShowGUCConfigOption(const char *name, DestReceiver *dest)
Definition: guc_funcs.c:438
static void ShowAllGUCConfig(DestReceiver *dest)
Definition: guc_funcs.c:466

References generate_unaccent_rules::dest, guc_name_compare(), name, ShowAllGUCConfig(), and ShowGUCConfigOption().

Referenced by exec_replication_command(), and standard_ProcessUtility().

◆ GetPGVariableResultDesc()

TupleDesc GetPGVariableResultDesc ( const char *  name)

Definition at line 404 of file guc_funcs.c.

405 {
406  TupleDesc tupdesc;
407 
408  if (guc_name_compare(name, "all") == 0)
409  {
410  /* need a tuple descriptor representing three TEXT columns */
411  tupdesc = CreateTemplateTupleDesc(3);
412  TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
413  TEXTOID, -1, 0);
414  TupleDescInitEntry(tupdesc, (AttrNumber) 2, "setting",
415  TEXTOID, -1, 0);
416  TupleDescInitEntry(tupdesc, (AttrNumber) 3, "description",
417  TEXTOID, -1, 0);
418  }
419  else
420  {
421  const char *varname;
422 
423  /* Get the canonical spelling of name */
424  (void) GetConfigOptionByName(name, &varname, false);
425 
426  /* need a tuple descriptor representing a single TEXT column */
427  tupdesc = CreateTemplateTupleDesc(1);
428  TupleDescInitEntry(tupdesc, (AttrNumber) 1, varname,
429  TEXTOID, -1, 0);
430  }
431  return tupdesc;
432 }
int16 AttrNumber
Definition: attnum.h:21
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:45
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:583

References CreateTemplateTupleDesc(), GetConfigOptionByName(), guc_name_compare(), name, and TupleDescInitEntry().

Referenced by UtilityTupleDescriptor().

◆ GUC_check_errcode()

void GUC_check_errcode ( int  sqlerrcode)

◆ guc_free()

void guc_free ( void *  ptr)

Definition at line 681 of file guc.c.

682 {
683  /*
684  * Historically, GUC-related code has relied heavily on the ability to do
685  * free(NULL), so we allow that here even though pfree() doesn't.
686  */
687  if (ptr != NULL)
688  {
689  /* This is to help catch old code that malloc's GUC data. */
691  pfree(ptr);
692  }
693 }
static MemoryContext GUCMemoryContext
Definition: guc.c:194
MemoryContext GetMemoryChunkContext(void *pointer)
Definition: mcxt.c:589

References Assert(), GetMemoryChunkContext(), GUCMemoryContext, and pfree().

Referenced by add_placeholder_variable(), AlterSystemSetConfigFile(), call_string_check_hook(), check_client_encoding(), check_datestyle(), check_default_text_search_config(), define_custom_variable(), parse_and_validate_value(), ReportGUCOption(), RestoreGUCState(), SelectConfigFiles(), set_config_option_ext(), set_config_sourcefile(), set_extra_field(), and set_string_field().

◆ guc_malloc()

◆ guc_realloc()

pg_nodiscard void* guc_realloc ( int  elevel,
void *  old,
size_t  size 
)

Definition at line 644 of file guc.c.

645 {
646  void *data;
647 
648  if (old != NULL)
649  {
650  /* This is to help catch old code that malloc's GUC data. */
652  data = repalloc_extended(old, size,
654  }
655  else
656  {
657  /* Like realloc(3), but not like repalloc(), we allow old == NULL. */
660  }
661  if (unlikely(data == NULL))
662  ereport(elevel,
663  (errcode(ERRCODE_OUT_OF_MEMORY),
664  errmsg("out of memory")));
665  return data;
666 }
void * repalloc_extended(void *pointer, Size size, int flags)
Definition: mcxt.c:1360

References Assert(), data, ereport, errcode(), errmsg(), GetMemoryChunkContext(), GUCMemoryContext, MCXT_ALLOC_NO_OOM, MemoryContextAllocExtended(), repalloc_extended(), and unlikely.

◆ guc_strdup()

char* guc_strdup ( int  elevel,
const char *  src 
)

Definition at line 669 of file guc.c.

670 {
671  char *data;
672  size_t len = strlen(src) + 1;
673 
674  data = guc_malloc(elevel, len);
675  if (likely(data != NULL))
676  memcpy(data, src, len);
677  return data;
678 }
#define likely(x)
Definition: c.h:294
void * guc_malloc(int elevel, size_t size)
Definition: guc.c:630
const void size_t len

References data, guc_malloc(), len, and likely.

Referenced by add_placeholder_variable(), check_application_name(), check_client_encoding(), check_cluster_name(), check_datestyle(), check_default_text_search_config(), init_custom_variable(), InitializeOneGUCOption(), parse_and_validate_value(), ReportGUCOption(), set_config_option_ext(), and set_config_sourcefile().

◆ GUCArrayAdd()

ArrayType* GUCArrayAdd ( ArrayType array,
ArrayType **  usersetArray,
const char *  name,
const char *  value,
bool  user_set 
)

Definition at line 6284 of file guc.c.

6286 {
6287  struct config_generic *record;
6288  Datum datum;
6289  char *newval;
6290  ArrayType *a;
6291 
6292  Assert(name);
6293  Assert(value);
6294 
6295  /* test if the option is valid and we're allowed to set it */
6296  (void) validate_option_array_item(name, value, user_set, false);
6297 
6298  /* normalize name (converts obsolete GUC names to modern spellings) */
6299  record = find_option(name, false, true, WARNING);
6300  if (record)
6301  name = record->name;
6302 
6303  /* build new item for array */
6304  newval = psprintf("%s=%s", name, value);
6305  datum = CStringGetTextDatum(newval);
6306 
6307  if (array)
6308  {
6309  int index;
6310  bool isnull;
6311  int i;
6312 
6313  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6314  Assert(ARR_NDIM(array) == 1);
6315  Assert(ARR_LBOUND(array)[0] == 1);
6316 
6317  index = ARR_DIMS(array)[0] + 1; /* add after end */
6318 
6319  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6320  {
6321  Datum d;
6322  char *current;
6323 
6324  d = array_ref(array, 1, &i,
6325  -1 /* varlenarray */ ,
6326  -1 /* TEXT's typlen */ ,
6327  false /* TEXT's typbyval */ ,
6328  TYPALIGN_INT /* TEXT's typalign */ ,
6329  &isnull);
6330  if (isnull)
6331  continue;
6332  current = TextDatumGetCString(d);
6333 
6334  /* check for match up through and including '=' */
6335  if (strncmp(current, newval, strlen(name) + 1) == 0)
6336  {
6337  bool currentUserSet = false;
6338 
6339  if (usersetArray)
6340  {
6341  currentUserSet = DatumGetBool(array_ref(*usersetArray, 1, &i,
6342  -1 /* varlenarray */ ,
6343  sizeof(bool) /* BOOL's typlen */ ,
6344  true /* BOOL's typbyval */ ,
6345  TYPALIGN_CHAR /* BOOL's typalign */ ,
6346  &isnull));
6347  if (isnull)
6348  currentUserSet = false;
6349  }
6350 
6351  /*
6352  * Recheck permissons if we found an option without USER SET
6353  * flag while we're setting an optionn with USER SET flag.
6354  */
6355  if (!currentUserSet && user_set)
6357  false, false);
6358  index = i;
6359  break;
6360  }
6361  }
6362 
6363  a = array_set(array, 1, &index,
6364  datum,
6365  false,
6366  -1 /* varlena array */ ,
6367  -1 /* TEXT's typlen */ ,
6368  false /* TEXT's typbyval */ ,
6369  TYPALIGN_INT /* TEXT's typalign */ );
6370 
6371  if (usersetArray)
6372  *usersetArray = array_set(*usersetArray, 1, &index,
6373  BoolGetDatum(user_set),
6374  false,
6375  -1 /* varlena array */ ,
6376  sizeof(bool) /* BOOL's typlen */ ,
6377  true /* BOOL's typbyval */ ,
6378  TYPALIGN_CHAR /* BOOL's typalign */ );
6379  }
6380  else
6381  {
6382  a = construct_array_builtin(&datum, 1, TEXTOID);
6383  if (usersetArray)
6384  {
6385  datum = BoolGetDatum(user_set);
6386  *usersetArray = construct_array_builtin(&datum, 1, BOOLOID);
6387  }
6388  }
6389 
6390  return a;
6391 }
#define ARR_NDIM(a)
Definition: array.h:283
#define ARR_ELEMTYPE(a)
Definition: array.h:285
#define ARR_DIMS(a)
Definition: array.h:287
#define ARR_LBOUND(a)
Definition: array.h:289
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3363
ArrayType * array_set(ArrayType *array, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3145
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:3128
#define CStringGetTextDatum(s)
Definition: builtins.h:88
#define TextDatumGetCString(d)
Definition: builtins.h:89
static bool validate_option_array_item(const char *name, const char *value, bool user_set, bool skipIfNoPermissions)
Definition: guc.c:6606
int a
Definition: isn.c:69
static bool DatumGetBool(Datum X)
Definition: postgres.h:438
uintptr_t Datum
Definition: postgres.h:412
static Datum BoolGetDatum(bool X)
Definition: postgres.h:450
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
Definition: type.h:95

References a, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), array_set(), Assert(), BoolGetDatum(), construct_array_builtin(), CStringGetTextDatum, DatumGetBool(), find_option(), i, name, config_generic::name, newval, psprintf(), TextDatumGetCString, validate_option_array_item(), value, and WARNING.

Referenced by AlterSetting(), and update_proconfig_value().

◆ GUCArrayDelete()

ArrayType* GUCArrayDelete ( ArrayType array,
ArrayType **  usersetArray,
const char *  name 
)

Definition at line 6400 of file guc.c.

6401 {
6402  struct config_generic *record;
6403  ArrayType *newarray;
6404  ArrayType *newUsersetArray;
6405  int i;
6406  int index;
6407 
6408  Assert(name);
6409 
6410  /* normalize name (converts obsolete GUC names to modern spellings) */
6411  record = find_option(name, false, true, WARNING);
6412  if (record)
6413  name = record->name;
6414 
6415  /* if array is currently null, then surely nothing to delete */
6416  if (!array)
6417  return NULL;
6418 
6419  newarray = NULL;
6420  newUsersetArray = NULL;
6421  index = 1;
6422 
6423  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6424  {
6425  Datum d;
6426  Datum userSetDatum = BoolGetDatum(false);
6427  char *val;
6428  bool isnull;
6429 
6430  d = array_ref(array, 1, &i,
6431  -1 /* varlenarray */ ,
6432  -1 /* TEXT's typlen */ ,
6433  false /* TEXT's typbyval */ ,
6434  TYPALIGN_INT /* TEXT's typalign */ ,
6435  &isnull);
6436  if (isnull)
6437  continue;
6438  val = TextDatumGetCString(d);
6439 
6440  if (usersetArray)
6441  userSetDatum = array_ref(*usersetArray, 1, &i,
6442  -1 /* varlenarray */ ,
6443  sizeof(bool) /* BOOL's typlen */ ,
6444  true /* BOOL's typbyval */ ,
6445  TYPALIGN_CHAR /* BOOL's typalign */ ,
6446  &isnull);
6447  if (isnull)
6448  userSetDatum = BoolGetDatum(false);
6449 
6450  /* ignore entry if it's what we want to delete */
6451  if (strncmp(val, name, strlen(name)) == 0
6452  && val[strlen(name)] == '=')
6453  {
6454  /* test if the option is valid and we're allowed to set it */
6455  (void) validate_option_array_item(name, NULL,
6456  DatumGetBool(userSetDatum), false);
6457  continue;
6458  }
6459 
6460  /* else add it to the output array */
6461  if (newarray)
6462  {
6463  newarray = array_set(newarray, 1, &index,
6464  d,
6465  false,
6466  -1 /* varlenarray */ ,
6467  -1 /* TEXT's typlen */ ,
6468  false /* TEXT's typbyval */ ,
6469  TYPALIGN_INT /* TEXT's typalign */ );
6470  if (usersetArray)
6471  newUsersetArray = array_set(newUsersetArray, 1, &index,
6472  userSetDatum,
6473  false,
6474  -1 /* varlena array */ ,
6475  sizeof(bool) /* BOOL's typlen */ ,
6476  true /* BOOL's typbyval */ ,
6477  TYPALIGN_CHAR /* BOOL's typalign */ );
6478  }
6479  else
6480  {
6481  newarray = construct_array_builtin(&d, 1, TEXTOID);
6482  if (usersetArray)
6483  newUsersetArray = construct_array_builtin(&d, 1, BOOLOID);
6484  }
6485 
6486  index++;
6487  }
6488 
6489  if (usersetArray)
6490  *usersetArray = newUsersetArray;
6491 
6492  return newarray;
6493 }
long val
Definition: informix.c:664

References ARR_DIMS, array_ref(), array_set(), Assert(), BoolGetDatum(), construct_array_builtin(), DatumGetBool(), find_option(), i, name, config_generic::name, TextDatumGetCString, val, validate_option_array_item(), and WARNING.

Referenced by AlterSetting(), and update_proconfig_value().

◆ GUCArrayReset()

ArrayType* GUCArrayReset ( ArrayType array,
ArrayType **  usersetArray 
)

Definition at line 6502 of file guc.c.

6503 {
6504  ArrayType *newarray;
6505  ArrayType *newUsersetArray;
6506  int i;
6507  int index;
6508 
6509  /* if array is currently null, nothing to do */
6510  if (!array)
6511  return NULL;
6512 
6513  /* if we're superuser, we can delete everything, so just do it */
6514  if (superuser())
6515  return NULL;
6516 
6517  newarray = NULL;
6518  newUsersetArray = NULL;
6519  index = 1;
6520 
6521  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6522  {
6523  Datum d;
6524  Datum userSetDatum = BoolGetDatum(false);
6525  char *val;
6526  char *eqsgn;
6527  bool isnull;
6528 
6529  d = array_ref(array, 1, &i,
6530  -1 /* varlenarray */ ,
6531  -1 /* TEXT's typlen */ ,
6532  false /* TEXT's typbyval */ ,
6533  TYPALIGN_INT /* TEXT's typalign */ ,
6534  &isnull);
6535  if (isnull)
6536  continue;
6537  val = TextDatumGetCString(d);
6538 
6539  if (usersetArray)
6540  userSetDatum = array_ref(*usersetArray, 1, &i,
6541  -1 /* varlenarray */ ,
6542  sizeof(bool) /* BOOL's typlen */ ,
6543  true /* BOOL's typbyval */ ,
6544  TYPALIGN_CHAR /* BOOL's typalign */ ,
6545  &isnull);
6546  if (isnull)
6547  userSetDatum = BoolGetDatum(false);
6548 
6549  eqsgn = strchr(val, '=');
6550  *eqsgn = '\0';
6551 
6552  /* skip if we have permission to delete it */
6553  if (validate_option_array_item(val, NULL,
6554  DatumGetBool(userSetDatum), true))
6555  continue;
6556 
6557  /* else add it to the output array */
6558  if (newarray)
6559  {
6560  newarray = array_set(newarray, 1, &index,
6561  d,
6562  false,
6563  -1 /* varlenarray */ ,
6564  -1 /* TEXT's typlen */ ,
6565  false /* TEXT's typbyval */ ,
6566  TYPALIGN_INT /* TEXT's typalign */ );
6567  if (usersetArray)
6568  newUsersetArray = array_set(newUsersetArray, 1, &index,
6569  userSetDatum,
6570  false,
6571  -1 /* varlena array */ ,
6572  sizeof(bool) /* BOOL's typlen */ ,
6573  true /* BOOL's typbyval */ ,
6574  TYPALIGN_CHAR /* BOOL's typalign */ );
6575  }
6576  else
6577  {
6578  newarray = construct_array_builtin(&d, 1, TEXTOID);
6579  if (usersetArray)
6580  newUsersetArray = construct_array_builtin(&userSetDatum, 1, BOOLOID);
6581  }
6582 
6583  index++;
6584  pfree(val);
6585  }
6586 
6587  if (usersetArray)
6588  *usersetArray = newUsersetArray;
6589 
6590  return newarray;
6591 }

References ARR_DIMS, array_ref(), array_set(), BoolGetDatum(), construct_array_builtin(), DatumGetBool(), i, pfree(), superuser(), TextDatumGetCString, val, and validate_option_array_item().

Referenced by AlterSetting().

◆ InitializeGUCOptions()

void InitializeGUCOptions ( void  )

Definition at line 1476 of file guc.c.

1477 {
1479  GUCHashEntry *hentry;
1480 
1481  /*
1482  * Before log_line_prefix could possibly receive a nonempty setting, make
1483  * sure that timezone processing is minimally alive (see elog.c).
1484  */
1486 
1487  /*
1488  * Create GUCMemoryContext and build hash table of all GUC variables.
1489  */
1491 
1492  /*
1493  * Load all variables with their compiled-in defaults, and initialize
1494  * status fields as needed.
1495  */
1497  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
1498  {
1499  /* Check mapping between initial and default value */
1500  Assert(check_GUC_init(hentry->gucvar));
1501 
1502  InitializeOneGUCOption(hentry->gucvar);
1503  }
1504 
1505  reporting_enabled = false;
1506 
1507  /*
1508  * Prevent any attempt to override the transaction modes from
1509  * non-interactive sources.
1510  */
1511  SetConfigOption("transaction_isolation", "read committed",
1513  SetConfigOption("transaction_read_only", "no",
1515  SetConfigOption("transaction_deferrable", "no",
1517 
1518  /*
1519  * For historical reasons, some GUC parameters can receive defaults from
1520  * environment variables. Process those settings.
1521  */
1523 }
static void InitializeOneGUCOption(struct config_generic *gconf)
Definition: guc.c:1590
void build_guc_variables(void)
Definition: guc.c:895
static void InitializeGUCOptionsFromEnvironment(void)
Definition: guc.c:1535
void pg_timezone_initialize(void)
Definition: pgtz.c:361

References Assert(), build_guc_variables(), guc_hashtab, GUCHashEntry::gucvar, hash_seq_init(), hash_seq_search(), InitializeGUCOptionsFromEnvironment(), InitializeOneGUCOption(), pg_timezone_initialize(), PGC_POSTMASTER, PGC_S_OVERRIDE, reporting_enabled, SetConfigOption(), and status().

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ MarkGUCPrefixReserved()

void void void void void void MarkGUCPrefixReserved ( const char *  className)

Definition at line 5086 of file guc.c.

5087 {
5088  int classLen = strlen(className);
5090  GUCHashEntry *hentry;
5091  MemoryContext oldcontext;
5092 
5093  /*
5094  * Check for existing placeholders. We must actually remove invalid
5095  * placeholders, else future parallel worker startups will fail. (We
5096  * don't bother trying to free associated memory, since this shouldn't
5097  * happen often.)
5098  */
5100  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5101  {
5102  struct config_generic *var = hentry->gucvar;
5103 
5104  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5105  strncmp(className, var->name, classLen) == 0 &&
5106  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5107  {
5108  ereport(WARNING,
5109  (errcode(ERRCODE_INVALID_NAME),
5110  errmsg("invalid configuration parameter name \"%s\", removing it",
5111  var->name),
5112  errdetail("\"%s\" is now a reserved prefix.",
5113  className)));
5114  /* Remove it from the hash table */
5116  &var->name,
5117  HASH_REMOVE,
5118  NULL);
5119  /* Remove it from any lists it's in, too */
5120  RemoveGUCFromLists(var);
5121  }
5122  }
5123 
5124  /* And remember the name so we can prevent future mistakes. */
5127  MemoryContextSwitchTo(oldcontext);
5128 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:953
int errdetail(const char *fmt,...)
Definition: elog.c:1202
static void RemoveGUCFromLists(struct config_generic *gconf)
Definition: guc.c:1707
static List * reserved_class_prefix
Definition: guc.c:71
#define GUC_CUSTOM_PLACEHOLDER
Definition: guc.h:217
#define GUC_QUALIFIER_SEPARATOR
Definition: guc.h:202
@ HASH_REMOVE
Definition: hsearch.h:115
List * lappend(List *list, void *datum)
Definition: list.c:338
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:135

References ereport, errcode(), errdetail(), errmsg(), config_generic::flags, GUC_CUSTOM_PLACEHOLDER, guc_hashtab, GUC_QUALIFIER_SEPARATOR, GUCMemoryContext, GUCHashEntry::gucvar, HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), lappend(), MemoryContextSwitchTo(), config_generic::name, pstrdup(), RemoveGUCFromLists(), reserved_class_prefix, status(), and WARNING.

Referenced by _PG_init().

◆ NewGUCNestLevel()

◆ parse_int()

bool parse_int ( const char *  value,
int *  result,
int  flags,
const char **  hintmsg 
)

Definition at line 2805 of file guc.c.

2806 {
2807  /*
2808  * We assume here that double is wide enough to represent any integer
2809  * value with adequate precision.
2810  */
2811  double val;
2812  char *endptr;
2813 
2814  /* To suppress compiler warnings, always set output params */
2815  if (result)
2816  *result = 0;
2817  if (hintmsg)
2818  *hintmsg = NULL;
2819 
2820  /*
2821  * Try to parse as an integer (allowing octal or hex input). If the
2822  * conversion stops at a decimal point or 'e', or overflows, re-parse as
2823  * float. This should work fine as long as we have no unit names starting
2824  * with 'e'. If we ever do, the test could be extended to check for a
2825  * sign or digit after 'e', but for now that's unnecessary.
2826  */
2827  errno = 0;
2828  val = strtol(value, &endptr, 0);
2829  if (*endptr == '.' || *endptr == 'e' || *endptr == 'E' ||
2830  errno == ERANGE)
2831  {
2832  errno = 0;
2833  val = strtod(value, &endptr);
2834  }
2835 
2836  if (endptr == value || errno == ERANGE)
2837  return false; /* no HINT for these cases */
2838 
2839  /* reject NaN (infinities will fail range check below) */
2840  if (isnan(val))
2841  return false; /* treat same as syntax error; no HINT */
2842 
2843  /* allow whitespace between number and unit */
2844  while (isspace((unsigned char) *endptr))
2845  endptr++;
2846 
2847  /* Handle possible unit */
2848  if (*endptr != '\0')
2849  {
2850  if ((flags & GUC_UNIT) == 0)
2851  return false; /* this setting does not accept a unit */
2852 
2854  endptr, (flags & GUC_UNIT),
2855  &val))
2856  {
2857  /* invalid unit, or garbage after the unit; set hint and fail. */
2858  if (hintmsg)
2859  {
2860  if (flags & GUC_UNIT_MEMORY)
2861  *hintmsg = memory_units_hint;
2862  else
2863  *hintmsg = time_units_hint;
2864  }
2865  return false;
2866  }
2867  }
2868 
2869  /* Round to int, then check for overflow */
2870  val = rint(val);
2871 
2872  if (val > INT_MAX || val < INT_MIN)
2873  {
2874  if (hintmsg)
2875  *hintmsg = gettext_noop("Value exceeds integer range.");
2876  return false;
2877  }
2878 
2879  if (result)
2880  *result = (int) val;
2881  return true;
2882 }
#define gettext_noop(x)
Definition: c.h:1135
static const char * memory_units_hint
Definition: guc.c:115
static bool convert_to_base_unit(double value, const char *unit, int base_unit, double *base_value)
Definition: guc.c:2605
static const char * time_units_hint
Definition: guc.c:152
#define GUC_UNIT
Definition: guc.h:237

References convert_to_base_unit(), config_generic::flags, gettext_noop, GUC_UNIT, GUC_UNIT_MEMORY, memory_units_hint, time_units_hint, val, and value.

Referenced by apply_server_options(), apply_table_options(), get_batch_size_option(), parse_and_validate_value(), parse_one_reloption(), postgres_fdw_validator(), and postgresAcquireSampleRowsFunc().

◆ parse_real()

bool parse_real ( const char *  value,
double *  result,
int  flags,
const char **  hintmsg 
)

Definition at line 2895 of file guc.c.

2896 {
2897  double val;
2898  char *endptr;
2899 
2900  /* To suppress compiler warnings, always set output params */
2901  if (result)
2902  *result = 0;
2903  if (hintmsg)
2904  *hintmsg = NULL;
2905 
2906  errno = 0;
2907  val = strtod(value, &endptr);
2908 
2909  if (endptr == value || errno == ERANGE)
2910  return false; /* no HINT for these cases */
2911 
2912  /* reject NaN (infinities will fail range checks later) */
2913  if (isnan(val))
2914  return false; /* treat same as syntax error; no HINT */
2915 
2916  /* allow whitespace between number and unit */
2917  while (isspace((unsigned char) *endptr))
2918  endptr++;
2919 
2920  /* Handle possible unit */
2921  if (*endptr != '\0')
2922  {
2923  if ((flags & GUC_UNIT) == 0)
2924  return false; /* this setting does not accept a unit */
2925 
2927  endptr, (flags & GUC_UNIT),
2928  &val))
2929  {
2930  /* invalid unit, or garbage after the unit; set hint and fail. */
2931  if (hintmsg)
2932  {
2933  if (flags & GUC_UNIT_MEMORY)
2934  *hintmsg = memory_units_hint;
2935  else
2936  *hintmsg = time_units_hint;
2937  }
2938  return false;
2939  }
2940  }
2941 
2942  if (result)
2943  *result = val;
2944  return true;
2945 }

References convert_to_base_unit(), config_generic::flags, GUC_UNIT, GUC_UNIT_MEMORY, memory_units_hint, time_units_hint, val, and value.

Referenced by apply_server_options(), parse_and_validate_value(), parse_one_reloption(), and postgres_fdw_validator().

◆ ParseConfigDirectory()

bool ParseConfigDirectory ( const char *  includedir,
const char *  calling_file,
int  calling_lineno,
int  depth,
int  elevel,
ConfigVariable **  head_p,
ConfigVariable **  tail_p 
)

◆ ParseConfigFile()

bool ParseConfigFile ( const char *  config_file,
bool  strict,
const char *  calling_file,
int  calling_lineno,
int  depth,
int  elevel,
ConfigVariable **  head_p,
ConfigVariable **  tail_p 
)

◆ ParseConfigFp()

bool ParseConfigFp ( FILE *  fp,
const char *  config_file,
int  depth,
int  elevel,
ConfigVariable **  head_p,
ConfigVariable **  tail_p 
)

◆ ParseLongOption()

void ParseLongOption ( const char *  string,
char **  name,
char **  value 
)

Definition at line 6169 of file guc.c.

6170 {
6171  size_t equal_pos;
6172  char *cp;
6173 
6174  Assert(string);
6175  Assert(name);
6176  Assert(value);
6177 
6178  equal_pos = strcspn(string, "=");
6179 
6180  if (string[equal_pos] == '=')
6181  {
6182  *name = palloc(equal_pos + 1);
6183  strlcpy(*name, string, equal_pos + 1);
6184  *value = pstrdup(&string[equal_pos + 1]);
6185  }
6186  else
6187  {
6188  /* no equal sign in string */
6189  *name = pstrdup(string);
6190  *value = NULL;
6191  }
6192 
6193  for (cp = *name; *cp; cp++)
6194  if (*cp == '-')
6195  *cp = '_';
6196 }
void * palloc(Size size)
Definition: mcxt.c:1199
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45

References Assert(), name, palloc(), pstrdup(), strlcpy(), and value.

Referenced by BootstrapModeMain(), PostmasterMain(), process_postgres_switches(), and ProcessGUCArray().

◆ ProcessConfigFile()

◆ ProcessGUCArray()

void ProcessGUCArray ( ArrayType array,
ArrayType usersetArray,
GucContext  context,
GucSource  source,
GucAction  action 
)

Definition at line 6206 of file guc.c.

6208 {
6209  int i;
6210 
6211  Assert(array != NULL);
6212  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6213  Assert(ARR_NDIM(array) == 1);
6214  Assert(ARR_LBOUND(array)[0] == 1);
6215 
6216  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6217  {
6218  Datum d;
6219  Datum userSetDatum = BoolGetDatum(false);
6220  bool isnull;
6221  char *s;
6222  char *name;
6223  char *value;
6224 
6225  d = array_ref(array, 1, &i,
6226  -1 /* varlenarray */ ,
6227  -1 /* TEXT's typlen */ ,
6228  false /* TEXT's typbyval */ ,
6229  TYPALIGN_INT /* TEXT's typalign */ ,
6230  &isnull);
6231 
6232  if (isnull)
6233  continue;
6234 
6235  s = TextDatumGetCString(d);
6236 
6237  ParseLongOption(s, &name, &value);
6238  if (!value)
6239  {
6240  ereport(WARNING,
6241  (errcode(ERRCODE_SYNTAX_ERROR),
6242  errmsg("could not parse setting for parameter \"%s\"",
6243  name)));
6244  pfree(name);
6245  continue;
6246  }
6247 
6248  if (usersetArray)
6249  userSetDatum = array_ref(usersetArray, 1, &i,
6250  -1 /* varlenarray */ ,
6251  sizeof(bool) /* BOOL's typlen */ ,
6252  true /* BOOL's typbyval */ ,
6253  TYPALIGN_CHAR /* BOOL's typalign */ ,
6254  &isnull);
6255  if (isnull)
6256  userSetDatum = BoolGetDatum(false);
6257 
6258  /*
6259  * USER SET values are appliciable only for PGC_USERSET parameters. We
6260  * use InvalidOid as role in order to evade possible privileges of the
6261  * current user.
6262  */
6263  if (!DatumGetBool(userSetDatum))
6264  (void) set_config_option(name, value,
6265  context, source,
6266  action, true, 0, false);
6267  else
6270  action, true, 0, false);
6271 
6272  pfree(name);
6273  pfree(value);
6274  pfree(s);
6275  }
6276 }
int set_config_option_ext(const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3305
void ParseLongOption(const char *string, char **name, char **value)
Definition: guc.c:6169
static rewind_source * source
Definition: pg_rewind.c:81
#define InvalidOid
Definition: postgres_ext.h:36

References generate_unaccent_rules::action, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), Assert(), BoolGetDatum(), DatumGetBool(), ereport, errcode(), errmsg(), i, InvalidOid, name, ParseLongOption(), pfree(), PGC_USERSET, set_config_option(), set_config_option_ext(), source, TextDatumGetCString, value, and WARNING.

Referenced by ApplySetting(), fmgr_security_definer(), and ProcedureCreate().

◆ ReportChangedGUCOptions()

void ReportChangedGUCOptions ( void  )

Definition at line 2530 of file guc.c.

2531 {
2532  slist_mutable_iter iter;
2533 
2534  /* Quick exit if not (yet) enabled */
2535  if (!reporting_enabled)
2536  return;
2537 
2538  /*
2539  * Since in_hot_standby isn't actually changed by normal GUC actions, we
2540  * need a hack to check whether a new value needs to be reported to the
2541  * client. For speed, we rely on the assumption that it can never
2542  * transition from false to true.
2543  */
2545  SetConfigOption("in_hot_standby", "false",
2547 
2548  /* Transmit new values of interesting variables */
2550  {
2551  struct config_generic *conf = slist_container(struct config_generic,
2552  report_link, iter.cur);
2553 
2554  Assert((conf->flags & GUC_REPORT) && (conf->status & GUC_NEEDS_REPORT));
2555  ReportGUCOption(conf);
2556  conf->status &= ~GUC_NEEDS_REPORT;
2557  slist_delete_current(&iter);
2558  }
2559 }
bool in_hot_standby_guc
Definition: guc_tables.c:587

References Assert(), slist_mutable_iter::cur, config_generic::flags, GUC_NEEDS_REPORT, GUC_REPORT, guc_report_list, in_hot_standby_guc, PGC_INTERNAL, PGC_S_OVERRIDE, RecoveryInProgress(), config_generic::report_link, ReportGUCOption(), reporting_enabled, SetConfigOption(), slist_container, slist_delete_current(), slist_foreach_modify, and config_generic::status.

Referenced by PostgresMain().

◆ ResetAllOptions()

void ResetAllOptions ( void  )

Definition at line 1950 of file guc.c.

1951 {
1952  dlist_mutable_iter iter;
1953 
1954  /* We need only consider GUCs not already at PGC_S_DEFAULT */
1956  {
1957  struct config_generic *gconf = dlist_container(struct config_generic,
1958  nondef_link, iter.cur);
1959 
1960  /* Don't reset non-SET-able values */
1961  if (gconf->context != PGC_SUSET &&
1962  gconf->context != PGC_USERSET)
1963  continue;
1964  /* Don't reset if special exclusion from RESET ALL */
1965  if (gconf->flags & GUC_NO_RESET_ALL)
1966  continue;
1967  /* No need to reset if wasn't SET */
1968  if (gconf->source <= PGC_S_OVERRIDE)
1969  continue;
1970 
1971  /* Save old value to support transaction abort */
1973 
1974  switch (gconf->vartype)
1975  {
1976  case PGC_BOOL:
1977  {
1978  struct config_bool *conf = (struct config_bool *) gconf;
1979 
1980  if (conf->assign_hook)
1981  conf->assign_hook(conf->reset_val,
1982  conf->reset_extra);
1983  *conf->variable = conf->reset_val;
1984  set_extra_field(&conf->gen, &conf->gen.extra,
1985  conf->reset_extra);
1986  break;
1987  }
1988  case PGC_INT:
1989  {
1990  struct config_int *conf = (struct config_int *) gconf;
1991 
1992  if (conf->assign_hook)
1993  conf->assign_hook(conf->reset_val,
1994  conf->reset_extra);
1995  *conf->variable = conf->reset_val;
1996  set_extra_field(&conf->gen, &conf->gen.extra,
1997  conf->reset_extra);
1998  break;
1999  }
2000  case PGC_REAL:
2001  {
2002  struct config_real *conf = (struct config_real *) gconf;
2003 
2004  if (conf->assign_hook)
2005  conf->assign_hook(conf->reset_val,
2006  conf->reset_extra);
2007  *conf->variable = conf->reset_val;
2008  set_extra_field(&conf->gen, &conf->gen.extra,
2009  conf->reset_extra);
2010  break;
2011  }
2012  case PGC_STRING:
2013  {
2014  struct config_string *conf = (struct config_string *) gconf;
2015 
2016  if (conf->assign_hook)
2017  conf->assign_hook(conf->reset_val,
2018  conf->reset_extra);
2019  set_string_field(conf, conf->variable, conf->reset_val);
2020  set_extra_field(&conf->gen, &conf->gen.extra,
2021  conf->reset_extra);
2022  break;
2023  }
2024  case PGC_ENUM:
2025  {
2026  struct config_enum *conf = (struct config_enum *) gconf;
2027 
2028  if (conf->assign_hook)
2029  conf->assign_hook(conf->reset_val,
2030  conf->reset_extra);
2031  *conf->variable = conf->reset_val;
2032  set_extra_field(&conf->gen, &conf->gen.extra,
2033  conf->reset_extra);
2034  break;
2035  }
2036  }
2037 
2038  set_guc_source(gconf, gconf->reset_source);
2039  gconf->scontext = gconf->reset_scontext;
2040  gconf->srole = gconf->reset_srole;
2041 
2042  if ((gconf->flags & GUC_REPORT) && !(gconf->status & GUC_NEEDS_REPORT))
2043  {
2044  gconf->status |= GUC_NEEDS_REPORT;
2046  }
2047  }
2048 }
static void push_old_value(struct config_generic *gconf, GucAction action)
Definition: guc.c:2081
#define GUC_NO_RESET_ALL
Definition: guc.h:212
#define dlist_foreach_modify(iter, lhead)
Definition: ilist.h:590
void * reset_extra
Definition: guc_tables.h:208
bool reset_val
Definition: guc_tables.h:207
void * reset_extra
Definition: guc_tables.h:269
GucContext reset_scontext
Definition: guc_tables.h:167
GucSource source
Definition: guc_tables.h:164
GucSource reset_source
Definition: guc_tables.h:165
void * reset_extra
Definition: guc_tables.h:224
int reset_val
Definition: guc_tables.h:223
void * reset_extra
Definition: guc_tables.h:240
double reset_val
Definition: guc_tables.h:239
char * reset_val
Definition: guc_tables.h:253
void * reset_extra
Definition: guc_tables.h:254
dlist_node * cur
Definition: ilist.h:200

References config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_generic::context, dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, config_generic::extra, config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_ACTION_SET, GUC_NEEDS_REPORT, GUC_NO_RESET_ALL, guc_nondef_list, GUC_REPORT, guc_report_list, config_generic::nondef_link, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_OVERRIDE, PGC_STRING, PGC_SUSET, PGC_USERSET, push_old_value(), config_generic::report_link, config_bool::reset_extra, config_int::reset_extra, config_real::reset_extra, config_string::reset_extra, config_enum::reset_extra, config_generic::reset_scontext, config_generic::reset_source, config_generic::reset_srole, config_bool::reset_val, config_int::reset_val, config_real::reset_val, config_string::reset_val, config_enum::reset_val, config_generic::scontext, set_extra_field(), set_guc_source(), set_string_field(), slist_push_head(), config_generic::source, config_generic::srole, config_generic::status, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by DiscardAll(), and ExecSetVariableStmt().

◆ RestoreGUCState()

void RestoreGUCState ( void *  gucstate)

Definition at line 6000 of file guc.c.

6001 {
6002  char *varname,
6003  *varvalue,
6004  *varsourcefile;
6005  int varsourceline;
6006  GucSource varsource;
6007  GucContext varscontext;
6008  Oid varsrole;
6009  char *srcptr = (char *) gucstate;
6010  char *srcend;
6011  Size len;
6012  dlist_mutable_iter iter;
6013  ErrorContextCallback error_context_callback;
6014 
6015  /*
6016  * First, ensure that all potentially-shippable GUCs are reset to their
6017  * default values. We must not touch those GUCs that the leader will
6018  * never ship, while there is no need to touch those that are shippable
6019  * but already have their default values. Thus, this ends up being the
6020  * same test that SerializeGUCState uses, even though the sets of
6021  * variables involved may well be different since the leader's set of
6022  * variables-not-at-default-values can differ from the set that are
6023  * not-default in this freshly started worker.
6024  *
6025  * Once we have set all the potentially-shippable GUCs to default values,
6026  * restoring the GUCs that the leader sent (because they had non-default
6027  * values over there) leads us to exactly the set of GUC values that the
6028  * leader has. This is true even though the worker may have initially
6029  * absorbed postgresql.conf settings that the leader hasn't yet seen, or
6030  * ALTER USER/DATABASE SET settings that were established after the leader
6031  * started.
6032  *
6033  * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
6034  * also ensures that set_config_option won't refuse to set them because of
6035  * source-priority comparisons.
6036  */
6038  {
6039  struct config_generic *gconf = dlist_container(struct config_generic,
6040  nondef_link, iter.cur);
6041 
6042  /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
6043  if (can_skip_gucvar(gconf))
6044  continue;
6045 
6046  /*
6047  * We can use InitializeOneGUCOption to reset the GUC to default, but
6048  * first we must free any existing subsidiary data to avoid leaking
6049  * memory. The stack must be empty, but we have to clean up all other
6050  * fields. Beware that there might be duplicate value or "extra"
6051  * pointers. We also have to be sure to take it out of any lists it's
6052  * in.
6053  */
6054  Assert(gconf->stack == NULL);
6055  guc_free(gconf->extra);
6056  guc_free(gconf->last_reported);
6057  guc_free(gconf->sourcefile);
6058  switch (gconf->vartype)
6059  {
6060  case PGC_BOOL:
6061  {
6062  struct config_bool *conf = (struct config_bool *) gconf;
6063 
6064  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6065  guc_free(conf->reset_extra);
6066  break;
6067  }
6068  case PGC_INT:
6069  {
6070  struct config_int *conf = (struct config_int *) gconf;
6071 
6072  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6073  guc_free(conf->reset_extra);
6074  break;
6075  }
6076  case PGC_REAL:
6077  {
6078  struct config_real *conf = (struct config_real *) gconf;
6079 
6080  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6081  guc_free(conf->reset_extra);
6082  break;
6083  }
6084  case PGC_STRING:
6085  {
6086  struct config_string *conf = (struct config_string *) gconf;
6087 
6088  guc_free(*conf->variable);
6089  if (conf->reset_val && conf->reset_val != *conf->variable)
6090  guc_free(conf->reset_val);
6091  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6092  guc_free(conf->reset_extra);
6093  break;
6094  }
6095  case PGC_ENUM:
6096  {
6097  struct config_enum *conf = (struct config_enum *) gconf;
6098 
6099  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6100  guc_free(conf->reset_extra);
6101  break;
6102  }
6103  }
6104  /* Remove it from any lists it's in. */
6105  RemoveGUCFromLists(gconf);
6106  /* Now we can reset the struct to PGS_S_DEFAULT state. */
6107  InitializeOneGUCOption(gconf);
6108  }
6109 
6110  /* First item is the length of the subsequent data */
6111  memcpy(&len, gucstate, sizeof(len));
6112 
6113  srcptr += sizeof(len);
6114  srcend = srcptr + len;
6115 
6116  /* If the GUC value check fails, we want errors to show useful context. */
6117  error_context_callback.callback = guc_restore_error_context_callback;
6118  error_context_callback.previous = error_context_stack;
6119  error_context_callback.arg = NULL;
6120  error_context_stack = &error_context_callback;
6121 
6122  /* Restore all the listed GUCs. */
6123  while (srcptr < srcend)
6124  {
6125  int result;
6126  char *error_context_name_and_value[2];
6127 
6128  varname = read_gucstate(&srcptr, srcend);
6129  varvalue = read_gucstate(&srcptr, srcend);
6130  varsourcefile = read_gucstate(&srcptr, srcend);
6131  if (varsourcefile[0])
6132  read_gucstate_binary(&srcptr, srcend,
6133  &varsourceline, sizeof(varsourceline));
6134  else
6135  varsourceline = 0;
6136  read_gucstate_binary(&srcptr, srcend,
6137  &varsource, sizeof(varsource));
6138  read_gucstate_binary(&srcptr, srcend,
6139  &varscontext, sizeof(varscontext));
6140  read_gucstate_binary(&srcptr, srcend,
6141  &varsrole, sizeof(varsrole));
6142 
6143  error_context_name_and_value[0] = varname;
6144  error_context_name_and_value[1] = varvalue;
6145  error_context_callback.arg = &error_context_name_and_value[0];
6146  result = set_config_option_ext(varname, varvalue,
6147  varscontext, varsource, varsrole,
6148  GUC_ACTION_SET, true, ERROR, true);
6149  if (result <= 0)
6150  ereport(ERROR,
6151  (errcode(ERRCODE_INTERNAL_ERROR),
6152  errmsg("parameter \"%s\" could not be set", varname)));
6153  if (varsourcefile[0])
6154  set_config_sourcefile(varname, varsourcefile, varsourceline);
6155  error_context_callback.arg = NULL;
6156  }
6157 
6158  error_context_stack = error_context_callback.previous;
6159 }
ErrorContextCallback * error_context_stack
Definition: elog.c:95
static void guc_restore_error_context_callback(void *arg)
Definition: guc.c:5978
static void set_config_sourcefile(const char *name, char *sourcefile, int sourceline)
Definition: guc.c:4124
static char * read_gucstate(char **srcptr, char *srcend)
Definition: guc.c:5941
static bool can_skip_gucvar(struct config_generic *gconf)
Definition: guc.c:5615
static void read_gucstate_binary(char **srcptr, char *srcend, void *dest, Size size)
Definition: guc.c:5964
struct ErrorContextCallback * previous
Definition: elog.h:295
void(* callback)(void *arg)
Definition: elog.h:296
char * last_reported
Definition: guc_tables.h:178
char * sourcefile
Definition: guc_tables.h:180

References ErrorContextCallback::arg, Assert(), ErrorContextCallback::callback, can_skip_gucvar(), dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, ereport, errcode(), errmsg(), ERROR, error_context_stack, config_generic::extra, GUC_ACTION_SET, guc_free(), guc_nondef_list, guc_restore_error_context_callback(), InitializeOneGUCOption(), config_generic::last_reported, len, config_generic::nondef_link, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, ErrorContextCallback::previous, read_gucstate(), read_gucstate_binary(), RemoveGUCFromLists(), config_bool::reset_extra, config_int::reset_extra, config_real::reset_extra, config_string::reset_extra, config_enum::reset_extra, config_string::reset_val, set_config_option_ext(), set_config_sourcefile(), config_generic::sourcefile, config_generic::stack, config_string::variable, and config_generic::vartype.

Referenced by ParallelWorkerMain().

◆ SelectConfigFiles()

bool SelectConfigFiles ( const char *  userDoption,
const char *  progname 
)

Definition at line 1730 of file guc.c.

1731 {
1732  char *configdir;
1733  char *fname;
1734  bool fname_is_malloced;
1735  struct stat stat_buf;
1736  struct config_string *data_directory_rec;
1737 
1738  /* configdir is -D option, or $PGDATA if no -D */
1739  if (userDoption)
1740  configdir = make_absolute_path(userDoption);
1741  else
1742  configdir = make_absolute_path(getenv("PGDATA"));
1743 
1744  if (configdir && stat(configdir, &stat_buf) != 0)
1745  {
1746  write_stderr("%s: could not access directory \"%s\": %s\n",
1747  progname,
1748  configdir,
1749  strerror(errno));
1750  if (errno == ENOENT)
1751  write_stderr("Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n");
1752  return false;
1753  }
1754 
1755  /*
1756  * Find the configuration file: if config_file was specified on the
1757  * command line, use it, else use configdir/postgresql.conf. In any case
1758  * ensure the result is an absolute path, so that it will be interpreted
1759  * the same way by future backends.
1760  */
1761  if (ConfigFileName)
1762  {
1764  fname_is_malloced = true;
1765  }
1766  else if (configdir)
1767  {
1768  fname = guc_malloc(FATAL,
1769  strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
1770  sprintf(fname, "%s/%s", configdir, CONFIG_FILENAME);
1771  fname_is_malloced = false;
1772  }
1773  else
1774  {
1775  write_stderr("%s does not know where to find the server configuration file.\n"
1776  "You must specify the --config-file or -D invocation "
1777  "option or set the PGDATA environment variable.\n",
1778  progname);
1779  return false;
1780  }
1781 
1782  /*
1783  * Set the ConfigFileName GUC variable to its final value, ensuring that
1784  * it can't be overridden later.
1785  */
1786  SetConfigOption("config_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1787 
1788  if (fname_is_malloced)
1789  free(fname);
1790  else
1791  guc_free(fname);
1792 
1793  /*
1794  * Now read the config file for the first time.
1795  */
1796  if (stat(ConfigFileName, &stat_buf) != 0)
1797  {
1798  write_stderr("%s: could not access the server configuration file \"%s\": %s\n",
1799  progname, ConfigFileName, strerror(errno));
1800  free(configdir);
1801  return false;
1802  }
1803 
1804  /*
1805  * Read the configuration file for the first time. This time only the
1806  * data_directory parameter is picked up to determine the data directory,
1807  * so that we can read the PG_AUTOCONF_FILENAME file next time.
1808  */
1810 
1811  /*
1812  * If the data_directory GUC variable has been set, use that as DataDir;
1813  * otherwise use configdir if set; else punt.
1814  *
1815  * Note: SetDataDir will copy and absolute-ize its argument, so we don't
1816  * have to.
1817  */
1818  data_directory_rec = (struct config_string *)
1819  find_option("data_directory", false, false, PANIC);
1820  if (*data_directory_rec->variable)
1821  SetDataDir(*data_directory_rec->variable);
1822  else if (configdir)
1823  SetDataDir(configdir);
1824  else
1825  {
1826  write_stderr("%s does not know where to find the database system data.\n"
1827  "This can be specified as \"data_directory\" in \"%s\", "
1828  "or by the -D invocation option, or by the "
1829  "PGDATA environment variable.\n",
1831  return false;
1832  }
1833 
1834  /*
1835  * Reflect the final DataDir value back into the data_directory GUC var.
1836  * (If you are wondering why we don't just make them a single variable,
1837  * it's because the EXEC_BACKEND case needs DataDir to be transmitted to
1838  * child backends specially. XXX is that still true? Given that we now
1839  * chdir to DataDir, EXEC_BACKEND can read the config file without knowing
1840  * DataDir in advance.)
1841  */
1843 
1844  /*
1845  * Now read the config file a second time, allowing any settings in the
1846  * PG_AUTOCONF_FILENAME file to take effect. (This is pretty ugly, but
1847  * since we have to determine the DataDir before we can find the autoconf
1848  * file, the alternatives seem worse.)
1849  */
1851 
1852  /*
1853  * If timezone_abbreviations wasn't set in the configuration file, install
1854  * the default value. We do it this way because we can't safely install a
1855  * "real" value until my_exec_path is set, which may not have happened
1856  * when InitializeGUCOptions runs, so the bootstrap default value cannot
1857  * be the real desired default.
1858  */
1860 
1861  /*
1862  * Figure out where pg_hba.conf is, and make sure the path is absolute.
1863  */
1864  if (HbaFileName)
1865  {
1867  fname_is_malloced = true;
1868  }
1869  else if (configdir)
1870  {
1871  fname = guc_malloc(FATAL,
1872  strlen(configdir) + strlen(HBA_FILENAME) + 2);
1873  sprintf(fname, "%s/%s", configdir, HBA_FILENAME);
1874  fname_is_malloced = false;
1875  }
1876  else
1877  {
1878  write_stderr("%s does not know where to find the \"hba\" configuration file.\n"
1879  "This can be specified as \"hba_file\" in \"%s\", "
1880  "or by the -D invocation option, or by the "
1881  "PGDATA environment variable.\n",
1883  return false;
1884  }
1885  SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1886 
1887  if (fname_is_malloced)
1888  free(fname);
1889  else
1890  guc_free(fname);
1891 
1892  /*
1893  * Likewise for pg_ident.conf.
1894  */
1895  if (IdentFileName)
1896  {
1898  fname_is_malloced = true;
1899  }
1900  else if (configdir)
1901  {
1902  fname = guc_malloc(FATAL,
1903  strlen(configdir) + strlen(IDENT_FILENAME) + 2);
1904  sprintf(fname, "%s/%s", configdir, IDENT_FILENAME);
1905  fname_is_malloced = false;
1906  }
1907  else
1908  {
1909  write_stderr("%s does not know where to find the \"ident\" configuration file.\n"
1910  "This can be specified as \"ident_file\" in \"%s\", "
1911  "or by the -D invocation option, or by the "
1912  "PGDATA environment variable.\n",
1914  return false;
1915  }
1916  SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1917 
1918  if (fname_is_malloced)
1919  free(fname);
1920  else
1921  guc_free(fname);
1922 
1923  free(configdir);
1924 
1925  return true;
1926 }
#define write_stderr(str)
Definition: parallel.c:184
#define FATAL
Definition: elog.h:41
#define PANIC
Definition: elog.h:42
char * DataDir
Definition: globals.c:66
static void pg_timezone_abbrev_initialize(void)
Definition: guc.c:1939
#define IDENT_FILENAME
Definition: guc.c:56
#define HBA_FILENAME
Definition: guc.c:55
#define CONFIG_FILENAME
Definition: guc.c:54
void ProcessConfigFile(GucContext context)
char * HbaFileName
Definition: guc_tables.c:504
char * ConfigFileName
Definition: guc_tables.c:503
char * IdentFileName
Definition: guc_tables.c:505
#define free(a)
Definition: header.h:65
const char * progname
Definition: main.c:45
void SetDataDir(const char *dir)
Definition: miscinit.c:416
char * make_absolute_path(const char *path)
Definition: path.c:729
#define sprintf
Definition: port.h:240
#define strerror
Definition: port.h:251
static const char * userDoption
Definition: postgres.c:156

References CONFIG_FILENAME, ConfigFileName, DataDir, FATAL, find_option(), free, guc_free(), guc_malloc(), HBA_FILENAME, HbaFileName, IDENT_FILENAME, IdentFileName, make_absolute_path(), PANIC, pg_timezone_abbrev_initialize(), PGC_POSTMASTER, PGC_S_OVERRIDE, ProcessConfigFile(), progname, SetConfigOption(), SetDataDir(), sprintf, stat, strerror, userDoption, config_string::variable, and write_stderr.

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ SerializeGUCState()

void SerializeGUCState ( Size  maxsize,
char *  start_address 
)

Definition at line 5908 of file guc.c.

5909 {
5910  char *curptr;
5911  Size actual_size;
5912  Size bytes_left;
5913  dlist_iter iter;
5914 
5915  /* Reserve space for saving the actual size of the guc state */
5916  Assert(maxsize > sizeof(actual_size));
5917  curptr = start_address + sizeof(actual_size);
5918  bytes_left = maxsize - sizeof(actual_size);
5919 
5920  /* We need only consider GUCs with source not PGC_S_DEFAULT */
5922  {
5923  struct config_generic *gconf = dlist_container(struct config_generic,
5924  nondef_link, iter.cur);
5925 
5926  serialize_variable(&curptr, &bytes_left, gconf);
5927  }
5928 
5929  /* Store actual size without assuming alignment of start_address. */
5930  actual_size = maxsize - bytes_left - sizeof(actual_size);
5931  memcpy(start_address, &actual_size, sizeof(actual_size));
5932 }
static void serialize_variable(char **destptr, Size *maxbytes, struct config_generic *gconf)
Definition: guc.c:5831

References Assert(), dlist_iter::cur, dlist_container, dlist_foreach, guc_nondef_list, config_generic::nondef_link, and serialize_variable().

Referenced by InitializeParallelDSM().

◆ set_config_option()

int set_config_option ( const char *  name,
const char *  value,
GucContext  context,
GucSource  source,
GucAction  action,
bool  changeVal,
int  elevel,
bool  is_reload 
)

Definition at line 3265 of file guc.c.

3269 {
3270  Oid srole;
3271 
3272  /*
3273  * Non-interactive sources should be treated as having all privileges,
3274  * except for PGC_S_CLIENT. Note in particular that this is true for
3275  * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3276  * privilege check was done when the pg_db_role_setting entry was made.
3277  */
3279  srole = GetUserId();
3280  else
3281  srole = BOOTSTRAP_SUPERUSERID;
3282 
3284  context, source, srole,
3285  action, changeVal, elevel,
3286  is_reload);
3287 }

References generate_unaccent_rules::action, GetUserId(), name, PGC_S_CLIENT, PGC_S_INTERACTIVE, set_config_option_ext(), source, and value.

Referenced by applyRemoteGucs(), DefineIndex(), ExecSetVariableStmt(), execute_extension_script(), parse_subscription_options(), ProcessConfigFileInternal(), ProcessGUCArray(), RI_Initial_Check(), RI_PartitionRemove_Check(), set_config_by_name(), set_transmission_modes(), SetConfigOption(), SetPGVariable(), and validate_option_array_item().

◆ set_config_option_ext()

int set_config_option_ext ( const char *  name,
const char *  value,
GucContext  context,
GucSource  source,
Oid  srole,
GucAction  action,
bool  changeVal,
int  elevel,
bool  is_reload 
)

Definition at line 3305 of file guc.c.

3309 {
3310  struct config_generic *record;
3311  union config_var_val newval_union;
3312  void *newextra = NULL;
3313  bool prohibitValueChange = false;
3314  bool makeDefault;
3315 
3316  if (elevel == 0)
3317  {
3318  if (source == PGC_S_DEFAULT || source == PGC_S_FILE)
3319  {
3320  /*
3321  * To avoid cluttering the log, only the postmaster bleats loudly
3322  * about problems with the config file.
3323  */
3324  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
3325  }
3326  else if (source == PGC_S_GLOBAL ||
3327  source == PGC_S_DATABASE ||
3328  source == PGC_S_USER ||
3330  elevel = WARNING;
3331  else
3332  elevel = ERROR;
3333  }
3334 
3335  /*
3336  * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
3337  * because the current worker will also pop the change. We're probably
3338  * dealing with a function having a proconfig entry. Only the function's
3339  * body should observe the change, and peer workers do not share in the
3340  * execution of a function call started by this worker.
3341  *
3342  * Other changes might need to affect other workers, so forbid them.
3343  */
3344  if (IsInParallelMode() && changeVal && action != GUC_ACTION_SAVE)
3345  ereport(elevel,
3346  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3347  errmsg("cannot set parameters during a parallel operation")));
3348 
3349  record = find_option(name, true, false, elevel);
3350  if (record == NULL)
3351  return 0;
3352 
3353  /*
3354  * Check if the option can be set at this time. See guc.h for the precise
3355  * rules.
3356  */
3357  switch (record->context)
3358  {
3359  case PGC_INTERNAL:
3360  if (context != PGC_INTERNAL)
3361  {
3362  ereport(elevel,
3363  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3364  errmsg("parameter \"%s\" cannot be changed",
3365  name)));
3366  return 0;
3367  }
3368  break;
3369  case PGC_POSTMASTER:
3370  if (context == PGC_SIGHUP)
3371  {
3372  /*
3373  * We are re-reading a PGC_POSTMASTER variable from
3374  * postgresql.conf. We can't change the setting, so we should
3375  * give a warning if the DBA tries to change it. However,
3376  * because of variant formats, canonicalization by check
3377  * hooks, etc, we can't just compare the given string directly
3378  * to what's stored. Set a flag to check below after we have
3379  * the final storable value.
3380  */
3381  prohibitValueChange = true;
3382  }
3383  else if (context != PGC_POSTMASTER)
3384  {
3385  ereport(elevel,
3386  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3387  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3388  name)));
3389  return 0;
3390  }
3391  break;
3392  case PGC_SIGHUP:
3393  if (context != PGC_SIGHUP && context != PGC_POSTMASTER)
3394  {
3395  ereport(elevel,
3396  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3397  errmsg("parameter \"%s\" cannot be changed now",
3398  name)));
3399  return 0;
3400  }
3401 
3402  /*
3403  * Hmm, the idea of the SIGHUP context is "ought to be global, but
3404  * can be changed after postmaster start". But there's nothing
3405  * that prevents a crafty administrator from sending SIGHUP
3406  * signals to individual backends only.
3407  */
3408  break;
3409  case PGC_SU_BACKEND:
3410  if (context == PGC_BACKEND)
3411  {
3412  /*
3413  * Check whether the requesting user has been granted
3414  * privilege to set this GUC.
3415  */
3416  AclResult aclresult;
3417 
3418  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3419  if (aclresult != ACLCHECK_OK)
3420  {
3421  /* No granted privilege */
3422  ereport(elevel,
3423  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3424  errmsg("permission denied to set parameter \"%s\"",
3425  name)));
3426  return 0;
3427  }
3428  }
3429  /* fall through to process the same as PGC_BACKEND */
3430  /* FALLTHROUGH */
3431  case PGC_BACKEND:
3432  if (context == PGC_SIGHUP)
3433  {
3434  /*
3435  * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
3436  * the config file, we want to accept the new value in the
3437  * postmaster (whence it will propagate to
3438  * subsequently-started backends), but ignore it in existing
3439  * backends. This is a tad klugy, but necessary because we
3440  * don't re-read the config file during backend start.
3441  *
3442  * In EXEC_BACKEND builds, this works differently: we load all
3443  * non-default settings from the CONFIG_EXEC_PARAMS file
3444  * during backend start. In that case we must accept
3445  * PGC_SIGHUP settings, so as to have the same value as if
3446  * we'd forked from the postmaster. This can also happen when
3447  * using RestoreGUCState() within a background worker that
3448  * needs to have the same settings as the user backend that
3449  * started it. is_reload will be true when either situation
3450  * applies.
3451  */
3452  if (IsUnderPostmaster && !is_reload)
3453  return -1;
3454  }
3455  else if (context != PGC_POSTMASTER &&
3456  context != PGC_BACKEND &&
3457  context != PGC_SU_BACKEND &&
3458  source != PGC_S_CLIENT)
3459  {
3460  ereport(elevel,
3461  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3462  errmsg("parameter \"%s\" cannot be set after connection start",
3463  name)));
3464  return 0;
3465  }
3466  break;
3467  case PGC_SUSET:
3468  if (context == PGC_USERSET || context == PGC_BACKEND)
3469  {
3470  /*
3471  * Check whether the requesting user has been granted
3472  * privilege to set this GUC.
3473  */
3474  AclResult aclresult;
3475 
3476  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3477  if (aclresult != ACLCHECK_OK)
3478  {
3479  /* No granted privilege */
3480  ereport(elevel,
3481  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3482  errmsg("permission denied to set parameter \"%s\"",
3483  name)));
3484  return 0;
3485  }
3486  }
3487  break;
3488  case PGC_USERSET:
3489  /* always okay */
3490  break;
3491  }
3492 
3493  /*
3494  * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
3495  * security restriction context. We can reject this regardless of the GUC
3496  * context or source, mainly because sources that it might be reasonable
3497  * to override for won't be seen while inside a function.
3498  *
3499  * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
3500  * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
3501  * An exception might be made if the reset value is assumed to be "safe".
3502  *
3503  * Note: this flag is currently used for "session_authorization" and
3504  * "role". We need to prohibit changing these inside a local userid
3505  * context because when we exit it, GUC won't be notified, leaving things
3506  * out of sync. (This could be fixed by forcing a new GUC nesting level,
3507  * but that would change behavior in possibly-undesirable ways.) Also, we
3508  * prohibit changing these in a security-restricted operation because
3509  * otherwise RESET could be used to regain the session user's privileges.
3510  */
3511  if (record->flags & GUC_NOT_WHILE_SEC_REST)
3512  {
3513  if (InLocalUserIdChange())
3514  {
3515  /*
3516  * Phrasing of this error message is historical, but it's the most
3517  * common case.
3518  */
3519  ereport(elevel,
3520  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3521  errmsg("cannot set parameter \"%s\" within security-definer function",
3522  name)));
3523  return 0;
3524  }
3526  {
3527  ereport(elevel,
3528  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3529  errmsg("cannot set parameter \"%s\" within security-restricted operation",
3530  name)));
3531  return 0;
3532  }
3533  }
3534 
3535  /* Disallow resetting and saving GUC_NO_RESET values */
3536  if (record->flags & GUC_NO_RESET)
3537  {
3538  if (value == NULL)
3539  {
3540  ereport(elevel,
3541  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3542  errmsg("parameter \"%s\" cannot be reset", name)));
3543  return 0;
3544  }
3545  if (action == GUC_ACTION_SAVE)
3546  {
3547  ereport(elevel,
3548  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3549  errmsg("parameter \"%s\" cannot be set locally in functions",
3550  name)));
3551  return 0;
3552  }
3553  }
3554 
3555  /*
3556  * Should we set reset/stacked values? (If so, the behavior is not
3557  * transactional.) This is done either when we get a default value from
3558  * the database's/user's/client's default settings or when we reset a
3559  * value to its default.
3560  */
3561  makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
3562  ((value != NULL) || source == PGC_S_DEFAULT);
3563 
3564  /*
3565  * Ignore attempted set if overridden by previously processed setting.
3566  * However, if changeVal is false then plow ahead anyway since we are
3567  * trying to find out if the value is potentially good, not actually use
3568  * it. Also keep going if makeDefault is true, since we may want to set
3569  * the reset/stacked values even if we can't set the variable itself.
3570  */
3571  if (record->source > source)
3572  {
3573  if (changeVal && !makeDefault)
3574  {
3575  elog(DEBUG3, "\"%s\": setting ignored because previous source is higher priority",
3576  name);
3577  return -1;
3578  }
3579  changeVal = false;
3580  }
3581 
3582  /*
3583  * Evaluate value and set variable.
3584  */
3585  switch (record->vartype)
3586  {
3587  case PGC_BOOL:
3588  {
3589  struct config_bool *conf = (struct config_bool *) record;
3590 
3591 #define newval (newval_union.boolval)
3592 
3593  if (value)
3594  {
3595  if (!parse_and_validate_value(record, name, value,
3596  source, elevel,
3597  &newval_union, &newextra))
3598  return 0;
3599  }
3600  else if (source == PGC_S_DEFAULT)
3601  {
3602  newval = conf->boot_val;
3603  if (!call_bool_check_hook(conf, &newval, &newextra,
3604  source, elevel))
3605  return 0;
3606  }
3607  else
3608  {
3609  newval = conf->reset_val;
3610  newextra = conf->reset_extra;
3611  source = conf->gen.reset_source;
3612  context = conf->gen.reset_scontext;
3613  srole = conf->gen.reset_srole;
3614  }
3615 
3616  if (prohibitValueChange)
3617  {
3618  /* Release newextra, unless it's reset_extra */
3619  if (newextra && !extra_field_used(&conf->gen, newextra))
3620  guc_free(newextra);
3621 
3622  if (*conf->variable != newval)
3623  {
3624  record->status |= GUC_PENDING_RESTART;
3625  ereport(elevel,
3626  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3627  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3628  name)));
3629  return 0;
3630  }
3631  record->status &= ~GUC_PENDING_RESTART;
3632  return -1;
3633  }
3634 
3635  if (changeVal)
3636  {
3637  /* Save old value to support transaction abort */
3638  if (!makeDefault)
3639  push_old_value(&conf->gen, action);
3640 
3641  if (conf->assign_hook)
3642  conf->assign_hook(newval, newextra);
3643  *conf->variable = newval;
3644  set_extra_field(&conf->gen, &conf->gen.extra,
3645  newextra);
3646  set_guc_source(&conf->gen, source);
3647  conf->gen.scontext = context;
3648  conf->gen.srole = srole;
3649  }
3650  if (makeDefault)
3651  {
3652  GucStack *stack;
3653 
3654  if (conf->gen.reset_source <= source)
3655  {
3656  conf->reset_val = newval;
3657  set_extra_field(&conf->gen, &conf->reset_extra,
3658  newextra);
3659  conf->gen.reset_source = source;
3660  conf->gen.reset_scontext = context;
3661  conf->gen.reset_srole = srole;
3662  }
3663  for (stack = conf->gen.stack; stack; stack = stack->prev)
3664  {
3665  if (stack->source <= source)
3666  {
3667  stack->prior.val.boolval = newval;
3668  set_extra_field(&conf->gen, &stack->prior.extra,
3669  newextra);
3670  stack->source = source;
3671  stack->scontext = context;
3672  stack->srole = srole;
3673  }
3674  }
3675  }
3676 
3677  /* Perhaps we didn't install newextra anywhere */
3678  if (newextra && !extra_field_used(&conf->gen, newextra))
3679  guc_free(newextra);
3680  break;
3681 
3682 #undef newval
3683  }
3684 
3685  case PGC_INT:
3686  {
3687  struct config_int *conf = (struct config_int *) record;
3688 
3689 #define newval (newval_union.intval)
3690 
3691  if (value)
3692  {
3693  if (!parse_and_validate_value(record, name, value,
3694  source, elevel,
3695  &newval_union, &newextra))
3696  return 0;
3697  }
3698  else if (source == PGC_S_DEFAULT)
3699  {
3700  newval = conf->boot_val;
3701  if (!call_int_check_hook(conf, &newval, &newextra,
3702  source, elevel))
3703  return 0;
3704  }
3705  else
3706  {
3707  newval = conf->reset_val;
3708  newextra = conf->reset_extra;
3709  source = conf->gen.reset_source;
3710  context = conf->gen.reset_scontext;
3711  srole = conf->gen.reset_srole;
3712  }
3713 
3714  if (prohibitValueChange)
3715  {
3716  /* Release newextra, unless it's reset_extra */
3717  if (newextra && !extra_field_used(&conf->gen, newextra))
3718  guc_free(newextra);
3719 
3720  if (*conf->variable != newval)
3721  {
3722  record->status |= GUC_PENDING_RESTART;
3723  ereport(elevel,
3724  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3725  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3726  name)));
3727  return 0;
3728  }
3729  record->status &= ~GUC_PENDING_RESTART;
3730  return -1;
3731  }
3732 
3733  if (changeVal)
3734  {
3735  /* Save old value to support transaction abort */
3736  if (!makeDefault)
3737  push_old_value(&conf->gen, action);
3738 
3739  if (conf->assign_hook)
3740  conf->assign_hook(newval, newextra);
3741  *conf->variable = newval;
3742  set_extra_field(&conf->gen, &conf->gen.extra,
3743  newextra);
3744  set_guc_source(&conf->gen, source);
3745  conf->gen.scontext = context;
3746  conf->gen.srole = srole;
3747  }
3748  if (makeDefault)
3749  {
3750  GucStack *stack;
3751 
3752  if (conf->gen.reset_source <= source)
3753  {
3754  conf->reset_val = newval;
3755  set_extra_field(&conf->gen, &conf->reset_extra,
3756  newextra);
3757  conf->gen.reset_source = source;
3758  conf->gen.reset_scontext = context;
3759  conf->gen.reset_srole = srole;
3760  }
3761  for (stack = conf->gen.stack; stack; stack = stack->prev)
3762  {
3763  if (stack->source <= source)
3764  {
3765  stack->prior.val.intval = newval;
3766  set_extra_field(&conf->gen, &stack->prior.extra,
3767  newextra);
3768  stack->source = source;
3769  stack->scontext = context;
3770  stack->srole = srole;
3771  }
3772  }
3773  }
3774 
3775  /* Perhaps we didn't install newextra anywhere */
3776  if (newextra && !extra_field_used(&conf->gen, newextra))
3777  guc_free(newextra);
3778  break;
3779 
3780 #undef newval
3781  }
3782 
3783  case PGC_REAL:
3784  {
3785  struct config_real *conf = (struct config_real *) record;
3786 
3787 #define newval (newval_union.realval)
3788 
3789  if (value)
3790  {
3791  if (!parse_and_validate_value(record, name, value,
3792  source, elevel,
3793  &newval_union, &newextra))
3794  return 0;
3795  }
3796  else if (source == PGC_S_DEFAULT)
3797  {
3798  newval = conf->boot_val;
3799  if (!call_real_check_hook(conf, &newval, &newextra,
3800  source, elevel))
3801  return 0;
3802  }
3803  else
3804  {
3805  newval = conf->reset_val;
3806  newextra = conf->reset_extra;
3807  source = conf->gen.reset_source;
3808  context = conf->gen.reset_scontext;
3809  srole = conf->gen.reset_srole;
3810  }
3811 
3812  if (prohibitValueChange)
3813  {
3814  /* Release newextra, unless it's reset_extra */
3815  if (newextra && !extra_field_used(&conf->gen, newextra))
3816  guc_free(newextra);
3817 
3818  if (*conf->variable != newval)
3819  {
3820  record->status |= GUC_PENDING_RESTART;
3821  ereport(elevel,
3822  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3823  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3824  name)));
3825  return 0;
3826  }
3827  record->status &= ~GUC_PENDING_RESTART;
3828  return -1;
3829  }
3830 
3831  if (changeVal)
3832  {
3833  /* Save old value to support transaction abort */
3834  if (!makeDefault)
3835  push_old_value(&conf->gen, action);
3836 
3837  if (conf->assign_hook)
3838  conf->assign_hook(newval, newextra);
3839  *conf->variable = newval;
3840  set_extra_field(&conf->gen, &conf->gen.extra,
3841  newextra);
3842  set_guc_source(&conf->gen, source);
3843  conf->gen.scontext = context;
3844  conf->gen.srole = srole;
3845  }
3846  if (makeDefault)
3847  {
3848  GucStack *stack;
3849 
3850  if (conf->gen.reset_source <= source)
3851  {
3852  conf->reset_val = newval;
3853  set_extra_field(&conf->gen, &conf->reset_extra,
3854  newextra);
3855  conf->gen.reset_source = source;
3856  conf->gen.reset_scontext = context;
3857  conf->gen.reset_srole = srole;
3858  }
3859  for (stack = conf->gen.stack; stack; stack = stack->prev)
3860  {
3861  if (stack->source <= source)
3862  {
3863  stack->prior.val.realval = newval;
3864  set_extra_field(&conf->gen, &stack->prior.extra,
3865  newextra);
3866  stack->source = source;
3867  stack->scontext = context;
3868  stack->srole = srole;
3869  }
3870  }
3871  }
3872 
3873  /* Perhaps we didn't install newextra anywhere */
3874  if (newextra && !extra_field_used(&conf->gen, newextra))
3875  guc_free(newextra);
3876  break;
3877 
3878 #undef newval
3879  }
3880 
3881  case PGC_STRING:
3882  {
3883  struct config_string *conf = (struct config_string *) record;
3884 
3885 #define newval (newval_union.stringval)
3886 
3887  if (value)
3888  {
3889  if (!parse_and_validate_value(record, name, value,
3890  source, elevel,
3891  &newval_union, &newextra))
3892  return 0;
3893  }
3894  else if (source == PGC_S_DEFAULT)
3895  {
3896  /* non-NULL boot_val must always get strdup'd */
3897  if (conf->boot_val != NULL)
3898  {
3899  newval = guc_strdup(elevel, conf->boot_val);
3900  if (newval == NULL)
3901  return 0;
3902  }
3903  else
3904  newval = NULL;
3905 
3906  if (!call_string_check_hook(conf, &newval, &newextra,
3907  source, elevel))
3908  {
3909  guc_free(newval);
3910  return 0;
3911  }
3912  }
3913  else
3914  {
3915  /*
3916  * strdup not needed, since reset_val is already under
3917  * guc.c's control
3918  */
3919  newval = conf->reset_val;
3920  newextra = conf->reset_extra;
3921  source = conf->gen.reset_source;
3922  context = conf->gen.reset_scontext;
3923  srole = conf->gen.reset_srole;
3924  }
3925 
3926  if (prohibitValueChange)
3927  {
3928  bool newval_different;
3929 
3930  /* newval shouldn't be NULL, so we're a bit sloppy here */
3931  newval_different = (*conf->variable == NULL ||
3932  newval == NULL ||
3933  strcmp(*conf->variable, newval) != 0);
3934 
3935  /* Release newval, unless it's reset_val */
3936  if (newval && !string_field_used(conf, newval))
3937  guc_free(newval);
3938  /* Release newextra, unless it's reset_extra */
3939  if (newextra && !extra_field_used(&conf->gen, newextra))
3940  guc_free(newextra);
3941 
3942  if (newval_different)
3943  {
3944  record->status |= GUC_PENDING_RESTART;
3945  ereport(elevel,
3946  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3947  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3948  name)));
3949  return 0;
3950  }
3951  record->status &= ~GUC_PENDING_RESTART;
3952  return -1;
3953  }
3954 
3955  if (changeVal)
3956  {
3957  /* Save old value to support transaction abort */
3958  if (!makeDefault)
3959  push_old_value(&conf->gen, action);
3960 
3961  if (conf->assign_hook)
3962  conf->assign_hook(newval, newextra);
3963  set_string_field(conf, conf->variable, newval);
3964  set_extra_field(&conf->gen, &conf->gen.extra,
3965  newextra);
3966  set_guc_source(&conf->gen, source);
3967  conf->gen.scontext = context;
3968  conf->gen.srole = srole;
3969  }
3970 
3971  if (makeDefault)
3972  {
3973  GucStack *stack;
3974 
3975  if (conf->gen.reset_source <= source)
3976  {
3977  set_string_field(conf, &conf->reset_val, newval);
3978  set_extra_field(&conf->gen, &conf->reset_extra,
3979  newextra);
3980  conf->gen.reset_source = source;
3981  conf->gen.reset_scontext = context;
3982  conf->gen.reset_srole = srole;
3983  }
3984  for (stack = conf->gen.stack; stack; stack = stack->prev)
3985  {
3986  if (stack->source <= source)
3987  {
3988  set_string_field(conf, &stack->prior.val.stringval,
3989  newval);
3990  set_extra_field(&conf->gen, &stack->prior.extra,
3991  newextra);
3992  stack->source = source;
3993  stack->scontext = context;
3994  stack->srole = srole;
3995  }
3996  }
3997  }
3998 
3999  /* Perhaps we didn't install newval anywhere */
4000  if (newval && !string_field_used(conf, newval))
4001  guc_free(newval);
4002  /* Perhaps we didn't install newextra anywhere */
4003  if (newextra && !extra_field_used(&conf->gen, newextra))
4004  guc_free(newextra);
4005  break;
4006 
4007 #undef newval
4008  }
4009 
4010  case PGC_ENUM:
4011  {
4012  struct config_enum *conf = (struct config_enum *) record;
4013 
4014 #define newval (newval_union.enumval)
4015 
4016  if (value)
4017  {
4018  if (!parse_and_validate_value(record, name, value,
4019  source, elevel,
4020  &newval_union, &newextra))
4021  return 0;
4022  }
4023  else if (source == PGC_S_DEFAULT)
4024  {
4025  newval = conf->boot_val;
4026  if (!call_enum_check_hook(conf, &newval, &newextra,
4027  source, elevel))
4028  return 0;
4029  }
4030  else
4031  {
4032  newval = conf->reset_val;
4033  newextra = conf->reset_extra;
4034  source = conf->gen.reset_source;
4035  context = conf->gen.reset_scontext;
4036  srole = conf->gen.reset_srole;
4037  }
4038 
4039  if (prohibitValueChange)
4040  {
4041  /* Release newextra, unless it's reset_extra */
4042  if (newextra && !extra_field_used(&conf->gen, newextra))
4043  guc_free(newextra);
4044 
4045  if (*conf->variable != newval)
4046  {
4047  record->status |= GUC_PENDING_RESTART;
4048  ereport(elevel,
4049  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4050  errmsg("parameter \"%s\" cannot be changed without restarting the server",
4051  name)));
4052  return 0;
4053  }
4054  record->status &= ~GUC_PENDING_RESTART;
4055  return -1;
4056  }
4057 
4058  if (changeVal)
4059  {
4060  /* Save old value to support transaction abort */
4061  if (!makeDefault)
4062  push_old_value(&conf->gen, action);
4063 
4064  if (conf->assign_hook)
4065  conf->assign_hook(newval, newextra);
4066  *conf->variable = newval;
4067  set_extra_field(&conf->gen, &conf->gen.extra,
4068  newextra);
4069  set_guc_source(&conf->gen, source);
4070  conf->gen.scontext = context;
4071  conf->gen.srole = srole;
4072  }
4073  if (makeDefault)
4074  {
4075  GucStack *stack;
4076 
4077  if (conf->gen.reset_source <= source)
4078  {
4079  conf->reset_val = newval;
4080  set_extra_field(&conf->gen, &conf->reset_extra,
4081  newextra);
4082  conf->gen.reset_source = source;
4083  conf->gen.reset_scontext = context;
4084  conf->gen.reset_srole = srole;
4085  }
4086  for (stack = conf->gen.stack; stack; stack = stack->prev)
4087  {
4088  if (stack->source <= source)
4089  {
4090  stack->prior.val.enumval = newval;
4091  set_extra_field(&conf->gen, &stack->prior.extra,
4092  newextra);
4093  stack->source = source;
4094  stack->scontext = context;
4095  stack->srole = srole;
4096  }
4097  }
4098  }
4099 
4100  /* Perhaps we didn't install newextra anywhere */
4101  if (newextra && !extra_field_used(&conf->gen, newextra))
4102  guc_free(newextra);
4103  break;
4104 
4105 #undef newval
4106  }
4107  }
4108 
4109  if (changeVal && (record->flags & GUC_REPORT) &&
4110  !(record->status & GUC_NEEDS_REPORT))
4111  {
4112  record->status |= GUC_NEEDS_REPORT;
4114  }
4115 
4116  return changeVal ? 1 : -1;
4117 }
#define DEBUG3
Definition: elog.h:28
bool IsUnderPostmaster
Definition: globals.c:113
static bool call_string_check_hook(struct config_string *conf, char **newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6800
static bool extra_field_used(struct config_generic *gconf, void *extra)
Definition: guc.c:739
static void static bool call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6698
static bool call_int_check_hook(struct config_int *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6732
char * guc_strdup(int elevel, const char *src)
Definition: guc.c:669
static bool string_field_used(struct config_string *conf, char *strval)
Definition: guc.c:700
static bool call_real_check_hook(struct config_real *conf, double *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6766
static bool call_enum_check_hook(struct config_enum *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6850
#define GUC_NO_RESET
Definition: guc.h:211
#define GUC_NOT_WHILE_SEC_REST
Definition: guc.h:220
#define GUC_PENDING_RESTART
Definition: guc_tables.h:191
bool InSecurityRestrictedOperation(void)
Definition: miscinit.c:645
bool InLocalUserIdChange(void)
Definition: miscinit.c:636
bool boot_val
Definition: guc_tables.h:202
int boot_val
Definition: guc_tables.h:216
double boot_val
Definition: guc_tables.h:232
const char * boot_val
Definition: guc_tables.h:248

References ACL_SET, ACLCHECK_OK, generate_unaccent_rules::action, config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_var_val::boolval, config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), config_generic::context, DEBUG3, elog(), config_var_val::enumval, ereport, errcode(), errmsg(), ERROR, config_var_value::extra, config_generic::extra, extra_field_used(), find_option(), config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_ACTION_SAVE, guc_free(), GUC_NEEDS_REPORT, GUC_NO_RESET, GUC_NOT_WHILE_SEC_REST, GUC_PENDING_RESTART, GUC_REPORT, guc_report_list, guc_strdup(), InLocalUserIdChange(), InSecurityRestrictedOperation(), config_var_val::intval, IsInParallelMode(), IsUnderPostmaster, LOG, name, newval, parse_and_validate_value(), pg_parameter_aclcheck(), PGC_BACKEND, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_INTERNAL, PGC_POSTMASTER, PGC_REAL, PGC_S_CLIENT, PGC_S_DATABASE, PGC_S_DATABASE_USER, PGC_S_DEFAULT, PGC_S_FILE, PGC_S_GLOBAL, PGC_S_OVERRIDE, PGC_S_USER, PGC_SIGHUP, PGC_STRING, PGC_SU_BACKEND, PGC_SUSET, PGC_USERSET, guc_stack::prev, guc_stack::prior, push_old_value(), config_var_val::realval, config_generic::report_link, config_bool::reset_extra, config_int::reset_extra, config_real::reset_extra, config_string::reset_extra, config_enum::reset_extra, config_generic::reset_scontext, config_generic::reset_source, config_generic::reset_srole, config_bool::reset_val, config_int::reset_val, config_real::reset_val, config_string::reset_val, config_enum::reset_val, guc_stack::scontext, config_generic::scontext, set_extra_field(), set_guc_source(), set_string_field(), slist_push_head(), source, guc_stack::source, config_generic::source, guc_stack::srole, config_generic::srole, config_generic::stack, config_generic::status, string_field_used(), config_var_val::stringval, config_var_value::val, value, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, config_generic::vartype, and WARNING.

Referenced by define_custom_variable(), execute_extension_script(), InitializeWalConsistencyChecking(), ProcessGUCArray(), reapply_stacked_values(), RestoreGUCState(), and set_config_option().

◆ SetConfigOption()

◆ SetPGVariable()

void SetPGVariable ( const char *  name,
List args,
bool  is_local 
)

Definition at line 325 of file guc_funcs.c.

326 {
327  char *argstring = flatten_set_variable_args(name, args);
328 
329  /* Note SET DEFAULT (argstring == NULL) is equivalent to RESET */
330  (void) set_config_option(name,
331  argstring,
334  is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET,
335  true, 0, false);
336 }

References generate_unaccent_rules::args, flatten_set_variable_args(), GUC_ACTION_LOCAL, GUC_ACTION_SET, name, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, set_config_option(), and superuser().

Referenced by DiscardAll(), ExecSetVariableStmt(), and standard_ProcessUtility().

Variable Documentation

◆ application_name

◆ backtrace_functions

PGDLLIMPORT char* backtrace_functions
extern

Definition at line 496 of file guc_tables.c.

Referenced by errfinish().

◆ check_function_bodies

◆ client_min_messages

PGDLLIMPORT int client_min_messages
extern

Definition at line 487 of file guc_tables.c.

Referenced by execute_extension_script(), and should_output_to_client().

◆ cluster_name

PGDLLIMPORT char* cluster_name
extern

Definition at line 502 of file guc_tables.c.

Referenced by init_ps_display(), process_pgfdw_appname(), and WalReceiverMain().

◆ ConfigFileName

PGDLLIMPORT char* ConfigFileName
extern

Definition at line 503 of file guc_tables.c.

Referenced by ProcessConfigFileInternal(), and SelectConfigFiles().

◆ Debug_pretty_print

PGDLLIMPORT bool Debug_pretty_print
extern

Definition at line 465 of file guc_tables.c.

Referenced by pg_plan_query(), and pg_rewrite_query().

◆ Debug_print_parse

PGDLLIMPORT bool Debug_print_parse
extern

Definition at line 463 of file guc_tables.c.

Referenced by pg_rewrite_query().

◆ Debug_print_plan

PGDLLIMPORT bool Debug_print_plan
extern

Definition at line 462 of file guc_tables.c.

Referenced by pg_plan_query().

◆ Debug_print_rewritten

PGDLLIMPORT bool Debug_print_rewritten
extern

Definition at line 464 of file guc_tables.c.

Referenced by pg_rewrite_query().

◆ external_pid_file

PGDLLIMPORT char* external_pid_file
extern

Definition at line 506 of file guc_tables.c.

Referenced by PostmasterMain(), and unlink_external_pid_file().

◆ GUC_check_errdetail_string

PGDLLIMPORT char* GUC_check_errdetail_string
extern

◆ GUC_check_errhint_string

PGDLLIMPORT char* GUC_check_errhint_string
extern

◆ GUC_check_errmsg_string

PGDLLIMPORT char* GUC_check_errmsg_string
extern

◆ HbaFileName

PGDLLIMPORT char* HbaFileName
extern

◆ IdentFileName

PGDLLIMPORT char* IdentFileName
extern

Definition at line 505 of file guc_tables.c.

Referenced by fill_ident_view(), load_ident(), SelectConfigFiles(), and SIGHUP_handler().

◆ log_btree_build_stats

PGDLLIMPORT bool log_btree_build_stats
extern

◆ log_duration

PGDLLIMPORT bool log_duration
extern

Definition at line 461 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_executor_stats

PGDLLIMPORT bool log_executor_stats
extern

Definition at line 469 of file guc_tables.c.

Referenced by check_log_stats(), PortalRun(), and PortalRunMulti().

◆ log_min_duration_sample

PGDLLIMPORT int log_min_duration_sample
extern

Definition at line 488 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_min_duration_statement

PGDLLIMPORT int log_min_duration_statement
extern

Definition at line 489 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_min_error_statement

PGDLLIMPORT int log_min_error_statement
extern

Definition at line 485 of file guc_tables.c.

Referenced by check_log_of_query().

◆ log_min_messages

PGDLLIMPORT int log_min_messages
extern

Definition at line 486 of file guc_tables.c.

Referenced by execute_extension_script(), and should_output_to_server().

◆ log_parameter_max_length

PGDLLIMPORT int log_parameter_max_length
extern

Definition at line 490 of file guc_tables.c.

Referenced by errdetail_params().

◆ log_parameter_max_length_on_error

PGDLLIMPORT int log_parameter_max_length_on_error
extern

Definition at line 491 of file guc_tables.c.

Referenced by bind_param_error_callback(), and exec_bind_message().

◆ log_parser_stats

◆ log_planner_stats

PGDLLIMPORT bool log_planner_stats
extern

Definition at line 468 of file guc_tables.c.

Referenced by check_log_stats(), and pg_plan_query().

◆ log_statement_sample_rate

PGDLLIMPORT double log_statement_sample_rate
extern

Definition at line 493 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_statement_stats

◆ log_temp_files

PGDLLIMPORT int log_temp_files
extern

Definition at line 492 of file guc_tables.c.

Referenced by ReportTemporaryFileUsage().

◆ log_xact_sample_rate

PGDLLIMPORT double log_xact_sample_rate
extern

Definition at line 494 of file guc_tables.c.

Referenced by StartTransaction().

◆ num_temp_buffers

PGDLLIMPORT int num_temp_buffers
extern

Definition at line 500 of file guc_tables.c.

Referenced by InitLocalBuffers().

◆ session_auth_is_superuser

PGDLLIMPORT bool session_auth_is_superuser
extern

Definition at line 483 of file guc_tables.c.

Referenced by InitializeParallelDSM().

◆ tcp_keepalives_count

PGDLLIMPORT int tcp_keepalives_count
extern

Definition at line 514 of file guc_tables.c.

Referenced by StreamConnection().

◆ tcp_keepalives_idle

PGDLLIMPORT int tcp_keepalives_idle
extern

Definition at line 512 of file guc_tables.c.

Referenced by StreamConnection().

◆ tcp_keepalives_interval

PGDLLIMPORT int tcp_keepalives_interval
extern

Definition at line 513 of file guc_tables.c.

Referenced by StreamConnection().

◆ tcp_user_timeout

PGDLLIMPORT int tcp_user_timeout
extern

Definition at line 515 of file guc_tables.c.

Referenced by StreamConnection().

◆ temp_file_limit

PGDLLIMPORT int temp_file_limit
extern

Definition at line 498 of file guc_tables.c.

Referenced by FileWrite().