guc.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <float.h>
#include <math.h>
#include <limits.h>
#include <unistd.h>
#include <sys/stat.h>
#include "access/commit_ts.h"
#include "access/gin.h"
#include "access/rmgr.h"
#include "access/tableam.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xlog_internal.h"
#include "catalog/namespace.h"
#include "catalog/pg_authid.h"
#include "commands/async.h"
#include "commands/prepare.h"
#include "commands/trigger.h"
#include "commands/user.h"
#include "commands/vacuum.h"
#include "commands/variable.h"
#include "common/string.h"
#include "funcapi.h"
#include "jit/jit.h"
#include "libpq/auth.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "optimizer/cost.h"
#include "optimizer/geqo.h"
#include "optimizer/optimizer.h"
#include "optimizer/paths.h"
#include "optimizer/planmain.h"
#include "parser/parse_expr.h"
#include "parser/parse_type.h"
#include "parser/parser.h"
#include "parser/scansup.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "postmaster/bgworker_internals.h"
#include "postmaster/bgwriter.h"
#include "postmaster/postmaster.h"
#include "postmaster/syslogger.h"
#include "postmaster/walwriter.h"
#include "replication/logicallauncher.h"
#include "replication/reorderbuffer.h"
#include "replication/slot.h"
#include "replication/syncrep.h"
#include "replication/walreceiver.h"
#include "replication/walsender.h"
#include "storage/bufmgr.h"
#include "storage/dsm_impl.h"
#include "storage/fd.h"
#include "storage/large_object.h"
#include "storage/pg_shmem.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "storage/standby.h"
#include "tcop/tcopprot.h"
#include "tsearch/ts_cache.h"
#include "utils/builtins.h"
#include "utils/bytea.h"
#include "utils/guc_tables.h"
#include "utils/memutils.h"
#include "utils/pg_locale.h"
#include "utils/pg_lsn.h"
#include "utils/plancache.h"
#include "utils/portal.h"
#include "utils/ps_status.h"
#include "utils/rls.h"
#include "utils/snapmgr.h"
#include "utils/tzparser.h"
#include "utils/varlena.h"
#include "utils/xml.h"
#include "guc-file.c"

Include dependency graph for guc.c:

Go to the source code of this file.

Data Structures
struct	unit_conversion

Macros
#define	PG_KRB_SRVTAB   ""
#define	CONFIG_FILENAME   "postgresql.conf"
#define	HBA_FILENAME   "pg_hba.conf"
#define	IDENT_FILENAME   "pg_ident.conf"
#define	REALTYPE_PRECISION   17
#define	MAX_UNIT_LEN   3 /* length of longest recognized unit string */
#define	newval   (newval_union.boolval)
#define	newval   (newval_union.intval)
#define	newval   (newval_union.realval)
#define	newval   (newval_union.stringval)
#define	newval   (newval_union.enumval)
#define	NUM_PG_SETTINGS_ATTS   17
#define	NUM_PG_FILE_SETTINGS_ATTS   7

Functions
static void	do_serialize (char **destptr, Size *maxbytes, const char *fmt,...) pg_attribute_printf(3
static void static void	set_config_sourcefile (const char *name, char *sourcefile, int sourceline)
static bool	call_bool_check_hook (struct config_bool *conf, bool *newval, void **extra, GucSource source, int elevel)
static bool	call_int_check_hook (struct config_int *conf, int *newval, void **extra, GucSource source, int elevel)
static bool	call_real_check_hook (struct config_real *conf, double *newval, void **extra, GucSource source, int elevel)
static bool	call_string_check_hook (struct config_string *conf, char **newval, void **extra, GucSource source, int elevel)
static bool	call_enum_check_hook (struct config_enum *conf, int *newval, void **extra, GucSource source, int elevel)
static bool	check_log_destination (char **newval, void **extra, GucSource source)
static void	assign_log_destination (const char *newval, void *extra)
static bool	check_wal_consistency_checking (char **newval, void **extra, GucSource source)
static void	assign_wal_consistency_checking (const char *newval, void *extra)
static void	assign_syslog_facility (int newval, void *extra)
static void	assign_syslog_ident (const char *newval, void *extra)
static void	assign_session_replication_role (int newval, void *extra)
static bool	check_temp_buffers (int *newval, void **extra, GucSource source)
static bool	check_bonjour (bool *newval, void **extra, GucSource source)
static bool	check_ssl (bool *newval, void **extra, GucSource source)
static bool	check_stage_log_stats (bool *newval, void **extra, GucSource source)
static bool	check_log_stats (bool *newval, void **extra, GucSource source)
static bool	check_canonical_path (char **newval, void **extra, GucSource source)
static bool	check_timezone_abbreviations (char **newval, void **extra, GucSource source)
static void	assign_timezone_abbreviations (const char *newval, void *extra)
static void	pg_timezone_abbrev_initialize (void)
static const char *	show_archive_command (void)
static void	assign_tcp_keepalives_idle (int newval, void *extra)
static void	assign_tcp_keepalives_interval (int newval, void *extra)
static void	assign_tcp_keepalives_count (int newval, void *extra)
static void	assign_tcp_user_timeout (int newval, void *extra)
static const char *	show_tcp_keepalives_idle (void)
static const char *	show_tcp_keepalives_interval (void)
static const char *	show_tcp_keepalives_count (void)
static const char *	show_tcp_user_timeout (void)
static bool	check_maxconnections (int *newval, void **extra, GucSource source)
static bool	check_max_worker_processes (int *newval, void **extra, GucSource source)
static bool	check_autovacuum_max_workers (int *newval, void **extra, GucSource source)
static bool	check_max_wal_senders (int *newval, void **extra, GucSource source)
static bool	check_autovacuum_work_mem (int *newval, void **extra, GucSource source)
static bool	check_effective_io_concurrency (int *newval, void **extra, GucSource source)
static void	assign_effective_io_concurrency (int newval, void *extra)
static void	assign_pgstat_temp_directory (const char *newval, void *extra)
static bool	check_application_name (char **newval, void **extra, GucSource source)
static void	assign_application_name (const char *newval, void *extra)
static bool	check_cluster_name (char **newval, void **extra, GucSource source)
static const char *	show_unix_socket_permissions (void)
static const char *	show_log_file_mode (void)
static const char *	show_data_directory_mode (void)
static bool	check_backtrace_functions (char **newval, void **extra, GucSource source)
static void	assign_backtrace_functions (const char *newval, void *extra)
static bool	check_recovery_target_timeline (char **newval, void **extra, GucSource source)
static void	assign_recovery_target_timeline (const char *newval, void *extra)
static bool	check_recovery_target (char **newval, void **extra, GucSource source)
static void	assign_recovery_target (const char *newval, void *extra)
static bool	check_recovery_target_xid (char **newval, void **extra, GucSource source)
static void	assign_recovery_target_xid (const char *newval, void *extra)
static bool	check_recovery_target_time (char **newval, void **extra, GucSource source)
static void	assign_recovery_target_time (const char *newval, void *extra)
static bool	check_recovery_target_name (char **newval, void **extra, GucSource source)
static void	assign_recovery_target_name (const char *newval, void *extra)
static bool	check_recovery_target_lsn (char **newval, void **extra, GucSource source)
static void	assign_recovery_target_lsn (const char *newval, void *extra)
static bool	check_primary_slot_name (char **newval, void **extra, GucSource source)
static bool	check_default_with_oids (bool *newval, void **extra, GucSource source)
static ConfigVariable *	ProcessConfigFileInternal (GucContext context, bool applySettings, int elevel)
static int	guc_var_compare (const void *a, const void *b)
static int	guc_name_compare (const char *namea, const char *nameb)
static void	InitializeGUCOptionsFromEnvironment (void)
static void	InitializeOneGUCOption (struct config_generic *gconf)
static void	push_old_value (struct config_generic *gconf, GucAction action)
static void	ReportGUCOption (struct config_generic *record)
static void	reapply_stacked_values (struct config_generic *variable, struct config_string *pHolder, GucStack *stack, const char *curvalue, GucContext curscontext, GucSource cursource)
static void	ShowGUCConfigOption (const char *name, DestReceiver *dest)
static void	ShowAllGUCConfig (DestReceiver *dest)
static char *	_ShowOption (struct config_generic *record, bool use_units)
static bool	validate_option_array_item (const char *name, const char *value, bool skipIfNoPermissions)
static void	write_auto_conf_file (int fd, const char *filename, ConfigVariable *head_p)
static void	replace_auto_config_value (ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
static void *	guc_malloc (int elevel, size_t size)
static void *	guc_realloc (int elevel, void *old, size_t size)
static char *	guc_strdup (int elevel, const char *src)
static bool	string_field_used (struct config_string *conf, char *strval)
static void	set_string_field (struct config_string *conf, char **field, char *newval)
static bool	extra_field_used (struct config_generic *gconf, void *extra)
static void	set_extra_field (struct config_generic *gconf, void **field, void *newval)
static void	set_stack_value (struct config_generic *gconf, config_var_value *val)
static void	discard_stack_value (struct config_generic *gconf, config_var_value *val)
struct config_generic **	get_guc_variables (void)
void	build_guc_variables (void)
static bool	add_guc_variable (struct config_generic *var, int elevel)
static struct config_generic *	add_placeholder_variable (const char *name, int elevel)
static struct config_generic *	find_option (const char *name, bool create_placeholders, int elevel)
void	InitializeGUCOptions (void)
bool	SelectConfigFiles (const char *userDoption, const char *progname)
void	ResetAllOptions (void)
void	AtStart_GUC (void)
int	NewGUCNestLevel (void)
void	AtEOXact_GUC (bool isCommit, int nestLevel)
void	BeginReportingGUCOptions (void)
static bool	convert_to_base_unit (double value, const char *unit, int base_unit, double *base_value)
static void	convert_int_from_base_unit (int64 base_value, int base_unit, int64 *value, const char **unit)
static void	convert_real_from_base_unit (double base_value, int base_unit, double *value, const char **unit)
static 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)
const char *	config_enum_lookup_by_value (struct config_enum *record, int val)
bool	config_enum_lookup_by_name (struct config_enum *record, const char *value, int *retval)
static char *	config_enum_get_options (struct config_enum *record, const char *prefix, const char *suffix, const char *separator)
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)
int	set_config_option (const char *name, const char *value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)
void	SetConfigOption (const char *name, const char *value, GucContext context, GucSource source)
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)
static char *	flatten_set_variable_args (const char *name, List *args)
void	AlterSystemSetConfigFile (AlterSystemStmt *altersysstmt)
void	ExecSetVariableStmt (VariableSetStmt *stmt, bool isTopLevel)
char *	ExtractSetVariableArgs (VariableSetStmt *stmt)
void	SetPGVariable (const char *name, List *args, bool is_local)
Datum	set_config_by_name (PG_FUNCTION_ARGS)
static struct config_generic *	init_custom_variable (const char *name, const char *short_desc, const char *long_desc, GucContext context, int flags, enum config_type type, size_t sz)
static void	define_custom_variable (struct config_generic *variable)
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)
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)
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)
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)
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)
void	EmitWarningsOnPlaceholders (const char *className)
void	GetPGVariable (const char *name, DestReceiver *dest)
TupleDesc	GetPGVariableResultDesc (const char *name)
struct config_generic **	get_explain_guc_options (int *num)
char *	GetConfigOptionByName (const char *name, const char **varname, bool missing_ok)
void	GetConfigOptionByNum (int varnum, const char **values, bool *noshow)
int	GetNumConfigOptions (void)
Datum	show_config_by_name (PG_FUNCTION_ARGS)
Datum	show_config_by_name_missing_ok (PG_FUNCTION_ARGS)
Datum	show_all_settings (PG_FUNCTION_ARGS)
Datum	show_all_file_settings (PG_FUNCTION_ARGS)
static bool	can_skip_gucvar (struct config_generic *gconf)
static Size	estimate_variable_size (struct config_generic *gconf)
Size	EstimateGUCStateSpace (void)
static void	do_serialize_binary (char **destptr, Size *maxbytes, void *val, Size valsize)
static void	serialize_variable (char **destptr, Size *maxbytes, struct config_generic *gconf)
void	SerializeGUCState (Size maxsize, char *start_address)
static char *	read_gucstate (char **srcptr, char *srcend)
static void	read_gucstate_binary (char **srcptr, char *srcend, void *dest, Size size)
static void	guc_restore_error_context_callback (void *arg)
void	RestoreGUCState (void *gucstate)
void	ParseLongOption (const char *string, char **name, char **value)
void	ProcessGUCArray (ArrayType *array, GucContext context, GucSource source, GucAction action)
ArrayType *	GUCArrayAdd (ArrayType *array, const char *name, const char *value)
ArrayType *	GUCArrayDelete (ArrayType *array, const char *name)
ArrayType *	GUCArrayReset (ArrayType *array)
void	GUC_check_errcode (int sqlerrcode)
static void	pg_attribute_noreturn ()

