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   0x0001 /* input can be list format */
#define	GUC_LIST_QUOTE   0x0002 /* double-quote list elements */
#define	GUC_NO_SHOW_ALL   0x0004 /* exclude from SHOW ALL */
#define	GUC_NO_RESET_ALL   0x0008 /* exclude from RESET ALL */
#define	GUC_REPORT   0x0010 /* auto-report changes to client */
#define	GUC_NOT_IN_SAMPLE   0x0020 /* not in postgresql.conf.sample */
#define	GUC_DISALLOW_IN_FILE   0x0040 /* can't set in postgresql.conf */
#define	GUC_CUSTOM_PLACEHOLDER   0x0080 /* placeholder for custom variable */
#define	GUC_SUPERUSER_ONLY   0x0100 /* show only to superusers */
#define	GUC_IS_NAME   0x0200 /* limit string to NAMEDATALEN-1 */
#define	GUC_NOT_WHILE_SEC_REST   0x0400 /* can't set if security restricted */
#define	GUC_DISALLOW_IN_AUTO_FILE
#define	GUC_UNIT_KB   0x1000 /* value is in kilobytes */
#define	GUC_UNIT_BLOCKS   0x2000 /* value is in blocks */
#define	GUC_UNIT_XBLOCKS   0x3000 /* value is in xlog blocks */
#define	GUC_UNIT_MB   0x4000 /* value is in megabytes */
#define	GUC_UNIT_MEMORY   0xF000 /* mask for size-related units */
#define	GUC_UNIT_MS   0x10000 /* value is in milliseconds */
#define	GUC_UNIT_S   0x20000 /* value is in seconds */
#define	GUC_UNIT_MIN   0x30000 /* value is in minutes */
#define	GUC_UNIT_TIME   0xF0000 /* mask for time-related units */
#define	GUC_UNIT   (GUC_UNIT_MEMORY | GUC_UNIT_TIME)
#define	GUC_check_errmsg
#define	GUC_check_errdetail
#define	GUC_check_errhint

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

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

Functions
bool	ParseConfigFile (const char *config_file, bool strict, const char *calling_file, int calling_lineno, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
bool	ParseConfigFp (FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
bool	ParseConfigDirectory (const char *includedir, const char *calling_file, int calling_lineno, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
void	FreeConfigVariables (ConfigVariable *list)
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)
void	DefineCustomIntVariable (const char *name, const char *short_desc, const char *long_desc, int *valueAddr, int bootValue, int minValue, int maxValue, GucContext context, int flags, GucIntCheckHook check_hook, GucIntAssignHook assign_hook, GucShowHook show_hook)
void	DefineCustomRealVariable (const char *name, const char *short_desc, const char *long_desc, double *valueAddr, double bootValue, double minValue, double maxValue, GucContext context, int flags, GucRealCheckHook check_hook, GucRealAssignHook assign_hook, GucShowHook show_hook)
void	DefineCustomStringVariable (const char *name, const char *short_desc, const char *long_desc, char **valueAddr, const char *bootValue, GucContext context, int flags, GucStringCheckHook check_hook, GucStringAssignHook assign_hook, GucShowHook show_hook)
void	DefineCustomEnumVariable (const char *name, const char *short_desc, const char *long_desc, int *valueAddr, int bootValue, const struct config_enum_entry *options, GucContext context, int flags, GucEnumCheckHook check_hook, GucEnumAssignHook assign_hook, GucShowHook show_hook)
void	EmitWarningsOnPlaceholders (const char *className)
const char *	GetConfigOption (const char *name, bool missing_ok, bool restrict_superuser)
const char *	GetConfigOptionResetString (const char *name)
void	ProcessConfigFile (GucContext context)
void	InitializeGUCOptions (void)
bool	SelectConfigFiles (const char *userDoption, const char *progname)
void	ResetAllOptions (void)
void	AtStart_GUC (void)
int	NewGUCNestLevel (void)
void	AtEOXact_GUC (bool isCommit, int nestLevel)
void	BeginReportingGUCOptions (void)
void	ParseLongOption (const char *string, char **name, char **value)
bool	parse_int (const char *value, int *result, int flags, const char **hintmsg)
bool	parse_real (const char *value, double *result)
int	set_config_option (const char *name, const char *value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)
void	AlterSystemSetConfigFile (AlterSystemStmt *setstmt)
char *	GetConfigOptionByName (const char *name, const char **varname, bool missing_ok)
void	GetConfigOptionByNum (int varnum, const char **values, bool *noshow)
int	GetNumConfigOptions (void)
void	SetPGVariable (const char *name, List *args, bool is_local)
void	GetPGVariable (const char *name, DestReceiver *dest)
TupleDesc	GetPGVariableResultDesc (const char *name)
void	ExecSetVariableStmt (VariableSetStmt *stmt, bool isTopLevel)
char *	ExtractSetVariableArgs (VariableSetStmt *stmt)
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)
Size	EstimateGUCStateSpace (void)
void	SerializeGUCState (Size maxsize, char *start_address)
void	RestoreGUCState (void *gucstate)
void	GUC_check_errcode (int sqlerrcode)
bool	check_default_tablespace (char **newval, void **extra, GucSource source)
bool	check_temp_tablespaces (char **newval, void **extra, GucSource source)
void	assign_temp_tablespaces (const char *newval, void *extra)
bool	check_search_path (char **newval, void **extra, GucSource source)
void	assign_search_path (const char *newval, void *extra)
bool	check_wal_buffers (int *newval, void **extra, GucSource source)
void	assign_xlog_sync_method (int new_sync_method, void *extra)

Variables
bool	log_duration
bool	Debug_print_plan
bool	Debug_print_parse
bool	Debug_print_rewritten
bool	Debug_pretty_print
bool	log_parser_stats
bool	log_planner_stats
bool	log_executor_stats
bool	log_statement_stats
bool	log_btree_build_stats
PGDLLIMPORT bool	check_function_bodies
bool	default_with_oids
int	log_min_error_statement
int	log_min_messages
int	client_min_messages
int	log_min_duration_statement
int	log_temp_files
int	temp_file_limit
int	num_temp_buffers
char *	cluster_name
char *	ConfigFileName
char *	HbaFileName
char *	IdentFileName
char *	external_pid_file
char *	application_name
int	tcp_keepalives_idle
int	tcp_keepalives_interval
int	tcp_keepalives_count
PGDLLIMPORT char *	GUC_check_errmsg_string
PGDLLIMPORT char *	GUC_check_errdetail_string
PGDLLIMPORT char *	GUC_check_errhint_string

Macro Definition Documentation

#define GUC_check_errdetail

Value:

pre_format_elog_string(errno, TEXTDOMAIN), \
	GUC_check_errdetail_string = format_elog_string

Definition at line 407 of file guc.h.

Referenced by addToArray(), check_client_encoding(), check_datestyle(), check_default_tablespace(), check_log_destination(), check_log_stats(), check_log_timezone(), check_max_stack_depth(), check_search_path(), check_stage_log_stats(), check_synchronous_standby_names(), check_temp_buffers(), check_temp_tablespaces(), check_timezone(), check_wal_consistency_checking(), and plpgsql_extra_checks_check_hook().

#define GUC_check_errhint

Value:

pre_format_elog_string(errno, TEXTDOMAIN), \
	GUC_check_errhint_string = format_elog_string

Definition at line 411 of file guc.h.

Referenced by check_max_stack_depth(), check_XactIsoLevel(), and ParseTzFile().

#define GUC_check_errmsg

Value:

pre_format_elog_string(errno, TEXTDOMAIN), \
	GUC_check_errmsg_string = format_elog_string

Definition at line 403 of file guc.h.

Referenced by addToArray(), check_bonjour(), check_log_timezone(), check_role(), check_session_authorization(), check_ssl(), check_synchronous_standby_names(), check_timezone(), check_transaction_deferrable(), check_transaction_read_only(), check_XactIsoLevel(), load_tzoffsets(), ParseTzFile(), splitTzLine(), and validateTzEntry().

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

Definition at line 211 of file guc.h.

Referenced by add_placeholder_variable(), define_custom_variable(), EmitWarningsOnPlaceholders(), and validate_option_array_item().

#define GUC_DISALLOW_IN_AUTO_FILE

Value:

0x0800  /* can't set in
                                             * PG_AUTOCONF_FILENAME */

Definition at line 215 of file guc.h.

Referenced by AlterSystemSetConfigFile().

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

Definition at line 210 of file guc.h.

Referenced by AlterSystemSetConfigFile(), and displayStruct().

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

Definition at line 213 of file guc.h.

Referenced by parse_and_validate_value().

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

Definition at line 204 of file guc.h.

Referenced by _PG_init(), and flatten_set_variable_args().

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

Definition at line 205 of file guc.h.

Referenced by flatten_set_variable_args().

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

Definition at line 207 of file guc.h.

Referenced by ResetAllOptions().

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

Definition at line 206 of file guc.h.

Referenced by add_placeholder_variable(), displayStruct(), GetConfigOptionByNum(), and ShowAllGUCConfig().

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

Definition at line 209 of file guc.h.

Referenced by _PG_init(), add_placeholder_variable(), and displayStruct().

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

Definition at line 214 of file guc.h.

Referenced by set_config_option().

#define GUC_QUALIFIER_SEPARATOR   '.'

Definition at line 199 of file guc.h.

Referenced by EmitWarningsOnPlaceholders(), and find_option().

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

Definition at line 208 of file guc.h.

Referenced by AtEOXact_GUC(), BeginReportingGUCOptions(), ReportGUCOption(), ResetAllOptions(), and set_config_option().

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

Definition at line 212 of file guc.h.

Referenced by GetConfigOption(), GetConfigOptionByName(), GetConfigOptionByNum(), GetConfigOptionResetString(), and ShowAllGUCConfig().

#define GUC_UNIT   (GUC_UNIT_MEMORY | GUC_UNIT_TIME)

Definition at line 229 of file guc.h.

Referenced by _ShowOption(), and parse_int().

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

Definition at line 219 of file guc.h.

Referenced by GetConfigOptionByNum().

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

Definition at line 218 of file guc.h.

Referenced by GetConfigOptionByNum().

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

Definition at line 221 of file guc.h.

Referenced by GetConfigOptionByNum().

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

Definition at line 222 of file guc.h.

Referenced by convert_from_base_unit(), convert_to_base_unit(), GetConfigOptionByNum(), and parse_int().

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

Definition at line 226 of file guc.h.

Referenced by GetConfigOptionByNum().

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

Definition at line 224 of file guc.h.

Referenced by _PG_init(), GetConfigOptionByNum(), and readRecoveryCommandFile().

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

Definition at line 225 of file guc.h.

Referenced by _PG_init(), and GetConfigOptionByNum().

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

Definition at line 227 of file guc.h.

Referenced by GetConfigOptionByNum().

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

Definition at line 220 of file guc.h.

Referenced by GetConfigOptionByNum().

#define MAX_KILOBYTES   (INT_MAX / 1024)

Definition at line 26 of file guc.h.

#define PG_AUTOCONF_FILENAME   "postgresql.auto.conf"

Definition at line 34 of file guc.h.

Referenced by AlterSystemSetConfigFile().

Typedef Documentation

typedef struct ConfigVariable ConfigVariable

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

Definition at line 180 of file guc.h.

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

Definition at line 174 of file guc.h.

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

Definition at line 184 of file guc.h.

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

Definition at line 178 of file guc.h.

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

Definition at line 181 of file guc.h.

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

Definition at line 175 of file guc.h.

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

Definition at line 182 of file guc.h.

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

Definition at line 176 of file guc.h.

typedef const char*(* GucShowHook)(void)

Definition at line 186 of file guc.h.

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

Definition at line 183 of file guc.h.

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

Definition at line 177 of file guc.h.

Enumeration Type Documentation

enum GucAction

Enumerator
GUC_ACTION_SET
GUC_ACTION_LOCAL
GUC_ACTION_SAVE

Definition at line 191 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;

enum GucContext

Enumerator
PGC_INTERNAL
PGC_POSTMASTER
PGC_SIGHUP
PGC_SU_BACKEND
PGC_BACKEND
PGC_SUSET
PGC_USERSET

Definition at line 68 of file guc.h.

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

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 105 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

void AlterSystemSetConfigFile

(

AlterSystemStmt *

setstmt

)

Definition at line 7081 of file guc.c.

References AllocateFile(), BasicOpenFile(), close, config_generic::context, durable_rename(), elog, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, ExtractSetVariableArgs(), find_option(), config_generic::flags, free, FreeConfigVariables(), FreeFile(), GUC_DISALLOW_IN_AUTO_FILE, GUC_DISALLOW_IN_FILE, infile(), VariableSetStmt::kind, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAXPGPATH, name, VariableSetStmt::name, NULL, parse_and_validate_value(), ParseConfigFp(), PG_AUTOCONF_FILENAME, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PGC_INTERNAL, PGC_S_FILE, PGC_STRING, replace_auto_config_value(), AlterSystemStmt::setstmt, snprintf(), config_var_val::stringval, superuser(), unlink(), value, VAR_RESET, VAR_RESET_ALL, VAR_SET_DEFAULT, VAR_SET_VALUE, config_generic::vartype, and write_auto_conf_file().

Referenced by standard_ProcessUtility().

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            FreeFile(infile);
        }

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

    /*
     * To ensure crash safety, first write the new file data to a temp file,
     * then atomically rename it into place.
     *
     * If there is a temp file left over due to a previous crash, it's okay to
     * truncate and reuse it.
     */
    Tmpfd = BasicOpenFile(AutoConfTmpFileName,
                          O_CREAT | O_RDWR | O_TRUNC,
                          S_IRUSR | S_IWUSR);
    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);
}

