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

Go to the source code of this file.

Data Structures

struct  ConfigVariable
 
struct  config_enum_entry
 

Macros

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

Typedefs

typedef struct ConfigVariable ConfigVariable
 
typedef 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_handleget_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)
 
ArrayTypeGUCArrayAdd (ArrayType *array, const char *name, const char *value)
 
ArrayTypeGUCArrayDelete (ArrayType *array, const char *name)
 
ArrayTypeGUCArrayReset (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_rewritten
 
PGDLLIMPORT bool Debug_pretty_print
 
PGDLLIMPORT bool log_parser_stats
 
PGDLLIMPORT bool log_planner_stats
 
PGDLLIMPORT bool log_executor_stats
 
PGDLLIMPORT bool log_statement_stats
 
PGDLLIMPORT bool log_btree_build_stats
 
PGDLLIMPORT bool check_function_bodies
 
PGDLLIMPORT bool 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 * 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 361 of file guc.h.

◆ GUC_check_errdetail

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

Definition at line 447 of file guc.h.

◆ GUC_check_errhint

#define GUC_check_errhint
Value:
GUC_check_errhint_string = format_elog_string

Definition at line 451 of file guc.h.

◆ GUC_check_errmsg

#define GUC_check_errmsg
Value:
GUC_check_errmsg_string = format_elog_string

Definition at line 443 of file guc.h.

◆ GUC_CUSTOM_PLACEHOLDER

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

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

◆ GUC_DISALLOW_IN_FILE

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

Definition at line 218 of file guc.h.

◆ GUC_EXPLAIN

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

Definition at line 215 of file guc.h.

◆ GUC_IS_NAME

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

Definition at line 221 of file guc.h.

◆ GUC_LIST_INPUT

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

Definition at line 210 of file guc.h.

◆ GUC_LIST_QUOTE

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

Definition at line 211 of file guc.h.

◆ GUC_NO_RESET

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

Definition at line 213 of file guc.h.

◆ GUC_NO_RESET_ALL

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

Definition at line 214 of file guc.h.

◆ GUC_NO_SHOW_ALL

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

Definition at line 212 of file guc.h.

◆ GUC_NOT_IN_SAMPLE

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

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

◆ GUC_QUALIFIER_SEPARATOR

#define GUC_QUALIFIER_SEPARATOR   '.'

Definition at line 204 of file guc.h.

◆ GUC_REPORT

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

Definition at line 216 of file guc.h.

◆ GUC_RUNTIME_COMPUTED

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

Definition at line 225 of file guc.h.

◆ GUC_SUPERUSER_ONLY

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

Definition at line 220 of file guc.h.

◆ GUC_UNIT

#define GUC_UNIT   (GUC_UNIT_MEMORY | GUC_UNIT_TIME)

Definition at line 239 of file guc.h.

◆ GUC_UNIT_BLOCKS

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

Definition at line 228 of file guc.h.

◆ GUC_UNIT_BYTE

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

Definition at line 231 of file guc.h.

◆ GUC_UNIT_KB

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

Definition at line 227 of file guc.h.

◆ GUC_UNIT_MB

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

Definition at line 230 of file guc.h.

◆ GUC_UNIT_MEMORY

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

Definition at line 232 of file guc.h.

◆ GUC_UNIT_MIN

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

Definition at line 236 of file guc.h.

◆ GUC_UNIT_MS

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

Definition at line 234 of file guc.h.

◆ GUC_UNIT_S

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

Definition at line 235 of file guc.h.

◆ GUC_UNIT_TIME

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

Definition at line 237 of file guc.h.

◆ GUC_UNIT_XBLOCKS

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

Definition at line 229 of file guc.h.

◆ MAX_KILOBYTES

#define MAX_KILOBYTES   (INT_MAX / 1024)

Definition at line 25 of file guc.h.

◆ PG_AUTOCONF_FILENAME

#define PG_AUTOCONF_FILENAME   "postgresql.auto.conf"

Definition at line 33 of file guc.h.

Typedef Documentation

◆ config_handle

typedef struct config_generic config_handle

Definition at line 1 of file guc.h.

◆ ConfigVariable

◆ GucBoolAssignHook

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

Definition at line 185 of file guc.h.

◆ GucBoolCheckHook

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

Definition at line 179 of file guc.h.

◆ GucEnumAssignHook

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

Definition at line 189 of file guc.h.

◆ GucEnumCheckHook

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

Definition at line 183 of file guc.h.

◆ GucIntAssignHook

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

Definition at line 186 of file guc.h.

◆ GucIntCheckHook

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

Definition at line 180 of file guc.h.

◆ GucRealAssignHook

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

Definition at line 187 of file guc.h.

◆ GucRealCheckHook

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

Definition at line 181 of file guc.h.

◆ GucShowHook

typedef const char*(* GucShowHook) (void)

Definition at line 191 of file guc.h.

◆ GucStringAssignHook

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

Definition at line 188 of file guc.h.

◆ GucStringCheckHook

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

Definition at line 182 of file guc.h.

Enumeration Type Documentation

◆ GucAction

enum GucAction
Enumerator
GUC_ACTION_SET 
GUC_ACTION_LOCAL 
GUC_ACTION_SAVE 

Definition at line 196 of file guc.h.

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

◆ GucContext

enum GucContext
Enumerator
PGC_INTERNAL 
PGC_POSTMASTER 
PGC_SIGHUP 
PGC_SU_BACKEND 
PGC_BACKEND 
PGC_SUSET 
PGC_USERSET 

Definition at line 67 of file guc.h.

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

◆ GucSource

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

Definition at line 107 of file guc.h.

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

Function Documentation

◆ AlterSystemSetConfigFile()

void AlterSystemSetConfigFile ( AlterSystemStmt altersysstmt)

Definition at line 4560 of file guc.c.

4561 {
4562  char *name;
4563  char *value;
4564  bool resetall = false;
4565  ConfigVariable *head = NULL;
4566  ConfigVariable *tail = NULL;
4567  volatile int Tmpfd;
4568  char AutoConfFileName[MAXPGPATH];
4569  char AutoConfTmpFileName[MAXPGPATH];
4570 
4571  /*
4572  * Extract statement arguments
4573  */
4574  name = altersysstmt->setstmt->name;
4575 
4576  if (!AllowAlterSystem)
4577  ereport(ERROR,
4578  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4579  errmsg("ALTER SYSTEM is not allowed in this environment")));
4580 
4581  switch (altersysstmt->setstmt->kind)
4582  {
4583  case VAR_SET_VALUE:
4584  value = ExtractSetVariableArgs(altersysstmt->setstmt);
4585  break;
4586 
4587  case VAR_SET_DEFAULT:
4588  case VAR_RESET:
4589  value = NULL;
4590  break;
4591 
4592  case VAR_RESET_ALL:
4593  value = NULL;
4594  resetall = true;
4595  break;
4596 
4597  default:
4598  elog(ERROR, "unrecognized alter system stmt type: %d",
4599  altersysstmt->setstmt->kind);
4600  break;
4601  }
4602 
4603  /*
4604  * Check permission to run ALTER SYSTEM on the target variable
4605  */
4606  if (!superuser())
4607  {
4608  if (resetall)
4609  ereport(ERROR,
4610  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4611  errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4612  else
4613  {
4614  AclResult aclresult;
4615 
4616  aclresult = pg_parameter_aclcheck(name, GetUserId(),
4618  if (aclresult != ACLCHECK_OK)
4619  ereport(ERROR,
4620  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4621  errmsg("permission denied to set parameter \"%s\"",
4622  name)));
4623  }
4624  }
4625 
4626  /*
4627  * Unless it's RESET_ALL, validate the target variable and value
4628  */
4629  if (!resetall)
4630  {
4631  struct config_generic *record;
4632 
4633  /* We don't want to create a placeholder if there's not one already */
4634  record = find_option(name, false, true, DEBUG5);
4635  if (record != NULL)
4636  {
4637  /*
4638  * Don't allow parameters that can't be set in configuration files
4639  * to be set in PG_AUTOCONF_FILENAME file.
4640  */
4641  if ((record->context == PGC_INTERNAL) ||
4642  (record->flags & GUC_DISALLOW_IN_FILE) ||
4643  (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
4644  ereport(ERROR,
4645  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4646  errmsg("parameter \"%s\" cannot be changed",
4647  name)));
4648 
4649  /*
4650  * If a value is specified, verify that it's sane.
4651  */
4652  if (value)
4653  {
4654  union config_var_val newval;
4655  void *newextra = NULL;
4656 
4657  if (!parse_and_validate_value(record, name, value,
4658  PGC_S_FILE, ERROR,
4659  &newval, &newextra))
4660  ereport(ERROR,
4661  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4662  errmsg("invalid value for parameter \"%s\": \"%s\"",
4663  name, value)));
4664 
4665  if (record->vartype == PGC_STRING && newval.stringval != NULL)
4666  guc_free(newval.stringval);
4667  guc_free(newextra);
4668  }
4669  }
4670  else
4671  {
4672  /*
4673  * Variable not known; check we'd be allowed to create it. (We
4674  * cannot validate the value, but that's fine. A non-core GUC in
4675  * the config file cannot cause postmaster start to fail, so we
4676  * don't have to be too tense about possibly installing a bad
4677  * value.)
4678  */
4679  (void) assignable_custom_variable_name(name, false, ERROR);
4680  }
4681 
4682  /*
4683  * We must also reject values containing newlines, because the grammar
4684  * for config files doesn't support embedded newlines in string
4685  * literals.
4686  */
4687  if (value && strchr(value, '\n'))
4688  ereport(ERROR,
4689  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4690  errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4691  }
4692 
4693  /*
4694  * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4695  * the data directory, so we can reference them by simple relative paths.
4696  */
4697  snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4699  snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4700  AutoConfFileName,
4701  "tmp");
4702 
4703  /*
4704  * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4705  * time. Use AutoFileLock to ensure that. We must hold the lock while
4706  * reading the old file contents.
4707  */
4708  LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4709 
4710  /*
4711  * If we're going to reset everything, then no need to open or parse the
4712  * old file. We'll just write out an empty list.
4713  */
4714  if (!resetall)
4715  {
4716  struct stat st;
4717 
4718  if (stat(AutoConfFileName, &st) == 0)
4719  {
4720  /* open old file PG_AUTOCONF_FILENAME */
4721  FILE *infile;
4722 
4723  infile = AllocateFile(AutoConfFileName, "r");
4724  if (infile == NULL)
4725  ereport(ERROR,
4727  errmsg("could not open file \"%s\": %m",
4728  AutoConfFileName)));
4729 
4730  /* parse it */
4731  if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4732  LOG, &head, &tail))
4733  ereport(ERROR,
4734  (errcode(ERRCODE_CONFIG_FILE_ERROR),
4735  errmsg("could not parse contents of file \"%s\"",
4736  AutoConfFileName)));
4737 
4738  FreeFile(infile);
4739  }
4740 
4741  /*
4742  * Now, replace any existing entry with the new value, or add it if
4743  * not present.
4744  */
4745  replace_auto_config_value(&head, &tail, name, value);
4746  }
4747 
4748  /*
4749  * Invoke the post-alter hook for setting this GUC variable. GUCs
4750  * typically do not have corresponding entries in pg_parameter_acl, so we
4751  * call the hook using the name rather than a potentially-non-existent
4752  * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4753  * context can be distinguished from others. (Note that "name" will be
4754  * NULL in the RESET ALL case.)
4755  *
4756  * We do this here rather than at the end, because ALTER SYSTEM is not
4757  * transactional. If the hook aborts our transaction, it will be cleaner
4758  * to do so before we touch any files.
4759  */
4760  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4762  altersysstmt->setstmt->kind,
4763  false);
4764 
4765  /*
4766  * To ensure crash safety, first write the new file data to a temp file,
4767  * then atomically rename it into place.
4768  *
4769  * If there is a temp file left over due to a previous crash, it's okay to
4770  * truncate and reuse it.
4771  */
4772  Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4773  O_CREAT | O_RDWR | O_TRUNC);
4774  if (Tmpfd < 0)
4775  ereport(ERROR,
4777  errmsg("could not open file \"%s\": %m",
4778  AutoConfTmpFileName)));
4779 
4780  /*
4781  * Use a TRY block to clean up the file if we fail. Since we need a TRY
4782  * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4783  */
4784  PG_TRY();
4785  {
4786  /* Write and sync the new contents to the temporary file */
4787  write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4788 
4789  /* Close before renaming; may be required on some platforms */
4790  close(Tmpfd);
4791  Tmpfd = -1;
4792 
4793  /*
4794  * As the rename is atomic operation, if any problem occurs after this
4795  * at worst it can lose the parameters set by last ALTER SYSTEM
4796  * command.
4797  */
4798  durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4799  }
4800  PG_CATCH();
4801  {
4802  /* Close file first, else unlink might fail on some platforms */
4803  if (Tmpfd >= 0)
4804  close(Tmpfd);
4805 
4806  /* Unlink, but ignore any error */
4807  (void) unlink(AutoConfTmpFileName);
4808 
4809  PG_RE_THROW();
4810  }
4811  PG_END_TRY();
4812 
4813  FreeConfigVariables(head);
4814 
4815  LWLockRelease(AutoFileLock);
4816 }
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
AclResult pg_parameter_aclcheck(const char *name, Oid roleid, AclMode mode)
Definition: aclchk.c:4118
#define CONF_FILE_START_DEPTH
Definition: conffiles.h:17
int errcode_for_file_access(void)
Definition: elog.c:880
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define LOG
Definition: elog.h:31
#define PG_RE_THROW()
Definition: elog.h:411
#define PG_TRY(...)
Definition: elog.h:370
#define PG_END_TRY(...)
Definition: elog.h:395
#define ERROR
Definition: elog.h:39
#define PG_CATCH(...)
Definition: elog.h:380
#define elog(elevel,...)
Definition: elog.h:224
#define ereport(elevel,...)
Definition: elog.h:149
#define DEBUG5
Definition: elog.h:26
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2583
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:782
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:1087
int FreeFile(FILE *file)
Definition: fd.c:2781
static bool assignable_custom_variable_name(const char *name, bool skip_errors, int elevel)
Definition: guc.c:1123
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1237
static bool parse_and_validate_value(struct config_generic *record, const char *name, const char *value, GucSource source, int elevel, union config_var_val *newval, void **newextra)
Definition: guc.c:3132
void guc_free(void *ptr)
Definition: guc.c:691
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head)
Definition: guc.c:4422
#define newval
static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
Definition: guc.c:4490
#define PG_AUTOCONF_FILENAME
Definition: guc.h:33
void FreeConfigVariables(ConfigVariable *list)
bool ParseConfigFp(FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
#define GUC_DISALLOW_IN_FILE
Definition: guc.h:218
#define GUC_DISALLOW_IN_AUTO_FILE
Definition: guc.h:223
char * ExtractSetVariableArgs(VariableSetStmt *stmt)
Definition: guc_funcs.c:167
bool AllowAlterSystem
Definition: guc_tables.c:498
@ PGC_STRING
Definition: guc_tables.h:28
static struct @155 value
#define close(a)
Definition: win32.h:12
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1170
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1783
@ LW_EXCLUSIVE
Definition: lwlock.h:114
Oid GetUserId(void)
Definition: miscinit.c:514
#define InvokeObjectPostAlterHookArgStr(classId, objectName, subId, auxiliaryId, is_internal)
Definition: objectaccess.h:247
@ VAR_SET_DEFAULT
Definition: parsenodes.h:2616
@ VAR_RESET
Definition: parsenodes.h:2619
@ VAR_SET_VALUE
Definition: parsenodes.h:2615
@ VAR_RESET_ALL
Definition: parsenodes.h:2620
#define ACL_ALTER_SYSTEM
Definition: parsenodes.h:89
#define MAXPGPATH
#define snprintf
Definition: port.h:238
VariableSetStmt * setstmt
Definition: parsenodes.h:3820
VariableSetKind kind
Definition: parsenodes.h:2626
GucContext context
Definition: guc_tables.h:157
enum config_type vartype
Definition: guc_tables.h:163
bool superuser(void)
Definition: superuser.c:46
const char * name
#define stat
Definition: win32_port.h:284
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(), 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 2264 of file guc.c.

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

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

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

◆ AtStart_GUC()

void AtStart_GUC ( void  )

Definition at line 2217 of file guc.c.

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

References elog, GUCNestLevel, and WARNING.

Referenced by StartTransaction().

◆ BeginReportingGUCOptions()

void BeginReportingGUCOptions ( void  )

Definition at line 2548 of file guc.c.

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

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

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

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

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

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

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

◆ DeescapeQuotedString()

char* DeescapeQuotedString ( const char *  s)

◆ DefineCustomBoolVariable()

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

◆ DefineCustomEnumVariable()

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

◆ DefineCustomIntVariable()

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

◆ DefineCustomRealVariable()

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

◆ DefineCustomStringVariable()

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

◆ EstimateGUCStateSpace()

Size EstimateGUCStateSpace ( void  )

Definition at line 5907 of file guc.c.

5908 {
5909  Size size;
5910  dlist_iter iter;
5911 
5912  /* Add space reqd for saving the data size of the guc state */
5913  size = sizeof(Size);
5914 
5915  /*
5916  * Add up the space needed for each GUC variable.
5917  *
5918  * We need only process non-default GUCs.
5919  */
5921  {
5922  struct config_generic *gconf = dlist_container(struct config_generic,
5923  nondef_link, iter.cur);
5924 
5926  }
5927 
5928  return size;
5929 }
size_t Size
Definition: c.h:605
static dlist_head guc_nondef_list
Definition: guc.c:224
static Size estimate_variable_size(struct config_generic *gconf)
Definition: guc.c:5807
#define dlist_foreach(iter, lhead)
Definition: ilist.h:623
#define dlist_container(type, membername, ptr)
Definition: ilist.h:593
Size add_size(Size s1, Size s2)
Definition: shmem.c:493
static pg_noinline void Size size
Definition: slab.c:607
dlist_node nondef_link
Definition: guc_tables.h:173
dlist_node * cur
Definition: ilist.h:179

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

Referenced by InitializeParallelDSM().

◆ ExecSetVariableStmt()

void ExecSetVariableStmt ( VariableSetStmt stmt,
bool  isTopLevel 
)

Definition at line 43 of file guc_funcs.c.

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

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 }
char * GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
Definition: guc.c:5385
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)