Variables
bool	Log_disconnections
int	CommitDelay
int	CommitSiblings
char *	default_tablespace
char *	temp_tablespaces
bool	ignore_checksum_failure
bool	synchronize_seqscans
static int	GUC_check_errcode_value
char *	GUC_check_errmsg_string
char *	GUC_check_errdetail_string
char *	GUC_check_errhint_string
static int	syslog_facility = 0
static const struct config_enum_entry	bytea_output_options []
static const struct config_enum_entry	client_message_level_options []
static const struct config_enum_entry	server_message_level_options []
static const struct config_enum_entry	intervalstyle_options []
static const struct config_enum_entry	log_error_verbosity_options []
static const struct config_enum_entry	log_statement_options []
static const struct config_enum_entry	isolation_level_options []
static const struct config_enum_entry	session_replication_role_options []
static const struct config_enum_entry	syslog_facility_options []
static const struct config_enum_entry	track_function_options []
static const struct config_enum_entry	xmlbinary_options []
static const struct config_enum_entry	xmloption_options []
static const struct config_enum_entry	backslash_quote_options []
static const struct config_enum_entry	constraint_exclusion_options []
static const struct config_enum_entry	synchronous_commit_options []
static const struct config_enum_entry	huge_pages_options []
static const struct config_enum_entry	force_parallel_mode_options []
static const struct config_enum_entry	plan_cache_mode_options []
static const struct config_enum_entry	password_encryption_options []
const struct config_enum_entry	ssl_protocol_versions_info []
static struct config_enum_entry	shared_memory_options []
const struct config_enum_entry	wal_level_options []
const struct config_enum_entry	archive_mode_options []
const struct config_enum_entry	recovery_target_action_options []
const struct config_enum_entry	sync_method_options []
const struct config_enum_entry	dynamic_shared_memory_options []
bool	log_duration = false
bool	log_parameters_on_error = false
bool	Debug_print_plan = false
bool	Debug_print_parse = false
bool	Debug_print_rewritten = false
bool	Debug_pretty_print = true
bool	log_parser_stats = false
bool	log_planner_stats = false
bool	log_executor_stats = false
bool	log_statement_stats = false
bool	log_btree_build_stats = false
char *	event_source
bool	row_security
bool	check_function_bodies = true
bool	default_with_oids = false
bool	session_auth_is_superuser
int	log_min_error_statement = ERROR
int	log_min_messages = WARNING
int	client_min_messages = NOTICE
int	log_min_duration_sample = -1
int	log_min_duration_statement = -1
int	log_temp_files = -1
double	log_statement_sample_rate = 1.0
double	log_xact_sample_rate = 0
int	trace_recovery_messages = LOG
char *	backtrace_functions
char *	backtrace_symbol_list
int	temp_file_limit = -1
int	num_temp_buffers = 1024
char *	cluster_name = ""
char *	ConfigFileName
char *	HbaFileName
char *	IdentFileName
char *	external_pid_file
char *	pgstat_temp_directory
char *	application_name
int	tcp_keepalives_idle
int	tcp_keepalives_interval
int	tcp_keepalives_count
int	tcp_user_timeout
int	ssl_renegotiation_limit
int	huge_pages
static char *	syslog_ident_str
static double	phony_random_seed
static char *	client_encoding_string
static char *	datestyle_string
static char *	locale_collate
static char *	locale_ctype
static char *	server_encoding_string
static char *	server_version_string
static int	server_version_num
static char *	timezone_string
static char *	log_timezone_string
static char *	timezone_abbreviations_string
static char *	data_directory
static char *	session_authorization_string
static int	max_function_args
static int	max_index_keys
static int	max_identifier_length
static int	block_size
static int	segment_size
static int	wal_block_size
static bool	data_checksums
static bool	integer_datetimes
static bool	assert_enabled
static char *	recovery_target_timeline_string
static char *	recovery_target_string
static char *	recovery_target_xid_string
static char *	recovery_target_name_string
static char *	recovery_target_lsn_string
char *	role_string
const char *const	GucContext_Names []
const char *const	GucSource_Names []
const char *const	config_group_names []
const char *const	config_type_names []
static const char *	memory_units_hint = gettext_noop("Valid units for this parameter are \"B\", \"kB\", \"MB\", \"GB\", and \"TB\".")
static const unit_conversion	memory_unit_conversion_table []
static const char *	time_units_hint = gettext_noop("Valid units for this parameter are \"us\", \"ms\", \"s\", \"min\", \"h\", and \"d\".")
static const unit_conversion	time_unit_conversion_table []
static struct config_bool	ConfigureNamesBool []
static struct config_int	ConfigureNamesInt []
static struct config_real	ConfigureNamesReal []
static struct config_string	ConfigureNamesString []
static struct config_enum	ConfigureNamesEnum []
static const char *const	map_old_guc_names []
static struct config_generic **	guc_variables
static int	num_guc_variables
static int	num_guc_explain_variables
static int	size_guc_variables
static bool	guc_dirty
static bool	reporting_enabled
static int	GUCNestLevel = 0

Macro Definition Documentation

CONFIG_FILENAME

#define CONFIG_FILENAME   "postgresql.conf"

Definition at line 104 of file guc.c.

Referenced by SelectConfigFiles().

HBA_FILENAME

#define HBA_FILENAME   "pg_hba.conf"

Definition at line 105 of file guc.c.

Referenced by SelectConfigFiles().

IDENT_FILENAME

#define IDENT_FILENAME   "pg_ident.conf"

Definition at line 106 of file guc.c.

Referenced by SelectConfigFiles().

MAX_UNIT_LEN

#define MAX_UNIT_LEN   3 /* length of longest recognized unit string */

Definition at line 776 of file guc.c.

Referenced by convert_to_base_unit().

newval [1/5]

#define newval   (newval_union.boolval)

Referenced by _ltree_penalty(), assign_checkpoint_completion_target(), assign_max_wal_size(), assign_recovery_target_name(), AtEOXact_GUC(), ATExecAddColumn(), ATPrepAlterColumnType(), bool_substitute_hook(), brin_inclusion_add_value(), brin_minmax_add_value(), check_foreign_key(), check_recovery_target_time(), check_timezone(), check_XactIsoLevel(), comp_keyword_case_substitute_hook(), echo_substitute_hook(), exec_command_set(), exec_command_setenv(), ExecEvalNextValueExpr(), fetch_count_substitute_hook(), float4_accum(), float8_accum(), g_intbig_penalty(), ghstore_penalty(), gtrgm_penalty(), gtsquery_penalty(), gtsvector_penalty(), GUCArrayAdd(), histcontrol_substitute_hook(), histsize_substitute_hook(), ignoreeof_substitute_hook(), InitializeOneGUCOption(), insert_username(), int2_accum(), int2_accum_inv(), int2_avg_accum(), int2_avg_accum_inv(), int2_sum(), int4_accum(), int4_accum_inv(), int4_avg_accum(), int4_avg_accum_inv(), int4_sum(), int8_accum(), int8_accum_inv(), int8_avg_accum(), int8_avg_accum_inv(), int8_sum(), interval_accum(), interval_accum_inv(), jsonb_insert(), jsonb_set(), ltree_penalty(), numeric_accum_inv(), pg_atomic_compare_exchange_u32_impl(), pg_atomic_compare_exchange_u64_impl(), pg_atomic_fetch_add_u32_impl(), prompt1_hook(), prompt2_hook(), prompt3_hook(), set_config_option(), set_extra_field(), set_string_field(), show_context_substitute_hook(), table_scan_sample_next_tuple(), and verbosity_substitute_hook().

newval [2/5]

#define newval   (newval_union.intval)

newval [3/5]

#define newval   (newval_union.realval)

newval [4/5]

#define newval   (newval_union.stringval)

newval [5/5]

#define newval   (newval_union.enumval)

NUM_PG_FILE_SETTINGS_ATTS

#define NUM_PG_FILE_SETTINGS_ATTS   7

Referenced by show_all_file_settings().

NUM_PG_SETTINGS_ATTS

#define NUM_PG_SETTINGS_ATTS   17

Definition at line 9354 of file guc.c.

Referenced by show_all_settings().

PG_KRB_SRVTAB

#define PG_KRB_SRVTAB   ""

Definition at line 101 of file guc.c.

REALTYPE_PRECISION

#define REALTYPE_PRECISION   17

Definition at line 117 of file guc.c.

Referenced by estimate_variable_size(), and serialize_variable().

Function Documentation

_ShowOption()

static char * _ShowOption ( struct config_generic *  record, bool  use_units  )

static

Definition at line 9601 of file guc.c.

References AllocateFile(), Assert, config_enum_lookup_by_value(), convert_int_from_base_unit(), convert_real_from_base_unit(), elevel, elog, ereport, errcode_for_file_access(), errmsg(), ERROR, FATAL, find_option(), config_generic::flags, fprintf, free, FreeFile(), GUC_ACTION_SET, guc_malloc(), guc_realloc(), GUC_UNIT, i, INT64_FORMAT, IsInitProcessingMode, LOG, config_generic::name, num_guc_variables, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_POSTMASTER, PGC_REAL, PGC_S_DEFAULT, PGC_SIGHUP, PGC_STRING, pstrdup(), config_generic::scontext, set_config_option(), set_config_sourcefile(), config_bool::show_hook, config_int::show_hook, config_real::show_hook, config_string::show_hook, config_enum::show_hook, snprintf, config_generic::source, config_generic::sourcefile, config_generic::sourceline, generate_unaccent_rules::str, val, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by GetConfigOptionByName(), GetConfigOptionByNum(), ReportGUCOption(), and ShowAllGUCConfig().

{
    char        buffer[256];
    const char *val;

    switch (record->vartype)
    {
        case PGC_BOOL:
            {
                struct config_bool *conf = (struct config_bool *) record;

                if (conf->show_hook)
                    val = conf->show_hook();
                else
                    val = *conf->variable ? "on" : "off";
            }
            break;

        case PGC_INT:
            {
                struct config_int *conf = (struct config_int *) record;

                if (conf->show_hook)
                    val = conf->show_hook();
                else
                {
                    /*
                     * Use int64 arithmetic to avoid overflows in units
                     * conversion.
                     */
                    int64       result = *conf->variable;
                    const char *unit;

                    if (use_units && result > 0 && (record->flags & GUC_UNIT))
                        convert_int_from_base_unit(result,
                                                   record->flags & GUC_UNIT,
                                                   &result, &unit);
                    else
                        unit = "";

                    snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
                             result, unit);
                    val = buffer;
                }
            }
            break;

        case PGC_REAL:
            {
                struct config_real *conf = (struct config_real *) record;

                if (conf->show_hook)
                    val = conf->show_hook();
                else
                {
                    double      result = *conf->variable;
                    const char *unit;

                    if (use_units && result > 0 && (record->flags & GUC_UNIT))
                        convert_real_from_base_unit(result,
                                                    record->flags & GUC_UNIT,
                                                    &result, &unit);
                    else
                        unit = "";

                    snprintf(buffer, sizeof(buffer), "%g%s",
                             result, unit);
                    val = buffer;
                }
            }
            break;

        case PGC_STRING:
            {
                struct config_string *conf = (struct config_string *) record;

                if (conf->show_hook)
                    val = conf->show_hook();
                else if (*conf->variable && **conf->variable)
                    val = *conf->variable;
                else
                    val = "";
            }
            break;

        case PGC_ENUM:
            {
                struct config_enum *conf = (struct config_enum *) record;

                if (conf->show_hook)
                    val = conf->show_hook();
                else
                    val = config_enum_lookup_by_value(conf, *conf->variable);
            }
            break;

        default:
            /* just to keep compiler quiet */
            val = "???";
            break;
    }

    return pstrdup(val);
}

add_guc_variable()

static bool add_guc_variable ( struct config_generic *  var, int  elevel  )

static

Definition at line 4999 of file guc.c.

References guc_malloc(), guc_realloc(), guc_var_compare(), and qsort.

Referenced by add_placeholder_variable(), and define_custom_variable().

{
    if (num_guc_variables + 1 >= size_guc_variables)
    {
        /*
         * Increase the vector by 25%
         */
        int         size_vars = size_guc_variables + size_guc_variables / 4;
        struct config_generic **guc_vars;

        if (size_vars == 0)
        {
            size_vars = 100;
            guc_vars = (struct config_generic **)
                guc_malloc(elevel, size_vars * sizeof(struct config_generic *));
        }
        else
        {
            guc_vars = (struct config_generic **)
                guc_realloc(elevel, guc_variables, size_vars * sizeof(struct config_generic *));
        }

        if (guc_vars == NULL)
            return false;       /* out of memory */

        guc_variables = guc_vars;
        size_guc_variables = size_vars;
    }
    guc_variables[num_guc_variables++] = var;
    qsort((void *) guc_variables, num_guc_variables,
          sizeof(struct config_generic *), guc_var_compare);
    return true;
}

add_placeholder_variable()

static struct config_generic* add_placeholder_variable ( const char *  name, int  elevel  )

static

Definition at line 5037 of file guc.c.

References add_guc_variable(), config_generic::context, CUSTOM_OPTIONS, config_generic::flags, free, config_string::gen, config_generic::group, GUC_CUSTOM_PLACEHOLDER, guc_malloc(), GUC_NO_SHOW_ALL, GUC_NOT_IN_SAMPLE, guc_strdup(), config_generic::name, PGC_STRING, PGC_USERSET, config_generic::short_desc, unconstify, config_string::variable, and config_generic::vartype.