void assign_search_path	(	const char *	newval,
		void *	extra
	)

Definition at line 4094 of file namespace.c.

References baseSearchPathValid.

{
    /*
     * We mark the path as needing recomputation, but don't do anything until
     * it's needed.  This avoids trying to do database access during GUC
     * initialization, or outside a transaction.
     */
    baseSearchPathValid = false;
}

void assign_temp_tablespaces	(	const char *	newval,
		void *	extra
	)

Definition at line 1262 of file tablespace.c.

References NULL, temp_tablespaces_extra::numSpcs, SetTempTablespaces(), and temp_tablespaces_extra::tblSpcs.

{
    temp_tablespaces_extra *myextra = (temp_tablespaces_extra *) extra;

    /*
     * If check_temp_tablespaces was executed inside a transaction, then pass
     * the list it made to fd.c.  Otherwise, clear fd.c's list; we must be
     * still outside a transaction, or else restoring during transaction exit,
     * and in either case we can just let the next PrepareTempTablespaces call
     * make things sane.
     */
    if (myextra)
        SetTempTablespaces(myextra->tblSpcs, myextra->numSpcs);
    else
        SetTempTablespaces(NULL, 0);
}

void assign_xlog_sync_method	(	int	new_sync_method,
		void *	extra
	)

Definition at line 10060 of file xlog.c.

References ereport, errcode_for_file_access(), errmsg(), get_sync_bit(), openLogFile, openLogSegNo, PANIC, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), sync_method, ThisTimeLineID, WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN, XLogFileClose(), and XLogFileNameP().

{
    if (sync_method != new_sync_method)
    {
        /*
         * To ensure that no blocks escape unsynced, force an fsync on the
         * currently open log segment (if any).  Also, if the open flag is
         * changing, close the log file so it will be reopened (with new flag
         * bit) at next use.
         */
        if (openLogFile >= 0)
        {
            pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN);
            if (pg_fsync(openLogFile) != 0)
                ereport(PANIC,
                        (errcode_for_file_access(),
                         errmsg("could not fsync log segment %s: %m",
                                XLogFileNameP(ThisTimeLineID, openLogSegNo))));
            pgstat_report_wait_end();
            if (get_sync_bit(sync_method) != get_sync_bit(new_sync_method))
                XLogFileClose();
        }
    }
}

