Thanks to visit codestin.com
Credit goes to doxygen.postgresql.org

PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
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_ALLOW_IN_PARALLEL   0x008000 /* allow setting in parallel mode */
 
#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 struct config_generic config_handle
 
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)
 
void 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 RestrictSearchPath (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)
 
int set_config_with_handle (const char *name, config_handle *handle, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
 
config_handle * get_config_handle (const char *name)
 
void AlterSystemSetConfigFile (AlterSystemStmt *altersysstmt)
 
char * GetConfigOptionByName (const char *name, const char **varname, bool missing_ok)
 
void TransformGUCArray (ArrayType *array, List **names, List **values)
 
void ProcessGUCArray (ArrayType *array, GucContext context, GucSource source, GucAction action)
 
ArrayType * GUCArrayAdd (ArrayType *array, const char *name, const char *value)
 
ArrayType * GUCArrayDelete (ArrayType *array, const char *name)
 
ArrayType * GUCArrayReset (ArrayType *array)
 
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_raw_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 char * event_source
 
PGDLLIMPORT bool check_function_bodies
 
PGDLLIMPORT bool current_role_is_superuser
 
PGDLLIMPORT bool AllowAlterSystem
 
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 * role_string
 
PGDLLIMPORT bool in_hot_standby_guc
 
PGDLLIMPORT bool trace_sort
 
PGDLLIMPORT const struct config_enum_entry archive_mode_options []
 
PGDLLIMPORT const struct config_enum_entry dynamic_shared_memory_options []
 
PGDLLIMPORT const struct config_enum_entry io_method_options []
 
PGDLLIMPORT const struct config_enum_entry recovery_target_action_options []
 
PGDLLIMPORT const struct config_enum_entry wal_level_options []
 
PGDLLIMPORT const struct config_enum_entry wal_sync_method_options []
 
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 419 of file guc.h.

◆ GUC_ALLOW_IN_PARALLEL

#define GUC_ALLOW_IN_PARALLEL   0x008000 /* allow setting in parallel mode */

Definition at line 230 of file guc.h.

◆ GUC_check_errdetail

#define GUC_check_errdetail
Value:
pre_format_elog_string(errno, TEXTDOMAIN), \
GUC_check_errdetail_string = format_elog_string
format_elog_string
char * format_elog_string(const char *fmt,...)
Definition: elog.c:1662
pre_format_elog_string
void pre_format_elog_string(int errnumber, const char *domain)
Definition: elog.c:1653
TEXTDOMAIN
#define TEXTDOMAIN
Definition: elog.h:153

Definition at line 505 of file guc.h.

◆ GUC_check_errhint

#define GUC_check_errhint
Value:
pre_format_elog_string(errno, TEXTDOMAIN), \
GUC_check_errhint_string = format_elog_string

Definition at line 509 of file guc.h.

◆ GUC_check_errmsg

#define GUC_check_errmsg
Value:
pre_format_elog_string(errno, TEXTDOMAIN), \
GUC_check_errmsg_string = format_elog_string

Definition at line 501 of file guc.h.

◆ GUC_CUSTOM_PLACEHOLDER

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

Definition at line 223 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 227 of file guc.h.

◆ GUC_DISALLOW_IN_FILE

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

Definition at line 222 of file guc.h.

◆ GUC_EXPLAIN

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

Definition at line 219 of file guc.h.

◆ GUC_IS_NAME

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

Definition at line 225 of file guc.h.

◆ GUC_LIST_INPUT

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

Definition at line 214 of file guc.h.

◆ GUC_LIST_QUOTE

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

Definition at line 215 of file guc.h.

◆ GUC_NO_RESET

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

Definition at line 217 of file guc.h.

◆ GUC_NO_RESET_ALL

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

Definition at line 218 of file guc.h.

◆ GUC_NO_SHOW_ALL

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

Definition at line 216 of file guc.h.

◆ GUC_NOT_IN_SAMPLE

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

Definition at line 221 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 226 of file guc.h.

◆ GUC_QUALIFIER_SEPARATOR

#define GUC_QUALIFIER_SEPARATOR   '.'

Definition at line 208 of file guc.h.

◆ GUC_REPORT

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

Definition at line 220 of file guc.h.

◆ GUC_RUNTIME_COMPUTED

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

Definition at line 229 of file guc.h.

◆ GUC_SUPERUSER_ONLY

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

Definition at line 224 of file guc.h.

◆ GUC_UNIT

#define GUC_UNIT   (GUC_UNIT_MEMORY | GUC_UNIT_TIME)

Definition at line 244 of file guc.h.

◆ GUC_UNIT_BLOCKS

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

Definition at line 233 of file guc.h.

◆ GUC_UNIT_BYTE

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

Definition at line 236 of file guc.h.

◆ GUC_UNIT_KB

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

Definition at line 232 of file guc.h.

◆ GUC_UNIT_MB

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

Definition at line 235 of file guc.h.

◆ GUC_UNIT_MEMORY

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

Definition at line 237 of file guc.h.

◆ GUC_UNIT_MIN

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

Definition at line 241 of file guc.h.

◆ GUC_UNIT_MS

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

Definition at line 239 of file guc.h.

◆ GUC_UNIT_S

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

Definition at line 240 of file guc.h.

◆ GUC_UNIT_TIME

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

Definition at line 242 of file guc.h.

◆ GUC_UNIT_XBLOCKS

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

Definition at line 234 of file guc.h.

◆ MAX_KILOBYTES

#define MAX_KILOBYTES   (INT_MAX / 1024)

Definition at line 29 of file guc.h.

◆ PG_AUTOCONF_FILENAME

#define PG_AUTOCONF_FILENAME   "postgresql.auto.conf"

Definition at line 37 of file guc.h.

Typedef Documentation

◆ config_handle

typedef struct config_generic config_handle

Definition at line 151 of file guc.h.

◆ ConfigVariable

typedef struct ConfigVariable ConfigVariable

◆ GucBoolAssignHook

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

Definition at line 189 of file guc.h.

◆ GucBoolCheckHook

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

Definition at line 183 of file guc.h.

◆ GucEnumAssignHook

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

Definition at line 193 of file guc.h.

◆ GucEnumCheckHook

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

Definition at line 187 of file guc.h.

◆ GucIntAssignHook

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

Definition at line 190 of file guc.h.

◆ GucIntCheckHook

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

Definition at line 184 of file guc.h.

◆ GucRealAssignHook

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

Definition at line 191 of file guc.h.

◆ GucRealCheckHook

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

Definition at line 185 of file guc.h.

◆ GucShowHook

typedef const char *(* GucShowHook) (void)

Definition at line 195 of file guc.h.

◆ GucStringAssignHook

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

Definition at line 192 of file guc.h.

◆ GucStringCheckHook

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

Definition at line 186 of file guc.h.

Enumeration Type Documentation

◆ GucAction

enum GucAction
Enumerator
GUC_ACTION_SET 
GUC_ACTION_LOCAL 
GUC_ACTION_SAVE 

Definition at line 200 of file guc.h.

201{
202 /* Types of set_config_option actions */
203 GUC_ACTION_SET, /* regular SET command */
204 GUC_ACTION_LOCAL, /* SET LOCAL command */
205 GUC_ACTION_SAVE, /* function SET option, or temp assignment */
206} GucAction;
GucAction
GucAction
Definition: guc.h:201
GUC_ACTION_SAVE
@ GUC_ACTION_SAVE
Definition: guc.h:205
GUC_ACTION_SET
@ GUC_ACTION_SET
Definition: guc.h:203
GUC_ACTION_LOCAL
@ GUC_ACTION_LOCAL
Definition: guc.h:204

◆ GucContext

enum GucContext
Enumerator
PGC_INTERNAL 
PGC_POSTMASTER 
PGC_SIGHUP 
PGC_SU_BACKEND 
PGC_BACKEND 
PGC_SUSET 
PGC_USERSET 

Definition at line 71 of file guc.h.

72{
73 PGC_INTERNAL,
74 PGC_POSTMASTER,
75 PGC_SIGHUP,
76 PGC_SU_BACKEND,
77 PGC_BACKEND,
78 PGC_SUSET,
79 PGC_USERSET,
80} GucContext;
GucContext
GucContext
Definition: guc.h:72
PGC_SUSET
@ PGC_SUSET
Definition: guc.h:78
PGC_INTERNAL
@ PGC_INTERNAL
Definition: guc.h:73
PGC_USERSET
@ PGC_USERSET
Definition: guc.h:79
PGC_SU_BACKEND
@ PGC_SU_BACKEND
Definition: guc.h:76
PGC_POSTMASTER
@ PGC_POSTMASTER
Definition: guc.h:74
PGC_SIGHUP
@ PGC_SIGHUP
Definition: guc.h:75
PGC_BACKEND
@ PGC_BACKEND
Definition: guc.h:77

◆ 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 111 of file guc.h.

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

Function Documentation

◆ AlterSystemSetConfigFile()

void AlterSystemSetConfigFile ( AlterSystemStmt *  altersysstmt)

Definition at line 4612 of file guc.c.

4613{
4614 char *name;
4615 char *value;
4616 bool resetall = false;
4617 ConfigVariable *head = NULL;
4618 ConfigVariable *tail = NULL;
4619 volatile int Tmpfd;
4620 char AutoConfFileName[MAXPGPATH];
4621 char AutoConfTmpFileName[MAXPGPATH];
4622
4623 /*
4624 * Extract statement arguments
4625 */
4626 name = altersysstmt->setstmt->name;
4627
4628 if (!AllowAlterSystem)
4629 ereport(ERROR,
4630 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4631 errmsg("ALTER SYSTEM is not allowed in this environment")));
4632
4633 switch (altersysstmt->setstmt->kind)
4634 {
4635 case VAR_SET_VALUE:
4636 value = ExtractSetVariableArgs(altersysstmt->setstmt);
4637 break;
4638
4639 case VAR_SET_DEFAULT:
4640 case VAR_RESET:
4641 value = NULL;
4642 break;
4643
4644 case VAR_RESET_ALL:
4645 value = NULL;
4646 resetall = true;
4647 break;
4648
4649 default:
4650 elog(ERROR, "unrecognized alter system stmt type: %d",
4651 altersysstmt->setstmt->kind);
4652 break;
4653 }
4654
4655 /*
4656 * Check permission to run ALTER SYSTEM on the target variable
4657 */
4658 if (!superuser())
4659 {
4660 if (resetall)
4661 ereport(ERROR,
4662 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4663 errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4664 else
4665 {
4666 AclResult aclresult;
4667
4668 aclresult = pg_parameter_aclcheck(name, GetUserId(),
4669 ACL_ALTER_SYSTEM);
4670 if (aclresult != ACLCHECK_OK)
4671 ereport(ERROR,
4672 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4673 errmsg("permission denied to set parameter \"%s\"",
4674 name)));
4675 }
4676 }
4677
4678 /*
4679 * Unless it's RESET_ALL, validate the target variable and value
4680 */
4681 if (!resetall)
4682 {
4683 struct config_generic *record;
4684
4685 /* We don't want to create a placeholder if there's not one already */
4686 record = find_option(name, false, true, DEBUG5);
4687 if (record != NULL)
4688 {
4689 /*
4690 * Don't allow parameters that can't be set in configuration files
4691 * to be set in PG_AUTOCONF_FILENAME file.
4692 */
4693 if ((record->context == PGC_INTERNAL) ||
4694 (record->flags & GUC_DISALLOW_IN_FILE) ||
4695 (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
4696 ereport(ERROR,
4697 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4698 errmsg("parameter \"%s\" cannot be changed",
4699 name)));
4700
4701 /*
4702 * If a value is specified, verify that it's sane.
4703 */
4704 if (value)
4705 {
4706 union config_var_val newval;
4707 void *newextra = NULL;
4708
4709 if (!parse_and_validate_value(record, value,
4710 PGC_S_FILE, ERROR,
4711 &newval, &newextra))
4712 ereport(ERROR,
4713 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4714 errmsg("invalid value for parameter \"%s\": \"%s\"",
4715 name, value)));
4716
4717 if (record->vartype == PGC_STRING && newval.stringval != NULL)
4718 guc_free(newval.stringval);
4719 guc_free(newextra);
4720 }
4721 }
4722 else
4723 {
4724 /*
4725 * Variable not known; check we'd be allowed to create it. (We
4726 * cannot validate the value, but that's fine. A non-core GUC in
4727 * the config file cannot cause postmaster start to fail, so we
4728 * don't have to be too tense about possibly installing a bad
4729 * value.)
4730 *
4731 * As an exception, we skip this check if this is a RESET command
4732 * for an unknown custom GUC, else there'd be no way for users to
4733 * remove such settings with reserved prefixes.
4734 */
4735 if (value || !valid_custom_variable_name(name))
4736 (void) assignable_custom_variable_name(name, false, ERROR);
4737 }
4738
4739 /*
4740 * We must also reject values containing newlines, because the grammar
4741 * for config files doesn't support embedded newlines in string
4742 * literals.
4743 */
4744 if (value && strchr(value, '\n'))
4745 ereport(ERROR,
4746 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4747 errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4748 }
4749
4750 /*
4751 * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4752 * the data directory, so we can reference them by simple relative paths.
4753 */
4754 snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4755 PG_AUTOCONF_FILENAME);
4756 snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4757 AutoConfFileName,
4758 "tmp");
4759
4760 /*
4761 * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4762 * time. Use AutoFileLock to ensure that. We must hold the lock while
4763 * reading the old file contents.
4764 */
4765 LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4766
4767 /*
4768 * If we're going to reset everything, then no need to open or parse the
4769 * old file. We'll just write out an empty list.
4770 */
4771 if (!resetall)
4772 {
4773 struct stat st;
4774
4775 if (stat(AutoConfFileName, &st) == 0)
4776 {
4777 /* open old file PG_AUTOCONF_FILENAME */
4778 FILE *infile;
4779
4780 infile = AllocateFile(AutoConfFileName, "r");
4781 if (infile == NULL)
4782 ereport(ERROR,
4783 (errcode_for_file_access(),
4784 errmsg("could not open file \"%s\": %m",
4785 AutoConfFileName)));
4786
4787 /* parse it */
4788 if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4789 LOG, &head, &tail))
4790 ereport(ERROR,
4791 (errcode(ERRCODE_CONFIG_FILE_ERROR),
4792 errmsg("could not parse contents of file \"%s\"",
4793 AutoConfFileName)));
4794
4795 FreeFile(infile);
4796 }
4797
4798 /*
4799 * Now, replace any existing entry with the new value, or add it if
4800 * not present.
4801 */
4802 replace_auto_config_value(&head, &tail, name, value);
4803 }
4804
4805 /*
4806 * Invoke the post-alter hook for setting this GUC variable. GUCs
4807 * typically do not have corresponding entries in pg_parameter_acl, so we
4808 * call the hook using the name rather than a potentially-non-existent
4809 * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4810 * context can be distinguished from others. (Note that "name" will be
4811 * NULL in the RESET ALL case.)
4812 *
4813 * We do this here rather than at the end, because ALTER SYSTEM is not
4814 * transactional. If the hook aborts our transaction, it will be cleaner
4815 * to do so before we touch any files.
4816 */
4817 InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4818 ACL_ALTER_SYSTEM,
4819 altersysstmt->setstmt->kind,
4820 false);
4821
4822 /*
4823 * To ensure crash safety, first write the new file data to a temp file,
4824 * then atomically rename it into place.
4825 *
4826 * If there is a temp file left over due to a previous crash, it's okay to
4827 * truncate and reuse it.
4828 */
4829 Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4830 O_CREAT | O_RDWR | O_TRUNC);
4831 if (Tmpfd < 0)
4832 ereport(ERROR,
4833 (errcode_for_file_access(),
4834 errmsg("could not open file \"%s\": %m",
4835 AutoConfTmpFileName)));
4836
4837 /*
4838 * Use a TRY block to clean up the file if we fail. Since we need a TRY
4839 * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4840 */
4841 PG_TRY();
4842 {
4843 /* Write and sync the new contents to the temporary file */
4844 write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4845
4846 /* Close before renaming; may be required on some platforms */
4847 close(Tmpfd);
4848 Tmpfd = -1;
4849
4850 /*
4851 * As the rename is atomic operation, if any problem occurs after this
4852 * at worst it can lose the parameters set by last ALTER SYSTEM
4853 * command.
4854 */
4855 durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4856 }
4857 PG_CATCH();
4858 {
4859 /* Close file first, else unlink might fail on some platforms */
4860 if (Tmpfd >= 0)
4861 close(Tmpfd);
4862
4863 /* Unlink, but ignore any error */
4864 (void) unlink(AutoConfTmpFileName);
4865
4866 PG_RE_THROW();
4867 }
4868 PG_END_TRY();
4869
4870 FreeConfigVariables(head);
4871
4872 LWLockRelease(AutoFileLock);
4873}
AclResult
AclResult
Definition: acl.h:182
ACLCHECK_OK
@ ACLCHECK_OK
Definition: acl.h:183
pg_parameter_aclcheck
AclResult pg_parameter_aclcheck(const char *name, Oid roleid, AclMode mode)
Definition: aclchk.c:4062
CONF_FILE_START_DEPTH
#define CONF_FILE_START_DEPTH
Definition: conffiles.h:17
errcode_for_file_access
int errcode_for_file_access(void)
Definition: elog.c:877
errcode
int errcode(int sqlerrcode)
Definition: elog.c:854
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:1071
LOG
#define LOG
Definition: elog.h:31
PG_RE_THROW
#define PG_RE_THROW()
Definition: elog.h:405
PG_TRY
#define PG_TRY(...)
Definition: elog.h:372
PG_END_TRY
#define PG_END_TRY(...)
Definition: elog.h:397
ERROR
#define ERROR
Definition: elog.h:39
PG_CATCH
#define PG_CATCH(...)
Definition: elog.h:382
elog
#define elog(elevel,...)
Definition: elog.h:226
ereport
#define ereport(elevel,...)
Definition: elog.h:150
DEBUG5
#define DEBUG5
Definition: elog.h:26
durable_rename
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:779
BasicOpenFile
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:1086
FreeFile
int FreeFile(FILE *file)
Definition: fd.c:2840
AllocateFile
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2641
FreeConfigVariables
void FreeConfigVariables(ConfigVariable *list)
Definition: guc-file.l:617
ParseConfigFp
bool ParseConfigFp(FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
Definition: guc-file.l:350
assignable_custom_variable_name
static bool assignable_custom_variable_name(const char *name, bool skip_errors, int elevel)
Definition: guc.c:1122
guc_free
void guc_free(void *ptr)
Definition: guc.c:690
valid_custom_variable_name
static bool valid_custom_variable_name(const char *name)
Definition: guc.c:1077
parse_and_validate_value
static bool parse_and_validate_value(struct config_generic *record, const char *value, GucSource source, int elevel, union config_var_val *newval, void **newextra)
Definition: guc.c:3134
write_auto_conf_file
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head)
Definition: guc.c:4474
newval
#define newval
find_option
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1236
replace_auto_config_value
static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
Definition: guc.c:4542
PG_AUTOCONF_FILENAME
#define PG_AUTOCONF_FILENAME
Definition: guc.h:37
GUC_DISALLOW_IN_FILE
#define GUC_DISALLOW_IN_FILE
Definition: guc.h:222
GUC_DISALLOW_IN_AUTO_FILE
#define GUC_DISALLOW_IN_AUTO_FILE
Definition: guc.h:227
ExtractSetVariableArgs
char * ExtractSetVariableArgs(VariableSetStmt *stmt)
Definition: guc_funcs.c:167
AllowAlterSystem
bool AllowAlterSystem
Definition: guc_tables.c:506
PGC_STRING
@ PGC_STRING
Definition: guc_tables.h:28
value
static struct @166 value
close
#define close(a)
Definition: win32.h:12
LWLockAcquire
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1174
LWLockRelease
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1894
LW_EXCLUSIVE
@ LW_EXCLUSIVE
Definition: lwlock.h:112
GetUserId
Oid GetUserId(void)
Definition: miscinit.c:469
InvokeObjectPostAlterHookArgStr
#define InvokeObjectPostAlterHookArgStr(classId, objectName, subId, auxiliaryId, is_internal)
Definition: objectaccess.h:247
VAR_SET_DEFAULT
@ VAR_SET_DEFAULT
Definition: parsenodes.h:2694
VAR_RESET
@ VAR_RESET
Definition: parsenodes.h:2697
VAR_SET_VALUE
@ VAR_SET_VALUE
Definition: parsenodes.h:2693
VAR_RESET_ALL
@ VAR_RESET_ALL
Definition: parsenodes.h:2698
ACL_ALTER_SYSTEM
#define ACL_ALTER_SYSTEM
Definition: parsenodes.h:89
MAXPGPATH
#define MAXPGPATH
Definition: pg_config_manual.h:95
snprintf
#define snprintf
Definition: port.h:239
AlterSystemStmt::setstmt
VariableSetStmt * setstmt
Definition: parsenodes.h:3950
VariableSetStmt::kind
VariableSetKind kind
Definition: parsenodes.h:2706
config_generic
Definition: guc_tables.h:172
config_generic::context
GucContext context
Definition: guc_tables.h:175
config_generic::flags
int flags
Definition: guc_tables.h:179
config_generic::vartype
enum config_type vartype
Definition: guc_tables.h:181
superuser
bool superuser(void)
Definition: superuser.c:46
config_var_val
Definition: guc_tables.h:33
name
const char * name
Definition: wait_event_funcs.c:28
stat
#define stat
Definition: win32_port.h:274
infile
static void infile(const char *name)
Definition: zic.c:1243

