guc.h File Reference

#include "nodes/parsenodes.h"
#include "tcop/dest.h"
#include "utils/array.h"

Include dependency graph for guc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ConfigVariable
struct	config_enum_entry

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

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

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

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

Variables
PGDLLIMPORT bool	Debug_print_plan
PGDLLIMPORT bool	Debug_print_parse
PGDLLIMPORT bool	Debug_print_raw_parse
PGDLLIMPORT bool	Debug_print_rewritten
PGDLLIMPORT bool	Debug_pretty_print
PGDLLIMPORT bool	log_parser_stats
PGDLLIMPORT bool	log_planner_stats
PGDLLIMPORT bool	log_executor_stats
PGDLLIMPORT bool	log_statement_stats
PGDLLIMPORT bool	log_btree_build_stats
PGDLLIMPORT char *	event_source
PGDLLIMPORT bool	check_function_bodies
PGDLLIMPORT bool	current_role_is_superuser
PGDLLIMPORT bool	AllowAlterSystem
PGDLLIMPORT bool	log_duration
PGDLLIMPORT int	log_parameter_max_length
PGDLLIMPORT int	log_parameter_max_length_on_error
PGDLLIMPORT int	log_min_error_statement
PGDLLIMPORT int	log_min_messages []
PGDLLIMPORT int	client_min_messages
PGDLLIMPORT int	log_min_duration_sample
PGDLLIMPORT int	log_min_duration_statement
PGDLLIMPORT int	log_temp_files
PGDLLIMPORT double	log_statement_sample_rate
PGDLLIMPORT double	log_xact_sample_rate
PGDLLIMPORT char *	backtrace_functions
PGDLLIMPORT int	temp_file_limit
PGDLLIMPORT int	num_temp_buffers
PGDLLIMPORT char *	cluster_name
PGDLLIMPORT char *	ConfigFileName
PGDLLIMPORT char *	HbaFileName
PGDLLIMPORT char *	IdentFileName
PGDLLIMPORT char *	HostsFileName
PGDLLIMPORT char *	external_pid_file
PGDLLIMPORT char *	application_name
PGDLLIMPORT int	tcp_keepalives_idle
PGDLLIMPORT int	tcp_keepalives_interval
PGDLLIMPORT int	tcp_keepalives_count
PGDLLIMPORT int	tcp_user_timeout
PGDLLIMPORT char *	role_string
PGDLLIMPORT bool	in_hot_standby_guc
PGDLLIMPORT bool	trace_sort
PGDLLIMPORT const struct config_enum_entry	archive_mode_options []
PGDLLIMPORT const struct config_enum_entry	dynamic_shared_memory_options []
PGDLLIMPORT const struct config_enum_entry	io_method_options []
PGDLLIMPORT const struct config_enum_entry	recovery_target_action_options []
PGDLLIMPORT const struct config_enum_entry	server_message_level_options []
PGDLLIMPORT const struct config_enum_entry	wal_level_options []
PGDLLIMPORT const struct config_enum_entry	wal_sync_method_options []
PGDLLIMPORT char *	GUC_check_errmsg_string
PGDLLIMPORT char *	GUC_check_errdetail_string
PGDLLIMPORT char *	GUC_check_errhint_string

Macro Definition Documentation

EmitWarningsOnPlaceholders

#define EmitWarningsOnPlaceholders

(

className

)

MarkGUCPrefixReserved(className)

Definition at line 421 of file guc.h.

GUC_ALLOW_IN_PARALLEL

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

Definition at line 230 of file guc.h.

GUC_check_errdetail

#define GUC_check_errdetail

Value:

    pre_format_elog_string(errno, TEXTDOMAIN), \
    GUC_check_errdetail_string = format_elog_string

Definition at line 507 of file guc.h.

GUC_check_errhint

#define GUC_check_errhint

Value:

    pre_format_elog_string(errno, TEXTDOMAIN), \
    GUC_check_errhint_string = format_elog_string

Definition at line 511 of file guc.h.

GUC_check_errmsg

#define GUC_check_errmsg

Value:

    pre_format_elog_string(errno, TEXTDOMAIN), \
    GUC_check_errmsg_string = format_elog_string

Definition at line 503 of file guc.h.

GUC_CUSTOM_PLACEHOLDER

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

Definition at line 223 of file guc.h.

GUC_DISALLOW_IN_AUTO_FILE

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

Definition at line 227 of file guc.h.

GUC_DISALLOW_IN_FILE

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

Definition at line 222 of file guc.h.

GUC_EXPLAIN

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

Definition at line 219 of file guc.h.

GUC_IS_NAME

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

Definition at line 225 of file guc.h.

GUC_LIST_INPUT

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

Definition at line 214 of file guc.h.

GUC_LIST_QUOTE

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

Definition at line 215 of file guc.h.

GUC_NO_RESET

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

Definition at line 217 of file guc.h.

GUC_NO_RESET_ALL

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

Definition at line 218 of file guc.h.

GUC_NO_SHOW_ALL

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

Definition at line 216 of file guc.h.

GUC_NOT_IN_SAMPLE

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

Definition at line 221 of file guc.h.

GUC_NOT_WHILE_SEC_REST

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

Definition at line 226 of file guc.h.

GUC_QUALIFIER_SEPARATOR

#define GUC_QUALIFIER_SEPARATOR   '.'

Definition at line 208 of file guc.h.

GUC_REPORT

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

Definition at line 220 of file guc.h.

GUC_RUNTIME_COMPUTED

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

Definition at line 229 of file guc.h.

GUC_SUPERUSER_ONLY

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

Definition at line 224 of file guc.h.

GUC_UNIT

#define GUC_UNIT   (GUC_UNIT_MEMORY | GUC_UNIT_TIME)

Definition at line 244 of file guc.h.

GUC_UNIT_BLOCKS

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

Definition at line 233 of file guc.h.

GUC_UNIT_BYTE

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

Definition at line 236 of file guc.h.

GUC_UNIT_KB

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

Definition at line 232 of file guc.h.

GUC_UNIT_MB

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

Definition at line 235 of file guc.h.

GUC_UNIT_MEMORY

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

Definition at line 237 of file guc.h.

GUC_UNIT_MIN

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

Definition at line 241 of file guc.h.

GUC_UNIT_MS

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

Definition at line 239 of file guc.h.

GUC_UNIT_S

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

Definition at line 240 of file guc.h.

GUC_UNIT_TIME

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

Definition at line 242 of file guc.h.

GUC_UNIT_XBLOCKS

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

Definition at line 234 of file guc.h.

MAX_KILOBYTES

#define MAX_KILOBYTES   (INT_MAX / 1024)

Definition at line 29 of file guc.h.

PG_AUTOCONF_FILENAME

#define PG_AUTOCONF_FILENAME   "postgresql.auto.conf"

Definition at line 37 of file guc.h.

Typedef Documentation

config_handle

typedef struct config_generic config_handle

Definition at line 151 of file guc.h.

ConfigVariable

typedef struct ConfigVariable ConfigVariable

GucBoolAssignHook

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

Definition at line 189 of file guc.h.

GucBoolCheckHook

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

Definition at line 183 of file guc.h.

GucEnumAssignHook

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

Definition at line 193 of file guc.h.

GucEnumCheckHook

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

Definition at line 187 of file guc.h.

GucIntAssignHook

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

Definition at line 190 of file guc.h.

GucIntCheckHook

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

Definition at line 184 of file guc.h.

GucRealAssignHook

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

Definition at line 191 of file guc.h.

GucRealCheckHook

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

Definition at line 185 of file guc.h.

GucShowHook

typedef const char *(* GucShowHook) (void)

Definition at line 195 of file guc.h.

GucStringAssignHook

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

Definition at line 192 of file guc.h.

GucStringCheckHook

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

Definition at line 186 of file guc.h.

Enumeration Type Documentation

GucAction

enum GucAction

Enumerator
GUC_ACTION_SET
GUC_ACTION_LOCAL
GUC_ACTION_SAVE

Definition at line 200 of file guc.h.

{
    /* Types of set_config_option actions */
    GUC_ACTION_SET,             /* regular SET command */
    GUC_ACTION_LOCAL,           /* SET LOCAL command */
    GUC_ACTION_SAVE,            /* function SET option, or temp assignment */
} GucAction;

GucContext

enum GucContext

Enumerator
PGC_INTERNAL
PGC_POSTMASTER
PGC_SIGHUP
PGC_SU_BACKEND
PGC_BACKEND
PGC_SUSET
PGC_USERSET

Definition at line 71 of file guc.h.

{
    PGC_INTERNAL,
    PGC_POSTMASTER,
    PGC_SIGHUP,
    PGC_SU_BACKEND,
    PGC_BACKEND,
    PGC_SUSET,
    PGC_USERSET,
} GucContext;

GucSource

enum GucSource

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

Definition at line 111 of file guc.h.

{
    PGC_S_DEFAULT,              /* hard-wired default ("boot_val") */
    PGC_S_DYNAMIC_DEFAULT,      /* default computed during initialization */
    PGC_S_ENV_VAR,              /* postmaster environment variable */
    PGC_S_FILE,                 /* postgresql.conf */
    PGC_S_ARGV,                 /* postmaster command line */
    PGC_S_GLOBAL,               /* global in-database setting */
    PGC_S_DATABASE,             /* per-database setting */
    PGC_S_USER,                 /* per-user setting */
    PGC_S_DATABASE_USER,        /* per-user-and-database setting */
    PGC_S_CLIENT,               /* from client connection request */
    PGC_S_OVERRIDE,             /* special case to forcibly set default */
    PGC_S_INTERACTIVE,          /* dividing line for error reporting */
    PGC_S_TEST,                 /* test per-database or per-user setting */
    PGC_S_SESSION,              /* SET command */
} GucSource;

Function Documentation

AlterSystemSetConfigFile()

void AlterSystemSetConfigFile ( AlterSystemStmt *  altersysstmt )

extern

Definition at line 4508 of file guc.c.