void AtEOXact_GUC	(	bool	isCommit,
		int	nestLevel
	)

Definition at line 5090 of file guc.c.

References Assert, config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_var_val::boolval, discard_stack_value(), config_var_val::enumval, config_var_value::extra, config_generic::extra, config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_LOCAL, GUC_REPORT, GUC_SAVE, GUC_SET, GUC_SET_LOCAL, i, config_var_val::intval, guc_stack::masked, guc_stack::masked_scontext, guc_stack::nest_level, newval, NULL, num_guc_variables, pfree(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_SESSION, PGC_STRING, guc_stack::prev, guc_stack::prior, config_var_val::realval, ReportGUCOption(), guc_stack::scontext, config_generic::scontext, set_extra_field(), set_string_field(), guc_stack::source, config_generic::source, config_generic::stack, guc_stack::state, config_var_val::stringval, config_var_value::val, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by AbortSubTransaction(), AbortTransaction(), CommitSubTransaction(), CommitTransaction(), do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), execute_extension_script(), fmgr_security_definer(), index_build(), PrepareTransaction(), ProcedureCreate(), reset_transmission_modes(), restoreLocalGucs(), RI_Initial_Check(), vacuum_rel(), and validate_index().

{
    bool        still_dirty;
    int         i;

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

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

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

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

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

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

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

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

            changed = false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void AtStart_GUC

(

void

)

Definition at line 5056 of file guc.c.

References elog, and WARNING.

Referenced by StartTransaction().

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

void BeginReportingGUCOptions

(

void

)

Definition at line 5371 of file guc.c.

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

Referenced by PostgresMain().

{
    int         i;

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

    reporting_enabled = true;

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

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

bool check_default_tablespace	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 1062 of file tablespace.c.

References ereport, errcode(), errmsg(), get_tablespace_oid(), GUC_check_errdetail, IsTransactionState(), NOTICE, OidIsValid, and PGC_S_TEST.

{
    /*
     * If we aren't inside a transaction, we cannot do database access so
     * cannot verify the name.  Must accept the value on faith.
     */
    if (IsTransactionState())
    {
        if (**newval != '\0' &&
            !OidIsValid(get_tablespace_oid(*newval, true)))
        {
            /*
             * When source == PGC_S_TEST, don't throw a hard error for a
             * nonexistent tablespace, only a NOTICE.  See comments in guc.h.
             */
            if (source == PGC_S_TEST)
            {
                ereport(NOTICE,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("tablespace \"%s\" does not exist",
                                *newval)));
            }
            else
            {
                GUC_check_errdetail("Tablespace \"%s\" does not exist.",
                                    *newval);
                return false;
            }
        }
    }

    return true;
}

bool check_search_path	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4060 of file namespace.c.

References GUC_check_errdetail, list_free(), pfree(), pstrdup(), and SplitIdentifierString().

{
    char       *rawname;
    List       *namelist;

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

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

    /*
     * We used to try to check that the named schemas exist, but there are
     * many valid use-cases for having search_path settings that include
     * schemas that don't exist; and often, we are not inside a transaction
     * here and so can't consult the system catalogs anyway.  So now, the only
     * requirement is syntactic validity of the identifier list.
     */

    pfree(rawname);
    list_free(namelist);

    return true;
}

bool check_temp_tablespaces	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 1157 of file tablespace.c.

References ACL_CREATE, ACL_KIND_TABLESPACE, aclcheck_error(), ACLCHECK_OK, ereport, errcode(), errmsg(), get_tablespace_oid(), GetUserId(), GUC_check_errdetail, InvalidOid, IsTransactionState(), lfirst, list_free(), list_length(), malloc, MyDatabaseTableSpace, NOTICE, temp_tablespaces_extra::numSpcs, offsetof, palloc(), pfree(), pg_tablespace_aclcheck(), PGC_S_INTERACTIVE, PGC_S_TEST, pstrdup(), SplitIdentifierString(), and temp_tablespaces_extra::tblSpcs.

{
    char       *rawname;
    List       *namelist;

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

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

    /*
     * If we aren't inside a transaction, we cannot do database access so
     * cannot verify the individual names.  Must accept the list on faith.
     * Fortunately, there's then also no need to pass the data to fd.c.
     */
    if (IsTransactionState())
    {
        temp_tablespaces_extra *myextra;
        Oid        *tblSpcs;
        int         numSpcs;
        ListCell   *l;

        /* temporary workspace until we are done verifying the list */
        tblSpcs = (Oid *) palloc(list_length(namelist) * sizeof(Oid));
        numSpcs = 0;
        foreach(l, namelist)
        {
            char       *curname = (char *) lfirst(l);
            Oid         curoid;
            AclResult   aclresult;

            /* Allow an empty string (signifying database default) */
            if (curname[0] == '\0')
            {
                tblSpcs[numSpcs++] = InvalidOid;
                continue;
            }

            /*
             * In an interactive SET command, we ereport for bad info.  When
             * source == PGC_S_TEST, don't throw a hard error for a
             * nonexistent tablespace, only a NOTICE.  See comments in guc.h.
             */
            curoid = get_tablespace_oid(curname, source <= PGC_S_TEST);
            if (curoid == InvalidOid)
            {
                if (source == PGC_S_TEST)
                    ereport(NOTICE,
                            (errcode(ERRCODE_UNDEFINED_OBJECT),
                             errmsg("tablespace \"%s\" does not exist",
                                    curname)));
                continue;
            }

            /*
             * Allow explicit specification of database's default tablespace
             * in temp_tablespaces without triggering permissions checks.
             */
            if (curoid == MyDatabaseTableSpace)
            {
                tblSpcs[numSpcs++] = InvalidOid;
                continue;
            }

            /* Check permissions, similarly complaining only if interactive */
            aclresult = pg_tablespace_aclcheck(curoid, GetUserId(),
                                               ACL_CREATE);
            if (aclresult != ACLCHECK_OK)
            {
                if (source >= PGC_S_INTERACTIVE)
                    aclcheck_error(aclresult, ACL_KIND_TABLESPACE, curname);
                continue;
            }

            tblSpcs[numSpcs++] = curoid;
        }

        /* Now prepare an "extra" struct for assign_temp_tablespaces */
        myextra = malloc(offsetof(temp_tablespaces_extra, tblSpcs) +
                         numSpcs * sizeof(Oid));
        if (!myextra)
            return false;
        myextra->numSpcs = numSpcs;
        memcpy(myextra->tblSpcs, tblSpcs, numSpcs * sizeof(Oid));
        *extra = (void *) myextra;

        pfree(tblSpcs);
    }

    pfree(rawname);
    list_free(namelist);

    return true;
}

bool check_wal_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4771 of file xlog.c.

References XLOGbuffers, and XLOGChooseNumBuffers().

{
    /*
     * -1 indicates a request for auto-tune.
     */
    if (*newval == -1)
    {
        /*
         * If we haven't yet changed the boot_val default of -1, just let it
         * be.  We'll fix it when XLOGShmemSize is called.
         */
        if (XLOGbuffers == -1)
            return true;

        /* Otherwise, substitute the auto-tune value */
        *newval = XLOGChooseNumBuffers();
    }

    /*
     * We clamp manually-set values to at least 4 blocks.  Prior to PostgreSQL
     * 9.1, a minimum of 4 was enforced by guc.c, but since that is no longer
     * the case, we just silently treat such values as a request for the
     * minimum.  (We could throw an error instead, but that doesn't seem very
     * helpful.)
     */
    if (*newval < 4)
        *newval = 4;

    return true;
}

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

Definition at line 7740 of file guc.c.

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

Referenced by _PG_init().

{
    struct config_bool *var;

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

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

Definition at line 7851 of file guc.c.

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

Referenced by _PG_init().

{
    struct config_enum *var;

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

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

Definition at line 7766 of file guc.c.

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

Referenced by _PG_init().

{
    struct config_int *var;

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

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

Definition at line 7796 of file guc.c.

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

Referenced by _PG_init().

{
    struct config_real *var;

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

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

Definition at line 7826 of file guc.c.

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

Referenced by _PG_init().

{
    struct config_string *var;

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

void EmitWarningsOnPlaceholders

(

const char *

className

)

Definition at line 7879 of file guc.c.

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

Referenced by _PG_init().

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

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

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

Size EstimateGUCStateSpace

(

void

)

Definition at line 9102 of file guc.c.

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

Referenced by InitializeParallelDSM().

{
    Size        size;
    int         i;

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

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

    return size;
}

void ExecSetVariableStmt	(	VariableSetStmt *	stmt,
		bool	isTopLevel
	)

Definition at line 7296 of file guc.c.

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

Referenced by standard_ProcessUtility().

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

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

    switch (stmt->kind)
    {
        case VAR_SET_VALUE:
        case VAR_SET_CURRENT:
            if (stmt->is_local)
                WarnNoTransactionChain(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;

                WarnNoTransactionChain(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")));

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

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

char* ExtractSetVariableArgs

(

VariableSetStmt *

stmt

)

Definition at line 7420 of file guc.c.

References VariableSetStmt::args, flatten_set_variable_args(), GetConfigOptionByName(), VariableSetStmt::kind, VariableSetStmt::name, NULL, VAR_SET_CURRENT, and VAR_SET_VALUE.

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

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

void FreeConfigVariables

(

ConfigVariable *

list

)

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

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

Definition at line 6707 of file guc.c.

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

Referenced by applyRemoteGucs(), and PostmasterMain().

{
    struct config_generic *record;
    static char buffer[256];

    record = find_option(name, false, ERROR);
    if (record == NULL)
    {
        if (missing_ok)
            return NULL;
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("unrecognized configuration parameter \"%s\"",
                        name)));
    }
    if (restrict_superuser &&
        (record->flags & GUC_SUPERUSER_ONLY) &&
        !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_SETTINGS))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser or a member of pg_read_all_settings to examine \"%s\"",
                        name)));

    switch (record->vartype)
    {
        case PGC_BOOL:
            return *((struct config_bool *) record)->variable ? "on" : "off";

        case PGC_INT:
            snprintf(buffer, sizeof(buffer), "%d",
                     *((struct config_int *) record)->variable);
            return buffer;

        case PGC_REAL:
            snprintf(buffer, sizeof(buffer), "%g",
                     *((struct config_real *) record)->variable);
            return buffer;

        case PGC_STRING:
            return *((struct config_string *) record)->variable;

        case PGC_ENUM:
            return config_enum_lookup_by_value((struct config_enum *) record,
                                               *((struct config_enum *) record)->variable);
    }
    return NULL;
}

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

Definition at line 8046 of file guc.c.

References _ShowOption(), DEFAULT_ROLE_READ_ALL_SETTINGS, ereport, errcode(), errmsg(), ERROR, find_option(), config_generic::flags, GetUserId(), GUC_SUPERUSER_ONLY, is_member_of_role(), config_generic::name, and NULL.

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

{
    struct config_generic *record;

    record = find_option(name, false, ERROR);
    if (record == NULL)
    {
        if (missing_ok)
        {
            if (varname)
                *varname = NULL;
            return NULL;
        }

        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("unrecognized configuration parameter \"%s\"", name)));
    }

    if ((record->flags & GUC_SUPERUSER_ONLY) &&
        !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_SETTINGS))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser or a member of pg_read_all_settings to examine \"%s\"",
                        name)));

    if (varname)
        *varname = record->name;

    return _ShowOption(record, true);
}