References ACL_ALTER_SYSTEM, ACLCHECK_OK, AllocateFile(), AllowAlterSystem, assignable_custom_variable_name(), BasicOpenFile(), close, CONF_FILE_START_DEPTH, config_generic::context, DEBUG5, 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(), valid_custom_variable_name(), 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 2267 of file guc.c.

2268{
2269 slist_mutable_iter iter;
2270
2271 /*
2272 * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
2273 * abort, if there is a failure during transaction start before
2274 * AtStart_GUC is called.
2275 */
2276 Assert(nestLevel > 0 &&
2277 (nestLevel <= GUCNestLevel ||
2278 (nestLevel == GUCNestLevel + 1 && !isCommit)));
2279
2280 /* We need only process GUCs having nonempty stacks */
2281 slist_foreach_modify(iter, &guc_stack_list)
2282 {
2283 struct config_generic *gconf = slist_container(struct config_generic,
2284 stack_link, iter.cur);
2285 GucStack *stack;
2286
2287 /*
2288 * Process and pop each stack entry within the nest level. To simplify
2289 * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
2290 * we allow failure exit from code that uses a local nest level to be
2291 * recovered at the surrounding transaction or subtransaction abort;
2292 * so there could be more than one stack entry to pop.
2293 */
2294 while ((stack = gconf->stack) != NULL &&
2295 stack->nest_level >= nestLevel)
2296 {
2297 GucStack *prev = stack->prev;
2298 bool restorePrior = false;
2299 bool restoreMasked = false;
2300 bool changed;
2301
2302 /*
2303 * In this next bit, if we don't set either restorePrior or
2304 * restoreMasked, we must "discard" any unwanted fields of the
2305 * stack entries to avoid leaking memory. If we do set one of
2306 * those flags, unused fields will be cleaned up after restoring.
2307 */
2308 if (!isCommit) /* if abort, always restore prior value */
2309 restorePrior = true;
2310 else if (stack->state == GUC_SAVE)
2311 restorePrior = true;
2312 else if (stack->nest_level == 1)
2313 {
2314 /* transaction commit */
2315 if (stack->state == GUC_SET_LOCAL)
2316 restoreMasked = true;
2317 else if (stack->state == GUC_SET)
2318 {
2319 /* we keep the current active value */
2320 discard_stack_value(gconf, &stack->prior);
2321 }
2322 else /* must be GUC_LOCAL */
2323 restorePrior = true;
2324 }
2325 else if (prev == NULL ||
2326 prev->nest_level < stack->nest_level - 1)
2327 {
2328 /* decrement entry's level and do not pop it */
2329 stack->nest_level--;
2330 continue;
2331 }
2332 else
2333 {
2334 /*
2335 * We have to merge this stack entry into prev. See README for
2336 * discussion of this bit.
2337 */
2338 switch (stack->state)
2339 {
2340 case GUC_SAVE:
2341 Assert(false); /* can't get here */
2342 break;
2343
2344 case GUC_SET:
2345 /* next level always becomes SET */
2346 discard_stack_value(gconf, &stack->prior);
2347 if (prev->state == GUC_SET_LOCAL)
2348 discard_stack_value(gconf, &prev->masked);
2349 prev->state = GUC_SET;
2350 break;
2351
2352 case GUC_LOCAL:
2353 if (prev->state == GUC_SET)
2354 {
2355 /* LOCAL migrates down */
2356 prev->masked_scontext = stack->scontext;
2357 prev->masked_srole = stack->srole;
2358 prev->masked = stack->prior;
2359 prev->state = GUC_SET_LOCAL;
2360 }
2361 else
2362 {
2363 /* else just forget this stack level */
2364 discard_stack_value(gconf, &stack->prior);
2365 }
2366 break;
2367
2368 case GUC_SET_LOCAL:
2369 /* prior state at this level no longer wanted */
2370 discard_stack_value(gconf, &stack->prior);
2371 /* copy down the masked state */
2372 prev->masked_scontext = stack->masked_scontext;
2373 prev->masked_srole = stack->masked_srole;
2374 if (prev->state == GUC_SET_LOCAL)
2375 discard_stack_value(gconf, &prev->masked);
2376 prev->masked = stack->masked;
2377 prev->state = GUC_SET_LOCAL;
2378 break;
2379 }
2380 }
2381
2382 changed = false;
2383
2384 if (restorePrior || restoreMasked)
2385 {
2386 /* Perform appropriate restoration of the stacked value */
2387 config_var_value newvalue;
2388 GucSource newsource;
2389 GucContext newscontext;
2390 Oid newsrole;
2391
2392 if (restoreMasked)
2393 {
2394 newvalue = stack->masked;
2395 newsource = PGC_S_SESSION;
2396 newscontext = stack->masked_scontext;
2397 newsrole = stack->masked_srole;
2398 }
2399 else
2400 {
2401 newvalue = stack->prior;
2402 newsource = stack->source;
2403 newscontext = stack->scontext;
2404 newsrole = stack->srole;
2405 }
2406
2407 switch (gconf->vartype)
2408 {
2409 case PGC_BOOL:
2410 {
2411 struct config_bool *conf = (struct config_bool *) gconf;
2412 bool newval = newvalue.val.boolval;
2413 void *newextra = newvalue.extra;
2414
2415 if (*conf->variable != newval ||
2416 conf->gen.extra != newextra)
2417 {
2418 if (conf->assign_hook)
2419 conf->assign_hook(newval, newextra);
2420 *conf->variable = newval;
2421 set_extra_field(&conf->gen, &conf->gen.extra,
2422 newextra);
2423 changed = true;
2424 }
2425 break;
2426 }
2427 case PGC_INT:
2428 {
2429 struct config_int *conf = (struct config_int *) gconf;
2430 int newval = newvalue.val.intval;
2431 void *newextra = newvalue.extra;
2432
2433 if (*conf->variable != newval ||
2434 conf->gen.extra != newextra)
2435 {
2436 if (conf->assign_hook)
2437 conf->assign_hook(newval, newextra);
2438 *conf->variable = newval;
2439 set_extra_field(&conf->gen, &conf->gen.extra,
2440 newextra);
2441 changed = true;
2442 }
2443 break;
2444 }
2445 case PGC_REAL:
2446 {
2447 struct config_real *conf = (struct config_real *) gconf;
2448 double newval = newvalue.val.realval;
2449 void *newextra = newvalue.extra;
2450
2451 if (*conf->variable != newval ||
2452 conf->gen.extra != newextra)
2453 {
2454 if (conf->assign_hook)
2455 conf->assign_hook(newval, newextra);
2456 *conf->variable = newval;
2457 set_extra_field(&conf->gen, &conf->gen.extra,
2458 newextra);
2459 changed = true;
2460 }
2461 break;
2462 }
2463 case PGC_STRING:
2464 {
2465 struct config_string *conf = (struct config_string *) gconf;
2466 char *newval = newvalue.val.stringval;
2467 void *newextra = newvalue.extra;
2468
2469 if (*conf->variable != newval ||
2470 conf->gen.extra != newextra)
2471 {
2472 if (conf->assign_hook)
2473 conf->assign_hook(newval, newextra);
2474 set_string_field(conf, conf->variable, newval);
2475 set_extra_field(&conf->gen, &conf->gen.extra,
2476 newextra);
2477 changed = true;
2478 }
2479
2480 /*
2481 * Release stacked values if not used anymore. We
2482 * could use discard_stack_value() here, but since
2483 * we have type-specific code anyway, might as
2484 * well inline it.
2485 */
2486 set_string_field(conf, &stack->prior.val.stringval, NULL);
2487 set_string_field(conf, &stack->masked.val.stringval, NULL);
2488 break;
2489 }
2490 case PGC_ENUM:
2491 {
2492 struct config_enum *conf = (struct config_enum *) gconf;
2493 int newval = newvalue.val.enumval;
2494 void *newextra = newvalue.extra;
2495
2496 if (*conf->variable != newval ||
2497 conf->gen.extra != newextra)
2498 {
2499 if (conf->assign_hook)
2500 conf->assign_hook(newval, newextra);
2501 *conf->variable = newval;
2502 set_extra_field(&conf->gen, &conf->gen.extra,
2503 newextra);
2504 changed = true;
2505 }
2506 break;
2507 }
2508 }
2509
2510 /*
2511 * Release stacked extra values if not used anymore.
2512 */
2513 set_extra_field(gconf, &(stack->prior.extra), NULL);
2514 set_extra_field(gconf, &(stack->masked.extra), NULL);
2515
2516 /* And restore source information */
2517 set_guc_source(gconf, newsource);
2518 gconf->scontext = newscontext;
2519 gconf->srole = newsrole;
2520 }
2521
2522 /*
2523 * Pop the GUC's state stack; if it's now empty, remove the GUC
2524 * from guc_stack_list.
2525 */
2526 gconf->stack = prev;
2527 if (prev == NULL)
2528 slist_delete_current(&iter);
2529 pfree(stack);
2530
2531 /* Report new value if we changed it */
2532 if (changed && (gconf->flags & GUC_REPORT) &&
2533 !(gconf->status & GUC_NEEDS_REPORT))
2534 {
2535 gconf->status |= GUC_NEEDS_REPORT;
2536 slist_push_head(&guc_report_list, &gconf->report_link);
2537 }
2538 } /* end of stack-popping loop */
2539 }
2540
2541 /* Update nesting level */
2542 GUCNestLevel = nestLevel - 1;
2543}
guc_report_list
static slist_head guc_report_list
Definition: guc.c:226
set_string_field
static void set_string_field(struct config_string *conf, char **field, char *newval)
Definition: guc.c:732
GUCNestLevel
static int GUCNestLevel
Definition: guc.c:231
discard_stack_value
static void discard_stack_value(struct config_generic *gconf, config_var_value *val)
Definition: guc.c:847
guc_stack_list
static slist_head guc_stack_list
Definition: guc.c:224
set_guc_source
static void set_guc_source(struct config_generic *gconf, GucSource newsource)
Definition: guc.c:2116
set_extra_field
static void set_extra_field(struct config_generic *gconf, void **field, void *newval)
Definition: guc.c:793
GUC_REPORT
#define GUC_REPORT
Definition: guc.h:220
GUC_SET_LOCAL
@ GUC_SET_LOCAL
Definition: guc_tables.h:117
GUC_SET
@ GUC_SET
Definition: guc_tables.h:115
GUC_SAVE
@ GUC_SAVE
Definition: guc_tables.h:114
GUC_LOCAL
@ GUC_LOCAL
Definition: guc_tables.h:116
GUC_NEEDS_REPORT
#define GUC_NEEDS_REPORT
Definition: guc_tables.h:211
PGC_BOOL
@ PGC_BOOL
Definition: guc_tables.h:25
PGC_ENUM
@ PGC_ENUM
Definition: guc_tables.h:29
PGC_REAL
@ PGC_REAL
Definition: guc_tables.h:27
PGC_INT
@ PGC_INT
Definition: guc_tables.h:26
Assert
Assert(PointerIsAligned(start, uint64))
slist_delete_current
static void slist_delete_current(slist_mutable_iter *iter)
Definition: ilist.h:1084
slist_foreach_modify
#define slist_foreach_modify(iter, lhead)
Definition: ilist.h:1148
slist_push_head
static void slist_push_head(slist_head *head, slist_node *node)
Definition: ilist.h:1006
slist_container
#define slist_container(type, membername, ptr)
Definition: ilist.h:1106
pfree
void pfree(void *pointer)
Definition: mcxt.c:1594
Oid
unsigned int Oid
Definition: postgres_ext.h:32
config_bool
Definition: guc_tables.h:217
config_bool::gen
struct config_generic gen
Definition: guc_tables.h:218
config_bool::variable
bool * variable
Definition: guc_tables.h:220
config_bool::assign_hook
GucBoolAssignHook assign_hook
Definition: guc_tables.h:223
config_enum
Definition: guc_tables.h:287
config_enum::variable
int * variable
Definition: guc_tables.h:290
config_enum::assign_hook
GucEnumAssignHook assign_hook
Definition: guc_tables.h:294
config_enum::gen
struct config_generic gen
Definition: guc_tables.h:288
config_generic::status
int status
Definition: guc_tables.h:182
config_generic::scontext
GucContext scontext
Definition: guc_tables.h:185
config_generic::stack_link
slist_node stack_link
Definition: guc_tables.h:193
config_generic::srole
Oid srole
Definition: guc_tables.h:187
config_generic::stack
GucStack * stack
Definition: guc_tables.h:189
config_generic::extra
void * extra
Definition: guc_tables.h:190
config_generic::report_link
slist_node report_link
Definition: guc_tables.h:195
config_int
Definition: guc_tables.h:231
config_int::assign_hook
GucIntAssignHook assign_hook
Definition: guc_tables.h:239
config_int::variable
int * variable
Definition: guc_tables.h:234
config_int::gen
struct config_generic gen
Definition: guc_tables.h:232
config_real
Definition: guc_tables.h:247
config_real::assign_hook
GucRealAssignHook assign_hook
Definition: guc_tables.h:255
config_real::variable
double * variable
Definition: guc_tables.h:250
config_real::gen
struct config_generic gen
Definition: guc_tables.h:248
config_string
Definition: guc_tables.h:273
config_string::gen
struct config_generic gen
Definition: guc_tables.h:274
config_string::assign_hook
GucStringAssignHook assign_hook
Definition: guc_tables.h:279
config_string::variable
char ** variable
Definition: guc_tables.h:276
config_var_value
Definition: guc_tables.h:46
config_var_value::val
union config_var_val val
Definition: guc_tables.h:47
config_var_value::extra
void * extra
Definition: guc_tables.h:48
guc_stack
Definition: guc_tables.h:121
guc_stack::prev
struct guc_stack * prev
Definition: guc_tables.h:122
guc_stack::masked_srole
Oid masked_srole
Definition: guc_tables.h:130
guc_stack::nest_level
int nest_level
Definition: guc_tables.h:123
guc_stack::masked
config_var_value masked
Definition: guc_tables.h:132
guc_stack::prior
config_var_value prior
Definition: guc_tables.h:131
guc_stack::srole
Oid srole
Definition: guc_tables.h:129
guc_stack::scontext
GucContext scontext
Definition: guc_tables.h:127
guc_stack::state
GucStackState state
Definition: guc_tables.h:124
guc_stack::source
GucSource source
Definition: guc_tables.h:125
guc_stack::masked_scontext
GucContext masked_scontext
Definition: guc_tables.h:128
slist_mutable_iter
Definition: ilist.h:273
slist_mutable_iter::cur
slist_node * cur
Definition: ilist.h:274
config_var_val::boolval
bool boolval
Definition: guc_tables.h:34
config_var_val::realval
double realval
Definition: guc_tables.h:36
config_var_val::stringval
char * stringval
Definition: guc_tables.h:37
config_var_val::intval
int intval
Definition: guc_tables.h:35
config_var_val::enumval
int enumval
Definition: guc_tables.h:38

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(), amcheck_lock_relation_and_check(), brin_summarize_range(), cluster_rel(), CommitSubTransaction(), CommitTransaction(), ComputeIndexAttrs(), CreateSchemaCommand(), DefineIndex(), do_analyze_rel(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), PrepareTransaction(), ProcedureCreate(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), reset_transmission_modes(), restoreLocalGucs(), RestoreUserContext(), RI_Initial_Check(), RI_PartitionRemove_Check(), vacuum_rel(), and validate_index().

◆ AtStart_GUC()

void AtStart_GUC ( void  )

Definition at line 2220 of file guc.c.

2221{
2222 /*
2223 * The nest level should be 0 between transactions; if it isn't, somebody
2224 * didn't call AtEOXact_GUC, or called it with the wrong nestLevel. We
2225 * throw a warning but make no other effort to clean up.
2226 */
2227 if (GUCNestLevel != 0)
2228 elog(WARNING, "GUC nest level = %d at transaction start",
2229 GUCNestLevel);
2230 GUCNestLevel = 1;
2231}
WARNING
#define WARNING
Definition: elog.h:36

References elog, GUCNestLevel, and WARNING.

Referenced by StartTransaction().

◆ BeginReportingGUCOptions()

void BeginReportingGUCOptions ( void  )

Definition at line 2551 of file guc.c.

2552{
2553 HASH_SEQ_STATUS status;
2554 GUCHashEntry *hentry;
2555
2556 /*
2557 * Don't do anything unless talking to an interactive frontend.
2558 */
2559 if (whereToSendOutput != DestRemote)
2560 return;
2561
2562 reporting_enabled = true;
2563
2564 /*
2565 * Hack for in_hot_standby: set the GUC value true if appropriate. This
2566 * is kind of an ugly place to do it, but there's few better options.
2567 *
2568 * (This could be out of date by the time we actually send it, in which
2569 * case the next ReportChangedGUCOptions call will send a duplicate
2570 * report.)
2571 */
2572 if (RecoveryInProgress())
2573 SetConfigOption("in_hot_standby", "true",
2574 PGC_INTERNAL, PGC_S_OVERRIDE);
2575
2576 /* Transmit initial values of interesting variables */
2577 hash_seq_init(&status, guc_hashtab);
2578 while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
2579 {
2580 struct config_generic *conf = hentry->gucvar;
2581
2582 if (conf->flags & GUC_REPORT)
2583 ReportGUCOption(conf);
2584 }
2585}
DestRemote
@ DestRemote
Definition: dest.h:89
hash_seq_search
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1415
hash_seq_init
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1380
ReportGUCOption
static void ReportGUCOption(struct config_generic *record)
Definition: guc.c:2639
SetConfigOption
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4337
guc_hashtab
static HTAB * guc_hashtab
Definition: guc.c:212
reporting_enabled
static bool reporting_enabled
Definition: guc.c:229
whereToSendOutput
CommandDest whereToSendOutput
Definition: postgres.c:91
GUCHashEntry::gucvar
struct config_generic * gucvar
Definition: guc.c:209
HASH_SEQ_STATUS
Definition: hsearch.h:121
RecoveryInProgress
bool RecoveryInProgress(void)
Definition: xlog.c:6383

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(), and whereToSendOutput.

Referenced by PostgresMain().

◆ check_GUC_name_for_parameter_acl()

void check_GUC_name_for_parameter_acl ( const char *  name)

Definition at line 1411 of file guc.c.

1412{
1413 /* OK if the GUC exists. */
1414 if (find_option(name, false, true, DEBUG5) != NULL)
1415 return;
1416 /* Otherwise, it'd better be a valid custom GUC name. */
1417 (void) assignable_custom_variable_name(name, false, ERROR);
1418}

References assignable_custom_variable_name(), DEBUG5, ERROR, find_option(), and name.

Referenced by ParameterAclCreate().

◆ convert_GUC_name_for_parameter_acl()

char * convert_GUC_name_for_parameter_acl ( const char *  name)

Definition at line 1375 of file guc.c.

1376{
1377 char *result;
1378
1379 /* Apply old-GUC-name mapping. */
1380 for (int i = 0; map_old_guc_names[i] != NULL; i += 2)
1381 {
1382 if (guc_name_compare(name, map_old_guc_names[i]) == 0)
1383 {
1384 name = map_old_guc_names[i + 1];
1385 break;
1386 }
1387 }
1388
1389 /* Apply case-folding that matches guc_name_compare(). */
1390 result = pstrdup(name);
1391 for (char *ptr = result; *ptr != '\0'; ptr++)
1392 {
1393 char ch = *ptr;
1394
1395 if (ch >= 'A' && ch <= 'Z')
1396 {
1397 ch += 'a' - 'A';
1398 *ptr = ch;
1399 }
1400 }
1401
1402 return result;
1403}
map_old_guc_names
static const char *const map_old_guc_names[]
Definition: guc.c:190
guc_name_compare
int guc_name_compare(const char *namea, const char *nameb)
Definition: guc.c:1301
i
int i
Definition: isn.c:77
pstrdup
char * pstrdup(const char *in)
Definition: mcxt.c:1759

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)

Definition at line 661 of file guc-file.l.