{
    char       *name;
    char       *value;
    bool        resetall = false;
    ConfigVariable *head = NULL;
    ConfigVariable *tail = NULL;
    volatile int Tmpfd;
    char        AutoConfFileName[MAXPGPATH];
    char        AutoConfTmpFileName[MAXPGPATH];
 
    /*
     * Extract statement arguments
     */
    name = altersysstmt->setstmt->name;
 
    if (!AllowAlterSystem)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("ALTER SYSTEM is not allowed in this environment")));
 
    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;
    }
 
    /*
     * Check permission to run ALTER SYSTEM on the target variable
     */
    if (!superuser())
    {
        if (resetall)
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
        else
        {
            AclResult   aclresult;
 
            aclresult = pg_parameter_aclcheck(name, GetUserId(),
                                              ACL_ALTER_SYSTEM);
            if (aclresult != ACLCHECK_OK)
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("permission denied to set parameter \"%s\"",
                                name)));
        }
    }
 
    /*
     * Unless it's RESET_ALL, validate the target variable and value
     */
    if (!resetall)
    {
        struct config_generic *record;
 
        /* We don't want to create a placeholder if there's not one already */
        record = find_option(name, false, true, DEBUG5);
        if (record != NULL)
        {
            /*
             * 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;
 
                if (!parse_and_validate_value(record, 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)
                    guc_free(newval.stringval);
                guc_free(newextra);
            }
        }
        else
        {
            /*
             * Variable not known; check we'd be allowed to create it.  (We
             * cannot validate the value, but that's fine.  A non-core GUC in
             * the config file cannot cause postmaster start to fail, so we
             * don't have to be too tense about possibly installing a bad
             * value.)
             *
             * As an exception, we skip this check if this is a RESET command
             * for an unknown custom GUC, else there'd be no way for users to
             * remove such settings with reserved prefixes.
             */
            if (value || !valid_custom_variable_name(name))
                (void) assignable_custom_variable_name(name, false, ERROR);
        }
 
        /*
         * We must also reject values containing newlines, because the grammar
         * for config files doesn't support embedded newlines in string
         * literals.
         */
        if (value && 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, CONF_FILE_START_DEPTH,
                               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);
    }
 
    /*
     * Invoke the post-alter hook for setting this GUC variable.  GUCs
     * typically do not have corresponding entries in pg_parameter_acl, so we
     * call the hook using the name rather than a potentially-non-existent
     * OID.  Nonetheless, we pass ParameterAclRelationId so that this call
     * context can be distinguished from others.  (Note that "name" will be
     * NULL in the RESET ALL case.)
     *
     * We do this here rather than at the end, because ALTER SYSTEM is not
     * transactional.  If the hook aborts our transaction, it will be cleaner
     * to do so before we touch any files.
     */
    InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
                                    ACL_ALTER_SYSTEM,
                                    altersysstmt->setstmt->kind,
                                    false);
 
    /*
     * 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);
}

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

Referenced by standard_ProcessUtility().

AtEOXact_GUC()

void AtEOXact_GUC ( bool  isCommit, int  nestLevel  )

extern

Definition at line 2169 of file guc.c.

{
    slist_mutable_iter iter;
 
    /*
     * 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)));
 
    /* We need only process GUCs having nonempty stacks */
    slist_foreach_modify(iter, &guc_stack_list)
    {
        struct config_generic *gconf = slist_container(struct config_generic,
                                                       stack_link, iter.cur);
        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_srole = stack->srole;
                            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;
                        prev->masked_srole = stack->masked_srole;
                        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;
                Oid         newsrole;
 
                if (restoreMasked)
                {
                    newvalue = stack->masked;
                    newsource = PGC_S_SESSION;
                    newscontext = stack->masked_scontext;
                    newsrole = stack->masked_srole;
                }
                else
                {
                    newvalue = stack->prior;
                    newsource = stack->source;
                    newscontext = stack->scontext;
                    newsrole = stack->srole;
                }
 
                switch (gconf->vartype)
                {
                    case PGC_BOOL:
                        {
                            struct config_bool *conf = &gconf->_bool;
                            bool        newval = newvalue.val.boolval;
                            void       *newextra = newvalue.extra;
 
                            if (*conf->variable != newval ||
                                gconf->extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                *conf->variable = newval;
                                set_extra_field(gconf, &gconf->extra,
                                                newextra);
                                changed = true;
                            }
                            break;
                        }
                    case PGC_INT:
                        {
                            struct config_int *conf = &gconf->_int;
                            int         newval = newvalue.val.intval;
                            void       *newextra = newvalue.extra;
 
                            if (*conf->variable != newval ||
                                gconf->extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                *conf->variable = newval;
                                set_extra_field(gconf, &gconf->extra,
                                                newextra);
                                changed = true;
                            }
                            break;
                        }
                    case PGC_REAL:
                        {
                            struct config_real *conf = &gconf->_real;
                            double      newval = newvalue.val.realval;
                            void       *newextra = newvalue.extra;
 
                            if (*conf->variable != newval ||
                                gconf->extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                *conf->variable = newval;
                                set_extra_field(gconf, &gconf->extra,
                                                newextra);
                                changed = true;
                            }
                            break;
                        }
                    case PGC_STRING:
                        {
                            struct config_string *conf = &gconf->_string;
                            char       *newval = newvalue.val.stringval;
                            void       *newextra = newvalue.extra;
 
                            if (*conf->variable != newval ||
                                gconf->extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                set_string_field(gconf, conf->variable, newval);
                                set_extra_field(gconf, &gconf->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(gconf, &stack->prior.val.stringval, NULL);
                            set_string_field(gconf, &stack->masked.val.stringval, NULL);
                            break;
                        }
                    case PGC_ENUM:
                        {
                            struct config_enum *conf = &gconf->_enum;
                            int         newval = newvalue.val.enumval;
                            void       *newextra = newvalue.extra;
 
                            if (*conf->variable != newval ||
                                gconf->extra != newextra)
                            {
                                if (conf->assign_hook)
                                    conf->assign_hook(newval, newextra);
                                *conf->variable = newval;
                                set_extra_field(gconf, &gconf->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 */
                set_guc_source(gconf, newsource);
                gconf->scontext = newscontext;
                gconf->srole = newsrole;
            }
 
            /*
             * Pop the GUC's state stack; if it's now empty, remove the GUC
             * from guc_stack_list.
             */
            gconf->stack = prev;
            if (prev == NULL)
                slist_delete_current(&iter);
            pfree(stack);
 
            /* Report new value if we changed it */
            if (changed && (gconf->flags & GUC_REPORT) &&
                !(gconf->status & GUC_NEEDS_REPORT))
            {
                gconf->status |= GUC_NEEDS_REPORT;
                slist_push_head(&guc_report_list, &gconf->report_link);
            }
        }                       /* end of stack-popping loop */
    }
 
    /* Update nesting level */
    GUCNestLevel = nestLevel - 1;
}

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

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

AtStart_GUC()

void AtStart_GUC ( void  )

extern

Definition at line 2122 of file guc.c.

{
    /*
     * 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;
}

References elog, GUCNestLevel, and WARNING.

Referenced by StartTransaction().

BeginReportingGUCOptions()

void BeginReportingGUCOptions ( void  )

extern

Definition at line 2453 of file guc.c.

{
    HASH_SEQ_STATUS status;
    GUCHashEntry *hentry;
 
    /*
     * Don't do anything unless talking to an interactive frontend.
     */
    if (whereToSendOutput != DestRemote)
        return;
 
    reporting_enabled = true;
 
    /*
     * Hack for in_hot_standby: set the GUC value true if appropriate.  This
     * is kind of an ugly place to do it, but there's few better options.
     *
     * (This could be out of date by the time we actually send it, in which
     * case the next ReportChangedGUCOptions call will send a duplicate
     * report.)
     */
    if (RecoveryInProgress())
        SetConfigOption("in_hot_standby", "true",
                        PGC_INTERNAL, PGC_S_OVERRIDE);
 
    /* Transmit initial values of interesting variables */
    hash_seq_init(&status, guc_hashtab);
    while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
    {
        struct config_generic *conf = hentry->gucvar;
 
        if (conf->flags & GUC_REPORT)
            ReportGUCOption(conf);
    }
}

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

Referenced by PostgresMain().

check_GUC_name_for_parameter_acl()

void check_GUC_name_for_parameter_acl ( const char *  name )

extern

Definition at line 1288 of file guc.c.

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

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

Referenced by ParameterAclCreate().

convert_GUC_name_for_parameter_acl()

char * convert_GUC_name_for_parameter_acl ( const char *  name )

extern

Definition at line 1252 of file guc.c.

{
    char       *result;
 
    /* Apply old-GUC-name mapping. */
    for (int i = 0; map_old_guc_names[i] != NULL; i += 2)
    {
        if (guc_name_compare(name, map_old_guc_names[i]) == 0)
        {
            name = map_old_guc_names[i + 1];
            break;
        }
    }
 
    /* Apply case-folding that matches guc_name_compare(). */
    result = pstrdup(name);
    for (char *ptr = result; *ptr != '\0'; ptr++)
    {
        char        ch = *ptr;
 
        if (ch >= 'A' && ch <= 'Z')
        {
            ch += 'a' - 'A';
            *ptr = ch;
        }
    }
 
    return result;
}

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

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

DeescapeQuotedString()

char * DeescapeQuotedString ( const char *  s )

extern

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

{
    char       *newStr;
    int         len,
                i,
                j;
 
    /* We just Assert that there are leading and trailing quotes */
    Assert(s != NULL && s[0] == '\'');
    len = strlen(s);
    Assert(len >= 2);
    Assert(s[len - 1] == '\'');
 
    /* Skip the leading quote; we'll handle the trailing quote below */
    s++, len--;
 
    /* Since len still includes trailing quote, this is enough space */
    newStr = palloc(len);
 
    for (i = 0, j = 0; i < len; i++)
    {
        if (s[i] == '\\')
        {
            i++;
            switch (s[i])
            {
                case 'b':
                    newStr[j] = '\b';
                    break;
                case 'f':
                    newStr[j] = '\f';
                    break;
                case 'n':
                    newStr[j] = '\n';
                    break;
                case 'r':
                    newStr[j] = '\r';
                    break;
                case 't':
                    newStr[j] = '\t';
                    break;
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                    {
                        int         k;
                        long        octVal = 0;
 
                        for (k = 0;
                             s[i + k] >= '0' && s[i + k] <= '7' && k < 3;
                             k++)
                            octVal = (octVal << 3) + (s[i + k] - '0');
                        i += k - 1;
                        newStr[j] = ((char) octVal);
                    }
                    break;
                default:
                    newStr[j] = s[i];
                    break;
            }                   /* switch */
        }
        else if (s[i] == '\'' && s[i + 1] == '\'')
        {
            /* doubled quote becomes just one quote */
            newStr[j] = s[++i];
        }
        else
            newStr[j] = s[i];
        j++;
    }
 
    /* We copied the ending quote to newStr, so replace with \0 */
    Assert(j > 0 && j <= len);
    newStr[--j] = '\0';
 
    return newStr;
}

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

Referenced by ParseConfigFp().

DefineCustomBoolVariable()

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

extern

DefineCustomEnumVariable()

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

extern

DefineCustomIntVariable()

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

extern

DefineCustomRealVariable()

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

extern

DefineCustomStringVariable()

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

extern

EstimateGUCStateSpace()

Size EstimateGUCStateSpace ( void  )

extern

Definition at line 5855 of file guc.c.

{
    Size        size;
    dlist_iter  iter;
 
    /* Add space reqd for saving the data size of the guc state */
    size = sizeof(Size);
 
    /*
     * Add up the space needed for each GUC variable.
     *
     * We need only process non-default GUCs.
     */
    dlist_foreach(iter, &guc_nondef_list)
    {
        struct config_generic *gconf = dlist_container(struct config_generic,
                                                       nondef_link, iter.cur);
 
        size = add_size(size, estimate_variable_size(gconf));
    }
 
    return size;
}

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

Referenced by InitializeParallelDSM().

ExecSetVariableStmt()

void ExecSetVariableStmt ( VariableSetStmt *  stmt, bool  isTopLevel  )

extern

Definition at line 45 of file guc_funcs.c.

{
    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");
                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");
            pg_fallthrough;
        case VAR_RESET:
            (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;
    }
 
    /* Invoke the post-alter hook for setting this GUC variable, by name. */
    InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, stmt->name,
                                    ACL_SET, stmt->kind, false);
}

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

Referenced by standard_ProcessUtility().

ExtractSetVariableArgs()

char * ExtractSetVariableArgs ( VariableSetStmt *  stmt )

extern

Definition at line 169 of file guc_funcs.c.

{
    switch (stmt->kind)
    {
        case VAR_SET_VALUE:
            return flatten_set_variable_args(stmt->name, stmt->args);
        case VAR_SET_CURRENT:
            return GetConfigOptionByName(stmt->name, NULL, false);
        default:
            return NULL;
    }
}

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

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

FreeConfigVariables()

void FreeConfigVariables ( ConfigVariable *  list )

extern

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

{
    ConfigVariable *item;
 
    item = list;
    while (item)
    {
        ConfigVariable *next = item->next;
 
        FreeConfigVariable(item);
        item = next;
    }
}

References FreeConfigVariable(), next, and ConfigVariable::next.

Referenced by AlterSystemSetConfigFile(), and parse_extension_control_file().

get_config_handle()

config_handle * get_config_handle ( const char *  name )

extern

Definition at line 4186 of file guc.c.

{
    struct config_generic *gen = find_option(name, false, false, 0);
 
    if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
        return gen;
 
    return NULL;
}

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

Referenced by fmgr_security_definer().

get_config_unit_name()

const char * get_config_unit_name ( int  flags )

extern

Definition at line 2718 of file guc.c.

{
    switch (flags & GUC_UNIT)
    {
        case 0:
            return NULL;        /* GUC has no units */
        case GUC_UNIT_BYTE:
            return "B";
        case GUC_UNIT_KB:
            return "kB";
        case GUC_UNIT_MB:
            return "MB";
        case GUC_UNIT_BLOCKS:
            {
                static char bbuf[8];
 
                /* initialize if first time through */
                if (bbuf[0] == '\0')
                    snprintf(bbuf, sizeof(bbuf), "%dkB", BLCKSZ / 1024);
                return bbuf;
            }
        case GUC_UNIT_XBLOCKS:
            {
                static char xbuf[8];
 
                /* initialize if first time through */
                if (xbuf[0] == '\0')
                    snprintf(xbuf, sizeof(xbuf), "%dkB", XLOG_BLCKSZ / 1024);
                return xbuf;
            }
        case GUC_UNIT_MS:
            return "ms";
        case GUC_UNIT_S:
            return "s";
        case GUC_UNIT_MIN:
            return "min";
        default:
            elog(ERROR, "unrecognized GUC units value: %d",
                 flags & GUC_UNIT);
            return NULL;
    }
}

References elog, ERROR, config_generic::flags, GUC_UNIT, GUC_UNIT_BLOCKS, GUC_UNIT_BYTE, GUC_UNIT_KB, GUC_UNIT_MB, GUC_UNIT_MIN, GUC_UNIT_MS, GUC_UNIT_S, GUC_UNIT_XBLOCKS, and snprintf.

Referenced by GetConfigOptionValues(), and parse_and_validate_value().

GetConfigOption()

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

extern

Definition at line 4257 of file guc.c.

{
    struct config_generic *record;
    static char buffer[256];
 
    record = find_option(name, false, missing_ok, ERROR);
    if (record == NULL)
        return NULL;
    if (restrict_privileged &&
        !ConfigOptionIsVisible(record))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to examine \"%s\"", name),
                 errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
                           "pg_read_all_settings")));
 
    switch (record->vartype)
    {
        case PGC_BOOL:
            return *record->_bool.variable ? "on" : "off";
 
        case PGC_INT:
            snprintf(buffer, sizeof(buffer), "%d",
                     *record->_int.variable);
            return buffer;
 
        case PGC_REAL:
            snprintf(buffer, sizeof(buffer), "%g",
                     *record->_real.variable);
            return buffer;
 
        case PGC_STRING:
            return *record->_string.variable ?
                *record->_string.variable : "";
 
        case PGC_ENUM:
            return config_enum_lookup_by_value(record,
                                               *record->_enum.variable);
    }
    return NULL;
}

References config_generic::_bool, config_generic::_enum, config_generic::_int, config_generic::_real, config_generic::_string, config_enum_lookup_by_value(), ConfigOptionIsVisible(), ereport, errcode(), errdetail(), errmsg, ERROR, find_option(), name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, snprintf, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

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

GetConfigOptionByName()

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

extern

Definition at line 5339 of file guc.c.

{
    struct config_generic *record;
 
    record = find_option(name, false, missing_ok, ERROR);
    if (record == NULL)
    {
        if (varname)
            *varname = NULL;
        return NULL;
    }
 
    if (!ConfigOptionIsVisible(record))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to examine \"%s\"", name),
                 errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
                           "pg_read_all_settings")));
 
    if (varname)
        *varname = record->name;
 
    return ShowGUCOption(record, true);
}

References ConfigOptionIsVisible(), ereport, errcode(), errdetail(), errmsg, ERROR, find_option(), name, config_generic::name, and ShowGUCOption().

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

GetConfigOptionFlags()

int GetConfigOptionFlags ( const char *  name, bool  missing_ok  )

extern

Definition at line 4354 of file guc.c.

{
    struct config_generic *record;
 
    record = find_option(name, false, missing_ok, ERROR);
    if (record == NULL)
        return 0;
    return record->flags;
}

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

Referenced by append_guc_value(), pg_get_functiondef(), and PostmasterMain().

GetConfigOptionResetString()

const char * GetConfigOptionResetString ( const char *  name )

extern

Definition at line 4307 of file guc.c.

{
    struct config_generic *record;
    static char buffer[256];
 
    record = find_option(name, false, false, ERROR);
    Assert(record != NULL);
    if (!ConfigOptionIsVisible(record))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to examine \"%s\"", name),
                 errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
                           "pg_read_all_settings")));
 
    switch (record->vartype)
    {
        case PGC_BOOL:
            return record->_bool.reset_val ? "on" : "off";
 
        case PGC_INT:
            snprintf(buffer, sizeof(buffer), "%d",
                     record->_int.reset_val);
            return buffer;
 
        case PGC_REAL:
            snprintf(buffer, sizeof(buffer), "%g",
                     record->_real.reset_val);
            return buffer;
 
        case PGC_STRING:
            return record->_string.reset_val ?
                record->_string.reset_val : "";
 
        case PGC_ENUM:
            return config_enum_lookup_by_value(record,
                                               record->_enum.reset_val);
    }
    return NULL;
}

References config_generic::_bool, config_generic::_enum, config_generic::_int, config_generic::_real, config_generic::_string, Assert, config_enum_lookup_by_value(), ConfigOptionIsVisible(), ereport, errcode(), errdetail(), errmsg, ERROR, find_option(), name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, config_bool::reset_val, config_int::reset_val, config_real::reset_val, config_string::reset_val, config_enum::reset_val, snprintf, and config_generic::vartype.