void GetConfigOptionByNum	(	int	varnum,
		const char **	values,
		bool *	noshow
	)

Definition at line 8083 of file guc.c.

References _ShowOption(), Assert, config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, buffer, config_enum_get_options(), config_enum_lookup_by_value(), config_generic::context, DEFAULT_ROLE_READ_ALL_SETTINGS, elog, ERROR, config_generic::flags, GetUserId(), config_generic::group, GUC_NO_SHOW_ALL, GUC_PENDING_RESTART, GUC_SUPERUSER_ONLY, GUC_UNIT_BLOCKS, GUC_UNIT_KB, GUC_UNIT_MB, GUC_UNIT_MEMORY, GUC_UNIT_MIN, GUC_UNIT_MS, GUC_UNIT_S, GUC_UNIT_TIME, GUC_UNIT_XBLOCKS, is_member_of_role(), config_generic::long_desc, config_int::max, config_real::max, config_int::min, config_real::min, config_generic::name, NULL, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_FILE, PGC_STRING, pstrdup(), config_bool::reset_val, config_int::reset_val, config_real::reset_val, config_string::reset_val, config_enum::reset_val, config_generic::short_desc, snprintf(), config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_generic::status, superuser(), and config_generic::vartype.

Referenced by show_all_settings().

{
    char        buffer[256];
    struct config_generic *conf;

    /* check requested variable number valid */
    Assert((varnum >= 0) && (varnum < num_guc_variables));

    conf = guc_variables[varnum];

    if (noshow)
    {
        if ((conf->flags & GUC_NO_SHOW_ALL) ||
            ((conf->flags & GUC_SUPERUSER_ONLY) &&
             !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_SETTINGS)))
            *noshow = true;
        else
            *noshow = false;
    }

    /* first get the generic attributes */

    /* name */
    values[0] = conf->name;

    /* setting : use _ShowOption in order to avoid duplicating the logic */
    values[1] = _ShowOption(conf, false);

    /* unit */
    if (conf->vartype == PGC_INT)
    {
        switch (conf->flags & (GUC_UNIT_MEMORY | GUC_UNIT_TIME))
        {
            case GUC_UNIT_KB:
                values[2] = "kB";
                break;
            case GUC_UNIT_MB:
                values[2] = "MB";
                break;
            case GUC_UNIT_BLOCKS:
                snprintf(buffer, sizeof(buffer), "%dkB", BLCKSZ / 1024);
                values[2] = pstrdup(buffer);
                break;
            case GUC_UNIT_XBLOCKS:
                snprintf(buffer, sizeof(buffer), "%dkB", XLOG_BLCKSZ / 1024);
                values[2] = pstrdup(buffer);
                break;
            case GUC_UNIT_MS:
                values[2] = "ms";
                break;
            case GUC_UNIT_S:
                values[2] = "s";
                break;
            case GUC_UNIT_MIN:
                values[2] = "min";
                break;
            case 0:
                values[2] = NULL;
                break;
            default:
                elog(ERROR, "unrecognized GUC units value: %d",
                     conf->flags & (GUC_UNIT_MEMORY | GUC_UNIT_TIME));
                values[2] = NULL;
                break;
        }
    }
    else
        values[2] = NULL;

    /* group */
    values[3] = config_group_names[conf->group];

    /* short_desc */
    values[4] = conf->short_desc;

    /* extra_desc */
    values[5] = conf->long_desc;

    /* context */
    values[6] = GucContext_Names[conf->context];

    /* vartype */
    values[7] = config_type_names[conf->vartype];

    /* source */
    values[8] = GucSource_Names[conf->source];

    /* now get the type specific attributes */
    switch (conf->vartype)
    {
        case PGC_BOOL:
            {
                struct config_bool *lconf = (struct config_bool *) conf;

                /* min_val */
                values[9] = NULL;

                /* max_val */
                values[10] = NULL;

                /* enumvals */
                values[11] = NULL;

                /* boot_val */
                values[12] = pstrdup(lconf->boot_val ? "on" : "off");

                /* reset_val */
                values[13] = pstrdup(lconf->reset_val ? "on" : "off");
            }
            break;

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

                /* min_val */
                snprintf(buffer, sizeof(buffer), "%d", lconf->min);
                values[9] = pstrdup(buffer);

                /* max_val */
                snprintf(buffer, sizeof(buffer), "%d", lconf->max);
                values[10] = pstrdup(buffer);

                /* enumvals */
                values[11] = NULL;

                /* boot_val */
                snprintf(buffer, sizeof(buffer), "%d", lconf->boot_val);
                values[12] = pstrdup(buffer);

                /* reset_val */
                snprintf(buffer, sizeof(buffer), "%d", lconf->reset_val);
                values[13] = pstrdup(buffer);
            }
            break;

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

                /* min_val */
                snprintf(buffer, sizeof(buffer), "%g", lconf->min);
                values[9] = pstrdup(buffer);

                /* max_val */
                snprintf(buffer, sizeof(buffer), "%g", lconf->max);
                values[10] = pstrdup(buffer);

                /* enumvals */
                values[11] = NULL;

                /* boot_val */
                snprintf(buffer, sizeof(buffer), "%g", lconf->boot_val);
                values[12] = pstrdup(buffer);

                /* reset_val */
                snprintf(buffer, sizeof(buffer), "%g", lconf->reset_val);
                values[13] = pstrdup(buffer);
            }
            break;

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

                /* min_val */
                values[9] = NULL;

                /* max_val */
                values[10] = NULL;

                /* enumvals */
                values[11] = NULL;

                /* boot_val */
                if (lconf->boot_val == NULL)
                    values[12] = NULL;
                else
                    values[12] = pstrdup(lconf->boot_val);

                /* reset_val */
                if (lconf->reset_val == NULL)
                    values[13] = NULL;
                else
                    values[13] = pstrdup(lconf->reset_val);
            }
            break;

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

                /* min_val */
                values[9] = NULL;

                /* max_val */
                values[10] = NULL;

                /* enumvals */

                /*
                 * NOTE! enumvals with double quotes in them are not
                 * supported!
                 */
                values[11] = config_enum_get_options((struct config_enum *) conf,
                                                     "{\"", "\"}", "\",\"");

                /* boot_val */
                values[12] = pstrdup(config_enum_lookup_by_value(lconf,
                                                                 lconf->boot_val));

                /* reset_val */
                values[13] = pstrdup(config_enum_lookup_by_value(lconf,
                                                                 lconf->reset_val));
            }
            break;

        default:
            {
                /*
                 * should never get here, but in case we do, set 'em to NULL
                 */

                /* min_val */
                values[9] = NULL;

                /* max_val */
                values[10] = NULL;

                /* enumvals */
                values[11] = NULL;

                /* boot_val */
                values[12] = NULL;

                /* reset_val */
                values[13] = NULL;
            }
            break;
    }

    /*
     * If the setting came from a config file, set the source location. For
     * security reasons, we don't show source file/line number for
     * non-superusers.
     */
    if (conf->source == PGC_S_FILE && superuser())
    {
        values[14] = conf->sourcefile;
        snprintf(buffer, sizeof(buffer), "%d", conf->sourceline);
        values[15] = pstrdup(buffer);
    }
    else
    {
        values[14] = NULL;
        values[15] = NULL;
    }

    values[16] = (conf->status & GUC_PENDING_RESTART) ? "t" : "f";
}

