#include "postgres.h"
#include <limits.h>
#include <math.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_parameter_acl.h"
#include "catalog/pg_type.h"
#include "guc_internal.h"
#include "libpq/pqformat.h"
#include "libpq/protocol.h"
#include "miscadmin.h"
#include "parser/scansup.h"
#include "port/pg_bitutils.h"
#include "storage/fd.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
#include "tcop/tcopprot.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/conffiles.h"
#include "utils/guc_tables.h"
#include "utils/memutils.h"
#include "utils/timestamp.h"

Include dependency graph for guc.c:

Data Structures
struct	unit_conversion

struct	GUCHashEntry

Macros
#define	CONFIG_FILENAME "postgresql.conf"

#define	HBA_FILENAME "pg_hba.conf"

#define	IDENT_FILENAME "pg_ident.conf"

#define	REALTYPE_PRECISION 17

#define	GUC_SAFE_SEARCH_PATH "pg_catalog, pg_temp"

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

#define	newval (newval_union.boolval)

#define	newval (newval_union.intval)

#define	newval (newval_union.realval)

#define	newval (newval_union.stringval)

#define	newval (newval_union.enumval)

Functions
static int	guc_var_compare (const void a, const void b)

static uint32	guc_name_hash (const void *key, Size keysize)

static int	guc_name_match (const void key1, const void key2, Size keysize)

static void	InitializeGUCOptionsFromEnvironment (void)

static void	InitializeOneGUCOption (struct config_generic *gconf)

static void	RemoveGUCFromLists (struct config_generic *gconf)

static void	set_guc_source (struct config_generic *gconf, GucSource newsource)

static void	pg_timezone_abbrev_initialize (void)

static void	push_old_value (struct config_generic *gconf, GucAction action)

static void	ReportGUCOption (struct config_generic *record)

static void	set_config_sourcefile (const char name, char sourcefile, int sourceline)

static void	reapply_stacked_values (struct config_generic variable, struct config_string pHolder, GucStack stack, const char curvalue, GucContext curscontext, GucSource cursource, Oid cursrole)

static void	free_placeholder (struct config_string *pHolder)

static bool	validate_option_array_item (const char name, const char value, bool skipIfNoPermissions)

static void	write_auto_conf_file (int fd, const char filename, ConfigVariable head)

static void	replace_auto_config_value (ConfigVariable head_p, ConfigVariable tail_p, const char name, const char value)

static bool	valid_custom_variable_name (const char *name)

static bool	assignable_custom_variable_name (const char *name, bool skip_errors, int elevel)

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

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

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

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

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

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

ConfigVariable *	ProcessConfigFileInternal (GucContext context, bool applySettings, int elevel)

void *	guc_malloc (int elevel, size_t size)

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

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

void	guc_free (void *ptr)

static bool	string_field_used (struct config_string conf, char strval)

static void	set_string_field (struct config_string conf, char field, char newval)

static bool	extra_field_used (struct config_generic gconf, void extra)

static void	set_extra_field (struct config_generic gconf, void field, void newval)

static void	set_stack_value (struct config_generic gconf, config_var_value val)

static void	discard_stack_value (struct config_generic gconf, config_var_value val)

struct config_generic **	get_guc_variables (int *num_vars)

void	build_guc_variables (void)

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

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

struct config_generic *	find_option (const char *name, bool create_placeholders, bool skip_errors, int elevel)

int	guc_name_compare (const char namea, const char nameb)

char *	convert_GUC_name_for_parameter_acl (const char *name)

void	check_GUC_name_for_parameter_acl (const char *name)

void	InitializeGUCOptions (void)

bool	SelectConfigFiles (const char userDoption, const char progname)

void	ResetAllOptions (void)

void	AtStart_GUC (void)

int	NewGUCNestLevel (void)

void	RestrictSearchPath (void)

void	AtEOXact_GUC (bool isCommit, int nestLevel)

void	BeginReportingGUCOptions (void)

void	ReportChangedGUCOptions (void)

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

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

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

const char *	get_config_unit_name (int flags)

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

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

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

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

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

static bool	parse_and_validate_value (struct config_generic record, const char value, GucSource source, int elevel, union config_var_val newval, void *newextra)

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

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

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

config_handle *	get_config_handle (const char *name)

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

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

const char *	GetConfigOptionResetString (const char *name)

int	GetConfigOptionFlags (const char *name, bool missing_ok)

void	AlterSystemSetConfigFile (AlterSystemStmt *altersysstmt)

static struct config_generic *	init_custom_variable (const char name, const char short_desc, const char *long_desc, GucContext context, int flags, enum config_type type, size_t sz)

static void	define_custom_variable (struct config_generic *variable)

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

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

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

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

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

void	MarkGUCPrefixReserved (const char *className)

struct config_generic **	get_explain_guc_options (int *num)

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

char *	ShowGUCOption (struct config_generic *record, bool use_units)

static bool	can_skip_gucvar (struct config_generic *gconf)

static Size	estimate_variable_size (struct config_generic *gconf)

Size	EstimateGUCStateSpace (void)

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

static void	serialize_variable (char *destptr, Size maxbytes, struct config_generic *gconf)

void	SerializeGUCState (Size maxsize, char *start_address)

static char *	read_gucstate (char *srcptr, char srcend)

static void	read_gucstate_binary (char *srcptr, char srcend, void *dest, Size size)

static void	guc_restore_error_context_callback (void *arg)

void	RestoreGUCState (void *gucstate)

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

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

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

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

ArrayType *	GUCArrayDelete (ArrayType array, const char name)

ArrayType *	GUCArrayReset (ArrayType *array)

void	GUC_check_errcode (int sqlerrcode)

Variables
static int	GUC_check_errcode_value

static List *	reserved_class_prefix = NIL

char *	GUC_check_errmsg_string

char *	GUC_check_errdetail_string

char *	GUC_check_errhint_string

static const char *const	memory_units_hint = gettext_noop("Valid units for this parameter are \"B\", \"kB\", \"MB\", \"GB\", and \"TB\".")

static const unit_conversion	memory_unit_conversion_table []

static const char *const	time_units_hint = gettext_noop("Valid units for this parameter are \"us\", \"ms\", \"s\", \"min\", \"h\", and \"d\".")

static const unit_conversion	time_unit_conversion_table []

static const char *const	map_old_guc_names []

static MemoryContext	GUCMemoryContext

static HTAB *	guc_hashtab

static dlist_head	guc_nondef_list

static slist_head	guc_stack_list

static slist_head	guc_report_list

static bool	reporting_enabled

static int	GUCNestLevel = 0

Macro Definition Documentation

◆ CONFIG_FILENAME

#define CONFIG_FILENAME "postgresql.conf"

Definition at line 56 of file guc.c.

◆ GUC_SAFE_SEARCH_PATH

#define GUC_SAFE_SEARCH_PATH "pg_catalog, pg_temp"

Definition at line 75 of file guc.c.

◆ HBA_FILENAME

#define HBA_FILENAME "pg_hba.conf"

Definition at line 57 of file guc.c.

◆ IDENT_FILENAME

#define IDENT_FILENAME "pg_ident.conf"

Definition at line 58 of file guc.c.

◆ MAX_UNIT_LEN

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

Definition at line 102 of file guc.c.

◆ newval [1/5]

#define newval (newval_union.boolval)

◆ newval [2/5]

#define newval (newval_union.intval)

◆ newval [3/5]

#define newval (newval_union.realval)

◆ newval [4/5]

#define newval (newval_union.stringval)

◆ newval [5/5]

#define newval (newval_union.enumval)

◆ REALTYPE_PRECISION

#define REALTYPE_PRECISION 17

Definition at line 69 of file guc.c.

Function Documentation

◆ add_guc_variable()

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

static

Definition at line 1049 of file guc.c.

{
    GUCHashEntry *hentry;
    bool        found;
 
    hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                          &var->name,
                                          HASH_ENTER_NULL,
                                          &found);
    if (unlikely(hentry == NULL))
    {
        ereport(elevel,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
        return false;           /* out of memory */
    }
    Assert(!found);
    hentry->gucvar = var;
    return true;
}

References Assert(), ereport, errcode(), errmsg(), guc_hashtab, GUCHashEntry::gucvar, HASH_ENTER_NULL, hash_search(), config_generic::name, and unlikely.

Referenced by add_placeholder_variable(), and define_custom_variable().

◆ add_placeholder_variable()

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

static

Definition at line 1179 of file guc.c.

{
    size_t      sz = sizeof(struct config_string) + sizeof(char *);
    struct config_string *var;
    struct config_generic *gen;
 
    var = (struct config_string *) guc_malloc(elevel, sz);
    if (var == NULL)
        return NULL;
    memset(var, 0, sz);
    gen = &var->gen;
 
    gen->name = guc_strdup(elevel, name);
    if (gen->name == NULL)
    {
        guc_free(var);
        return NULL;
    }
 
    gen->context = PGC_USERSET;
    gen->group = CUSTOM_OPTIONS;
    gen->short_desc = "GUC placeholder variable";
    gen->flags = GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE | GUC_CUSTOM_PLACEHOLDER;
    gen->vartype = PGC_STRING;
 
    /*
     * The char* is allocated at the end of the struct since we have no
     * 'static' place to point to.  Note that the current value, as well as
     * the boot and reset values, start out NULL.
     */
    var->variable = (char **) (var + 1);
 
    if (!add_guc_variable((struct config_generic *) var, elevel))
    {
        guc_free(unconstify(char *, gen->name));
        guc_free(var);
        return NULL;
    }
 
    return gen;
}

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

Referenced by find_option().

◆ AlterSystemSetConfigFile()

void AlterSystemSetConfigFile ( AlterSystemStmt * altersysstmt )

Definition at line 4613 of file guc.c.

{
    char       *name;
    char       *value;
    bool        resetall = false;
    ConfigVariable *head = NULL;
    ConfigVariable *tail = NULL;
    volatile int Tmpfd;
    char        AutoConfFileName[MAXPGPATH];
    char        AutoConfTmpFileName[MAXPGPATH];
 
    /*
     * Extract statement arguments
     */
    name = altersysstmt->setstmt->name;
 
    if (!AllowAlterSystem)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("ALTER SYSTEM is not allowed in this environment")));
 
    switch (altersysstmt->setstmt->kind)
    {
        case VAR_SET_VALUE:
            value = ExtractSetVariableArgs(altersysstmt->setstmt);
            break;
 
        case VAR_SET_DEFAULT:
        case VAR_RESET:
            value = NULL;
            break;
 
        case VAR_RESET_ALL:
            value = NULL;
            resetall = true;
            break;
 
        default:
            elog(ERROR, "unrecognized alter system stmt type: %d",
                 altersysstmt->setstmt->kind);
            break;
    }
 
    /*
     * Check permission to run ALTER SYSTEM on the target variable
     */
    if (!superuser())
    {
        if (resetall)
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
        else
        {
            AclResult   aclresult;
 
            aclresult = pg_parameter_aclcheck(name, GetUserId(),
                                              ACL_ALTER_SYSTEM);
            if (aclresult != ACLCHECK_OK)
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("permission denied to set parameter \"%s\"",
                                name)));
        }
    }
 
    /*
     * Unless it's RESET_ALL, validate the target variable and value
     */
    if (!resetall)
    {
        struct config_generic *record;
 
        /* We don't want to create a placeholder if there's not one already */
        record = find_option(name, false, true, DEBUG5);
        if (record != NULL)
        {
            /*
             * Don't allow parameters that can't be set in configuration files
             * to be set in PG_AUTOCONF_FILENAME file.
             */
            if ((record->context == PGC_INTERNAL) ||
                (record->flags & GUC_DISALLOW_IN_FILE) ||
                (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
                ereport(ERROR,
                        (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                         errmsg("parameter \"%s\" cannot be changed",
                                name)));
 
            /*
             * If a value is specified, verify that it's sane.
             */
            if (value)
            {
                union config_var_val newval;
                void       *newextra = NULL;
 
                if (!parse_and_validate_value(record, value,
                                              PGC_S_FILE, ERROR,
                                              &newval, &newextra))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("invalid value for parameter \"%s\": \"%s\"",
                                    name, value)));
 
                if (record->vartype == PGC_STRING && newval.stringval != NULL)
                    guc_free(newval.stringval);
                guc_free(newextra);
            }
        }
        else
        {
            /*
             * Variable not known; check we'd be allowed to create it.  (We
             * cannot validate the value, but that's fine.  A non-core GUC in
             * the config file cannot cause postmaster start to fail, so we
             * don't have to be too tense about possibly installing a bad
             * value.)
             *
             * As an exception, we skip this check if this is a RESET command
             * for an unknown custom GUC, else there'd be no way for users to
             * remove such settings with reserved prefixes.
             */
            if (value || !valid_custom_variable_name(name))
                (void) assignable_custom_variable_name(name, false, ERROR);
        }
 
        /*
         * We must also reject values containing newlines, because the grammar
         * for config files doesn't support embedded newlines in string
         * literals.
         */
        if (value && strchr(value, '\n'))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
    }
 
    /*
     * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
     * the data directory, so we can reference them by simple relative paths.
     */
    snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
             PG_AUTOCONF_FILENAME);
    snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
             AutoConfFileName,
             "tmp");
 
    /*
     * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
     * time.  Use AutoFileLock to ensure that.  We must hold the lock while
     * reading the old file contents.
     */
    LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
 
    /*
     * If we're going to reset everything, then no need to open or parse the
     * old file.  We'll just write out an empty list.
     */
    if (!resetall)
    {
        struct stat st;
 
        if (stat(AutoConfFileName, &st) == 0)
        {
            /* open old file PG_AUTOCONF_FILENAME */
            FILE       *infile;
 
            infile = AllocateFile(AutoConfFileName, "r");
            if (infile == NULL)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not open file \"%s\": %m",
                                AutoConfFileName)));
 
            /* parse it */
            if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
                               LOG, &head, &tail))
                ereport(ERROR,
                        (errcode(ERRCODE_CONFIG_FILE_ERROR),
                         errmsg("could not parse contents of file \"%s\"",
                                AutoConfFileName)));
 
            FreeFile(infile);
        }
 
        /*
         * Now, replace any existing entry with the new value, or add it if
         * not present.
         */
        replace_auto_config_value(&head, &tail, name, value);
    }
 
    /*
     * Invoke the post-alter hook for setting this GUC variable.  GUCs
     * typically do not have corresponding entries in pg_parameter_acl, so we
     * call the hook using the name rather than a potentially-non-existent
     * OID.  Nonetheless, we pass ParameterAclRelationId so that this call
     * context can be distinguished from others.  (Note that "name" will be
     * NULL in the RESET ALL case.)
     *
     * We do this here rather than at the end, because ALTER SYSTEM is not
     * transactional.  If the hook aborts our transaction, it will be cleaner
     * to do so before we touch any files.
     */
    InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
                                    ACL_ALTER_SYSTEM,
                                    altersysstmt->setstmt->kind,
                                    false);
 
    /*
     * To ensure crash safety, first write the new file data to a temp file,
     * then atomically rename it into place.
     *
     * If there is a temp file left over due to a previous crash, it's okay to
     * truncate and reuse it.
     */
    Tmpfd = BasicOpenFile(AutoConfTmpFileName,
                          O_CREAT | O_RDWR | O_TRUNC);
    if (Tmpfd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m",
                        AutoConfTmpFileName)));
 
    /*
     * Use a TRY block to clean up the file if we fail.  Since we need a TRY
     * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
     */
    PG_TRY();
    {
        /* Write and sync the new contents to the temporary file */
        write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
 
        /* Close before renaming; may be required on some platforms */
        close(Tmpfd);
        Tmpfd = -1;
 
        /*
         * As the rename is atomic operation, if any problem occurs after this
         * at worst it can lose the parameters set by last ALTER SYSTEM
         * command.
         */
        durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
    }
    PG_CATCH();
    {
        /* Close file first, else unlink might fail on some platforms */
        if (Tmpfd >= 0)
            close(Tmpfd);
 
        /* Unlink, but ignore any error */
        (void) unlink(AutoConfTmpFileName);
 
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    FreeConfigVariables(head);
 
    LWLockRelease(AutoFileLock);
}

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