Referenced by check_datestyle().

GetPGVariable()

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

extern

Definition at line 410 of file guc_funcs.c.

{
    if (guc_name_compare(name, "all") == 0)
        ShowAllGUCConfig(dest);
    else
        ShowGUCConfigOption(name, dest);
}

References guc_name_compare(), name, ShowAllGUCConfig(), and ShowGUCConfigOption().

Referenced by exec_replication_command(), and standard_ProcessUtility().

GetPGVariableResultDesc()

TupleDesc GetPGVariableResultDesc ( const char *  name )

extern

Definition at line 422 of file guc_funcs.c.

{
    TupleDesc   tupdesc;
 
    if (guc_name_compare(name, "all") == 0)
    {
        /* need a tuple descriptor representing three TEXT columns */
        tupdesc = CreateTemplateTupleDesc(3);
        TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 2, "setting",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 3, "description",
                           TEXTOID, -1, 0);
    }
    else
    {
        const char *varname;
 
        /* Get the canonical spelling of name */
        (void) GetConfigOptionByName(name, &varname, false);
 
        /* need a tuple descriptor representing a single TEXT column */
        tupdesc = CreateTemplateTupleDesc(1);
        TupleDescInitEntry(tupdesc, (AttrNumber) 1, varname,
                           TEXTOID, -1, 0);
    }
    TupleDescFinalize(tupdesc);
    return tupdesc;
}

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

Referenced by UtilityTupleDescriptor().

GUC_check_errcode()

void GUC_check_errcode ( int  sqlerrcode )

extern

Definition at line 6666 of file guc.c.

{
    GUC_check_errcode_value = sqlerrcode;
}

References GUC_check_errcode_value.

Referenced by check_client_encoding(), check_default_with_oids(), check_primary_slot_name(), check_role(), check_session_authorization(), check_standard_conforming_strings(), check_synchronous_standby_names(), check_transaction_deferrable(), check_transaction_isolation(), check_transaction_read_only(), pgsa_check_stash_name_guc(), and validate_sync_standby_slots().

guc_free()

void guc_free ( void *  ptr )

extern

Definition at line 688 of file guc.c.

{
    /*
     * Historically, GUC-related code has relied heavily on the ability to do
     * free(NULL), so we allow that here even though pfree() doesn't.
     */
    if (ptr != NULL)
    {
        /* This is to help catch old code that malloc's GUC data. */
        Assert(GetMemoryChunkContext(ptr) == GUCMemoryContext);
        pfree(ptr);
    }
}

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

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

guc_malloc()

void * guc_malloc ( int  elevel, size_t  size  )

extern

Definition at line 637 of file guc.c.

{
    void       *data;
 
    data = MemoryContextAllocExtended(GUCMemoryContext, size,
                                      MCXT_ALLOC_NO_OOM);
    if (unlikely(data == NULL))
        ereport(elevel,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
    return data;
}

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

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

guc_realloc()

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

extern

Definition at line 651 of file guc.c.

{
    void       *data;
 
    if (old != NULL)
    {
        /* This is to help catch old code that malloc's GUC data. */
        Assert(GetMemoryChunkContext(old) == GUCMemoryContext);
        data = repalloc_extended(old, size,
                                 MCXT_ALLOC_NO_OOM);
    }
    else
    {
        /* Like realloc(3), but not like repalloc(), we allow old == NULL. */
        data = MemoryContextAllocExtended(GUCMemoryContext, size,
                                          MCXT_ALLOC_NO_OOM);
    }
    if (unlikely(data == NULL))
        ereport(elevel,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
    return data;
}

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

guc_strdup()

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

extern

Definition at line 676 of file guc.c.

{
    char       *data;
    size_t      len = strlen(src) + 1;
 
    data = guc_malloc(elevel, len);
    if (likely(data != NULL))
        memcpy(data, src, len);
    return data;
}

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

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

GUCArrayAdd()

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

extern

Definition at line 6366 of file guc.c.

{
    struct config_generic *record;
    Datum       datum;
    char       *newval;
    ArrayType  *a;
 
    Assert(name);
    Assert(value);
 
    /* test if the option is valid and we're allowed to set it */
    (void) validate_option_array_item(name, value, false);
 
    /* normalize name (converts obsolete GUC names to modern spellings) */
    record = find_option(name, false, true, WARNING);
    if (record)
        name = record->name;
 
    /* build new item for array */
    newval = psprintf("%s=%s", name, value);
    datum = CStringGetTextDatum(newval);
 
    if (array)
    {
        int         index;
        bool        isnull;
 
        Assert(ARR_ELEMTYPE(array) == TEXTOID);
        Assert(ARR_NDIM(array) == 1);
        Assert(ARR_LBOUND(array)[0] == 1);
 
        index = ARR_DIMS(array)[0] + 1; /* add after end */
 
        for (int i = 1; i <= ARR_DIMS(array)[0]; i++)
        {
            Datum       d;
            char       *current;
 
            d = array_ref(array, 1, &i,
                          -1 /* varlenarray */ ,
                          -1 /* TEXT's typlen */ ,
                          false /* TEXT's typbyval */ ,
                          TYPALIGN_INT /* TEXT's typalign */ ,
                          &isnull);
            if (isnull)
                continue;
            current = TextDatumGetCString(d);
 
            /* check for match up through and including '=' */
            if (strncmp(current, newval, strlen(name) + 1) == 0)
            {
                index = i;
                break;
            }
        }
 
        a = array_set(array, 1, &index,
                      datum,
                      false,
                      -1 /* varlena array */ ,
                      -1 /* TEXT's typlen */ ,
                      false /* TEXT's typbyval */ ,
                      TYPALIGN_INT /* TEXT's typalign */ );
    }
    else
        a = construct_array_builtin(&datum, 1, TEXTOID);
 
    return a;
}

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

Referenced by AlterSetting(), and update_proconfig_value().

GUCArrayDelete()

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

extern

Definition at line 6443 of file guc.c.

{
    struct config_generic *record;
    ArrayType  *newarray;
    int         index;
 
    Assert(name);
 
    /* test if the option is valid and we're allowed to set it */
    (void) validate_option_array_item(name, NULL, false);
 
    /* normalize name (converts obsolete GUC names to modern spellings) */
    record = find_option(name, false, true, WARNING);
    if (record)
        name = record->name;
 
    /* if array is currently null, then surely nothing to delete */
    if (!array)
        return NULL;
 
    newarray = NULL;
    index = 1;
 
    for (int i = 1; i <= ARR_DIMS(array)[0]; i++)
    {
        Datum       d;
        char       *val;
        bool        isnull;
 
        d = array_ref(array, 1, &i,
                      -1 /* varlenarray */ ,
                      -1 /* TEXT's typlen */ ,
                      false /* TEXT's typbyval */ ,
                      TYPALIGN_INT /* TEXT's typalign */ ,
                      &isnull);
        if (isnull)
            continue;
        val = TextDatumGetCString(d);
 
        /* ignore entry if it's what we want to delete */
        if (strncmp(val, name, strlen(name)) == 0
            && val[strlen(name)] == '=')
            continue;
 
        /* else add it to the output array */
        if (newarray)
            newarray = array_set(newarray, 1, &index,
                                 d,
                                 false,
                                 -1 /* varlenarray */ ,
                                 -1 /* TEXT's typlen */ ,
                                 false /* TEXT's typbyval */ ,
                                 TYPALIGN_INT /* TEXT's typalign */ );
        else
            newarray = construct_array_builtin(&d, 1, TEXTOID);
 
        index++;
    }
 
    return newarray;
}

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

Referenced by AlterSetting(), and update_proconfig_value().

GUCArrayReset()

ArrayType * GUCArrayReset ( ArrayType *  array )

extern

Definition at line 6512 of file guc.c.

{
    ArrayType  *newarray;
    int         index;
 
    /* if array is currently null, nothing to do */
    if (!array)
        return NULL;
 
    /* if we're superuser, we can delete everything, so just do it */
    if (superuser())
        return NULL;
 
    newarray = NULL;
    index = 1;
 
    for (int i = 1; i <= ARR_DIMS(array)[0]; i++)
    {
        Datum       d;
        char       *val;
        char       *eqsgn;
        bool        isnull;
 
        d = array_ref(array, 1, &i,
                      -1 /* varlenarray */ ,
                      -1 /* TEXT's typlen */ ,
                      false /* TEXT's typbyval */ ,
                      TYPALIGN_INT /* TEXT's typalign */ ,
                      &isnull);
        if (isnull)
            continue;
        val = TextDatumGetCString(d);
 
        eqsgn = strchr(val, '=');
        *eqsgn = '\0';
 
        /* skip if we have permission to delete it */
        if (validate_option_array_item(val, NULL, true))
            continue;
 
        /* else add it to the output array */
        if (newarray)
            newarray = array_set(newarray, 1, &index,
                                 d,
                                 false,
                                 -1 /* varlenarray */ ,
                                 -1 /* TEXT's typlen */ ,
                                 false /* TEXT's typbyval */ ,
                                 TYPALIGN_INT /* TEXT's typalign */ );
        else
            newarray = construct_array_builtin(&d, 1, TEXTOID);
 
        index++;
        pfree(val);
    }
 
    return newarray;
}

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

Referenced by AlterSetting().

InitializeGUCOptions()

void InitializeGUCOptions ( void  )

extern

Definition at line 1408 of file guc.c.

{
    HASH_SEQ_STATUS status;
    GUCHashEntry *hentry;
 
    /*
     * Before log_line_prefix could possibly receive a nonempty setting, make
     * sure that timezone processing is minimally alive (see elog.c).
     */
    pg_timezone_initialize();
 
    /*
     * Create GUCMemoryContext and build hash table of all GUC variables.
     */
    build_guc_variables();
 
    /*
     * Load all variables with their compiled-in defaults, and initialize
     * status fields as needed.
     */
    hash_seq_init(&status, guc_hashtab);
    while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
    {
        /* Check mapping between initial and default value */
        Assert(check_GUC_init(hentry->gucvar));
 
        InitializeOneGUCOption(hentry->gucvar);
    }
 
    reporting_enabled = false;
 
    /*
     * Prevent any attempt to override the transaction modes from
     * non-interactive sources.
     */
    SetConfigOption("transaction_isolation", "read committed",
                    PGC_POSTMASTER, PGC_S_OVERRIDE);
    SetConfigOption("transaction_read_only", "no",
                    PGC_POSTMASTER, PGC_S_OVERRIDE);
    SetConfigOption("transaction_deferrable", "no",
                    PGC_POSTMASTER, PGC_S_OVERRIDE);
 
    /*
     * For historical reasons, some GUC parameters can receive defaults from
     * environment variables.  Process those settings.
     */
    InitializeGUCOptionsFromEnvironment();
}

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

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

MarkGUCPrefixReserved()

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

extern

Definition at line 5186 of file guc.c.

{
    int         classLen = strlen(className);
    HASH_SEQ_STATUS status;
    GUCHashEntry *hentry;
    MemoryContext oldcontext;
 
    /*
     * Check for existing placeholders.  We must actually remove invalid
     * placeholders, else future parallel worker startups will fail.
     */
    hash_seq_init(&status, guc_hashtab);
    while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
    {
        struct config_generic *var = hentry->gucvar;
 
        if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
            strncmp(className, var->name, classLen) == 0 &&
            var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
        {
            ereport(WARNING,
                    (errcode(ERRCODE_INVALID_NAME),
                     errmsg("invalid configuration parameter name \"%s\", removing it",
                            var->name),
                     errdetail("\"%s\" is now a reserved prefix.",
                               className)));
            /* Remove it from the hash table */
            hash_search(guc_hashtab,
                        &var->name,
                        HASH_REMOVE,
                        NULL);
            /* Remove it from any lists it's in, too */
            RemoveGUCFromLists(var);
            /* And free it */
            free_placeholder(var);
        }
    }
 
    /* And remember the name so we can prevent future mistakes. */
    oldcontext = MemoryContextSwitchTo(GUCMemoryContext);
    reserved_class_prefix = lappend(reserved_class_prefix, pstrdup(className));
    MemoryContextSwitchTo(oldcontext);
}

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

Referenced by _PG_init().

NewGUCNestLevel()

int NewGUCNestLevel ( void  )

extern

Definition at line 2142 of file guc.c.

{
    return ++GUCNestLevel;
}

References GUCNestLevel.

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

parse_int()

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

extern

Definition at line 2775 of file guc.c.

{
    /*
     * We assume here that double is wide enough to represent any integer
     * value with adequate precision.
     */
    double      val;
    char       *endptr;
 
    /* To suppress compiler warnings, always set output params */
    if (result)
        *result = 0;
    if (hintmsg)
        *hintmsg = NULL;
 
    /*
     * Try to parse as an integer (allowing octal or hex input).  If the
     * conversion stops at a decimal point or 'e', or overflows, re-parse as
     * float.  This should work fine as long as we have no unit names starting
     * with 'e'.  If we ever do, the test could be extended to check for a
     * sign or digit after 'e', but for now that's unnecessary.
     */
    errno = 0;
    val = strtol(value, &endptr, 0);
    if (*endptr == '.' || *endptr == 'e' || *endptr == 'E' ||
        errno == ERANGE)
    {
        errno = 0;
        val = strtod(value, &endptr);
    }
 
    if (endptr == value || errno == ERANGE)
        return false;           /* no HINT for these cases */
 
    /* reject NaN (infinities will fail range check below) */
    if (isnan(val))
        return false;           /* treat same as syntax error; no HINT */
 
    /* allow whitespace between number and unit */
    while (isspace((unsigned char) *endptr))
        endptr++;
 
    /* Handle possible unit */
    if (*endptr != '\0')
    {
        if ((flags & GUC_UNIT) == 0)
            return false;       /* this setting does not accept a unit */
 
        if (!convert_to_base_unit(val,
                                  endptr, (flags & GUC_UNIT),
                                  &val))
        {
            /* invalid unit, or garbage after the unit; set hint and fail. */
            if (hintmsg)
            {
                if (flags & GUC_UNIT_MEMORY)
                    *hintmsg = memory_units_hint;
                else
                    *hintmsg = time_units_hint;
            }
            return false;
        }
    }
 
    /* Round to int, then check for overflow */
    val = rint(val);
 
    if (val > INT_MAX || val < INT_MIN)
    {
        if (hintmsg)
            *hintmsg = gettext_noop("Value exceeds integer range.");
        return false;
    }
 
    if (result)
        *result = (int) val;
    return true;
}

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

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

parse_real()

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

extern

Definition at line 2865 of file guc.c.

{
    double      val;
    char       *endptr;
 
    /* To suppress compiler warnings, always set output params */
    if (result)
        *result = 0;
    if (hintmsg)
        *hintmsg = NULL;
 
    errno = 0;
    val = strtod(value, &endptr);
 
    if (endptr == value || errno == ERANGE)
        return false;           /* no HINT for these cases */
 
    /* reject NaN (infinities will fail range checks later) */
    if (isnan(val))
        return false;           /* treat same as syntax error; no HINT */
 
    /* allow whitespace between number and unit */
    while (isspace((unsigned char) *endptr))
        endptr++;
 
    /* Handle possible unit */
    if (*endptr != '\0')
    {
        if ((flags & GUC_UNIT) == 0)
            return false;       /* this setting does not accept a unit */
 
        if (!convert_to_base_unit(val,
                                  endptr, (flags & GUC_UNIT),
                                  &val))
        {
            /* invalid unit, or garbage after the unit; set hint and fail. */
            if (hintmsg)
            {
                if (flags & GUC_UNIT_MEMORY)
                    *hintmsg = memory_units_hint;
                else
                    *hintmsg = time_units_hint;
            }
            return false;
        }
    }
 
    if (result)
        *result = val;
    return true;
}

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

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

ParseConfigDirectory()

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

extern

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

{
    char       *err_msg;
    char      **filenames;
    int         num_filenames;
 
    filenames = GetConfFilesInDir(includedir, calling_file, elevel,
                                  &num_filenames, &err_msg);
 
    if (!filenames)
    {
        record_config_file_error(err_msg, calling_file, calling_lineno, head_p,
                                 tail_p);
        return false;
    }
 
    for (int i = 0; i < num_filenames; i++)
    {
        if (!ParseConfigFile(filenames[i], true,
                             calling_file, calling_lineno,
                             depth, elevel,
                             head_p, tail_p))
            return false;
    }
 
    return true;
}

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

Referenced by ParseConfigFp().

ParseConfigFile()

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

extern

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

{
    char       *abs_path;
    bool        OK = true;
    FILE       *fp;
 
    /*
     * Reject file name that is all-blank (including empty), as that leads to
     * confusion --- we'd try to read the containing directory as a file.
     */
    if (strspn(config_file, " \t\r\n") == strlen(config_file))
    {
        ereport(elevel,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("empty configuration file name: \"%s\"",
                        config_file)));
        record_config_file_error("empty configuration file name",
                                 calling_file, calling_lineno,
                                 head_p, tail_p);
        return false;
    }
 
    /*
     * Reject too-deep include nesting depth.  This is just a safety check to
     * avoid dumping core due to stack overflow if an include file loops back
     * to itself.  The maximum nesting depth is pretty arbitrary.
     */
    if (depth > CONF_FILE_MAX_DEPTH)
    {
        ereport(elevel,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("could not open configuration file \"%s\": maximum nesting depth exceeded",
                        config_file)));
        record_config_file_error("nesting depth exceeded",
                                 calling_file, calling_lineno,
                                 head_p, tail_p);
        return false;
    }
 
    abs_path = AbsoluteConfigLocation(config_file, calling_file);
 
    /*
     * Reject direct recursion.  Indirect recursion is also possible, but it's
     * harder to detect and so doesn't seem worth the trouble.  (We test at
     * this step because the canonicalization done by AbsoluteConfigLocation
     * makes it more likely that a simple strcmp comparison will match.)
     */
    if (calling_file && strcmp(abs_path, calling_file) == 0)
    {
        ereport(elevel,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("configuration file recursion in \"%s\"",
                        calling_file)));
        record_config_file_error("configuration file recursion",
                                 calling_file, calling_lineno,
                                 head_p, tail_p);
        pfree(abs_path);
        return false;
    }
 
    fp = AllocateFile(abs_path, "r");
    if (!fp)
    {
        if (strict)
        {
            ereport(elevel,
                    (errcode_for_file_access(),
                     errmsg("could not open configuration file \"%s\": %m",
                            abs_path)));
            record_config_file_error(psprintf("could not open file \"%s\"",
                                              abs_path),
                                     calling_file, calling_lineno,
                                     head_p, tail_p);
            OK = false;
        }
        else
        {
            ereport(LOG,
                    (errmsg("skipping missing configuration file \"%s\"",
                            abs_path)));
        }
        goto cleanup;
    }
 
    OK = ParseConfigFp(fp, abs_path, depth, elevel, head_p, tail_p);
 