662{
663 char *newStr;
664 int len,
665 i,
666 j;
667
668 /* We just Assert that there are leading and trailing quotes */
669 Assert(s != NULL && s[0] == '\'');
670 len = strlen(s);
671 Assert(len >= 2);
672 Assert(s[len - 1] == '\'');
673
674 /* Skip the leading quote; we'll handle the trailing quote below */
675 s++, len--;
676
677 /* Since len still includes trailing quote, this is enough space */
678 newStr = palloc(len);
679
680 for (i = 0, j = 0; i < len; i++)
681 {
682 if (s[i] == '\\')
683 {
684 i++;
685 switch (s[i])
686 {
687 case 'b':
688 newStr[j] = '\b';
689 break;
690 case 'f':
691 newStr[j] = '\f';
692 break;
693 case 'n':
694 newStr[j] = '\n';
695 break;
696 case 'r':
697 newStr[j] = '\r';
698 break;
699 case 't':
700 newStr[j] = '\t';
701 break;
702 case '0':
703 case '1':
704 case '2':
705 case '3':
706 case '4':
707 case '5':
708 case '6':
709 case '7':
710 {
711 int k;
712 long octVal = 0;
713
714 for (k = 0;
715 s[i + k] >= '0' && s[i + k] <= '7' && k < 3;
716 k++)
717 octVal = (octVal << 3) + (s[i + k] - '0');
718 i += k - 1;
719 newStr[j] = ((char) octVal);
720 }
721 break;
722 default:
723 newStr[j] = s[i];
724 break;
725 } /* switch */
726 }
727 else if (s[i] == '\'' && s[i + 1] == '\'')
728 {
729 /* doubled quote becomes just one quote */
730 newStr[j] = s[++i];
731 }
732 else
733 newStr[j] = s[i];
734 j++;
735 }
736
737 /* We copied the ending quote to newStr, so replace with \0 */
738 Assert(j > 0 && j <= len);
739 newStr[--j] = '\0';
740
741 return newStr;
742}
j
int j
Definition: isn.c:78
palloc
void * palloc(Size size)
Definition: mcxt.c:1365
len
const void size_t len
Definition: pg_crc32c_sse42.c:28

References Assert(), i, j, len, and palloc().

Referenced by ParseConfigFp().

◆ 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 5970 of file guc.c.

5971{
5972 Size size;
5973 dlist_iter iter;
5974
5975 /* Add space reqd for saving the data size of the guc state */
5976 size = sizeof(Size);
5977
5978 /*
5979 * Add up the space needed for each GUC variable.
5980 *
5981 * We need only process non-default GUCs.
5982 */
5983 dlist_foreach(iter, &guc_nondef_list)
5984 {
5985 struct config_generic *gconf = dlist_container(struct config_generic,
5986 nondef_link, iter.cur);
5987
5988 size = add_size(size, estimate_variable_size(gconf));
5989 }
5990
5991 return size;
5992}
Size
size_t Size
Definition: c.h:611
guc_nondef_list
static dlist_head guc_nondef_list
Definition: guc.c:222
estimate_variable_size
static Size estimate_variable_size(struct config_generic *gconf)
Definition: guc.c:5870
dlist_foreach
#define dlist_foreach(iter, lhead)
Definition: ilist.h:623
dlist_container
#define dlist_container(type, membername, ptr)
Definition: ilist.h:593
add_size
Size add_size(Size s1, Size s2)
Definition: shmem.c:493
config_generic::nondef_link
dlist_node nondef_link
Definition: guc_tables.h:191
dlist_iter
Definition: ilist.h:178
dlist_iter::cur
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{
45 GucAction action = stmt->is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET;
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,
63 ExtractSetVariableArgs(stmt),
64 (superuser() ? PGC_SUSET : PGC_USERSET),
65 PGC_S_SESSION,
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,
146 (superuser() ? PGC_SUSET : PGC_USERSET),
147 PGC_S_SESSION,
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}
ResetAllOptions
void ResetAllOptions(void)
Definition: guc.c:2008
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: guc.c:3347
SetPGVariable
void SetPGVariable(const char *name, List *args, bool is_local)
Definition: guc_funcs.c:315
stmt
#define stmt
Definition: indent_codes.h:59
generate_unaccent_rules.action
action
Definition: generate_unaccent_rules.py:287
ACL_SET
#define ACL_SET
Definition: parsenodes.h:88
VAR_SET_MULTI
@ VAR_SET_MULTI
Definition: parsenodes.h:2696
VAR_SET_CURRENT
@ VAR_SET_CURRENT
Definition: parsenodes.h:2695
lfirst
#define lfirst(lc)
Definition: pg_list.h:172
linitial_node
#define linitial_node(type, l)
Definition: pg_list.h:181
list_make1
#define list_make1(x1)
Definition: pg_list.h:212
ImportSnapshot
void ImportSnapshot(const char *idstr)
Definition: snapmgr.c:1385
A_Const
Definition: parsenodes.h:383
A_Const::val
union ValUnion val
Definition: parsenodes.h:387
DefElem::defname
char * defname
Definition: parsenodes.h:842
DefElem::arg
Node * arg
Definition: parsenodes.h:843
strVal
#define strVal(v)
Definition: value.h:82
WarnNoTransactionBlock
void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3722
IsInParallelMode
bool IsInParallelMode(void)
Definition: xact.c:1089

References ACL_SET, generate_unaccent_rules::action, DefElem::arg, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, ExtractSetVariableArgs(), GUC_ACTION_LOCAL, GUC_ACTION_SET, ImportSnapshot(), InvokeObjectPostAlterHookArgStr, IsInParallelMode(), lfirst, linitial_node, list_make1, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, ResetAllOptions(), set_config_option(), SetPGVariable(), stmt, 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 switch (stmt->kind)
170 {
171 case VAR_SET_VALUE:
172 return flatten_set_variable_args(stmt->name, stmt->args);
173 case VAR_SET_CURRENT:
174 return GetConfigOptionByName(stmt->name, NULL, false);
175 default:
176 return NULL;
177 }
178}
GetConfigOptionByName
char * GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
Definition: guc.c:5454
flatten_set_variable_args
static char * flatten_set_variable_args(const char *name, List *args)
Definition: guc_funcs.c:192

References flatten_set_variable_args(), GetConfigOptionByName(), stmt, VAR_SET_CURRENT, and VAR_SET_VALUE.

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

◆ FreeConfigVariables()

void FreeConfigVariables ( ConfigVariable *  list)

Definition at line 617 of file guc-file.l.

618{
619 ConfigVariable *item;
620
621 item = list;
622 while (item)
623 {
624 ConfigVariable *next = item->next;
625
626 FreeConfigVariable(item);
627 item = next;
628 }
629}
next
static int32 next
Definition: blutils.c:224
FreeConfigVariable
static void FreeConfigVariable(ConfigVariable *item)
Definition: guc-file.l:635
ConfigVariable::next
struct ConfigVariable * next
Definition: guc.h:148

References FreeConfigVariable(), sort-test::list, next, and ConfigVariable::next.

Referenced by AlterSystemSetConfigFile(), and parse_extension_control_file().

◆ get_config_handle()

config_handle * get_config_handle ( const char *  name)

Definition at line 4289 of file guc.c.

4290{
4291 struct config_generic *gen = find_option(name, false, false, 0);
4292
4293 if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
4294 return gen;
4295
4296 return NULL;
4297}
GUC_CUSTOM_PLACEHOLDER
#define GUC_CUSTOM_PLACEHOLDER
Definition: guc.h:223

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

Referenced by fmgr_security_definer().

◆ get_config_unit_name()

const char * get_config_unit_name ( int  flags)

Definition at line 2819 of file guc.c.

2820{
2821 switch (flags & GUC_UNIT)
2822 {
2823 case 0:
2824 return NULL; /* GUC has no units */
2825 case GUC_UNIT_BYTE:
2826 return "B";
2827 case GUC_UNIT_KB:
2828 return "kB";
2829 case GUC_UNIT_MB:
2830 return "MB";
2831 case GUC_UNIT_BLOCKS:
2832 {
2833 static char bbuf[8];
2834
2835 /* initialize if first time through */
2836 if (bbuf[0] == '\0')
2837 snprintf(bbuf, sizeof(bbuf), "%dkB", BLCKSZ / 1024);
2838 return bbuf;
2839 }
2840 case GUC_UNIT_XBLOCKS:
2841 {
2842 static char xbuf[8];
2843
2844 /* initialize if first time through */
2845 if (xbuf[0] == '\0')
2846 snprintf(xbuf, sizeof(xbuf), "%dkB", XLOG_BLCKSZ / 1024);
2847 return xbuf;
2848 }
2849 case GUC_UNIT_MS:
2850 return "ms";
2851 case GUC_UNIT_S:
2852 return "s";
2853 case GUC_UNIT_MIN:
2854 return "min";
2855 default:
2856 elog(ERROR, "unrecognized GUC units value: %d",
2857 flags & GUC_UNIT);
2858 return NULL;
2859 }
2860}
GUC_UNIT_MB
#define GUC_UNIT_MB
Definition: guc.h:235
GUC_UNIT
#define GUC_UNIT
Definition: guc.h:244
GUC_UNIT_MS
#define GUC_UNIT_MS
Definition: guc.h:239
GUC_UNIT_BLOCKS
#define GUC_UNIT_BLOCKS
Definition: guc.h:233
GUC_UNIT_XBLOCKS
#define GUC_UNIT_XBLOCKS
Definition: guc.h:234
GUC_UNIT_BYTE
#define GUC_UNIT_BYTE
Definition: guc.h:236
GUC_UNIT_S
#define GUC_UNIT_S
Definition: guc.h:240
GUC_UNIT_KB
#define GUC_UNIT_KB
Definition: guc.h:232
GUC_UNIT_MIN
#define GUC_UNIT_MIN
Definition: guc.h:241

References elog, ERROR, config_generic::flags, GUC_UNIT, GUC_UNIT_BLOCKS, GUC_UNIT_BYTE, GUC_UNIT_KB, GUC_UNIT_MB, GUC_UNIT_MIN, GUC_UNIT_MS, GUC_UNIT_S, 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 4360 of file guc.c.

4361{
4362 struct config_generic *record;
4363 static char buffer[256];
4364
4365 record = find_option(name, false, missing_ok, ERROR);
4366 if (record == NULL)
4367 return NULL;
4368 if (restrict_privileged &&
4369 !ConfigOptionIsVisible(record))
4370 ereport(ERROR,
4371 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4372 errmsg("permission denied to examine \"%s\"", name),
4373 errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4374 "pg_read_all_settings")));
4375
4376 switch (record->vartype)
4377 {
4378 case PGC_BOOL:
4379 return *((struct config_bool *) record)->variable ? "on" : "off";
4380
4381 case PGC_INT:
4382 snprintf(buffer, sizeof(buffer), "%d",
4383 *((struct config_int *) record)->variable);
4384 return buffer;
4385
4386 case PGC_REAL:
4387 snprintf(buffer, sizeof(buffer), "%g",
4388 *((struct config_real *) record)->variable);
4389 return buffer;
4390
4391 case PGC_STRING:
4392 return *((struct config_string *) record)->variable ?
4393 *((struct config_string *) record)->variable : "";
4394
4395 case PGC_ENUM:
4396 return config_enum_lookup_by_value((struct config_enum *) record,
4397 *((struct config_enum *) record)->variable);
4398 }
4399 return NULL;
4400}
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:1207
config_enum_lookup_by_value
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:3028
ConfigOptionIsVisible
bool ConfigOptionIsVisible(struct config_generic *conf)
Definition: guc_funcs.c:581

References config_enum_lookup_by_value(), ConfigOptionIsVisible(), ereport, errcode(), errdetail(), errmsg(), ERROR, find_option(), name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, snprintf, and config_generic::vartype.

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

◆ GetConfigOptionByName()

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

Definition at line 5454 of file guc.c.

5455{
5456 struct config_generic *record;
5457
5458 record = find_option(name, false, missing_ok, ERROR);
5459 if (record == NULL)
5460 {
5461 if (varname)
5462 *varname = NULL;
5463 return NULL;
5464 }
5465
5466 if (!ConfigOptionIsVisible(record))
5467 ereport(ERROR,
5468 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
5469 errmsg("permission denied to examine \"%s\"", name),
5470 errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
5471 "pg_read_all_settings")));
5472
5473 if (varname)
5474 *varname = record->name;
5475
5476 return ShowGUCOption(record, true);
5477}
ShowGUCOption
char * ShowGUCOption(struct config_generic *record, bool use_units)
Definition: guc.c:5487
config_generic::name
const char * name
Definition: guc_tables.h:174

References ConfigOptionIsVisible(), ereport, errcode(), errdetail(), errmsg(), ERROR, find_option(), 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 4457 of file guc.c.

4458{
4459 struct config_generic *record;
4460
4461 record = find_option(name, false, missing_ok, ERROR);
4462 if (record == NULL)
4463 return 0;
4464 return record->flags;
4465}

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 4410 of file guc.c.

4411{
4412 struct config_generic *record;
4413 static char buffer[256];
4414
4415 record = find_option(name, false, false, ERROR);
4416 Assert(record != NULL);
4417 if (!ConfigOptionIsVisible(record))
4418 ereport(ERROR,
4419 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4420 errmsg("permission denied to examine \"%s\"", name),
4421 errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4422 "pg_read_all_settings")));
4423
4424 switch (record->vartype)
4425 {
4426 case PGC_BOOL:
4427 return ((struct config_bool *) record)->reset_val ? "on" : "off";
4428
4429 case PGC_INT:
4430 snprintf(buffer, sizeof(buffer), "%d",
4431 ((struct config_int *) record)->reset_val);
4432 return buffer;
4433
4434 case PGC_REAL:
4435 snprintf(buffer, sizeof(buffer), "%g",
4436 ((struct config_real *) record)->reset_val);
4437 return buffer;
4438
4439 case PGC_STRING:
4440 return ((struct config_string *) record)->reset_val ?
4441 ((struct config_string *) record)->reset_val : "";
4442
4443 case PGC_ENUM:
4444 return config_enum_lookup_by_value((struct config_enum *) record,
4445 ((struct config_enum *) record)->reset_val);
4446 }
4447 return NULL;
4448}
config_string::reset_val
char * reset_val
Definition: guc_tables.h:282

References Assert(), config_enum_lookup_by_value(), ConfigOptionIsVisible(), ereport, errcode(), errdetail(), errmsg(), ERROR, find_option(), name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, config_string::reset_val, snprintf, and config_generic::vartype.

Referenced by check_datestyle().

◆ GetPGVariable()

void GetPGVariable ( const char *  name,
DestReceiver *  dest 
)

Definition at line 382 of file guc_funcs.c.

383{
384 if (guc_name_compare(name, "all") == 0)
385 ShowAllGUCConfig(dest);
386 else
387 ShowGUCConfigOption(name, dest);
388}
ShowGUCConfigOption
static void ShowGUCConfigOption(const char *name, DestReceiver *dest)
Definition: guc_funcs.c:428
ShowAllGUCConfig
static void ShowAllGUCConfig(DestReceiver *dest)
Definition: guc_funcs.c:456
generate_unaccent_rules.dest
dest
Definition: generate_unaccent_rules.py:285

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 394 of file guc_funcs.c.

395{
396 TupleDesc tupdesc;
397
398 if (guc_name_compare(name, "all") == 0)
399 {
400 /* need a tuple descriptor representing three TEXT columns */
401 tupdesc = CreateTemplateTupleDesc(3);
402 TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
403 TEXTOID, -1, 0);
404 TupleDescInitEntry(tupdesc, (AttrNumber) 2, "setting",
405 TEXTOID, -1, 0);
406 TupleDescInitEntry(tupdesc, (AttrNumber) 3, "description",
407 TEXTOID, -1, 0);
408 }
409 else
410 {
411 const char *varname;
412
413 /* Get the canonical spelling of name */
414 (void) GetConfigOptionByName(name, &varname, false);
415
416 /* need a tuple descriptor representing a single TEXT column */
417 tupdesc = CreateTemplateTupleDesc(1);
418 TupleDescInitEntry(tupdesc, (AttrNumber) 1, varname,
419 TEXTOID, -1, 0);
420 }
421 return tupdesc;
422}
AttrNumber
int16 AttrNumber
Definition: attnum.h:21
CreateTemplateTupleDesc
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:182
TupleDescInitEntry
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:842

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

Referenced by UtilityTupleDescriptor().

◆ GUC_check_errcode()

void GUC_check_errcode ( int  sqlerrcode)

Definition at line 6813 of file guc.c.

6814{
6815 GUC_check_errcode_value = sqlerrcode;
6816}
GUC_check_errcode_value
static int GUC_check_errcode_value
Definition: guc.c:76

References GUC_check_errcode_value.

Referenced by check_client_encoding(), check_default_with_oids(), check_role(), check_session_authorization(), check_synchronous_standby_names(), check_transaction_deferrable(), check_transaction_isolation(), and check_transaction_read_only().

◆ guc_free()

void guc_free ( void *  ptr)

Definition at line 690 of file guc.c.

691{
692 /*
693 * Historically, GUC-related code has relied heavily on the ability to do
694 * free(NULL), so we allow that here even though pfree() doesn't.
695 */
696 if (ptr != NULL)
697 {
698 /* This is to help catch old code that malloc's GUC data. */
699 Assert(GetMemoryChunkContext(ptr) == GUCMemoryContext);
700 pfree(ptr);
701 }
702}
GUCMemoryContext
static MemoryContext GUCMemoryContext
Definition: guc.c:199
GetMemoryChunkContext
MemoryContext GetMemoryChunkContext(void *pointer)
Definition: mcxt.c:753

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

Referenced by add_placeholder_variable(), AlterSystemSetConfigFile(), call_string_check_hook(), check_application_name(), check_client_encoding(), check_cluster_name(), check_datestyle(), check_default_text_search_config(), free_placeholder(), parse_and_validate_value(), ReportGUCOption(), RestoreGUCState(), SelectConfigFiles(), set_config_sourcefile(), set_config_with_handle(), set_extra_field(), and set_string_field().

◆ guc_malloc()

void * guc_malloc ( int  elevel,
size_t  size 
)

Definition at line 639 of file guc.c.

640{
641 void *data;
642
643 data = MemoryContextAllocExtended(GUCMemoryContext, size,
644 MCXT_ALLOC_NO_OOM);
645 if (unlikely(data == NULL))
646 ereport(elevel,
647 (errcode(ERRCODE_OUT_OF_MEMORY),
648 errmsg("out of memory")));
649 return data;
650}
unlikely
#define unlikely(x)
Definition: c.h:403
MCXT_ALLOC_NO_OOM
#define MCXT_ALLOC_NO_OOM
Definition: fe_memutils.h:29
MemoryContextAllocExtended
void * MemoryContextAllocExtended(MemoryContext context, Size size, int flags)
Definition: mcxt.c:1286
data
const void * data
Definition: pg_crc32c_sse42.c:27

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

Referenced by add_placeholder_variable(), check_backtrace_functions(), check_client_encoding(), check_createrole_self_grant(), check_datestyle(), check_debug_io_direct(), check_log_connections(), check_log_destination(), check_log_timezone(), check_random_seed(), check_recovery_target_lsn(), check_recovery_target_timeline(), check_recovery_target_xid(), check_restrict_nonsystem_relation_kind(), check_role(), check_session_authorization(), check_synchronized_standby_slots(), check_synchronous_standby_names(), check_temp_tablespaces(), check_timezone(), check_wal_consistency_checking(), ConvertTimeZoneAbbrevs(), guc_strdup(), init_custom_variable(), plpgsql_extra_checks_check_hook(), and SelectConfigFiles().

◆ guc_realloc()

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

Definition at line 653 of file guc.c.

654{
655 void *data;
656
657 if (old != NULL)
658 {
659 /* This is to help catch old code that malloc's GUC data. */
660 Assert(GetMemoryChunkContext(old) == GUCMemoryContext);
661 data = repalloc_extended(old, size,
662 MCXT_ALLOC_NO_OOM);
663 }
664 else
665 {
666 /* Like realloc(3), but not like repalloc(), we allow old == NULL. */
667 data = MemoryContextAllocExtended(GUCMemoryContext, size,
668 MCXT_ALLOC_NO_OOM);
669 }
670 if (unlikely(data == NULL))
671 ereport(elevel,
672 (errcode(ERRCODE_OUT_OF_MEMORY),
673 errmsg("out of memory")));
674 return data;
675}
repalloc_extended
void * repalloc_extended(void *pointer, Size size, int flags)
Definition: mcxt.c:1645

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 678 of file guc.c.

679{
680 char *data;
681 size_t len = strlen(src) + 1;
682
683 data = guc_malloc(elevel, len);
684 if (likely(data != NULL))
685 memcpy(data, src, len);
686 return data;
687}
likely
#define likely(x)
Definition: c.h:402
guc_malloc
void * guc_malloc(int elevel, size_t size)
Definition: guc.c:639

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_sourcefile(), and set_config_with_handle().