Referenced by standard_ProcessUtility().

◆ assignable_custom_variable_name()

static bool assignable_custom_variable_name	(	const char *	name,
		bool	skip_errors,
		int	elevel
	)

static

Definition at line 1123 of file guc.c.

{
    /* If there's no separator, it can't be a custom variable */
    const char *sep = strchr(name, GUC_QUALIFIER_SEPARATOR);
 
    if (sep != NULL)
    {
        size_t      classLen = sep - name;
        ListCell   *lc;
 
        /* The name must be syntactically acceptable ... */
        if (!valid_custom_variable_name(name))
        {
            if (!skip_errors)
                ereport(elevel,
                        (errcode(ERRCODE_INVALID_NAME),
                         errmsg("invalid configuration parameter name \"%s\"",
                                name),
                         errdetail("Custom parameter names must be two or more simple identifiers separated by dots.")));
            return false;
        }
        /* ... and it must not match any previously-reserved prefix */
        foreach(lc, reserved_class_prefix)
        {
            const char *rcprefix = lfirst(lc);
 
            if (strlen(rcprefix) == classLen &&
                strncmp(name, rcprefix, classLen) == 0)
            {
                if (!skip_errors)
                    ereport(elevel,
                            (errcode(ERRCODE_INVALID_NAME),
                             errmsg("invalid configuration parameter name \"%s\"",
                                    name),
                             errdetail("\"%s\" is a reserved prefix.",
                                       rcprefix)));
                return false;
            }
        }
        /* OK to create it */
        return true;
    }
 
    /* Unrecognized single-part name */
    if (!skip_errors)
        ereport(elevel,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("unrecognized configuration parameter \"%s\"",
                        name)));
    return false;
}

References ereport, errcode(), errdetail(), errmsg(), GUC_QUALIFIER_SEPARATOR, lfirst, name, reserved_class_prefix, and valid_custom_variable_name().

Referenced by AlterSystemSetConfigFile(), check_GUC_name_for_parameter_acl(), and find_option().

◆ AtEOXact_GUC()

void AtEOXact_GUC	(	bool	isCommit,
		int	nestLevel
	)

Definition at line 2268 of file guc.c.