const char* GetConfigOptionResetString

(

const char *

name

)

Definition at line 6763 of file guc.c.

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

Referenced by check_datestyle().

{
    struct config_generic *record;
    static char buffer[256];

    record = find_option(name, false, ERROR);
    if (record == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("unrecognized configuration parameter \"%s\"", name)));
    if ((record->flags & GUC_SUPERUSER_ONLY) &&
        !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_SETTINGS))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser or a member of pg_read_all_settings to examine \"%s\"",
                        name)));

    switch (record->vartype)
    {
        case PGC_BOOL:
            return ((struct config_bool *) record)->reset_val ? "on" : "off";

        case PGC_INT:
            snprintf(buffer, sizeof(buffer), "%d",
                     ((struct config_int *) record)->reset_val);
            return buffer;

        case PGC_REAL:
            snprintf(buffer, sizeof(buffer), "%g",
                     ((struct config_real *) record)->reset_val);
            return buffer;

        case PGC_STRING:
            return ((struct config_string *) record)->reset_val;

        case PGC_ENUM:
            return config_enum_lookup_by_value((struct config_enum *) record,
                                               ((struct config_enum *) record)->reset_val);
    }
    return NULL;
}

int GetNumConfigOptions

(

void

)

Definition at line 8348 of file guc.c.

References num_guc_variables.

Referenced by GucInfoMain(), and show_all_settings().

{
    return num_guc_variables;
}

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

Definition at line 7905 of file guc.c.

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

Referenced by exec_replication_command(), and standard_ProcessUtility().

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

TupleDesc GetPGVariableResultDesc

(

const char *

name

)

Definition at line 7914 of file guc.c.

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

Referenced by UtilityTupleDescriptor().

{
    TupleDesc   tupdesc;

    if (guc_name_compare(name, "all") == 0)
    {
        /* need a tuple descriptor representing three TEXT columns */
        tupdesc = CreateTemplateTupleDesc(3, false);
        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, false);
        TupleDescInitEntry(tupdesc, (AttrNumber) 1, varname,
                           TEXTOID, -1, 0);
    }
    return tupdesc;
}

void GUC_check_errcode

(

int

sqlerrcode

)

Definition at line 9784 of file guc.c.

References GUC_check_errcode_value.

Referenced by check_client_encoding(), check_role(), check_synchronous_standby_names(), check_transaction_deferrable(), check_transaction_read_only(), and check_XactIsoLevel().

{
    GUC_check_errcode_value = sqlerrcode;
}

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

Definition at line 9481 of file guc.c.

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

Referenced by AlterSetting(), and update_proconfig_value().

{
    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, 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;
        int         i;

        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 (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 */ ,
                          'i' /* 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 */ ,
                      'i' /* TEXT's typalign */ );
    }
    else
        a = construct_array(&datum, 1,
                            TEXTOID,
                            -1, false, 'i');

    return a;
}

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

Definition at line 9561 of file guc.c.

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

Referenced by AlterSetting(), and update_proconfig_value().

{
    struct config_generic *record;
    ArrayType  *newarray;
    int         i;
    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, 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 (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 */ ,
                      'i' /* 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 */ ,
                                 'i' /* TEXT's typalign */ );
        else
            newarray = construct_array(&d, 1,
                                       TEXTOID,
                                       -1, false, 'i');

        index++;
    }

    return newarray;
}

ArrayType* GUCArrayReset

(

ArrayType *

array

)

Definition at line 9633 of file guc.c.

References ARR_DIMS, array_ref(), array_set(), construct_array(), i, NULL, pfree(), superuser(), TextDatumGetCString, TEXTOID, val, and validate_option_array_item().

Referenced by AlterSetting().

{
    ArrayType  *newarray;
    int         i;
    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 (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 */ ,
                      'i' /* 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 */ ,
                                 'i' /* TEXT's typalign */ );
        else
            newarray = construct_array(&d, 1,
                                       TEXTOID,
                                       -1, false, 'i');

        index++;
        pfree(val);
    }

    return newarray;
}

void InitializeGUCOptions

(

void

)

Definition at line 4478 of file guc.c.

References build_guc_variables(), i, InitializeGUCOptionsFromEnvironment(), InitializeOneGUCOption(), num_guc_variables, pg_timezone_initialize(), PGC_POSTMASTER, PGC_S_OVERRIDE, and SetConfigOption().

Referenced by AuxiliaryProcessMain(), PostgresMain(), and PostmasterMain().