cleanup:
    if (fp)
        FreeFile(fp);
    pfree(abs_path);
 
    return OK;
}

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

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

ParseConfigFp()

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

extern

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

{
    volatile bool OK = true;
    unsigned int save_ConfigFileLineno = ConfigFileLineno;
    sigjmp_buf *save_GUC_flex_fatal_jmp = GUC_flex_fatal_jmp;
    sigjmp_buf  flex_fatal_jmp;
    yyscan_t    scanner;
    struct yyguts_t *yyg;       /* needed for yytext macro */
    volatile YY_BUFFER_STATE lex_buffer = NULL;
    int         errorcount;
    int         token;
 
    if (sigsetjmp(flex_fatal_jmp, 1) == 0)
        GUC_flex_fatal_jmp = &flex_fatal_jmp;
    else
    {
        /*
         * Regain control after a fatal, internal flex error.  It may have
         * corrupted parser state.  Consequently, abandon the file, but trust
         * that the state remains sane enough for yy_delete_buffer().
         */
        elog(elevel, "%s at file \"%s\" line %u",
             GUC_flex_fatal_errmsg, config_file, ConfigFileLineno);
        record_config_file_error(GUC_flex_fatal_errmsg,
                                 config_file, ConfigFileLineno,
                                 head_p, tail_p);
        OK = false;
        goto cleanup;
    }
 
    /*
     * Parse
     */
    ConfigFileLineno = 1;
    errorcount = 0;
 
    if (yylex_init(&scanner) != 0)
        elog(elevel, "yylex_init() failed: %m");
    yyg = (struct yyguts_t *) scanner;
 
    lex_buffer = yy_create_buffer(fp, YY_BUF_SIZE, scanner);
    yy_switch_to_buffer(lex_buffer, scanner);
 
    /* This loop iterates once per logical line */
    while ((token = yylex(scanner)))
    {
        char       *opt_name = NULL;
        char       *opt_value = NULL;
        ConfigVariable *item;
 
        if (token == GUC_EOL)   /* empty or comment line */
            continue;
 
        /* first token on line is option name */
        if (token != GUC_ID && token != GUC_QUALIFIED_ID)
            goto parse_error;
        opt_name = pstrdup(yytext);
 
        /* next we have an optional equal sign; discard if present */
        token = yylex(scanner);
        if (token == GUC_EQUALS)
            token = yylex(scanner);
 
        /* now we must have the option value */
        if (token != GUC_ID &&
            token != GUC_STRING &&
            token != GUC_INTEGER &&
            token != GUC_REAL &&
            token != GUC_UNQUOTED_STRING)
            goto parse_error;
        if (token == GUC_STRING)    /* strip quotes and escapes */
            opt_value = DeescapeQuotedString(yytext);
        else
            opt_value = pstrdup(yytext);
 
        /* now we'd like an end of line, or possibly EOF */
        token = yylex(scanner);
        if (token != GUC_EOL)
        {
            if (token != 0)
                goto parse_error;
            /* treat EOF like \n for line numbering purposes, cf bug 4752 */
            ConfigFileLineno++;
        }
 
        /* OK, process the option name and value */
        if (guc_name_compare(opt_name, "include_dir") == 0)
        {
            /*
             * An include_dir directive isn't a variable and should be
             * processed immediately.
             */
            if (!ParseConfigDirectory(opt_value,
                                      config_file, ConfigFileLineno - 1,
                                      depth + 1, elevel,
                                      head_p, tail_p))
                OK = false;
            yy_switch_to_buffer(lex_buffer, scanner);
            pfree(opt_name);
            pfree(opt_value);
        }
        else if (guc_name_compare(opt_name, "include_if_exists") == 0)
        {
            /*
             * An include_if_exists directive isn't a variable and should be
             * processed immediately.
             */
            if (!ParseConfigFile(opt_value, false,
                                 config_file, ConfigFileLineno - 1,
                                 depth + 1, elevel,
                                 head_p, tail_p))
                OK = false;
            yy_switch_to_buffer(lex_buffer, scanner);
            pfree(opt_name);
            pfree(opt_value);
        }
        else if (guc_name_compare(opt_name, "include") == 0)
        {
            /*
             * An include directive isn't a variable and should be processed
             * immediately.
             */
            if (!ParseConfigFile(opt_value, true,
                                 config_file, ConfigFileLineno - 1,
                                 depth + 1, elevel,
                                 head_p, tail_p))
                OK = false;
            yy_switch_to_buffer(lex_buffer, scanner);
            pfree(opt_name);
            pfree(opt_value);
        }
        else
        {
            /* ordinary variable, append to list */
            item = palloc_object(ConfigVariable);
            item->name = opt_name;
            item->value = opt_value;
            item->errmsg = NULL;
            item->filename = pstrdup(config_file);
            item->sourceline = ConfigFileLineno - 1;
            item->ignore = false;
            item->applied = false;
            item->next = NULL;
            if (*head_p == NULL)
                *head_p = item;
            else
                (*tail_p)->next = item;
            *tail_p = item;
        }
 
        /* break out of loop if read EOF, else loop for next line */
        if (token == 0)
            break;
        continue;
 
parse_error:
        /* release storage if we allocated any on this line */
        if (opt_name)
            pfree(opt_name);
        if (opt_value)
            pfree(opt_value);
 
        /* report the error */
        if (token == GUC_EOL || token == 0)
        {
            ereport(elevel,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("syntax error in file \"%s\" line %u, near end of line",
                            config_file, ConfigFileLineno - 1)));
            record_config_file_error("syntax error",
                                     config_file, ConfigFileLineno - 1,
                                     head_p, tail_p);
        }
        else
        {
            ereport(elevel,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("syntax error in file \"%s\" line %u, near token \"%s\"",
                            config_file, ConfigFileLineno, yytext)));
            record_config_file_error("syntax error",
                                     config_file, ConfigFileLineno,
                                     head_p, tail_p);
        }
        OK = false;
        errorcount++;
 
        /*
         * To avoid producing too much noise when fed a totally bogus file,
         * give up after 100 syntax errors per file (an arbitrary number).
         * Also, if we're only logging the errors at DEBUG level anyway, might
         * as well give up immediately.  (This prevents postmaster children
         * from bloating the logs with duplicate complaints.)
         */
        if (errorcount >= 100 || elevel <= DEBUG1)
        {
            ereport(elevel,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("too many syntax errors found, abandoning file \"%s\"",
                            config_file)));
            break;
        }
 
        /* resync to next end-of-line or EOF */
        while (token != GUC_EOL && token != 0)
            token = yylex(scanner);
        /* break out of loop on EOF */
        if (token == 0)
            break;
    }
 
cleanup:
    yy_delete_buffer(lex_buffer, scanner);
    yylex_destroy(scanner);
    /* Each recursion level must save and restore these static variables. */
    ConfigFileLineno = save_ConfigFileLineno;
    GUC_flex_fatal_jmp = save_GUC_flex_fatal_jmp;
    return OK;
}

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

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

ParseLongOption()

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

extern

Definition at line 6243 of file guc.c.

{
    size_t      equal_pos;
 
    Assert(string);
    Assert(name);
    Assert(value);
 
    equal_pos = strcspn(string, "=");
 
    if (string[equal_pos] == '=')
    {
        *name = palloc(equal_pos + 1);
        strlcpy(*name, string, equal_pos + 1);
 
        *value = pstrdup(&string[equal_pos + 1]);
    }
    else
    {
        /* no equal sign in string */
        *name = pstrdup(string);
        *value = NULL;
    }
 
    for (char *cp = *name; *cp; cp++)
        if (*cp == '-')
            *cp = '_';
}

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

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

ProcessConfigFile()

void ProcessConfigFile ( GucContext  context )

extern

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

{
    int         elevel;
    MemoryContext config_cxt;
    MemoryContext caller_cxt;
 
    /*
     * Config files are processed on startup (by the postmaster only) and on
     * SIGHUP (by the postmaster and its children)
     */
    Assert((context == PGC_POSTMASTER && !IsUnderPostmaster) ||
           context == PGC_SIGHUP);
 
    /*
     * To avoid cluttering the log, only the postmaster bleats loudly about
     * problems with the config file.
     */
    elevel = IsUnderPostmaster ? DEBUG2 : LOG;
 
    /*
     * This function is usually called within a process-lifespan memory
     * context.  To ensure that any memory leaked during GUC processing does
     * not accumulate across repeated SIGHUP cycles, do the work in a private
     * context that we can free at exit.
     */
    config_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                       "config file processing",
                                       ALLOCSET_DEFAULT_SIZES);
    caller_cxt = MemoryContextSwitchTo(config_cxt);
 
    /*
     * Read and apply the config file.  We don't need to examine the result.
     */
    (void) ProcessConfigFileInternal(context, true, elevel);
 
    /* Clean up */
    MemoryContextSwitchTo(caller_cxt);
    MemoryContextDelete(config_cxt);
}

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

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

ProcessGUCArray()

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

extern

Definition at line 6334 of file guc.c.

{
    List       *gucNames;
    List       *gucValues;
    ListCell   *lc1;
    ListCell   *lc2;
 
    TransformGUCArray(array, &gucNames, &gucValues);
    forboth(lc1, gucNames, lc2, gucValues)
    {
        char       *name = lfirst(lc1);
        char       *value = lfirst(lc2);
 
        (void) set_config_option(name, value,
                                 context, source,
                                 action, true, 0, false);
 
        pfree(name);
        pfree(value);
    }
 
    list_free(gucNames);
    list_free(gucValues);
}

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

Referenced by ApplySetting(), and ProcedureCreate().

ReportChangedGUCOptions()

void ReportChangedGUCOptions ( void  )

extern

Definition at line 2503 of file guc.c.