◆ get_config_handle()

config_handle* get_config_handle ( const char *  name)

Definition at line 4237 of file guc.c.

4238 {
4239  struct config_generic *gen = find_option(name, false, false, 0);
4240 
4241  if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
4242  return gen;
4243 
4244  return NULL;
4245 }
#define GUC_CUSTOM_PLACEHOLDER
Definition: guc.h:219

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

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

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

4309 {
4310  struct config_generic *record;
4311  static char buffer[256];
4312 
4313  record = find_option(name, false, missing_ok, ERROR);
4314  if (record == NULL)
4315  return NULL;
4316  if (restrict_privileged &&
4317  !ConfigOptionIsVisible(record))
4318  ereport(ERROR,
4319  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4320  errmsg("permission denied to examine \"%s\"", name),
4321  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4322  "pg_read_all_settings")));
4323 
4324  switch (record->vartype)
4325  {
4326  case PGC_BOOL:
4327  return *((struct config_bool *) record)->variable ? "on" : "off";
4328 
4329  case PGC_INT:
4330  snprintf(buffer, sizeof(buffer), "%d",
4331  *((struct config_int *) record)->variable);
4332  return buffer;
4333 
4334  case PGC_REAL:
4335  snprintf(buffer, sizeof(buffer), "%g",
4336  *((struct config_real *) record)->variable);
4337  return buffer;
4338 
4339  case PGC_STRING:
4340  return *((struct config_string *) record)->variable ?
4341  *((struct config_string *) record)->variable : "";
4342 
4343  case PGC_ENUM:
4344  return config_enum_lookup_by_value((struct config_enum *) record,
4345  *((struct config_enum *) record)->variable);
4346  }
4347  return NULL;
4348 }
int errdetail(const char *fmt,...)
Definition: elog.c:1203
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:3025
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 5385 of file guc.c.