{
    slist_mutable_iter iter;
 
    /*
     * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
     * abort, if there is a failure during transaction start before
     * AtStart_GUC is called.
     */
    Assert(nestLevel > 0 &&
           (nestLevel <= GUCNestLevel ||
            (nestLevel == GUCNestLevel + 1 && !isCommit)));
 
    /* We need only process GUCs having nonempty stacks */
    slist_foreach_modify(iter, &guc_stack_list)
    {
        struct config_generic *gconf = slist_container(struct config_generic,
                                                       stack_link, iter.cur);
        GucStack   *stack;
 
        /*
         * Process and pop each stack entry within the nest level. To simplify
         * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
         * we allow failure exit from code that uses a local nest level to be
         * recovered at the surrounding transaction or subtransaction abort;
         * so there could be more than one stack entry to pop.
         */
        while ((stack = gconf->stack) != NULL &&
               stack->nest_level >= nestLevel)
        {
            GucStack   *prev = stack->prev;
            bool        restorePrior = false;
            bool        restoreMasked = false;
            bool        changed;
 
            /*
             * In this next bit, if we don't set either restorePrior or
             * restoreMasked, we must "discard" any unwanted fields of the
             * stack entries to avoid leaking memory.  If we do set one of
             * those flags, unused fields will be cleaned up after restoring.
             */
            if (!isCommit)      /* if abort, always restore prior value */
                restorePrior = true;
            else if (stack->state == GUC_SAVE)
                restorePrior = true;
            else if (stack->nest_level == 1)
            {
                /* transaction commit */
                if (stack->state == GUC_SET_LOCAL)
                    restoreMasked = true;
                else if (stack->state == GUC_SET)
                {
                    /* we keep the current active value */
                    discard_stack_value(gconf, &stack->prior);
                }
                else            /* must be GUC_LOCAL */
                    restorePrior = true;
            }
            else if (prev == NULL ||
                     prev->nest_level < stack->nest_level - 1)
            {
                /* decrement entry's level and do not pop it */
                stack->nest_level--;
                continue;
            }
            else
            {
                /*
                 * We have to merge this stack entry into prev. See README for
                 * discussion of this bit.
                 */
                switch (stack->state)
                {
                    case GUC_SAVE:
                        Assert(false);  /* can't get here */
                        break;
 
                    case GUC_SET:
                        /* next level always becomes SET */
                        discard_stack_value(gconf, &stack->prior);
                        if (prev->state == GUC_SET_LOCAL)
                            discard_stack_value(gconf, &prev->masked);
                        prev->state = GUC_SET;
                        break;
 
                    case GUC_LOCAL:
                        if (prev->state == GUC_SET)
                        {
                            /* LOCAL migrates down */
                            prev->masked_scontext = stack->scontext;
                            prev->masked_srole = stack->srole;
                            prev->masked = stack->prior;
                            prev->state = GUC_SET_LOCAL;
                        }
                        else
                        {
                            /* else just forget this stack level */
                            discard_stack_value(gconf, &stack->prior);
                        }
                        break;
 
                    case GUC_SET_LOCAL:
                        /* prior state at this level no longer wanted */
                        discard_stack_value(gconf, &stack->prior);
                        /* copy down the masked state */
                        prev->masked_scontext = stack->masked_scontext;
                        prev->masked_srole = stack->masked_srole;
                        if (prev->state == GUC_SET_LOCAL)
                            discard_stack_value(gconf, &prev->masked);
                        prev->masked = stack->masked;
                        prev->state = GUC_SET_LOCAL;
                        break;
                }
            }
 
            changed = false;
 
            if (restorePrior || restoreMasked)
            {
                /* Perform appropriate restoration of the stacked value */
                config_var_value newvalue;
                GucSource   newsource;
                GucContext  newscontext;
                Oid         newsrole;
 
                if (restoreMasked)
                {
                    newvalue = stack->masked;
                    newsource = PGC_S_SESSION;
                    newscontext = stack->masked_scontext;
                    newsrole = stack->masked_srole;
                }
                else
                {
                    newvalue = stack->prior;
                    newsource = stack->source;
                    newscontext = stack->scontext;
                    newsrole = stack->srole;
                }
 
                switch (gconf->vartype)
                {
                    case PGC_BOOL:
                        {
                            struct config_bool *conf = (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 */
                set_guc_source(gconf, newsource);
                gconf->scontext = newscontext;
                gconf->srole = newsrole;
            }
 
            /*
             * Pop the GUC's state stack; if it's now empty, remove the GUC
             * from guc_stack_list.
             */
            gconf->stack = prev;
            if (prev == NULL)
                slist_delete_current(&iter);
            pfree(stack);
 
            /* Report new value if we changed it */
            if (changed && (gconf->flags & GUC_REPORT) &&
                !(gconf->status & GUC_NEEDS_REPORT))
            {
                gconf->status |= GUC_NEEDS_REPORT;
                slist_push_head(&guc_report_list, &gconf->report_link);
            }
        }                       /* end of stack-popping loop */
    }
 
    /* Update nesting level */
    GUCNestLevel = nestLevel - 1;
}

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

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

◆ AtStart_GUC()

void AtStart_GUC ( void )

Definition at line 2221 of file guc.c.

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

References elog, GUCNestLevel, and WARNING.

Referenced by StartTransaction().

◆ BeginReportingGUCOptions()

void BeginReportingGUCOptions ( void )

Definition at line 2552 of file guc.c.

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

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

Referenced by PostgresMain().

◆ build_guc_variables()

void build_guc_variables ( void )

Definition at line 905 of file guc.c.

{
    int         size_vars;
    int         num_vars = 0;
    HASHCTL     hash_ctl;
    GUCHashEntry *hentry;
    bool        found;
    int         i;
 
    /*
     * Create the memory context that will hold all GUC-related data.
     */
    Assert(GUCMemoryContext == NULL);
    GUCMemoryContext = AllocSetContextCreate(TopMemoryContext,
                                             "GUCMemoryContext",
                                             ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Count all the built-in variables, and set their vartypes correctly.
     */
    for (i = 0; ConfigureNamesBool[i].gen.name; i++)
    {
        struct config_bool *conf = &ConfigureNamesBool[i];
 
        /* Rather than requiring vartype to be filled in by hand, do this: */
        conf->gen.vartype = PGC_BOOL;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesInt[i].gen.name; i++)
    {
        struct config_int *conf = &ConfigureNamesInt[i];
 
        conf->gen.vartype = PGC_INT;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesReal[i].gen.name; i++)
    {
        struct config_real *conf = &ConfigureNamesReal[i];
 
        conf->gen.vartype = PGC_REAL;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesString[i].gen.name; i++)
    {
        struct config_string *conf = &ConfigureNamesString[i];
 
        conf->gen.vartype = PGC_STRING;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
    {
        struct config_enum *conf = &ConfigureNamesEnum[i];
 
        conf->gen.vartype = PGC_ENUM;
        num_vars++;
    }
 
    /*
     * Create hash table with 20% slack
     */
    size_vars = num_vars + num_vars / 4;
 
    hash_ctl.keysize = sizeof(char *);
    hash_ctl.entrysize = sizeof(GUCHashEntry);
    hash_ctl.hash = guc_name_hash;
    hash_ctl.match = guc_name_match;
    hash_ctl.hcxt = GUCMemoryContext;
    guc_hashtab = hash_create("GUC hash table",
                              size_vars,
                              &hash_ctl,
                              HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT);
 
    for (i = 0; ConfigureNamesBool[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesBool[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    for (i = 0; ConfigureNamesInt[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesInt[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    for (i = 0; ConfigureNamesReal[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesReal[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    for (i = 0; ConfigureNamesString[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesString[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesEnum[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    Assert(num_vars == hash_get_num_entries(guc_hashtab));
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), ConfigureNamesBool, ConfigureNamesEnum, ConfigureNamesInt, ConfigureNamesReal, ConfigureNamesString, HASHCTL::entrysize, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, guc_hashtab, guc_name_hash(), guc_name_match(), GUCMemoryContext, GUCHashEntry::gucvar, HASHCTL::hash, HASH_COMPARE, HASH_CONTEXT, hash_create(), HASH_ELEM, HASH_ENTER, HASH_FUNCTION, hash_get_num_entries(), hash_search(), HASHCTL::hcxt, i, HASHCTL::keysize, HASHCTL::match, config_generic::name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, TopMemoryContext, and config_generic::vartype.

Referenced by GucInfoMain(), and InitializeGUCOptions().

◆ call_bool_check_hook()

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

static

Definition at line 6827 of file guc.c.

{
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;
 
    /* Reset variables that might be set by hook */
    GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
    GUC_check_errmsg_string = NULL;
    GUC_check_errdetail_string = NULL;
    GUC_check_errhint_string = NULL;
 
    if (!conf->check_hook(newval, extra, source))
    {
        ereport(elevel,
                (errcode(GUC_check_errcode_value),
                 GUC_check_errmsg_string ?
                 errmsg_internal("%s", GUC_check_errmsg_string) :
                 errmsg("invalid value for parameter \"%s\": %d",
                        conf->gen.name, (int) *newval),
                 GUC_check_errdetail_string ?
                 errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                 GUC_check_errhint_string ?
                 errhint("%s", GUC_check_errhint_string) : 0));
        /* Flush any strings created in ErrorContext */
        FlushErrorState();
        return false;
    }
 
    return true;
}

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

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

◆ call_enum_check_hook()

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

static

Definition at line 6979 of file guc.c.

{
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;
 
    /* Reset variables that might be set by hook */
    GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
    GUC_check_errmsg_string = NULL;
    GUC_check_errdetail_string = NULL;
    GUC_check_errhint_string = NULL;
 
    if (!conf->check_hook(newval, extra, source))
    {
        ereport(elevel,
                (errcode(GUC_check_errcode_value),
                 GUC_check_errmsg_string ?
                 errmsg_internal("%s", GUC_check_errmsg_string) :
                 errmsg("invalid value for parameter \"%s\": \"%s\"",
                        conf->gen.name,
                        config_enum_lookup_by_value(conf, *newval)),
                 GUC_check_errdetail_string ?
                 errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                 GUC_check_errhint_string ?
                 errhint("%s", GUC_check_errhint_string) : 0));
        /* Flush any strings created in ErrorContext */
        FlushErrorState();
        return false;
    }
 
    return true;
}

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

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

◆ call_int_check_hook()

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

static

Definition at line 6861 of file guc.c.

{
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;
 
    /* Reset variables that might be set by hook */
    GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
    GUC_check_errmsg_string = NULL;
    GUC_check_errdetail_string = NULL;
    GUC_check_errhint_string = NULL;
 
    if (!conf->check_hook(newval, extra, source))
    {
        ereport(elevel,
                (errcode(GUC_check_errcode_value),
                 GUC_check_errmsg_string ?
                 errmsg_internal("%s", GUC_check_errmsg_string) :
                 errmsg("invalid value for parameter \"%s\": %d",
                        conf->gen.name, *newval),
                 GUC_check_errdetail_string ?
                 errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                 GUC_check_errhint_string ?
                 errhint("%s", GUC_check_errhint_string) : 0));
        /* Flush any strings created in ErrorContext */
        FlushErrorState();
        return false;
    }
 
    return true;
}

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

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

◆ call_real_check_hook()

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

static

Definition at line 6895 of file guc.c.

{
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;
 
    /* Reset variables that might be set by hook */
    GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
    GUC_check_errmsg_string = NULL;
    GUC_check_errdetail_string = NULL;
    GUC_check_errhint_string = NULL;
 
    if (!conf->check_hook(newval, extra, source))
    {
        ereport(elevel,
                (errcode(GUC_check_errcode_value),
                 GUC_check_errmsg_string ?
                 errmsg_internal("%s", GUC_check_errmsg_string) :
                 errmsg("invalid value for parameter \"%s\": %g",
                        conf->gen.name, *newval),
                 GUC_check_errdetail_string ?
                 errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                 GUC_check_errhint_string ?
                 errhint("%s", GUC_check_errhint_string) : 0));
        /* Flush any strings created in ErrorContext */
        FlushErrorState();
        return false;
    }
 
    return true;
}

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

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

◆ call_string_check_hook()

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

static

Definition at line 6929 of file guc.c.

{
    volatile bool result = true;
 
    /* Quick success if no hook */
    if (!conf->check_hook)
        return true;
 
    /*
     * If elevel is ERROR, or if the check_hook itself throws an elog
     * (undesirable, but not always avoidable), make sure we don't leak the
     * already-malloc'd newval string.
     */
    PG_TRY();
    {
        /* Reset variables that might be set by hook */
        GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
        GUC_check_errmsg_string = NULL;
        GUC_check_errdetail_string = NULL;
        GUC_check_errhint_string = NULL;
 
        if (!conf->check_hook(newval, extra, source))
        {
            ereport(elevel,
                    (errcode(GUC_check_errcode_value),
                     GUC_check_errmsg_string ?
                     errmsg_internal("%s", GUC_check_errmsg_string) :
                     errmsg("invalid value for parameter \"%s\": \"%s\"",
                            conf->gen.name, *newval ? *newval : ""),
                     GUC_check_errdetail_string ?
                     errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                     GUC_check_errhint_string ?
                     errhint("%s", GUC_check_errhint_string) : 0));
            /* Flush any strings created in ErrorContext */
            FlushErrorState();
            result = false;
        }
    }
    PG_CATCH();
    {
        guc_free(*newval);
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    return result;
}

References config_string::check_hook, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), config_generic::extra, FlushErrorState(), config_string::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, guc_free(), config_generic::name, newval, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, and source.

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

◆ can_skip_gucvar()

static bool can_skip_gucvar ( struct config_generic * gconf )

static

Definition at line 5837 of file guc.c.

{
    /*
     * We can skip GUCs that are guaranteed to have the same values in leaders
     * and workers.  (Note it is critical that the leader and worker have the
     * same idea of which GUCs fall into this category.  It's okay to consider
     * context and name for this purpose, since those are unchanging
     * properties of a GUC.)
     *
     * PGC_POSTMASTER variables always have the same value in every child of a
     * particular postmaster, so the worker will certainly have the right
     * value already.  Likewise, PGC_INTERNAL variables are set by special
     * mechanisms (if indeed they aren't compile-time constants).  So we may
     * always skip these.
     *
     * For all other GUCs, we skip if the GUC has its compiled-in default
     * value (i.e., source == PGC_S_DEFAULT).  On the leader side, this means
     * we don't send GUCs that have their default values, which typically
     * saves lots of work.  On the worker side, this means we don't need to
     * reset the GUC to default because it already has that value.  See
     * comments in RestoreGUCState for more info.
     */
    return gconf->context == PGC_POSTMASTER ||
        gconf->context == PGC_INTERNAL ||
        gconf->source == PGC_S_DEFAULT;
}

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

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

◆ check_GUC_name_for_parameter_acl()

void check_GUC_name_for_parameter_acl ( const char * name )

Definition at line 1412 of file guc.c.

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

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

Referenced by ParameterAclCreate().

◆ config_enum_get_options()

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

Definition at line 3078 of file guc.c.

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

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

Referenced by GetConfigOptionValues(), and parse_and_validate_value().

◆ config_enum_lookup_by_name()

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

Definition at line 3052 of file guc.c.

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

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

Referenced by parse_and_validate_value().

◆ config_enum_lookup_by_value()

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

Definition at line 3029 of file guc.c.

{
    const struct config_enum_entry *entry;
 
    for (entry = record->options; entry && entry->name; entry++)
    {
        if (entry->val == val)
            return entry->name;
    }
 
    elog(ERROR, "could not find enum option %d for %s",
         val, record->gen.name);
    return NULL;                /* silence compiler */
}

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

Referenced by call_enum_check_hook(), estimate_variable_size(), GetConfigOption(), GetConfigOptionResetString(), GetConfigOptionValues(), printMixedStruct(), serialize_variable(), and ShowGUCOption().

◆ convert_GUC_name_for_parameter_acl()

char * convert_GUC_name_for_parameter_acl ( const char * name )

Definition at line 1376 of file guc.c.

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

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

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

◆ convert_int_from_base_unit()

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

static

Definition at line 2735 of file guc.c.

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

References Assert(), GUC_UNIT_MEMORY, i, memory_unit_conversion_table, table, time_unit_conversion_table, and value.

Referenced by ShowGUCOption().

◆ convert_real_from_base_unit()

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

static

Definition at line 2777 of file guc.c.

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

References Assert(), GUC_UNIT_MEMORY, i, memory_unit_conversion_table, table, time_unit_conversion_table, and value.

Referenced by ShowGUCOption().

◆ convert_to_base_unit()

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

static

Definition at line 2677 of file guc.c.

{
    char        unitstr[MAX_UNIT_LEN + 1];
    int         unitlen;
    const unit_conversion *table;
    int         i;
 
    /* extract unit string to compare to table entries */
    unitlen = 0;
    while (*unit != '\0' && !isspace((unsigned char) *unit) &&
           unitlen < MAX_UNIT_LEN)
        unitstr[unitlen++] = *(unit++);
    unitstr[unitlen] = '\0';
    /* allow whitespace after unit */
    while (isspace((unsigned char) *unit))
        unit++;
    if (*unit != '\0')
        return false;           /* unit too long, or garbage after it */
 
    /* now search the appropriate table */
    if (base_unit & GUC_UNIT_MEMORY)
        table = memory_unit_conversion_table;
    else
        table = time_unit_conversion_table;
 
    for (i = 0; *table[i].unit; i++)
    {
        if (base_unit == table[i].base_unit &&
            strcmp(unitstr, table[i].unit) == 0)
        {
            double      cvalue = value * table[i].multiplier;
 
            /*
             * If the user gave a fractional value such as "30.1GB", round it
             * off to the nearest multiple of the next smaller unit, if there
             * is one.
             */
            if (*table[i + 1].unit &&
                base_unit == table[i + 1].base_unit)
                cvalue = rint(cvalue / table[i + 1].multiplier) *
                    table[i + 1].multiplier;
 
            *base_value = cvalue;
            return true;
        }
    }
    return false;
}

References GUC_UNIT_MEMORY, i, MAX_UNIT_LEN, memory_unit_conversion_table, table, time_unit_conversion_table, and value.

Referenced by parse_int(), and parse_real().

◆ define_custom_variable()

static void define_custom_variable ( struct config_generic * variable )

static

Definition at line 4943 of file guc.c.

{
    const char *name = variable->name;
    GUCHashEntry *hentry;
    struct config_string *pHolder;
 
    /* Check mapping between initial and default value */
    Assert(check_GUC_init(variable));
 
    /*
     * See if there's a placeholder by the same name.
     */
    hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                          &name,
                                          HASH_FIND,
                                          NULL);
    if (hentry == NULL)
    {
        /*
         * No placeholder to replace, so we can just add it ... but first,
         * make sure it's initialized to its default value.
         */
        InitializeOneGUCOption(variable);
        add_guc_variable(variable, ERROR);
        return;
    }
 
    /*
     * This better be a placeholder
     */
    if ((hentry->gucvar->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("attempt to redefine parameter \"%s\"", name)));
 
    Assert(hentry->gucvar->vartype == PGC_STRING);
    pHolder = (struct config_string *) hentry->gucvar;
 
    /*
     * First, set the variable to its default value.  We must do this even
     * though we intend to immediately apply a new value, since it's possible
     * that the new value is invalid.
     */
    InitializeOneGUCOption(variable);
 
    /*
     * Replace the placeholder in the hash table.  We aren't changing the name
     * (at least up to case-folding), so the hash value is unchanged.
     */
    hentry->gucname = name;
    hentry->gucvar = variable;
 
    /*
     * Remove the placeholder from any lists it's in, too.
     */
    RemoveGUCFromLists(&pHolder->gen);
 
    /*
     * Assign the string value(s) stored in the placeholder to the real
     * variable.  Essentially, we need to duplicate all the active and stacked
     * values, but with appropriate validation and datatype adjustment.
     *
     * If an assignment fails, we report a WARNING and keep going.  We don't
     * want to throw ERROR for bad values, because it'd bollix the add-on
     * module that's presumably halfway through getting loaded.  In such cases
     * the default or previous state will become active instead.
     */
 
    /* First, apply the reset value if any */
    if (pHolder->reset_val)
        (void) set_config_option_ext(name, pHolder->reset_val,
                                     pHolder->gen.reset_scontext,
                                     pHolder->gen.reset_source,
                                     pHolder->gen.reset_srole,
                                     GUC_ACTION_SET, true, WARNING, false);
    /* That should not have resulted in stacking anything */
    Assert(variable->stack == NULL);
 
    /* Now, apply current and stacked values, in the order they were stacked */
    reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
                           *(pHolder->variable),
                           pHolder->gen.scontext, pHolder->gen.source,
                           pHolder->gen.srole);
 
    /* Also copy over any saved source-location information */
    if (pHolder->gen.sourcefile)
        set_config_sourcefile(name, pHolder->gen.sourcefile,
                              pHolder->gen.sourceline);
 
    /* Now we can free the no-longer-referenced placeholder variable */
    free_placeholder(pHolder);
}

References add_guc_variable(), Assert(), ereport, errcode(), errmsg(), ERROR, config_generic::flags, free_placeholder(), config_string::gen, GUC_ACTION_SET, GUC_CUSTOM_PLACEHOLDER, guc_hashtab, GUCHashEntry::gucname, GUCHashEntry::gucvar, HASH_FIND, hash_search(), InitializeOneGUCOption(), name, variable::name, PGC_STRING, reapply_stacked_values(), RemoveGUCFromLists(), config_generic::reset_scontext, config_generic::reset_source, config_generic::reset_srole, config_string::reset_val, config_generic::scontext, set_config_option_ext(), set_config_sourcefile(), config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_generic::srole, config_generic::stack, config_string::variable, config_generic::vartype, and WARNING.

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

◆ DefineCustomBoolVariable()

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

Definition at line 5155 of file guc.c.

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

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

Referenced by _PG_init().

◆ DefineCustomEnumVariable()

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

Definition at line 5266 of file guc.c.

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

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

Referenced by _PG_init().

◆ DefineCustomIntVariable()

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

Definition at line 5181 of file guc.c.

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

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, name, PGC_INT, config_int::reset_val, config_int::show_hook, and config_int::variable.

Referenced by _PG_init().

◆ DefineCustomRealVariable()

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

Definition at line 5211 of file guc.c.

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

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, name, PGC_REAL, config_real::reset_val, config_real::show_hook, and config_real::variable.

Referenced by _PG_init().

◆ DefineCustomStringVariable()

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

Definition at line 5241 of file guc.c.

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

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

Referenced by _PG_init().

◆ discard_stack_value()

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

static

Definition at line 848 of file guc.c.

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

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

Referenced by AtEOXact_GUC(), and push_old_value().

◆ do_serialize()

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

static

Definition at line 6002 of file guc.c.

{
    va_list     vargs;
    int         n;
 
    if (*maxbytes <= 0)
        elog(ERROR, "not enough space to serialize GUC state");
 
    va_start(vargs, fmt);
    n = vsnprintf(*destptr, *maxbytes, fmt, vargs);
    va_end(vargs);
 
    if (n < 0)
    {
        /* Shouldn't happen. Better show errno description. */
        elog(ERROR, "vsnprintf failed: %m with format string \"%s\"", fmt);
    }
    if (n >= *maxbytes)
    {
        /* This shouldn't happen either, really. */
        elog(ERROR, "not enough space to serialize GUC state");
    }
 
    /* Shift the destptr ahead of the null terminator */
    *destptr += n + 1;
    *maxbytes -= n + 1;
}

References elog, ERROR, and vsnprintf.

Referenced by serialize_variable().

◆ do_serialize_binary()

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

static

Definition at line 6032 of file guc.c.

{
    if (valsize > *maxbytes)
        elog(ERROR, "not enough space to serialize GUC state");
 
    memcpy(*destptr, val, valsize);
    *destptr += valsize;
    *maxbytes -= valsize;
}

References elog, ERROR, and val.

Referenced by serialize_variable().

◆ estimate_variable_size()

static Size estimate_variable_size ( struct config_generic * gconf )

static

Definition at line 5871 of file guc.c.

{
    Size        size;
    Size        valsize = 0;
 
    /* Skippable GUCs consume zero space. */
    if (can_skip_gucvar(gconf))
        return 0;
 
    /* Name, plus trailing zero byte. */
    size = strlen(gconf->name) + 1;
 
    /* Get the maximum display length of the GUC value. */
    switch (gconf->vartype)
    {
        case PGC_BOOL:
            {
                valsize = 5;    /* max(strlen('true'), strlen('false')) */
            }
            break;
 
        case PGC_INT:
            {
                struct config_int *conf = (struct config_int *) gconf;
 
                /*
                 * Instead of getting the exact display length, use max
                 * length.  Also reduce the max length for typical ranges of
                 * small values.  Maximum value is 2147483647, i.e. 10 chars.
                 * Include one byte for sign.
                 */
                if (abs(*conf->variable) < 1000)
                    valsize = 3 + 1;
                else
                    valsize = 10 + 1;
            }
            break;
 
        case PGC_REAL:
            {
                /*
                 * We are going to print it with %e with REALTYPE_PRECISION
                 * fractional digits.  Account for sign, leading digit,
                 * decimal point, and exponent with up to 3 digits.  E.g.
                 * -3.99329042340000021e+110
                 */
                valsize = 1 + 1 + 1 + REALTYPE_PRECISION + 5;
            }
            break;
 
        case PGC_STRING:
            {
                struct config_string *conf = (struct config_string *) gconf;
 
                /*
                 * If the value is NULL, we transmit it as an empty string.
                 * Although this is not physically the same value, GUC
                 * generally treats a NULL the same as empty string.
                 */
                if (*conf->variable)
                    valsize = strlen(*conf->variable);
                else
                    valsize = 0;
            }
            break;
 
        case PGC_ENUM:
            {
                struct config_enum *conf = (struct config_enum *) gconf;
 
                valsize = strlen(config_enum_lookup_by_value(conf, *conf->variable));
            }
            break;
    }
 
    /* Allow space for terminating zero-byte for value */
    size = add_size(size, valsize + 1);
 
    if (gconf->sourcefile)
        size = add_size(size, strlen(gconf->sourcefile));
 
    /* Allow space for terminating zero-byte for sourcefile */
    size = add_size(size, 1);
 
    /* Include line whenever file is nonempty. */
    if (gconf->sourcefile && gconf->sourcefile[0])
        size = add_size(size, sizeof(gconf->sourceline));
 
    size = add_size(size, sizeof(gconf->source));
    size = add_size(size, sizeof(gconf->scontext));
    size = add_size(size, sizeof(gconf->srole));
 
    return size;
}

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

Referenced by EstimateGUCStateSpace().

◆ EstimateGUCStateSpace()

Size EstimateGUCStateSpace ( void )

Definition at line 5971 of file guc.c.

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

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

Referenced by InitializeParallelDSM().

◆ extra_field_used()

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

static

Definition at line 749 of file guc.c.

{
    GucStack   *stack;
 
    if (extra == gconf->extra)
        return true;
    switch (gconf->vartype)
    {
        case PGC_BOOL:
            if (extra == ((struct config_bool *) gconf)->reset_extra)
                return true;
            break;
        case PGC_INT:
            if (extra == ((struct config_int *) gconf)->reset_extra)
                return true;
            break;
        case PGC_REAL:
            if (extra == ((struct config_real *) gconf)->reset_extra)
                return true;
            break;
        case PGC_STRING:
            if (extra == ((struct config_string *) gconf)->reset_extra)
                return true;
            break;
        case PGC_ENUM:
            if (extra == ((struct config_enum *) gconf)->reset_extra)
                return true;
            break;
    }
    for (stack = gconf->stack; stack; stack = stack->prev)
    {
        if (extra == stack->prior.extra ||
            extra == stack->masked.extra)
            return true;
    }
 
    return false;
}

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

Referenced by set_config_with_handle(), and set_extra_field().

◆ find_option()

struct config_generic * find_option	(	const char *	name,
		bool	create_placeholders,
		bool	skip_errors,
		int	elevel
	)

Definition at line 1237 of file guc.c.

{
    GUCHashEntry *hentry;
    int         i;
 
    Assert(name);
 
    /* Look it up using the hash table. */
    hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                          &name,
                                          HASH_FIND,
                                          NULL);
    if (hentry)
        return hentry->gucvar;
 
    /*
     * See if the name is an obsolete name for a variable.  We assume that the
     * set of supported old names is short enough that a brute-force search is
     * the best way.
     */
    for (i = 0; map_old_guc_names[i] != NULL; i += 2)
    {
        if (guc_name_compare(name, map_old_guc_names[i]) == 0)
            return find_option(map_old_guc_names[i + 1], false,
                               skip_errors, elevel);
    }
 
    if (create_placeholders)
    {
        /*
         * Check if the name is valid, and if so, add a placeholder.
         */
        if (assignable_custom_variable_name(name, skip_errors, elevel))
            return add_placeholder_variable(name, elevel);
        else
            return NULL;        /* error message, if any, already emitted */
    }
 
    /* Unknown name and we're not supposed to make a placeholder */
    if (!skip_errors)
        ereport(elevel,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("unrecognized configuration parameter \"%s\"",
                        name)));
    return NULL;
}

References add_placeholder_variable(), Assert(), assignable_custom_variable_name(), ereport, errcode(), errmsg(), find_option(), guc_hashtab, guc_name_compare(), GUCHashEntry::gucvar, HASH_FIND, hash_search(), i, map_old_guc_names, and name.

Referenced by AlterSystemSetConfigFile(), check_GUC_name_for_parameter_acl(), find_option(), flatten_set_variable_args(), get_config_handle(), GetConfigOption(), GetConfigOptionByName(), GetConfigOptionFlags(), GetConfigOptionResetString(), GUCArrayAdd(), GUCArrayDelete(), InitializeWalConsistencyChecking(), pg_settings_get_flags(), ProcessConfigFileInternal(), SelectConfigFiles(), set_config_sourcefile(), set_config_with_handle(), and validate_option_array_item().

◆ free_placeholder()

static void free_placeholder ( struct config_string * pHolder )

static

Definition at line 5140 of file guc.c.

{
    /* Placeholders are always STRING type, so free their values */
    Assert(pHolder->gen.vartype == PGC_STRING);
    set_string_field(pHolder, pHolder->variable, NULL);
    set_string_field(pHolder, &pHolder->reset_val, NULL);
 
    guc_free(unconstify(char *, pHolder->gen.name));
    guc_free(pHolder);
}

References Assert(), config_string::gen, guc_free(), config_generic::name, PGC_STRING, config_string::reset_val, set_string_field(), unconstify, config_string::variable, and config_generic::vartype.

Referenced by define_custom_variable(), and MarkGUCPrefixReserved().

◆ get_config_handle()

config_handle * get_config_handle ( const char * name )

Definition at line 4290 of file guc.c.

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

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

Referenced by fmgr_security_definer().

◆ get_config_unit_name()

const char * get_config_unit_name ( int flags )

Definition at line 2820 of file guc.c.

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

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

Referenced by GetConfigOptionValues(), and parse_and_validate_value().

◆ get_explain_guc_options()

struct config_generic ** get_explain_guc_options ( int * num )

Definition at line 5354 of file guc.c.

{
    struct config_generic **result;
    dlist_iter  iter;
 
    *num = 0;
 
    /*
     * While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
     * it doesn't seem worth dynamically resizing this array.
     */
    result = palloc(sizeof(struct config_generic *) * hash_get_num_entries(guc_hashtab));
 
    /* We need only consider GUCs with source not PGC_S_DEFAULT */
    dlist_foreach(iter, &guc_nondef_list)
    {
        struct config_generic *conf = dlist_container(struct config_generic,
                                                      nondef_link, iter.cur);
        bool        modified;
 
        /* return only parameters marked for inclusion in explain */
        if (!(conf->flags & GUC_EXPLAIN))
            continue;
 
        /* return only options visible to the current user */
        if (!ConfigOptionIsVisible(conf))
            continue;
 
        /* return only options that are different from their boot values */
        modified = false;
 
        switch (conf->vartype)
        {
            case PGC_BOOL:
                {
                    struct config_bool *lconf = (struct config_bool *) conf;
 
                    modified = (lconf->boot_val != *(lconf->variable));
                }
                break;
 
            case PGC_INT:
                {
                    struct config_int *lconf = (struct config_int *) conf;
 
                    modified = (lconf->boot_val != *(lconf->variable));
                }
                break;
 
            case PGC_REAL:
                {
                    struct config_real *lconf = (struct config_real *) conf;
 
                    modified = (lconf->boot_val != *(lconf->variable));
                }
                break;
 
            case PGC_STRING:
                {
                    struct config_string *lconf = (struct config_string *) conf;
 
                    if (lconf->boot_val == NULL &&
                        *lconf->variable == NULL)
                        modified = false;
                    else if (lconf->boot_val == NULL ||
                             *lconf->variable == NULL)
                        modified = true;
                    else
                        modified = (strcmp(lconf->boot_val, *(lconf->variable)) != 0);
                }
                break;
 
            case PGC_ENUM:
                {
                    struct config_enum *lconf = (struct config_enum *) conf;
 
                    modified = (lconf->boot_val != *(lconf->variable));
                }
                break;
 
            default:
                elog(ERROR, "unexpected GUC type: %d", conf->vartype);
        }
 
        if (!modified)
            continue;
 
        /* OK, report it */
        result[*num] = conf;
        *num = *num + 1;
    }
 
    return result;
}

References config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, ConfigOptionIsVisible(), dlist_iter::cur, dlist_container, dlist_foreach, elog, ERROR, config_generic::flags, GUC_EXPLAIN, guc_hashtab, guc_nondef_list, hash_get_num_entries(), config_generic::nondef_link, palloc(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by ExplainPrintSettings().

◆ get_guc_variables()

struct config_generic ** get_guc_variables ( int * num_vars )

Definition at line 874 of file guc.c.

{
    struct config_generic **result;
    HASH_SEQ_STATUS status;
    GUCHashEntry *hentry;
    int         i;
 
    *num_vars = hash_get_num_entries(guc_hashtab);
    result = palloc(sizeof(struct config_generic *) * *num_vars);
 
    /* Extract pointers from the hash table */
    i = 0;
    hash_seq_init(&status, guc_hashtab);
    while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
        result[i++] = hentry->gucvar;
    Assert(i == *num_vars);
 
    /* Sort by name */
    qsort(result, *num_vars,
          sizeof(struct config_generic *), guc_var_compare);
 
    return result;
}

References Assert(), guc_hashtab, guc_var_compare(), GUCHashEntry::gucvar, hash_get_num_entries(), hash_seq_init(), hash_seq_search(), i, palloc(), qsort, and config_generic::status.

Referenced by GucInfoMain(), show_all_settings(), and ShowAllGUCConfig().

◆ GetConfigOption()

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

Definition at line 4361 of file guc.c.

{
    struct config_generic *record;
    static char buffer[256];
 
    record = find_option(name, false, missing_ok, ERROR);
    if (record == NULL)
        return NULL;
    if (restrict_privileged &&
        !ConfigOptionIsVisible(record))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to examine \"%s\"", name),
                 errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
                           "pg_read_all_settings")));
 
    switch (record->vartype)
    {
        case PGC_BOOL:
            return *((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 ?
                *((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;
}

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

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

◆ GetConfigOptionByName()

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

Definition at line 5455 of file guc.c.

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

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

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

◆ GetConfigOptionFlags()

int GetConfigOptionFlags	(	const char *	name,
		bool	missing_ok
	)

Definition at line 4458 of file guc.c.

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

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

Referenced by pg_get_functiondef(), and PostmasterMain().

◆ GetConfigOptionResetString()

const char * GetConfigOptionResetString ( const char * name )

Definition at line 4411 of file guc.c.

{
    struct config_generic *record;
    static char buffer[256];
 
    record = find_option(name, false, false, ERROR);
    Assert(record != NULL);
    if (!ConfigOptionIsVisible(record))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to examine \"%s\"", name),
                 errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
                           "pg_read_all_settings")));
 
    switch (record->vartype)
    {
        case PGC_BOOL:
            return ((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 ?
                ((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;
}

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

Referenced by check_datestyle().

◆ GUC_check_errcode()

void GUC_check_errcode ( int sqlerrcode )

Definition at line 6814 of file guc.c.

{
    GUC_check_errcode_value = sqlerrcode;
}

References GUC_check_errcode_value.

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

◆ guc_free()

void guc_free ( void * ptr )

Definition at line 691 of file guc.c.

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

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

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

◆ guc_malloc()

void * guc_malloc	(	int	elevel,
		size_t	size
	)

Definition at line 640 of file guc.c.

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

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

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

◆ guc_name_compare()

int guc_name_compare	(	const char *	namea,
		const char *	nameb
	)

Definition at line 1302 of file guc.c.

{
    /*
     * The temptation to use strcasecmp() here must be resisted, because the
     * hash mapping has to remain stable across setlocale() calls. So, build
     * our own with a simple ASCII-only downcasing.
     */
    while (*namea && *nameb)
    {
        char        cha = *namea++;
        char        chb = *nameb++;
 
        if (cha >= 'A' && cha <= 'Z')
            cha += 'a' - 'A';
        if (chb >= 'A' && chb <= 'Z')
            chb += 'a' - 'A';
        if (cha != chb)
            return cha - chb;
    }
    if (*namea)
        return 1;               /* a is longer */
    if (*nameb)
        return -1;              /* b is longer */
    return 0;
}

Referenced by convert_GUC_name_for_parameter_acl(), find_option(), GetPGVariable(), GetPGVariableResultDesc(), guc_name_match(), guc_var_compare(), ParseConfigFp(), and replace_auto_config_value().

◆ guc_name_hash()

static uint32 guc_name_hash	(	const void *	key,
		Size	keysize
	)

static

Definition at line 1332 of file guc.c.

{
    uint32      result = 0;
    const char *name = *(const char *const *) key;
 
    while (*name)
    {
        char        ch = *name++;
 
        /* Case-fold in the same way as guc_name_compare */
        if (ch >= 'A' && ch <= 'Z')
            ch += 'a' - 'A';
 
        /* Merge into hash ... not very bright, but it needn't be */
        result = pg_rotate_left32(result, 5);
        result ^= (uint32) ch;
    }
    return result;
}

References sort-test::key, name, and pg_rotate_left32().

Referenced by build_guc_variables().

◆ guc_name_match()

static int guc_name_match	(	const void *	key1,
		const void *	key2,
		Size	keysize
	)

static

Definition at line 1356 of file guc.c.

{
    const char *name1 = *(const char *const *) key1;
    const char *name2 = *(const char *const *) key2;
 
    return guc_name_compare(name1, name2);
}

References guc_name_compare().

Referenced by build_guc_variables().

◆ guc_realloc()

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

Definition at line 654 of file guc.c.

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

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

◆ guc_restore_error_context_callback()

static void guc_restore_error_context_callback ( void * arg )

static

Definition at line 6194 of file guc.c.

{
    char      **error_context_name_and_value = (char **) arg;
 
    if (error_context_name_and_value)
        errcontext("while setting parameter \"%s\" to \"%s\"",
                   error_context_name_and_value[0],
                   error_context_name_and_value[1]);
}

References arg, and errcontext.

Referenced by RestoreGUCState().

◆ guc_strdup()

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

Definition at line 679 of file guc.c.

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

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

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

◆ guc_var_compare()

static int guc_var_compare	(	const void *	a,
		const void *	b
	)

static

Definition at line 1290 of file guc.c.

{
    const char *namea = **(const char **const *) a;
    const char *nameb = **(const char **const *) b;
 
    return guc_name_compare(namea, nameb);
}

References a, b, and guc_name_compare().

Referenced by get_guc_variables().

◆ GUCArrayAdd()

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

Definition at line 6511 of file guc.c.

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

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

Referenced by AlterSetting(), and update_proconfig_value().

◆ GUCArrayDelete()

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

Definition at line 6589 of file guc.c.

{
    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, true, WARNING);
    if (record)
        name = record->name;
 
    /* if array is currently null, then surely nothing to delete */
    if (!array)
        return NULL;
 
    newarray = NULL;
    index = 1;
 
    for (i = 1; i <= ARR_DIMS(array)[0]; i++)
    {
        Datum       d;
        char       *val;
        bool        isnull;
 
        d = array_ref(array, 1, &i,
                      -1 /* varlenarray */ ,
                      -1 /* TEXT's typlen */ ,
                      false /* TEXT's typbyval */ ,
                      TYPALIGN_INT /* TEXT's typalign */ ,
                      &isnull);
        if (isnull)
            continue;
        val = TextDatumGetCString(d);
 
        /* ignore entry if it's what we want to delete */
        if (strncmp(val, name, strlen(name)) == 0
            && val[strlen(name)] == '=')
            continue;
 
        /* else add it to the output array */
        if (newarray)
            newarray = array_set(newarray, 1, &index,
                                 d,
                                 false,
                                 -1 /* varlenarray */ ,
                                 -1 /* TEXT's typlen */ ,
                                 false /* TEXT's typbyval */ ,
                                 TYPALIGN_INT /* TEXT's typalign */ );
        else
            newarray = construct_array_builtin(&d, 1, TEXTOID);
 
        index++;
    }
 
    return newarray;
}

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

Referenced by AlterSetting(), and update_proconfig_value().

◆ GUCArrayReset()

ArrayType * GUCArrayReset ( ArrayType * array )

Definition at line 6659 of file guc.c.

{
    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 */ ,
                      TYPALIGN_INT /* TEXT's typalign */ ,
                      &isnull);
        if (isnull)
            continue;
        val = TextDatumGetCString(d);
 
        eqsgn = strchr(val, '=');
        *eqsgn = '\0';
 
        /* skip if we have permission to delete it */
        if (validate_option_array_item(val, NULL, true))
            continue;
 
        /* else add it to the output array */
        if (newarray)
            newarray = array_set(newarray, 1, &index,
                                 d,
                                 false,
                                 -1 /* varlenarray */ ,
                                 -1 /* TEXT's typlen */ ,
                                 false /* TEXT's typbyval */ ,
                                 TYPALIGN_INT /* TEXT's typalign */ );
        else
            newarray = construct_array_builtin(&d, 1, TEXTOID);
 
        index++;
        pfree(val);
    }
 
    return newarray;
}

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

Referenced by AlterSetting().

◆ init_custom_variable()

static struct config_generic * init_custom_variable	(	const char *	name,
		const char *	short_desc,
		const char *	long_desc,
		GucContext	context,
		int	flags,
		enum config_type	type,
		size_t	sz
	)

static

Definition at line 4882 of file guc.c.

{
    struct config_generic *gen;
 
    /*
     * Only allow custom PGC_POSTMASTER variables to be created during shared
     * library preload; any later than that, we can't ensure that the value
     * doesn't change after startup.  This is a fatal elog if it happens; just
     * erroring out isn't safe because we don't know what the calling loadable
     * module might already have hooked into.
     */
    if (context == PGC_POSTMASTER &&
        !process_shared_preload_libraries_in_progress)
        elog(FATAL, "cannot create PGC_POSTMASTER variables after startup");
 
    /*
     * We can't support custom GUC_LIST_QUOTE variables, because the wrong
     * things would happen if such a variable were set or pg_dump'd when the
     * defining extension isn't loaded.  Again, treat this as fatal because
     * the loadable module may be partly initialized already.
     */
    if (flags & GUC_LIST_QUOTE)
        elog(FATAL, "extensions cannot define GUC_LIST_QUOTE variables");
 
    /*
     * Before pljava commit 398f3b876ed402bdaec8bc804f29e2be95c75139
     * (2015-12-15), two of that module's PGC_USERSET variables facilitated
     * trivial escalation to superuser privileges.  Restrict the variables to
     * protect sites that have yet to upgrade pljava.
     */
    if (context == PGC_USERSET &&
        (strcmp(name, "pljava.classpath") == 0 ||
         strcmp(name, "pljava.vmoptions") == 0))
        context = PGC_SUSET;
 
    /* As above, an OOM here is FATAL */
    gen = (struct config_generic *) guc_malloc(FATAL, sz);
    memset(gen, 0, sz);
 
    gen->name = guc_strdup(FATAL, name);
    gen->context = context;
    gen->group = CUSTOM_OPTIONS;
    gen->short_desc = short_desc;
    gen->long_desc = long_desc;
    gen->flags = flags;
    gen->vartype = type;
 
    return gen;
}

References config_generic::context, CUSTOM_OPTIONS, elog, FATAL, config_generic::flags, config_generic::group, GUC_LIST_QUOTE, guc_malloc(), guc_strdup(), config_generic::long_desc, name, config_generic::name, PGC_POSTMASTER, PGC_SUSET, PGC_USERSET, process_shared_preload_libraries_in_progress, config_generic::short_desc, type, and config_generic::vartype.

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

◆ InitializeGUCOptions()

void InitializeGUCOptions ( void )

Definition at line 1532 of file guc.c.

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

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

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

◆ InitializeGUCOptionsFromEnvironment()

static void InitializeGUCOptionsFromEnvironment ( void )

static

Definition at line 1591 of file guc.c.

{
    char       *env;
    ssize_t     stack_rlimit;
 
    env = getenv("PGPORT");
    if (env != NULL)
        SetConfigOption("port", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
 
    env = getenv("PGDATESTYLE");
    if (env != NULL)
        SetConfigOption("datestyle", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
 
    env = getenv("PGCLIENTENCODING");
    if (env != NULL)
        SetConfigOption("client_encoding", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
 
    /*
     * rlimit isn't exactly an "environment variable", but it behaves about
     * the same.  If we can identify the platform stack depth rlimit, increase
     * default stack depth setting up to whatever is safe (but at most 2MB).
     * Report the value's source as PGC_S_DYNAMIC_DEFAULT if it's 2MB, or as
     * PGC_S_ENV_VAR if it's reflecting the rlimit limit.
     */
    stack_rlimit = get_stack_depth_rlimit();
    if (stack_rlimit > 0)
    {
        ssize_t     new_limit = (stack_rlimit - STACK_DEPTH_SLOP) / 1024;
 
        if (new_limit > 100)
        {
            GucSource   source;
            char        limbuf[16];
 
            if (new_limit < 2048)
                source = PGC_S_ENV_VAR;
            else
            {
                new_limit = 2048;
                source = PGC_S_DYNAMIC_DEFAULT;
            }
            snprintf(limbuf, sizeof(limbuf), "%d", (int) new_limit);
            SetConfigOption("max_stack_depth", limbuf,
                            PGC_POSTMASTER, source);
        }
    }
}

References get_stack_depth_rlimit(), PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_ENV_VAR, SetConfigOption(), snprintf, source, and STACK_DEPTH_SLOP.

Referenced by InitializeGUCOptions(), and ProcessConfigFileInternal().

◆ InitializeOneGUCOption()

static void InitializeOneGUCOption ( struct config_generic * gconf )

static

Definition at line 1646 of file guc.c.

{
    gconf->status = 0;
    gconf->source = PGC_S_DEFAULT;
    gconf->reset_source = PGC_S_DEFAULT;
    gconf->scontext = PGC_INTERNAL;
    gconf->reset_scontext = PGC_INTERNAL;
    gconf->srole = BOOTSTRAP_SUPERUSERID;
    gconf->reset_srole = BOOTSTRAP_SUPERUSERID;
    gconf->stack = NULL;
    gconf->extra = NULL;
    gconf->last_reported = NULL;
    gconf->sourcefile = NULL;
    gconf->sourceline = 0;
 
    switch (gconf->vartype)
    {
        case PGC_BOOL:
            {
                struct config_bool *conf = (struct config_bool *) gconf;
                bool        newval = conf->boot_val;
                void       *extra = NULL;
 
                if (!call_bool_check_hook(conf, &newval, &extra,
                                          PGC_S_DEFAULT, LOG))
                    elog(FATAL, "failed to initialize %s to %d",
                         conf->gen.name, (int) newval);
                if (conf->assign_hook)
                    conf->assign_hook(newval, extra);
                *conf->variable = conf->reset_val = newval;
                conf->gen.extra = conf->reset_extra = extra;
                break;
            }
        case PGC_INT:
            {
                struct config_int *conf = (struct config_int *) gconf;
                int         newval = conf->boot_val;
                void       *extra = NULL;
 
                Assert(newval >= conf->min);
                Assert(newval <= conf->max);
                if (!call_int_check_hook(conf, &newval, &extra,
                                         PGC_S_DEFAULT, LOG))
                    elog(FATAL, "failed to initialize %s to %d",
                         conf->gen.name, newval);
                if (conf->assign_hook)
                    conf->assign_hook(newval, extra);
                *conf->variable = conf->reset_val = newval;
                conf->gen.extra = conf->reset_extra = extra;
                break;
            }
        case PGC_REAL:
            {
                struct config_real *conf = (struct config_real *) gconf;
                double      newval = conf->boot_val;
                void       *extra = NULL;
 
                Assert(newval >= conf->min);
                Assert(newval <= conf->max);
                if (!call_real_check_hook(conf, &newval, &extra,
                                          PGC_S_DEFAULT, LOG))
                    elog(FATAL, "failed to initialize %s to %g",
                         conf->gen.name, newval);
                if (conf->assign_hook)
                    conf->assign_hook(newval, extra);
                *conf->variable = conf->reset_val = newval;
                conf->gen.extra = conf->reset_extra = extra;
                break;
            }
        case PGC_STRING:
            {
                struct config_string *conf = (struct config_string *) gconf;
                char       *newval;
                void       *extra = NULL;
 
                /* non-NULL boot_val must always get strdup'd */
                if (conf->boot_val != NULL)
                    newval = guc_strdup(FATAL, conf->boot_val);
                else
                    newval = NULL;
 
                if (!call_string_check_hook(conf, &newval, &extra,
                                            PGC_S_DEFAULT, LOG))
                    elog(FATAL, "failed to initialize %s to \"%s\"",
                         conf->gen.name, newval ? newval : "");
                if (conf->assign_hook)
                    conf->assign_hook(newval, extra);
                *conf->variable = conf->reset_val = newval;
                conf->gen.extra = conf->reset_extra = extra;
                break;
            }
        case PGC_ENUM:
            {
                struct config_enum *conf = (struct config_enum *) gconf;
                int         newval = conf->boot_val;
                void       *extra = NULL;
 
                if (!call_enum_check_hook(conf, &newval, &extra,
                                          PGC_S_DEFAULT, LOG))
                    elog(FATAL, "failed to initialize %s to %d",
                         conf->gen.name, newval);
                if (conf->assign_hook)
                    conf->assign_hook(newval, extra);
                *conf->variable = conf->reset_val = newval;
                conf->gen.extra = conf->reset_extra = extra;
                break;
            }
    }
}

References Assert(), config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), elog, config_generic::extra, FATAL, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, guc_strdup(), config_generic::last_reported, LOG, config_int::max, config_real::max, config_int::min, config_real::min, config_generic::name, newval, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_INTERNAL, PGC_REAL, PGC_S_DEFAULT, PGC_STRING, config_bool::reset_extra, config_int::reset_extra, config_real::reset_extra, config_string::reset_extra, config_enum::reset_extra, config_generic::reset_scontext, config_generic::reset_source, config_generic::reset_srole, config_bool::reset_val, config_int::reset_val, config_real::reset_val, config_string::reset_val, config_enum::reset_val, config_generic::scontext, config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_generic::srole, config_generic::stack, config_generic::status, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by define_custom_variable(), InitializeGUCOptions(), and RestoreGUCState().

◆ MarkGUCPrefixReserved()

void MarkGUCPrefixReserved ( const char * className )

Definition at line 5302 of file guc.c.

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

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

Referenced by _PG_init().

◆ NewGUCNestLevel()

int NewGUCNestLevel ( void )

Definition at line 2241 of file guc.c.

{
    return ++GUCNestLevel;
}

References GUCNestLevel.

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

◆ parse_and_validate_value()

static bool parse_and_validate_value	(	struct config_generic *	record,
		const char *	value,
		GucSource	source,
		int	elevel,
		union config_var_val *	newval,
		void **	newextra
	)

static

Definition at line 3135 of file guc.c.

{
    switch (record->vartype)
    {
        case PGC_BOOL:
            {
                struct config_bool *conf = (struct config_bool *) record;
 
                if (!parse_bool(value, &newval->boolval))
                {
                    ereport(elevel,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("parameter \"%s\" requires a Boolean value",
                                    conf->gen.name)));
                    return false;
                }
 
                if (!call_bool_check_hook(conf, &newval->boolval, newextra,
                                          source, elevel))
                    return false;
            }
            break;
        case PGC_INT:
            {
                struct config_int *conf = (struct config_int *) record;
                const char *hintmsg;
 
                if (!parse_int(value, &newval->intval,
                               conf->gen.flags, &hintmsg))
                {
                    ereport(elevel,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("invalid value for parameter \"%s\": \"%s\"",
                                    conf->gen.name, value),
                             hintmsg ? errhint("%s", _(hintmsg)) : 0));
                    return false;
                }
 
                if (newval->intval < conf->min || newval->intval > conf->max)
                {
                    const char *unit = get_config_unit_name(conf->gen.flags);
                    const char *unitspace;
 
                    if (unit)
                        unitspace = " ";
                    else
                        unit = unitspace = "";
 
                    ereport(elevel,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("%d%s%s is outside the valid range for parameter \"%s\" (%d%s%s .. %d%s%s)",
                                    newval->intval, unitspace, unit,
                                    conf->gen.name,
                                    conf->min, unitspace, unit,
                                    conf->max, unitspace, unit)));
                    return false;
                }
 
                if (!call_int_check_hook(conf, &newval->intval, newextra,
                                         source, elevel))
                    return false;
            }
            break;
        case PGC_REAL:
            {
                struct config_real *conf = (struct config_real *) record;
                const char *hintmsg;
 
                if (!parse_real(value, &newval->realval,
                                conf->gen.flags, &hintmsg))
                {
                    ereport(elevel,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("invalid value for parameter \"%s\": \"%s\"",
                                    conf->gen.name, value),
                             hintmsg ? errhint("%s", _(hintmsg)) : 0));
                    return false;
                }
 
                if (newval->realval < conf->min || newval->realval > conf->max)
                {
                    const char *unit = get_config_unit_name(conf->gen.flags);
                    const char *unitspace;
 
                    if (unit)
                        unitspace = " ";
                    else
                        unit = unitspace = "";
 
                    ereport(elevel,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("%g%s%s is outside the valid range for parameter \"%s\" (%g%s%s .. %g%s%s)",
                                    newval->realval, unitspace, unit,
                                    conf->gen.name,
                                    conf->min, unitspace, unit,
                                    conf->max, unitspace, unit)));
                    return false;
                }
 
                if (!call_real_check_hook(conf, &newval->realval, newextra,
                                          source, elevel))
                    return false;
            }
            break;
        case PGC_STRING:
            {
                struct config_string *conf = (struct config_string *) record;
 
                /*
                 * The value passed by the caller could be transient, so we
                 * always strdup it.
                 */
                newval->stringval = guc_strdup(elevel, value);
                if (newval->stringval == NULL)
                    return false;
 
                /*
                 * The only built-in "parsing" check we have is to apply
                 * truncation if GUC_IS_NAME.
                 */
                if (conf->gen.flags & GUC_IS_NAME)
                    truncate_identifier(newval->stringval,
                                        strlen(newval->stringval),
                                        true);
 
                if (!call_string_check_hook(conf, &newval->stringval, newextra,
                                            source, elevel))
                {
                    guc_free(newval->stringval);
                    newval->stringval = NULL;
                    return false;
                }
            }
            break;
        case PGC_ENUM:
            {
                struct config_enum *conf = (struct config_enum *) record;
 
                if (!config_enum_lookup_by_name(conf, value, &newval->enumval))
                {
                    char       *hintmsg;
 
                    hintmsg = config_enum_get_options(conf,
                                                      "Available values: ",
                                                      ".", ", ");
 
                    ereport(elevel,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("invalid value for parameter \"%s\": \"%s\"",
                                    conf->gen.name, value),
                             hintmsg ? errhint("%s", _(hintmsg)) : 0));
 
                    if (hintmsg)
                        pfree(hintmsg);
                    return false;
                }
 
                if (!call_enum_check_hook(conf, &newval->enumval, newextra,
                                          source, elevel))
                    return false;
            }
            break;
    }
 
    return true;
}

References _, call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), config_enum_get_options(), config_enum_lookup_by_name(), ereport, errcode(), errhint(), errmsg(), config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, get_config_unit_name(), guc_free(), GUC_IS_NAME, guc_strdup(), config_int::max, config_real::max, config_int::min, config_real::min, config_generic::name, newval, parse_bool(), parse_int(), parse_real(), pfree(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, source, truncate_identifier(), value, and config_generic::vartype.

Referenced by AlterSystemSetConfigFile(), and set_config_with_handle().

◆ parse_int()

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

Definition at line 2877 of file guc.c.

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

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

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

◆ parse_real()

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

Definition at line 2967 of file guc.c.

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

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

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

◆ ParseLongOption()

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

Definition at line 6385 of file guc.c.

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

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

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

◆ pg_timezone_abbrev_initialize()

static void pg_timezone_abbrev_initialize ( void )

static

Definition at line 1998 of file guc.c.

{
    SetConfigOption("timezone_abbreviations", "Default",
                    PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT);
}

References PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, and SetConfigOption().

Referenced by ProcessConfigFileInternal(), and SelectConfigFiles().

◆ ProcessConfigFileInternal()

ConfigVariable * ProcessConfigFileInternal	(	GucContext	context,
		bool	applySettings,
		int	elevel
	)

Definition at line 284 of file guc.c.

{
    bool        error = false;
    bool        applying = false;
    const char *ConfFileWithError;
    ConfigVariable *item,
               *head,
               *tail;
    HASH_SEQ_STATUS status;
    GUCHashEntry *hentry;
 
    /* Parse the main config file into a list of option names and values */
    ConfFileWithError = ConfigFileName;
    head = tail = NULL;
 
    if (!ParseConfigFile(ConfigFileName, true,
                         NULL, 0, CONF_FILE_START_DEPTH, elevel,
                         &head, &tail))
    {
        /* Syntax error(s) detected in the file, so bail out */
        error = true;
        goto bail_out;
    }
 
    /*
     * Parse the PG_AUTOCONF_FILENAME file, if present, after the main file to
     * replace any parameters set by ALTER SYSTEM command.  Because this file
     * is in the data directory, we can't read it until the DataDir has been
     * set.
     */
    if (DataDir)
    {
        if (!ParseConfigFile(PG_AUTOCONF_FILENAME, false,
                             NULL, 0, CONF_FILE_START_DEPTH, elevel,
                             &head, &tail))
        {
            /* Syntax error(s) detected in the file, so bail out */
            error = true;
            ConfFileWithError = PG_AUTOCONF_FILENAME;
            goto bail_out;
        }
    }
    else
    {
        /*
         * If DataDir is not set, the PG_AUTOCONF_FILENAME file cannot be
         * read.  In this case, we don't want to accept any settings but
         * data_directory from postgresql.conf, because they might be
         * overwritten with settings in the PG_AUTOCONF_FILENAME file which
         * will be read later. OTOH, since data_directory isn't allowed in the
         * PG_AUTOCONF_FILENAME file, it will never be overwritten later.
         */
        ConfigVariable *newlist = NULL;
 
        /*
         * Prune all items except the last "data_directory" from the list.
         */
        for (item = head; item; item = item->next)
        {
            if (!item->ignore &&
                strcmp(item->name, "data_directory") == 0)
                newlist = item;
        }
 
        if (newlist)
            newlist->next = NULL;
        head = tail = newlist;
 
        /*
         * Quick exit if data_directory is not present in file.
         *
         * We need not do any further processing, in particular we don't set
         * PgReloadTime; that will be set soon by subsequent full loading of
         * the config file.
         */
        if (head == NULL)
            goto bail_out;
    }
 
    /*
     * Mark all extant GUC variables as not present in the config file. We
     * need this so that we can tell below which ones have been removed from
     * the file since we last processed it.
     */
    hash_seq_init(&status, guc_hashtab);
    while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
    {
        struct config_generic *gconf = hentry->gucvar;
 
        gconf->status &= ~GUC_IS_IN_FILE;
    }
 
    /*
     * Check if all the supplied option names are valid, as an additional
     * quasi-syntactic check on the validity of the config file.  It is
     * important that the postmaster and all backends agree on the results of
     * this phase, else we will have strange inconsistencies about which
     * processes accept a config file update and which don't.  Hence, unknown
     * custom variable names have to be accepted without complaint.  For the
     * same reason, we don't attempt to validate the options' values here.
     *
     * In addition, the GUC_IS_IN_FILE flag is set on each existing GUC
     * variable mentioned in the file; and we detect duplicate entries in the
     * file and mark the earlier occurrences as ignorable.
     */
    for (item = head; item; item = item->next)
    {
        struct config_generic *record;
 
        /* Ignore anything already marked as ignorable */
        if (item->ignore)
            continue;
 
        /*
         * Try to find the variable; but do not create a custom placeholder if
         * it's not there already.
         */
        record = find_option(item->name, false, true, elevel);
 
        if (record)
        {
            /* If it's already marked, then this is a duplicate entry */
            if (record->status & GUC_IS_IN_FILE)
            {
                /*
                 * Mark the earlier occurrence(s) as dead/ignorable.  We could
                 * avoid the O(N^2) behavior here with some additional state,
                 * but it seems unlikely to be worth the trouble.
                 */
                ConfigVariable *pitem;
 
                for (pitem = head; pitem != item; pitem = pitem->next)
                {
                    if (!pitem->ignore &&
                        strcmp(pitem->name, item->name) == 0)
                        pitem->ignore = true;
                }
            }
            /* Now mark it as present in file */
            record->status |= GUC_IS_IN_FILE;
        }
        else if (!valid_custom_variable_name(item->name))
        {
            /* Invalid non-custom variable, so complain */
            ereport(elevel,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("unrecognized configuration parameter \"%s\" in file \"%s\" line %d",
                            item->name,
                            item->filename, item->sourceline)));
            item->errmsg = pstrdup("unrecognized configuration parameter");
            error = true;
            ConfFileWithError = item->filename;
        }
    }
 
    /*
     * If we've detected any errors so far, we don't want to risk applying any
     * changes.
     */
    if (error)
        goto bail_out;
 
    /* Otherwise, set flag that we're beginning to apply changes */
    applying = true;
 
    /*
     * Check for variables having been removed from the config file, and
     * revert their reset values (and perhaps also effective values) to the
     * boot-time defaults.  If such a variable can't be changed after startup,
     * report that and continue.
     */
    hash_seq_init(&status, guc_hashtab);
    while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
    {
        struct config_generic *gconf = hentry->gucvar;
        GucStack   *stack;
 
        if (gconf->reset_source != PGC_S_FILE ||
            (gconf->status & GUC_IS_IN_FILE))
            continue;
        if (gconf->context < PGC_SIGHUP)
        {
            /* The removal can't be effective without a restart */
            gconf->status |= GUC_PENDING_RESTART;
            ereport(elevel,
                    (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                     errmsg("parameter \"%s\" cannot be changed without restarting the server",
                            gconf->name)));
            record_config_file_error(psprintf("parameter \"%s\" cannot be changed without restarting the server",
                                              gconf->name),
                                     NULL, 0,
                                     &head, &tail);
            error = true;
            continue;
        }
 
        /* No more to do if we're just doing show_all_file_settings() */
        if (!applySettings)
            continue;
 
        /*
         * Reset any "file" sources to "default", else set_config_option will
         * not override those settings.
         */
        if (gconf->reset_source == PGC_S_FILE)
            gconf->reset_source = PGC_S_DEFAULT;
        if (gconf->source == PGC_S_FILE)
            set_guc_source(gconf, PGC_S_DEFAULT);
        for (stack = gconf->stack; stack; stack = stack->prev)
        {
            if (stack->source == PGC_S_FILE)
                stack->source = PGC_S_DEFAULT;
        }
 
        /* Now we can re-apply the wired-in default (i.e., the boot_val) */
        if (set_config_option(gconf->name, NULL,
                              context, PGC_S_DEFAULT,
                              GUC_ACTION_SET, true, 0, false) > 0)
        {
            /* Log the change if appropriate */
            if (context == PGC_SIGHUP)
                ereport(elevel,
                        (errmsg("parameter \"%s\" removed from configuration file, reset to default",
                                gconf->name)));
        }
    }
 
    /*
     * Restore any variables determined by environment variables or
     * dynamically-computed defaults.  This is a no-op except in the case
     * where one of these had been in the config file and is now removed.
     *
     * In particular, we *must not* do this during the postmaster's initial
     * loading of the file, since the timezone functions in particular should
     * be run only after initialization is complete.
     *
     * XXX this is an unmaintainable crock, because we have to know how to set
     * (or at least what to call to set) every non-PGC_INTERNAL variable that
     * could potentially have PGC_S_DYNAMIC_DEFAULT or PGC_S_ENV_VAR source.
     */
    if (context == PGC_SIGHUP && applySettings)
    {
        InitializeGUCOptionsFromEnvironment();
        pg_timezone_abbrev_initialize();
        /* this selects SQL_ASCII in processes not connected to a database */
        SetConfigOption("client_encoding", GetDatabaseEncodingName(),
                        PGC_BACKEND, PGC_S_DYNAMIC_DEFAULT);
    }
 
    /*
     * Now apply the values from the config file.
     */
    for (item = head; item; item = item->next)
    {
        char       *pre_value = NULL;
        int         scres;
 
        /* Ignore anything marked as ignorable */
        if (item->ignore)
            continue;
 
        /* In SIGHUP cases in the postmaster, we want to report changes */
        if (context == PGC_SIGHUP && applySettings && !IsUnderPostmaster)
        {
            const char *preval = GetConfigOption(item->name, true, false);
 
            /* If option doesn't exist yet or is NULL, treat as empty string */
            if (!preval)
                preval = "";
            /* must dup, else might have dangling pointer below */
            pre_value = pstrdup(preval);
        }
 
        scres = set_config_option(item->name, item->value,
                                  context, PGC_S_FILE,
                                  GUC_ACTION_SET, applySettings, 0, false);
        if (scres > 0)
        {
            /* variable was updated, so log the change if appropriate */
            if (pre_value)
            {
                const char *post_value = GetConfigOption(item->name, true, false);
 
                if (!post_value)
                    post_value = "";
                if (strcmp(pre_value, post_value) != 0)
                    ereport(elevel,
                            (errmsg("parameter \"%s\" changed to \"%s\"",
                                    item->name, item->value)));
            }
            item->applied = true;
        }
        else if (scres == 0)
        {
            error = true;
            item->errmsg = pstrdup("setting could not be applied");
            ConfFileWithError = item->filename;
        }
        else
        {
            /* no error, but variable's active value was not changed */
            item->applied = true;
        }
 
        /*
         * We should update source location unless there was an error, since
         * even if the active value didn't change, the reset value might have.
         * (In the postmaster, there won't be a difference, but it does matter
         * in backends.)
         */
        if (scres != 0 && applySettings)
            set_config_sourcefile(item->name, item->filename,
                                  item->sourceline);
 
        if (pre_value)
            pfree(pre_value);
    }
 
    /* Remember when we last successfully loaded the config file. */
    if (applySettings)
        PgReloadTime = GetCurrentTimestamp();
 
bail_out:
    if (error && applySettings)
    {
        /* During postmaster startup, any error is fatal */
        if (context == PGC_POSTMASTER)
            ereport(ERROR,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("configuration file \"%s\" contains errors",
                            ConfFileWithError)));
        else if (applying)
            ereport(elevel,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("configuration file \"%s\" contains errors; unaffected changes were applied",
                            ConfFileWithError)));
        else
            ereport(elevel,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("configuration file \"%s\" contains errors; no changes were applied",
                            ConfFileWithError)));
    }
 
    /* Successful or otherwise, return the collected data list */
    return head;
}

References ConfigVariable::applied, bail_out(), CONF_FILE_START_DEPTH, ConfigFileName, config_generic::context, DataDir, ereport, errcode(), errmsg(), ConfigVariable::errmsg, ERROR, error(), ConfigVariable::filename, find_option(), GetConfigOption(), GetCurrentTimestamp(), GetDatabaseEncodingName(), GUC_ACTION_SET, guc_hashtab, GUC_IS_IN_FILE, GUC_PENDING_RESTART, GUCHashEntry::gucvar, hash_seq_init(), hash_seq_search(), ConfigVariable::ignore, InitializeGUCOptionsFromEnvironment(), IsUnderPostmaster, ConfigVariable::name, config_generic::name, ConfigVariable::next, ParseConfigFile(), pfree(), PG_AUTOCONF_FILENAME, pg_timezone_abbrev_initialize(), PGC_BACKEND, PGC_POSTMASTER, PGC_S_DEFAULT, PGC_S_DYNAMIC_DEFAULT, PGC_S_FILE, PGC_SIGHUP, PgReloadTime, guc_stack::prev, psprintf(), pstrdup(), record_config_file_error(), config_generic::reset_source, set_config_option(), set_config_sourcefile(), set_guc_source(), SetConfigOption(), guc_stack::source, config_generic::source, ConfigVariable::sourceline, config_generic::stack, config_generic::status, valid_custom_variable_name(), and ConfigVariable::value.

Referenced by ProcessConfigFile(), and show_all_file_settings().

◆ ProcessGUCArray()

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

Definition at line 6479 of file guc.c.

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

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

Referenced by ApplySetting(), and ProcedureCreate().

◆ push_old_value()

static void push_old_value	(	struct config_generic *	gconf,
		GucAction	action
	)

static

Definition at line 2140 of file guc.c.

{
    GucStack   *stack;
 
    /* If we're not inside a nest level, do nothing */
    if (GUCNestLevel == 0)
        return;
 
    /* Do we already have a stack entry of the current nest level? */
    stack = gconf->stack;
    if (stack && stack->nest_level >= GUCNestLevel)
    {
        /* Yes, so adjust its state if necessary */
        Assert(stack->nest_level == GUCNestLevel);
        switch (action)
        {
            case GUC_ACTION_SET:
                /* SET overrides any prior action at same nest level */
                if (stack->state == GUC_SET_LOCAL)
                {
                    /* must discard old masked value */
                    discard_stack_value(gconf, &stack->masked);
                }
                stack->state = GUC_SET;
                break;
            case GUC_ACTION_LOCAL:
                if (stack->state == GUC_SET)
                {
                    /* SET followed by SET LOCAL, remember SET's value */
                    stack->masked_scontext = gconf->scontext;
                    stack->masked_srole = gconf->srole;
                    set_stack_value(gconf, &stack->masked);
                    stack->state = GUC_SET_LOCAL;
                }
                /* in all other cases, no change to stack entry */
                break;
            case GUC_ACTION_SAVE:
                /* Could only have a prior SAVE of same variable */
                Assert(stack->state == GUC_SAVE);
                break;
        }
        return;
    }
 
    /*
     * Push a new stack entry
     *
     * We keep all the stack entries in TopTransactionContext for simplicity.
     */
    stack = (GucStack *) MemoryContextAllocZero(TopTransactionContext,
                                                sizeof(GucStack));
 
    stack->prev = gconf->stack;
    stack->nest_level = GUCNestLevel;
    switch (action)
    {
        case GUC_ACTION_SET:
            stack->state = GUC_SET;
            break;
        case GUC_ACTION_LOCAL:
            stack->state = GUC_LOCAL;
            break;
        case GUC_ACTION_SAVE:
            stack->state = GUC_SAVE;
            break;
    }
    stack->source = gconf->source;
    stack->scontext = gconf->scontext;
    stack->srole = gconf->srole;
    set_stack_value(gconf, &stack->prior);
 
    if (gconf->stack == NULL)
        slist_push_head(&guc_stack_list, &gconf->stack_link);
    gconf->stack = stack;
}

References generate_unaccent_rules::action, Assert(), discard_stack_value(), GUC_ACTION_LOCAL, GUC_ACTION_SAVE, GUC_ACTION_SET, GUC_LOCAL, GUC_SAVE, GUC_SET, GUC_SET_LOCAL, guc_stack_list, GUCNestLevel, guc_stack::masked, guc_stack::masked_scontext, guc_stack::masked_srole, MemoryContextAllocZero(), guc_stack::nest_level, guc_stack::prev, guc_stack::prior, guc_stack::scontext, config_generic::scontext, set_stack_value(), slist_push_head(), guc_stack::source, config_generic::source, guc_stack::srole, config_generic::srole, config_generic::stack, config_generic::stack_link, guc_stack::state, and TopTransactionContext.

Referenced by ResetAllOptions(), and set_config_with_handle().

◆ read_gucstate()

static char * read_gucstate	(	char **	srcptr,
		char *	srcend
	)

static

Definition at line 6157 of file guc.c.

{
    char       *retptr = *srcptr;
    char       *ptr;
 
    if (*srcptr >= srcend)
        elog(ERROR, "incomplete GUC state");
 
    /* The string variables are all null terminated */
    for (ptr = *srcptr; ptr < srcend && *ptr != '\0'; ptr++)
        ;
 
    if (ptr >= srcend)
        elog(ERROR, "could not find null terminator in GUC state");
 
    /* Set the new position to the byte following the terminating NUL */
    *srcptr = ptr + 1;
 
    return retptr;
}

References elog, and ERROR.

Referenced by RestoreGUCState().

◆ read_gucstate_binary()

static void read_gucstate_binary	(	char **	srcptr,
		char *	srcend,
		void *	dest,
		Size	size
	)

static

Definition at line 6180 of file guc.c.

{
    if (*srcptr + size > srcend)
        elog(ERROR, "incomplete GUC state");
 
    memcpy(dest, *srcptr, size);
    *srcptr += size;
}

References generate_unaccent_rules::dest, elog, and ERROR.

Referenced by RestoreGUCState().

◆ reapply_stacked_values()

static void reapply_stacked_values	(	struct config_generic *	variable,
		struct config_string *	pHolder,
		GucStack *	stack,
		const char *	curvalue,
		GucContext	curscontext,
		GucSource	cursource,
		Oid	cursrole
	)

static

Definition at line 5044 of file guc.c.

{
    const char *name = variable->name;
    GucStack   *oldvarstack = variable->stack;
 
    if (stack != NULL)
    {
        /* First, recurse, so that stack items are processed bottom to top */
        reapply_stacked_values(variable, pHolder, stack->prev,
                               stack->prior.val.stringval,
                               stack->scontext, stack->source, stack->srole);
 
        /* See how to apply the passed-in value */
        switch (stack->state)
        {
            case GUC_SAVE:
                (void) set_config_option_ext(name, curvalue,
                                             curscontext, cursource, cursrole,
                                             GUC_ACTION_SAVE, true,
                                             WARNING, false);
                break;
 
            case GUC_SET:
                (void) set_config_option_ext(name, curvalue,
                                             curscontext, cursource, cursrole,
                                             GUC_ACTION_SET, true,
                                             WARNING, false);
                break;
 
            case GUC_LOCAL:
                (void) set_config_option_ext(name, curvalue,
                                             curscontext, cursource, cursrole,
                                             GUC_ACTION_LOCAL, true,
                                             WARNING, false);
                break;
 
            case GUC_SET_LOCAL:
                /* first, apply the masked value as SET */
                (void) set_config_option_ext(name, stack->masked.val.stringval,
                                             stack->masked_scontext,
                                             PGC_S_SESSION,
                                             stack->masked_srole,
                                             GUC_ACTION_SET, true,
                                             WARNING, false);
                /* then apply the current value as LOCAL */
                (void) set_config_option_ext(name, curvalue,
                                             curscontext, cursource, cursrole,
                                             GUC_ACTION_LOCAL, true,
                                             WARNING, false);
                break;
        }
 
        /* If we successfully made a stack entry, adjust its nest level */
        if (variable->stack != oldvarstack)
            variable->stack->nest_level = stack->nest_level;
    }
    else
    {
        /*
         * We are at the end of the stack.  If the active/previous value is
         * different from the reset value, it must represent a previously
         * committed session value.  Apply it, and then drop the stack entry
         * that set_config_option will have created under the impression that
         * this is to be just a transactional assignment.  (We leak the stack
         * entry.)
         */
        if (curvalue != pHolder->reset_val ||
            curscontext != pHolder->gen.reset_scontext ||
            cursource != pHolder->gen.reset_source ||
            cursrole != pHolder->gen.reset_srole)
        {
            (void) set_config_option_ext(name, curvalue,
                                         curscontext, cursource, cursrole,
                                         GUC_ACTION_SET, true, WARNING, false);
            if (variable->stack != NULL)
            {
                slist_delete(&guc_stack_list, &variable->stack_link);
                variable->stack = NULL;
            }
        }
    }
}

References config_string::gen, GUC_ACTION_LOCAL, GUC_ACTION_SAVE, GUC_ACTION_SET, GUC_LOCAL, GUC_SAVE, GUC_SET, GUC_SET_LOCAL, guc_stack_list, guc_stack::masked, guc_stack::masked_scontext, guc_stack::masked_srole, name, variable::name, guc_stack::nest_level, PGC_S_SESSION, guc_stack::prev, guc_stack::prior, reapply_stacked_values(), config_generic::reset_scontext, config_generic::reset_source, config_generic::reset_srole, config_string::reset_val, guc_stack::scontext, set_config_option_ext(), slist_delete(), guc_stack::source, guc_stack::srole, guc_stack::state, config_var_val::stringval, config_var_value::val, and WARNING.

Referenced by define_custom_variable(), and reapply_stacked_values().

◆ RemoveGUCFromLists()

static void RemoveGUCFromLists ( struct config_generic * gconf )

static

Definition at line 1763 of file guc.c.

{
    if (gconf->source != PGC_S_DEFAULT)
        dlist_delete(&gconf->nondef_link);
    if (gconf->stack != NULL)
        slist_delete(&guc_stack_list, &gconf->stack_link);
    if (gconf->status & GUC_NEEDS_REPORT)
        slist_delete(&guc_report_list, &gconf->report_link);
}

References dlist_delete(), GUC_NEEDS_REPORT, guc_report_list, guc_stack_list, config_generic::nondef_link, PGC_S_DEFAULT, config_generic::report_link, slist_delete(), config_generic::source, config_generic::stack, config_generic::stack_link, and config_generic::status.

Referenced by define_custom_variable(), MarkGUCPrefixReserved(), and RestoreGUCState().

◆ replace_auto_config_value()

static void replace_auto_config_value	(	ConfigVariable **	head_p,
		ConfigVariable **	tail_p,
		const char *	name,
		const char *	value
	)

static

Definition at line 4543 of file guc.c.

{
    ConfigVariable *item,
               *next,
               *prev = NULL;
 
    /*
     * Remove any existing match(es) for "name".  Normally there'd be at most
     * one, but if external tools have modified the config file, there could
     * be more.
     */
    for (item = *head_p; item != NULL; item = next)
    {
        next = item->next;
        if (guc_name_compare(item->name, name) == 0)
        {
            /* found a match, delete it */
            if (prev)
                prev->next = next;
            else
                *head_p = next;
            if (next == NULL)
                *tail_p = prev;
 
            pfree(item->name);
            pfree(item->value);
            pfree(item->filename);
            pfree(item);
        }
        else
            prev = item;
    }
 
    /* Done if we're trying to delete it */
    if (value == NULL)
        return;
 
    /* OK, append a new entry */
    item = palloc(sizeof *item);
    item->name = pstrdup(name);
    item->value = pstrdup(value);
    item->errmsg = NULL;
    item->filename = pstrdup("");   /* new item has no location */
    item->sourceline = 0;
    item->ignore = false;
    item->applied = false;
    item->next = NULL;
 
    if (*head_p == NULL)
        *head_p = item;
    else
        (*tail_p)->next = item;
    *tail_p = item;
}

References ConfigVariable::applied, ConfigVariable::errmsg, ConfigVariable::filename, guc_name_compare(), ConfigVariable::ignore, name, ConfigVariable::name, next, ConfigVariable::next, palloc(), pfree(), pstrdup(), ConfigVariable::sourceline, ConfigVariable::value, and value.

Referenced by AlterSystemSetConfigFile().

◆ ReportChangedGUCOptions()

void ReportChangedGUCOptions ( void )

Definition at line 2602 of file guc.c.

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

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

Referenced by PostgresMain().

◆ ReportGUCOption()

static void ReportGUCOption ( struct config_generic * record )

static

Definition at line 2640 of file guc.c.

{
    char       *val = ShowGUCOption(record, false);
 
    if (record->last_reported == NULL ||
        strcmp(val, record->last_reported) != 0)
    {
        StringInfoData msgbuf;
 
        pq_beginmessage(&msgbuf, PqMsg_ParameterStatus);
        pq_sendstring(&msgbuf, record->name);
        pq_sendstring(&msgbuf, val);
        pq_endmessage(&msgbuf);
 
        /*
         * We need a long-lifespan copy.  If guc_strdup() fails due to OOM,
         * we'll set last_reported to NULL and thereby possibly make a
         * duplicate report later.
         */
        guc_free(record->last_reported);
        record->last_reported = guc_strdup(LOG, val);
    }
 
    pfree(val);
}

References guc_free(), guc_strdup(), config_generic::last_reported, LOG, config_generic::name, pfree(), pq_beginmessage(), pq_endmessage(), pq_sendstring(), PqMsg_ParameterStatus, ShowGUCOption(), and val.

Referenced by BeginReportingGUCOptions(), and ReportChangedGUCOptions().

◆ ResetAllOptions()

void ResetAllOptions ( void )

Definition at line 2009 of file guc.c.

{
    dlist_mutable_iter iter;
 
    /* We need only consider GUCs not already at PGC_S_DEFAULT */
    dlist_foreach_modify(iter, &guc_nondef_list)
    {
        struct config_generic *gconf = dlist_container(struct config_generic,
                                                       nondef_link, iter.cur);
 
        /* Don't reset non-SET-able values */
        if (gconf->context != PGC_SUSET &&
            gconf->context != PGC_USERSET)
            continue;
        /* Don't reset if special exclusion from RESET ALL */
        if (gconf->flags & GUC_NO_RESET_ALL)
            continue;
        /* No need to reset if wasn't SET */
        if (gconf->source <= PGC_S_OVERRIDE)
            continue;
 
        /* Save old value to support transaction abort */
        push_old_value(gconf, GUC_ACTION_SET);
 
        switch (gconf->vartype)
        {
            case PGC_BOOL:
                {
                    struct config_bool *conf = (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;
                }
        }
 
        set_guc_source(gconf, gconf->reset_source);
        gconf->scontext = gconf->reset_scontext;
        gconf->srole = gconf->reset_srole;
 
        if ((gconf->flags & GUC_REPORT) && !(gconf->status & GUC_NEEDS_REPORT))
        {
            gconf->status |= GUC_NEEDS_REPORT;
            slist_push_head(&guc_report_list, &gconf->report_link);
        }
    }
}

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

Referenced by DiscardAll(), and ExecSetVariableStmt().

◆ RestoreGUCState()

void RestoreGUCState ( void * gucstate )

Definition at line 6216 of file guc.c.

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

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

Referenced by ParallelWorkerMain().

◆ RestrictSearchPath()

void RestrictSearchPath ( void )

Definition at line 2252 of file guc.c.

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

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

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

◆ SelectConfigFiles()

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

Definition at line 1786 of file guc.c.

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

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

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

◆ serialize_variable()

static void serialize_variable	(	char **	destptr,
		Size *	maxbytes,
		struct config_generic *	gconf
	)

static

Definition at line 6047 of file guc.c.

{
    /* Ignore skippable GUCs. */
    if (can_skip_gucvar(gconf))
        return;
 
    do_serialize(destptr, maxbytes, "%s", gconf->name);
 
    switch (gconf->vartype)
    {
        case PGC_BOOL:
            {
                struct config_bool *conf = (struct config_bool *) gconf;
 
                do_serialize(destptr, maxbytes,
                             (*conf->variable ? "true" : "false"));
            }
            break;
 
        case PGC_INT:
            {
                struct config_int *conf = (struct config_int *) gconf;
 
                do_serialize(destptr, maxbytes, "%d", *conf->variable);
            }
            break;
 
        case PGC_REAL:
            {
                struct config_real *conf = (struct config_real *) gconf;
 
                do_serialize(destptr, maxbytes, "%.*e",
                             REALTYPE_PRECISION, *conf->variable);
            }
            break;
 
        case PGC_STRING:
            {
                struct config_string *conf = (struct config_string *) gconf;
 
                /* NULL becomes empty string, see estimate_variable_size() */
                do_serialize(destptr, maxbytes, "%s",
                             *conf->variable ? *conf->variable : "");
            }
            break;
 
        case PGC_ENUM:
            {
                struct config_enum *conf = (struct config_enum *) gconf;
 
                do_serialize(destptr, maxbytes, "%s",
                             config_enum_lookup_by_value(conf, *conf->variable));
            }
            break;
    }
 
    do_serialize(destptr, maxbytes, "%s",
                 (gconf->sourcefile ? gconf->sourcefile : ""));
 
    if (gconf->sourcefile && gconf->sourcefile[0])
        do_serialize_binary(destptr, maxbytes, &gconf->sourceline,
                            sizeof(gconf->sourceline));
 
    do_serialize_binary(destptr, maxbytes, &gconf->source,
                        sizeof(gconf->source));
    do_serialize_binary(destptr, maxbytes, &gconf->scontext,
                        sizeof(gconf->scontext));
    do_serialize_binary(destptr, maxbytes, &gconf->srole,
                        sizeof(gconf->srole));
}

References can_skip_gucvar(), config_enum_lookup_by_value(), do_serialize(), do_serialize_binary(), config_generic::name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, REALTYPE_PRECISION, config_generic::scontext, config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_generic::srole, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by SerializeGUCState().

◆ SerializeGUCState()

void SerializeGUCState	(	Size	maxsize,
		char *	start_address
	)

Definition at line 6124 of file guc.c.

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

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

Referenced by InitializeParallelDSM().

◆ set_config_option()

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

Definition at line 3348 of file guc.c.

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

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

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

◆ set_config_option_ext()

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

Definition at line 3388 of file guc.c.

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

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

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

◆ set_config_sourcefile()

static void set_config_sourcefile	(	const char *	name,
		char *	sourcefile,
		int	sourceline
	)

static

Definition at line 4305 of file guc.c.

{
    struct config_generic *record;
    int         elevel;
 
    /*
     * To avoid cluttering the log, only the postmaster bleats loudly about
     * problems with the config file.
     */
    elevel = IsUnderPostmaster ? DEBUG3 : LOG;
 
    record = find_option(name, true, false, elevel);
    /* should not happen */
    if (record == NULL)
        return;
 
    sourcefile = guc_strdup(elevel, sourcefile);
    guc_free(record->sourcefile);
    record->sourcefile = sourcefile;
    record->sourceline = sourceline;
}

References DEBUG3, find_option(), guc_free(), guc_strdup(), IsUnderPostmaster, LOG, name, config_generic::sourcefile, and config_generic::sourceline.

Referenced by define_custom_variable(), ProcessConfigFileInternal(), and RestoreGUCState().

◆ set_config_with_handle()

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

Definition at line 3411 of file guc.c.

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

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

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

◆ set_extra_field()

static void set_extra_field	(	struct config_generic *	gconf,
		void **	field,
		void *	newval
	)

static

Definition at line 794 of file guc.c.

{
    void       *oldval = *field;
 
    /* Do the assignment */
    *field = newval;
 
    /* Free old value if it's not NULL and isn't referenced anymore */
    if (oldval && !extra_field_used(gconf, oldval))
        guc_free(oldval);
}

References extra_field_used(), guc_free(), and newval.

Referenced by AtEOXact_GUC(), discard_stack_value(), ResetAllOptions(), set_config_with_handle(), and set_stack_value().

◆ set_guc_source()

static void set_guc_source	(	struct config_generic *	gconf,
		GucSource	newsource
	)

static

Definition at line 2117 of file guc.c.

{
    /* Adjust nondef list membership if appropriate for change */
    if (gconf->source == PGC_S_DEFAULT)
    {
        if (newsource != PGC_S_DEFAULT)
            dlist_push_tail(&guc_nondef_list, &gconf->nondef_link);
    }
    else
    {
        if (newsource == PGC_S_DEFAULT)
            dlist_delete(&gconf->nondef_link);
    }
    /* Now update the source field */
    gconf->source = newsource;
}

References dlist_delete(), dlist_push_tail(), guc_nondef_list, config_generic::nondef_link, PGC_S_DEFAULT, and config_generic::source.

Referenced by AtEOXact_GUC(), ProcessConfigFileInternal(), ResetAllOptions(), and set_config_with_handle().

◆ set_stack_value()

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

static

Definition at line 814 of file guc.c.

{
    switch (gconf->vartype)
    {
        case PGC_BOOL:
            val->val.boolval =
                *((struct config_bool *) gconf)->variable;
            break;
        case PGC_INT:
            val->val.intval =
                *((struct config_int *) gconf)->variable;
            break;
        case PGC_REAL:
            val->val.realval =
                *((struct config_real *) gconf)->variable;
            break;
        case PGC_STRING:
            set_string_field((struct config_string *) gconf,
                             &(val->val.stringval),
                             *((struct config_string *) gconf)->variable);
            break;
        case PGC_ENUM:
            val->val.enumval =
                *((struct config_enum *) gconf)->variable;
            break;
    }
    set_extra_field(gconf, &(val->extra), gconf->extra);
}

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

Referenced by push_old_value().

◆ set_string_field()

static void set_string_field	(	struct config_string *	conf,
		char **	field,
		char *	newval
	)

static

Definition at line 733 of file guc.c.

{
    char       *oldval = *field;
 
    /* Do the assignment */
    *field = newval;
 
    /* Free old value if it's not NULL and isn't referenced anymore */
    if (oldval && !string_field_used(conf, oldval))
        guc_free(oldval);
}

References guc_free(), newval, and string_field_used().

Referenced by AtEOXact_GUC(), discard_stack_value(), free_placeholder(), ResetAllOptions(), set_config_with_handle(), and set_stack_value().

◆ SetConfigOption()

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

Definition at line 4338 of file guc.c.

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

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

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

◆ ShowGUCOption()

char * ShowGUCOption	(	struct config_generic *	record,
		bool	use_units
	)

Definition at line 5488 of file guc.c.

{
    char        buffer[256];
    const char *val;
 
    switch (record->vartype)
    {
        case PGC_BOOL:
            {
                struct config_bool *conf = (struct config_bool *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else
                    val = *conf->variable ? "on" : "off";
            }
            break;
 
        case PGC_INT:
            {
                struct config_int *conf = (struct config_int *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else
                {
                    /*
                     * Use int64 arithmetic to avoid overflows in units
                     * conversion.
                     */
                    int64       result = *conf->variable;
                    const char *unit;
 
                    if (use_units && result > 0 && (record->flags & GUC_UNIT))
                        convert_int_from_base_unit(result,
                                                   record->flags & GUC_UNIT,
                                                   &result, &unit);
                    else
                        unit = "";
 
                    snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
                             result, unit);
                    val = buffer;
                }
            }
            break;
 
        case PGC_REAL:
            {
                struct config_real *conf = (struct config_real *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else
                {
                    double      result = *conf->variable;
                    const char *unit;
 
                    if (use_units && result > 0 && (record->flags & GUC_UNIT))
                        convert_real_from_base_unit(result,
                                                    record->flags & GUC_UNIT,
                                                    &result, &unit);
                    else
                        unit = "";
 
                    snprintf(buffer, sizeof(buffer), "%g%s",
                             result, unit);
                    val = buffer;
                }
            }
            break;
 
        case PGC_STRING:
            {
                struct config_string *conf = (struct config_string *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else if (*conf->variable && **conf->variable)
                    val = *conf->variable;
                else
                    val = "";
            }
            break;
 
        case PGC_ENUM:
            {
                struct config_enum *conf = (struct config_enum *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else
                    val = config_enum_lookup_by_value(conf, *conf->variable);
            }
            break;
 
        default:
            /* just to keep compiler quiet */
            val = "???";
            break;
    }
 
    return pstrdup(val);
}

References config_enum_lookup_by_value(), convert_int_from_base_unit(), convert_real_from_base_unit(), config_generic::flags, GUC_UNIT, INT64_FORMAT, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, pstrdup(), config_bool::show_hook, config_int::show_hook, config_real::show_hook, config_string::show_hook, config_enum::show_hook, snprintf, val, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

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

◆ string_field_used()

static bool string_field_used	(	struct config_string *	conf,
		char *	strval
	)

static

Definition at line 710 of file guc.c.

{
    GucStack   *stack;
 
    if (strval == *(conf->variable) ||
        strval == conf->reset_val ||
        strval == conf->boot_val)
        return true;
    for (stack = conf->gen.stack; stack; stack = stack->prev)
    {
        if (strval == stack->prior.val.stringval ||
            strval == stack->masked.val.stringval)
            return true;
    }
    return false;
}

References config_string::boot_val, config_string::gen, guc_stack::masked, guc_stack::prev, guc_stack::prior, config_string::reset_val, config_generic::stack, config_var_val::stringval, config_var_value::val, and config_string::variable.

Referenced by set_config_with_handle(), and set_string_field().

◆ TransformGUCArray()

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

Definition at line 6422 of file guc.c.

{
    int         i;
 
    Assert(array != NULL);
    Assert(ARR_ELEMTYPE(array) == TEXTOID);
    Assert(ARR_NDIM(array) == 1);
    Assert(ARR_LBOUND(array)[0] == 1);
 
    *names = NIL;
    *values = NIL;
    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 */ ,
                      TYPALIGN_INT /* TEXT's typalign */ ,
                      &isnull);
 
        if (isnull)
            continue;
 
        s = TextDatumGetCString(d);
 
        ParseLongOption(s, &name, &value);
        if (!value)
        {
            ereport(WARNING,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("could not parse setting for parameter \"%s\"",
                            name)));
            pfree(name);
            continue;
        }
 
        *names = lappend(*names, name);
        *values = lappend(*values, value);
 
        pfree(s);
    }
}

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

Referenced by fmgr_security_definer(), and ProcessGUCArray().

◆ valid_custom_variable_name()

static bool valid_custom_variable_name ( const char * name )

static

Definition at line 1078 of file guc.c.

{
    bool        saw_sep = false;
    bool        name_start = true;
 
    for (const char *p = name; *p; p++)
    {
        if (*p == GUC_QUALIFIER_SEPARATOR)
        {
            if (name_start)
                return false;   /* empty name component */
            saw_sep = true;
            name_start = true;
        }
        else if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                        "abcdefghijklmnopqrstuvwxyz_", *p) != NULL ||
                 IS_HIGHBIT_SET(*p))
        {
            /* okay as first or non-first character */
            name_start = false;
        }
        else if (!name_start && strchr("0123456789$", *p) != NULL)
             /* okay as non-first character */ ;
        else
            return false;
    }
    if (name_start)
        return false;           /* empty name component */
    /* OK if we found at least one separator */
    return saw_sep;
}

References GUC_QUALIFIER_SEPARATOR, IS_HIGHBIT_SET, and name.

Referenced by AlterSystemSetConfigFile(), assignable_custom_variable_name(), ProcessConfigFileInternal(), and validate_option_array_item().

◆ validate_option_array_item()

static bool validate_option_array_item	(	const char *	name,
		const char *	value,
		bool	skipIfNoPermissions
	)

static

Definition at line 6731 of file guc.c.

{
    struct config_generic *gconf;
    bool        reset_custom;
 
    /*
     * There are three cases to consider:
     *
     * name is a known GUC variable.  Check the value normally, check
     * permissions normally (i.e., allow if variable is USERSET, or if it's
     * SUSET and user is superuser or holds ACL_SET permissions).
     *
     * name is not known, but exists or can be created as a placeholder (i.e.,
     * it has a valid custom name).  We allow this case if you're a superuser,
     * otherwise not.  Superusers are assumed to know what they're doing. We
     * can't allow it for other users, because when the placeholder is
     * resolved it might turn out to be a SUSET variable.  (With currently
     * available infrastructure, we can actually handle such cases within the
     * current session --- but once an entry is made in pg_db_role_setting,
     * it's assumed to be fully validated.)
     *
     * name is not known and can't be created as a placeholder.  Throw error,
     * unless skipIfNoPermissions or reset_custom is true.  If reset_custom is
     * true, this is a RESET or RESET ALL operation for an unknown custom GUC
     * with a reserved prefix, in which case we want to fall through to the
     * placeholder case described in the preceding paragraph (else there'd be
     * no way for users to remove them).  Otherwise, return false.
     */
    reset_custom = (!value && valid_custom_variable_name(name));
    gconf = find_option(name, true, skipIfNoPermissions || reset_custom, ERROR);
    if (!gconf && !reset_custom)
    {
        /* not known, failed to make a placeholder */
        return false;
    }
 
    if (!gconf || gconf->flags & GUC_CUSTOM_PLACEHOLDER)
    {
        /*
         * We cannot do any meaningful check on the value, so only permissions
         * are useful to check.
         */
        if (superuser() ||
            pg_parameter_aclcheck(name, GetUserId(), ACL_SET) == ACLCHECK_OK)
            return true;
        if (skipIfNoPermissions)
            return false;
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to set parameter \"%s\"", name)));
    }
 
    /* manual permissions check so we can avoid an error being thrown */
    if (gconf->context == PGC_USERSET)
         /* ok */ ;
    else if (gconf->context == PGC_SUSET &&
             (superuser() ||
              pg_parameter_aclcheck(name, GetUserId(), ACL_SET) == ACLCHECK_OK))
         /* ok */ ;
    else if (skipIfNoPermissions)
        return false;
    /* if a permissions error should be thrown, let set_config_option do it */
 
    /* test for permissions and valid option value */
    (void) set_config_option(name, value,
                             superuser() ? PGC_SUSET : PGC_USERSET,
                             PGC_S_TEST, GUC_ACTION_SET, false, 0, false);
 
    return true;
}

References ACL_SET, ACLCHECK_OK, config_generic::context, ereport, errcode(), errmsg(), ERROR, find_option(), config_generic::flags, GetUserId(), GUC_ACTION_SET, GUC_CUSTOM_PLACEHOLDER, name, pg_parameter_aclcheck(), PGC_S_TEST, PGC_SUSET, PGC_USERSET, set_config_option(), superuser(), valid_custom_variable_name(), and value.

Referenced by GUCArrayAdd(), GUCArrayDelete(), and GUCArrayReset().

◆ write_auto_conf_file()

static void write_auto_conf_file	(	int	fd,
		const char *	filename,
		ConfigVariable *	head
	)

static

Definition at line 4475 of file guc.c.

{
    StringInfoData buf;
    ConfigVariable *item;
 
    initStringInfo(&buf);
 
    /* Emit file header containing warning comment */
    appendStringInfoString(&buf, "# Do not edit this file manually!\n");
    appendStringInfoString(&buf, "# It will be overwritten by the ALTER SYSTEM command.\n");
 
    errno = 0;
    if (write(fd, buf.data, buf.len) != buf.len)
    {
        /* if write didn't set errno, assume problem is no disk space */
        if (errno == 0)
            errno = ENOSPC;
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not write to file \"%s\": %m", filename)));
    }
 
    /* Emit each parameter, properly quoting the value */
    for (item = head; item != NULL; item = item->next)
    {
        char       *escaped;
 
        resetStringInfo(&buf);
 
        appendStringInfoString(&buf, item->name);
        appendStringInfoString(&buf, " = '");
 
        escaped = escape_single_quotes_ascii(item->value);
        if (!escaped)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
        appendStringInfoString(&buf, escaped);
        free(escaped);
 
        appendStringInfoString(&buf, "'\n");
 
        errno = 0;
        if (write(fd, buf.data, buf.len) != buf.len)
        {
            /* if write didn't set errno, assume problem is no disk space */
            if (errno == 0)
                errno = ENOSPC;
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not write to file \"%s\": %m", filename)));
        }
    }
 
    /* fsync before considering the write to be successful */
    if (pg_fsync(fd) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not fsync file \"%s\": %m", filename)));
 
    pfree(buf.data);
}