◆ GUCArrayAdd()

ArrayType * GUCArrayAdd ( ArrayType *  array,
const char *  name,
const char *  value 
)

Definition at line 6510 of file guc.c.

6511{
6512 struct config_generic *record;
6513 Datum datum;
6514 char *newval;
6515 ArrayType *a;
6516
6517 Assert(name);
6518 Assert(value);
6519
6520 /* test if the option is valid and we're allowed to set it */
6521 (void) validate_option_array_item(name, value, false);
6522
6523 /* normalize name (converts obsolete GUC names to modern spellings) */
6524 record = find_option(name, false, true, WARNING);
6525 if (record)
6526 name = record->name;
6527
6528 /* build new item for array */
6529 newval = psprintf("%s=%s", name, value);
6530 datum = CStringGetTextDatum(newval);
6531
6532 if (array)
6533 {
6534 int index;
6535 bool isnull;
6536 int i;
6537
6538 Assert(ARR_ELEMTYPE(array) == TEXTOID);
6539 Assert(ARR_NDIM(array) == 1);
6540 Assert(ARR_LBOUND(array)[0] == 1);
6541
6542 index = ARR_DIMS(array)[0] + 1; /* add after end */
6543
6544 for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6545 {
6546 Datum d;
6547 char *current;
6548
6549 d = array_ref(array, 1, &i,
6550 -1 /* varlenarray */ ,
6551 -1 /* TEXT's typlen */ ,
6552 false /* TEXT's typbyval */ ,
6553 TYPALIGN_INT /* TEXT's typalign */ ,
6554 &isnull);
6555 if (isnull)
6556 continue;
6557 current = TextDatumGetCString(d);
6558
6559 /* check for match up through and including '=' */
6560 if (strncmp(current, newval, strlen(name) + 1) == 0)
6561 {
6562 index = i;
6563 break;
6564 }
6565 }
6566
6567 a = array_set(array, 1, &index,
6568 datum,
6569 false,
6570 -1 /* varlena array */ ,
6571 -1 /* TEXT's typlen */ ,
6572 false /* TEXT's typbyval */ ,
6573 TYPALIGN_INT /* TEXT's typalign */ );
6574 }
6575 else
6576 a = construct_array_builtin(&datum, 1, TEXTOID);
6577
6578 return a;
6579}
ARR_NDIM
#define ARR_NDIM(a)
Definition: array.h:290
ARR_ELEMTYPE
#define ARR_ELEMTYPE(a)
Definition: array.h:292
ARR_DIMS
#define ARR_DIMS(a)
Definition: array.h:294
ARR_LBOUND
#define ARR_LBOUND(a)
Definition: array.h:296
array_set
ArrayType * array_set(ArrayType *array, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3163
array_ref
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:3146
construct_array_builtin
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3381
CStringGetTextDatum
#define CStringGetTextDatum(s)
Definition: builtins.h:97
TextDatumGetCString
#define TextDatumGetCString(d)
Definition: builtins.h:98
validate_option_array_item
static bool validate_option_array_item(const char *name, const char *value, bool skipIfNoPermissions)
Definition: guc.c:6730
a
int a
Definition: isn.c:73
Datum
uint64_t Datum
Definition: postgres.h:70
psprintf
char * psprintf(const char *fmt,...)
Definition: psprintf.c:43
index
Definition: type.h:96

References a, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), array_set(), Assert(), construct_array_builtin(), CStringGetTextDatum, 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,
const char *  name 
)

Definition at line 6588 of file guc.c.

6589{
6590 struct config_generic *record;
6591 ArrayType *newarray;
6592 int i;
6593 int index;
6594
6595 Assert(name);
6596
6597 /* test if the option is valid and we're allowed to set it */
6598 (void) validate_option_array_item(name, NULL, false);
6599
6600 /* normalize name (converts obsolete GUC names to modern spellings) */
6601 record = find_option(name, false, true, WARNING);
6602 if (record)
6603 name = record->name;
6604
6605 /* if array is currently null, then surely nothing to delete */
6606 if (!array)
6607 return NULL;
6608
6609 newarray = NULL;
6610 index = 1;
6611
6612 for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6613 {
6614 Datum d;
6615 char *val;
6616 bool isnull;
6617
6618 d = array_ref(array, 1, &i,
6619 -1 /* varlenarray */ ,
6620 -1 /* TEXT's typlen */ ,
6621 false /* TEXT's typbyval */ ,
6622 TYPALIGN_INT /* TEXT's typalign */ ,
6623 &isnull);
6624 if (isnull)
6625 continue;
6626 val = TextDatumGetCString(d);
6627
6628 /* ignore entry if it's what we want to delete */
6629 if (strncmp(val, name, strlen(name)) == 0
6630 && val[strlen(name)] == '=')
6631 continue;
6632
6633 /* else add it to the output array */
6634 if (newarray)
6635 newarray = array_set(newarray, 1, &index,
6636 d,
6637 false,
6638 -1 /* varlenarray */ ,
6639 -1 /* TEXT's typlen */ ,
6640 false /* TEXT's typbyval */ ,
6641 TYPALIGN_INT /* TEXT's typalign */ );
6642 else
6643 newarray = construct_array_builtin(&d, 1, TEXTOID);
6644
6645 index++;
6646 }
6647
6648 return newarray;
6649}
val
long val
Definition: informix.c:689

References ARR_DIMS, array_ref(), array_set(), Assert(), construct_array_builtin(), 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)

Definition at line 6658 of file guc.c.

6659{
6660 ArrayType *newarray;
6661 int i;
6662 int index;
6663
6664 /* if array is currently null, nothing to do */
6665 if (!array)
6666 return NULL;
6667
6668 /* if we're superuser, we can delete everything, so just do it */
6669 if (superuser())
6670 return NULL;
6671
6672 newarray = NULL;
6673 index = 1;
6674
6675 for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6676 {
6677 Datum d;
6678 char *val;
6679 char *eqsgn;
6680 bool isnull;
6681
6682 d = array_ref(array, 1, &i,
6683 -1 /* varlenarray */ ,
6684 -1 /* TEXT's typlen */ ,
6685 false /* TEXT's typbyval */ ,
6686 TYPALIGN_INT /* TEXT's typalign */ ,
6687 &isnull);
6688 if (isnull)
6689 continue;
6690 val = TextDatumGetCString(d);
6691
6692 eqsgn = strchr(val, '=');
6693 *eqsgn = '\0';
6694
6695 /* skip if we have permission to delete it */
6696 if (validate_option_array_item(val, NULL, true))
6697 continue;
6698
6699 /* else add it to the output array */
6700 if (newarray)
6701 newarray = array_set(newarray, 1, &index,
6702 d,
6703 false,
6704 -1 /* varlenarray */ ,
6705 -1 /* TEXT's typlen */ ,
6706 false /* TEXT's typbyval */ ,
6707 TYPALIGN_INT /* TEXT's typalign */ );
6708 else
6709 newarray = construct_array_builtin(&d, 1, TEXTOID);
6710
6711 index++;
6712 pfree(val);
6713 }
6714
6715 return newarray;
6716}

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

Referenced by AlterSetting().

◆ InitializeGUCOptions()

void InitializeGUCOptions ( void  )

Definition at line 1531 of file guc.c.

1532{
1533 HASH_SEQ_STATUS status;
1534 GUCHashEntry *hentry;
1535
1536 /*
1537 * Before log_line_prefix could possibly receive a nonempty setting, make
1538 * sure that timezone processing is minimally alive (see elog.c).
1539 */
1540 pg_timezone_initialize();
1541
1542 /*
1543 * Create GUCMemoryContext and build hash table of all GUC variables.
1544 */
1545 build_guc_variables();
1546
1547 /*
1548 * Load all variables with their compiled-in defaults, and initialize
1549 * status fields as needed.
1550 */
1551 hash_seq_init(&status, guc_hashtab);
1552 while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
1553 {
1554 /* Check mapping between initial and default value */
1555 Assert(check_GUC_init(hentry->gucvar));
1556
1557 InitializeOneGUCOption(hentry->gucvar);
1558 }
1559
1560 reporting_enabled = false;
1561
1562 /*
1563 * Prevent any attempt to override the transaction modes from
1564 * non-interactive sources.
1565 */
1566 SetConfigOption("transaction_isolation", "read committed",
1567 PGC_POSTMASTER, PGC_S_OVERRIDE);
1568 SetConfigOption("transaction_read_only", "no",
1569 PGC_POSTMASTER, PGC_S_OVERRIDE);
1570 SetConfigOption("transaction_deferrable", "no",
1571 PGC_POSTMASTER, PGC_S_OVERRIDE);
1572
1573 /*
1574 * For historical reasons, some GUC parameters can receive defaults from
1575 * environment variables. Process those settings.
1576 */
1577 InitializeGUCOptionsFromEnvironment();
1578}
InitializeOneGUCOption
static void InitializeOneGUCOption(struct config_generic *gconf)
Definition: guc.c:1645
build_guc_variables
void build_guc_variables(void)
Definition: guc.c:904
InitializeGUCOptionsFromEnvironment
static void InitializeGUCOptionsFromEnvironment(void)
Definition: guc.c:1590
pg_timezone_initialize
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, and SetConfigOption().

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

◆ MarkGUCPrefixReserved()

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

Definition at line 5301 of file guc.c.

5302{
5303 int classLen = strlen(className);
5304 HASH_SEQ_STATUS status;
5305 GUCHashEntry *hentry;
5306 MemoryContext oldcontext;
5307
5308 /*
5309 * Check for existing placeholders. We must actually remove invalid
5310 * placeholders, else future parallel worker startups will fail.
5311 */
5312 hash_seq_init(&status, guc_hashtab);
5313 while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5314 {
5315 struct config_generic *var = hentry->gucvar;
5316
5317 if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5318 strncmp(className, var->name, classLen) == 0 &&
5319 var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5320 {
5321 ereport(WARNING,
5322 (errcode(ERRCODE_INVALID_NAME),
5323 errmsg("invalid configuration parameter name \"%s\", removing it",
5324 var->name),
5325 errdetail("\"%s\" is now a reserved prefix.",
5326 className)));
5327 /* Remove it from the hash table */
5328 hash_search(guc_hashtab,
5329 &var->name,
5330 HASH_REMOVE,
5331 NULL);
5332 /* Remove it from any lists it's in, too */
5333 RemoveGUCFromLists(var);
5334 /* And free it */
5335 free_placeholder((struct config_string *) var);
5336 }
5337 }
5338
5339 /* And remember the name so we can prevent future mistakes. */
5340 oldcontext = MemoryContextSwitchTo(GUCMemoryContext);
5341 reserved_class_prefix = lappend(reserved_class_prefix, pstrdup(className));
5342 MemoryContextSwitchTo(oldcontext);
5343}
hash_search
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:952
RemoveGUCFromLists
static void RemoveGUCFromLists(struct config_generic *gconf)
Definition: guc.c:1762
free_placeholder
static void free_placeholder(struct config_string *pHolder)
Definition: guc.c:5139
reserved_class_prefix
static List * reserved_class_prefix
Definition: guc.c:78
GUC_QUALIFIER_SEPARATOR
#define GUC_QUALIFIER_SEPARATOR
Definition: guc.h:208
HASH_REMOVE
@ HASH_REMOVE
Definition: hsearch.h:115
lappend
List * lappend(List *list, void *datum)
Definition: list.c:339
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124

References ereport, errcode(), errdetail(), errmsg(), config_generic::flags, free_placeholder(), 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, and WARNING.

Referenced by _PG_init().

◆ NewGUCNestLevel()

int NewGUCNestLevel ( void  )

Definition at line 2240 of file guc.c.

2241{
2242 return ++GUCNestLevel;
2243}

References GUCNestLevel.

Referenced by amcheck_lock_relation_and_check(), applyRemoteGucs(), brin_summarize_range(), cluster_rel(), ComputeIndexAttrs(), CreateSchemaCommand(), DefineIndex(), do_analyze_rel(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), ProcedureCreate(), PushTransaction(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), RI_Initial_Check(), RI_PartitionRemove_Check(), set_transmission_modes(), SwitchToUntrustedUser(), vacuum_rel(), and validate_index().

◆ parse_int()

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

Definition at line 2876 of file guc.c.

2877{
2878 /*
2879 * We assume here that double is wide enough to represent any integer
2880 * value with adequate precision.
2881 */
2882 double val;
2883 char *endptr;
2884
2885 /* To suppress compiler warnings, always set output params */
2886 if (result)
2887 *result = 0;
2888 if (hintmsg)
2889 *hintmsg = NULL;
2890
2891 /*
2892 * Try to parse as an integer (allowing octal or hex input). If the
2893 * conversion stops at a decimal point or 'e', or overflows, re-parse as
2894 * float. This should work fine as long as we have no unit names starting
2895 * with 'e'. If we ever do, the test could be extended to check for a
2896 * sign or digit after 'e', but for now that's unnecessary.
2897 */
2898 errno = 0;
2899 val = strtol(value, &endptr, 0);
2900 if (*endptr == '.' || *endptr == 'e' || *endptr == 'E' ||
2901 errno == ERANGE)
2902 {
2903 errno = 0;
2904 val = strtod(value, &endptr);
2905 }
2906
2907 if (endptr == value || errno == ERANGE)
2908 return false; /* no HINT for these cases */
2909
2910 /* reject NaN (infinities will fail range check below) */
2911 if (isnan(val))
2912 return false; /* treat same as syntax error; no HINT */
2913
2914 /* allow whitespace between number and unit */
2915 while (isspace((unsigned char) *endptr))
2916 endptr++;
2917
2918 /* Handle possible unit */
2919 if (*endptr != '\0')
2920 {
2921 if ((flags & GUC_UNIT) == 0)
2922 return false; /* this setting does not accept a unit */
2923
2924 if (!convert_to_base_unit(val,
2925 endptr, (flags & GUC_UNIT),
2926 &val))
2927 {
2928 /* invalid unit, or garbage after the unit; set hint and fail. */
2929 if (hintmsg)
2930 {
2931 if (flags & GUC_UNIT_MEMORY)
2932 *hintmsg = memory_units_hint;
2933 else
2934 *hintmsg = time_units_hint;
2935 }
2936 return false;
2937 }
2938 }
2939
2940 /* Round to int, then check for overflow */
2941 val = rint(val);
2942
2943 if (val > INT_MAX || val < INT_MIN)
2944 {
2945 if (hintmsg)
2946 *hintmsg = gettext_noop("Value exceeds integer range.");
2947 return false;
2948 }
2949
2950 if (result)
2951 *result = (int) val;
2952 return true;
2953}
gettext_noop
#define gettext_noop(x)
Definition: c.h:1196
convert_to_base_unit
static bool convert_to_base_unit(double value, const char *unit, int base_unit, double *base_value)
Definition: guc.c:2676
memory_units_hint
static const char *const memory_units_hint
Definition: guc.c:119
time_units_hint
static const char *const time_units_hint
Definition: guc.c:156
GUC_UNIT_MEMORY
#define GUC_UNIT_MEMORY
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(), ExecVacuum(), 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 2966 of file guc.c.

2967{
2968 double val;
2969 char *endptr;
2970
2971 /* To suppress compiler warnings, always set output params */
2972 if (result)
2973 *result = 0;
2974 if (hintmsg)
2975 *hintmsg = NULL;
2976
2977 errno = 0;
2978 val = strtod(value, &endptr);
2979
2980 if (endptr == value || errno == ERANGE)
2981 return false; /* no HINT for these cases */
2982
2983 /* reject NaN (infinities will fail range checks later) */
2984 if (isnan(val))
2985 return false; /* treat same as syntax error; no HINT */
2986
2987 /* allow whitespace between number and unit */
2988 while (isspace((unsigned char) *endptr))
2989 endptr++;
2990
2991 /* Handle possible unit */
2992 if (*endptr != '\0')
2993 {
2994 if ((flags & GUC_UNIT) == 0)
2995 return false; /* this setting does not accept a unit */
2996
2997 if (!convert_to_base_unit(val,
2998 endptr, (flags & GUC_UNIT),
2999 &val))
3000 {
3001 /* invalid unit, or garbage after the unit; set hint and fail. */
3002 if (hintmsg)
3003 {
3004 if (flags & GUC_UNIT_MEMORY)
3005 *hintmsg = memory_units_hint;
3006 else
3007 *hintmsg = time_units_hint;
3008 }
3009 return false;
3010 }
3011 }
3012
3013 if (result)
3014 *result = val;
3015 return true;
3016}

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 
)

Definition at line 581 of file guc-file.l.

586{
587 char *err_msg;
588 char **filenames;
589 int num_filenames;
590
591 filenames = GetConfFilesInDir(includedir, calling_file, elevel,
592 &num_filenames, &err_msg);
593
594 if (!filenames)
595 {
596 record_config_file_error(err_msg, calling_file, calling_lineno, head_p,
597 tail_p);
598 return false;
599 }
600
601 for (int i = 0; i < num_filenames; i++)
602 {
603 if (!ParseConfigFile(filenames[i], true,
604 calling_file, calling_lineno,
605 depth, elevel,
606 head_p, tail_p))
607 return false;
608 }
609
610 return true;
611}
GetConfFilesInDir
char ** GetConfFilesInDir(const char *includedir, const char *calling_file, int elevel, int *num_filenames, char **err_msg)
Definition: conffiles.c:70
record_config_file_error
void record_config_file_error(const char *errmsg, const char *config_file, int lineno, ConfigVariable **head_p, ConfigVariable **tail_p)
Definition: guc-file.l:278
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)
Definition: guc-file.l:175

References GetConfFilesInDir(), i, ParseConfigFile(), and record_config_file_error().

Referenced by ParseConfigFp().

◆ 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 
)

Definition at line 175 of file guc-file.l.

180{
181 char *abs_path;
182 bool OK = true;
183 FILE *fp;
184
185 /*
186 * Reject file name that is all-blank (including empty), as that leads to
187 * confusion --- we'd try to read the containing directory as a file.
188 */
189 if (strspn(config_file, " \t\r\n") == strlen(config_file))
190 {
191 ereport(elevel,
192 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
193 errmsg("empty configuration file name: \"%s\"",
194 config_file)));
195 record_config_file_error("empty configuration file name",
196 calling_file, calling_lineno,
197 head_p, tail_p);
198 return false;
199 }
200
201 /*
202 * Reject too-deep include nesting depth. This is just a safety check to
203 * avoid dumping core due to stack overflow if an include file loops back
204 * to itself. The maximum nesting depth is pretty arbitrary.
205 */
206 if (depth > CONF_FILE_MAX_DEPTH)
207 {
208 ereport(elevel,
209 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
210 errmsg("could not open configuration file \"%s\": maximum nesting depth exceeded",
211 config_file)));
212 record_config_file_error("nesting depth exceeded",
213 calling_file, calling_lineno,
214 head_p, tail_p);
215 return false;
216 }
217
218 abs_path = AbsoluteConfigLocation(config_file, calling_file);
219
220 /*
221 * Reject direct recursion. Indirect recursion is also possible, but it's
222 * harder to detect and so doesn't seem worth the trouble. (We test at
223 * this step because the canonicalization done by AbsoluteConfigLocation
224 * makes it more likely that a simple strcmp comparison will match.)
225 */
226 if (calling_file && strcmp(abs_path, calling_file) == 0)
227 {
228 ereport(elevel,
229 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
230 errmsg("configuration file recursion in \"%s\"",
231 calling_file)));
232 record_config_file_error("configuration file recursion",
233 calling_file, calling_lineno,
234 head_p, tail_p);
235 pfree(abs_path);
236 return false;
237 }
238
239 fp = AllocateFile(abs_path, "r");
240 if (!fp)
241 {
242 if (strict)
243 {
244 ereport(elevel,
245 (errcode_for_file_access(),
246 errmsg("could not open configuration file \"%s\": %m",
247 abs_path)));
248 record_config_file_error(psprintf("could not open file \"%s\"",
249 abs_path),
250 calling_file, calling_lineno,
251 head_p, tail_p);
252 OK = false;
253 }
254 else
255 {
256 ereport(LOG,
257 (errmsg("skipping missing configuration file \"%s\"",
258 abs_path)));
259 }
260 goto cleanup;
261 }
262
263 OK = ParseConfigFp(fp, abs_path, depth, elevel, head_p, tail_p);
264
265cleanup:
266 if (fp)
267 FreeFile(fp);
268 pfree(abs_path);
269
270 return OK;
271}
cleanup
static void cleanup(void)
Definition: bootstrap.c:715
AbsoluteConfigLocation
char * AbsoluteConfigLocation(const char *location, const char *calling_file)
Definition: conffiles.c:36
CONF_FILE_MAX_DEPTH
#define CONF_FILE_MAX_DEPTH
Definition: conffiles.h:18
config_file
static char * config_file
Definition: pg_rewind.c:71