5386 {
5387  struct config_generic *record;
5388 
5389  record = find_option(name, false, missing_ok, ERROR);
5390  if (record == NULL)
5391  {
5392  if (varname)
5393  *varname = NULL;
5394  return NULL;
5395  }
5396 
5397  if (!ConfigOptionIsVisible(record))
5398  ereport(ERROR,
5399  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
5400  errmsg("permission denied to examine \"%s\"", name),
5401  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
5402  "pg_read_all_settings")));
5403 
5404  if (varname)
5405  *varname = record->name;
5406 
5407  return ShowGUCOption(record, true);
5408 }
char * ShowGUCOption(struct config_generic *record, bool use_units)
Definition: guc.c:5418
const char * name
Definition: guc_tables.h:156

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

4406 {
4407  struct config_generic *record;
4408 
4409  record = find_option(name, false, missing_ok, ERROR);
4410  if (record == NULL)
4411  return 0;
4412  return record->flags;
4413 }

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

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

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)
386  else
388 }
static void ShowGUCConfigOption(const char *name, DestReceiver *dest)
Definition: guc_funcs.c:428
static void ShowAllGUCConfig(DestReceiver *dest)
Definition: guc_funcs.c:456

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 }
int16 AttrNumber
Definition: attnum.h:21
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:67
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:651

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