References appendStringInfoString(), buf, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, escape_single_quotes_ascii(), fd(), filename, free, initStringInfo(), ConfigVariable::name, ConfigVariable::next, pfree(), pg_fsync(), resetStringInfo(), ConfigVariable::value, and write.

Referenced by AlterSystemSetConfigFile().

Variable Documentation

◆ GUC_check_errcode_value

int GUC_check_errcode_value

static

Definition at line 77 of file guc.c.

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

◆ GUC_check_errdetail_string

char* GUC_check_errdetail_string

Definition at line 83 of file guc.c.

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

◆ GUC_check_errhint_string

char* GUC_check_errhint_string

Definition at line 84 of file guc.c.

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

◆ GUC_check_errmsg_string

char* GUC_check_errmsg_string

Definition at line 82 of file guc.c.

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

◆ guc_hashtab

HTAB* guc_hashtab

static

Definition at line 213 of file guc.c.

Referenced by add_guc_variable(), BeginReportingGUCOptions(), build_guc_variables(), define_custom_variable(), find_option(), get_explain_guc_options(), get_guc_variables(), InitializeGUCOptions(), MarkGUCPrefixReserved(), and ProcessConfigFileInternal().

◆ guc_nondef_list

dlist_head guc_nondef_list

static

Definition at line 223 of file guc.c.