References AbsoluteConfigLocation(), AllocateFile(), cleanup(), CONF_FILE_MAX_DEPTH, config_file, ereport, errcode(), errcode_for_file_access(), errmsg(), FreeFile(), LOG, ParseConfigFp(), pfree(), psprintf(), and record_config_file_error().

Referenced by ParseConfigDirectory(), ParseConfigFp(), and ProcessConfigFileInternal().

◆ ParseConfigFp()

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

Definition at line 350 of file guc-file.l.

352{
353 volatile bool OK = true;
354 unsigned int save_ConfigFileLineno = ConfigFileLineno;
355 sigjmp_buf *save_GUC_flex_fatal_jmp = GUC_flex_fatal_jmp;
356 sigjmp_buf flex_fatal_jmp;
357 yyscan_t scanner;
358 struct yyguts_t *yyg; /* needed for yytext macro */
359 volatile YY_BUFFER_STATE lex_buffer = NULL;
360 int errorcount;
361 int token;
362
363 if (sigsetjmp(flex_fatal_jmp, 1) == 0)
364 GUC_flex_fatal_jmp = &flex_fatal_jmp;
365 else
366 {
367 /*
368 * Regain control after a fatal, internal flex error. It may have
369 * corrupted parser state. Consequently, abandon the file, but trust
370 * that the state remains sane enough for yy_delete_buffer().
371 */
372 elog(elevel, "%s at file \"%s\" line %u",
373 GUC_flex_fatal_errmsg, config_file, ConfigFileLineno);
374 record_config_file_error(GUC_flex_fatal_errmsg,
375 config_file, ConfigFileLineno,
376 head_p, tail_p);
377 OK = false;
378 goto cleanup;
379 }
380
381 /*
382 * Parse
383 */
384 ConfigFileLineno = 1;
385 errorcount = 0;
386
387 if (yylex_init(&scanner) != 0)
388 elog(elevel, "yylex_init() failed: %m");
389 yyg = (struct yyguts_t *) scanner;
390
391 lex_buffer = yy_create_buffer(fp, YY_BUF_SIZE, scanner);
392 yy_switch_to_buffer(lex_buffer, scanner);
393
394 /* This loop iterates once per logical line */
395 while ((token = yylex(scanner)))
396 {
397 char *opt_name = NULL;
398 char *opt_value = NULL;
399 ConfigVariable *item;
400
401 if (token == GUC_EOL) /* empty or comment line */
402 continue;
403
404 /* first token on line is option name */
405 if (token != GUC_ID && token != GUC_QUALIFIED_ID)
406 goto parse_error;
407 opt_name = pstrdup(yytext);
408
409 /* next we have an optional equal sign; discard if present */
410 token = yylex(scanner);
411 if (token == GUC_EQUALS)
412 token = yylex(scanner);
413
414 /* now we must have the option value */
415 if (token != GUC_ID &&
416 token != GUC_STRING &&
417 token != GUC_INTEGER &&
418 token != GUC_REAL &&
419 token != GUC_UNQUOTED_STRING)
420 goto parse_error;
421 if (token == GUC_STRING) /* strip quotes and escapes */
422 opt_value = DeescapeQuotedString(yytext);
423 else
424 opt_value = pstrdup(yytext);
425
426 /* now we'd like an end of line, or possibly EOF */
427 token = yylex(scanner);
428 if (token != GUC_EOL)
429 {
430 if (token != 0)
431 goto parse_error;
432 /* treat EOF like \n for line numbering purposes, cf bug 4752 */
433 ConfigFileLineno++;
434 }
435
436 /* OK, process the option name and value */
437 if (guc_name_compare(opt_name, "include_dir") == 0)
438 {
439 /*
440 * An include_dir directive isn't a variable and should be
441 * processed immediately.
442 */
443 if (!ParseConfigDirectory(opt_value,
444 config_file, ConfigFileLineno - 1,
445 depth + 1, elevel,
446 head_p, tail_p))
447 OK = false;
448 yy_switch_to_buffer(lex_buffer, scanner);
449 pfree(opt_name);
450 pfree(opt_value);
451 }
452 else if (guc_name_compare(opt_name, "include_if_exists") == 0)
453 {
454 /*
455 * An include_if_exists directive isn't a variable and should be
456 * processed immediately.
457 */
458 if (!ParseConfigFile(opt_value, false,
459 config_file, ConfigFileLineno - 1,
460 depth + 1, elevel,
461 head_p, tail_p))
462 OK = false;
463 yy_switch_to_buffer(lex_buffer, scanner);
464 pfree(opt_name);
465 pfree(opt_value);
466 }
467 else if (guc_name_compare(opt_name, "include") == 0)
468 {
469 /*
470 * An include directive isn't a variable and should be processed
471 * immediately.
472 */
473 if (!ParseConfigFile(opt_value, true,
474 config_file, ConfigFileLineno - 1,
475 depth + 1, elevel,
476 head_p, tail_p))
477 OK = false;
478 yy_switch_to_buffer(lex_buffer, scanner);
479 pfree(opt_name);
480 pfree(opt_value);
481 }
482 else
483 {
484 /* ordinary variable, append to list */
485 item = palloc(sizeof *item);
486 item->name = opt_name;
487 item->value = opt_value;
488 item->errmsg = NULL;
489 item->filename = pstrdup(config_file);
490 item->sourceline = ConfigFileLineno - 1;
491 item->ignore = false;
492 item->applied = false;
493 item->next = NULL;
494 if (*head_p == NULL)
495 *head_p = item;
496 else
497 (*tail_p)->next = item;
498 *tail_p = item;
499 }
500
501 /* break out of loop if read EOF, else loop for next line */
502 if (token == 0)
503 break;
504 continue;
505
506parse_error:
507 /* release storage if we allocated any on this line */
508 if (opt_name)
509 pfree(opt_name);
510 if (opt_value)
511 pfree(opt_value);
512
513 /* report the error */
514 if (token == GUC_EOL || token == 0)
515 {
516 ereport(elevel,
517 (errcode(ERRCODE_SYNTAX_ERROR),
518 errmsg("syntax error in file \"%s\" line %u, near end of line",
519 config_file, ConfigFileLineno - 1)));
520 record_config_file_error("syntax error",
521 config_file, ConfigFileLineno - 1,
522 head_p, tail_p);
523 }
524 else
525 {
526 ereport(elevel,
527 (errcode(ERRCODE_SYNTAX_ERROR),
528 errmsg("syntax error in file \"%s\" line %u, near token \"%s\"",
529 config_file, ConfigFileLineno, yytext)));
530 record_config_file_error("syntax error",
531 config_file, ConfigFileLineno,
532 head_p, tail_p);
533 }
534 OK = false;
535 errorcount++;
536
537 /*
538 * To avoid producing too much noise when fed a totally bogus file,
539 * give up after 100 syntax errors per file (an arbitrary number).
540 * Also, if we're only logging the errors at DEBUG level anyway, might
541 * as well give up immediately. (This prevents postmaster children
542 * from bloating the logs with duplicate complaints.)
543 */
544 if (errorcount >= 100 || elevel <= DEBUG1)
545 {
546 ereport(elevel,
547 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
548 errmsg("too many syntax errors found, abandoning file \"%s\"",
549 config_file)));
550 break;
551 }
552
553 /* resync to next end-of-line or EOF */
554 while (token != GUC_EOL && token != 0)
555 token = yylex(scanner);
556 /* break out of loop on EOF */
557 if (token == 0)
558 break;
559 }
560
561cleanup:
562 yy_delete_buffer(lex_buffer, scanner);
563 yylex_destroy(scanner);
564 /* Each recursion level must save and restore these static variables. */
565 ConfigFileLineno = save_ConfigFileLineno;
566 GUC_flex_fatal_jmp = save_GUC_flex_fatal_jmp;
567 return OK;
568}
yyscan_t
void * yyscan_t
Definition: cubedata.h:65
DEBUG1
#define DEBUG1
Definition: elog.h:30
GUC_flex_fatal_jmp
static sigjmp_buf * GUC_flex_fatal_jmp
Definition: guc-file.l:50
yylex
int yylex(yyscan_t yyscanner)
Definition: guc-file.l:91
ConfigFileLineno
static unsigned int ConfigFileLineno
Definition: guc-file.l:48
GUC_STRING
@ GUC_STRING
Definition: guc-file.l:38
GUC_UNQUOTED_STRING
@ GUC_UNQUOTED_STRING
Definition: guc-file.l:42
GUC_INTEGER
@ GUC_INTEGER
Definition: guc-file.l:39
GUC_QUALIFIED_ID
@ GUC_QUALIFIED_ID
Definition: guc-file.l:43
GUC_REAL
@ GUC_REAL
Definition: guc-file.l:40
GUC_ID
@ GUC_ID
Definition: guc-file.l:37
GUC_EOL
@ GUC_EOL
Definition: guc-file.l:44
GUC_EQUALS
@ GUC_EQUALS
Definition: guc-file.l:41
GUC_flex_fatal_errmsg
static const char * GUC_flex_fatal_errmsg
Definition: guc-file.l:49
DeescapeQuotedString
char * DeescapeQuotedString(const char *s)
Definition: guc-file.l:661
ParseConfigDirectory
bool ParseConfigDirectory(const char *includedir, const char *calling_file, int calling_lineno, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
Definition: guc-file.l:581
token
#define token
Definition: indent_globs.h:126
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: psqlscan_int.h:54
ConfigVariable::name
char * name
Definition: guc.h:141
ConfigVariable::ignore
bool ignore
Definition: guc.h:146
ConfigVariable::applied
bool applied
Definition: guc.h:147
ConfigVariable::filename
char * filename
Definition: guc.h:144
ConfigVariable::sourceline
int sourceline
Definition: guc.h:145
ConfigVariable::value
char * value
Definition: guc.h:142
ConfigVariable::errmsg
char * errmsg
Definition: guc.h:143
yyguts_t
Definition: pl_scanner.c:141

References ConfigVariable::applied, cleanup(), config_file, ConfigFileLineno, DEBUG1, DeescapeQuotedString(), elog, ereport, errcode(), errmsg(), ConfigVariable::errmsg, ConfigVariable::filename, GUC_EOL, GUC_EQUALS, GUC_flex_fatal_errmsg, GUC_flex_fatal_jmp, GUC_ID, GUC_INTEGER, guc_name_compare(), GUC_QUALIFIED_ID, GUC_REAL, GUC_STRING, GUC_UNQUOTED_STRING, ConfigVariable::ignore, ConfigVariable::name, ConfigVariable::next, palloc(), ParseConfigDirectory(), ParseConfigFile(), pfree(), pstrdup(), record_config_file_error(), ConfigVariable::sourceline, token, ConfigVariable::value, and yylex().

Referenced by AlterSystemSetConfigFile(), parse_extension_control_file(), and ParseConfigFile().

◆ ParseLongOption()

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

Definition at line 6384 of file guc.c.

6385{
6386 size_t equal_pos;
6387 char *cp;
6388
6389 Assert(string);
6390 Assert(name);
6391 Assert(value);
6392
6393 equal_pos = strcspn(string, "=");
6394
6395 if (string[equal_pos] == '=')
6396 {
6397 *name = palloc(equal_pos + 1);
6398 strlcpy(*name, string, equal_pos + 1);
6399
6400 *value = pstrdup(&string[equal_pos + 1]);
6401 }
6402 else
6403 {
6404 /* no equal sign in string */
6405 *name = pstrdup(string);
6406 *value = NULL;
6407 }
6408
6409 for (cp = *name; *cp; cp++)
6410 if (*cp == '-')
6411 *cp = '_';
6412}
strlcpy
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 TransformGUCArray().

◆ ProcessConfigFile()

void ProcessConfigFile ( GucContext  context)

Definition at line 120 of file guc-file.l.

121{
122 int elevel;
123 MemoryContext config_cxt;
124 MemoryContext caller_cxt;
125
126 /*
127 * Config files are processed on startup (by the postmaster only) and on
128 * SIGHUP (by the postmaster and its children)
129 */
130 Assert((context == PGC_POSTMASTER && !IsUnderPostmaster) ||
131 context == PGC_SIGHUP);
132
133 /*
134 * To avoid cluttering the log, only the postmaster bleats loudly about
135 * problems with the config file.
136 */
137 elevel = IsUnderPostmaster ? DEBUG2 : LOG;
138
139 /*
140 * This function is usually called within a process-lifespan memory
141 * context. To ensure that any memory leaked during GUC processing does
142 * not accumulate across repeated SIGHUP cycles, do the work in a private
143 * context that we can free at exit.
144 */
145 config_cxt = AllocSetContextCreate(CurrentMemoryContext,
146 "config file processing",
147 ALLOCSET_DEFAULT_SIZES);
148 caller_cxt = MemoryContextSwitchTo(config_cxt);
149
150 /*
151 * Read and apply the config file. We don't need to examine the result.
152 */
153 (void) ProcessConfigFileInternal(context, true, elevel);
154
155 /* Clean up */
156 MemoryContextSwitchTo(caller_cxt);
157 MemoryContextDelete(config_cxt);
158}
DEBUG2
#define DEBUG2
Definition: elog.h:29
IsUnderPostmaster
bool IsUnderPostmaster
Definition: globals.c:120
ProcessConfigFileInternal
ConfigVariable * ProcessConfigFileInternal(GucContext context, bool applySettings, int elevel)
Definition: guc.c:283
CurrentMemoryContext
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
MemoryContextDelete
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:469
AllocSetContextCreate
#define AllocSetContextCreate
Definition: memutils.h:129
ALLOCSET_DEFAULT_SIZES
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), CurrentMemoryContext, DEBUG2, IsUnderPostmaster, LOG, MemoryContextDelete(), MemoryContextSwitchTo(), PGC_POSTMASTER, PGC_SIGHUP, and ProcessConfigFileInternal().

Referenced by ApplyLauncherMain(), autoprewarm_main(), CheckpointWriteDelay(), do_autovacuum(), IoWorkerMain(), LogicalRepApplyLoop(), PostgresMain(), process_pm_reload_request(), ProcessAutoVacLauncherInterrupts(), ProcessCheckpointerInterrupts(), ProcessMainLoopInterrupts(), ProcessParallelApplyInterrupts(), ProcessPendingWrites(), ProcessPgArchInterrupts(), ProcessWalSummarizerInterrupts(), SelectConfigFiles(), slotsync_reread_config(), StartupRereadConfig(), SysLoggerMain(), vacuum_delay_point(), WaitForStandbyConfirmation(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), and worker_spi_main().

◆ ProcessGUCArray()

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

Definition at line 6478 of file guc.c.

6480{
6481 List *gucNames;
6482 List *gucValues;
6483 ListCell *lc1;
6484 ListCell *lc2;
6485
6486 TransformGUCArray(array, &gucNames, &gucValues);
6487 forboth(lc1, gucNames, lc2, gucValues)
6488 {
6489 char *name = lfirst(lc1);
6490 char *value = lfirst(lc2);
6491
6492 (void) set_config_option(name, value,
6493 context, source,
6494 action, true, 0, false);
6495
6496 pfree(name);
6497 pfree(value);
6498 }
6499
6500 list_free(gucNames);
6501 list_free(gucValues);
6502}
TransformGUCArray
void TransformGUCArray(ArrayType *array, List **names, List **values)
Definition: guc.c:6421
list_free
void list_free(List *list)
Definition: list.c:1546
forboth
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:518
source
static rewind_source * source
Definition: pg_rewind.c:89
List
Definition: pg_list.h:54

References generate_unaccent_rules::action, forboth, lfirst, list_free(), name, pfree(), set_config_option(), source, TransformGUCArray(), and value.

Referenced by ApplySetting(), and ProcedureCreate().

◆ ReportChangedGUCOptions()

void ReportChangedGUCOptions ( void  )

Definition at line 2601 of file guc.c.

2602{
2603 slist_mutable_iter iter;
2604
2605 /* Quick exit if not (yet) enabled */
2606 if (!reporting_enabled)
2607 return;
2608
2609 /*
2610 * Since in_hot_standby isn't actually changed by normal GUC actions, we
2611 * need a hack to check whether a new value needs to be reported to the
2612 * client. For speed, we rely on the assumption that it can never
2613 * transition from false to true.
2614 */
2615 if (in_hot_standby_guc && !RecoveryInProgress())
2616 SetConfigOption("in_hot_standby", "false",
2617 PGC_INTERNAL, PGC_S_OVERRIDE);
2618
2619 /* Transmit new values of interesting variables */
2620 slist_foreach_modify(iter, &guc_report_list)
2621 {
2622 struct config_generic *conf = slist_container(struct config_generic,
2623 report_link, iter.cur);
2624
2625 Assert((conf->flags & GUC_REPORT) && (conf->status & GUC_NEEDS_REPORT));
2626 ReportGUCOption(conf);
2627 conf->status &= ~GUC_NEEDS_REPORT;
2628 slist_delete_current(&iter);
2629 }
2630}
in_hot_standby_guc
bool in_hot_standby_guc
Definition: guc_tables.c:640

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 2008 of file guc.c.

2009{
2010 dlist_mutable_iter iter;
2011
2012 /* We need only consider GUCs not already at PGC_S_DEFAULT */
2013 dlist_foreach_modify(iter, &guc_nondef_list)
2014 {
2015 struct config_generic *gconf = dlist_container(struct config_generic,
2016 nondef_link, iter.cur);
2017
2018 /* Don't reset non-SET-able values */
2019 if (gconf->context != PGC_SUSET &&
2020 gconf->context != PGC_USERSET)
2021 continue;
2022 /* Don't reset if special exclusion from RESET ALL */
2023 if (gconf->flags & GUC_NO_RESET_ALL)
2024 continue;
2025 /* No need to reset if wasn't SET */
2026 if (gconf->source <= PGC_S_OVERRIDE)
2027 continue;
2028
2029 /* Save old value to support transaction abort */
2030 push_old_value(gconf, GUC_ACTION_SET);
2031
2032 switch (gconf->vartype)
2033 {
2034 case PGC_BOOL:
2035 {
2036 struct config_bool *conf = (struct config_bool *) gconf;
2037
2038 if (conf->assign_hook)
2039 conf->assign_hook(conf->reset_val,
2040 conf->reset_extra);
2041 *conf->variable = conf->reset_val;
2042 set_extra_field(&conf->gen, &conf->gen.extra,
2043 conf->reset_extra);
2044 break;
2045 }
2046 case PGC_INT:
2047 {
2048 struct config_int *conf = (struct config_int *) gconf;
2049
2050 if (conf->assign_hook)
2051 conf->assign_hook(conf->reset_val,
2052 conf->reset_extra);
2053 *conf->variable = conf->reset_val;
2054 set_extra_field(&conf->gen, &conf->gen.extra,
2055 conf->reset_extra);
2056 break;
2057 }
2058 case PGC_REAL:
2059 {
2060 struct config_real *conf = (struct config_real *) gconf;
2061
2062 if (conf->assign_hook)
2063 conf->assign_hook(conf->reset_val,
2064 conf->reset_extra);
2065 *conf->variable = conf->reset_val;
2066 set_extra_field(&conf->gen, &conf->gen.extra,
2067 conf->reset_extra);
2068 break;
2069 }
2070 case PGC_STRING:
2071 {
2072 struct config_string *conf = (struct config_string *) gconf;
2073
2074 if (conf->assign_hook)
2075 conf->assign_hook(conf->reset_val,
2076 conf->reset_extra);
2077 set_string_field(conf, conf->variable, conf->reset_val);
2078 set_extra_field(&conf->gen, &conf->gen.extra,
2079 conf->reset_extra);
2080 break;
2081 }
2082 case PGC_ENUM:
2083 {
2084 struct config_enum *conf = (struct config_enum *) gconf;
2085
2086 if (conf->assign_hook)
2087 conf->assign_hook(conf->reset_val,
2088 conf->reset_extra);
2089 *conf->variable = conf->reset_val;
2090 set_extra_field(&conf->gen, &conf->gen.extra,
2091 conf->reset_extra);
2092 break;
2093 }
2094 }
2095
2096 set_guc_source(gconf, gconf->reset_source);
2097 gconf->scontext = gconf->reset_scontext;
2098 gconf->srole = gconf->reset_srole;
2099
2100 if ((gconf->flags & GUC_REPORT) && !(gconf->status & GUC_NEEDS_REPORT))
2101 {
2102 gconf->status |= GUC_NEEDS_REPORT;
2103 slist_push_head(&guc_report_list, &gconf->report_link);
2104 }
2105 }
2106}
push_old_value
static void push_old_value(struct config_generic *gconf, GucAction action)
Definition: guc.c:2139
GUC_NO_RESET_ALL
#define GUC_NO_RESET_ALL
Definition: guc.h:218
dlist_foreach_modify
#define dlist_foreach_modify(iter, lhead)
Definition: ilist.h:640
config_bool::reset_extra
void * reset_extra
Definition: guc_tables.h:227
config_bool::reset_val
bool reset_val
Definition: guc_tables.h:226
config_enum::reset_val
int reset_val
Definition: guc_tables.h:297
config_enum::reset_extra
void * reset_extra
Definition: guc_tables.h:298
config_generic::reset_scontext
GucContext reset_scontext
Definition: guc_tables.h:186
config_generic::reset_srole
Oid reset_srole
Definition: guc_tables.h:188
config_generic::source
GucSource source
Definition: guc_tables.h:183
config_generic::reset_source
GucSource reset_source
Definition: guc_tables.h:184
config_int::reset_extra
void * reset_extra
Definition: guc_tables.h:243
config_int::reset_val
int reset_val
Definition: guc_tables.h:242
config_real::reset_extra
void * reset_extra
Definition: guc_tables.h:259
config_real::reset_val
double reset_val
Definition: guc_tables.h:258
config_string::reset_extra
void * reset_extra
Definition: guc_tables.h:283
dlist_mutable_iter
Definition: ilist.h:199
dlist_mutable_iter::cur
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 6215 of file guc.c.