Referenced by UtilityTupleDescriptor().

◆ GUC_check_errcode()

void GUC_check_errcode ( int  sqlerrcode)

◆ guc_free()

void guc_free ( void *  ptr)

Definition at line 691 of file guc.c.

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

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

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

◆ guc_malloc()

◆ guc_realloc()

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

Definition at line 654 of file guc.c.

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

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

◆ guc_strdup()

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

Definition at line 679 of file guc.c.

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

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

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

◆ GUCArrayAdd()

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

Definition at line 6447 of file guc.c.

6448 {
6449  struct config_generic *record;
6450  Datum datum;
6451  char *newval;
6452  ArrayType *a;
6453 
6454  Assert(name);
6455  Assert(value);
6456 
6457  /* test if the option is valid and we're allowed to set it */
6458  (void) validate_option_array_item(name, value, false);
6459 
6460  /* normalize name (converts obsolete GUC names to modern spellings) */
6461  record = find_option(name, false, true, WARNING);
6462  if (record)
6463  name = record->name;
6464 
6465  /* build new item for array */
6466  newval = psprintf("%s=%s", name, value);
6467  datum = CStringGetTextDatum(newval);
6468 
6469  if (array)
6470  {
6471  int index;
6472  bool isnull;
6473  int i;
6474 
6475  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6476  Assert(ARR_NDIM(array) == 1);
6477  Assert(ARR_LBOUND(array)[0] == 1);
6478 
6479  index = ARR_DIMS(array)[0] + 1; /* add after end */
6480 
6481  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6482  {
6483  Datum d;
6484  char *current;
6485 
6486  d = array_ref(array, 1, &i,
6487  -1 /* varlenarray */ ,
6488  -1 /* TEXT's typlen */ ,
6489  false /* TEXT's typbyval */ ,
6490  TYPALIGN_INT /* TEXT's typalign */ ,
6491  &isnull);
6492  if (isnull)
6493  continue;
6494  current = TextDatumGetCString(d);
6495 
6496  /* check for match up through and including '=' */
6497  if (strncmp(current, newval, strlen(name) + 1) == 0)
6498  {
6499  index = i;
6500  break;
6501  }
6502  }
6503 
6504  a = array_set(array, 1, &index,
6505  datum,
6506  false,
6507  -1 /* varlena array */ ,
6508  -1 /* TEXT's typlen */ ,
6509  false /* TEXT's typbyval */ ,
6510  TYPALIGN_INT /* TEXT's typalign */ );
6511  }
6512  else
6513  a = construct_array_builtin(&datum, 1, TEXTOID);
6514 
6515  return a;
6516 }
#define ARR_NDIM(a)
Definition: array.h:290
#define ARR_ELEMTYPE(a)
Definition: array.h:292
#define ARR_DIMS(a)
Definition: array.h:294
#define ARR_LBOUND(a)
Definition: array.h:296
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3374
ArrayType * array_set(ArrayType *array, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3156
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:3139
#define CStringGetTextDatum(s)
Definition: builtins.h:97
#define TextDatumGetCString(d)
Definition: builtins.h:98
static bool validate_option_array_item(const char *name, const char *value, bool skipIfNoPermissions)
Definition: guc.c:6667
int a
Definition: isn.c:69
uintptr_t Datum
Definition: postgres.h:64
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
Definition: type.h:95

References a, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), array_set(), Assert, 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 6525 of file guc.c.