Referenced by EstimateGUCStateSpace(), get_explain_guc_options(), ResetAllOptions(), RestoreGUCState(), SerializeGUCState(), and set_guc_source().

◆ guc_report_list

slist_head guc_report_list

static

Definition at line 227 of file guc.c.

Referenced by AtEOXact_GUC(), RemoveGUCFromLists(), ReportChangedGUCOptions(), ResetAllOptions(), and set_config_with_handle().

◆ guc_stack_list

slist_head guc_stack_list

static

Definition at line 225 of file guc.c.

Referenced by AtEOXact_GUC(), push_old_value(), reapply_stacked_values(), and RemoveGUCFromLists().

◆ GUCMemoryContext

MemoryContext GUCMemoryContext

static

Definition at line 200 of file guc.c.

Referenced by build_guc_variables(), guc_free(), guc_malloc(), guc_realloc(), and MarkGUCPrefixReserved().

◆ GUCNestLevel

int GUCNestLevel = 0

static

Definition at line 232 of file guc.c.

Referenced by AtEOXact_GUC(), AtStart_GUC(), NewGUCNestLevel(), and push_old_value().

◆ map_old_guc_names

const char* const map_old_guc_names[]

static

Initial value:

= {
    "sort_mem", "work_mem",
    "vacuum_mem", "maintenance_work_mem",
    "ssl_ecdh_curve", "ssl_groups",
    NULL
}