6216{
6217 char *varname,
6218 *varvalue,
6219 *varsourcefile;
6220 int varsourceline;
6221 GucSource varsource;
6222 GucContext varscontext;
6223 Oid varsrole;
6224 char *srcptr = (char *) gucstate;
6225 char *srcend;
6226 Size len;
6227 dlist_mutable_iter iter;
6228 ErrorContextCallback error_context_callback;
6229
6230 /*
6231 * First, ensure that all potentially-shippable GUCs are reset to their
6232 * default values. We must not touch those GUCs that the leader will
6233 * never ship, while there is no need to touch those that are shippable
6234 * but already have their default values. Thus, this ends up being the
6235 * same test that SerializeGUCState uses, even though the sets of
6236 * variables involved may well be different since the leader's set of
6237 * variables-not-at-default-values can differ from the set that are
6238 * not-default in this freshly started worker.
6239 *
6240 * Once we have set all the potentially-shippable GUCs to default values,
6241 * restoring the GUCs that the leader sent (because they had non-default
6242 * values over there) leads us to exactly the set of GUC values that the
6243 * leader has. This is true even though the worker may have initially
6244 * absorbed postgresql.conf settings that the leader hasn't yet seen, or
6245 * ALTER USER/DATABASE SET settings that were established after the leader
6246 * started.
6247 *
6248 * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
6249 * also ensures that set_config_option won't refuse to set them because of
6250 * source-priority comparisons.
6251 */
6252 dlist_foreach_modify(iter, &guc_nondef_list)
6253 {
6254 struct config_generic *gconf = dlist_container(struct config_generic,
6255 nondef_link, iter.cur);
6256
6257 /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
6258 if (can_skip_gucvar(gconf))
6259 continue;
6260
6261 /*
6262 * We can use InitializeOneGUCOption to reset the GUC to default, but
6263 * first we must free any existing subsidiary data to avoid leaking
6264 * memory. The stack must be empty, but we have to clean up all other
6265 * fields. Beware that there might be duplicate value or "extra"
6266 * pointers. We also have to be sure to take it out of any lists it's
6267 * in.
6268 */
6269 Assert(gconf->stack == NULL);
6270 guc_free(gconf->extra);
6271 guc_free(gconf->last_reported);
6272 guc_free(gconf->sourcefile);
6273 switch (gconf->vartype)
6274 {
6275 case PGC_BOOL:
6276 {
6277 struct config_bool *conf = (struct config_bool *) gconf;
6278
6279 if (conf->reset_extra && conf->reset_extra != gconf->extra)
6280 guc_free(conf->reset_extra);
6281 break;
6282 }
6283 case PGC_INT:
6284 {
6285 struct config_int *conf = (struct config_int *) gconf;
6286
6287 if (conf->reset_extra && conf->reset_extra != gconf->extra)
6288 guc_free(conf->reset_extra);
6289 break;
6290 }
6291 case PGC_REAL:
6292 {
6293 struct config_real *conf = (struct config_real *) gconf;
6294
6295 if (conf->reset_extra && conf->reset_extra != gconf->extra)
6296 guc_free(conf->reset_extra);
6297 break;
6298 }
6299 case PGC_STRING:
6300 {
6301 struct config_string *conf = (struct config_string *) gconf;
6302
6303 guc_free(*conf->variable);
6304 if (conf->reset_val && conf->reset_val != *conf->variable)
6305 guc_free(conf->reset_val);
6306 if (conf->reset_extra && conf->reset_extra != gconf->extra)
6307 guc_free(conf->reset_extra);
6308 break;
6309 }
6310 case PGC_ENUM:
6311 {
6312 struct config_enum *conf = (struct config_enum *) gconf;
6313
6314 if (conf->reset_extra && conf->reset_extra != gconf->extra)
6315 guc_free(conf->reset_extra);
6316 break;
6317 }
6318 }
6319 /* Remove it from any lists it's in. */
6320 RemoveGUCFromLists(gconf);
6321 /* Now we can reset the struct to PGS_S_DEFAULT state. */
6322 InitializeOneGUCOption(gconf);
6323 }
6324
6325 /* First item is the length of the subsequent data */
6326 memcpy(&len, gucstate, sizeof(len));
6327
6328 srcptr += sizeof(len);
6329 srcend = srcptr + len;
6330
6331 /* If the GUC value check fails, we want errors to show useful context. */
6332 error_context_callback.callback = guc_restore_error_context_callback;
6333 error_context_callback.previous = error_context_stack;
6334 error_context_callback.arg = NULL;
6335 error_context_stack = &error_context_callback;
6336
6337 /* Restore all the listed GUCs. */
6338 while (srcptr < srcend)
6339 {
6340 int result;
6341 char *error_context_name_and_value[2];
6342
6343 varname = read_gucstate(&srcptr, srcend);
6344 varvalue = read_gucstate(&srcptr, srcend);
6345 varsourcefile = read_gucstate(&srcptr, srcend);
6346 if (varsourcefile[0])
6347 read_gucstate_binary(&srcptr, srcend,
6348 &varsourceline, sizeof(varsourceline));
6349 else
6350 varsourceline = 0;
6351 read_gucstate_binary(&srcptr, srcend,
6352 &varsource, sizeof(varsource));
6353 read_gucstate_binary(&srcptr, srcend,
6354 &varscontext, sizeof(varscontext));
6355 read_gucstate_binary(&srcptr, srcend,
6356 &varsrole, sizeof(varsrole));
6357
6358 error_context_name_and_value[0] = varname;
6359 error_context_name_and_value[1] = varvalue;
6360 error_context_callback.arg = &error_context_name_and_value[0];
6361 result = set_config_option_ext(varname, varvalue,
6362 varscontext, varsource, varsrole,
6363 GUC_ACTION_SET, true, ERROR, true);
6364 if (result <= 0)
6365 ereport(ERROR,
6366 (errcode(ERRCODE_INTERNAL_ERROR),
6367 errmsg("parameter \"%s\" could not be set", varname)));
6368 if (varsourcefile[0])
6369 set_config_sourcefile(varname, varsourcefile, varsourceline);
6370 error_context_callback.arg = NULL;
6371 }
6372
6373 error_context_stack = error_context_callback.previous;
6374}
error_context_stack
ErrorContextCallback * error_context_stack
Definition: elog.c:95
guc_restore_error_context_callback
static void guc_restore_error_context_callback(void *arg)
Definition: guc.c:6193
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: guc.c:3387
set_config_sourcefile
static void set_config_sourcefile(const char *name, char *sourcefile, int sourceline)
Definition: guc.c:4304
can_skip_gucvar
static bool can_skip_gucvar(struct config_generic *gconf)
Definition: guc.c:5836
read_gucstate_binary
static void read_gucstate_binary(char **srcptr, char *srcend, void *dest, Size size)
Definition: guc.c:6179
read_gucstate
static char * read_gucstate(char **srcptr, char *srcend)
Definition: guc.c:6156
ErrorContextCallback::previous
struct ErrorContextCallback * previous
Definition: elog.h:297
ErrorContextCallback::callback
void(* callback)(void *arg)
Definition: elog.h:298
config_generic::last_reported
char * last_reported
Definition: guc_tables.h:197
config_generic::sourcefile
char * sourcefile
Definition: guc_tables.h:199

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().

◆ RestrictSearchPath()

void RestrictSearchPath ( void  )

Definition at line 2251 of file guc.c.

2252{
2253 if (!IsBootstrapProcessingMode())
2254 set_config_option("search_path", GUC_SAFE_SEARCH_PATH, PGC_USERSET,
2255 PGC_S_SESSION, GUC_ACTION_SAVE, true, 0, false);
2256}
GUC_SAFE_SEARCH_PATH
#define GUC_SAFE_SEARCH_PATH
Definition: guc.c:74
IsBootstrapProcessingMode
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:476

References GUC_ACTION_SAVE, GUC_SAFE_SEARCH_PATH, IsBootstrapProcessingMode, PGC_S_SESSION, PGC_USERSET, and set_config_option().

Referenced by brin_summarize_range(), cluster_rel(), ComputeIndexAttrs(), DefineIndex(), do_analyze_rel(), index_build(), index_concurrently_build(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), vacuum_rel(), and validate_index().

◆ SelectConfigFiles()

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

Definition at line 1785 of file guc.c.