Referenced by find_option().

{
    size_t      sz = sizeof(struct config_string) + sizeof(char *);
    struct config_string *var;
    struct config_generic *gen;

    var = (struct config_string *) guc_malloc(elevel, sz);
    if (var == NULL)
        return NULL;
    memset(var, 0, sz);
    gen = &var->gen;

    gen->name = guc_strdup(elevel, name);
    if (gen->name == NULL)
    {
        free(var);
        return NULL;
    }

    gen->context = PGC_USERSET;
    gen->group = CUSTOM_OPTIONS;
    gen->short_desc = "GUC placeholder variable";
    gen->flags = GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE | GUC_CUSTOM_PLACEHOLDER;
    gen->vartype = PGC_STRING;

    /*
     * The char* is allocated at the end of the struct since we have no
     * 'static' place to point to.  Note that the current value, as well as
     * the boot and reset values, start out NULL.
     */
    var->variable = (char **) (var + 1);

    if (!add_guc_variable((struct config_generic *) var, elevel))
    {
        free(unconstify(char *, gen->name));
        free(var);
        return NULL;
    }

    return gen;
}

AlterSystemSetConfigFile()

void AlterSystemSetConfigFile

(

AlterSystemStmt *

altersysstmt

)

Definition at line 7969 of file guc.c.

References AllocateFile(), BasicOpenFile(), close, config_generic::context, durable_rename(), elog, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, ExtractSetVariableArgs(), find_option(), config_generic::flags, free, FreeConfigVariables(), FreeFile(), GUC_DISALLOW_IN_AUTO_FILE, GUC_DISALLOW_IN_FILE, infile(), VariableSetStmt::kind, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAXPGPATH, name, VariableSetStmt::name, parse_and_validate_value(), ParseConfigFp(), PG_AUTOCONF_FILENAME, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PGC_INTERNAL, PGC_S_FILE, PGC_STRING, replace_auto_config_value(), AlterSystemStmt::setstmt, snprintf, stat, config_var_val::stringval, 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().

{
    char       *name;
    char       *value;
    bool        resetall = false;
    ConfigVariable *head = NULL;
    ConfigVariable *tail = NULL;
    volatile int Tmpfd;
    char        AutoConfFileName[MAXPGPATH];
    char        AutoConfTmpFileName[MAXPGPATH];

    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 (errmsg("must be superuser to execute ALTER SYSTEM command"))));

    /*
     * Extract statement arguments
     */
    name = altersysstmt->setstmt->name;

    switch (altersysstmt->setstmt->kind)
    {
        case VAR_SET_VALUE:
            value = ExtractSetVariableArgs(altersysstmt->setstmt);
            break;

        case VAR_SET_DEFAULT:
        case VAR_RESET:
            value = NULL;
            break;

        case VAR_RESET_ALL:
            value = NULL;
            resetall = true;
            break;

        default:
            elog(ERROR, "unrecognized alter system stmt type: %d",
                 altersysstmt->setstmt->kind);
            break;
    }

    /*
     * Unless it's RESET_ALL, validate the target variable and value
     */
    if (!resetall)
    {
        struct config_generic *record;

        record = find_option(name, false, ERROR);
        if (record == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("unrecognized configuration parameter \"%s\"",
                            name)));

        /*
         * Don't allow parameters that can't be set in configuration files to
         * be set in PG_AUTOCONF_FILENAME file.
         */
        if ((record->context == PGC_INTERNAL) ||
            (record->flags & GUC_DISALLOW_IN_FILE) ||
            (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
            ereport(ERROR,
                    (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                     errmsg("parameter \"%s\" cannot be changed",
                            name)));

        /*
         * If a value is specified, verify that it's sane.
         */
        if (value)
        {
            union config_var_val newval;
            void       *newextra = NULL;

            /* Check that it's acceptable for the indicated parameter */
            if (!parse_and_validate_value(record, name, value,
                                          PGC_S_FILE, ERROR,
                                          &newval, &newextra))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("invalid value for parameter \"%s\": \"%s\"",
                                name, value)));

            if (record->vartype == PGC_STRING && newval.stringval != NULL)
                free(newval.stringval);
            if (newextra)
                free(newextra);

            /*
             * We must also reject values containing newlines, because the
             * grammar for config files doesn't support embedded newlines in
             * string literals.
             */
            if (strchr(value, '\n'))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
        }
    }

    /*
     * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
     * the data directory, so we can reference them by simple relative paths.
     */
    snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
             PG_AUTOCONF_FILENAME);
    snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
             AutoConfFileName,
             "tmp");

    /*
     * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
     * time.  Use AutoFileLock to ensure that.  We must hold the lock while
     * reading the old file contents.
     */
    LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);

    /*
     * If we're going to reset everything, then no need to open or parse the
     * old file.  We'll just write out an empty list.
     */
    if (!resetall)
    {
        struct stat st;

        if (stat(AutoConfFileName, &st) == 0)
        {
            /* open old file PG_AUTOCONF_FILENAME */
            FILE       *infile;

            infile = AllocateFile(AutoConfFileName, "r");
            if (infile == NULL)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not open file \"%s\": %m",
                                AutoConfFileName)));

            /* parse it */
            if (!ParseConfigFp(infile, AutoConfFileName, 0, LOG, &head, &tail))
                ereport(ERROR,
                        (errcode(ERRCODE_CONFIG_FILE_ERROR),
                         errmsg("could not parse contents of file \"%s\"",
                                AutoConfFileName)));

            FreeFile(infile);
        }

        /*
         * Now, replace any existing entry with the new value, or add it if
         * not present.
         */
        replace_auto_config_value(&head, &tail, name, value);
    }

    /*
     * To ensure crash safety, first write the new file data to a temp file,
     * then atomically rename it into place.
     *
     * If there is a temp file left over due to a previous crash, it's okay to
     * truncate and reuse it.
     */
    Tmpfd = BasicOpenFile(AutoConfTmpFileName,
                          O_CREAT | O_RDWR | O_TRUNC);
    if (Tmpfd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m",
                        AutoConfTmpFileName)));

    /*
     * Use a TRY block to clean up the file if we fail.  Since we need a TRY
     * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
     */
    PG_TRY();
    {
        /* Write and sync the new contents to the temporary file */
        write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);

        /* Close before renaming; may be required on some platforms */
        close(Tmpfd);
        Tmpfd = -1;

        /*
         * As the rename is atomic operation, if any problem occurs after this
         * at worst it can lose the parameters set by last ALTER SYSTEM
         * command.
         */
        durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
    }
    PG_CATCH();
    {
        /* Close file first, else unlink might fail on some platforms */
        if (Tmpfd >= 0)
            close(Tmpfd);

        /* Unlink, but ignore any error */
        (void) unlink(AutoConfTmpFileName);

        PG_RE_THROW();
    }
    PG_END_TRY();

    FreeConfigVariables(head);

    LWLockRelease(AutoFileLock);
}

assign_application_name()

static void assign_application_name ( const char *  newval, void *  extra  )

static

Definition at line 11486 of file guc.c.

References pgstat_report_appname().

{
    /* Update the pg_stat_activity view */
    pgstat_report_appname(newval);
}

assign_backtrace_functions()

static void assign_backtrace_functions ( const char *  newval, void *  extra  )

static

Definition at line 11593 of file guc.c.

{
    backtrace_symbol_list = (char *) extra;
}

assign_effective_io_concurrency()

static void assign_effective_io_concurrency ( int  newval, void *  extra  )

static

Definition at line 11440 of file guc.c.

References target_prefetch_pages.

{
#ifdef USE_PREFETCH
    target_prefetch_pages = *((int *) extra);
#endif                          /* USE_PREFETCH */
}

assign_log_destination()

static void assign_log_destination ( const char *  newval, void *  extra  )

static

Definition at line 11095 of file guc.c.

References Log_destination.

{
    Log_destination = *((int *) extra);
}

assign_pgstat_temp_directory()

static void assign_pgstat_temp_directory ( const char *  newval, void *  extra  )

static

Definition at line 11448 of file guc.c.

References ERROR, free, guc_malloc(), pgstat_stat_directory, pgstat_stat_filename, pgstat_stat_tmpname, and sprintf.

{
    /* check_canonical_path already canonicalized newval for us */
    char       *dname;
    char       *tname;
    char       *fname;

    /* directory */
    dname = guc_malloc(ERROR, strlen(newval) + 1);  /* runtime dir */
    sprintf(dname, "%s", newval);

    /* global stats */
    tname = guc_malloc(ERROR, strlen(newval) + 12); /* /global.tmp */
    sprintf(tname, "%s/global.tmp", newval);
    fname = guc_malloc(ERROR, strlen(newval) + 13); /* /global.stat */
    sprintf(fname, "%s/global.stat", newval);

    if (pgstat_stat_directory)
        free(pgstat_stat_directory);
    pgstat_stat_directory = dname;
    if (pgstat_stat_tmpname)
        free(pgstat_stat_tmpname);
    pgstat_stat_tmpname = tname;
    if (pgstat_stat_filename)
        free(pgstat_stat_filename);
    pgstat_stat_filename = fname;
}

assign_recovery_target()

static void assign_recovery_target ( const char *  newval, void *  extra  )

static

Definition at line 11672 of file guc.c.

References RECOVERY_TARGET_IMMEDIATE, RECOVERY_TARGET_UNSET, and recoveryTarget.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_IMMEDIATE)
        error_multiple_recovery_targets();

    if (newval && strcmp(newval, "") != 0)
        recoveryTarget = RECOVERY_TARGET_IMMEDIATE;
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

assign_recovery_target_lsn()

static void assign_recovery_target_lsn ( const char *  newval, void *  extra  )

static

Definition at line 11840 of file guc.c.

References RECOVERY_TARGET_LSN, RECOVERY_TARGET_UNSET, recoveryTarget, and recoveryTargetLSN.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_LSN)
        error_multiple_recovery_targets();

    if (newval && strcmp(newval, "") != 0)
    {
        recoveryTarget = RECOVERY_TARGET_LSN;
        recoveryTargetLSN = *((XLogRecPtr *) extra);
    }
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

assign_recovery_target_name()

static void assign_recovery_target_name ( const char *  newval, void *  extra  )

static

Definition at line 11804 of file guc.c.

References newval, RECOVERY_TARGET_NAME, RECOVERY_TARGET_UNSET, recoveryTarget, and recoveryTargetName.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_NAME)
        error_multiple_recovery_targets();

    if (newval && strcmp(newval, "") != 0)
    {
        recoveryTarget = RECOVERY_TARGET_NAME;
        recoveryTargetName = newval;
    }
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

assign_recovery_target_time()

static void assign_recovery_target_time ( const char *  newval, void *  extra  )

static

Definition at line 11778 of file guc.c.

References RECOVERY_TARGET_TIME, RECOVERY_TARGET_UNSET, and recoveryTarget.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_TIME)
        error_multiple_recovery_targets();

    if (newval && strcmp(newval, "") != 0)
        recoveryTarget = RECOVERY_TARGET_TIME;
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

assign_recovery_target_timeline()

static void assign_recovery_target_timeline ( const char *  newval, void *  extra  )

static

Definition at line 11629 of file guc.c.

References RECOVERY_TARGET_TIMELINE_NUMERIC, recoveryTargetTimeLineGoal, and recoveryTargetTLIRequested.

{
    recoveryTargetTimeLineGoal = *((RecoveryTargetTimeLineGoal *) extra);
    if (recoveryTargetTimeLineGoal == RECOVERY_TARGET_TIMELINE_NUMERIC)
        recoveryTargetTLIRequested = (TimeLineID) strtoul(newval, NULL, 0);
    else
        recoveryTargetTLIRequested = 0;
}

assign_recovery_target_xid()

static void assign_recovery_target_xid ( const char *  newval, void *  extra  )

static

Definition at line 11705 of file guc.c.

References RECOVERY_TARGET_UNSET, RECOVERY_TARGET_XID, recoveryTarget, and recoveryTargetXid.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_XID)
        error_multiple_recovery_targets();

    if (newval && strcmp(newval, "") != 0)
    {
        recoveryTarget = RECOVERY_TARGET_XID;
        recoveryTargetXid = *((TransactionId *) extra);
    }
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

assign_session_replication_role()

static void assign_session_replication_role ( int  newval, void *  extra  )

static

Definition at line 11121 of file guc.c.

References ResetPlanCache(), and SessionReplicationRole.

{
    /*
     * Must flush the plan cache when changing replication role; but don't
     * flush unnecessarily.
     */
    if (SessionReplicationRole != newval)
        ResetPlanCache();
}

assign_syslog_facility()

static void assign_syslog_facility ( int  newval, void *  extra  )

static

Definition at line 11101 of file guc.c.

{
#ifdef HAVE_SYSLOG
    set_syslog_parameters(syslog_ident_str ? syslog_ident_str : "postgres",
                          newval);
#endif
    /* Without syslog support, just ignore it */
}

assign_syslog_ident()