{
    slist_mutable_iter iter;
 
    /* Quick exit if not (yet) enabled */
    if (!reporting_enabled)
        return;
 
    /*
     * Since in_hot_standby isn't actually changed by normal GUC actions, we
     * need a hack to check whether a new value needs to be reported to the
     * client.  For speed, we rely on the assumption that it can never
     * transition from false to true.
     */
    if (in_hot_standby_guc && !RecoveryInProgress())
        SetConfigOption("in_hot_standby", "false",
                        PGC_INTERNAL, PGC_S_OVERRIDE);
 
    /* Transmit new values of interesting variables */
    slist_foreach_modify(iter, &guc_report_list)
    {
        struct config_generic *conf = slist_container(struct config_generic,
                                                      report_link, iter.cur);
 
        Assert((conf->flags & GUC_REPORT) && (conf->status & GUC_NEEDS_REPORT));
        ReportGUCOption(conf);
        conf->status &= ~GUC_NEEDS_REPORT;
        slist_delete_current(&iter);
    }
}

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

Referenced by PostgresMain().

ResetAllOptions()

void ResetAllOptions ( void  )

extern

Definition at line 1910 of file guc.c.

{
    dlist_mutable_iter iter;
 
    /* We need only consider GUCs not already at PGC_S_DEFAULT */
    dlist_foreach_modify(iter, &guc_nondef_list)
    {
        struct config_generic *gconf = dlist_container(struct config_generic,
                                                       nondef_link, iter.cur);
 
        /* Don't reset non-SET-able values */
        if (gconf->context != PGC_SUSET &&
            gconf->context != PGC_USERSET)
            continue;
        /* Don't reset if special exclusion from RESET ALL */
        if (gconf->flags & GUC_NO_RESET_ALL)
            continue;
        /* No need to reset if wasn't SET */
        if (gconf->source <= PGC_S_OVERRIDE)
            continue;
 
        /* Save old value to support transaction abort */
        push_old_value(gconf, GUC_ACTION_SET);
 
        switch (gconf->vartype)
        {
            case PGC_BOOL:
                {
                    struct config_bool *conf = &gconf->_bool;
 
                    if (conf->assign_hook)
                        conf->assign_hook(conf->reset_val,
                                          gconf->reset_extra);
                    *conf->variable = conf->reset_val;
                    set_extra_field(gconf, &gconf->extra,
                                    gconf->reset_extra);
                    break;
                }
            case PGC_INT:
                {
                    struct config_int *conf = &gconf->_int;
 
                    if (conf->assign_hook)
                        conf->assign_hook(conf->reset_val,
                                          gconf->reset_extra);
                    *conf->variable = conf->reset_val;
                    set_extra_field(gconf, &gconf->extra,
                                    gconf->reset_extra);
                    break;
                }
            case PGC_REAL:
                {
                    struct config_real *conf = &gconf->_real;
 
                    if (conf->assign_hook)
                        conf->assign_hook(conf->reset_val,
                                          gconf->reset_extra);
                    *conf->variable = conf->reset_val;
                    set_extra_field(gconf, &gconf->extra,
                                    gconf->reset_extra);
                    break;
                }
            case PGC_STRING:
                {
                    struct config_string *conf = &gconf->_string;
 
                    if (conf->assign_hook)
                        conf->assign_hook(conf->reset_val,
                                          gconf->reset_extra);
                    set_string_field(gconf, conf->variable, conf->reset_val);
                    set_extra_field(gconf, &gconf->extra,
                                    gconf->reset_extra);
                    break;
                }
            case PGC_ENUM:
                {
                    struct config_enum *conf = &gconf->_enum;
 
                    if (conf->assign_hook)
                        conf->assign_hook(conf->reset_val,
                                          gconf->reset_extra);
                    *conf->variable = conf->reset_val;
                    set_extra_field(gconf, &gconf->extra,
                                    gconf->reset_extra);
                    break;
                }
        }
 
        set_guc_source(gconf, gconf->reset_source);
        gconf->scontext = gconf->reset_scontext;
        gconf->srole = gconf->reset_srole;
 
        if ((gconf->flags & GUC_REPORT) && !(gconf->status & GUC_NEEDS_REPORT))
        {
            gconf->status |= GUC_NEEDS_REPORT;
            slist_push_head(&guc_report_list, &gconf->report_link);
        }
    }
}

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

Referenced by DiscardAll(), and ExecSetVariableStmt().

RestoreGUCState()

void RestoreGUCState ( void *  gucstate )

extern

Definition at line 6100 of file guc.c.

{
    char       *varname,
               *varvalue,
               *varsourcefile;
    int         varsourceline;
    GucSource   varsource;
    GucContext  varscontext;
    Oid         varsrole;
    char       *srcptr = (char *) gucstate;
    char       *srcend;
    Size        len;
    dlist_mutable_iter iter;
    ErrorContextCallback error_context_callback;
 
    /*
     * First, ensure that all potentially-shippable GUCs are reset to their
     * default values.  We must not touch those GUCs that the leader will
     * never ship, while there is no need to touch those that are shippable
     * but already have their default values.  Thus, this ends up being the
     * same test that SerializeGUCState uses, even though the sets of
     * variables involved may well be different since the leader's set of
     * variables-not-at-default-values can differ from the set that are
     * not-default in this freshly started worker.
     *
     * Once we have set all the potentially-shippable GUCs to default values,
     * restoring the GUCs that the leader sent (because they had non-default
     * values over there) leads us to exactly the set of GUC values that the
     * leader has.  This is true even though the worker may have initially
     * absorbed postgresql.conf settings that the leader hasn't yet seen, or
     * ALTER USER/DATABASE SET settings that were established after the leader
     * started.
     *
     * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
     * also ensures that set_config_option won't refuse to set them because of
     * source-priority comparisons.
     */
    dlist_foreach_modify(iter, &guc_nondef_list)
    {
        struct config_generic *gconf = dlist_container(struct config_generic,
                                                       nondef_link, iter.cur);
 
        /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
        if (can_skip_gucvar(gconf))
            continue;
 
        /*
         * We can use InitializeOneGUCOption to reset the GUC to default, but
         * first we must free any existing subsidiary data to avoid leaking
         * memory.  The stack must be empty, but we have to clean up all other
         * fields.  Beware that there might be duplicate value or "extra"
         * pointers.  We also have to be sure to take it out of any lists it's
         * in.
         */
        Assert(gconf->stack == NULL);
        guc_free(gconf->extra);
        guc_free(gconf->last_reported);
        guc_free(gconf->sourcefile);
        switch (gconf->vartype)
        {
            case PGC_BOOL:
            case PGC_INT:
            case PGC_REAL:
            case PGC_ENUM:
                /* no need to do anything */
                break;
            case PGC_STRING:
                {
                    struct config_string *conf = &gconf->_string;
 
                    guc_free(*conf->variable);
                    if (conf->reset_val && conf->reset_val != *conf->variable)
                        guc_free(conf->reset_val);
                    break;
                }
        }
        if (gconf->reset_extra && gconf->reset_extra != gconf->extra)
            guc_free(gconf->reset_extra);
        /* Remove it from any lists it's in. */
        RemoveGUCFromLists(gconf);
        /* Now we can reset the struct to PGS_S_DEFAULT state. */
        InitializeOneGUCOption(gconf);
    }
 
    /* First item is the length of the subsequent data */
    memcpy(&len, gucstate, sizeof(len));
 
    srcptr += sizeof(len);
    srcend = srcptr + len;
 
    /* If the GUC value check fails, we want errors to show useful context. */
    error_context_callback.callback = guc_restore_error_context_callback;
    error_context_callback.previous = error_context_stack;
    error_context_callback.arg = NULL;
    error_context_stack = &error_context_callback;
 
    /* Restore all the listed GUCs. */
    while (srcptr < srcend)
    {
        int         result;
        char       *error_context_name_and_value[2];
 
        varname = read_gucstate(&srcptr, srcend);
        varvalue = read_gucstate(&srcptr, srcend);
        varsourcefile = read_gucstate(&srcptr, srcend);
        if (varsourcefile[0])
            read_gucstate_binary(&srcptr, srcend,
                                 &varsourceline, sizeof(varsourceline));
        else
            varsourceline = 0;
        read_gucstate_binary(&srcptr, srcend,
                             &varsource, sizeof(varsource));
        read_gucstate_binary(&srcptr, srcend,
                             &varscontext, sizeof(varscontext));
        read_gucstate_binary(&srcptr, srcend,
                             &varsrole, sizeof(varsrole));
 
        error_context_name_and_value[0] = varname;
        error_context_name_and_value[1] = varvalue;
        error_context_callback.arg = &error_context_name_and_value[0];
        result = set_config_option_ext(varname, varvalue,
                                       varscontext, varsource, varsrole,
                                       GUC_ACTION_SET, true, ERROR, true);
        if (result <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INTERNAL_ERROR),
                     errmsg("parameter \"%s\" could not be set", varname)));
        if (varsourcefile[0])
            set_config_sourcefile(varname, varsourcefile, varsourceline);
        error_context_callback.arg = NULL;
    }
 
    error_context_stack = error_context_callback.previous;
}

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

Referenced by ParallelWorkerMain().

RestrictSearchPath()

void RestrictSearchPath ( void  )

extern

Definition at line 2153 of file guc.c.

{
    if (!IsBootstrapProcessingMode())
        set_config_option("search_path", GUC_SAFE_SEARCH_PATH, PGC_USERSET,
                          PGC_S_SESSION, GUC_ACTION_SAVE, true, 0, false);
}

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

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

SelectConfigFiles()

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

extern

Definition at line 1656 of file guc.c.