Definition at line 191 of file guc.c.

Referenced by convert_GUC_name_for_parameter_acl(), and find_option().

◆ memory_unit_conversion_table

const unit_conversion memory_unit_conversion_table[]

static

Definition at line 122 of file guc.c.

Referenced by convert_int_from_base_unit(), convert_real_from_base_unit(), and convert_to_base_unit().

◆ memory_units_hint

const char* const memory_units_hint = gettext_noop("Valid units for this parameter are \"B\", \"kB\", \"MB\", \"GB\", and \"TB\".")

static

Definition at line 120 of file guc.c.

Referenced by parse_int(), and parse_real().

◆ reporting_enabled

bool reporting_enabled

static

Definition at line 230 of file guc.c.

Referenced by BeginReportingGUCOptions(), InitializeGUCOptions(), and ReportChangedGUCOptions().

◆ reserved_class_prefix

List* reserved_class_prefix = NIL

static

Definition at line 79 of file guc.c.

Referenced by assignable_custom_variable_name(), and MarkGUCPrefixReserved().

◆ time_unit_conversion_table

const unit_conversion time_unit_conversion_table[]

static

Initial value:

=
{
    {"d", GUC_UNIT_MS, 1000 * 60 * 60 * 24},
    {"h", GUC_UNIT_MS, 1000 * 60 * 60},
    {"min", GUC_UNIT_MS, 1000 * 60},
    {"s", GUC_UNIT_MS, 1000},
    {"ms", GUC_UNIT_MS, 1},
    {"us", GUC_UNIT_MS, 1.0 / 1000},
 
    {"d", GUC_UNIT_S, 60 * 60 * 24},
    {"h", GUC_UNIT_S, 60 * 60},
    {"min", GUC_UNIT_S, 60},
    {"s", GUC_UNIT_S, 1},
    {"ms", GUC_UNIT_S, 1.0 / 1000},
    {"us", GUC_UNIT_S, 1.0 / (1000 * 1000)},
 
    {"d", GUC_UNIT_MIN, 60 * 24},
    {"h", GUC_UNIT_MIN, 60},
    {"min", GUC_UNIT_MIN, 1},
    {"s", GUC_UNIT_MIN, 1.0 / 60},
    {"ms", GUC_UNIT_MIN, 1.0 / (1000 * 60)},
    {"us", GUC_UNIT_MIN, 1.0 / (1000 * 1000 * 60)},
 
    {""}                        
}