static void assign_syslog_ident ( const char *  newval, void *  extra  )

static

Definition at line 11111 of file guc.c.

{
#ifdef HAVE_SYSLOG
    set_syslog_parameters(newval, syslog_facility);
#endif
    /* Without syslog support, it will always be set to "none", so ignore */
}

assign_tcp_keepalives_count()

static void assign_tcp_keepalives_count ( int  newval, void *  extra  )

static

Definition at line 11320 of file guc.c.

References MyProcPort, and pq_setkeepalivescount().

{
    /* See comments in assign_tcp_keepalives_idle */
    (void) pq_setkeepalivescount(newval, MyProcPort);
}

assign_tcp_keepalives_idle()

static void assign_tcp_keepalives_idle ( int  newval, void *  extra  )

static

Definition at line 11276 of file guc.c.

References MyProcPort, and pq_setkeepalivesidle().

{
    /*
     * The kernel API provides no way to test a value without setting it; and
     * once we set it we might fail to unset it.  So there seems little point
     * in fully implementing the check-then-assign GUC API for these
     * variables.  Instead we just do the assignment on demand.  pqcomm.c
     * reports any problems via elog(LOG).
     *
     * This approach means that the GUC value might have little to do with the
     * actual kernel value, so we use a show_hook that retrieves the kernel
     * value rather than trusting GUC's copy.
     */
    (void) pq_setkeepalivesidle(newval, MyProcPort);
}

assign_tcp_keepalives_interval()

static void assign_tcp_keepalives_interval ( int  newval, void *  extra  )

static

Definition at line 11303 of file guc.c.

References MyProcPort, and pq_setkeepalivesinterval().

{
    /* See comments in assign_tcp_keepalives_idle */
    (void) pq_setkeepalivesinterval(newval, MyProcPort);
}

assign_tcp_user_timeout()

static void assign_tcp_user_timeout ( int  newval, void *  extra  )

static

Definition at line 11337 of file guc.c.

References MyProcPort, and pq_settcpusertimeout().

{
    /* See comments in assign_tcp_keepalives_idle */
    (void) pq_settcpusertimeout(newval, MyProcPort);
}

assign_timezone_abbreviations()

static void assign_timezone_abbreviations ( const char *  newval, void *  extra  )

static

Definition at line 11240 of file guc.c.

References InstallTimeZoneAbbrevs().

{
    /* Do nothing for the boot_val default of NULL */
    if (!extra)
        return;

    InstallTimeZoneAbbrevs((TimeZoneAbbrevTable *) extra);
}

assign_wal_consistency_checking()

static void assign_wal_consistency_checking ( const char *  newval, void *  extra  )

static

Definition at line 11032 of file guc.c.

References wal_consistency_checking.

{
    wal_consistency_checking = (bool *) extra;
}

AtEOXact_GUC()

void AtEOXact_GUC	(	bool	isCommit,
		int	nestLevel
	)

Definition at line 5792 of file guc.c.

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, 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_REPORT, GUC_SAVE, GUC_SET, GUC_SET_LOCAL, i, config_var_val::intval, guc_stack::masked, guc_stack::masked_scontext, guc_stack::nest_level, newval, num_guc_variables, pfree(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_SESSION, PGC_STRING, guc_stack::prev, guc_stack::prior, config_var_val::realval, ReportGUCOption(), guc_stack::scontext, config_generic::scontext, set_extra_field(), set_string_field(), guc_stack::source, config_generic::source, config_generic::stack, guc_stack::state, 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(), CommitSubTransaction(), CommitTransaction(), DefineIndex(), do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), execute_extension_script(), fmgr_security_definer(), index_build(), PrepareTransaction(), ProcedureCreate(), reset_transmission_modes(), restoreLocalGucs(), RI_Initial_Check(), RI_PartitionRemove_Check(), vacuum_rel(), and validate_index().

{
    bool        still_dirty;
    int         i;

    /*
     * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
     * abort, if there is a failure during transaction start before
     * AtStart_GUC is called.
     */
    Assert(nestLevel > 0 &&
           (nestLevel <= GUCNestLevel ||
            (nestLevel == GUCNestLevel + 1 && !isCommit)));

    /* Quick exit if nothing's changed in this transaction */
    if (!guc_dirty)
    {
        GUCNestLevel = nestLevel - 1;
        return;
    }

    still_dirty = false;
    for (i = 0; i < num_guc_variables; i++)
    {
        struct config_generic *gconf = guc_variables[i];
        GucStack   *stack;

        /*
         * Process and pop each stack entry within the nest level. To simplify
         * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
         * we allow failure exit from code that uses a local nest level to be
         * recovered at the surrounding transaction or subtransaction abort;
         * so there could be more than one stack entry to pop.
         */
        while ((stack = gconf->stack) != NULL &&
               stack->nest_level >= nestLevel)
        {
            GucStack   *prev = stack->prev;
            bool        restorePrior = false;
            bool        restoreMasked = false;
            bool        changed;

            /*
             * In this next bit, if we don't set either restorePrior or
             * restoreMasked, we must "discard" any unwanted fields of the
             * stack entries to avoid leaking memory.  If we do set one of
             * those flags, unused fields will be cleaned up after restoring.
             */
            if (!isCommit)      /* if abort, always restore prior value */
                restorePrior = true;
            else if (stack->state == GUC_SAVE)
                restorePrior = true;
            else if (stack->nest_level == 1)
            {
                /* transaction commit */
                if (stack->state == GUC_SET_LOCAL)
                    restoreMasked = true;
                else if (stack->state == GUC_SET)
                {
                    /* we keep the current active value */
                    discard_stack_value(gconf, &stack->prior);
                }
                else            /* must be GUC_LOCAL */
                    restorePrior = true;
            }
            else if (prev == NULL ||
                     prev->nest_level < stack->nest_level - 1)
            {
                /* decrement entry's level and do not pop it */
                stack->nest_level--;
                continue;
            }
            else
            {
                /*
                 * We have to merge this stack entry into prev. See README for
                 * discussion of this bit.
                 */
                switch (stack->state)
                {
                    case GUC_SAVE:
                        Assert(false);  /* can't get here */
                        break;

                    case GUC_SET:
                        /* next level always becomes SET */
                        discard_stack_value(gconf, &stack->prior);
                        if (prev->state == GUC_SET_LOCAL)
                            discard_stack_value(gconf, &prev->masked);
                        prev->state = GUC_SET;
                        break;

                    case GUC_LOCAL:
                        if (prev->state == GUC_SET)
                        {
                            /* LOCAL migrates down */
                            prev->masked_scontext = stack->scontext;
                            prev->masked = stack->prior;
                            prev->state = GUC_SET_LOCAL;
                        }
                        else
                        {
                            /* else just forget this stack level */
                            discard_stack_value(gconf, &stack->prior);
                        }
                        break;

                    case GUC_SET_LOCAL:
                        /* prior state at this level no longer wanted */
                        discard_stack_value(gconf, &stack->prior);
                        /* copy down the masked state */
                        prev->masked_scontext = stack->masked_scontext;
                        if (prev->state == GUC_SET_LOCAL)
                            discard_stack_value(gconf, &prev->masked);
                        prev->masked = stack->masked;
                        prev->state = GUC_SET_LOCAL;
                        break;
                }
            }

            changed = false;

            if (restorePrior || restoreMasked)
            {
                /* Perform appropriate restoration of the stacked value */
                config_var_value newvalue;
                GucSource   newsource;
                GucContext  newscontext;

                if (restoreMasked)
                {
                    newvalue = stack->masked;
                    newsource = PGC_S_SESSION;
                    newscontext = stack->masked_scontext;
                }
                else
                {
                    newvalue = stack->prior;
                    newsource = stack->source;
                    newscontext = stack->scontext;
                }

                switch (gconf->vartype)
                {
                    case PGC_BOOL:
                        {
                            struct config_bool *conf = (struct config_bool *) gconf;
                            bool        newval = newvalue.val.boolval;
                            void       *newextra = newvalue.extra;

                            if (*conf->variable != newval ||
                                conf->gen.extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                *conf->variable = newval;
                                set_extra_field(&conf->gen, &conf->gen.extra,
                                                newextra);
                                changed = true;
                            }
                            break;
                        }
                    case PGC_INT:
                        {
                            struct config_int *conf = (struct config_int *) gconf;
                            int         newval = newvalue.val.intval;
                            void       *newextra = newvalue.extra;

                            if (*conf->variable != newval ||
                                conf->gen.extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                *conf->variable = newval;
                                set_extra_field(&conf->gen, &conf->gen.extra,
                                                newextra);
                                changed = true;
                            }
                            break;
                        }
                    case PGC_REAL:
                        {
                            struct config_real *conf = (struct config_real *) gconf;
                            double      newval = newvalue.val.realval;
                            void       *newextra = newvalue.extra;

                            if (*conf->variable != newval ||
                                conf->gen.extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                *conf->variable = newval;
                                set_extra_field(&conf->gen, &conf->gen.extra,
                                                newextra);
                                changed = true;
                            }
                            break;
                        }
                    case PGC_STRING:
                        {
                            struct config_string *conf = (struct config_string *) gconf;
                            char       *newval = newvalue.val.stringval;
                            void       *newextra = newvalue.extra;

                            if (*conf->variable != newval ||
                                conf->gen.extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                set_string_field(conf, conf->variable, newval);
                                set_extra_field(&conf->gen, &conf->gen.extra,
                                                newextra);
                                changed = true;
                            }

                            /*
                             * Release stacked values if not used anymore. We
                             * could use discard_stack_value() here, but since
                             * we have type-specific code anyway, might as
                             * well inline it.
                             */
                            set_string_field(conf, &stack->prior.val.stringval, NULL);
                            set_string_field(conf, &stack->masked.val.stringval, NULL);
                            break;
                        }
                    case PGC_ENUM:
                        {
                            struct config_enum *conf = (struct config_enum *) gconf;
                            int         newval = newvalue.val.enumval;
                            void       *newextra = newvalue.extra;

                            if (*conf->variable != newval ||
                                conf->gen.extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                *conf->variable = newval;
                                set_extra_field(&conf->gen, &conf->gen.extra,
                                                newextra);
                                changed = true;
                            }
                            break;
                        }
                }

                /*
                 * Release stacked extra values if not used anymore.
                 */
                set_extra_field(gconf, &(stack->prior.extra), NULL);
                set_extra_field(gconf, &(stack->masked.extra), NULL);

                /* And restore source information */
                gconf->source = newsource;
                gconf->scontext = newscontext;
            }

            /* Finish popping the state stack */
            gconf->stack = prev;
            pfree(stack);

            /* Report new value if we changed it */
            if (changed && (gconf->flags & GUC_REPORT))
                ReportGUCOption(gconf);
        }                       /* end of stack-popping loop */

        if (stack != NULL)
            still_dirty = true;
    }

    /* If there are no remaining stack entries, we can reset guc_dirty */
    guc_dirty = still_dirty;

    /* Update nesting level */
    GUCNestLevel = nestLevel - 1;
}

AtStart_GUC()

void AtStart_GUC

(

void

)

Definition at line 5758 of file guc.c.

References elog, and WARNING.

Referenced by StartTransaction().

{
    /*
     * The nest level should be 0 between transactions; if it isn't, somebody
     * didn't call AtEOXact_GUC, or called it with the wrong nestLevel.  We
     * throw a warning but make no other effort to clean up.
     */
    if (GUCNestLevel != 0)
        elog(WARNING, "GUC nest level = %d at transaction start",
             GUCNestLevel);
    GUCNestLevel = 1;
}

BeginReportingGUCOptions()

void BeginReportingGUCOptions

(

void

)

Definition at line 6074 of file guc.c.

References DestRemote, config_generic::flags, FrontendProtocol, GUC_REPORT, i, num_guc_variables, PG_PROTOCOL_MAJOR, ReportGUCOption(), and whereToSendOutput.

Referenced by PostgresMain().