{
    char       *configdir;
    char       *fname;
    bool        fname_is_malloced;
    struct stat stat_buf;
    struct config_generic *data_directory_rec;
 
    /* configdir is -D option, or $PGDATA if no -D */
    if (userDoption)
        configdir = make_absolute_path(userDoption);
    else
        configdir = make_absolute_path(getenv("PGDATA"));
 
    if (configdir && stat(configdir, &stat_buf) != 0)
    {
        write_stderr("%s: could not access directory \"%s\": %m\n",
                     progname,
                     configdir);
        if (errno == ENOENT)
            write_stderr("Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n");
        goto fail;
    }
 
    /*
     * Find the configuration file: if config_file was specified on the
     * command line, use it, else use configdir/postgresql.conf.  In any case
     * ensure the result is an absolute path, so that it will be interpreted
     * the same way by future backends.
     */
    if (ConfigFileName)
    {
        fname = make_absolute_path(ConfigFileName);
        fname_is_malloced = true;
    }
    else if (configdir)
    {
        fname = guc_malloc(FATAL,
                           strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
        sprintf(fname, "%s/%s", configdir, CONFIG_FILENAME);
        fname_is_malloced = false;
    }
    else
    {
        write_stderr("%s does not know where to find the server configuration file.\n"
                     "You must specify the --config-file or -D invocation "
                     "option or set the PGDATA environment variable.\n",
                     progname);
        goto fail;
    }
 
    /*
     * Set the ConfigFileName GUC variable to its final value, ensuring that
     * it can't be overridden later.
     */
    SetConfigOption("config_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
 
    if (fname_is_malloced)
        free(fname);
    else
        guc_free(fname);
 
    /*
     * Now read the config file for the first time.
     */
    if (stat(ConfigFileName, &stat_buf) != 0)
    {
        write_stderr("%s: could not access the server configuration file \"%s\": %m\n",
                     progname, ConfigFileName);
        goto fail;
    }
 
    /*
     * Read the configuration file for the first time.  This time only the
     * data_directory parameter is picked up to determine the data directory,
     * so that we can read the PG_AUTOCONF_FILENAME file next time.
     */
    ProcessConfigFile(PGC_POSTMASTER);
 
    /*
     * If the data_directory GUC variable has been set, use that as DataDir;
     * otherwise use configdir if set; else punt.
     *
     * Note: SetDataDir will copy and absolute-ize its argument, so we don't
     * have to.
     */
    data_directory_rec =
        find_option("data_directory", false, false, PANIC);
    if (*data_directory_rec->_string.variable)
        SetDataDir(*data_directory_rec->_string.variable);
    else if (configdir)
        SetDataDir(configdir);
    else
    {
        write_stderr("%s does not know where to find the database system data.\n"
                     "This can be specified as \"data_directory\" in \"%s\", "
                     "or by the -D invocation option, or by the "
                     "PGDATA environment variable.\n",
                     progname, ConfigFileName);
        goto fail;
    }
 
    /*
     * Reflect the final DataDir value back into the data_directory GUC var.
     * (If you are wondering why we don't just make them a single variable,
     * it's because the EXEC_BACKEND case needs DataDir to be transmitted to
     * child backends specially.  XXX is that still true?  Given that we now
     * chdir to DataDir, EXEC_BACKEND can read the config file without knowing
     * DataDir in advance.)
     */
    SetConfigOption("data_directory", DataDir, PGC_POSTMASTER, PGC_S_OVERRIDE);
 
    /*
     * Now read the config file a second time, allowing any settings in the
     * PG_AUTOCONF_FILENAME file to take effect.  (This is pretty ugly, but
     * since we have to determine the DataDir before we can find the autoconf
     * file, the alternatives seem worse.)
     */
    ProcessConfigFile(PGC_POSTMASTER);
 
    /*
     * If timezone_abbreviations wasn't set in the configuration file, install
     * the default value.  We do it this way because we can't safely install a
     * "real" value until my_exec_path is set, which may not have happened
     * when InitializeGUCOptions runs, so the bootstrap default value cannot
     * be the real desired default.
     */
    pg_timezone_abbrev_initialize();
 
    /*
     * Figure out where pg_hba.conf is, and make sure the path is absolute.
     */
    if (HbaFileName)
    {
        fname = make_absolute_path(HbaFileName);
        fname_is_malloced = true;
    }
    else if (configdir)
    {
        fname = guc_malloc(FATAL,
                           strlen(configdir) + strlen(HBA_FILENAME) + 2);
        sprintf(fname, "%s/%s", configdir, HBA_FILENAME);
        fname_is_malloced = false;
    }
    else
    {
        write_stderr("%s does not know where to find the \"hba\" configuration file.\n"
                     "This can be specified as \"hba_file\" in \"%s\", "
                     "or by the -D invocation option, or by the "
                     "PGDATA environment variable.\n",
                     progname, ConfigFileName);
        goto fail;
    }
    SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
 
    if (fname_is_malloced)
        free(fname);
    else
        guc_free(fname);
 
    /*
     * Likewise for pg_ident.conf.
     */
    if (IdentFileName)
    {
        fname = make_absolute_path(IdentFileName);
        fname_is_malloced = true;
    }
    else if (configdir)
    {
        fname = guc_malloc(FATAL,
                           strlen(configdir) + strlen(IDENT_FILENAME) + 2);
        sprintf(fname, "%s/%s", configdir, IDENT_FILENAME);
        fname_is_malloced = false;
    }
    else
    {
        write_stderr("%s does not know where to find the \"ident\" configuration file.\n"
                     "This can be specified as \"ident_file\" in \"%s\", "
                     "or by the -D invocation option, or by the "
                     "PGDATA environment variable.\n",
                     progname, ConfigFileName);
        goto fail;
    }
    SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
 
    if (fname_is_malloced)
        free(fname);
    else
        guc_free(fname);
 
    /*
     * Likewise for pg_hosts.conf.
     */
    if (HostsFileName)
    {
        fname = make_absolute_path(HostsFileName);
        fname_is_malloced = true;
    }
    else if (configdir)
    {
        fname = guc_malloc(FATAL,
                           strlen(configdir) + strlen(HOSTS_FILENAME) + 2);
        sprintf(fname, "%s/%s", configdir, HOSTS_FILENAME);
        fname_is_malloced = false;
    }
    else
    {
        write_stderr("%s does not know where to find the \"hosts\" configuration file.\n"
                     "This can be specified as \"hosts_file\" in \"%s\", "
                     "or by the -D invocation option, or by the "
                     "PGDATA environment variable.\n",
                     progname, ConfigFileName);
        goto fail;
    }
    SetConfigOption("hosts_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
 
    if (fname_is_malloced)
        free(fname);
    else
        guc_free(fname);
 
    free(configdir);
 
    return true;
 
fail:
    free(configdir);
 
    return false;
}

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

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

SerializeGUCState()

void SerializeGUCState ( Size  maxsize, char *  start_address  )

extern

Definition at line 6008 of file guc.c.

{
    char       *curptr;
    Size        actual_size;
    Size        bytes_left;
    dlist_iter  iter;
 
    /* Reserve space for saving the actual size of the guc state */
    Assert(maxsize > sizeof(actual_size));
    curptr = start_address + sizeof(actual_size);
    bytes_left = maxsize - sizeof(actual_size);
 
    /* We need only consider GUCs with source not PGC_S_DEFAULT */
    dlist_foreach(iter, &guc_nondef_list)
    {
        struct config_generic *gconf = dlist_container(struct config_generic,
                                                       nondef_link, iter.cur);
 
        serialize_variable(&curptr, &bytes_left, gconf);
    }
 
    /* Store actual size without assuming alignment of start_address. */
    actual_size = maxsize - bytes_left - sizeof(actual_size);
    memcpy(start_address, &actual_size, sizeof(actual_size));
}

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

Referenced by InitializeParallelDSM().

set_config_option()

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

extern

Definition at line 3248 of file guc.c.

{
    Oid         srole;
 
    /*
     * Non-interactive sources should be treated as having all privileges,
     * except for PGC_S_CLIENT.  Note in particular that this is true for
     * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
     * privilege check was done when the pg_db_role_setting entry was made.
     */
    if (source >= PGC_S_INTERACTIVE || source == PGC_S_CLIENT)
        srole = GetUserId();
    else
        srole = BOOTSTRAP_SUPERUSERID;
 
    return set_config_with_handle(name, NULL, value,
                                  context, source, srole,
                                  action, changeVal, elevel,
                                  is_reload);
}

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

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

set_config_option_ext()

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

extern

Definition at line 3288 of file guc.c.

{
    return set_config_with_handle(name, NULL, value,
                                  context, source, srole,
                                  action, changeVal, elevel,
                                  is_reload);
}

References name, set_config_with_handle(), source, and value.

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

set_config_with_handle()

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

extern

Definition at line 3311 of file guc.c.

{
    struct config_generic *record;
    union config_var_val newval_union;
    void       *newextra = NULL;
    bool        prohibitValueChange = false;
    bool        makeDefault;
 
    if (elevel == 0)
    {
        if (source == PGC_S_DEFAULT || source == PGC_S_FILE)
        {
            /*
             * To avoid cluttering the log, only the postmaster bleats loudly
             * about problems with the config file.
             */
            elevel = IsUnderPostmaster ? DEBUG3 : LOG;
        }
        else if (source == PGC_S_GLOBAL ||
                 source == PGC_S_DATABASE ||
                 source == PGC_S_USER ||
                 source == PGC_S_DATABASE_USER)
            elevel = WARNING;
        else
            elevel = ERROR;
    }
 
    /* if handle is specified, no need to look up option */
    if (!handle)
    {
        record = find_option(name, true, false, elevel);
        if (record == NULL)
            return 0;
    }
    else
        record = handle;
 
    /*
     * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
     * because the current worker will also pop the change.  We're probably
     * dealing with a function having a proconfig entry.  Only the function's
     * body should observe the change, and peer workers do not share in the
     * execution of a function call started by this worker.
     *
     * Also allow normal setting if the GUC is marked GUC_ALLOW_IN_PARALLEL.
     *
     * Other changes might need to affect other workers, so forbid them. Note,
     * that parallel autovacuum leader is an exception because cost-based
     * delays need to be affected to parallel autovacuum workers. These
     * parameters are propagated to its workers during parallel vacuum (see
     * vacuumparallel.c for details). All other changes will affect only the
     * parallel autovacuum leader.
     */
    if (IsInParallelMode() && !AmAutoVacuumWorkerProcess() && changeVal &&
        action != GUC_ACTION_SAVE &&
        (record->flags & GUC_ALLOW_IN_PARALLEL) == 0)
    {
        ereport(elevel,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("parameter \"%s\" cannot be set during a parallel operation",
                        record->name)));
        return 0;
    }
 
    /*
     * Check if the option can be set at this time. See guc.h for the precise
     * rules.
     */
    switch (record->context)
    {
        case PGC_INTERNAL:
            if (context != PGC_INTERNAL)
            {
                ereport(elevel,
                        (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                         errmsg("parameter \"%s\" cannot be changed",
                                record->name)));
                return 0;
            }
            break;
        case PGC_POSTMASTER:
            if (context == PGC_SIGHUP)
            {
                /*
                 * We are re-reading a PGC_POSTMASTER variable from
                 * postgresql.conf.  We can't change the setting, so we should
                 * give a warning if the DBA tries to change it.  However,
                 * because of variant formats, canonicalization by check
                 * hooks, etc, we can't just compare the given string directly
                 * to what's stored.  Set a flag to check below after we have
                 * the final storable value.
                 */
                prohibitValueChange = true;
            }
            else if (context != PGC_POSTMASTER)
            {
                ereport(elevel,
                        (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                         errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                record->name)));
                return 0;
            }
            break;
        case PGC_SIGHUP:
            if (context != PGC_SIGHUP && context != PGC_POSTMASTER)
            {
                ereport(elevel,
                        (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                         errmsg("parameter \"%s\" cannot be changed now",
                                record->name)));
                return 0;
            }
 
            /*
             * Hmm, the idea of the SIGHUP context is "ought to be global, but
             * can be changed after postmaster start". But there's nothing
             * that prevents a crafty administrator from sending SIGHUP
             * signals to individual backends only.
             */
            break;
        case PGC_SU_BACKEND:
            if (context == PGC_BACKEND)
            {
                /*
                 * Check whether the requesting user has been granted
                 * privilege to set this GUC.
                 */
                AclResult   aclresult;
 
                aclresult = pg_parameter_aclcheck(record->name, srole, ACL_SET);
                if (aclresult != ACLCHECK_OK)
                {
                    /* No granted privilege */
                    ereport(elevel,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("permission denied to set parameter \"%s\"",
                                    record->name)));
                    return 0;
                }
            }
            /* fall through to process the same as PGC_BACKEND */
            pg_fallthrough;
        case PGC_BACKEND:
            if (context == PGC_SIGHUP)
            {
                /*
                 * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
                 * the config file, we want to accept the new value in the
                 * postmaster (whence it will propagate to
                 * subsequently-started backends), but ignore it in existing
                 * backends.  This is a tad klugy, but necessary because we
                 * don't re-read the config file during backend start.
                 *
                 * However, if changeVal is false then plow ahead anyway since
                 * we are trying to find out if the value is potentially good,
                 * not actually use it.
                 *
                 * In EXEC_BACKEND builds, this works differently: we load all
                 * non-default settings from the CONFIG_EXEC_PARAMS file
                 * during backend start.  In that case we must accept
                 * PGC_SIGHUP settings, so as to have the same value as if
                 * we'd forked from the postmaster.  This can also happen when
                 * using RestoreGUCState() within a background worker that
                 * needs to have the same settings as the user backend that
                 * started it. is_reload will be true when either situation
                 * applies.
                 */
                if (IsUnderPostmaster && changeVal && !is_reload)
                    return -1;
            }
            else if (context != PGC_POSTMASTER &&
                     context != PGC_BACKEND &&
                     context != PGC_SU_BACKEND &&
                     source != PGC_S_CLIENT)
            {
                ereport(elevel,
                        (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                         errmsg("parameter \"%s\" cannot be set after connection start",
                                record->name)));
                return 0;
            }
            break;
        case PGC_SUSET:
            if (context == PGC_USERSET || context == PGC_BACKEND)
            {
                /*
                 * Check whether the requesting user has been granted
                 * privilege to set this GUC.
                 */
                AclResult   aclresult;
 
                aclresult = pg_parameter_aclcheck(record->name, srole, ACL_SET);
                if (aclresult != ACLCHECK_OK)
                {
                    /* No granted privilege */
                    ereport(elevel,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("permission denied to set parameter \"%s\"",
                                    record->name)));
                    return 0;
                }
            }
            break;
        case PGC_USERSET:
            /* always okay */
            break;
    }
 
    /*
     * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
     * security restriction context.  We can reject this regardless of the GUC
     * context or source, mainly because sources that it might be reasonable
     * to override for won't be seen while inside a function.
     *
     * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
     * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
     * An exception might be made if the reset value is assumed to be "safe".
     *
     * Note: this flag is currently used for "session_authorization" and
     * "role".  We need to prohibit changing these inside a local userid
     * context because when we exit it, GUC won't be notified, leaving things
     * out of sync.  (This could be fixed by forcing a new GUC nesting level,
     * but that would change behavior in possibly-undesirable ways.)  Also, we
     * prohibit changing these in a security-restricted operation because
     * otherwise RESET could be used to regain the session user's privileges.
     */
    if (record->flags & GUC_NOT_WHILE_SEC_REST)
    {
        if (InLocalUserIdChange())
        {
            /*
             * Phrasing of this error message is historical, but it's the most
             * common case.
             */
            ereport(elevel,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("cannot set parameter \"%s\" within security-definer function",
                            record->name)));
            return 0;
        }
        if (InSecurityRestrictedOperation())
        {
            ereport(elevel,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("cannot set parameter \"%s\" within security-restricted operation",
                            record->name)));
            return 0;
        }
    }
 
    /* Disallow resetting and saving GUC_NO_RESET values */
    if (record->flags & GUC_NO_RESET)
    {
        if (value == NULL)
        {
            ereport(elevel,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("parameter \"%s\" cannot be reset", record->name)));
            return 0;
        }
        if (action == GUC_ACTION_SAVE)
        {
            ereport(elevel,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("parameter \"%s\" cannot be set locally in functions",
                            record->name)));
            return 0;
        }
    }
 
    /*
     * Should we set reset/stacked values?  (If so, the behavior is not
     * transactional.)  This is done either when we get a default value from
     * the database's/user's/client's default settings or when we reset a
     * value to its default.
     */
    makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
        ((value != NULL) || source == PGC_S_DEFAULT);
 
    /*
     * Ignore attempted set if overridden by previously processed setting.
     * However, if changeVal is false then plow ahead anyway since we are
     * trying to find out if the value is potentially good, not actually use
     * it. Also keep going if makeDefault is true, since we may want to set
     * the reset/stacked values even if we can't set the variable itself.
     */
    if (record->source > source)
    {
        if (changeVal && !makeDefault)
        {
            elog(DEBUG3, "\"%s\": setting ignored because previous source is higher priority",
                 record->name);
            return -1;
        }
        changeVal = false;
    }
 
    /*
     * Evaluate value and set variable.
     */
    switch (record->vartype)
    {
        case PGC_BOOL:
            {
                struct config_bool *conf = &record->_bool;
 
#define newval (newval_union.boolval)
 
                if (value)
                {
                    if (!parse_and_validate_value(record, value,
                                                  source, elevel,
                                                  &newval_union, &newextra))
                        return 0;
                }
                else if (source == PGC_S_DEFAULT)
                {
                    newval = conf->boot_val;
                    if (!call_bool_check_hook(record, &newval, &newextra,
                                              source, elevel))
                        return 0;
                }
                else
                {
                    newval = conf->reset_val;
                    newextra = record->reset_extra;
                    source = record->reset_source;
                    context = record->reset_scontext;
                    srole = record->reset_srole;
                }
 
                if (prohibitValueChange)
                {
                    /* Release newextra, unless it's reset_extra */
                    if (newextra && !extra_field_used(record, newextra))
                        guc_free(newextra);
 
                    if (*conf->variable != newval)
                    {
                        record->status |= GUC_PENDING_RESTART;
                        ereport(elevel,
                                (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                 errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                        record->name)));
                        return 0;
                    }
                    record->status &= ~GUC_PENDING_RESTART;
                    return -1;
                }
 
                if (changeVal)
                {
                    /* Save old value to support transaction abort */
                    if (!makeDefault)
                        push_old_value(record, action);
 
                    if (conf->assign_hook)
                        conf->assign_hook(newval, newextra);
                    *conf->variable = newval;
                    set_extra_field(record, &record->extra,
                                    newextra);
                    set_guc_source(record, source);
                    record->scontext = context;
                    record->srole = srole;
                }
                if (makeDefault)
                {
                    if (record->reset_source <= source)
                    {
                        conf->reset_val = newval;
                        set_extra_field(record, &record->reset_extra,
                                        newextra);
                        record->reset_source = source;
                        record->reset_scontext = context;
                        record->reset_srole = srole;
                    }
                    for (GucStack *stack = record->stack; stack; stack = stack->prev)
                    {
                        if (stack->source <= source)
                        {
                            stack->prior.val.boolval = newval;
                            set_extra_field(record, &stack->prior.extra,
                                            newextra);
                            stack->source = source;
                            stack->scontext = context;
                            stack->srole = srole;
                        }
                    }
                }
 
                /* Perhaps we didn't install newextra anywhere */
                if (newextra && !extra_field_used(record, newextra))
                    guc_free(newextra);
                break;
 
#undef newval
            }
 
        case PGC_INT:
            {
                struct config_int *conf = &record->_int;
 
#define newval (newval_union.intval)
 
                if (value)
                {
                    if (!parse_and_validate_value(record, value,
                                                  source, elevel,
                                                  &newval_union, &newextra))
                        return 0;
                }
                else if (source == PGC_S_DEFAULT)
                {
                    newval = conf->boot_val;
                    if (!call_int_check_hook(record, &newval, &newextra,
                                             source, elevel))
                        return 0;
                }
                else
                {
                    newval = conf->reset_val;
                    newextra = record->reset_extra;
                    source = record->reset_source;
                    context = record->reset_scontext;
                    srole = record->reset_srole;
                }
 
                if (prohibitValueChange)
                {
                    /* Release newextra, unless it's reset_extra */
                    if (newextra && !extra_field_used(record, newextra))
                        guc_free(newextra);
 
                    if (*conf->variable != newval)
                    {
                        record->status |= GUC_PENDING_RESTART;
                        ereport(elevel,
                                (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                 errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                        record->name)));
                        return 0;
                    }
                    record->status &= ~GUC_PENDING_RESTART;
                    return -1;
                }
 
                if (changeVal)
                {
                    /* Save old value to support transaction abort */
                    if (!makeDefault)
                        push_old_value(record, action);
 
                    if (conf->assign_hook)
                        conf->assign_hook(newval, newextra);
                    *conf->variable = newval;
                    set_extra_field(record, &record->extra,
                                    newextra);
                    set_guc_source(record, source);
                    record->scontext = context;
                    record->srole = srole;
                }
                if (makeDefault)
                {
                    if (record->reset_source <= source)
                    {
                        conf->reset_val = newval;
                        set_extra_field(record, &record->reset_extra,
                                        newextra);
                        record->reset_source = source;
                        record->reset_scontext = context;
                        record->reset_srole = srole;
                    }
                    for (GucStack *stack = record->stack; stack; stack = stack->prev)
                    {
                        if (stack->source <= source)
                        {
                            stack->prior.val.intval = newval;
                            set_extra_field(record, &stack->prior.extra,
                                            newextra);
                            stack->source = source;
                            stack->scontext = context;
                            stack->srole = srole;
                        }
                    }
                }
 
                /* Perhaps we didn't install newextra anywhere */
                if (newextra && !extra_field_used(record, newextra))
                    guc_free(newextra);
                break;
 