6526 {
6527  struct config_generic *record;
6528  ArrayType *newarray;
6529  int i;
6530  int index;
6531 
6532  Assert(name);
6533 
6534  /* test if the option is valid and we're allowed to set it */
6535  (void) validate_option_array_item(name, NULL, false);
6536 
6537  /* normalize name (converts obsolete GUC names to modern spellings) */
6538  record = find_option(name, false, true, WARNING);
6539  if (record)
6540  name = record->name;
6541 
6542  /* if array is currently null, then surely nothing to delete */
6543  if (!array)
6544  return NULL;
6545 
6546  newarray = NULL;
6547  index = 1;
6548 
6549  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6550  {
6551  Datum d;
6552  char *val;
6553  bool isnull;
6554 
6555  d = array_ref(array, 1, &i,
6556  -1 /* varlenarray */ ,
6557  -1 /* TEXT's typlen */ ,
6558  false /* TEXT's typbyval */ ,
6559  TYPALIGN_INT /* TEXT's typalign */ ,
6560  &isnull);
6561  if (isnull)
6562  continue;
6563  val = TextDatumGetCString(d);
6564 
6565  /* ignore entry if it's what we want to delete */
6566  if (strncmp(val, name, strlen(name)) == 0
6567  && val[strlen(name)] == '=')
6568  continue;
6569 
6570  /* else add it to the output array */
6571  if (newarray)
6572  newarray = array_set(newarray, 1, &index,
6573  d,
6574  false,
6575  -1 /* varlenarray */ ,
6576  -1 /* TEXT's typlen */ ,
6577  false /* TEXT's typbyval */ ,
6578  TYPALIGN_INT /* TEXT's typalign */ );
6579  else
6580  newarray = construct_array_builtin(&d, 1, TEXTOID);
6581 
6582  index++;
6583  }
6584 
6585  return newarray;
6586 }
long val
Definition: informix.c:670

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

6596 {
6597  ArrayType *newarray;
6598  int i;
6599  int index;
6600 
6601  /* if array is currently null, nothing to do */
6602  if (!array)
6603  return NULL;
6604 
6605  /* if we're superuser, we can delete everything, so just do it */
6606  if (superuser())
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  char *eqsgn;
6617  bool isnull;
6618 
6619  d = array_ref(array, 1, &i,
6620  -1 /* varlenarray */ ,
6621  -1 /* TEXT's typlen */ ,
6622  false /* TEXT's typbyval */ ,
6623  TYPALIGN_INT /* TEXT's typalign */ ,
6624  &isnull);
6625  if (isnull)
6626  continue;
6627  val = TextDatumGetCString(d);
6628 
6629  eqsgn = strchr(val, '=');
6630  *eqsgn = '\0';
6631 
6632  /* skip if we have permission to delete it */
6633  if (validate_option_array_item(val, NULL, true))
6634  continue;
6635 
6636  /* else add it to the output array */
6637  if (newarray)
6638  newarray = array_set(newarray, 1, &index,
6639  d,
6640  false,
6641  -1 /* varlenarray */ ,
6642  -1 /* TEXT's typlen */ ,
6643  false /* TEXT's typbyval */ ,
6644  TYPALIGN_INT /* TEXT's typalign */ );
6645  else
6646  newarray = construct_array_builtin(&d, 1, TEXTOID);
6647 
6648  index++;
6649  pfree(val);
6650  }
6651 
6652  return newarray;
6653 }

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

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

5233 {
5234  int classLen = strlen(className);
5235  HASH_SEQ_STATUS status;
5236  GUCHashEntry *hentry;
5237  MemoryContext oldcontext;
5238 
5239  /*
5240  * Check for existing placeholders. We must actually remove invalid
5241  * placeholders, else future parallel worker startups will fail. (We
5242  * don't bother trying to free associated memory, since this shouldn't
5243  * happen often.)
5244  */
5245  hash_seq_init(&status, guc_hashtab);
5246  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5247  {
5248  struct config_generic *var = hentry->gucvar;
5249 
5250  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5251  strncmp(className, var->name, classLen) == 0 &&
5252  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5253  {
5254  ereport(WARNING,
5255  (errcode(ERRCODE_INVALID_NAME),
5256  errmsg("invalid configuration parameter name \"%s\", removing it",
5257  var->name),
5258  errdetail("\"%s\" is now a reserved prefix.",
5259  className)));
5260  /* Remove it from the hash table */
5262  &var->name,
5263  HASH_REMOVE,
5264  NULL);
5265  /* Remove it from any lists it's in, too */
5266  RemoveGUCFromLists(var);
5267  }
5268  }
5269 
5270  /* And remember the name so we can prevent future mistakes. */
5273  MemoryContextSwitchTo(oldcontext);
5274 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
static void RemoveGUCFromLists(struct config_generic *gconf)
Definition: guc.c:1763
static List * reserved_class_prefix
Definition: guc.c:78
#define GUC_QUALIFIER_SEPARATOR
Definition: guc.h:204
@ HASH_REMOVE
Definition: hsearch.h:115
List * lappend(List *list, void *datum)
Definition: list.c:339
MemoryContextSwitchTo(old_ctx)

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