{
    int         i;

    /*
     * Before log_line_prefix could possibly receive a nonempty setting, make
     * sure that timezone processing is minimally alive (see elog.c).
     */
    pg_timezone_initialize();

    /*
     * Build sorted array of all GUC variables.
     */
    build_guc_variables();

    /*
     * Load all variables with their compiled-in defaults, and initialize
     * status fields as needed.
     */
    for (i = 0; i < num_guc_variables; i++)
    {
        InitializeOneGUCOption(guc_variables[i]);
    }

    guc_dirty = false;

    reporting_enabled = false;

    /*
     * Prevent any attempt to override the transaction modes from
     * non-interactive sources.
     */
    SetConfigOption("transaction_isolation", "default",
                    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();
}

int NewGUCNestLevel

(

void

)

Definition at line 5076 of file guc.c.

References GUCNestLevel.

Referenced by applyRemoteGucs(), do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), execute_extension_script(), fmgr_security_definer(), index_build(), ProcedureCreate(), PushTransaction(), RI_Initial_Check(), set_transmission_modes(), vacuum_rel(), and validate_index().

{
    return ++GUCNestLevel;
}

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

Definition at line 5508 of file guc.c.

References convert_to_base_unit(), gettext_noop, GUC_UNIT, GUC_UNIT_MEMORY, MAX_UNIT_LEN, memory_units_hint, NULL, time_units_hint, and val.

Referenced by parse_and_validate_value(), parse_one_reloption(), and readRecoveryCommandFile().

{
    int64       val;
    char       *endptr;

    /* To suppress compiler warnings, always set output params */
    if (result)
        *result = 0;
    if (hintmsg)
        *hintmsg = NULL;

    /* We assume here that int64 is at least as wide as long */
    errno = 0;
    val = strtol(value, &endptr, 0);

    if (endptr == value)
        return false;           /* no HINT for integer syntax error */

    if (errno == ERANGE || val != (int64) ((int32) val))
    {
        if (hintmsg)
            *hintmsg = gettext_noop("Value exceeds integer range.");
        return false;
    }

    /* allow whitespace between integer and unit */
    while (isspace((unsigned char) *endptr))
        endptr++;

    /* Handle possible unit */
    if (*endptr != '\0')
    {
        char        unit[MAX_UNIT_LEN + 1];
        int         unitlen;
        bool        converted = false;

        if ((flags & GUC_UNIT) == 0)
            return false;       /* this setting does not accept a unit */

        unitlen = 0;
        while (*endptr != '\0' && !isspace((unsigned char) *endptr) &&
               unitlen < MAX_UNIT_LEN)
            unit[unitlen++] = *(endptr++);
        unit[unitlen] = '\0';
        /* allow whitespace after unit */
        while (isspace((unsigned char) *endptr))
            endptr++;

        if (*endptr == '\0')
            converted = convert_to_base_unit(val, unit, (flags & GUC_UNIT),
                                             &val);
        if (!converted)
        {
            /* 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;
        }

        /* Check for overflow due to units conversion */
        if (val != (int64) ((int32) val))
        {
            if (hintmsg)
                *hintmsg = gettext_noop("Value exceeds integer range.");
            return false;
        }
    }

    if (result)
        *result = (int) val;
    return true;
}

bool parse_real	(	const char *	value,
		double *	result
	)

Definition at line 5594 of file guc.c.

References val.

Referenced by parse_and_validate_value(), and parse_one_reloption().

{
    double      val;
    char       *endptr;

    if (result)
        *result = 0;            /* suppress compiler warning */

    errno = 0;
    val = strtod(value, &endptr);
    if (endptr == value || errno == ERANGE)
        return false;

    /* allow whitespace after number */
    while (isspace((unsigned char) *endptr))
        endptr++;
    if (*endptr != '\0')
        return false;

    if (result)
        *result = val;
    return true;
}

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

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
	)

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

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

Definition at line 9385 of file guc.c.

References AssertArg, FATAL, guc_malloc(), guc_strdup(), NULL, and strlcpy().

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

{
    size_t      equal_pos;
    char       *cp;

    AssertArg(string);
    AssertArg(name);
    AssertArg(value);

    equal_pos = strcspn(string, "=");

    if (string[equal_pos] == '=')
    {
        *name = guc_malloc(FATAL, equal_pos + 1);
        strlcpy(*name, string, equal_pos + 1);

        *value = guc_strdup(FATAL, &string[equal_pos + 1]);
    }
    else
    {
        /* no equal sign in string */
        *name = guc_strdup(FATAL, string);
        *value = NULL;
    }

    for (cp = *name; *cp; cp++)
        if (*cp == '-')
            *cp = '_';
}

void ProcessConfigFile

(

GucContext

context

)

Referenced by ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), CheckpointWriteDelay(), do_autovacuum(), HandleStartupProcInterrupts(), LogicalRepApplyLoop(), pgarch_ArchiverCopyLoop(), pgarch_MainLoop(), PgstatCollectorMain(), PostgresMain(), SelectConfigFiles(), SIGHUP_handler(), SysLoggerMain(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), WalSndWriteData(), and WalWriterMain().

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

Definition at line 9423 of file guc.c.

References ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), Assert, ereport, errcode(), errmsg(), free, i, name, NULL, ParseLongOption(), pfree(), set_config_option(), TextDatumGetCString, TEXTOID, value, and WARNING.

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

{
    int         i;

    Assert(array != NULL);
    Assert(ARR_ELEMTYPE(array) == TEXTOID);
    Assert(ARR_NDIM(array) == 1);
    Assert(ARR_LBOUND(array)[0] == 1);

    for (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 */ ,
                      'i' /* 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)));
            free(name);
            continue;
        }

        (void) set_config_option(name, value,
                                 context, source,
                                 action, true, 0, false);

        free(name);
        if (value)
            free(value);
        pfree(s);
    }
}

void ResetAllOptions

(

void

)

Definition at line 4875 of file guc.c.

References config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_generic::context, config_generic::extra, config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_ACTION_SET, GUC_NO_RESET_ALL, GUC_REPORT, i, num_guc_variables, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_OVERRIDE, PGC_STRING, PGC_SUSET, PGC_USERSET, push_old_value(), ReportGUCOption(), config_bool::reset_extra, config_int::reset_extra, config_real::reset_extra, config_string::reset_extra, config_enum::reset_extra, config_generic::reset_scontext, config_generic::reset_source, config_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_string_field(), config_generic::source, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by DiscardAll(), and ExecSetVariableStmt().

{
    int         i;

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

        /* 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 = (struct config_bool *) gconf;

                    if (conf->assign_hook)
                        (*conf->assign_hook) (conf->reset_val,
                                              conf->reset_extra);
                    *conf->variable = conf->reset_val;
                    set_extra_field(&conf->gen, &conf->gen.extra,
                                    conf->reset_extra);
                    break;
                }
            case PGC_INT:
                {
                    struct config_int *conf = (struct config_int *) gconf;

                    if (conf->assign_hook)
                        (*conf->assign_hook) (conf->reset_val,
                                              conf->reset_extra);
                    *conf->variable = conf->reset_val;
                    set_extra_field(&conf->gen, &conf->gen.extra,
                                    conf->reset_extra);
                    break;
                }
            case PGC_REAL:
                {
                    struct config_real *conf = (struct config_real *) gconf;

                    if (conf->assign_hook)
                        (*conf->assign_hook) (conf->reset_val,
                                              conf->reset_extra);
                    *conf->variable = conf->reset_val;
                    set_extra_field(&conf->gen, &conf->gen.extra,
                                    conf->reset_extra);
                    break;
                }
            case PGC_STRING:
                {
                    struct config_string *conf = (struct config_string *) gconf;

                    if (conf->assign_hook)
                        (*conf->assign_hook) (conf->reset_val,
                                              conf->reset_extra);
                    set_string_field(conf, conf->variable, conf->reset_val);
                    set_extra_field(&conf->gen, &conf->gen.extra,
                                    conf->reset_extra);
                    break;
                }
            case PGC_ENUM:
                {
                    struct config_enum *conf = (struct config_enum *) gconf;

                    if (conf->assign_hook)
                        (*conf->assign_hook) (conf->reset_val,
                                              conf->reset_extra);
                    *conf->variable = conf->reset_val;
                    set_extra_field(&conf->gen, &conf->gen.extra,
                                    conf->reset_extra);
                    break;
                }
        }

        gconf->source = gconf->reset_source;
        gconf->scontext = gconf->reset_scontext;

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

void RestoreGUCState

(

void *

gucstate

)

Definition at line 9327 of file guc.c.

References can_skip_gucvar(), ereport, errcode(), errmsg(), ERROR, GUC_ACTION_SET, i, InitializeOneGUCOption(), num_guc_variables, read_gucstate(), read_gucstate_binary(), result, set_config_option(), and set_config_sourcefile().

Referenced by ParallelWorkerMain().

{
    char       *varname,
               *varvalue,
               *varsourcefile;
    int         varsourceline;
    GucSource   varsource;
    GucContext  varscontext;
    char       *srcptr = (char *) gucstate;
    char       *srcend;
    Size        len;
    int         i;

    /* See comment at can_skip_gucvar(). */
    for (i = 0; i < num_guc_variables; i++)
        if (!can_skip_gucvar(guc_variables[i]))
            InitializeOneGUCOption(guc_variables[i]);

    /* First item is the length of the subsequent data */
    memcpy(&len, gucstate, sizeof(len));

    srcptr += sizeof(len);
    srcend = srcptr + len;

    while (srcptr < srcend)
    {
        int         result;

        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));
        read_gucstate_binary(&srcptr, srcend,
                             &varsource, sizeof(varsource));
        read_gucstate_binary(&srcptr, srcend,
                             &varscontext, sizeof(varscontext));

        result = set_config_option(varname, varvalue, varscontext, varsource,
                                   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);
    }
}

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