#undef newval
            }
 
        case PGC_REAL:
            {
                struct config_real *conf = &record->_real;
 
#define newval (newval_union.realval)
 
                if (value)
                {
                    if (!parse_and_validate_value(record, value,
                                                  source, elevel,
                                                  &newval_union, &newextra))
                        return 0;
                }
                else if (source == PGC_S_DEFAULT)
                {
                    newval = conf->boot_val;
                    if (!call_real_check_hook(record, &newval, &newextra,
                                              source, elevel))
                        return 0;
                }
                else
                {
                    newval = conf->reset_val;
                    newextra = record->reset_extra;
                    source = record->reset_source;
                    context = record->reset_scontext;
                    srole = record->reset_srole;
                }
 
                if (prohibitValueChange)
                {
                    /* Release newextra, unless it's reset_extra */
                    if (newextra && !extra_field_used(record, newextra))
                        guc_free(newextra);
 
                    if (*conf->variable != newval)
                    {
                        record->status |= GUC_PENDING_RESTART;
                        ereport(elevel,
                                (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                 errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                        record->name)));
                        return 0;
                    }
                    record->status &= ~GUC_PENDING_RESTART;
                    return -1;
                }
 
                if (changeVal)
                {
                    /* Save old value to support transaction abort */
                    if (!makeDefault)
                        push_old_value(record, action);
 
                    if (conf->assign_hook)
                        conf->assign_hook(newval, newextra);
                    *conf->variable = newval;
                    set_extra_field(record, &record->extra,
                                    newextra);
                    set_guc_source(record, source);
                    record->scontext = context;
                    record->srole = srole;
                }
                if (makeDefault)
                {
                    if (record->reset_source <= source)
                    {
                        conf->reset_val = newval;
                        set_extra_field(record, &record->reset_extra,
                                        newextra);
                        record->reset_source = source;
                        record->reset_scontext = context;
                        record->reset_srole = srole;
                    }
                    for (GucStack *stack = record->stack; stack; stack = stack->prev)
                    {
                        if (stack->source <= source)
                        {
                            stack->prior.val.realval = newval;
                            set_extra_field(record, &stack->prior.extra,
                                            newextra);
                            stack->source = source;
                            stack->scontext = context;
                            stack->srole = srole;
                        }
                    }
                }
 
                /* Perhaps we didn't install newextra anywhere */
                if (newextra && !extra_field_used(record, newextra))
                    guc_free(newextra);
                break;
 
#undef newval
            }
 
        case PGC_STRING:
            {
                struct config_string *conf = &record->_string;
                GucContext  orig_context = context;
                GucSource   orig_source = source;
                Oid         orig_srole = srole;
 
#define newval (newval_union.stringval)
 
                if (value)
                {
                    if (!parse_and_validate_value(record, value,
                                                  source, elevel,
                                                  &newval_union, &newextra))
                        return 0;
                }
                else if (source == PGC_S_DEFAULT)
                {
                    /* non-NULL boot_val must always get strdup'd */
                    if (conf->boot_val != NULL)
                    {
                        newval = guc_strdup(elevel, conf->boot_val);
                        if (newval == NULL)
                            return 0;
                    }
                    else
                        newval = NULL;
 
                    if (!call_string_check_hook(record, &newval, &newextra,
                                                source, elevel))
                    {
                        guc_free(newval);
                        return 0;
                    }
                }
                else
                {
                    /*
                     * strdup not needed, since reset_val is already under
                     * guc.c's control
                     */
                    newval = conf->reset_val;
                    newextra = record->reset_extra;
                    source = record->reset_source;
                    context = record->reset_scontext;
                    srole = record->reset_srole;
                }
 
                if (prohibitValueChange)
                {
                    bool        newval_different;
 
                    /* newval shouldn't be NULL, so we're a bit sloppy here */
                    newval_different = (*conf->variable == NULL ||
                                        newval == NULL ||
                                        strcmp(*conf->variable, newval) != 0);
 
                    /* Release newval, unless it's reset_val */
                    if (newval && !string_field_used(record, newval))
                        guc_free(newval);
                    /* Release newextra, unless it's reset_extra */
                    if (newextra && !extra_field_used(record, newextra))
                        guc_free(newextra);
 
                    if (newval_different)
                    {
                        record->status |= GUC_PENDING_RESTART;
                        ereport(elevel,
                                (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                 errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                        record->name)));
                        return 0;
                    }
                    record->status &= ~GUC_PENDING_RESTART;
                    return -1;
                }
 
                if (changeVal)
                {
                    /* Save old value to support transaction abort */
                    if (!makeDefault)
                        push_old_value(record, action);
 
                    if (conf->assign_hook)
                        conf->assign_hook(newval, newextra);
                    set_string_field(record, conf->variable, newval);
                    set_extra_field(record, &record->extra,
                                    newextra);
                    set_guc_source(record, source);
                    record->scontext = context;
                    record->srole = srole;
 
                    /*
                     * Ugly hack: during SET session_authorization, forcibly
                     * do SET ROLE NONE with the same context/source/etc, so
                     * that the effects will have identical lifespan.  This is
                     * required by the SQL spec, and it's not possible to do
                     * it within the variable's check hook or assign hook
                     * because our APIs for those don't pass enough info.
                     * However, don't do it if is_reload: in that case we
                     * expect that if "role" isn't supposed to be default, it
                     * has been or will be set by a separate reload action.
                     *
                     * Also, for the call from InitializeSessionUserId with
                     * source == PGC_S_OVERRIDE, use PGC_S_DYNAMIC_DEFAULT for
                     * "role"'s source, so that it's still possible to set
                     * "role" from pg_db_role_setting entries.  (See notes in
                     * InitializeSessionUserId before changing this.)
                     *
                     * A fine point: for RESET session_authorization, we do
                     * "RESET role" not "SET ROLE NONE" (by passing down NULL
                     * rather than "none" for the value).  This would have the
                     * same effects in typical cases, but if the reset value
                     * of "role" is not "none" it seems better to revert to
                     * that.
                     */
                    if (!is_reload &&
                        strcmp(record->name, "session_authorization") == 0)
                        (void) set_config_with_handle("role", NULL,
                                                      value ? "none" : NULL,
                                                      orig_context,
                                                      (orig_source == PGC_S_OVERRIDE)
                                                      ? PGC_S_DYNAMIC_DEFAULT
                                                      : orig_source,
                                                      orig_srole,
                                                      action,
                                                      true,
                                                      elevel,
                                                      false);
                }
 
                if (makeDefault)
                {
                    if (record->reset_source <= source)
                    {
                        set_string_field(record, &conf->reset_val, newval);
                        set_extra_field(record, &record->reset_extra,
                                        newextra);
                        record->reset_source = source;
                        record->reset_scontext = context;
                        record->reset_srole = srole;
                    }
                    for (GucStack *stack = record->stack; stack; stack = stack->prev)
                    {
                        if (stack->source <= source)
                        {
                            set_string_field(record, &stack->prior.val.stringval,
                                             newval);
                            set_extra_field(record, &stack->prior.extra,
                                            newextra);
                            stack->source = source;
                            stack->scontext = context;
                            stack->srole = srole;
                        }
                    }
                }
 
                /* Perhaps we didn't install newval anywhere */
                if (newval && !string_field_used(record, newval))
                    guc_free(newval);
                /* Perhaps we didn't install newextra anywhere */
                if (newextra && !extra_field_used(record, newextra))
                    guc_free(newextra);
                break;
 
#undef newval
            }
 
        case PGC_ENUM:
            {
                struct config_enum *conf = &record->_enum;
 
#define newval (newval_union.enumval)
 
                if (value)
                {
                    if (!parse_and_validate_value(record, value,
                                                  source, elevel,
                                                  &newval_union, &newextra))
                        return 0;
                }
                else if (source == PGC_S_DEFAULT)
                {
                    newval = conf->boot_val;
                    if (!call_enum_check_hook(record, &newval, &newextra,
                                              source, elevel))
                        return 0;
                }
                else
                {
                    newval = conf->reset_val;
                    newextra = record->reset_extra;
                    source = record->reset_source;
                    context = record->reset_scontext;
                    srole = record->reset_srole;
                }
 
                if (prohibitValueChange)
                {
                    /* Release newextra, unless it's reset_extra */
                    if (newextra && !extra_field_used(record, newextra))
                        guc_free(newextra);
 
                    if (*conf->variable != newval)
                    {
                        record->status |= GUC_PENDING_RESTART;
                        ereport(elevel,
                                (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                 errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                        record->name)));
                        return 0;
                    }
                    record->status &= ~GUC_PENDING_RESTART;
                    return -1;
                }
 
                if (changeVal)
                {
                    /* Save old value to support transaction abort */
                    if (!makeDefault)
                        push_old_value(record, action);
 
                    if (conf->assign_hook)
                        conf->assign_hook(newval, newextra);
                    *conf->variable = newval;
                    set_extra_field(record, &record->extra,
                                    newextra);
                    set_guc_source(record, source);
                    record->scontext = context;
                    record->srole = srole;
                }
                if (makeDefault)
                {
                    if (record->reset_source <= source)
                    {
                        conf->reset_val = newval;
                        set_extra_field(record, &record->reset_extra,
                                        newextra);
                        record->reset_source = source;
                        record->reset_scontext = context;
                        record->reset_srole = srole;
                    }
                    for (GucStack *stack = record->stack; stack; stack = stack->prev)
                    {
                        if (stack->source <= source)
                        {
                            stack->prior.val.enumval = newval;
                            set_extra_field(record, &stack->prior.extra,
                                            newextra);
                            stack->source = source;
                            stack->scontext = context;
                            stack->srole = srole;
                        }
                    }
                }
 
                /* Perhaps we didn't install newextra anywhere */
                if (newextra && !extra_field_used(record, newextra))
                    guc_free(newextra);
                break;
 
#undef newval
            }
    }
 
    if (changeVal && (record->flags & GUC_REPORT) &&
        !(record->status & GUC_NEEDS_REPORT))
    {
        record->status |= GUC_NEEDS_REPORT;
        slist_push_head(&guc_report_list, &record->report_link);
    }
 
    return changeVal ? 1 : -1;
}

References config_generic::_bool, config_generic::_enum, config_generic::_int, config_generic::_real, config_generic::_string, ACL_SET, ACLCHECK_OK, AmAutoVacuumWorkerProcess, config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), config_generic::context, DEBUG3, elog, ereport, errcode(), errmsg, ERROR, config_generic::extra, extra_field_used(), find_option(), config_generic::flags, GUC_ACTION_SAVE, GUC_ALLOW_IN_PARALLEL, guc_free(), GUC_NEEDS_REPORT, GUC_NO_RESET, GUC_NOT_WHILE_SEC_REST, GUC_PENDING_RESTART, GUC_REPORT, guc_report_list, guc_strdup(), InLocalUserIdChange(), InSecurityRestrictedOperation(), IsInParallelMode(), IsUnderPostmaster, LOG, name, config_generic::name, newval, parse_and_validate_value(), pg_fallthrough, pg_parameter_aclcheck(), PGC_BACKEND, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_INTERNAL, PGC_POSTMASTER, PGC_REAL, PGC_S_CLIENT, PGC_S_DATABASE, PGC_S_DATABASE_USER, PGC_S_DEFAULT, PGC_S_DYNAMIC_DEFAULT, PGC_S_FILE, PGC_S_GLOBAL, PGC_S_OVERRIDE, PGC_S_USER, PGC_SIGHUP, PGC_STRING, PGC_SU_BACKEND, PGC_SUSET, PGC_USERSET, push_old_value(), config_generic::report_link, config_generic::reset_extra, config_generic::reset_scontext, config_generic::reset_source, config_generic::reset_srole, config_bool::reset_val, config_int::reset_val, config_real::reset_val, config_string::reset_val, config_enum::reset_val, config_generic::scontext, set_config_with_handle(), set_extra_field(), set_guc_source(), set_string_field(), slist_push_head(), source, config_generic::source, config_generic::srole, config_generic::stack, config_generic::status, string_field_used(), value, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, config_generic::vartype, and WARNING.

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