Referenced by _PG_init().

◆ NewGUCNestLevel()

◆ parse_int()

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

Definition at line 2873 of file guc.c.

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

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

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

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

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

◆ ParseConfigDirectory()

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

◆ ParseConfigFile()

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

◆ ParseConfigFp()

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

◆ ParseLongOption()

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

Definition at line 6321 of file guc.c.

6322 {
6323  size_t equal_pos;
6324  char *cp;
6325 
6326  Assert(string);
6327  Assert(name);
6328  Assert(value);
6329 
6330  equal_pos = strcspn(string, "=");
6331 
6332  if (string[equal_pos] == '=')
6333  {
6334  *name = palloc(equal_pos + 1);
6335  strlcpy(*name, string, equal_pos + 1);
6336 
6337  *value = pstrdup(&string[equal_pos + 1]);
6338  }
6339  else
6340  {
6341  /* no equal sign in string */
6342  *name = pstrdup(string);
6343  *value = NULL;
6344  }
6345 
6346  for (cp = *name; *cp; cp++)
6347  if (*cp == '-')
6348  *cp = '_';
6349 }
void * palloc(Size size)
Definition: mcxt.c:1316
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()

◆ ProcessGUCArray()

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

Definition at line 6415 of file guc.c.

6417 {
6418  List *gucNames;
6419  List *gucValues;
6420  ListCell *lc1;
6421  ListCell *lc2;
6422 
6423  TransformGUCArray(array, &gucNames, &gucValues);
6424  forboth(lc1, gucNames, lc2, gucValues)
6425  {
6426  char *name = lfirst(lc1);
6427  char *value = lfirst(lc2);
6428 
6429  (void) set_config_option(name, value,
6430  context, source,
6431  action, true, 0, false);
6432 
6433  pfree(name);
6434  pfree(value);
6435  }
6436 
6437  list_free(gucNames);
6438  list_free(gucValues);
6439 }
void TransformGUCArray(ArrayType *array, List **names, List **values)
Definition: guc.c:6358
void list_free(List *list)
Definition: list.c:1546
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:518
static rewind_source * source
Definition: pg_rewind.c:89
tree context
Definition: radixtree.h:1833
Definition: pg_list.h:54

References generate_unaccent_rules::action, context, 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 2598 of file guc.c.

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

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

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