Definition at line 4700 of file guc.c.

References CONFIG_FILENAME, DataDir, FATAL, free, guc_malloc(), HBA_FILENAME, IDENT_FILENAME, make_absolute_path(), pg_timezone_abbrev_initialize(), PGC_POSTMASTER, PGC_S_OVERRIDE, ProcessConfigFile(), SetConfigOption(), SetDataDir(), strerror(), and write_stderr.

Referenced by AuxiliaryProcessMain(), PostgresMain(), and PostmasterMain().

{
    char       *configdir;
    char       *fname;
    struct stat stat_buf;

    /* 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\": %s\n",
                     progname,
                     configdir,
                     strerror(errno));
        if (errno == ENOENT)
            write_stderr("Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n");
        return false;
    }

    /*
     * 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);
    else if (configdir)
    {
        fname = guc_malloc(FATAL,
                           strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
        sprintf(fname, "%s/%s", configdir, CONFIG_FILENAME);
    }
    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);
        return false;
    }

    /*
     * 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);
    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\": %s\n",
                     progname, ConfigFileName, strerror(errno));
        free(configdir);
        return false;
    }

    /*
     * 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.
     */
    if (data_directory)
        SetDataDir(data_directory);
    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);
        return false;
    }

    /*
     * 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);
    else if (configdir)
    {
        fname = guc_malloc(FATAL,
                           strlen(configdir) + strlen(HBA_FILENAME) + 2);
        sprintf(fname, "%s/%s", configdir, HBA_FILENAME);
    }
    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);
        return false;
    }
    SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
    free(fname);

    /*
     * Likewise for pg_ident.conf.
     */
    if (IdentFileName)
        fname = make_absolute_path(IdentFileName);
    else if (configdir)
    {
        fname = guc_malloc(FATAL,
                           strlen(configdir) + strlen(IDENT_FILENAME) + 2);
        sprintf(fname, "%s/%s", configdir, IDENT_FILENAME);
    }
    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);
        return false;
    }
    SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
    free(fname);

    free(configdir);

    return true;
}

void SerializeGUCState	(	Size	maxsize,
		char *	start_address
	)

Definition at line 9249 of file guc.c.

References Assert, i, num_guc_variables, and serialize_variable().

Referenced by InitializeParallelDSM().

{
    char       *curptr;
    Size        actual_size;
    Size        bytes_left;
    int         i;
    int         i_role = -1;

    /* 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);

    for (i = 0; i < num_guc_variables; i++)
    {
        /*
         * It's pretty ugly, but we've got to force "role" to be initialized
         * after "session_authorization"; otherwise, the latter will override
         * the former.
         */
        if (strcmp(guc_variables[i]->name, "role") == 0)
            i_role = i;
        else
            serialize_variable(&curptr, &bytes_left, guc_variables[i]);
    }
    if (i_role >= 0)
        serialize_variable(&curptr, &bytes_left, guc_variables[i_role]);

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

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

Definition at line 5919 of file guc.c.

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

Referenced by applyRemoteGucs(), define_custom_variable(), ExecSetVariableStmt(), execute_extension_script(), parse_subscription_options(), ProcessGUCArray(), reapply_stacked_values(), RestoreGUCState(), RI_Initial_Check(), set_config_by_name(), set_transmission_modes(), SetConfigOption(), SetPGVariable(), and validate_option_array_item().

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

    /*
     * 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.
     *
     * Other changes might need to affect other workers, so forbid them.
     */
    if (IsInParallelMode() && changeVal && action != GUC_ACTION_SAVE)
        ereport(elevel,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot set parameters during a parallel operation")));

    record = find_option(name, true, elevel);
    if (record == NULL)
    {
        ereport(elevel,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("unrecognized configuration parameter \"%s\"", 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",
                                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",
                                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",
                                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:
            /* Reject if we're connecting but user is not superuser */
            if (context == PGC_BACKEND)
            {
                ereport(elevel,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("permission denied to set parameter \"%s\"",
                                name)));
                return 0;
            }
            /* FALL THRU to process the same as PGC_BACKEND */
        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.
                 *
                 * 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 && !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",
                                name)));
                return 0;
            }
            break;
        case PGC_SUSET:
            if (context == PGC_USERSET || context == PGC_BACKEND)
            {
                ereport(elevel,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("permission denied to set parameter \"%s\"",
                                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",
                            name)));
            return 0;
        }
        if (InSecurityRestrictedOperation())
        {
            ereport(elevel,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("cannot set parameter \"%s\" within security-restricted operation",
                            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",
                 name);
            return -1;
        }
        changeVal = false;
    }

    /*
     * Evaluate value and set variable.
     */
    switch (record->vartype)
    {
        case PGC_BOOL:
            {
                struct config_bool *conf = (struct config_bool *) record;

#define newval (newval_union.boolval)

                if (value)
                {
                    if (!parse_and_validate_value(record, name, value,
                                                  source, elevel,
                                                  &newval_union, &newextra))
                        return 0;
                }
                else if (source == PGC_S_DEFAULT)
                {
                    newval = conf->boot_val;
                    if (!call_bool_check_hook(conf, &newval, &newextra,
                                              source, elevel))
                        return 0;
                }
                else
                {
                    newval = conf->reset_val;
                    newextra = conf->reset_extra;
                    source = conf->gen.reset_source;
                    context = conf->gen.reset_scontext;
                }

                if (prohibitValueChange)
                {
                    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",
                                        name)));
                        return 0;
                    }
                    record->status &= ~GUC_PENDING_RESTART;
                    return -1;
                }

                if (changeVal)
                {
                    /* Save old value to support transaction abort */
                    if (!makeDefault)
                        push_old_value(&conf->gen, action);

                    if (conf->assign_hook)
                        (*conf->assign_hook) (newval, newextra);
                    *conf->variable = newval;
                    set_extra_field(&conf->gen, &conf->gen.extra,
                                    newextra);
                    conf->gen.source = source;
                    conf->gen.scontext = context;
                }
                if (makeDefault)
                {
                    GucStack   *stack;

                    if (conf->gen.reset_source <= source)
                    {
                        conf->reset_val = newval;
                        set_extra_field(&conf->gen, &conf->reset_extra,
                                        newextra);
                        conf->gen.reset_source = source;
                        conf->gen.reset_scontext = context;
                    }
                    for (stack = conf->gen.stack; stack; stack = stack->prev)
                    {
                        if (stack->source <= source)
                        {
                            stack->prior.val.boolval = newval;
                            set_extra_field(&conf->gen, &stack->prior.extra,
                                            newextra);
                            stack->source = source;
                            stack->scontext = context;
                        }
                    }
                }

                /* Perhaps we didn't install newextra anywhere */
                if (newextra && !extra_field_used(&conf->gen, newextra))
                    free(newextra);
                break;