Definition at line 159 of file guc.c.

Referenced by convert_int_from_base_unit(), convert_real_from_base_unit(), and convert_to_base_unit().

◆ time_units_hint

const char* const time_units_hint = gettext_noop("Valid units for this parameter are \"us\", \"ms\", \"s\", \"min\", \"h\", and \"d\".")

static

Definition at line 157 of file guc.c.

Referenced by parse_int(), and parse_real().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ CONFIG_FILENAME

◆ GUC_SAFE_SEARCH_PATH

◆ HBA_FILENAME

◆ IDENT_FILENAME

◆ MAX_UNIT_LEN

◆ newval [1/5]

◆ newval [2/5]

◆ newval [3/5]

◆ newval [4/5]

◆ newval [5/5]

◆ REALTYPE_PRECISION

Function Documentation

◆ add_guc_variable()

◆ add_placeholder_variable()

◆ AlterSystemSetConfigFile()

◆ assignable_custom_variable_name()

◆ AtEOXact_GUC()

◆ AtStart_GUC()

◆ BeginReportingGUCOptions()

◆ build_guc_variables()

◆ call_bool_check_hook()

◆ call_enum_check_hook()

◆ call_int_check_hook()

◆ call_real_check_hook()

◆ call_string_check_hook()

◆ can_skip_gucvar()