{
    int         i;

    /*
     * Don't do anything unless talking to an interactive frontend of protocol
     * 3.0 or later.
     */
    if (whereToSendOutput != DestRemote ||
        PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
        return;

    reporting_enabled = true;

    /* Transmit initial values of interesting variables */
    for (i = 0; i < num_guc_variables; i++)
    {
        struct config_generic *conf = guc_variables[i];

        if (conf->flags & GUC_REPORT)
            ReportGUCOption(conf);
    }
}

build_guc_variables()

void build_guc_variables

(

void

)

Definition at line 4895 of file guc.c.

References FATAL, config_generic::flags, free, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_EXPLAIN, guc_malloc(), guc_var_compare(), i, config_generic::name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, qsort, and config_generic::vartype.

Referenced by GucInfoMain(), and InitializeGUCOptions().

{
    int         size_vars;
    int         num_vars = 0;
    int         num_explain_vars = 0;
    struct config_generic **guc_vars;
    int         i;

    for (i = 0; ConfigureNamesBool[i].gen.name; i++)
    {
        struct config_bool *conf = &ConfigureNamesBool[i];

        /* Rather than requiring vartype to be filled in by hand, do this: */
        conf->gen.vartype = PGC_BOOL;
        num_vars++;

        if (conf->gen.flags & GUC_EXPLAIN)
            num_explain_vars++;
    }

    for (i = 0; ConfigureNamesInt[i].gen.name; i++)
    {
        struct config_int *conf = &ConfigureNamesInt[i];

        conf->gen.vartype = PGC_INT;
        num_vars++;

        if (conf->gen.flags & GUC_EXPLAIN)
            num_explain_vars++;
    }

    for (i = 0; ConfigureNamesReal[i].gen.name; i++)
    {
        struct config_real *conf = &ConfigureNamesReal[i];

        conf->gen.vartype = PGC_REAL;
        num_vars++;

        if (conf->gen.flags & GUC_EXPLAIN)
            num_explain_vars++;
    }

    for (i = 0; ConfigureNamesString[i].gen.name; i++)
    {
        struct config_string *conf = &ConfigureNamesString[i];

        conf->gen.vartype = PGC_STRING;
        num_vars++;

        if (conf->gen.flags & GUC_EXPLAIN)
            num_explain_vars++;
    }

    for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
    {
        struct config_enum *conf = &ConfigureNamesEnum[i];

        conf->gen.vartype = PGC_ENUM;
        num_vars++;

        if (conf->gen.flags & GUC_EXPLAIN)
            num_explain_vars++;
    }

    /*
     * Create table with 20% slack
     */
    size_vars = num_vars + num_vars / 4;

    guc_vars = (struct config_generic **)
        guc_malloc(FATAL, size_vars * sizeof(struct config_generic *));

    num_vars = 0;

    for (i = 0; ConfigureNamesBool[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesBool[i].gen;

    for (i = 0; ConfigureNamesInt[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesInt[i].gen;

    for (i = 0; ConfigureNamesReal[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesReal[i].gen;

    for (i = 0; ConfigureNamesString[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesString[i].gen;

    for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesEnum[i].gen;

    if (guc_variables)
        free(guc_variables);
    guc_variables = guc_vars;
    num_guc_variables = num_vars;
    num_guc_explain_variables = num_explain_vars;
    size_guc_variables = size_vars;
    qsort((void *) guc_variables, num_guc_variables,
          sizeof(struct config_generic *), guc_var_compare);
}

call_bool_check_hook()

static bool call_bool_check_hook ( struct config_bool *  conf, bool *  newval, void **  extra, GucSource  source, int  elevel  )

static

Definition at line 10782 of file guc.c.

References config_bool::check_hook, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_bool::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

{
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;

    /* Reset variables that might be set by hook */
    GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
    GUC_check_errmsg_string = NULL;
    GUC_check_errdetail_string = NULL;
    GUC_check_errhint_string = NULL;

    if (!conf->check_hook(newval, extra, source))
    {
        ereport(elevel,
                (errcode(GUC_check_errcode_value),
                 GUC_check_errmsg_string ?
                 errmsg_internal("%s", GUC_check_errmsg_string) :
                 errmsg("invalid value for parameter \"%s\": %d",
                        conf->gen.name, (int) *newval),
                 GUC_check_errdetail_string ?
                 errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                 GUC_check_errhint_string ?
                 errhint("%s", GUC_check_errhint_string) : 0));
        /* Flush any strings created in ErrorContext */
        FlushErrorState();
        return false;
    }

    return true;
}

call_enum_check_hook()

static bool call_enum_check_hook ( struct config_enum *  conf, int *  newval, void **  extra, GucSource  source, int  elevel  )

static

Definition at line 10918 of file guc.c.

References config_enum::check_hook, config_enum_lookup_by_value(), ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_enum::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

{
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;

    /* Reset variables that might be set by hook */
    GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
    GUC_check_errmsg_string = NULL;
    GUC_check_errdetail_string = NULL;
    GUC_check_errhint_string = NULL;

    if (!conf->check_hook(newval, extra, source))
    {
        ereport(elevel,
                (errcode(GUC_check_errcode_value),
                 GUC_check_errmsg_string ?
                 errmsg_internal("%s", GUC_check_errmsg_string) :
                 errmsg("invalid value for parameter \"%s\": \"%s\"",
                        conf->gen.name,
                        config_enum_lookup_by_value(conf, *newval)),
                 GUC_check_errdetail_string ?
                 errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                 GUC_check_errhint_string ?
                 errhint("%s", GUC_check_errhint_string) : 0));
        /* Flush any strings created in ErrorContext */
        FlushErrorState();
        return false;
    }

    return true;
}

call_int_check_hook()

static bool call_int_check_hook ( struct config_int *  conf, int *  newval, void **  extra, GucSource  source, int  elevel  )

static

Definition at line 10816 of file guc.c.

References config_int::check_hook, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_int::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

{
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;

    /* Reset variables that might be set by hook */
    GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
    GUC_check_errmsg_string = NULL;
    GUC_check_errdetail_string = NULL;
    GUC_check_errhint_string = NULL;

    if (!conf->check_hook(newval, extra, source))
    {
        ereport(elevel,
                (errcode(GUC_check_errcode_value),
                 GUC_check_errmsg_string ?
                 errmsg_internal("%s", GUC_check_errmsg_string) :
                 errmsg("invalid value for parameter \"%s\": %d",
                        conf->gen.name, *newval),
                 GUC_check_errdetail_string ?
                 errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                 GUC_check_errhint_string ?
                 errhint("%s", GUC_check_errhint_string) : 0));
        /* Flush any strings created in ErrorContext */
        FlushErrorState();
        return false;
    }

    return true;
}

call_real_check_hook()

static bool call_real_check_hook ( struct config_real *  conf, double *  newval, void **  extra, GucSource  source, int  elevel  )

static

Definition at line 10850 of file guc.c.

References config_real::check_hook, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_real::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

{
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;

    /* Reset variables that might be set by hook */
    GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
    GUC_check_errmsg_string = NULL;
    GUC_check_errdetail_string = NULL;
    GUC_check_errhint_string = NULL;

    if (!conf->check_hook(newval, extra, source))
    {
        ereport(elevel,
                (errcode(GUC_check_errcode_value),
                 GUC_check_errmsg_string ?
                 errmsg_internal("%s", GUC_check_errmsg_string) :
                 errmsg("invalid value for parameter \"%s\": %g",
                        conf->gen.name, *newval),
                 GUC_check_errdetail_string ?
                 errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                 GUC_check_errhint_string ?
                 errhint("%s", GUC_check_errhint_string) : 0));
        /* Flush any strings created in ErrorContext */
        FlushErrorState();
        return false;
    }

    return true;
}

call_string_check_hook()

static bool call_string_check_hook ( struct config_string *  conf, char **  newval, void **  extra, GucSource  source, int  elevel  )

static

Definition at line 10884 of file guc.c.

References config_string::check_hook, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_string::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

{
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;

    /* Reset variables that might be set by hook */
    GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
    GUC_check_errmsg_string = NULL;
    GUC_check_errdetail_string = NULL;
    GUC_check_errhint_string = NULL;

    if (!conf->check_hook(newval, extra, source))
    {
        ereport(elevel,
                (errcode(GUC_check_errcode_value),
                 GUC_check_errmsg_string ?
                 errmsg_internal("%s", GUC_check_errmsg_string) :
                 errmsg("invalid value for parameter \"%s\": \"%s\"",
                        conf->gen.name, *newval ? *newval : ""),
                 GUC_check_errdetail_string ?
                 errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                 GUC_check_errhint_string ?
                 errhint("%s", GUC_check_errhint_string) : 0));
        /* Flush any strings created in ErrorContext */
        FlushErrorState();
        return false;
    }

    return true;
}

can_skip_gucvar()

static bool can_skip_gucvar ( struct config_generic *  gconf )

static

Definition at line 9962 of file guc.c.

References config_generic::context, config_generic::name, PGC_INTERNAL, PGC_POSTMASTER, PGC_S_DEFAULT, and config_generic::source.

Referenced by estimate_variable_size(), RestoreGUCState(), and serialize_variable().

{
    return gconf->context == PGC_POSTMASTER ||
        gconf->context == PGC_INTERNAL || gconf->source == PGC_S_DEFAULT ||
        strcmp(gconf->name, "role") == 0;
}

check_application_name()

static bool check_application_name ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11477 of file guc.c.

References pg_clean_ascii().

{
    /* Only allow clean ASCII chars in the application name */
    pg_clean_ascii(*newval);

    return true;
}

check_autovacuum_max_workers()

static bool check_autovacuum_max_workers ( int *  newval, void **  extra, GucSource  source  )

static

Definition at line 11363 of file guc.c.

References MAX_BACKENDS, max_wal_senders, max_worker_processes, and MaxConnections.

{
    if (MaxConnections + *newval + 1 +
        max_worker_processes + max_wal_senders > MAX_BACKENDS)
        return false;
    return true;
}

check_autovacuum_work_mem()

static bool check_autovacuum_work_mem ( int *  newval, void **  extra, GucSource  source  )

static

Definition at line 11381 of file guc.c.

{
    /*
     * -1 indicates fallback.
     *
     * If we haven't yet changed the boot_val default of -1, just let it be.
     * Autovacuum will look to maintenance_work_mem instead.
     */
    if (*newval == -1)
        return true;

    /*
     * We clamp manually-set values to at least 1MB.  Since
     * maintenance_work_mem is always set to at least this value, do the same
     * here.
     */
    if (*newval < 1024)
        *newval = 1024;

    return true;
}

check_backtrace_functions()

static bool check_backtrace_functions ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11537 of file guc.c.

References ERROR, GUC_check_errdetail, guc_malloc(), and i.

{
    int         newvallen = strlen(*newval);
    char       *someval;
    int         validlen;
    int         i;
    int         j;

    /*
     * Allow characters that can be C identifiers and commas as separators, as
     * well as some whitespace for readability.
     */
    validlen = strspn(*newval,
                      "0123456789_"
                      "abcdefghijklmnopqrstuvwxyz"
                      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                      ", \n\t");
    if (validlen != newvallen)
    {
        GUC_check_errdetail("invalid character");
        return false;
    }

    if (*newval[0] == '\0')
    {
        *extra = NULL;
        return true;
    }

    /*
     * Allocate space for the output and create the copy.  We could discount
     * whitespace chars to save some memory, but it doesn't seem worth the
     * trouble.
     */
    someval = guc_malloc(ERROR, newvallen + 1 + 1);
    for (i = 0, j = 0; i < newvallen; i++)
    {
        if ((*newval)[i] == ',')
            someval[j++] = '\0';    /* next item */
        else if ((*newval)[i] == ' ' ||
                 (*newval)[i] == '\n' ||
                 (*newval)[i] == '\t')
            ;   /* ignore these */
        else
            someval[j++] = (*newval)[i];    /* copy anything else */
    }

    /* two \0s end the setting */
    someval[j] = '\0';
    someval[j + 1] = '\0';

    *extra = someval;
    return true;
}

check_bonjour()

static bool check_bonjour ( bool *  newval, void **  extra, GucSource  source  )

static

Definition at line 11146 of file guc.c.

References GUC_check_errmsg.

{
#ifndef USE_BONJOUR
    if (*newval)
    {
        GUC_check_errmsg("Bonjour is not supported by this build");
        return false;
    }
#endif
    return true;
}

check_canonical_path()

static bool check_canonical_path ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11197 of file guc.c.

References canonicalize_path().

{
    /*
     * Since canonicalize_path never enlarges the string, we can just modify
     * newval in-place.  But watch out for NULL, which is the default value
     * for external_pid_file.
     */
    if (*newval)
        canonicalize_path(*newval);
    return true;
}

check_cluster_name()

static bool check_cluster_name ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11493 of file guc.c.

References pg_clean_ascii().

{
    /* Only allow clean ASCII chars in the cluster name */
    pg_clean_ascii(*newval);

    return true;
}

check_default_with_oids()

static bool check_default_with_oids ( bool *  newval, void **  extra, GucSource  source  )

static

Definition at line 11866 of file guc.c.

References GUC_check_errcode(), and GUC_check_errmsg.

{
    if (*newval)
    {
        /* check the GUC's definition for an explanation */
        GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
        GUC_check_errmsg("tables declared WITH OIDS are not supported");

        return false;
    }

    return true;
}

check_effective_io_concurrency()

static bool check_effective_io_concurrency ( int *  newval, void **  extra, GucSource  source  )

static

Definition at line 11413 of file guc.c.

References ComputeIoConcurrency(), ERROR, GUC_check_errdetail, guc_malloc(), and rint().

{
#ifdef USE_PREFETCH
    double      new_prefetch_pages;

    if (ComputeIoConcurrency(*newval, &new_prefetch_pages))
    {
        int        *myextra = (int *) guc_malloc(ERROR, sizeof(int));

        *myextra = (int) rint(new_prefetch_pages);
        *extra = (void *) myextra;

        return true;
    }
    else
        return false;
#else
    if (*newval != 0)
    {
        GUC_check_errdetail("effective_io_concurrency must be set to 0 on platforms that lack posix_fadvise().");
        return false;
    }
    return true;
#endif                          /* USE_PREFETCH */
}

check_log_destination()

static bool check_log_destination ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11038 of file guc.c.

References ERROR, GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG_DESTINATION_CSVLOG, LOG_DESTINATION_EVENTLOG, LOG_DESTINATION_STDERR, LOG_DESTINATION_SYSLOG, pfree(), pg_strcasecmp(), pstrdup(), and SplitIdentifierString().

{
    char       *rawstring;
    List       *elemlist;
    ListCell   *l;
    int         newlogdest = 0;
    int        *myextra;

    /* Need a modifiable copy of string */
    rawstring = pstrdup(*newval);

    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawstring, ',', &elemlist))
    {
        /* syntax error in list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawstring);
        list_free(elemlist);
        return false;
    }

    foreach(l, elemlist)
    {
        char       *tok = (char *) lfirst(l);

        if (pg_strcasecmp(tok, "stderr") == 0)
            newlogdest |= LOG_DESTINATION_STDERR;
        else if (pg_strcasecmp(tok, "csvlog") == 0)
            newlogdest |= LOG_DESTINATION_CSVLOG;
#ifdef HAVE_SYSLOG
        else if (pg_strcasecmp(tok, "syslog") == 0)
            newlogdest |= LOG_DESTINATION_SYSLOG;
#endif
#ifdef WIN32
        else if (pg_strcasecmp(tok, "eventlog") == 0)
            newlogdest |= LOG_DESTINATION_EVENTLOG;
#endif
        else
        {
            GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
            pfree(rawstring);
            list_free(elemlist);
            return false;
        }
    }

    pfree(rawstring);
    list_free(elemlist);

    myextra = (int *) guc_malloc(ERROR, sizeof(int));
    *myextra = newlogdest;
    *extra = (void *) myextra;

    return true;
}

check_log_stats()

static bool check_log_stats ( bool *  newval, void **  extra, GucSource  source  )

static

Definition at line 11183 of file guc.c.

References GUC_check_errdetail.

{
    if (*newval &&
        (log_parser_stats || log_planner_stats || log_executor_stats))
    {
        GUC_check_errdetail("Cannot enable \"log_statement_stats\" when "
                            "\"log_parser_stats\", \"log_planner_stats\", "
                            "or \"log_executor_stats\" is true.");
        return false;
    }
    return true;
}

check_max_wal_senders()

static bool check_max_wal_senders ( int *  newval, void **  extra, GucSource  source  )

static

Definition at line 11372 of file guc.c.

References autovacuum_max_workers, MAX_BACKENDS, max_worker_processes, and MaxConnections.

{
    if (MaxConnections + autovacuum_max_workers + 1 +
        max_worker_processes + *newval > MAX_BACKENDS)
        return false;
    return true;
}

check_max_worker_processes()

static bool check_max_worker_processes ( int *  newval, void **  extra, GucSource  source  )

static

Definition at line 11404 of file guc.c.

References autovacuum_max_workers, MAX_BACKENDS, max_wal_senders, and MaxConnections.

{
    if (MaxConnections + autovacuum_max_workers + 1 +
        *newval + max_wal_senders > MAX_BACKENDS)
        return false;
    return true;
}

check_maxconnections()

static bool check_maxconnections ( int *  newval, void **  extra, GucSource  source  )

static

Definition at line 11354 of file guc.c.

References autovacuum_max_workers, MAX_BACKENDS, max_wal_senders, and max_worker_processes.

{
    if (*newval + autovacuum_max_workers + 1 +
        max_worker_processes + max_wal_senders > MAX_BACKENDS)
        return false;
    return true;
}

check_primary_slot_name()

static bool check_primary_slot_name ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11856 of file guc.c.

References ReplicationSlotValidateName(), and WARNING.

{
    if (*newval && strcmp(*newval, "") != 0 &&
        !ReplicationSlotValidateName(*newval, WARNING))
        return false;

    return true;
}

check_recovery_target()

static bool check_recovery_target ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11661 of file guc.c.

References GUC_check_errdetail.

{
    if (strcmp(*newval, "immediate") != 0 && strcmp(*newval, "") != 0)
    {
        GUC_check_errdetail("The only allowed value is \"immediate\".");
        return false;
    }
    return true;
}

check_recovery_target_lsn()

static bool check_recovery_target_lsn ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11820 of file guc.c.

References ERROR, guc_malloc(), and pg_lsn_in_internal().

{
    if (strcmp(*newval, "") != 0)
    {
        XLogRecPtr  lsn;
        XLogRecPtr *myextra;
        bool        have_error = false;

        lsn = pg_lsn_in_internal(*newval, &have_error);
        if (have_error)
            return false;

        myextra = (XLogRecPtr *) guc_malloc(ERROR, sizeof(XLogRecPtr));
        *myextra = lsn;
        *extra = (void *) myextra;
    }
    return true;
}

check_recovery_target_name()

static bool check_recovery_target_name ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11791 of file guc.c.

References GUC_check_errdetail, and MAXFNAMELEN.

{
    /* Use the value of newval directly */
    if (strlen(*newval) >= MAXFNAMELEN)
    {
        GUC_check_errdetail("%s is too long (maximum %d characters).",
                            "recovery_target_name", MAXFNAMELEN - 1);
        return false;
    }
    return true;
}

check_recovery_target_time()

static bool check_recovery_target_time ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11728 of file guc.c.

References DecodeDateTime(), DTK_DATE, GUC_check_errdetail, MAXDATEFIELDS, MAXDATELEN, newval, ParseDateTime(), generate_unaccent_rules::str, tm, and tm2timestamp().

{
    if (strcmp(*newval, "") != 0)
    {
        /* reject some special values */
        if (strcmp(*newval, "now") == 0 ||
            strcmp(*newval, "today") == 0 ||
            strcmp(*newval, "tomorrow") == 0 ||
            strcmp(*newval, "yesterday") == 0)
        {
            return false;
        }

        /*
         * parse timestamp value (see also timestamptz_in())
         */
        {
            char       *str = *newval;
            fsec_t      fsec;
            struct pg_tm tt,
                       *tm = &tt;
            int         tz;
            int         dtype;
            int         nf;
            int         dterr;
            char       *field[MAXDATEFIELDS];
            int         ftype[MAXDATEFIELDS];
            char        workbuf[MAXDATELEN + MAXDATEFIELDS];
            TimestampTz timestamp;

            dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                                  field, ftype, MAXDATEFIELDS, &nf);
            if (dterr == 0)
                dterr = DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tz);
            if (dterr != 0)
                return false;
            if (dtype != DTK_DATE)
                return false;

            if (tm2timestamp(tm, fsec, &tz, &timestamp) != 0)
            {
                GUC_check_errdetail("timestamp out of range: \"%s\"", str);
                return false;
            }
        }
    }
    return true;
}

check_recovery_target_timeline()

static bool check_recovery_target_timeline ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11599 of file guc.c.

References ERROR, GUC_check_errdetail, guc_malloc(), RECOVERY_TARGET_TIMELINE_CONTROLFILE, RECOVERY_TARGET_TIMELINE_LATEST, and RECOVERY_TARGET_TIMELINE_NUMERIC.

{
    RecoveryTargetTimeLineGoal rttg;
    RecoveryTargetTimeLineGoal *myextra;

    if (strcmp(*newval, "current") == 0)
        rttg = RECOVERY_TARGET_TIMELINE_CONTROLFILE;
    else if (strcmp(*newval, "latest") == 0)
        rttg = RECOVERY_TARGET_TIMELINE_LATEST;
    else
    {
        rttg = RECOVERY_TARGET_TIMELINE_NUMERIC;

        errno = 0;
        strtoul(*newval, NULL, 0);
        if (errno == EINVAL || errno == ERANGE)
        {
            GUC_check_errdetail("recovery_target_timeline is not a valid number.");
            return false;
        }
    }

    myextra = (RecoveryTargetTimeLineGoal *) guc_malloc(ERROR, sizeof(RecoveryTargetTimeLineGoal));
    *myextra = rttg;
    *extra = (void *) myextra;

    return true;
}

check_recovery_target_xid()

static bool check_recovery_target_xid ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11685 of file guc.c.

References ERROR, and guc_malloc().

{
    if (strcmp(*newval, "") != 0)
    {
        TransactionId xid;
        TransactionId *myextra;

        errno = 0;
        xid = (TransactionId) strtoul(*newval, NULL, 0);
        if (errno == EINVAL || errno == ERANGE)
            return false;

        myextra = (TransactionId *) guc_malloc(ERROR, sizeof(TransactionId));
        *myextra = xid;
        *extra = (void *) myextra;
    }
    return true;
}

check_ssl()

static bool check_ssl ( bool *  newval, void **  extra, GucSource  source  )

static

Definition at line 11159 of file guc.c.

References GUC_check_errmsg.

{
#ifndef USE_SSL
    if (*newval)
    {
        GUC_check_errmsg("SSL is not supported by this build");
        return false;
    }
#endif
    return true;
}

check_stage_log_stats()

static bool check_stage_log_stats ( bool *  newval, void **  extra, GucSource  source  )

static

Definition at line 11172 of file guc.c.

References GUC_check_errdetail.

{
    if (*newval && log_statement_stats)
    {
        GUC_check_errdetail("Cannot enable parameter when \"log_statement_stats\" is true.");
        return false;
    }
    return true;
}

check_temp_buffers()

static bool check_temp_buffers ( int *  newval, void **  extra, GucSource  source  )

static

Definition at line 11132 of file guc.c.

References GUC_check_errdetail, and NLocBuffer.

{
    /*
     * Once local buffers have been initialized, it's too late to change this.
     */
    if (NLocBuffer && NLocBuffer != *newval)
    {
        GUC_check_errdetail("\"temp_buffers\" cannot be changed after any temporary tables have been accessed in the session.");
        return false;
    }
    return true;
}

check_timezone_abbreviations()

static bool check_timezone_abbreviations ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 11210 of file guc.c.

References Assert, load_tzoffsets(), and PGC_S_DEFAULT.

{
    /*
     * The boot_val given above for timezone_abbreviations is NULL. When we
     * see this we just do nothing.  If this value isn't overridden from the
     * config file then pg_timezone_abbrev_initialize() will eventually
     * replace it with "Default".  This hack has two purposes: to avoid
     * wasting cycles loading values that might soon be overridden from the
     * config file, and to avoid trying to read the timezone abbrev files
     * during InitializeGUCOptions().  The latter doesn't work in an
     * EXEC_BACKEND subprocess because my_exec_path hasn't been set yet and so
     * we can't locate PGSHAREDIR.
     */
    if (*newval == NULL)
    {
        Assert(source == PGC_S_DEFAULT);
        return true;
    }

    /* OK, load the file and produce a malloc'd TimeZoneAbbrevTable */
    *extra = load_tzoffsets(*newval);

    /* tzparser.c returns NULL on failure, reporting via GUC_check_errmsg */
    if (!*extra)
        return false;

    return true;
}

check_wal_consistency_checking()

static bool check_wal_consistency_checking ( char **  newval, void **  extra, GucSource  source  )

static

Definition at line 10958 of file guc.c.

References ERROR, GUC_check_errdetail, guc_malloc(), lfirst, list_free(), MemSet, pfree(), pg_strcasecmp(), pstrdup(), RmgrData::rm_mask, RM_MAX_ID, RmgrTable, and SplitIdentifierString().

{
    char       *rawstring;
    List       *elemlist;
    ListCell   *l;
    bool        newwalconsistency[RM_MAX_ID + 1];

    /* Initialize the array */
    MemSet(newwalconsistency, 0, (RM_MAX_ID + 1) * sizeof(bool));

    /* Need a modifiable copy of string */
    rawstring = pstrdup(*newval);

    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawstring, ',', &elemlist))
    {
        /* syntax error in list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawstring);
        list_free(elemlist);
        return false;
    }

    foreach(l, elemlist)
    {
        char       *tok = (char *) lfirst(l);
        bool        found = false;
        RmgrId      rmid;

        /* Check for 'all'. */
        if (pg_strcasecmp(tok, "all") == 0)
        {
            for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
                if (RmgrTable[rmid].rm_mask != NULL)
                    newwalconsistency[rmid] = true;
            found = true;
        }
        else
        {
            /*
             * Check if the token matches with any individual resource
             * manager.
             */
            for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
            {
                if (pg_strcasecmp(tok, RmgrTable[rmid].rm_name) == 0 &&
                    RmgrTable[rmid].rm_mask != NULL)
                {
                    newwalconsistency[rmid] = true;
                    found = true;
                }
            }
        }

        /* If a valid resource manager is found, check for the next one. */
        if (!found)
        {
            GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
            pfree(rawstring);
            list_free(elemlist);
            return false;
        }
    }

    pfree(rawstring);
    list_free(elemlist);

    /* assign new value */
    *extra = guc_malloc(ERROR, (RM_MAX_ID + 1) * sizeof(bool));
    memcpy(*extra, newwalconsistency, (RM_MAX_ID + 1) * sizeof(bool));
    return true;
}

config_enum_get_options()

static char* config_enum_get_options ( struct config_enum *  record, const char *  prefix, const char *  suffix, const char *  separator  )

static

Definition at line 6530 of file guc.c.

References appendBinaryStringInfo(), appendStringInfoString(), StringInfoData::data, config_enum_entry::hidden, initStringInfo(), StringInfoData::len, config_enum_entry::name, and config_enum::options.

Referenced by GetConfigOptionByNum(), and parse_and_validate_value().

{
    const struct config_enum_entry *entry;
    StringInfoData retstr;
    int         seplen;

    initStringInfo(&retstr);
    appendStringInfoString(&retstr, prefix);

    seplen = strlen(separator);
    for (entry = record->options; entry && entry->name; entry++)
    {
        if (!entry->hidden)
        {
            appendStringInfoString(&retstr, entry->name);
            appendBinaryStringInfo(&retstr, separator, seplen);
        }
    }

    /*
     * All the entries may have been hidden, leaving the string empty if no
     * prefix was given. This indicates a broken GUC setup, since there is no
     * use for an enum without any values, so we just check to make sure we
     * don't write to invalid memory instead of actually trying to do
     * something smart with it.
     */
    if (retstr.len >= seplen)
    {
        /* Replace final separator */
        retstr.data[retstr.len - seplen] = '\0';
        retstr.len -= seplen;
    }

    appendStringInfoString(&retstr, suffix);

    return retstr.data;
}

config_enum_lookup_by_name()

bool config_enum_lookup_by_name	(	struct config_enum *	record,
		const char *	value,
		int *	retval
	)

Definition at line 6504 of file guc.c.

References config_enum_entry::name, config_enum::options, pg_strcasecmp(), and config_enum_entry::val.

Referenced by parse_and_validate_value().

{
    const struct config_enum_entry *entry;

    for (entry = record->options; entry && entry->name; entry++)
    {
        if (pg_strcasecmp(value, entry->name) == 0)
        {
            *retval = entry->val;
            return true;
        }
    }

    *retval = 0;
    return false;
}

config_enum_lookup_by_value()

const char* config_enum_lookup_by_value	(	struct config_enum *	record,
		int	val
	)

Definition at line 6481 of file guc.c.

References elog, ERROR, config_enum::gen, config_generic::name, config_enum_entry::name, config_enum::options, and config_enum_entry::val.

Referenced by _ShowOption(), call_enum_check_hook(), estimate_variable_size(), GetConfigOption(), GetConfigOptionByNum(), GetConfigOptionResetString(), printMixedStruct(), and serialize_variable().

{
    const struct config_enum_entry *entry;

    for (entry = record->options; entry && entry->name; entry++)
    {
        if (entry->val == val)
            return entry->name;
    }

    elog(ERROR, "could not find enum option %d for %s",
         val, record->gen.name);
    return NULL;                /* silence compiler */
}

convert_int_from_base_unit()

static void convert_int_from_base_unit ( int64  base_value, int  base_unit, int64 *  value, const char **  unit  )

static

Definition at line 6187 of file guc.c.

References Assert, GUC_UNIT_MEMORY, i, memory_unit_conversion_table, rint(), time_unit_conversion_table, and unit_conversion::unit.

Referenced by _ShowOption().

{
    const unit_conversion *table;
    int         i;

    *unit = NULL;

    if (base_unit & GUC_UNIT_MEMORY)
        table = memory_unit_conversion_table;
    else
        table = time_unit_conversion_table;

    for (i = 0; *table[i].unit; i++)
    {
        if (base_unit == table[i].base_unit)
        {
            /*
             * Accept the first conversion that divides the value evenly.  We
             * assume that the conversions for each base unit are ordered from
             * greatest unit to the smallest!
             */
            if (table[i].multiplier <= 1.0 ||
                base_value % (int64) table[i].multiplier == 0)
            {
                *value = (int64) rint(base_value / table[i].multiplier);
                *unit = table[i].unit;
                break;
            }
        }
    }

    Assert(*unit != NULL);
}

convert_real_from_base_unit()

static void convert_real_from_base_unit ( double  base_value, int  base_unit, double *  value, const char **  unit  )

static

Definition at line 6229 of file guc.c.

References Assert, GUC_UNIT_MEMORY, i, memory_unit_conversion_table, unit_conversion::multiplier, rint(), time_unit_conversion_table, and unit_conversion::unit.

Referenced by _ShowOption().

{
    const unit_conversion *table;
    int         i;

    *unit = NULL;

    if (base_unit & GUC_UNIT_MEMORY)
        table = memory_unit_conversion_table;
    else
        table = time_unit_conversion_table;

    for (i = 0; *table[i].unit; i++)
    {
        if (base_unit == table[i].base_unit)
        {
            /*
             * Accept the first conversion that divides the value evenly; or
             * if there is none, use the smallest (last) target unit.
             *
             * What we actually care about here is whether snprintf with "%g"
             * will print the value as an integer, so the obvious test of
             * "*value == rint(*value)" is too strict; roundoff error might
             * make us choose an unreasonably small unit.  As a compromise,
             * accept a divisor that is within 1e-8 of producing an integer.
             */
            *value = base_value / table[i].multiplier;
            *unit = table[i].unit;
            if (*value > 0 &&
                fabs((rint(*value) / *value) - 1.0) <= 1e-8)
                break;
        }
    }

    Assert(*unit != NULL);
}

convert_to_base_unit()

static bool convert_to_base_unit ( double  value, const char *  unit, int  base_unit, double *  base_value  )

static

Definition at line 6129 of file guc.c.

References GUC_UNIT_MEMORY, i, MAX_UNIT_LEN, memory_unit_conversion_table, unit_conversion::multiplier, rint(), time_unit_conversion_table, and unit_conversion::unit.

Referenced by parse_int(), and parse_real().

{
    char        unitstr[MAX_UNIT_LEN + 1];
    int         unitlen;
    const unit_conversion *table;
    int         i;

    /* extract unit string to compare to table entries */
    unitlen = 0;
    while (*unit != '\0' && !isspace((unsigned char) *unit) &&
           unitlen < MAX_UNIT_LEN)
        unitstr[unitlen++] = *(unit++);
    unitstr[unitlen] = '\0';
    /* allow whitespace after unit */
    while (isspace((unsigned char) *unit))
        unit++;
    if (*unit != '\0')
        return false;           /* unit too long, or garbage after it */

    /* now search the appropriate table */
    if (base_unit & GUC_UNIT_MEMORY)
        table = memory_unit_conversion_table;
    else
        table = time_unit_conversion_table;

    for (i = 0; *table[i].unit; i++)
    {
        if (base_unit == table[i].base_unit &&
            strcmp(unitstr, table[i].unit) == 0)
        {
            double      cvalue = value * table[i].multiplier;

            /*
             * If the user gave a fractional value such as "30.1GB", round it
             * off to the nearest multiple of the next smaller unit, if there
             * is one.
             */
            if (*table[i + 1].unit &&
                base_unit == table[i + 1].base_unit)
                cvalue = rint(cvalue / table[i + 1].multiplier) *
                    table[i + 1].multiplier;

            *base_value = cvalue;
            return true;
        }
    }
    return false;
}

define_custom_variable()

static void define_custom_variable ( struct config_generic *  variable )

static

Definition at line 8455 of file guc.c.

References add_guc_variable(), Assert, ereport, errcode(), errmsg(), ERROR, free, config_string::gen, GUC_ACTION_SET, GUC_CUSTOM_PLACEHOLDER, guc_var_compare(), InitializeOneGUCOption(), config_generic::name, name, PGC_STRING, reapply_stacked_values(), config_generic::reset_scontext, config_generic::reset_source, config_string::reset_val, config_generic::scontext, set_config_option(), set_config_sourcefile(), set_string_field(), config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_generic::stack, config_string::variable, and WARNING.

Referenced by DefineCustomBoolVariable(), DefineCustomEnumVariable(), DefineCustomIntVariable(), DefineCustomRealVariable(), and DefineCustomStringVariable().

{
    const char *name = variable->name;
    const char **nameAddr = &name;
    struct config_string *pHolder;
    struct config_generic **res;

    /*
     * See if there's a placeholder by the same name.
     */
    res = (struct config_generic **) bsearch((void *) &nameAddr,
                                             (void *) guc_variables,
                                             num_guc_variables,
                                             sizeof(struct config_generic *),
                                             guc_var_compare);
    if (res == NULL)
    {
        /*
         * No placeholder to replace, so we can just add it ... but first,
         * make sure it's initialized to its default value.
         */
        InitializeOneGUCOption(variable);
        add_guc_variable(variable, ERROR);
        return;
    }

    /*
     * This better be a placeholder
     */
    if (((*res)->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("attempt to redefine parameter \"%s\"", name)));

    Assert((*res)->vartype == PGC_STRING);
    pHolder = (struct config_string *) (*res);

    /*
     * First, set the variable to its default value.  We must do this even
     * though we intend to immediately apply a new value, since it's possible
     * that the new value is invalid.
     */
    InitializeOneGUCOption(variable);

    /*
     * Replace the placeholder. We aren't changing the name, so no re-sorting
     * is necessary
     */
    *res = variable;

    /*
     * Assign the string value(s) stored in the placeholder to the real
     * variable.  Essentially, we need to duplicate all the active and stacked
     * values, but with appropriate validation and datatype adjustment.
     *
     * If an assignment fails, we report a WARNING and keep going.  We don't
     * want to throw ERROR for bad values, because it'd bollix the add-on
     * module that's presumably halfway through getting loaded.  In such cases
     * the default or previous state will become active instead.
     */

    /* First, apply the reset value if any */
    if (pHolder->reset_val)
        (void) set_config_option(name, pHolder->reset_val,
                                 pHolder->gen.reset_scontext,
                                 pHolder->gen.reset_source,
                                 GUC_ACTION_SET, true, WARNING, false);
    /* That should not have resulted in stacking anything */
    Assert(variable->stack == NULL);

    /* Now, apply current and stacked values, in the order they were stacked */
    reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
                           *(pHolder->variable),
                           pHolder->gen.scontext, pHolder->gen.source);

    /* Also copy over any saved source-location information */
    if (pHolder->gen.sourcefile)
        set_config_sourcefile(name, pHolder->gen.sourcefile,
                              pHolder->gen.sourceline);

    /*
     * Free up as much as we conveniently can of the placeholder structure.
     * (This neglects any stack items, so it's possible for some memory to be
     * leaked.  Since this can only happen once per session per variable, it
     * doesn't seem worth spending much code on.)
     */
    set_string_field(pHolder, pHolder->variable, NULL);
    set_string_field(pHolder, &pHolder->reset_val, NULL);

    free(pHolder);
}

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
	)

Definition at line 8636 of file guc.c.

References config_bool::assign_hook, config_bool::boot_val, config_bool::check_hook, define_custom_variable(), config_bool::gen, init_custom_variable(), PGC_BOOL, config_bool::reset_val, config_bool::show_hook, and config_bool::variable.

Referenced by _PG_init().

{
    struct config_bool *var;

    var = (struct config_bool *)
        init_custom_variable(name, short_desc, long_desc, context, flags,
                             PGC_BOOL, sizeof(struct config_bool));
    var->variable = valueAddr;
    var->boot_val = bootValue;
    var->reset_val = bootValue;
    var->check_hook = check_hook;
    var->assign_hook = assign_hook;
    var->show_hook = show_hook;
    define_custom_variable(&var->gen);
}

DefineCustomEnumVariable()

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
	)

Definition at line 8747 of file guc.c.

References config_enum::assign_hook, config_enum::boot_val, config_enum::check_hook, define_custom_variable(), config_enum::gen, init_custom_variable(), options, config_enum::options, PGC_ENUM, config_enum::reset_val, config_enum::show_hook, and config_enum::variable.

Referenced by _PG_init().

{
    struct config_enum *var;

    var = (struct config_enum *)
        init_custom_variable(name, short_desc, long_desc, context, flags,
                             PGC_ENUM, sizeof(struct config_enum));
    var->variable = valueAddr;
    var->boot_val = bootValue;
    var->reset_val = bootValue;
    var->options = options;
    var->check_hook = check_hook;
    var->assign_hook = assign_hook;
    var->show_hook = show_hook;
    define_custom_variable(&var->gen);
}

DefineCustomIntVariable()

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
	)