1786{
1787 char *configdir;
1788 char *fname;
1789 bool fname_is_malloced;
1790 struct stat stat_buf;
1791 struct config_string *data_directory_rec;
1792
1793 /* configdir is -D option, or $PGDATA if no -D */
1794 if (userDoption)
1795 configdir = make_absolute_path(userDoption);
1796 else
1797 configdir = make_absolute_path(getenv("PGDATA"));
1798
1799 if (configdir && stat(configdir, &stat_buf) != 0)
1800 {
1801 write_stderr("%s: could not access directory \"%s\": %m\n",
1802 progname,
1803 configdir);
1804 if (errno == ENOENT)
1805 write_stderr("Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n");
1806 goto fail;
1807 }
1808
1809 /*
1810 * Find the configuration file: if config_file was specified on the
1811 * command line, use it, else use configdir/postgresql.conf. In any case
1812 * ensure the result is an absolute path, so that it will be interpreted
1813 * the same way by future backends.
1814 */
1815 if (ConfigFileName)
1816 {
1817 fname = make_absolute_path(ConfigFileName);
1818 fname_is_malloced = true;
1819 }
1820 else if (configdir)
1821 {
1822 fname = guc_malloc(FATAL,
1823 strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
1824 sprintf(fname, "%s/%s", configdir, CONFIG_FILENAME);
1825 fname_is_malloced = false;
1826 }
1827 else
1828 {
1829 write_stderr("%s does not know where to find the server configuration file.\n"
1830 "You must specify the --config-file or -D invocation "
1831 "option or set the PGDATA environment variable.\n",
1832 progname);
1833 goto fail;
1834 }
1835
1836 /*
1837 * Set the ConfigFileName GUC variable to its final value, ensuring that
1838 * it can't be overridden later.
1839 */
1840 SetConfigOption("config_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1841
1842 if (fname_is_malloced)
1843 free(fname);
1844 else
1845 guc_free(fname);
1846
1847 /*
1848 * Now read the config file for the first time.
1849 */
1850 if (stat(ConfigFileName, &stat_buf) != 0)
1851 {
1852 write_stderr("%s: could not access the server configuration file \"%s\": %m\n",
1853 progname, ConfigFileName);
1854 goto fail;
1855 }
1856
1857 /*
1858 * Read the configuration file for the first time. This time only the
1859 * data_directory parameter is picked up to determine the data directory,
1860 * so that we can read the PG_AUTOCONF_FILENAME file next time.
1861 */
1862 ProcessConfigFile(PGC_POSTMASTER);
1863
1864 /*
1865 * If the data_directory GUC variable has been set, use that as DataDir;
1866 * otherwise use configdir if set; else punt.
1867 *
1868 * Note: SetDataDir will copy and absolute-ize its argument, so we don't
1869 * have to.
1870 */
1871 data_directory_rec = (struct config_string *)
1872 find_option("data_directory", false, false, PANIC);
1873 if (*data_directory_rec->variable)
1874 SetDataDir(*data_directory_rec->variable);
1875 else if (configdir)
1876 SetDataDir(configdir);
1877 else
1878 {
1879 write_stderr("%s does not know where to find the database system data.\n"
1880 "This can be specified as \"data_directory\" in \"%s\", "
1881 "or by the -D invocation option, or by the "
1882 "PGDATA environment variable.\n",
1883 progname, ConfigFileName);
1884 goto fail;
1885 }
1886
1887 /*
1888 * Reflect the final DataDir value back into the data_directory GUC var.
1889 * (If you are wondering why we don't just make them a single variable,
1890 * it's because the EXEC_BACKEND case needs DataDir to be transmitted to
1891 * child backends specially. XXX is that still true? Given that we now
1892 * chdir to DataDir, EXEC_BACKEND can read the config file without knowing
1893 * DataDir in advance.)
1894 */
1895 SetConfigOption("data_directory", DataDir, PGC_POSTMASTER, PGC_S_OVERRIDE);
1896
1897 /*
1898 * Now read the config file a second time, allowing any settings in the
1899 * PG_AUTOCONF_FILENAME file to take effect. (This is pretty ugly, but
1900 * since we have to determine the DataDir before we can find the autoconf
1901 * file, the alternatives seem worse.)
1902 */
1903 ProcessConfigFile(PGC_POSTMASTER);
1904
1905 /*
1906 * If timezone_abbreviations wasn't set in the configuration file, install
1907 * the default value. We do it this way because we can't safely install a
1908 * "real" value until my_exec_path is set, which may not have happened
1909 * when InitializeGUCOptions runs, so the bootstrap default value cannot
1910 * be the real desired default.
1911 */
1912 pg_timezone_abbrev_initialize();
1913
1914 /*
1915 * Figure out where pg_hba.conf is, and make sure the path is absolute.
1916 */
1917 if (HbaFileName)
1918 {
1919 fname = make_absolute_path(HbaFileName);
1920 fname_is_malloced = true;
1921 }
1922 else if (configdir)
1923 {
1924 fname = guc_malloc(FATAL,
1925 strlen(configdir) + strlen(HBA_FILENAME) + 2);
1926 sprintf(fname, "%s/%s", configdir, HBA_FILENAME);
1927 fname_is_malloced = false;
1928 }
1929 else
1930 {
1931 write_stderr("%s does not know where to find the \"hba\" configuration file.\n"
1932 "This can be specified as \"hba_file\" in \"%s\", "
1933 "or by the -D invocation option, or by the "
1934 "PGDATA environment variable.\n",
1935 progname, ConfigFileName);
1936 goto fail;
1937 }
1938 SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1939
1940 if (fname_is_malloced)
1941 free(fname);
1942 else
1943 guc_free(fname);
1944
1945 /*
1946 * Likewise for pg_ident.conf.
1947 */
1948 if (IdentFileName)
1949 {
1950 fname = make_absolute_path(IdentFileName);
1951 fname_is_malloced = true;
1952 }
1953 else if (configdir)
1954 {
1955 fname = guc_malloc(FATAL,
1956 strlen(configdir) + strlen(IDENT_FILENAME) + 2);
1957 sprintf(fname, "%s/%s", configdir, IDENT_FILENAME);
1958 fname_is_malloced = false;
1959 }
1960 else
1961 {
1962 write_stderr("%s does not know where to find the \"ident\" configuration file.\n"
1963 "This can be specified as \"ident_file\" in \"%s\", "
1964 "or by the -D invocation option, or by the "
1965 "PGDATA environment variable.\n",
1966 progname, ConfigFileName);
1967 goto fail;
1968 }
1969 SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1970
1971 if (fname_is_malloced)
1972 free(fname);
1973 else
1974 guc_free(fname);
1975
1976 free(configdir);
1977
1978 return true;
1979
1980fail:
1981 free(configdir);
1982
1983 return false;
1984}
write_stderr
#define write_stderr(str)
Definition: parallel.c:186
FATAL
#define FATAL
Definition: elog.h:41
PANIC
#define PANIC
Definition: elog.h:42
DataDir
char * DataDir
Definition: globals.c:71
ProcessConfigFile
void ProcessConfigFile(GucContext context)
Definition: guc-file.l:120
pg_timezone_abbrev_initialize
static void pg_timezone_abbrev_initialize(void)
Definition: guc.c:1997
IDENT_FILENAME
#define IDENT_FILENAME
Definition: guc.c:57
HBA_FILENAME
#define HBA_FILENAME
Definition: guc.c:56
CONFIG_FILENAME
#define CONFIG_FILENAME
Definition: guc.c:55
HbaFileName
char * HbaFileName
Definition: guc_tables.c:557
ConfigFileName
char * ConfigFileName
Definition: guc_tables.c:556
IdentFileName
char * IdentFileName
Definition: guc_tables.c:558
free
#define free(a)
Definition: header.h:65
progname
const char * progname
Definition: main.c:44
SetDataDir
void SetDataDir(const char *dir)
Definition: miscinit.c:389
sprintf
#define sprintf
Definition: port.h:241
make_absolute_path
char * make_absolute_path(const char *path)
Definition: path.c:807
userDoption
static const char * userDoption
Definition: postgres.c:153

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, userDoption, config_string::variable, and write_stderr.

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

◆ SerializeGUCState()

void SerializeGUCState ( Size  maxsize,
char *  start_address 
)

Definition at line 6123 of file guc.c.

6124{
6125 char *curptr;
6126 Size actual_size;
6127 Size bytes_left;
6128 dlist_iter iter;
6129
6130 /* Reserve space for saving the actual size of the guc state */
6131 Assert(maxsize > sizeof(actual_size));
6132 curptr = start_address + sizeof(actual_size);
6133 bytes_left = maxsize - sizeof(actual_size);
6134
6135 /* We need only consider GUCs with source not PGC_S_DEFAULT */
6136 dlist_foreach(iter, &guc_nondef_list)
6137 {
6138 struct config_generic *gconf = dlist_container(struct config_generic,
6139 nondef_link, iter.cur);
6140
6141 serialize_variable(&curptr, &bytes_left, gconf);
6142 }
6143
6144 /* Store actual size without assuming alignment of start_address. */
6145 actual_size = maxsize - bytes_left - sizeof(actual_size);
6146 memcpy(start_address, &actual_size, sizeof(actual_size));
6147}
serialize_variable
static void serialize_variable(char **destptr, Size *maxbytes, struct config_generic *gconf)
Definition: guc.c:6046

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 3347 of file guc.c.

3351{
3352 Oid srole;
3353
3354 /*
3355 * Non-interactive sources should be treated as having all privileges,
3356 * except for PGC_S_CLIENT. Note in particular that this is true for
3357 * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3358 * privilege check was done when the pg_db_role_setting entry was made.
3359 */
3360 if (source >= PGC_S_INTERACTIVE || source == PGC_S_CLIENT)
3361 srole = GetUserId();
3362 else
3363 srole = BOOTSTRAP_SUPERUSERID;
3364
3365 return set_config_with_handle(name, NULL, value,
3366 context, source, srole,
3367 action, changeVal, elevel,
3368 is_reload);
3369}
set_config_with_handle
int set_config_with_handle(const char *name, config_handle *handle, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3410

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

Referenced by accept_weak_input(), applyRemoteGucs(), CreateSchemaCommand(), DefineIndex(), ExecSetVariableStmt(), execute_extension_script(), parse_subscription_options(), ProcessConfigFileInternal(), ProcessGUCArray(), RestrictSearchPath(), 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 3387 of file guc.c.

3391{
3392 return set_config_with_handle(name, NULL, value,
3393 context, source, srole,
3394 action, changeVal, elevel,
3395 is_reload);
3396}

References generate_unaccent_rules::action, name, set_config_with_handle(), source, and value.

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

◆ set_config_with_handle()

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

Definition at line 3410 of file guc.c.

3415{
3416 struct config_generic *record;
3417 union config_var_val newval_union;
3418 void *newextra = NULL;
3419 bool prohibitValueChange = false;
3420 bool makeDefault;
3421
3422 if (elevel == 0)
3423 {
3424 if (source == PGC_S_DEFAULT || source == PGC_S_FILE)
3425 {
3426 /*
3427 * To avoid cluttering the log, only the postmaster bleats loudly
3428 * about problems with the config file.
3429 */
3430 elevel = IsUnderPostmaster ? DEBUG3 : LOG;
3431 }
3432 else if (source == PGC_S_GLOBAL ||
3433 source == PGC_S_DATABASE ||
3434 source == PGC_S_USER ||
3435 source == PGC_S_DATABASE_USER)
3436 elevel = WARNING;
3437 else
3438 elevel = ERROR;
3439 }
3440
3441 /* if handle is specified, no need to look up option */
3442 if (!handle)
3443 {
3444 record = find_option(name, true, false, elevel);
3445 if (record == NULL)
3446 return 0;
3447 }
3448 else
3449 record = handle;
3450
3451 /*
3452 * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
3453 * because the current worker will also pop the change. We're probably
3454 * dealing with a function having a proconfig entry. Only the function's
3455 * body should observe the change, and peer workers do not share in the
3456 * execution of a function call started by this worker.
3457 *
3458 * Also allow normal setting if the GUC is marked GUC_ALLOW_IN_PARALLEL.
3459 *
3460 * Other changes might need to affect other workers, so forbid them.
3461 */
3462 if (IsInParallelMode() && changeVal && action != GUC_ACTION_SAVE &&
3463 (record->flags & GUC_ALLOW_IN_PARALLEL) == 0)
3464 {
3465 ereport(elevel,
3466 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3467 errmsg("parameter \"%s\" cannot be set during a parallel operation",
3468 record->name)));
3469 return 0;
3470 }
3471
3472 /*
3473 * Check if the option can be set at this time. See guc.h for the precise
3474 * rules.
3475 */
3476 switch (record->context)
3477 {
3478 case PGC_INTERNAL:
3479 if (context != PGC_INTERNAL)
3480 {
3481 ereport(elevel,
3482 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3483 errmsg("parameter \"%s\" cannot be changed",
3484 record->name)));
3485 return 0;
3486 }
3487 break;
3488 case PGC_POSTMASTER:
3489 if (context == PGC_SIGHUP)
3490 {
3491 /*
3492 * We are re-reading a PGC_POSTMASTER variable from
3493 * postgresql.conf. We can't change the setting, so we should
3494 * give a warning if the DBA tries to change it. However,
3495 * because of variant formats, canonicalization by check
3496 * hooks, etc, we can't just compare the given string directly
3497 * to what's stored. Set a flag to check below after we have
3498 * the final storable value.
3499 */
3500 prohibitValueChange = true;
3501 }
3502 else if (context != PGC_POSTMASTER)
3503 {
3504 ereport(elevel,
3505 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3506 errmsg("parameter \"%s\" cannot be changed without restarting the server",
3507 record->name)));
3508 return 0;
3509 }
3510 break;
3511 case PGC_SIGHUP:
3512 if (context != PGC_SIGHUP && context != PGC_POSTMASTER)
3513 {
3514 ereport(elevel,
3515 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3516 errmsg("parameter \"%s\" cannot be changed now",
3517 record->name)));
3518 return 0;
3519 }
3520
3521 /*
3522 * Hmm, the idea of the SIGHUP context is "ought to be global, but
3523 * can be changed after postmaster start". But there's nothing
3524 * that prevents a crafty administrator from sending SIGHUP
3525 * signals to individual backends only.
3526 */
3527 break;
3528 case PGC_SU_BACKEND:
3529 if (context == PGC_BACKEND)
3530 {
3531 /*
3532 * Check whether the requesting user has been granted
3533 * privilege to set this GUC.
3534 */
3535 AclResult aclresult;
3536
3537 aclresult = pg_parameter_aclcheck(record->name, srole, ACL_SET);
3538 if (aclresult != ACLCHECK_OK)
3539 {
3540 /* No granted privilege */
3541 ereport(elevel,
3542 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3543 errmsg("permission denied to set parameter \"%s\"",
3544 record->name)));
3545 return 0;
3546 }
3547 }
3548 /* fall through to process the same as PGC_BACKEND */
3549 /* FALLTHROUGH */
3550 case PGC_BACKEND:
3551 if (context == PGC_SIGHUP)
3552 {
3553 /*
3554 * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
3555 * the config file, we want to accept the new value in the
3556 * postmaster (whence it will propagate to
3557 * subsequently-started backends), but ignore it in existing
3558 * backends. This is a tad klugy, but necessary because we
3559 * don't re-read the config file during backend start.
3560 *
3561 * However, if changeVal is false then plow ahead anyway since
3562 * we are trying to find out if the value is potentially good,
3563 * not actually use it.
3564 *
3565 * In EXEC_BACKEND builds, this works differently: we load all
3566 * non-default settings from the CONFIG_EXEC_PARAMS file
3567 * during backend start. In that case we must accept
3568 * PGC_SIGHUP settings, so as to have the same value as if
3569 * we'd forked from the postmaster. This can also happen when
3570 * using RestoreGUCState() within a background worker that
3571 * needs to have the same settings as the user backend that
3572 * started it. is_reload will be true when either situation
3573 * applies.
3574 */
3575 if (IsUnderPostmaster && changeVal && !is_reload)
3576 return -1;
3577 }
3578 else if (context != PGC_POSTMASTER &&
3579 context != PGC_BACKEND &&
3580 context != PGC_SU_BACKEND &&
3581 source != PGC_S_CLIENT)
3582 {
3583 ereport(elevel,
3584 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3585 errmsg("parameter \"%s\" cannot be set after connection start",
3586 record->name)));
3587 return 0;
3588 }
3589 break;
3590 case PGC_SUSET:
3591 if (context == PGC_USERSET || context == PGC_BACKEND)
3592 {
3593 /*
3594 * Check whether the requesting user has been granted
3595 * privilege to set this GUC.
3596 */
3597 AclResult aclresult;
3598
3599 aclresult = pg_parameter_aclcheck(record->name, srole, ACL_SET);
3600 if (aclresult != ACLCHECK_OK)
3601 {
3602 /* No granted privilege */
3603 ereport(elevel,
3604 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3605 errmsg("permission denied to set parameter \"%s\"",
3606 record->name)));
3607 return 0;
3608 }
3609 }
3610 break;
3611 case PGC_USERSET:
3612 /* always okay */
3613 break;
3614 }
3615
3616 /*
3617 * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
3618 * security restriction context. We can reject this regardless of the GUC
3619 * context or source, mainly because sources that it might be reasonable
3620 * to override for won't be seen while inside a function.
3621 *
3622 * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
3623 * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
3624 * An exception might be made if the reset value is assumed to be "safe".
3625 *
3626 * Note: this flag is currently used for "session_authorization" and
3627 * "role". We need to prohibit changing these inside a local userid
3628 * context because when we exit it, GUC won't be notified, leaving things
3629 * out of sync. (This could be fixed by forcing a new GUC nesting level,
3630 * but that would change behavior in possibly-undesirable ways.) Also, we
3631 * prohibit changing these in a security-restricted operation because
3632 * otherwise RESET could be used to regain the session user's privileges.
3633 */
3634 if (record->flags & GUC_NOT_WHILE_SEC_REST)
3635 {
3636 if (InLocalUserIdChange())
3637 {
3638 /*
3639 * Phrasing of this error message is historical, but it's the most
3640 * common case.
3641 */
3642 ereport(elevel,
3643 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3644 errmsg("cannot set parameter \"%s\" within security-definer function",
3645 record->name)));
3646 return 0;
3647 }
3648 if (InSecurityRestrictedOperation())
3649 {
3650 ereport(elevel,
3651 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3652 errmsg("cannot set parameter \"%s\" within security-restricted operation",
3653 record->name)));
3654 return 0;
3655 }
3656 }
3657
3658 /* Disallow resetting and saving GUC_NO_RESET values */
3659 if (record->flags & GUC_NO_RESET)
3660 {
3661 if (value == NULL)
3662 {
3663 ereport(elevel,
3664 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3665 errmsg("parameter \"%s\" cannot be reset", record->name)));
3666 return 0;
3667 }
3668 if (action == GUC_ACTION_SAVE)
3669 {
3670 ereport(elevel,
3671 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3672 errmsg("parameter \"%s\" cannot be set locally in functions",
3673 record->name)));
3674 return 0;
3675 }
3676 }
3677
3678 /*
3679 * Should we set reset/stacked values? (If so, the behavior is not
3680 * transactional.) This is done either when we get a default value from
3681 * the database's/user's/client's default settings or when we reset a
3682 * value to its default.
3683 */
3684 makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
3685 ((value != NULL) || source == PGC_S_DEFAULT);
3686
3687 /*
3688 * Ignore attempted set if overridden by previously processed setting.
3689 * However, if changeVal is false then plow ahead anyway since we are
3690 * trying to find out if the value is potentially good, not actually use
3691 * it. Also keep going if makeDefault is true, since we may want to set
3692 * the reset/stacked values even if we can't set the variable itself.
3693 */
3694 if (record->source > source)
3695 {
3696 if (changeVal && !makeDefault)
3697 {
3698 elog(DEBUG3, "\"%s\": setting ignored because previous source is higher priority",
3699 record->name);
3700 return -1;
3701 }
3702 changeVal = false;
3703 }
3704
3705 /*
3706 * Evaluate value and set variable.
3707 */
3708 switch (record->vartype)
3709 {
3710 case PGC_BOOL:
3711 {
3712 struct config_bool *conf = (struct config_bool *) record;
3713
3714#define newval (newval_union.boolval)
3715
3716 if (value)
3717 {
3718 if (!parse_and_validate_value(record, value,
3719 source, elevel,
3720 &newval_union, &newextra))
3721 return 0;
3722 }
3723 else if (source == PGC_S_DEFAULT)
3724 {
3725 newval = conf->boot_val;
3726 if (!call_bool_check_hook(conf, &newval, &newextra,
3727 source, elevel))
3728 return 0;
3729 }
3730 else
3731 {
3732 newval = conf->reset_val;
3733 newextra = conf->reset_extra;
3734 source = conf->gen.reset_source;
3735 context = conf->gen.reset_scontext;
3736 srole = conf->gen.reset_srole;
3737 }
3738
3739 if (prohibitValueChange)
3740 {
3741 /* Release newextra, unless it's reset_extra */
3742 if (newextra && !extra_field_used(&conf->gen, newextra))
3743 guc_free(newextra);
3744
3745 if (*conf->variable != newval)
3746 {
3747 record->status |= GUC_PENDING_RESTART;
3748 ereport(elevel,
3749 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3750 errmsg("parameter \"%s\" cannot be changed without restarting the server",
3751 conf->gen.name)));
3752 return 0;
3753 }
3754 record->status &= ~GUC_PENDING_RESTART;
3755 return -1;
3756 }
3757
3758 if (changeVal)
3759 {
3760 /* Save old value to support transaction abort */
3761 if (!makeDefault)
3762 push_old_value(&conf->gen, action);
3763
3764 if (conf->assign_hook)
3765 conf->assign_hook(newval, newextra);
3766 *conf->variable = newval;
3767 set_extra_field(&conf->gen, &conf->gen.extra,
3768 newextra);
3769 set_guc_source(&conf->gen, source);
3770 conf->gen.scontext = context;
3771 conf->gen.srole = srole;
3772 }
3773 if (makeDefault)
3774 {
3775 GucStack *stack;
3776
3777 if (conf->gen.reset_source <= source)
3778 {
3779 conf->reset_val = newval;
3780 set_extra_field(&conf->gen, &conf->reset_extra,
3781 newextra);
3782 conf->gen.reset_source = source;
3783 conf->gen.reset_scontext = context;
3784 conf->gen.reset_srole = srole;
3785 }
3786 for (stack = conf->gen.stack; stack; stack = stack->prev)
3787 {
3788 if (stack->source <= source)
3789 {
3790 stack->prior.val.boolval = newval;
3791 set_extra_field(&conf->gen, &stack->prior.extra,
3792 newextra);
3793 stack->source = source;
3794 stack->scontext = context;
3795 stack->srole = srole;
3796 }
3797 }
3798 }
3799
3800 /* Perhaps we didn't install newextra anywhere */
3801 if (newextra && !extra_field_used(&conf->gen, newextra))
3802 guc_free(newextra);
3803 break;
3804
3805#undef newval
3806 }
3807
3808 case PGC_INT:
3809 {
3810 struct config_int *conf = (struct config_int *) record;
3811
3812#define newval (newval_union.intval)
3813
3814 if (value)
3815 {
3816 if (!parse_and_validate_value(record, value,
3817 source, elevel,
3818 &newval_union, &newextra))
3819 return 0;
3820 }
3821 else if (source == PGC_S_DEFAULT)
3822 {
3823 newval = conf->boot_val;
3824 if (!call_int_check_hook(conf, &newval, &newextra,
3825 source, elevel))
3826 return 0;
3827 }
3828 else
3829 {
3830 newval = conf->reset_val;
3831 newextra = conf->reset_extra;
3832 source = conf->gen.reset_source;
3833 context = conf->gen.reset_scontext;
3834 srole = conf->gen.reset_srole;
3835 }
3836
3837 if (prohibitValueChange)
3838 {
3839 /* Release newextra, unless it's reset_extra */
3840 if (newextra && !extra_field_used(&conf->gen, newextra))
3841 guc_free(newextra);
3842
3843 if (*conf->variable != newval)
3844 {
3845 record->status |= GUC_PENDING_RESTART;
3846 ereport(elevel,
3847 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3848 errmsg("parameter \"%s\" cannot be changed without restarting the server",
3849 conf->gen.name)));
3850 return 0;
3851 }
3852 record->status &= ~GUC_PENDING_RESTART;
3853 return -1;
3854 }
3855
3856 if (changeVal)
3857 {
3858 /* Save old value to support transaction abort */
3859 if (!makeDefault)
3860 push_old_value(&conf->gen, action);
3861
3862 if (conf->assign_hook)
3863 conf->assign_hook(newval, newextra);
3864 *conf->variable = newval;
3865 set_extra_field(&conf->gen, &conf->gen.extra,
3866 newextra);
3867 set_guc_source(&conf->gen, source);
3868 conf->gen.scontext = context;
3869 conf->gen.srole = srole;
3870 }
3871 if (makeDefault)
3872 {
3873 GucStack *stack;
3874
3875 if (conf->gen.reset_source <= source)
3876 {
3877 conf->reset_val = newval;
3878 set_extra_field(&conf->gen, &conf->reset_extra,
3879 newextra);
3880 conf->gen.reset_source = source;
3881 conf->gen.reset_scontext = context;
3882 conf->gen.reset_srole = srole;
3883 }
3884 for (stack = conf->gen.stack; stack; stack = stack->prev)
3885 {
3886 if (stack->source <= source)
3887 {
3888 stack->prior.val.intval = newval;
3889 set_extra_field(&conf->gen, &stack->prior.extra,
3890 newextra);
3891 stack->source = source;
3892 stack->scontext = context;
3893 stack->srole = srole;
3894 }
3895 }
3896 }
3897
3898 /* Perhaps we didn't install newextra anywhere */
3899 if (newextra && !extra_field_used(&conf->gen, newextra))
3900 guc_free(newextra);
3901 break;
3902
3903#undef newval
3904 }
3905
3906 case PGC_REAL:
3907 {
3908 struct config_real *conf = (struct config_real *) record;
3909
3910#define newval (newval_union.realval)
3911
3912 if (value)
3913 {
3914 if (!parse_and_validate_value(record, value,
3915 source, elevel,
3916 &newval_union, &newextra))
3917 return 0;
3918 }
3919 else if (source == PGC_S_DEFAULT)
3920 {
3921 newval = conf->boot_val;
3922 if (!call_real_check_hook(conf, &newval, &newextra,
3923 source, elevel))
3924 return 0;
3925 }
3926 else
3927 {
3928 newval = conf->reset_val;
3929 newextra = conf->reset_extra;
3930 source = conf->gen.reset_source;
3931 context = conf->gen.reset_scontext;
3932 srole = conf->gen.reset_srole;
3933 }
3934
3935 if (prohibitValueChange)
3936 {
3937 /* Release newextra, unless it's reset_extra */
3938 if (newextra && !extra_field_used(&conf->gen, newextra))
3939 guc_free(newextra);
3940
3941 if (*conf->variable != newval)
3942 {
3943 record->status |= GUC_PENDING_RESTART;
3944 ereport(elevel,
3945 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3946 errmsg("parameter \"%s\" cannot be changed without restarting the server",
3947 conf->gen.name)));
3948 return 0;
3949 }
3950 record->status &= ~GUC_PENDING_RESTART;
3951 return -1;
3952 }
3953
3954 if (changeVal)
3955 {
3956 /* Save old value to support transaction abort */
3957 if (!makeDefault)
3958 push_old_value(&conf->gen, action);
3959
3960 if (conf->assign_hook)
3961 conf->assign_hook(newval, newextra);
3962 *conf->variable = newval;
3963 set_extra_field(&conf->gen, &conf->gen.extra,
3964 newextra);
3965 set_guc_source(&conf->gen, source);
3966 conf->gen.scontext = context;
3967 conf->gen.srole = srole;
3968 }
3969 if (makeDefault)
3970 {
3971 GucStack *stack;
3972
3973 if (conf->gen.reset_source <= source)
3974 {
3975 conf->reset_val = newval;
3976 set_extra_field(&conf->gen, &conf->reset_extra,
3977 newextra);
3978 conf->gen.reset_source = source;
3979 conf->gen.reset_scontext = context;
3980 conf->gen.reset_srole = srole;
3981 }
3982 for (stack = conf->gen.stack; stack; stack = stack->prev)
3983 {
3984 if (stack->source <= source)
3985 {
3986 stack->prior.val.realval = newval;
3987 set_extra_field(&conf->gen, &stack->prior.extra,
3988 newextra);
3989 stack->source = source;
3990 stack->scontext = context;
3991 stack->srole = srole;
3992 }
3993 }
3994 }
3995
3996 /* Perhaps we didn't install newextra anywhere */
3997 if (newextra && !extra_field_used(&conf->gen, newextra))
3998 guc_free(newextra);
3999 break;
4000
4001#undef newval
4002 }
4003
4004 case PGC_STRING:
4005 {
4006 struct config_string *conf = (struct config_string *) record;
4007 GucContext orig_context = context;
4008 GucSource orig_source = source;
4009 Oid orig_srole = srole;
4010
4011#define newval (newval_union.stringval)
4012
4013 if (value)
4014 {
4015 if (!parse_and_validate_value(record, value,
4016 source, elevel,
4017 &newval_union, &newextra))
4018 return 0;
4019 }
4020 else if (source == PGC_S_DEFAULT)
4021 {
4022 /* non-NULL boot_val must always get strdup'd */
4023 if (conf->boot_val != NULL)
4024 {
4025 newval = guc_strdup(elevel, conf->boot_val);
4026 if (newval == NULL)
4027 return 0;
4028 }
4029 else
4030 newval = NULL;
4031
4032 if (!call_string_check_hook(conf, &newval, &newextra,
4033 source, elevel))
4034 {
4035 guc_free(newval);
4036 return 0;
4037 }
4038 }
4039 else
4040 {
4041 /*
4042 * strdup not needed, since reset_val is already under
4043 * guc.c's control
4044 */
4045 newval = conf->reset_val;
4046 newextra = conf->reset_extra;
4047 source = conf->gen.reset_source;
4048 context = conf->gen.reset_scontext;
4049 srole = conf->gen.reset_srole;
4050 }
4051
4052 if (prohibitValueChange)
4053 {
4054 bool newval_different;
4055
4056 /* newval shouldn't be NULL, so we're a bit sloppy here */
4057 newval_different = (*conf->variable == NULL ||
4058 newval == NULL ||
4059 strcmp(*conf->variable, newval) != 0);
4060
4061 /* Release newval, unless it's reset_val */
4062 if (newval && !string_field_used(conf, newval))
4063 guc_free(newval);
4064 /* Release newextra, unless it's reset_extra */
4065 if (newextra && !extra_field_used(&conf->gen, newextra))
4066 guc_free(newextra);
4067
4068 if (newval_different)
4069 {
4070 record->status |= GUC_PENDING_RESTART;
4071 ereport(elevel,
4072 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4073 errmsg("parameter \"%s\" cannot be changed without restarting the server",
4074 conf->gen.name)));
4075 return 0;
4076 }
4077 record->status &= ~GUC_PENDING_RESTART;
4078 return -1;
4079 }
4080
4081 if (changeVal)
4082 {
4083 /* Save old value to support transaction abort */
4084 if (!makeDefault)
4085 push_old_value(&conf->gen, action);
4086
4087 if (conf->assign_hook)
4088 conf->assign_hook(newval, newextra);
4089 set_string_field(conf, conf->variable, newval);
4090 set_extra_field(&conf->gen, &conf->gen.extra,
4091 newextra);
4092 set_guc_source(&conf->gen, source);
4093 conf->gen.scontext = context;
4094 conf->gen.srole = srole;
4095
4096 /*
4097 * Ugly hack: during SET session_authorization, forcibly
4098 * do SET ROLE NONE with the same context/source/etc, so
4099 * that the effects will have identical lifespan. This is
4100 * required by the SQL spec, and it's not possible to do
4101 * it within the variable's check hook or assign hook
4102 * because our APIs for those don't pass enough info.
4103 * However, don't do it if is_reload: in that case we
4104 * expect that if "role" isn't supposed to be default, it
4105 * has been or will be set by a separate reload action.
4106 *
4107 * Also, for the call from InitializeSessionUserId with
4108 * source == PGC_S_OVERRIDE, use PGC_S_DYNAMIC_DEFAULT for
4109 * "role"'s source, so that it's still possible to set
4110 * "role" from pg_db_role_setting entries. (See notes in
4111 * InitializeSessionUserId before changing this.)
4112 *
4113 * A fine point: for RESET session_authorization, we do
4114 * "RESET role" not "SET ROLE NONE" (by passing down NULL
4115 * rather than "none" for the value). This would have the
4116 * same effects in typical cases, but if the reset value
4117 * of "role" is not "none" it seems better to revert to
4118 * that.
4119 */
4120 if (!is_reload &&
4121 strcmp(conf->gen.name, "session_authorization") == 0)
4122 (void) set_config_with_handle("role", NULL,
4123 value ? "none" : NULL,
4124 orig_context,
4125 (orig_source == PGC_S_OVERRIDE)
4126 ? PGC_S_DYNAMIC_DEFAULT
4127 : orig_source,
4128 orig_srole,
4129 action,
4130 true,
4131 elevel,
4132 false);
4133 }
4134
4135 if (makeDefault)
4136 {
4137 GucStack *stack;
4138
4139 if (conf->gen.reset_source <= source)
4140 {
4141 set_string_field(conf, &conf->reset_val, newval);
4142 set_extra_field(&conf->gen, &conf->reset_extra,
4143 newextra);
4144 conf->gen.reset_source = source;
4145 conf->gen.reset_scontext = context;
4146 conf->gen.reset_srole = srole;
4147 }
4148 for (stack = conf->gen.stack; stack; stack = stack->prev)
4149 {
4150 if (stack->source <= source)
4151 {
4152 set_string_field(conf, &stack->prior.val.stringval,
4153 newval);
4154 set_extra_field(&conf->gen, &stack->prior.extra,
4155 newextra);
4156 stack->source = source;
4157 stack->scontext = context;
4158 stack->srole = srole;
4159 }
4160 }
4161 }
4162
4163 /* Perhaps we didn't install newval anywhere */
4164 if (newval && !string_field_used(conf, newval))
4165 guc_free(newval);
4166 /* Perhaps we didn't install newextra anywhere */
4167 if (newextra && !extra_field_used(&conf->gen, newextra))
4168 guc_free(newextra);
4169 break;
4170
4171#undef newval
4172 }
4173
4174 case PGC_ENUM:
4175 {
4176 struct config_enum *conf = (struct config_enum *) record;
4177
4178#define newval (newval_union.enumval)
4179
4180 if (value)
4181 {
4182 if (!parse_and_validate_value(record, value,
4183 source, elevel,
4184 &newval_union, &newextra))
4185 return 0;
4186 }
4187 else if (source == PGC_S_DEFAULT)
4188 {
4189 newval = conf->boot_val;
4190 if (!call_enum_check_hook(conf, &newval, &newextra,
4191 source, elevel))
4192 return 0;
4193 }
4194 else
4195 {
4196 newval = conf->reset_val;
4197 newextra = conf->reset_extra;
4198 source = conf->gen.reset_source;
4199 context = conf->gen.reset_scontext;
4200 srole = conf->gen.reset_srole;
4201 }
4202
4203 if (prohibitValueChange)
4204 {
4205 /* Release newextra, unless it's reset_extra */
4206 if (newextra && !extra_field_used(&conf->gen, newextra))
4207 guc_free(newextra);
4208
4209 if (*conf->variable != newval)
4210 {
4211 record->status |= GUC_PENDING_RESTART;
4212 ereport(elevel,
4213 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4214 errmsg("parameter \"%s\" cannot be changed without restarting the server",
4215 conf->gen.name)));
4216 return 0;
4217 }
4218 record->status &= ~GUC_PENDING_RESTART;
4219 return -1;
4220 }
4221
4222 if (changeVal)
4223 {
4224 /* Save old value to support transaction abort */
4225 if (!makeDefault)
4226 push_old_value(&conf->gen, action);
4227
4228 if (conf->assign_hook)
4229 conf->assign_hook(newval, newextra);
4230 *conf->variable = newval;
4231 set_extra_field(&conf->gen, &conf->gen.extra,
4232 newextra);
4233 set_guc_source(&conf->gen, source);
4234 conf->gen.scontext = context;
4235 conf->gen.srole = srole;
4236 }
4237 if (makeDefault)
4238 {
4239 GucStack *stack;
4240
4241 if (conf->gen.reset_source <= source)
4242 {
4243 conf->reset_val = newval;
4244 set_extra_field(&conf->gen, &conf->reset_extra,
4245 newextra);
4246 conf->gen.reset_source = source;
4247 conf->gen.reset_scontext = context;
4248 conf->gen.reset_srole = srole;
4249 }
4250 for (stack = conf->gen.stack; stack; stack = stack->prev)
4251 {
4252 if (stack->source <= source)
4253 {
4254 stack->prior.val.enumval = newval;
4255 set_extra_field(&conf->gen, &stack->prior.extra,
4256 newextra);
4257 stack->source = source;
4258 stack->scontext = context;
4259 stack->srole = srole;
4260 }
4261 }
4262 }
4263
4264 /* Perhaps we didn't install newextra anywhere */
4265 if (newextra && !extra_field_used(&conf->gen, newextra))
4266 guc_free(newextra);
4267 break;
4268
4269#undef newval
4270 }
4271 }
4272
4273 if (changeVal && (record->flags & GUC_REPORT) &&
4274 !(record->status & GUC_NEEDS_REPORT))
4275 {
4276 record->status |= GUC_NEEDS_REPORT;
4277 slist_push_head(&guc_report_list, &record->report_link);
4278 }
4279
4280 return changeVal ? 1 : -1;
4281}
DEBUG3
#define DEBUG3
Definition: elog.h:28
call_string_check_hook
static bool call_string_check_hook(struct config_string *conf, char **newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6928
extra_field_used
static bool extra_field_used(struct config_generic *gconf, void *extra)
Definition: guc.c:748
call_bool_check_hook
static void static bool call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6826
call_int_check_hook
static bool call_int_check_hook(struct config_int *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6860
string_field_used
static bool string_field_used(struct config_string *conf, char *strval)
Definition: guc.c:709
call_real_check_hook
static bool call_real_check_hook(struct config_real *conf, double *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6894
guc_strdup
char * guc_strdup(int elevel, const char *src)
Definition: guc.c:678
call_enum_check_hook
static bool call_enum_check_hook(struct config_enum *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6978
GUC_NO_RESET
#define GUC_NO_RESET
Definition: guc.h:217
GUC_NOT_WHILE_SEC_REST
#define GUC_NOT_WHILE_SEC_REST
Definition: guc.h:226
GUC_ALLOW_IN_PARALLEL
#define GUC_ALLOW_IN_PARALLEL
Definition: guc.h:230
GUC_PENDING_RESTART
#define GUC_PENDING_RESTART
Definition: guc_tables.h:210
InSecurityRestrictedOperation
bool InSecurityRestrictedOperation(void)
Definition: miscinit.c:639
InLocalUserIdChange
bool InLocalUserIdChange(void)
Definition: miscinit.c:630
config_bool::boot_val
bool boot_val
Definition: guc_tables.h:221
config_enum::boot_val
int boot_val
Definition: guc_tables.h:291
config_int::boot_val
int boot_val
Definition: guc_tables.h:235
config_real::boot_val
double boot_val
Definition: guc_tables.h:251
config_string::boot_val
const char * boot_val
Definition: guc_tables.h:277

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_ALLOW_IN_PARALLEL, 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, config_generic::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_DYNAMIC_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_config_with_handle(), 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 fmgr_security_definer(), set_config_option(), set_config_option_ext(), and set_config_with_handle().

◆ SetConfigOption()

void SetConfigOption ( const char *  name,
const char *  value,
GucContext  context,
GucSource  source 
)

Definition at line 4337 of file guc.c.

4339{
4340 (void) set_config_option(name, value, context, source,
4341 GUC_ACTION_SET, true, 0, false);
4342}

References config_generic::context, GUC_ACTION_SET, name, set_config_option(), source, and value.

Referenced by AioShmemSize(), AutoVacLauncherMain(), AutoVacWorkerMain(), BeginReportingGUCOptions(), BootstrapModeMain(), CheckMyDatabase(), CLOGShmemInit(), CommitTsShmemInit(), CreateAnonymousSegment(), InitializeGUCOptions(), InitializeGUCOptionsFromEnvironment(), InitializeLogRepWorker(), InitializeSessionUserId(), InitializeShmemGUCs(), maybe_reread_subscription(), pg_timezone_abbrev_initialize(), PGSharedMemoryCreate(), PostmasterMain(), process_postgres_switches(), process_startup_options(), ProcessConfigFileInternal(), ReadControlFile(), ReplSlotSyncWorkerMain(), ReportChangedGUCOptions(), SelectConfigFiles(), set_debug_options(), set_limit(), set_plan_disabling_options(), SetOuterUserId(), SUBTRANSShmemInit(), and XLOGShmemSize().

◆ SetPGVariable()

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

Definition at line 315 of file guc_funcs.c.

316{
317 char *argstring = flatten_set_variable_args(name, args);
318
319 /* Note SET DEFAULT (argstring == NULL) is equivalent to RESET */
320 (void) set_config_option(name,
321 argstring,
322 (superuser() ? PGC_SUSET : PGC_USERSET),
323 PGC_S_SESSION,
324 is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET,
325 true, 0, false);
326}
generate_unaccent_rules.args
args
Definition: generate_unaccent_rules.py:288

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().

◆ TransformGUCArray()

void TransformGUCArray ( ArrayType *  array,
List **  names,
List **  values 
)

Definition at line 6421 of file guc.c.

6422{
6423 int i;
6424
6425 Assert(array != NULL);
6426 Assert(ARR_ELEMTYPE(array) == TEXTOID);
6427 Assert(ARR_NDIM(array) == 1);
6428 Assert(ARR_LBOUND(array)[0] == 1);
6429
6430 *names = NIL;
6431 *values = NIL;
6432 for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6433 {
6434 Datum d;
6435 bool isnull;
6436 char *s;
6437 char *name;
6438 char *value;
6439
6440 d = array_ref(array, 1, &i,
6441 -1 /* varlenarray */ ,
6442 -1 /* TEXT's typlen */ ,
6443 false /* TEXT's typbyval */ ,
6444 TYPALIGN_INT /* TEXT's typalign */ ,
6445 &isnull);
6446
6447 if (isnull)
6448 continue;
6449
6450 s = TextDatumGetCString(d);
6451
6452 ParseLongOption(s, &name, &value);
6453 if (!value)
6454 {
6455 ereport(WARNING,
6456 (errcode(ERRCODE_SYNTAX_ERROR),
6457 errmsg("could not parse setting for parameter \"%s\"",
6458 name)));
6459 pfree(name);
6460 continue;
6461 }
6462
6463 *names = lappend(*names, name);
6464 *values = lappend(*values, value);
6465
6466 pfree(s);
6467 }
6468}
values
static Datum values[MAXATTR]
Definition: bootstrap.c:153
ParseLongOption
void ParseLongOption(const char *string, char **name, char **value)
Definition: guc.c:6384
NIL
#define NIL
Definition: pg_list.h:68

References ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), Assert(), ereport, errcode(), errmsg(), i, lappend(), name, NIL, ParseLongOption(), pfree(), TextDatumGetCString, value, values, and WARNING.

Referenced by fmgr_security_definer(), and ProcessGUCArray().

Variable Documentation

◆ AllowAlterSystem

PGDLLIMPORT bool AllowAlterSystem
extern

Definition at line 506 of file guc_tables.c.

Referenced by AlterSystemSetConfigFile().

◆ application_name

PGDLLIMPORT char* application_name
extern

Definition at line 561 of file guc_tables.c.

Referenced by log_status_format(), pgstat_bestart_final(), process_pgfdw_appname(), SyncRepGetStandbyPriority(), SyncRepInitConfig(), SyncRepReleaseWaiters(), WalSndLoop(), write_csvlog(), and write_jsonlog().

◆ archive_mode_options

PGDLLIMPORT const struct config_enum_entry archive_mode_options[]
extern

Definition at line 192 of file xlog.c.

◆ backtrace_functions

PGDLLIMPORT char* backtrace_functions
extern

Definition at line 549 of file guc_tables.c.

Referenced by errfinish().

◆ check_function_bodies

PGDLLIMPORT bool check_function_bodies
extern

Definition at line 529 of file guc_tables.c.

Referenced by execute_extension_script(), fmgr_sql_validator(), plperl_validator(), plpgsql_compile_inline(), plpgsql_validator(), plpython3_validator(), and ProcedureCreate().

◆ client_min_messages

PGDLLIMPORT int client_min_messages
extern

Definition at line 541 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 555 of file guc_tables.c.

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

◆ ConfigFileName

PGDLLIMPORT char* ConfigFileName
extern

Definition at line 556 of file guc_tables.c.

Referenced by ProcessConfigFileInternal(), and SelectConfigFiles().

◆ current_role_is_superuser

PGDLLIMPORT bool current_role_is_superuser
extern

Definition at line 537 of file guc_tables.c.

Referenced by check_role(), and InitializeParallelDSM().

◆ Debug_pretty_print

PGDLLIMPORT bool Debug_pretty_print
extern

Definition at line 512 of file guc_tables.c.

Referenced by pg_parse_query(), pg_plan_query(), and pg_rewrite_query().

◆ Debug_print_parse

PGDLLIMPORT bool Debug_print_parse
extern

Definition at line 509 of file guc_tables.c.

Referenced by pg_rewrite_query().

◆ Debug_print_plan

PGDLLIMPORT bool Debug_print_plan
extern

Definition at line 508 of file guc_tables.c.

Referenced by pg_plan_query().

◆ Debug_print_raw_parse

PGDLLIMPORT bool Debug_print_raw_parse
extern

Definition at line 510 of file guc_tables.c.

Referenced by pg_parse_query().

◆ Debug_print_rewritten

PGDLLIMPORT bool Debug_print_rewritten
extern

Definition at line 511 of file guc_tables.c.

Referenced by pg_rewrite_query().

◆ dynamic_shared_memory_options

PGDLLIMPORT const struct config_enum_entry dynamic_shared_memory_options[]
extern

Definition at line 95 of file dsm_impl.c.

◆ event_source

PGDLLIMPORT char* event_source
extern

Definition at line 526 of file guc_tables.c.

◆ external_pid_file

PGDLLIMPORT char* external_pid_file
extern

Definition at line 559 of file guc_tables.c.

Referenced by PostmasterMain(), and unlink_external_pid_file().

◆ GUC_check_errdetail_string

PGDLLIMPORT char* GUC_check_errdetail_string
extern

Definition at line 82 of file guc.c.

Referenced by call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), and call_string_check_hook().

◆ GUC_check_errhint_string

PGDLLIMPORT char* GUC_check_errhint_string
extern

Definition at line 83 of file guc.c.

Referenced by call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), and call_string_check_hook().

◆ GUC_check_errmsg_string

PGDLLIMPORT char* GUC_check_errmsg_string
extern

Definition at line 81 of file guc.c.

Referenced by call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), and call_string_check_hook().