6153 {
6154  char *varname,
6155  *varvalue,
6156  *varsourcefile;
6157  int varsourceline;
6158  GucSource varsource;
6159  GucContext varscontext;
6160  Oid varsrole;
6161  char *srcptr = (char *) gucstate;
6162  char *srcend;
6163  Size len;
6164  dlist_mutable_iter iter;
6165  ErrorContextCallback error_context_callback;
6166 
6167  /*
6168  * First, ensure that all potentially-shippable GUCs are reset to their
6169  * default values. We must not touch those GUCs that the leader will
6170  * never ship, while there is no need to touch those that are shippable
6171  * but already have their default values. Thus, this ends up being the
6172  * same test that SerializeGUCState uses, even though the sets of
6173  * variables involved may well be different since the leader's set of
6174  * variables-not-at-default-values can differ from the set that are
6175  * not-default in this freshly started worker.
6176  *
6177  * Once we have set all the potentially-shippable GUCs to default values,
6178  * restoring the GUCs that the leader sent (because they had non-default
6179  * values over there) leads us to exactly the set of GUC values that the
6180  * leader has. This is true even though the worker may have initially
6181  * absorbed postgresql.conf settings that the leader hasn't yet seen, or
6182  * ALTER USER/DATABASE SET settings that were established after the leader
6183  * started.
6184  *
6185  * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
6186  * also ensures that set_config_option won't refuse to set them because of
6187  * source-priority comparisons.
6188  */
6190  {
6191  struct config_generic *gconf = dlist_container(struct config_generic,
6192  nondef_link, iter.cur);
6193 
6194  /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
6195  if (can_skip_gucvar(gconf))
6196  continue;
6197 
6198  /*
6199  * We can use InitializeOneGUCOption to reset the GUC to default, but
6200  * first we must free any existing subsidiary data to avoid leaking
6201  * memory. The stack must be empty, but we have to clean up all other
6202  * fields. Beware that there might be duplicate value or "extra"
6203  * pointers. We also have to be sure to take it out of any lists it's
6204  * in.
6205  */
6206  Assert(gconf->stack == NULL);
6207  guc_free(gconf->extra);
6208  guc_free(gconf->last_reported);
6209  guc_free(gconf->sourcefile);
6210  switch (gconf->vartype)
6211  {
6212  case PGC_BOOL:
6213  {
6214  struct config_bool *conf = (struct config_bool *) gconf;
6215 
6216  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6217  guc_free(conf->reset_extra);
6218  break;
6219  }
6220  case PGC_INT:
6221  {
6222  struct config_int *conf = (struct config_int *) gconf;
6223 
6224  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6225  guc_free(conf->reset_extra);
6226  break;
6227  }
6228  case PGC_REAL:
6229  {
6230  struct config_real *conf = (struct config_real *) gconf;
6231 
6232  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6233  guc_free(conf->reset_extra);
6234  break;
6235  }
6236  case PGC_STRING:
6237  {
6238  struct config_string *conf = (struct config_string *) gconf;
6239 
6240  guc_free(*conf->variable);
6241  if (conf->reset_val && conf->reset_val != *conf->variable)
6242  guc_free(conf->reset_val);
6243  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6244  guc_free(conf->reset_extra);
6245  break;
6246  }
6247  case PGC_ENUM:
6248  {
6249  struct config_enum *conf = (struct config_enum *) gconf;
6250 
6251  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6252  guc_free(conf->reset_extra);
6253  break;
6254  }
6255  }
6256  /* Remove it from any lists it's in. */
6257  RemoveGUCFromLists(gconf);
6258  /* Now we can reset the struct to PGS_S_DEFAULT state. */
6259  InitializeOneGUCOption(gconf);
6260  }
6261 
6262  /* First item is the length of the subsequent data */
6263  memcpy(&len, gucstate, sizeof(len));
6264 
6265  srcptr += sizeof(len);
6266  srcend = srcptr + len;
6267 
6268  /* If the GUC value check fails, we want errors to show useful context. */
6269  error_context_callback.callback = guc_restore_error_context_callback;
6270  error_context_callback.previous = error_context_stack;
6271  error_context_callback.arg = NULL;
6272  error_context_stack = &error_context_callback;
6273 
6274  /* Restore all the listed GUCs. */
6275  while (srcptr < srcend)
6276  {
6277  int result;
6278  char *error_context_name_and_value[2];
6279 
6280  varname = read_gucstate(&srcptr, srcend);
6281  varvalue = read_gucstate(&srcptr, srcend);
6282  varsourcefile = read_gucstate(&srcptr, srcend);
6283  if (varsourcefile[0])
6284  read_gucstate_binary(&srcptr, srcend,
6285  &varsourceline, sizeof(varsourceline));
6286  else
6287  varsourceline = 0;
6288  read_gucstate_binary(&srcptr, srcend,
6289  &varsource, sizeof(varsource));
6290  read_gucstate_binary(&srcptr, srcend,
6291  &varscontext, sizeof(varscontext));
6292  read_gucstate_binary(&srcptr, srcend,
6293  &varsrole, sizeof(varsrole));
6294 
6295  error_context_name_and_value[0] = varname;
6296  error_context_name_and_value[1] = varvalue;
6297  error_context_callback.arg = &error_context_name_and_value[0];
6298  result = set_config_option_ext(varname, varvalue,
6299  varscontext, varsource, varsrole,
6300  GUC_ACTION_SET, true, ERROR, true);
6301  if (result <= 0)
6302  ereport(ERROR,
6303  (errcode(ERRCODE_INTERNAL_ERROR),
6304  errmsg("parameter \"%s\" could not be set", varname)));
6305  if (varsourcefile[0])
6306  set_config_sourcefile(varname, varsourcefile, varsourceline);
6307  error_context_callback.arg = NULL;
6308  }
6309 
6310  error_context_stack = error_context_callback.previous;
6311 }
ErrorContextCallback * error_context_stack
Definition: elog.c:94
static void guc_restore_error_context_callback(void *arg)
Definition: guc.c:6130
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:3383
static void set_config_sourcefile(const char *name, char *sourcefile, int sourceline)
Definition: guc.c:4252
static char * read_gucstate(char **srcptr, char *srcend)
Definition: guc.c:6093
static bool can_skip_gucvar(struct config_generic *gconf)
Definition: guc.c:5767
static void read_gucstate_binary(char **srcptr, char *srcend, void *dest, Size size)
Definition: guc.c:6116
struct ErrorContextCallback * previous
Definition: elog.h:295
void(* callback)(void *arg)
Definition: elog.h:296
char * last_reported
Definition: guc_tables.h:179
char * sourcefile
Definition: guc_tables.h:181

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

◆ SelectConfigFiles()

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

Definition at line 1786 of file guc.c.

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

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

6061 {
6062  char *curptr;
6063  Size actual_size;
6064  Size bytes_left;
6065  dlist_iter iter;
6066 
6067  /* Reserve space for saving the actual size of the guc state */
6068  Assert(maxsize > sizeof(actual_size));
6069  curptr = start_address + sizeof(actual_size);
6070  bytes_left = maxsize - sizeof(actual_size);
6071 
6072  /* We need only consider GUCs with source not PGC_S_DEFAULT */
6074  {
6075  struct config_generic *gconf = dlist_container(struct config_generic,
6076  nondef_link, iter.cur);
6077 
6078  serialize_variable(&curptr, &bytes_left, gconf);
6079  }
6080 
6081  /* Store actual size without assuming alignment of start_address. */
6082  actual_size = maxsize - bytes_left - sizeof(actual_size);
6083  memcpy(start_address, &actual_size, sizeof(actual_size));
6084 }
static void serialize_variable(char **destptr, Size *maxbytes, struct config_generic *gconf)
Definition: guc.c:5983

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

3347 {
3348  Oid srole;
3349 
3350  /*
3351  * Non-interactive sources should be treated as having all privileges,
3352  * except for PGC_S_CLIENT. Note in particular that this is true for
3353  * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3354  * privilege check was done when the pg_db_role_setting entry was made.
3355  */
3357  srole = GetUserId();
3358  else
3359  srole = BOOTSTRAP_SUPERUSERID;
3360 
3361  return set_config_with_handle(name, NULL, value,
3362  context, source, srole,
3363  action, changeVal, elevel,
3364  is_reload);
3365 }
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:3403

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

Referenced by 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 3383 of file guc.c.

3387 {
3388  return set_config_with_handle(name, NULL, value,
3389  context, source, srole,
3390  action, changeVal, elevel,
3391  is_reload);
3392 }

References generate_unaccent_rules::action, context, 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 3403 of file guc.c.

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

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

Referenced by fmgr_security_definer(), set_config_option(), and set_config_option_ext().

◆ SetConfigOption()

◆ 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,
324  is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET,
325  true, 0, false);
326 }

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