Definition at line 8662 of file guc.c.

References config_int::assign_hook, config_int::boot_val, config_int::check_hook, define_custom_variable(), config_int::gen, init_custom_variable(), config_int::max, config_int::min, PGC_INT, config_int::reset_val, config_int::show_hook, and config_int::variable.

Referenced by _PG_init().

{
    struct config_int *var;

    var = (struct config_int *)
        init_custom_variable(name, short_desc, long_desc, context, flags,
                             PGC_INT, sizeof(struct config_int));
    var->variable = valueAddr;
    var->boot_val = bootValue;
    var->reset_val = bootValue;
    var->min = minValue;
    var->max = maxValue;
    var->check_hook = check_hook;
    var->assign_hook = assign_hook;
    var->show_hook = show_hook;
    define_custom_variable(&var->gen);
}

DefineCustomRealVariable()

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
	)

Definition at line 8692 of file guc.c.

References config_real::assign_hook, config_real::boot_val, config_real::check_hook, define_custom_variable(), config_real::gen, init_custom_variable(), config_real::max, config_real::min, PGC_REAL, config_real::reset_val, config_real::show_hook, and config_real::variable.

Referenced by _PG_init().

{
    struct config_real *var;

    var = (struct config_real *)
        init_custom_variable(name, short_desc, long_desc, context, flags,
                             PGC_REAL, sizeof(struct config_real));
    var->variable = valueAddr;
    var->boot_val = bootValue;
    var->reset_val = bootValue;
    var->min = minValue;
    var->max = maxValue;
    var->check_hook = check_hook;
    var->assign_hook = assign_hook;
    var->show_hook = show_hook;
    define_custom_variable(&var->gen);
}