◆ check_GUC_name_for_parameter_acl()

◆ config_enum_get_options()

◆ config_enum_lookup_by_name()

◆ config_enum_lookup_by_value()

◆ convert_GUC_name_for_parameter_acl()

◆ convert_int_from_base_unit()

◆ convert_real_from_base_unit()

◆ convert_to_base_unit()

◆ define_custom_variable()

◆ DefineCustomBoolVariable()

◆ DefineCustomEnumVariable()

◆ DefineCustomIntVariable()

◆ DefineCustomRealVariable()

◆ DefineCustomStringVariable()

◆ discard_stack_value()

◆ do_serialize()

◆ do_serialize_binary()

◆ estimate_variable_size()

◆ EstimateGUCStateSpace()

◆ extra_field_used()

◆ find_option()

◆ free_placeholder()

◆ get_config_handle()

◆ get_config_unit_name()

◆ get_explain_guc_options()

◆ get_guc_variables()

◆ GetConfigOption()

◆ GetConfigOptionByName()

◆ GetConfigOptionFlags()

◆ GetConfigOptionResetString()

◆ GUC_check_errcode()

◆ guc_free()

◆ guc_malloc()

◆ guc_name_compare()

◆ guc_name_hash()

◆ guc_name_match()

◆ guc_realloc()

◆ guc_restore_error_context_callback()

◆ guc_strdup()

◆ guc_var_compare()

◆ GUCArrayAdd()

◆ GUCArrayDelete()

◆ GUCArrayReset()

◆ init_custom_variable()

◆ InitializeGUCOptions()

◆ InitializeGUCOptionsFromEnvironment()

◆ InitializeOneGUCOption()

◆ MarkGUCPrefixReserved()

◆ NewGUCNestLevel()