SetConfigOption()

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

extern

Definition at line 4234 of file guc.c.

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

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

Referenced by AioShmemRequest(), AutoVacLauncherMain(), AutoVacWorkerMain(), BeginReportingGUCOptions(), BootstrapModeMain(), CheckMyDatabase(), CLOGShmemRequest(), CommitTsShmemRequest(), CreateAnonymousSegment(), InitializeGUCOptions(), InitializeGUCOptionsFromEnvironment(), InitializeLogRepWorker(), InitializeSessionUserId(), InitializeShmemGUCs(), maybe_reread_subscription(), pg_timezone_abbrev_initialize(), PGSharedMemoryCreate(), PostmasterMain(), process_postgres_switches(), process_startup_options(), ProcessConfigFileInternal(), ReadControlFile(), ReplSlotSyncWorkerMain(), ReportChangedGUCOptions(), SelectConfigFiles(), set_debug_options(), set_limit(), set_plan_disabling_options(), set_wal_receiver_timeout(), SetOuterUserId(), SUBTRANSShmemRequest(), and XLOGShmemRequest().

SetPGVariable()

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

extern

Definition at line 343 of file guc_funcs.c.

{
    char       *argstring = flatten_set_variable_args(name, args);
 
    /* Note SET DEFAULT (argstring == NULL) is equivalent to RESET */
    (void) set_config_option(name,
                             argstring,
                             (superuser() ? PGC_SUSET : PGC_USERSET),
                             PGC_S_SESSION,
                             is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET,
                             true, 0, false);
}

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

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

TransformGUCArray()

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

extern

Definition at line 6279 of file guc.c.

{
    Assert(array != NULL);
    Assert(ARR_ELEMTYPE(array) == TEXTOID);
    Assert(ARR_NDIM(array) == 1);
    Assert(ARR_LBOUND(array)[0] == 1);
 
    *names = NIL;
    *values = NIL;
    for (int i = 1; i <= ARR_DIMS(array)[0]; i++)
    {
        Datum       d;
        bool        isnull;
        char       *s;
        char       *name;
        char       *value;
 
        d = array_ref(array, 1, &i,
                      -1 /* varlenarray */ ,
                      -1 /* TEXT's typlen */ ,
                      false /* TEXT's typbyval */ ,
                      TYPALIGN_INT /* TEXT's typalign */ ,
                      &isnull);
 
        if (isnull)
            continue;
 
        s = TextDatumGetCString(d);
 
        ParseLongOption(s, &name, &value);
        if (!value)
        {
            ereport(WARNING,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("could not parse setting for parameter \"%s\"",
                            name)));
            pfree(name);
            continue;
        }
 
        *names = lappend(*names, name);
        *values = lappend(*values, value);
 
        pfree(s);
    }
}

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

Referenced by fmgr_security_definer(), and ProcessGUCArray().

Variable Documentation

AllowAlterSystem

PGDLLIMPORT bool AllowAlterSystem

extern

Definition at line 534 of file guc_tables.c.

Referenced by AlterSystemSetConfigFile().

application_name

PGDLLIMPORT char* application_name

extern

Definition at line 589 of file guc_tables.c.

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

archive_mode_options

PGDLLIMPORT const struct config_enum_entry archive_mode_options[]

extern

Definition at line 198 of file xlog.c.

                                                        {
    {"always", ARCHIVE_MODE_ALWAYS, false},
    {"on", ARCHIVE_MODE_ON, false},
    {"off", ARCHIVE_MODE_OFF, false},
    {"true", ARCHIVE_MODE_ON, true},
    {"false", ARCHIVE_MODE_OFF, true},
    {"yes", ARCHIVE_MODE_ON, true},
    {"no", ARCHIVE_MODE_OFF, true},
    {"1", ARCHIVE_MODE_ON, true},
    {"0", ARCHIVE_MODE_OFF, true},
    {NULL, 0, false}
};

backtrace_functions

PGDLLIMPORT char* backtrace_functions

extern

Definition at line 576 of file guc_tables.c.

Referenced by errfinish().

check_function_bodies

PGDLLIMPORT bool check_function_bodies

extern

Definition at line 557 of file guc_tables.c.

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

client_min_messages

PGDLLIMPORT int client_min_messages

extern

Definition at line 568 of file guc_tables.c.

Referenced by execute_extension_script(), and should_output_to_client().

cluster_name

PGDLLIMPORT char* cluster_name

extern

Definition at line 582 of file guc_tables.c.

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

ConfigFileName

PGDLLIMPORT char* ConfigFileName

extern

Definition at line 583 of file guc_tables.c.

Referenced by ProcessConfigFileInternal(), and SelectConfigFiles().

current_role_is_superuser

PGDLLIMPORT bool current_role_is_superuser

extern

Definition at line 565 of file guc_tables.c.

Referenced by check_role(), and InitializeParallelDSM().

Debug_pretty_print

PGDLLIMPORT bool Debug_pretty_print

extern

Definition at line 540 of file guc_tables.c.

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

Debug_print_parse

PGDLLIMPORT bool Debug_print_parse

extern

Definition at line 537 of file guc_tables.c.

Referenced by pg_rewrite_query().

Debug_print_plan

PGDLLIMPORT bool Debug_print_plan

extern

Definition at line 536 of file guc_tables.c.

Referenced by pg_plan_query().

Debug_print_raw_parse

PGDLLIMPORT bool Debug_print_raw_parse

extern

Definition at line 538 of file guc_tables.c.

Referenced by pg_parse_query().

Debug_print_rewritten

PGDLLIMPORT bool Debug_print_rewritten

extern

Definition at line 539 of file guc_tables.c.

Referenced by pg_rewrite_query().

dynamic_shared_memory_options

PGDLLIMPORT const struct config_enum_entry dynamic_shared_memory_options[]

extern

Definition at line 96 of file dsm_impl.c.

                                                                 {
#ifdef USE_DSM_POSIX
    {"posix", DSM_IMPL_POSIX, false},
#endif
#ifdef USE_DSM_SYSV
    {"sysv", DSM_IMPL_SYSV, false},
#endif
#ifdef USE_DSM_WINDOWS
    {"windows", DSM_IMPL_WINDOWS, false},
#endif
#ifdef USE_DSM_MMAP
    {"mmap", DSM_IMPL_MMAP, false},
#endif
    {NULL, 0, false}
};

event_source

PGDLLIMPORT char* event_source

extern

Definition at line 554 of file guc_tables.c.

external_pid_file

PGDLLIMPORT char* external_pid_file

extern

Definition at line 587 of file guc_tables.c.

Referenced by PostmasterMain(), and unlink_external_pid_file().

GUC_check_errdetail_string

PGDLLIMPORT char* GUC_check_errdetail_string

extern

Definition at line 84 of file guc.c.

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

GUC_check_errhint_string

PGDLLIMPORT char* GUC_check_errhint_string

extern

Definition at line 85 of file guc.c.

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

GUC_check_errmsg_string

PGDLLIMPORT char* GUC_check_errmsg_string

extern

Definition at line 83 of file guc.c.

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

HbaFileName

PGDLLIMPORT char* HbaFileName

extern

Definition at line 584 of file guc_tables.c.

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

HostsFileName

PGDLLIMPORT char* HostsFileName

extern

Definition at line 586 of file guc_tables.c.

Referenced by load_hosts(), and SelectConfigFiles().

IdentFileName

PGDLLIMPORT char* IdentFileName

extern

Definition at line 585 of file guc_tables.c.

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

in_hot_standby_guc

PGDLLIMPORT bool in_hot_standby_guc

extern

Definition at line 676 of file guc_tables.c.

Referenced by ReportChangedGUCOptions().

io_method_options

PGDLLIMPORT const struct config_enum_entry io_method_options[]

extern

Definition at line 64 of file aio.c.

                                                     {
    {"sync", IOMETHOD_SYNC, false},
    {"worker", IOMETHOD_WORKER, false},
#ifdef IOMETHOD_IO_URING_ENABLED
    {"io_uring", IOMETHOD_IO_URING, false},
#endif
    {NULL, 0, false}
};

log_btree_build_stats

PGDLLIMPORT bool log_btree_build_stats

extern

Definition at line 553 of file guc_tables.c.

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

log_duration

PGDLLIMPORT bool log_duration

extern

Definition at line 535 of file guc_tables.c.

Referenced by check_log_duration().

log_executor_stats

PGDLLIMPORT bool log_executor_stats

extern

Definition at line 550 of file guc_tables.c.

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

log_min_duration_sample

PGDLLIMPORT int log_min_duration_sample

extern

Definition at line 569 of file guc_tables.c.

Referenced by check_log_duration().

log_min_duration_statement

PGDLLIMPORT int log_min_duration_statement

extern

Definition at line 570 of file guc_tables.c.

Referenced by check_log_duration().

log_min_error_statement

PGDLLIMPORT int log_min_error_statement

extern

Definition at line 567 of file guc_tables.c.

Referenced by check_log_of_query().

log_min_messages

PGDLLIMPORT int log_min_messages[]

extern

Definition at line 681 of file guc_tables.c.

                                 {
#define PG_PROCTYPE(bktype, bkcategory, description, main_func, shmem_attach) \
    [bktype] = WARNING,
#include "postmaster/proctypelist.h"
#undef PG_PROCTYPE
};

Referenced by assign_log_min_messages(), execute_extension_script(), and should_output_to_server().

log_parameter_max_length

PGDLLIMPORT int log_parameter_max_length

extern

Definition at line 571 of file guc_tables.c.

Referenced by errdetail_params().

log_parameter_max_length_on_error

PGDLLIMPORT int log_parameter_max_length_on_error

extern

Definition at line 572 of file guc_tables.c.

Referenced by bind_param_error_callback(), and exec_bind_message().

log_parser_stats

PGDLLIMPORT bool log_parser_stats

extern

Definition at line 548 of file guc_tables.c.

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

log_planner_stats

PGDLLIMPORT bool log_planner_stats

extern

Definition at line 549 of file guc_tables.c.

Referenced by check_log_stats(), and pg_plan_query().

log_statement_sample_rate

PGDLLIMPORT double log_statement_sample_rate

extern

Definition at line 574 of file guc_tables.c.

Referenced by check_log_duration().

log_statement_stats

PGDLLIMPORT bool log_statement_stats

extern

Definition at line 551 of file guc_tables.c.

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

log_temp_files

PGDLLIMPORT int log_temp_files

extern

Definition at line 573 of file guc_tables.c.

Referenced by ReportTemporaryFileUsage().

log_xact_sample_rate

PGDLLIMPORT double log_xact_sample_rate

extern

Definition at line 575 of file guc_tables.c.

Referenced by StartTransaction().

num_temp_buffers

PGDLLIMPORT int num_temp_buffers

extern

Definition at line 580 of file guc_tables.c.

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

recovery_target_action_options

PGDLLIMPORT const struct config_enum_entry recovery_target_action_options[]

extern

Definition at line 78 of file xlogrecovery.c.

                                                                  {
    {"pause", RECOVERY_TARGET_ACTION_PAUSE, false},
    {"promote", RECOVERY_TARGET_ACTION_PROMOTE, false},
    {"shutdown", RECOVERY_TARGET_ACTION_SHUTDOWN, false},
    {NULL, 0, false}
};

role_string

PGDLLIMPORT char* role_string

extern

Definition at line 673 of file guc_tables.c.

Referenced by show_role().

server_message_level_options

PGDLLIMPORT const struct config_enum_entry server_message_level_options[]

extern

Definition at line 152 of file guc_tables.c.

                                                                {
    {"debug5", DEBUG5, false},
    {"debug4", DEBUG4, false},
    {"debug3", DEBUG3, false},
    {"debug2", DEBUG2, false},
    {"debug1", DEBUG1, false},
    {"debug", DEBUG2, true},
    {"info", INFO, false},
    {"notice", NOTICE, false},
    {"warning", WARNING, false},
    {"error", ERROR, false},
    {"log", LOG, false},
    {"fatal", FATAL, false},
    {"panic", PANIC, false},
    {NULL, 0, false}
};

Referenced by check_log_min_messages().

tcp_keepalives_count

PGDLLIMPORT int tcp_keepalives_count

extern

Definition at line 593 of file guc_tables.c.

Referenced by pq_init().

tcp_keepalives_idle

PGDLLIMPORT int tcp_keepalives_idle

extern

Definition at line 591 of file guc_tables.c.

Referenced by pq_init().

tcp_keepalives_interval

PGDLLIMPORT int tcp_keepalives_interval

extern

Definition at line 592 of file guc_tables.c.

Referenced by pq_init().

tcp_user_timeout

PGDLLIMPORT int tcp_user_timeout

extern

Definition at line 594 of file guc_tables.c.

Referenced by pq_init().

temp_file_limit

PGDLLIMPORT int temp_file_limit

extern

Definition at line 578 of file guc_tables.c.

Referenced by FileWriteV().

trace_sort

PGDLLIMPORT bool trace_sort

extern

Definition at line 123 of file tuplesort.c.

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

wal_level_options

PGDLLIMPORT const struct config_enum_entry wal_level_options[]

extern

Definition at line 28 of file xlogdesc.c.

                                                     {
    {"minimal", WAL_LEVEL_MINIMAL, false},
    {"replica", WAL_LEVEL_REPLICA, false},
    {"archive", WAL_LEVEL_REPLICA, true},   /* deprecated */
    {"hot_standby", WAL_LEVEL_REPLICA, true},   /* deprecated */
    {"logical", WAL_LEVEL_LOGICAL, false},
    {NULL, 0, false}
};

Referenced by get_wal_level_string().

wal_sync_method_options

PGDLLIMPORT const struct config_enum_entry wal_sync_method_options[]

extern

Definition at line 178 of file xlog.c.

                                                           {
    {"fsync", WAL_SYNC_METHOD_FSYNC, false},
#ifdef HAVE_FSYNC_WRITETHROUGH
    {"fsync_writethrough", WAL_SYNC_METHOD_FSYNC_WRITETHROUGH, false},
#endif
    {"fdatasync", WAL_SYNC_METHOD_FDATASYNC, false},
#ifdef O_SYNC
    {"open_sync", WAL_SYNC_METHOD_OPEN, false},
#endif
#ifdef O_DSYNC
    {"open_datasync", WAL_SYNC_METHOD_OPEN_DSYNC, false},
#endif
    {NULL, 0, false}
};