DefineCustomStringVariable()

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
	)

Definition at line 8722 of file guc.c.

References config_string::assign_hook, config_string::boot_val, config_string::check_hook, define_custom_variable(), config_string::gen, init_custom_variable(), PGC_STRING, config_string::show_hook, and config_string::variable.

Referenced by _PG_init().

{
    struct config_string *var;

    var = (struct config_string *)
        init_custom_variable(name, short_desc, long_desc, context, flags,
                             PGC_STRING, sizeof(struct config_string));
    var->variable = valueAddr;
    var->boot_val = bootValue;
    var->check_hook = check_hook;
    var->assign_hook = assign_hook;
    var->show_hook = show_hook;
    define_custom_variable(&var->gen);
}

discard_stack_value()

static void discard_stack_value ( struct config_generic *  gconf, config_var_value *  val  )

static

Definition at line 4859 of file guc.c.

References config_var_value::extra, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, set_extra_field(), set_string_field(), config_var_val::stringval, config_var_value::val, and config_generic::vartype.

Referenced by AtEOXact_GUC(), and push_old_value().

{
    switch (gconf->vartype)
    {
        case PGC_BOOL:
        case PGC_INT:
        case PGC_REAL:
        case PGC_ENUM:
            /* no need to do anything */
            break;
        case PGC_STRING:
            set_string_field((struct config_string *) gconf,
                             &(val->val.stringval),
                             NULL);
            break;
    }
    set_extra_field(gconf, &(val->extra), NULL);
}