6359 {
6360  int i;
6361 
6362  Assert(array != NULL);
6363  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6364  Assert(ARR_NDIM(array) == 1);
6365  Assert(ARR_LBOUND(array)[0] == 1);
6366 
6367  *names = NIL;
6368  *values = NIL;
6369  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6370  {
6371  Datum d;
6372  bool isnull;
6373  char *s;
6374  char *name;
6375  char *value;
6376 
6377  d = array_ref(array, 1, &i,
6378  -1 /* varlenarray */ ,
6379  -1 /* TEXT's typlen */ ,
6380  false /* TEXT's typbyval */ ,
6381  TYPALIGN_INT /* TEXT's typalign */ ,
6382  &isnull);
6383 
6384  if (isnull)
6385  continue;
6386 
6387  s = TextDatumGetCString(d);
6388 
6389  ParseLongOption(s, &name, &value);
6390  if (!value)
6391  {
6392  ereport(WARNING,
6393  (errcode(ERRCODE_SYNTAX_ERROR),
6394  errmsg("could not parse setting for parameter \"%s\"",
6395  name)));
6396  pfree(name);
6397  continue;
6398  }
6399 
6400  *names = lappend(*names, name);
6401  *values = lappend(*values, value);
6402 
6403  pfree(s);
6404  }
6405 }
static Datum values[MAXATTR]
Definition: bootstrap.c:152
void ParseLongOption(const char *string, char **name, char **value)
Definition: guc.c:6321
#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 498 of file guc_tables.c.

Referenced by AlterSystemSetConfigFile().

◆ application_name

◆ backtrace_functions

PGDLLIMPORT char* backtrace_functions
extern

Definition at line 533 of file guc_tables.c.

Referenced by errfinish().

◆ check_function_bodies

◆ client_min_messages

PGDLLIMPORT int client_min_messages
extern

Definition at line 525 of file guc_tables.c.

Referenced by execute_extension_script(), and should_output_to_client().

◆ cluster_name

◆ ConfigFileName

PGDLLIMPORT char* ConfigFileName
extern

Definition at line 540 of file guc_tables.c.

Referenced by ProcessConfigFileInternal(), and SelectConfigFiles().

◆ current_role_is_superuser

PGDLLIMPORT bool current_role_is_superuser
extern

Definition at line 521 of file guc_tables.c.

Referenced by InitializeParallelDSM().

◆ Debug_pretty_print

PGDLLIMPORT bool Debug_pretty_print
extern

Definition at line 503 of file guc_tables.c.

Referenced by pg_plan_query(), and pg_rewrite_query().

◆ Debug_print_parse

PGDLLIMPORT bool Debug_print_parse
extern

Definition at line 501 of file guc_tables.c.

Referenced by pg_rewrite_query().

◆ Debug_print_plan

PGDLLIMPORT bool Debug_print_plan
extern

Definition at line 500 of file guc_tables.c.

Referenced by pg_plan_query().

◆ Debug_print_rewritten

PGDLLIMPORT bool Debug_print_rewritten
extern

Definition at line 502 of file guc_tables.c.

Referenced by pg_rewrite_query().

◆ external_pid_file

PGDLLIMPORT char* external_pid_file
extern

Definition at line 543 of file guc_tables.c.

Referenced by PostmasterMain(), and unlink_external_pid_file().

◆ GUC_check_errdetail_string

PGDLLIMPORT char* GUC_check_errdetail_string
extern

◆ GUC_check_errhint_string

PGDLLIMPORT char* GUC_check_errhint_string
extern

◆ GUC_check_errmsg_string

PGDLLIMPORT char* GUC_check_errmsg_string
extern

◆ HbaFileName

◆ IdentFileName

PGDLLIMPORT char* IdentFileName
extern

◆ log_btree_build_stats

PGDLLIMPORT bool log_btree_build_stats
extern

◆ log_duration

PGDLLIMPORT bool log_duration
extern

Definition at line 499 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_executor_stats

PGDLLIMPORT bool log_executor_stats
extern

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

Referenced by check_log_duration().

◆ log_min_duration_statement

PGDLLIMPORT int log_min_duration_statement
extern

Definition at line 527 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_min_error_statement

PGDLLIMPORT int log_min_error_statement
extern

Definition at line 523 of file guc_tables.c.

Referenced by check_log_of_query().

◆ log_min_messages

PGDLLIMPORT int log_min_messages
extern

Definition at line 524 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 528 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 529 of file guc_tables.c.

Referenced by bind_param_error_callback(), and exec_bind_message().

◆ log_parser_stats

◆ log_planner_stats

PGDLLIMPORT bool log_planner_stats
extern

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

Referenced by check_log_duration().

◆ log_statement_stats

◆ log_temp_files

PGDLLIMPORT int log_temp_files
extern

Definition at line 530 of file guc_tables.c.

Referenced by ReportTemporaryFileUsage().

◆ log_xact_sample_rate

PGDLLIMPORT double log_xact_sample_rate
extern

Definition at line 532 of file guc_tables.c.

Referenced by StartTransaction().

◆ num_temp_buffers

PGDLLIMPORT int num_temp_buffers
extern

Definition at line 537 of file guc_tables.c.

Referenced by InitLocalBuffers(), and LimitAdditionalLocalPins().

◆ tcp_keepalives_count

PGDLLIMPORT int tcp_keepalives_count
extern

Definition at line 549 of file guc_tables.c.

Referenced by pq_init().

◆ tcp_keepalives_idle

PGDLLIMPORT int tcp_keepalives_idle
extern

Definition at line 547 of file guc_tables.c.

Referenced by pq_init().

◆ tcp_keepalives_interval

PGDLLIMPORT int tcp_keepalives_interval
extern

Definition at line 548 of file guc_tables.c.

Referenced by pq_init().

◆ tcp_user_timeout

PGDLLIMPORT int tcp_user_timeout
extern

Definition at line 550 of file guc_tables.c.

Referenced by pq_init().

◆ temp_file_limit

PGDLLIMPORT int temp_file_limit
extern

Definition at line 535 of file guc_tables.c.

Referenced by FileWriteV().