◆ HbaFileName

PGDLLIMPORT char* HbaFileName
extern

Definition at line 557 of file guc_tables.c.

Referenced by fill_hba_view(), load_hba(), PerformAuthentication(), PostmasterMain(), process_pm_reload_request(), and SelectConfigFiles().

◆ IdentFileName

PGDLLIMPORT char* IdentFileName
extern

Definition at line 558 of file guc_tables.c.

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

◆ in_hot_standby_guc

PGDLLIMPORT bool in_hot_standby_guc
extern

Definition at line 640 of file guc_tables.c.

Referenced by ReportChangedGUCOptions().

◆ io_method_options

PGDLLIMPORT const struct config_enum_entry io_method_options[]
extern

Definition at line 64 of file aio.c.

Referenced by assign_io_method().

◆ log_btree_build_stats

PGDLLIMPORT bool log_btree_build_stats
extern

Definition at line 525 of file guc_tables.c.

Referenced by _bt_leader_participate_as_worker(), _bt_leafbuild(), _bt_parallel_build_main(), and btbuild().

◆ log_duration

PGDLLIMPORT bool log_duration
extern

Definition at line 507 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_executor_stats

PGDLLIMPORT bool log_executor_stats
extern

Definition at line 522 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 542 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_min_duration_statement

PGDLLIMPORT int log_min_duration_statement
extern

Definition at line 543 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_min_error_statement

PGDLLIMPORT int log_min_error_statement
extern

Definition at line 539 of file guc_tables.c.

Referenced by check_log_of_query().

◆ log_min_messages

PGDLLIMPORT int log_min_messages
extern

Definition at line 540 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 544 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 545 of file guc_tables.c.

Referenced by bind_param_error_callback(), and exec_bind_message().

◆ log_parser_stats

PGDLLIMPORT bool log_parser_stats
extern

Definition at line 520 of file guc_tables.c.

Referenced by check_log_stats(), pg_analyze_and_rewrite_fixedparams(), pg_analyze_and_rewrite_varparams(), pg_analyze_and_rewrite_withcb(), pg_parse_query(), and pg_rewrite_query().

◆ log_planner_stats

PGDLLIMPORT bool log_planner_stats
extern

Definition at line 521 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 547 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_statement_stats

PGDLLIMPORT bool log_statement_stats
extern

Definition at line 523 of file guc_tables.c.

Referenced by check_stage_log_stats(), exec_bind_message(), exec_execute_message(), exec_parse_message(), and exec_simple_query().

◆ log_temp_files

PGDLLIMPORT int log_temp_files
extern

Definition at line 546 of file guc_tables.c.

Referenced by ReportTemporaryFileUsage().

◆ log_xact_sample_rate

PGDLLIMPORT double log_xact_sample_rate
extern

Definition at line 548 of file guc_tables.c.

Referenced by StartTransaction().

◆ num_temp_buffers

PGDLLIMPORT int num_temp_buffers
extern

Definition at line 553 of file guc_tables.c.

Referenced by GetAdditionalLocalPinLimit(), GetLocalPinLimit(), InitLocalBuffers(), and LimitAdditionalLocalPins().

◆ recovery_target_action_options

PGDLLIMPORT const struct config_enum_entry recovery_target_action_options[]
extern

Definition at line 76 of file xlogrecovery.c.

◆ role_string

PGDLLIMPORT char* role_string
extern

Definition at line 637 of file guc_tables.c.

Referenced by show_role().

◆ tcp_keepalives_count

PGDLLIMPORT int tcp_keepalives_count
extern

Definition at line 565 of file guc_tables.c.

Referenced by pq_init().

◆ tcp_keepalives_idle

PGDLLIMPORT int tcp_keepalives_idle
extern

Definition at line 563 of file guc_tables.c.

Referenced by pq_init().

◆ tcp_keepalives_interval

PGDLLIMPORT int tcp_keepalives_interval
extern

Definition at line 564 of file guc_tables.c.

Referenced by pq_init().

◆ tcp_user_timeout

PGDLLIMPORT int tcp_user_timeout
extern

Definition at line 566 of file guc_tables.c.

Referenced by pq_init().

◆ temp_file_limit

PGDLLIMPORT int temp_file_limit
extern

Definition at line 551 of file guc_tables.c.

Referenced by FileWriteV().

◆ trace_sort

PGDLLIMPORT bool trace_sort
extern

Definition at line 124 of file tuplesort.c.

Referenced by dumptuples(), inittapes(), macaddr_abbrev_abort(), mergeruns(), network_abbrev_abort(), numeric_abbrev_abort(), tuplesort_begin_cluster(), tuplesort_begin_common(), tuplesort_begin_datum(), tuplesort_begin_heap(), tuplesort_begin_index_brin(), tuplesort_begin_index_btree(), tuplesort_begin_index_gin(), tuplesort_begin_index_gist(), tuplesort_begin_index_hash(), tuplesort_free(), tuplesort_performsort(), tuplesort_puttuple_common(), uuid_abbrev_abort(), and varstr_abbrev_abort().

◆ wal_level_options

PGDLLIMPORT const struct config_enum_entry wal_level_options[]
extern

Definition at line 27 of file xlogdesc.c.

Referenced by get_wal_level_string().

◆ wal_sync_method_options

PGDLLIMPORT const struct config_enum_entry wal_sync_method_options[]
extern

Definition at line 172 of file xlog.c.