do_serialize()

static void do_serialize ( char **  destptr, Size *  maxbytes, const char *  fmt,   ...  )

static

Definition at line 10097 of file guc.c.

References elog, ERROR, and vsnprintf.

Referenced by serialize_variable().

{
    va_list     vargs;
    int         n;

    if (*maxbytes <= 0)
        elog(ERROR, "not enough space to serialize GUC state");

    va_start(vargs, fmt);
    n = vsnprintf(*destptr, *maxbytes, fmt, vargs);
    va_end(vargs);

    if (n < 0)
    {
        /* Shouldn't happen. Better show errno description. */
        elog(ERROR, "vsnprintf failed: %m with format string \"%s\"", fmt);
    }
    if (n >= *maxbytes)
    {
        /* This shouldn't happen either, really. */
        elog(ERROR, "not enough space to serialize GUC state");
    }

    /* Shift the destptr ahead of the null terminator */
    *destptr += n + 1;
    *maxbytes -= n + 1;
}

do_serialize_binary()

static void do_serialize_binary ( char **  destptr, Size *  maxbytes, void *  val, Size  valsize  )

static

Definition at line 10127 of file guc.c.

References elog, and ERROR.

Referenced by serialize_variable().

{
    if (valsize > *maxbytes)
        elog(ERROR, "not enough space to serialize GUC state");

    memcpy(*destptr, val, valsize);
    *destptr += valsize;
    *maxbytes -= valsize;
}

EmitWarningsOnPlaceholders()

void EmitWarningsOnPlaceholders

(

const char *

className

)

Definition at line 8775 of file guc.c.

References ereport, errcode(), errmsg(), config_generic::flags, GUC_CUSTOM_PLACEHOLDER, GUC_QUALIFIER_SEPARATOR, i, config_generic::name, num_guc_variables, and WARNING.

Referenced by _PG_init().

{
    int         classLen = strlen(className);
    int         i;

    for (i = 0; i < num_guc_variables; i++)
    {
        struct config_generic *var = guc_variables[i];

        if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
            strncmp(className, var->name, classLen) == 0 &&
            var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
        {
            ereport(WARNING,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("unrecognized configuration parameter \"%s\"",
                            var->name)));
        }
    }
}

estimate_variable_size()

static Size estimate_variable_size ( struct config_generic *  gconf )

static

Definition at line 9976 of file guc.c.

References Abs, add_size(), can_skip_gucvar(), config_enum_lookup_by_value(), config_generic::name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, REALTYPE_PRECISION, config_generic::scontext, config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_int::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by EstimateGUCStateSpace().

{
    Size        size;
    Size        valsize = 0;

    if (can_skip_gucvar(gconf))
        return 0;

    /* Name, plus trailing zero byte. */
    size = strlen(gconf->name) + 1;

    /* Get the maximum display length of the GUC value. */
    switch (gconf->vartype)
    {
        case PGC_BOOL:
            {
                valsize = 5;    /* max(strlen('true'), strlen('false')) */
            }
            break;

        case PGC_INT:
            {
                struct config_int *conf = (struct config_int *) gconf;

                /*
                 * Instead of getting the exact display length, use max
                 * length.  Also reduce the max length for typical ranges of
                 * small values.  Maximum value is 2147483647, i.e. 10 chars.
                 * Include one byte for sign.
                 */
                if (Abs(*conf->variable) < 1000)
                    valsize = 3 + 1;
                else
                    valsize = 10 + 1;
            }
            break;

        case PGC_REAL:
            {
                /*
                 * We are going to print it with %e with REALTYPE_PRECISION
                 * fractional digits.  Account for sign, leading digit,
                 * decimal point, and exponent with up to 3 digits.  E.g.
                 * -3.99329042340000021e+110
                 */
                valsize = 1 + 1 + 1 + REALTYPE_PRECISION + 5;
            }
            break;

        case PGC_STRING:
            {
                struct config_string *conf = (struct config_string *) gconf;

                /*
                 * If the value is NULL, we transmit it as an empty string.
                 * Although this is not physically the same value, GUC
                 * generally treats a NULL the same as empty string.
                 */
                if (*conf->variable)
                    valsize = strlen(*conf->variable);
                else
                    valsize = 0;
            }
            break;

        case PGC_ENUM:
            {
                struct config_enum *conf = (struct config_enum *) gconf;

                valsize = strlen(config_enum_lookup_by_value(conf, *conf->variable));
            }
            break;
    }

    /* Allow space for terminating zero-byte for value */
    size = add_size(size, valsize + 1);

    if (gconf->sourcefile)
        size = add_size(size, strlen(gconf->sourcefile));

    /* Allow space for terminating zero-byte for sourcefile */
    size = add_size(size, 1);

    /* Include line whenever file is nonempty. */
    if (gconf->sourcefile && gconf->sourcefile[0])
        size = add_size(size, sizeof(gconf->sourceline));

    size = add_size(size, sizeof(gconf->source));
    size = add_size(size, sizeof(gconf->scontext));

    return size;
}

EstimateGUCStateSpace()

Size EstimateGUCStateSpace

(

void

)

Definition at line 10074 of file guc.c.

References add_size(), estimate_variable_size(), i, and num_guc_variables.

Referenced by InitializeParallelDSM().

{
    Size        size;
    int         i;

    /* Add space reqd for saving the data size of the guc state */
    size = sizeof(Size);

    /* Add up the space needed for each GUC variable */
    for (i = 0; i < num_guc_variables; i++)
        size = add_size(size,
                        estimate_variable_size(guc_variables[i]));

    return size;
}

ExecSetVariableStmt()

void ExecSetVariableStmt	(	VariableSetStmt *	stmt,
		bool	isTopLevel
	)

Definition at line 8183 of file guc.c.

References generate_unaccent_rules::action, DefElem::arg, VariableSetStmt::args, Assert, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, ExtractSetVariableArgs(), GUC_ACTION_LOCAL, GUC_ACTION_SET, ImportSnapshot(), VariableSetStmt::is_local, IsInParallelMode(), VariableSetStmt::kind, lfirst, linitial_node, list_make1, VariableSetStmt::name, nodeTag, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, ResetAllOptions(), set_config_option(), SetPGVariable(), strVal, superuser(), T_String, 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().

{
    GucAction   action = stmt->is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET;

    /*
     * Workers synchronize these parameters at the start of the parallel
     * operation; then, we block SET during the operation.
     */
    if (IsInParallelMode())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot set parameters during a parallel operation")));

    switch (stmt->kind)
    {
        case VAR_SET_VALUE:
        case VAR_SET_CURRENT:
            if (stmt->is_local)
                WarnNoTransactionBlock(isTopLevel, "SET LOCAL");
            (void) set_config_option(stmt->name,
                                     ExtractSetVariableArgs(stmt),
                                     (superuser() ? PGC_SUSET : PGC_USERSET),
                                     PGC_S_SESSION,
                                     action, true, 0, false);
            break;
        case VAR_SET_MULTI:

            /*
             * Special-case SQL syntaxes.  The TRANSACTION and SESSION
             * CHARACTERISTICS cases effectively set more than one variable
             * per statement.  TRANSACTION SNAPSHOT only takes one argument,
             * but we put it here anyway since it's a special case and not
             * related to any GUC variable.
             */
            if (strcmp(stmt->name, "TRANSACTION") == 0)
            {
                ListCell   *head;

                WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION");

                foreach(head, stmt->args)
                {
                    DefElem    *item = (DefElem *) lfirst(head);

                    if (strcmp(item->defname, "transaction_isolation") == 0)
                        SetPGVariable("transaction_isolation",
                                      list_make1(item->arg), stmt->is_local);
                    else if (strcmp(item->defname, "transaction_read_only") == 0)
                        SetPGVariable("transaction_read_only",
                                      list_make1(item->arg), stmt->is_local);
                    else if (strcmp(item->defname, "transaction_deferrable") == 0)
                        SetPGVariable("transaction_deferrable",
                                      list_make1(item->arg), stmt->is_local);
                    else
                        elog(ERROR, "unexpected SET TRANSACTION element: %s",
                             item->defname);
                }
            }
            else if (strcmp(stmt->name, "SESSION CHARACTERISTICS") == 0)
            {
                ListCell   *head;

                foreach(head, stmt->args)
                {
                    DefElem    *item = (DefElem *) lfirst(head);

                    if (strcmp(item->defname, "transaction_isolation") == 0)
                        SetPGVariable("default_transaction_isolation",
                                      list_make1(item->arg), stmt->is_local);
                    else if (strcmp(item->defname, "transaction_read_only") == 0)
                        SetPGVariable("default_transaction_read_only",
                                      list_make1(item->arg), stmt->is_local);
                    else if (strcmp(item->defname, "transaction_deferrable") == 0)
                        SetPGVariable("default_transaction_deferrable",
                                      list_make1(item->arg), stmt->is_local);
                    else
                        elog(ERROR, "unexpected SET SESSION element: %s",
                             item->defname);
                }
            }
            else if (strcmp(stmt->name, "TRANSACTION SNAPSHOT") == 0)
            {
                A_Const    *con = linitial_node(A_Const, stmt->args);

                if (stmt->is_local)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("SET LOCAL TRANSACTION SNAPSHOT is not implemented")));

                WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION");
                Assert(nodeTag(&con->val) == T_String);
                ImportSnapshot(strVal(&con->val));
            }
            else
                elog(ERROR, "unexpected SET MULTI element: %s",
                     stmt->name);
            break;
        case VAR_SET_DEFAULT:
            if (stmt->is_local)
                WarnNoTransactionBlock(isTopLevel, "SET LOCAL");
            /* fall through */
        case VAR_RESET:
            if (strcmp(stmt->name, "transaction_isolation") == 0)
                WarnNoTransactionBlock(isTopLevel, "RESET TRANSACTION");

            (void) set_config_option(stmt->name,
                                     NULL,
                                     (superuser() ? PGC_SUSET : PGC_USERSET),
                                     PGC_S_SESSION,
                                     action, true, 0, false);
            break;
        case VAR_RESET_ALL:
            ResetAllOptions();
            break;
    }
}

extra_field_used()

static bool extra_field_used ( struct config_generic *  gconf, void *  extra  )

static

Definition at line 4760 of file guc.c.

References config_var_value::extra, config_generic::extra, guc_stack::masked, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, guc_stack::prev, guc_stack::prior, config_generic::stack, and config_generic::vartype.

Referenced by set_config_option(), and set_extra_field().

{
    GucStack   *stack;

    if (extra == gconf->extra)
        return true;
    switch (gconf->vartype)
    {
        case PGC_BOOL:
            if (extra == ((struct config_bool *) gconf)->reset_extra)
                return true;
            break;
        case PGC_INT:
            if (extra == ((struct config_int *) gconf)->reset_extra)
                return true;
            break;
        case PGC_REAL:
            if (extra == ((struct config_real *) gconf)->reset_extra)
                return true;
            break;
        case PGC_STRING:
            if (extra == ((struct config_string *) gconf)->reset_extra)
                return true;