#undef newval
            }

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

#define newval (newval_union.intval)

                if (value)
                {
                    if (!parse_and_validate_value(record, name, value,
                                                  source, elevel,
                                                  &newval_union, &newextra))
                        return 0;
                }
                else if (source == PGC_S_DEFAULT)
                {
                    newval = conf->boot_val;
                    if (!call_int_check_hook(conf, &newval, &newextra,
                                             source, elevel))
                        return 0;
                }
                else
                {
                    newval = conf->reset_val;
                    newextra = conf->reset_extra;
                    source = conf->gen.reset_source;
                    context = conf->gen.reset_scontext;
                }

                if (prohibitValueChange)
                {
                    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",
                                        name)));
                        return 0;
                    }
                    record->status &= ~GUC_PENDING_RESTART;
                    return -1;
                }

                if (changeVal)
                {
                    /* Save old value to support transaction abort */
                    if (!makeDefault)
                        push_old_value(&conf->gen, action);

                    if (conf->assign_hook)
                        (*conf->assign_hook) (newval, newextra);
                    *conf->variable = newval;
                    set_extra_field(&conf->gen, &conf->gen.extra,
                                    newextra);
                    conf->gen.source = source;
                    conf->gen.scontext = context;
                }
                if (makeDefault)
                {
                    GucStack   *stack;

                    if (conf->gen.reset_source <= source)
                    {
                        conf->reset_val = newval;
                        set_extra_field(&conf->gen, &conf->reset_extra,
                                        newextra);
                        conf->gen.reset_source = source;
                        conf->gen.reset_scontext = context;
                    }
                    for (stack = conf->gen.stack; stack; stack = stack->prev)
                    {
                        if (stack->source <= source)
                        {
                            stack->prior.val.intval = newval;
                            set_extra_field(&conf->gen, &stack->prior.extra,
                                            newextra);
                            stack->source = source;
                            stack->scontext = context;
                        }
                    }
                }

                /* Perhaps we didn't install newextra anywhere */
                if (newextra && !extra_field_used(&conf->gen, newextra))
                    free(newextra);
                break;

#undef newval
            }

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

#define newval (newval_union.realval)

                if (value)
                {
                    if (!parse_and_validate_value(record, name, value,
                                                  source, elevel,
                                                  &newval_union, &newextra))
                        return 0;
                }
                else if (source == PGC_S_DEFAULT)
                {
                    newval = conf->boot_val;
                    if (!call_real_check_hook(conf, &newval, &newextra,
                                              source, elevel))
                        return 0;
                }
                else
                {
                    newval = conf->reset_val;
                    newextra = conf->reset_extra;
                    source = conf->gen.reset_source;
                    context = conf->gen.reset_scontext;
                }

                if (prohibitValueChange)
                {
                    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",
                                        name)));
                        return 0;
                    }
                    record->status &= ~GUC_PENDING_RESTART;
                    return -1;
                }

                if (changeVal)
                {
                    /* Save old value to support transaction abort */
                    if (!makeDefault)
                        push_old_value(&conf->gen, action);

                    if (conf->assign_hook)
                        (*conf->assign_hook) (newval, newextra);
                    *conf->variable = newval;
                    set_extra_field(&conf->gen, &conf->gen.extra,
                                    newextra);
                    conf->gen.source = source;
                    conf->gen.scontext = context;
                }
                if (makeDefault)
                {
                    GucStack   *stack;

                    if (conf->gen.reset_source <= source)
                    {
                        conf->reset_val = newval;
                        set_extra_field(&conf->gen, &conf->reset_extra,
                                        newextra);
                        conf->gen.reset_source = source;
                        conf->gen.reset_scontext = context;
                    }
                    for (stack = conf->gen.stack; stack; stack = stack->prev)
                    {
                        if (stack->source <= source)
                        {
                            stack->prior.val.realval = newval;
                            set_extra_field(&conf->gen, &stack->prior.extra,
                                            newextra);
                            stack->source = source;
                            stack->scontext = context;
                        }
                    }
                }

                /* Perhaps we didn't install newextra anywhere */
                if (newextra && !extra_field_used(&conf->gen, newextra))
                    free(newextra);
                break;

#undef newval
            }

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

#define newval (newval_union.stringval)

                if (value)
                {
                    if (!parse_and_validate_value(record, name, 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(conf, &newval, &newextra,
                                                source, elevel))
                    {
                        free(newval);
                        return 0;
                    }
                }
                else
                {
                    /*
                     * strdup not needed, since reset_val is already under
                     * guc.c's control
                     */
                    newval = conf->reset_val;
                    newextra = conf->reset_extra;
                    source = conf->gen.reset_source;
                    context = conf->gen.reset_scontext;
                }

                if (prohibitValueChange)
                {
                    /* newval shouldn't be NULL, so we're a bit sloppy here */
                    if (*conf->variable == NULL || newval == NULL ||
                        strcmp(*conf->variable, newval) != 0)
                    {
                        record->status |= GUC_PENDING_RESTART;
                        ereport(elevel,
                                (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                 errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                        name)));
                        return 0;
                    }
                    record->status &= ~GUC_PENDING_RESTART;
                    return -1;
                }

                if (changeVal)
                {
                    /* Save old value to support transaction abort */
                    if (!makeDefault)
                        push_old_value(&conf->gen, action);

                    if (conf->assign_hook)
                        (*conf->assign_hook) (newval, newextra);
                    set_string_field(conf, conf->variable, newval);
                    set_extra_field(&conf->gen, &conf->gen.extra,
                                    newextra);
                    conf->gen.source = source;
                    conf->gen.scontext = context;
                }

                if (makeDefault)
                {
                    GucStack   *stack;

                    if (conf->gen.reset_source <= source)
                    {
                        set_string_field(conf, &conf->reset_val, newval);
                        set_extra_field(&conf->gen, &conf->reset_extra,
                                        newextra);
                        conf->gen.reset_source = source;
                        conf->gen.reset_scontext = context;
                    }
                    for (stack = conf->gen.stack; stack; stack = stack->prev)
                    {
                        if (stack->source <= source)
                        {
                            set_string_field(conf, &stack->prior.val.stringval,
                                             newval);
                            set_extra_field(&conf->gen, &stack->prior.extra,
                                            newextra);
                            stack->source = source;
                            stack->scontext = context;
                        }
                    }
                }

                /* Perhaps we didn't install newval anywhere */
                if (newval && !string_field_used(conf, newval))
                    free(newval);
                /* Perhaps we didn't install newextra anywhere */
                if (newextra && !extra_field_used(&conf->gen, newextra))
                    free(newextra);
                break;

#undef newval
            }

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

#define newval (newval_union.enumval)

                if (value)
                {
                    if (!parse_and_validate_value(record, name, value,
                                                  source, elevel,
                                                  &newval_union, &newextra))
                        return 0;
                }
                else if (source == PGC_S_DEFAULT)
                {
                    newval = conf->boot_val;
                    if (!call_enum_check_hook(conf, &newval, &newextra,
                                              source, elevel))
                        return 0;
                }
                else
                {
                    newval = conf->reset_val;
                    newextra = conf->reset_extra;
                    source = conf->gen.reset_source;
                    context = conf->gen.reset_scontext;
                }

                if (prohibitValueChange)
                {
                    if (*conf->variable != newval)
                    {
                        record->status |= GUC_PENDING_RESTART;
                        ereport(elevel,
                                (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                 errmsg("parameter \"%s\" cannot be changed without rest