PostgreSQL Source Code  git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
guc.c File Reference
#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 "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:

Go to the source code of this file.

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 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)
 
ConfigVariableProcessConfigFileInternal (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_genericadd_placeholder_variable (const char *name, int elevel)
 
struct config_genericfind_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_handleget_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_genericinit_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)
 
ArrayTypeGUCArrayAdd (ArrayType *array, const char *name, const char *value)
 
ArrayTypeGUCArrayDelete (ArrayType *array, const char *name)
 
ArrayTypeGUCArrayReset (ArrayType *array)
 
void GUC_check_errcode (int sqlerrcode)
 

Variables

static int GUC_check_errcode_value
 
static Listreserved_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 HTABguc_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 55 of file guc.c.

◆ GUC_SAFE_SEARCH_PATH

#define GUC_SAFE_SEARCH_PATH   "pg_catalog, pg_temp"

Definition at line 74 of file guc.c.

◆ HBA_FILENAME

#define HBA_FILENAME   "pg_hba.conf"

Definition at line 56 of file guc.c.

◆ IDENT_FILENAME

#define IDENT_FILENAME   "pg_ident.conf"

Definition at line 57 of file guc.c.

◆ MAX_UNIT_LEN

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

Definition at line 101 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 68 of file guc.c.

Function Documentation

◆ add_guc_variable()

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

Definition at line 1047 of file guc.c.

1048 {
1049  GUCHashEntry *hentry;
1050  bool found;
1051 
1052  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1053  &var->name,
1055  &found);
1056  if (unlikely(hentry == NULL))
1057  {
1058  ereport(elevel,
1059  (errcode(ERRCODE_OUT_OF_MEMORY),
1060  errmsg("out of memory")));
1061  return false; /* out of memory */
1062  }
1063  Assert(!found);
1064  hentry->gucvar = var;
1065  return true;
1066 }
#define Assert(condition)
Definition: c.h:863
#define unlikely(x)
Definition: c.h:326
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ereport(elevel,...)
Definition: elog.h:149
static HTAB * guc_hashtab
Definition: guc.c:212
@ HASH_ENTER_NULL
Definition: hsearch.h:116
struct config_generic * gucvar
Definition: guc.c:209
const char * name
Definition: guc_tables.h:156

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

1178 {
1179  size_t sz = sizeof(struct config_string) + sizeof(char *);
1180  struct config_string *var;
1181  struct config_generic *gen;
1182 
1183  var = (struct config_string *) guc_malloc(elevel, sz);
1184  if (var == NULL)
1185  return NULL;
1186  memset(var, 0, sz);
1187  gen = &var->gen;
1188 
1189  gen->name = guc_strdup(elevel, name);
1190  if (gen->name == NULL)
1191  {
1192  guc_free(var);
1193  return NULL;
1194  }
1195 
1196  gen->context = PGC_USERSET;
1198  gen->short_desc = "GUC placeholder variable";
1200  gen->vartype = PGC_STRING;
1201 
1202  /*
1203  * The char* is allocated at the end of the struct since we have no
1204  * 'static' place to point to. Note that the current value, as well as
1205  * the boot and reset values, start out NULL.
1206  */
1207  var->variable = (char **) (var + 1);
1208 
1209  if (!add_guc_variable((struct config_generic *) var, elevel))
1210  {
1211  guc_free(unconstify(char *, gen->name));
1212  guc_free(var);
1213  return NULL;
1214  }
1215 
1216  return gen;
1217 }
#define unconstify(underlying_type, expr)
Definition: c.h:1250
void * guc_malloc(int elevel, size_t size)
Definition: guc.c:638
void guc_free(void *ptr)
Definition: guc.c:689
static bool add_guc_variable(struct config_generic *var, int elevel)
Definition: guc.c:1047
char * guc_strdup(int elevel, const char *src)
Definition: guc.c:677
#define GUC_CUSTOM_PLACEHOLDER
Definition: guc.h:219
#define GUC_NO_SHOW_ALL
Definition: guc.h:212
@ PGC_USERSET
Definition: guc.h:75
#define GUC_NOT_IN_SAMPLE
Definition: guc.h:217
@ CUSTOM_OPTIONS
Definition: guc_tables.h:100
@ PGC_STRING
Definition: guc_tables.h:28
enum config_group group
Definition: guc_tables.h:158
GucContext context
Definition: guc_tables.h:157
const char * short_desc
Definition: guc_tables.h:159
enum config_type vartype
Definition: guc_tables.h:163
struct config_generic gen
Definition: guc_tables.h:256
char ** variable
Definition: guc_tables.h:258
const char * name

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

4608 {
4609  char *name;
4610  char *value;
4611  bool resetall = false;
4612  ConfigVariable *head = NULL;
4613  ConfigVariable *tail = NULL;
4614  volatile int Tmpfd;
4615  char AutoConfFileName[MAXPGPATH];
4616  char AutoConfTmpFileName[MAXPGPATH];
4617 
4618  /*
4619  * Extract statement arguments
4620  */
4621  name = altersysstmt->setstmt->name;
4622 
4623  if (!AllowAlterSystem)
4624  ereport(ERROR,
4625  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4626  errmsg("ALTER SYSTEM is not allowed in this environment")));
4627 
4628  switch (altersysstmt->setstmt->kind)
4629  {
4630  case VAR_SET_VALUE:
4631  value = ExtractSetVariableArgs(altersysstmt->setstmt);
4632  break;
4633 
4634  case VAR_SET_DEFAULT:
4635  case VAR_RESET:
4636  value = NULL;
4637  break;
4638 
4639  case VAR_RESET_ALL:
4640  value = NULL;
4641  resetall = true;
4642  break;
4643 
4644  default:
4645  elog(ERROR, "unrecognized alter system stmt type: %d",
4646  altersysstmt->setstmt->kind);
4647  break;
4648  }
4649 
4650  /*
4651  * Check permission to run ALTER SYSTEM on the target variable
4652  */
4653  if (!superuser())
4654  {
4655  if (resetall)
4656  ereport(ERROR,
4657  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4658  errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4659  else
4660  {
4661  AclResult aclresult;
4662 
4663  aclresult = pg_parameter_aclcheck(name, GetUserId(),
4665  if (aclresult != ACLCHECK_OK)
4666  ereport(ERROR,
4667  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4668  errmsg("permission denied to set parameter \"%s\"",
4669  name)));
4670  }
4671  }
4672 
4673  /*
4674  * Unless it's RESET_ALL, validate the target variable and value
4675  */
4676  if (!resetall)
4677  {
4678  struct config_generic *record;
4679 
4680  /* We don't want to create a placeholder if there's not one already */
4681  record = find_option(name, false, true, DEBUG5);
4682  if (record != NULL)
4683  {
4684  /*
4685  * Don't allow parameters that can't be set in configuration files
4686  * to be set in PG_AUTOCONF_FILENAME file.
4687  */
4688  if ((record->context == PGC_INTERNAL) ||
4689  (record->flags & GUC_DISALLOW_IN_FILE) ||
4690  (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
4691  ereport(ERROR,
4692  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4693  errmsg("parameter \"%s\" cannot be changed",
4694  name)));
4695 
4696  /*
4697  * If a value is specified, verify that it's sane.
4698  */
4699  if (value)
4700  {
4701  union config_var_val newval;
4702  void *newextra = NULL;
4703 
4704  if (!parse_and_validate_value(record, value,
4705  PGC_S_FILE, ERROR,
4706  &newval, &newextra))
4707  ereport(ERROR,
4708  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4709  errmsg("invalid value for parameter \"%s\": \"%s\"",
4710  name, value)));
4711 
4712  if (record->vartype == PGC_STRING && newval.stringval != NULL)
4713  guc_free(newval.stringval);
4714  guc_free(newextra);
4715  }
4716  }
4717  else
4718  {
4719  /*
4720  * Variable not known; check we'd be allowed to create it. (We
4721  * cannot validate the value, but that's fine. A non-core GUC in
4722  * the config file cannot cause postmaster start to fail, so we
4723  * don't have to be too tense about possibly installing a bad
4724  * value.)
4725  */
4726  (void) assignable_custom_variable_name(name, false, ERROR);
4727  }
4728 
4729  /*
4730  * We must also reject values containing newlines, because the grammar
4731  * for config files doesn't support embedded newlines in string
4732  * literals.
4733  */
4734  if (value && strchr(value, '\n'))
4735  ereport(ERROR,
4736  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4737  errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4738  }
4739 
4740  /*
4741  * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4742  * the data directory, so we can reference them by simple relative paths.
4743  */
4744  snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4746  snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4747  AutoConfFileName,
4748  "tmp");
4749 
4750  /*
4751  * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4752  * time. Use AutoFileLock to ensure that. We must hold the lock while
4753  * reading the old file contents.
4754  */
4755  LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4756 
4757  /*
4758  * If we're going to reset everything, then no need to open or parse the
4759  * old file. We'll just write out an empty list.
4760  */
4761  if (!resetall)
4762  {
4763  struct stat st;
4764 
4765  if (stat(AutoConfFileName, &st) == 0)
4766  {
4767  /* open old file PG_AUTOCONF_FILENAME */
4768  FILE *infile;
4769 
4770  infile = AllocateFile(AutoConfFileName, "r");
4771  if (infile == NULL)
4772  ereport(ERROR,
4774  errmsg("could not open file \"%s\": %m",
4775  AutoConfFileName)));
4776 
4777  /* parse it */
4778  if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4779  LOG, &head, &tail))
4780  ereport(ERROR,
4781  (errcode(ERRCODE_CONFIG_FILE_ERROR),
4782  errmsg("could not parse contents of file \"%s\"",
4783  AutoConfFileName)));
4784 
4785  FreeFile(infile);
4786  }
4787 
4788  /*
4789  * Now, replace any existing entry with the new value, or add it if
4790  * not present.
4791  */
4792  replace_auto_config_value(&head, &tail, name, value);
4793  }
4794 
4795  /*
4796  * Invoke the post-alter hook for setting this GUC variable. GUCs
4797  * typically do not have corresponding entries in pg_parameter_acl, so we
4798  * call the hook using the name rather than a potentially-non-existent
4799  * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4800  * context can be distinguished from others. (Note that "name" will be
4801  * NULL in the RESET ALL case.)
4802  *
4803  * We do this here rather than at the end, because ALTER SYSTEM is not
4804  * transactional. If the hook aborts our transaction, it will be cleaner
4805  * to do so before we touch any files.
4806  */
4807  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4809  altersysstmt->setstmt->kind,
4810  false);
4811 
4812  /*
4813  * To ensure crash safety, first write the new file data to a temp file,
4814  * then atomically rename it into place.
4815  *
4816  * If there is a temp file left over due to a previous crash, it's okay to
4817  * truncate and reuse it.
4818  */
4819  Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4820  O_CREAT | O_RDWR | O_TRUNC);
4821  if (Tmpfd < 0)
4822  ereport(ERROR,
4824  errmsg("could not open file \"%s\": %m",
4825  AutoConfTmpFileName)));
4826 
4827  /*
4828  * Use a TRY block to clean up the file if we fail. Since we need a TRY
4829  * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4830  */
4831  PG_TRY();
4832  {
4833  /* Write and sync the new contents to the temporary file */
4834  write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4835 
4836  /* Close before renaming; may be required on some platforms */
4837  close(Tmpfd);
4838  Tmpfd = -1;
4839 
4840  /*
4841  * As the rename is atomic operation, if any problem occurs after this
4842  * at worst it can lose the parameters set by last ALTER SYSTEM
4843  * command.
4844  */
4845  durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4846  }
4847  PG_CATCH();
4848  {
4849  /* Close file first, else unlink might fail on some platforms */
4850  if (Tmpfd >= 0)
4851  close(Tmpfd);
4852 
4853  /* Unlink, but ignore any error */
4854  (void) unlink(AutoConfTmpFileName);
4855 
4856  PG_RE_THROW();
4857  }
4858  PG_END_TRY();
4859 
4860  FreeConfigVariables(head);
4861 
4862  LWLockRelease(AutoFileLock);
4863 }
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
AclResult pg_parameter_aclcheck(const char *name, Oid roleid, AclMode mode)
Definition: aclchk.c:4038
#define CONF_FILE_START_DEPTH
Definition: conffiles.h:17
int errcode_for_file_access(void)
Definition: elog.c:876
#define LOG
Definition: elog.h:31
#define PG_RE_THROW()
Definition: elog.h:412
#define PG_TRY(...)
Definition: elog.h:371
#define PG_END_TRY(...)
Definition: elog.h:396
#define ERROR
Definition: elog.h:39
#define PG_CATCH(...)
Definition: elog.h:381
#define elog(elevel,...)
Definition: elog.h:225
#define DEBUG5
Definition: elog.h:26
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2605
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:781
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:1086
int FreeFile(FILE *file)
Definition: fd.c:2803
static bool assignable_custom_variable_name(const char *name, bool skip_errors, int elevel)
Definition: guc.c:1121
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1235
static bool parse_and_validate_value(struct config_generic *record, const char *value, GucSource source, int elevel, union config_var_val *newval, void **newextra)
Definition: guc.c:3129
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head)
Definition: guc.c:4469
#define newval
static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
Definition: guc.c:4537
#define PG_AUTOCONF_FILENAME
Definition: guc.h:33
void FreeConfigVariables(ConfigVariable *list)
bool ParseConfigFp(FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
#define GUC_DISALLOW_IN_FILE
Definition: guc.h:218
@ PGC_S_FILE
Definition: guc.h:112
#define GUC_DISALLOW_IN_AUTO_FILE
Definition: guc.h:223
@ PGC_INTERNAL
Definition: guc.h:69
char * ExtractSetVariableArgs(VariableSetStmt *stmt)
Definition: guc_funcs.c:167
bool AllowAlterSystem
Definition: guc_tables.c:489
static struct @160 value
#define close(a)
Definition: win32.h:12
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1168
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1781
@ LW_EXCLUSIVE
Definition: lwlock.h:114
Oid GetUserId(void)
Definition: miscinit.c:524
#define InvokeObjectPostAlterHookArgStr(classId, objectName, subId, auxiliaryId, is_internal)
Definition: objectaccess.h:247
@ VAR_SET_DEFAULT
Definition: parsenodes.h:2620
@ VAR_RESET
Definition: parsenodes.h:2623
@ VAR_SET_VALUE
Definition: parsenodes.h:2619
@ VAR_RESET_ALL
Definition: parsenodes.h:2624
#define ACL_ALTER_SYSTEM
Definition: parsenodes.h:89
#define MAXPGPATH
#define snprintf
Definition: port.h:238
VariableSetStmt * setstmt
Definition: parsenodes.h:3843
VariableSetKind kind
Definition: parsenodes.h:2632
bool superuser(void)
Definition: superuser.c:46
#define stat
Definition: win32_port.h:284
static void infile(const char *name)
Definition: zic.c:1243

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

Referenced by standard_ProcessUtility().

◆ assignable_custom_variable_name()

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

Definition at line 1121 of file guc.c.

1122 {
1123  /* If there's no separator, it can't be a custom variable */
1124  const char *sep = strchr(name, GUC_QUALIFIER_SEPARATOR);
1125 
1126  if (sep != NULL)
1127  {
1128  size_t classLen = sep - name;
1129  ListCell *lc;
1130 
1131  /* The name must be syntactically acceptable ... */
1133  {
1134  if (!skip_errors)
1135  ereport(elevel,
1136  (errcode(ERRCODE_INVALID_NAME),
1137  errmsg("invalid configuration parameter name \"%s\"",
1138  name),
1139  errdetail("Custom parameter names must be two or more simple identifiers separated by dots.")));
1140  return false;
1141  }
1142  /* ... and it must not match any previously-reserved prefix */
1143  foreach(lc, reserved_class_prefix)
1144  {
1145  const char *rcprefix = lfirst(lc);
1146 
1147  if (strlen(rcprefix) == classLen &&
1148  strncmp(name, rcprefix, classLen) == 0)
1149  {
1150  if (!skip_errors)
1151  ereport(elevel,
1152  (errcode(ERRCODE_INVALID_NAME),
1153  errmsg("invalid configuration parameter name \"%s\"",
1154  name),
1155  errdetail("\"%s\" is a reserved prefix.",
1156  rcprefix)));
1157  return false;
1158  }
1159  }
1160  /* OK to create it */
1161  return true;
1162  }
1163 
1164  /* Unrecognized single-part name */
1165  if (!skip_errors)
1166  ereport(elevel,
1167  (errcode(ERRCODE_UNDEFINED_OBJECT),
1168  errmsg("unrecognized configuration parameter \"%s\"",
1169  name)));
1170  return false;
1171 }
int errdetail(const char *fmt,...)
Definition: elog.c:1203
static bool valid_custom_variable_name(const char *name)
Definition: guc.c:1076
static List * reserved_class_prefix
Definition: guc.c:78
#define GUC_QUALIFIER_SEPARATOR
Definition: guc.h:204
#define lfirst(lc)
Definition: pg_list.h:172

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

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

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

Referenced by AbortSubTransaction(), AbortTransaction(), brin_summarize_range(), bt_index_check_internal(), cluster_rel(), CommitSubTransaction(), CommitTransaction(), ComputeIndexAttrs(), CreateSchemaCommand(), DefineIndex(), do_analyze_rel(), 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 2215 of file guc.c.

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

References elog, GUCNestLevel, and WARNING.

Referenced by StartTransaction().

◆ BeginReportingGUCOptions()

void BeginReportingGUCOptions ( void  )

Definition at line 2546 of file guc.c.

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

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

904 {
905  int size_vars;
906  int num_vars = 0;
907  HASHCTL hash_ctl;
908  GUCHashEntry *hentry;
909  bool found;
910  int i;
911 
912  /*
913  * Create the memory context that will hold all GUC-related data.
914  */
915  Assert(GUCMemoryContext == NULL);
917  "GUCMemoryContext",
919 
920  /*
921  * Count all the built-in variables, and set their vartypes correctly.
922  */
923  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
924  {
925  struct config_bool *conf = &ConfigureNamesBool[i];
926 
927  /* Rather than requiring vartype to be filled in by hand, do this: */
928  conf->gen.vartype = PGC_BOOL;
929  num_vars++;
930  }
931 
932  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
933  {
934  struct config_int *conf = &ConfigureNamesInt[i];
935 
936  conf->gen.vartype = PGC_INT;
937  num_vars++;
938  }
939 
940  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
941  {
942  struct config_real *conf = &ConfigureNamesReal[i];
943 
944  conf->gen.vartype = PGC_REAL;
945  num_vars++;
946  }
947 
948  for (i = 0; ConfigureNamesString[i].gen.name; i++)
949  {
950  struct config_string *conf = &ConfigureNamesString[i];
951 
952  conf->gen.vartype = PGC_STRING;
953  num_vars++;
954  }
955 
956  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
957  {
958  struct config_enum *conf = &ConfigureNamesEnum[i];
959 
960  conf->gen.vartype = PGC_ENUM;
961  num_vars++;
962  }
963 
964  /*
965  * Create hash table with 20% slack
966  */
967  size_vars = num_vars + num_vars / 4;
968 
969  hash_ctl.keysize = sizeof(char *);
970  hash_ctl.entrysize = sizeof(GUCHashEntry);
971  hash_ctl.hash = guc_name_hash;
972  hash_ctl.match = guc_name_match;
973  hash_ctl.hcxt = GUCMemoryContext;
974  guc_hashtab = hash_create("GUC hash table",
975  size_vars,
976  &hash_ctl,
978 
979  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
980  {
981  struct config_generic *gucvar = &ConfigureNamesBool[i].gen;
982 
983  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
984  &gucvar->name,
985  HASH_ENTER,
986  &found);
987  Assert(!found);
988  hentry->gucvar = gucvar;
989  }
990 
991  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
992  {
993  struct config_generic *gucvar = &ConfigureNamesInt[i].gen;
994 
995  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
996  &gucvar->name,
997  HASH_ENTER,
998  &found);
999  Assert(!found);
1000  hentry->gucvar = gucvar;
1001  }
1002 
1003  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
1004  {
1005  struct config_generic *gucvar = &ConfigureNamesReal[i].gen;
1006 
1007  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1008  &gucvar->name,
1009  HASH_ENTER,
1010  &found);
1011  Assert(!found);
1012  hentry->gucvar = gucvar;
1013  }
1014 
1015  for (i = 0; ConfigureNamesString[i].gen.name; i++)
1016  {
1017  struct config_generic *gucvar = &ConfigureNamesString[i].gen;
1018 
1019  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1020  &gucvar->name,
1021  HASH_ENTER,
1022  &found);
1023  Assert(!found);
1024  hentry->gucvar = gucvar;
1025  }
1026 
1027  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
1028  {
1029  struct config_generic *gucvar = &ConfigureNamesEnum[i].gen;
1030 
1031  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1032  &gucvar->name,
1033  HASH_ENTER,
1034  &found);
1035  Assert(!found);
1036  hentry->gucvar = gucvar;
1037  }
1038 
1039  Assert(num_vars == hash_get_num_entries(guc_hashtab));
1040 }
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:352
long hash_get_num_entries(HTAB *hashp)
Definition: dynahash.c:1341
static int guc_name_match(const void *key1, const void *key2, Size keysize)
Definition: guc.c:1354
static uint32 guc_name_hash(const void *key, Size keysize)
Definition: guc.c:1330
static MemoryContext GUCMemoryContext
Definition: guc.c:199
struct config_string ConfigureNamesString[]
Definition: guc_tables.c:4005
struct config_int ConfigureNamesInt[]
Definition: guc_tables.c:2086
struct config_bool ConfigureNamesBool[]
Definition: guc_tables.c:770
struct config_real ConfigureNamesReal[]
Definition: guc_tables.c:3724
struct config_enum ConfigureNamesEnum[]
Definition: guc_tables.c:4804
@ HASH_ENTER
Definition: hsearch.h:114
#define HASH_CONTEXT
Definition: hsearch.h:102
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_COMPARE
Definition: hsearch.h:99
#define HASH_FUNCTION
Definition: hsearch.h:98
int i
Definition: isn.c:72
MemoryContext TopMemoryContext
Definition: mcxt.c:149
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
Size keysize
Definition: hsearch.h:75
HashValueFunc hash
Definition: hsearch.h:78
Size entrysize
Definition: hsearch.h:76
HashCompareFunc match
Definition: hsearch.h:80
MemoryContext hcxt
Definition: hsearch.h:86

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

6800 {
6801  /* Quick success if no hook */
6802  if (!conf->check_hook)
6803  return true;
6804 
6805  /* Reset variables that might be set by hook */
6806  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6807  GUC_check_errmsg_string = NULL;
6809  GUC_check_errhint_string = NULL;
6810 
6811  if (!conf->check_hook(newval, extra, source))
6812  {
6813  ereport(elevel,
6817  errmsg("invalid value for parameter \"%s\": %d",
6818  conf->gen.name, (int) *newval),
6822  errhint("%s", GUC_check_errhint_string) : 0));
6823  /* Flush any strings created in ErrorContext */
6824  FlushErrorState();
6825  return false;
6826  }
6827 
6828  return true;
6829 }
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
int errdetail_internal(const char *fmt,...)
Definition: elog.c:1230
void FlushErrorState(void)
Definition: elog.c:1867
int errhint(const char *fmt,...)
Definition: elog.c:1317
char * GUC_check_errhint_string
Definition: guc.c:83
char * GUC_check_errmsg_string
Definition: guc.c:81
static int GUC_check_errcode_value
Definition: guc.c:76
char * GUC_check_errdetail_string
Definition: guc.c:82
static rewind_source * source
Definition: pg_rewind.c:89
GucBoolCheckHook check_hook
Definition: guc_tables.h:204

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

6952 {
6953  /* Quick success if no hook */
6954  if (!conf->check_hook)
6955  return true;
6956 
6957  /* Reset variables that might be set by hook */
6958  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6959  GUC_check_errmsg_string = NULL;
6961  GUC_check_errhint_string = NULL;
6962 
6963  if (!conf->check_hook(newval, extra, source))
6964  {
6965  ereport(elevel,
6969  errmsg("invalid value for parameter \"%s\": \"%s\"",
6970  conf->gen.name,
6975  errhint("%s", GUC_check_errhint_string) : 0));
6976  /* Flush any strings created in ErrorContext */
6977  FlushErrorState();
6978  return false;
6979  }
6980 
6981  return true;
6982 }
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:3023
GucEnumCheckHook check_hook
Definition: guc_tables.h:275

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

6834 {
6835  /* Quick success if no hook */
6836  if (!conf->check_hook)
6837  return true;
6838 
6839  /* Reset variables that might be set by hook */
6840  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6841  GUC_check_errmsg_string = NULL;
6843  GUC_check_errhint_string = NULL;
6844 
6845  if (!conf->check_hook(newval, extra, source))
6846  {
6847  ereport(elevel,
6851  errmsg("invalid value for parameter \"%s\": %d",
6852  conf->gen.name, *newval),
6856  errhint("%s", GUC_check_errhint_string) : 0));
6857  /* Flush any strings created in ErrorContext */
6858  FlushErrorState();
6859  return false;
6860  }
6861 
6862  return true;
6863 }
GucIntCheckHook check_hook
Definition: guc_tables.h:220

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

6868 {
6869  /* Quick success if no hook */
6870  if (!conf->check_hook)
6871  return true;
6872 
6873  /* Reset variables that might be set by hook */
6874  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6875  GUC_check_errmsg_string = NULL;
6877  GUC_check_errhint_string = NULL;
6878 
6879  if (!conf->check_hook(newval, extra, source))
6880  {
6881  ereport(elevel,
6885  errmsg("invalid value for parameter \"%s\": %g",
6886  conf->gen.name, *newval),
6890  errhint("%s", GUC_check_errhint_string) : 0));
6891  /* Flush any strings created in ErrorContext */
6892  FlushErrorState();
6893  return false;
6894  }
6895 
6896  return true;
6897 }
GucRealCheckHook check_hook
Definition: guc_tables.h:236

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

6902 {
6903  volatile bool result = true;
6904 
6905  /* Quick success if no hook */
6906  if (!conf->check_hook)
6907  return true;
6908 
6909  /*
6910  * If elevel is ERROR, or if the check_hook itself throws an elog
6911  * (undesirable, but not always avoidable), make sure we don't leak the
6912  * already-malloc'd newval string.
6913  */
6914  PG_TRY();
6915  {
6916  /* Reset variables that might be set by hook */
6917  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6918  GUC_check_errmsg_string = NULL;
6920  GUC_check_errhint_string = NULL;
6921 
6922  if (!conf->check_hook(newval, extra, source))
6923  {
6924  ereport(elevel,
6928  errmsg("invalid value for parameter \"%s\": \"%s\"",
6929  conf->gen.name, *newval ? *newval : ""),
6933  errhint("%s", GUC_check_errhint_string) : 0));
6934  /* Flush any strings created in ErrorContext */
6935  FlushErrorState();
6936  result = false;
6937  }
6938  }
6939  PG_CATCH();
6940  {
6941  guc_free(*newval);
6942  PG_RE_THROW();
6943  }
6944  PG_END_TRY();
6945 
6946  return result;
6947 }
GucStringCheckHook check_hook
Definition: guc_tables.h:260

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

5815 {
5816  /*
5817  * We can skip GUCs that are guaranteed to have the same values in leaders
5818  * and workers. (Note it is critical that the leader and worker have the
5819  * same idea of which GUCs fall into this category. It's okay to consider
5820  * context and name for this purpose, since those are unchanging
5821  * properties of a GUC.)
5822  *
5823  * PGC_POSTMASTER variables always have the same value in every child of a
5824  * particular postmaster, so the worker will certainly have the right
5825  * value already. Likewise, PGC_INTERNAL variables are set by special
5826  * mechanisms (if indeed they aren't compile-time constants). So we may
5827  * always skip these.
5828  *
5829  * For all other GUCs, we skip if the GUC has its compiled-in default
5830  * value (i.e., source == PGC_S_DEFAULT). On the leader side, this means
5831  * we don't send GUCs that have their default values, which typically
5832  * saves lots of work. On the worker side, this means we don't need to
5833  * reset the GUC to default because it already has that value. See
5834  * comments in RestoreGUCState for more info.
5835  */
5836  return gconf->context == PGC_POSTMASTER ||
5837  gconf->context == PGC_INTERNAL ||
5838  gconf->source == PGC_S_DEFAULT;
5839 }
@ PGC_S_DEFAULT
Definition: guc.h:109
@ PGC_POSTMASTER
Definition: guc.h:70
GucSource source
Definition: guc_tables.h:165

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

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

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

3074 {
3075  const struct config_enum_entry *entry;
3076  StringInfoData retstr;
3077  int seplen;
3078 
3079  initStringInfo(&retstr);
3080  appendStringInfoString(&retstr, prefix);
3081 
3082  seplen = strlen(separator);
3083  for (entry = record->options; entry && entry->name; entry++)
3084  {
3085  if (!entry->hidden)
3086  {
3087  appendStringInfoString(&retstr, entry->name);
3088  appendBinaryStringInfo(&retstr, separator, seplen);
3089  }
3090  }
3091 
3092  /*
3093  * All the entries may have been hidden, leaving the string empty if no
3094  * prefix was given. This indicates a broken GUC setup, since there is no
3095  * use for an enum without any values, so we just check to make sure we
3096  * don't write to invalid memory instead of actually trying to do
3097  * something smart with it.
3098  */
3099  if (retstr.len >= seplen)
3100  {
3101  /* Replace final separator */
3102  retstr.data[retstr.len - seplen] = '\0';
3103  retstr.len -= seplen;
3104  }
3105 
3106  appendStringInfoString(&retstr, suffix);
3107 
3108  return retstr.data;
3109 }
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
Definition: stringinfo.c:230
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:179
void initStringInfo(StringInfo str)
Definition: stringinfo.c:56
Definition: guc.h:170
const char * name
Definition: guc.h:171
bool hidden
Definition: guc.h:173
const struct config_enum_entry * options
Definition: guc_tables.h:274

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

3048 {
3049  const struct config_enum_entry *entry;
3050 
3051  for (entry = record->options; entry && entry->name; entry++)
3052  {
3053  if (pg_strcasecmp(value, entry->name) == 0)
3054  {
3055  *retval = entry->val;
3056  return true;
3057  }
3058  }
3059 
3060  *retval = 0;
3061  return false;
3062 }
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
int val
Definition: guc.h:172

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

3024 {
3025  const struct config_enum_entry *entry;
3026 
3027  for (entry = record->options; entry && entry->name; entry++)
3028  {
3029  if (entry->val == val)
3030  return entry->name;
3031  }
3032 
3033  elog(ERROR, "could not find enum option %d for %s",
3034  val, record->gen.name);
3035  return NULL; /* silence compiler */
3036 }
long val
Definition: informix.c:689

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(), serialize_variable(), and ShowGUCOption().

◆ convert_GUC_name_for_parameter_acl()

char* convert_GUC_name_for_parameter_acl ( const char *  name)

Definition at line 1374 of file guc.c.

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

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

2731 {
2732  const unit_conversion *table;
2733  int i;
2734 
2735  *unit = NULL;
2736 
2737  if (base_unit & GUC_UNIT_MEMORY)
2739  else
2741 
2742  for (i = 0; *table[i].unit; i++)
2743  {
2744  if (base_unit == table[i].base_unit)
2745  {
2746  /*
2747  * Accept the first conversion that divides the value evenly. We
2748  * assume that the conversions for each base unit are ordered from
2749  * greatest unit to the smallest!
2750  */
2751  if (table[i].multiplier <= 1.0 ||
2752  base_value % (int64) table[i].multiplier == 0)
2753  {
2754  *value = (int64) rint(base_value / table[i].multiplier);
2755  *unit = table[i].unit;
2756  break;
2757  }
2758  }
2759  }
2760 
2761  Assert(*unit != NULL);
2762 }
static const unit_conversion memory_unit_conversion_table[]
Definition: guc.c:121
static const unit_conversion time_unit_conversion_table[]
Definition: guc.c:158
#define GUC_UNIT_MEMORY
Definition: guc.h:233
char unit[MAX_UNIT_LEN+1]
Definition: guc.c:105

References Assert, GUC_UNIT_MEMORY, i, memory_unit_conversion_table, time_unit_conversion_table, unit_conversion::unit, 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 2771 of file guc.c.

2773 {
2774  const unit_conversion *table;
2775  int i;
2776 
2777  *unit = NULL;
2778 
2779  if (base_unit & GUC_UNIT_MEMORY)
2781  else
2783 
2784  for (i = 0; *table[i].unit; i++)
2785  {
2786  if (base_unit == table[i].base_unit)
2787  {
2788  /*
2789  * Accept the first conversion that divides the value evenly; or
2790  * if there is none, use the smallest (last) target unit.
2791  *
2792  * What we actually care about here is whether snprintf with "%g"
2793  * will print the value as an integer, so the obvious test of
2794  * "*value == rint(*value)" is too strict; roundoff error might
2795  * make us choose an unreasonably small unit. As a compromise,
2796  * accept a divisor that is within 1e-8 of producing an integer.
2797  */
2798  *value = base_value / table[i].multiplier;
2799  *unit = table[i].unit;
2800  if (*value > 0 &&
2801  fabs((rint(*value) / *value) - 1.0) <= 1e-8)
2802  break;
2803  }
2804  }
2805 
2806  Assert(*unit != NULL);
2807 }
e
Definition: preproc-init.c:82
double multiplier
Definition: guc.c:108

References Assert, GUC_UNIT_MEMORY, i, memory_unit_conversion_table, unit_conversion::multiplier, time_unit_conversion_table, unit_conversion::unit, 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 2671 of file guc.c.

2673 {
2674  char unitstr[MAX_UNIT_LEN + 1];
2675  int unitlen;
2676  const unit_conversion *table;
2677  int i;
2678 
2679  /* extract unit string to compare to table entries */
2680  unitlen = 0;
2681  while (*unit != '\0' && !isspace((unsigned char) *unit) &&
2682  unitlen < MAX_UNIT_LEN)
2683  unitstr[unitlen++] = *(unit++);
2684  unitstr[unitlen] = '\0';
2685  /* allow whitespace after unit */
2686  while (isspace((unsigned char) *unit))
2687  unit++;
2688  if (*unit != '\0')
2689  return false; /* unit too long, or garbage after it */
2690 
2691  /* now search the appropriate table */
2692  if (base_unit & GUC_UNIT_MEMORY)
2694  else
2696 
2697  for (i = 0; *table[i].unit; i++)
2698  {
2699  if (base_unit == table[i].base_unit &&
2700  strcmp(unitstr, table[i].unit) == 0)
2701  {
2702  double cvalue = value * table[i].multiplier;
2703 
2704  /*
2705  * If the user gave a fractional value such as "30.1GB", round it
2706  * off to the nearest multiple of the next smaller unit, if there
2707  * is one.
2708  */
2709  if (*table[i + 1].unit &&
2710  base_unit == table[i + 1].base_unit)
2711  cvalue = rint(cvalue / table[i + 1].multiplier) *
2712  table[i + 1].multiplier;
2713 
2714  *base_value = cvalue;
2715  return true;
2716  }
2717  }
2718  return false;
2719 }
#define MAX_UNIT_LEN
Definition: guc.c:101

References GUC_UNIT_MEMORY, i, MAX_UNIT_LEN, memory_unit_conversion_table, unit_conversion::multiplier, time_unit_conversion_table, unit_conversion::unit, 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 4931 of file guc.c.

4932 {
4933  const char *name = variable->name;
4934  GUCHashEntry *hentry;
4935  struct config_string *pHolder;
4936 
4937  /* Check mapping between initial and default value */
4938  Assert(check_GUC_init(variable));
4939 
4940  /*
4941  * See if there's a placeholder by the same name.
4942  */
4943  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
4944  &name,
4945  HASH_FIND,
4946  NULL);
4947  if (hentry == NULL)
4948  {
4949  /*
4950  * No placeholder to replace, so we can just add it ... but first,
4951  * make sure it's initialized to its default value.
4952  */
4955  return;
4956  }
4957 
4958  /*
4959  * This better be a placeholder
4960  */
4961  if ((hentry->gucvar->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
4962  ereport(ERROR,
4963  (errcode(ERRCODE_INTERNAL_ERROR),
4964  errmsg("attempt to redefine parameter \"%s\"", name)));
4965 
4966  Assert(hentry->gucvar->vartype == PGC_STRING);
4967  pHolder = (struct config_string *) hentry->gucvar;
4968 
4969  /*
4970  * First, set the variable to its default value. We must do this even
4971  * though we intend to immediately apply a new value, since it's possible
4972  * that the new value is invalid.
4973  */
4975 
4976  /*
4977  * Replace the placeholder in the hash table. We aren't changing the name
4978  * (at least up to case-folding), so the hash value is unchanged.
4979  */
4980  hentry->gucname = name;
4981  hentry->gucvar = variable;
4982 
4983  /*
4984  * Remove the placeholder from any lists it's in, too.
4985  */
4986  RemoveGUCFromLists(&pHolder->gen);
4987 
4988  /*
4989  * Assign the string value(s) stored in the placeholder to the real
4990  * variable. Essentially, we need to duplicate all the active and stacked
4991  * values, but with appropriate validation and datatype adjustment.
4992  *
4993  * If an assignment fails, we report a WARNING and keep going. We don't
4994  * want to throw ERROR for bad values, because it'd bollix the add-on
4995  * module that's presumably halfway through getting loaded. In such cases
4996  * the default or previous state will become active instead.
4997  */
4998 
4999  /* First, apply the reset value if any */
5000  if (pHolder->reset_val)
5001  (void) set_config_option_ext(name, pHolder->reset_val,
5002  pHolder->gen.reset_scontext,
5003  pHolder->gen.reset_source,
5004  pHolder->gen.reset_srole,
5005  GUC_ACTION_SET, true, WARNING, false);
5006  /* That should not have resulted in stacking anything */
5007  Assert(variable->stack == NULL);
5008 
5009  /* Now, apply current and stacked values, in the order they were stacked */
5010  reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
5011  *(pHolder->variable),
5012  pHolder->gen.scontext, pHolder->gen.source,
5013  pHolder->gen.srole);
5014 
5015  /* Also copy over any saved source-location information */
5016  if (pHolder->gen.sourcefile)
5018  pHolder->gen.sourceline);
5019 
5020  /*
5021  * Free up as much as we conveniently can of the placeholder structure.
5022  * (This neglects any stack items, so it's possible for some memory to be
5023  * leaked. Since this can only happen once per session per variable, it
5024  * doesn't seem worth spending much code on.)
5025  */
5026  set_string_field(pHolder, pHolder->variable, NULL);
5027  set_string_field(pHolder, &pHolder->reset_val, NULL);
5028 
5029  guc_free(pHolder);
5030 }
int set_config_option_ext(const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3382
static void set_config_sourcefile(const char *name, char *sourcefile, int sourceline)
Definition: guc.c:4299
static void reapply_stacked_values(struct config_generic *variable, struct config_string *pHolder, GucStack *stack, const char *curvalue, GucContext curscontext, GucSource cursource, Oid cursrole)
Definition: guc.c:5040
static void InitializeOneGUCOption(struct config_generic *gconf)
Definition: guc.c:1644
static void RemoveGUCFromLists(struct config_generic *gconf)
Definition: guc.c:1761
@ GUC_ACTION_SET
Definition: guc.h:199
@ HASH_FIND
Definition: hsearch.h:113
const char * gucname
Definition: guc.c:208
char * sourcefile
Definition: guc_tables.h:181
GucContext reset_scontext
Definition: guc_tables.h:168
GucSource reset_source
Definition: guc_tables.h:166
char * reset_val
Definition: guc_tables.h:264
char * name
Definition: type.h:190

References add_guc_variable(), Assert, ereport, errcode(), errmsg(), ERROR, config_generic::flags, config_string::gen, GUC_ACTION_SET, GUC_CUSTOM_PLACEHOLDER, guc_free(), 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(), set_string_field(), 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 5132 of file guc.c.

5142 {
5143  struct config_bool *var;
5144 
5145  var = (struct config_bool *)
5146  init_custom_variable(name, short_desc, long_desc, context, flags,
5147  PGC_BOOL, sizeof(struct config_bool));
5148  var->variable = valueAddr;
5149  var->boot_val = bootValue;
5150  var->reset_val = bootValue;
5151  var->check_hook = check_hook;
5152  var->assign_hook = assign_hook;
5153  var->show_hook = show_hook;
5154  define_custom_variable(&var->gen);
5155 }
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)
Definition: guc.c:4871
static void define_custom_variable(struct config_generic *variable)
Definition: guc.c:4931
tree context
Definition: radixtree.h:1835
bool reset_val
Definition: guc_tables.h:208
bool boot_val
Definition: guc_tables.h:203
GucShowHook show_hook
Definition: guc_tables.h:206

References config_bool::assign_hook, config_bool::boot_val, config_bool::check_hook, context, 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 5243 of file guc.c.

5254 {
5255  struct config_enum *var;
5256 
5257  var = (struct config_enum *)
5258  init_custom_variable(name, short_desc, long_desc, context, flags,
5259  PGC_ENUM, sizeof(struct config_enum));
5260  var->variable = valueAddr;
5261  var->boot_val = bootValue;
5262  var->reset_val = bootValue;
5263  var->options = options;
5264  var->check_hook = check_hook;
5265  var->assign_hook = assign_hook;
5266  var->show_hook = show_hook;
5267  define_custom_variable(&var->gen);
5268 }
static char ** options
GucShowHook show_hook
Definition: guc_tables.h:277

References config_enum::assign_hook, config_enum::boot_val, config_enum::check_hook, context, 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 5158 of file guc.c.

5170 {
5171  struct config_int *var;
5172 
5173  var = (struct config_int *)
5174  init_custom_variable(name, short_desc, long_desc, context, flags,
5175  PGC_INT, sizeof(struct config_int));
5176  var->variable = valueAddr;
5177  var->boot_val = bootValue;
5178  var->reset_val = bootValue;
5179  var->min = minValue;
5180  var->max = maxValue;
5181  var->check_hook = check_hook;
5182  var->assign_hook = assign_hook;
5183  var->show_hook = show_hook;
5184  define_custom_variable(&var->gen);
5185 }
int reset_val
Definition: guc_tables.h:224
int boot_val
Definition: guc_tables.h:217
GucShowHook show_hook
Definition: guc_tables.h:222

References config_int::assign_hook, config_int::boot_val, config_int::check_hook, context, 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 5188 of file guc.c.

5200 {
5201  struct config_real *var;
5202 
5203  var = (struct config_real *)
5204  init_custom_variable(name, short_desc, long_desc, context, flags,
5205  PGC_REAL, sizeof(struct config_real));
5206  var->variable = valueAddr;
5207  var->boot_val = bootValue;
5208  var->reset_val = bootValue;
5209  var->min = minValue;
5210  var->max = maxValue;
5211  var->check_hook = check_hook;
5212  var->assign_hook = assign_hook;
5213  var->show_hook = show_hook;
5214  define_custom_variable(&var->gen);
5215 }
double boot_val
Definition: guc_tables.h:233
double reset_val
Definition: guc_tables.h:240
double min
Definition: guc_tables.h:234
double max
Definition: guc_tables.h:235
GucShowHook show_hook
Definition: guc_tables.h:238

References config_real::assign_hook, config_real::boot_val, config_real::check_hook, context, 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 5218 of file guc.c.

5228 {
5229  struct config_string *var;
5230 
5231  var = (struct config_string *)
5232  init_custom_variable(name, short_desc, long_desc, context, flags,
5233  PGC_STRING, sizeof(struct config_string));
5234  var->variable = valueAddr;
5235  var->boot_val = bootValue;
5236  var->check_hook = check_hook;
5237  var->assign_hook = assign_hook;
5238  var->show_hook = show_hook;
5239  define_custom_variable(&var->gen);
5240 }
GucShowHook show_hook
Definition: guc_tables.h:262
const char * boot_val
Definition: guc_tables.h:259

References config_string::assign_hook, config_string::boot_val, config_string::check_hook, context, 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 846 of file guc.c.

847 {
848  switch (gconf->vartype)
849  {
850  case PGC_BOOL:
851  case PGC_INT:
852  case PGC_REAL:
853  case PGC_ENUM:
854  /* no need to do anything */
855  break;
856  case PGC_STRING:
857  set_string_field((struct config_string *) gconf,
858  &(val->val.stringval),
859  NULL);
860  break;
861  }
862  set_extra_field(gconf, &(val->extra), NULL);
863 }

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

5980 {
5981  va_list vargs;
5982  int n;
5983 
5984  if (*maxbytes <= 0)
5985  elog(ERROR, "not enough space to serialize GUC state");
5986 
5987  va_start(vargs, fmt);
5988  n = vsnprintf(*destptr, *maxbytes, fmt, vargs);
5989  va_end(vargs);
5990 
5991  if (n < 0)
5992  {
5993  /* Shouldn't happen. Better show errno description. */
5994  elog(ERROR, "vsnprintf failed: %m with format string \"%s\"", fmt);
5995  }
5996  if (n >= *maxbytes)
5997  {
5998  /* This shouldn't happen either, really. */
5999  elog(ERROR, "not enough space to serialize GUC state");
6000  }
6001 
6002  /* Shift the destptr ahead of the null terminator */
6003  *destptr += n + 1;
6004  *maxbytes -= n + 1;
6005 }
static void const char * fmt
va_end(args)
va_start(args, fmt)
#define vsnprintf
Definition: port.h:237

References elog, ERROR, fmt, va_end(), va_start(), 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 6009 of file guc.c.

6010 {
6011  if (valsize > *maxbytes)
6012  elog(ERROR, "not enough space to serialize GUC state");
6013 
6014  memcpy(*destptr, val, valsize);
6015  *destptr += valsize;
6016  *maxbytes -= valsize;
6017 }

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

5849 {
5850  Size size;
5851  Size valsize = 0;
5852 
5853  /* Skippable GUCs consume zero space. */
5854  if (can_skip_gucvar(gconf))
5855  return 0;
5856 
5857  /* Name, plus trailing zero byte. */
5858  size = strlen(gconf->name) + 1;
5859 
5860  /* Get the maximum display length of the GUC value. */
5861  switch (gconf->vartype)
5862  {
5863  case PGC_BOOL:
5864  {
5865  valsize = 5; /* max(strlen('true'), strlen('false')) */
5866  }
5867  break;
5868 
5869  case PGC_INT:
5870  {
5871  struct config_int *conf = (struct config_int *) gconf;
5872 
5873  /*
5874  * Instead of getting the exact display length, use max
5875  * length. Also reduce the max length for typical ranges of
5876  * small values. Maximum value is 2147483647, i.e. 10 chars.
5877  * Include one byte for sign.
5878  */
5879  if (abs(*conf->variable) < 1000)
5880  valsize = 3 + 1;
5881  else
5882  valsize = 10 + 1;
5883  }
5884  break;
5885 
5886  case PGC_REAL:
5887  {
5888  /*
5889  * We are going to print it with %e with REALTYPE_PRECISION
5890  * fractional digits. Account for sign, leading digit,
5891  * decimal point, and exponent with up to 3 digits. E.g.
5892  * -3.99329042340000021e+110
5893  */
5894  valsize = 1 + 1 + 1 + REALTYPE_PRECISION + 5;
5895  }
5896  break;
5897 
5898  case PGC_STRING:
5899  {
5900  struct config_string *conf = (struct config_string *) gconf;
5901 
5902  /*
5903  * If the value is NULL, we transmit it as an empty string.
5904  * Although this is not physically the same value, GUC
5905  * generally treats a NULL the same as empty string.
5906  */
5907  if (*conf->variable)
5908  valsize = strlen(*conf->variable);
5909  else
5910  valsize = 0;
5911  }
5912  break;
5913 
5914  case PGC_ENUM:
5915  {
5916  struct config_enum *conf = (struct config_enum *) gconf;
5917 
5918  valsize = strlen(config_enum_lookup_by_value(conf, *conf->variable));
5919  }
5920  break;
5921  }
5922 
5923  /* Allow space for terminating zero-byte for value */
5924  size = add_size(size, valsize + 1);
5925 
5926  if (gconf->sourcefile)
5927  size = add_size(size, strlen(gconf->sourcefile));
5928 
5929  /* Allow space for terminating zero-byte for sourcefile */
5930  size = add_size(size, 1);
5931 
5932  /* Include line whenever file is nonempty. */
5933  if (gconf->sourcefile && gconf->sourcefile[0])
5934  size = add_size(size, sizeof(gconf->sourceline));
5935 
5936  size = add_size(size, sizeof(gconf->source));
5937  size = add_size(size, sizeof(gconf->scontext));
5938  size = add_size(size, sizeof(gconf->srole));
5939 
5940  return size;
5941 }
size_t Size
Definition: c.h:610
static bool can_skip_gucvar(struct config_generic *gconf)
Definition: guc.c:5814
#define REALTYPE_PRECISION
Definition: guc.c:68
Size add_size(Size s1, Size s2)
Definition: shmem.c:493
static pg_noinline void Size size
Definition: slab.c:607

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, size, 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 5948 of file guc.c.

5949 {
5950  Size size;
5951  dlist_iter iter;
5952 
5953  /* Add space reqd for saving the data size of the guc state */
5954  size = sizeof(Size);
5955 
5956  /*
5957  * Add up the space needed for each GUC variable.
5958  *
5959  * We need only process non-default GUCs.
5960  */
5962  {
5963  struct config_generic *gconf = dlist_container(struct config_generic,
5964  nondef_link, iter.cur);
5965 
5967  }
5968 
5969  return size;
5970 }
static dlist_head guc_nondef_list
Definition: guc.c:222
static Size estimate_variable_size(struct config_generic *gconf)
Definition: guc.c:5848
#define dlist_foreach(iter, lhead)
Definition: ilist.h:623
#define dlist_container(type, membername, ptr)
Definition: ilist.h:593
dlist_node nondef_link
Definition: guc_tables.h:173
dlist_node * cur
Definition: ilist.h:179

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

Referenced by InitializeParallelDSM().

◆ extra_field_used()

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

Definition at line 747 of file guc.c.

748 {
749  GucStack *stack;
750 
751  if (extra == gconf->extra)
752  return true;
753  switch (gconf->vartype)
754  {
755  case PGC_BOOL:
756  if (extra == ((struct config_bool *) gconf)->reset_extra)
757  return true;
758  break;
759  case PGC_INT:
760  if (extra == ((struct config_int *) gconf)->reset_extra)
761  return true;
762  break;
763  case PGC_REAL:
764  if (extra == ((struct config_real *) gconf)->reset_extra)
765  return true;
766  break;
767  case PGC_STRING:
768  if (extra == ((struct config_string *) gconf)->reset_extra)
769  return true;
770  break;
771  case PGC_ENUM:
772  if (extra == ((struct config_enum *) gconf)->reset_extra)
773  return true;
774  break;
775  }
776  for (stack = gconf->stack; stack; stack = stack->prev)
777  {
778  if (extra == stack->prior.extra ||
779  extra == stack->masked.extra)
780  return true;
781  }
782 
783  return false;
784 }

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

1237 {
1238  GUCHashEntry *hentry;
1239  int i;
1240 
1241  Assert(name);
1242 
1243  /* Look it up using the hash table. */
1244  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1245  &name,
1246  HASH_FIND,
1247  NULL);
1248  if (hentry)
1249  return hentry->gucvar;
1250 
1251  /*
1252  * See if the name is an obsolete name for a variable. We assume that the
1253  * set of supported old names is short enough that a brute-force search is
1254  * the best way.
1255  */
1256  for (i = 0; map_old_guc_names[i] != NULL; i += 2)
1257  {
1259  return find_option(map_old_guc_names[i + 1], false,
1260  skip_errors, elevel);
1261  }
1262 
1263  if (create_placeholders)
1264  {
1265  /*
1266  * Check if the name is valid, and if so, add a placeholder.
1267  */
1268  if (assignable_custom_variable_name(name, skip_errors, elevel))
1269  return add_placeholder_variable(name, elevel);
1270  else
1271  return NULL; /* error message, if any, already emitted */
1272  }
1273 
1274  /* Unknown name and we're not supposed to make a placeholder */
1275  if (!skip_errors)
1276  ereport(elevel,
1277  (errcode(ERRCODE_UNDEFINED_OBJECT),
1278  errmsg("unrecognized configuration parameter \"%s\"",
1279  name)));
1280  return NULL;
1281 }
static struct config_generic * add_placeholder_variable(const char *name, int elevel)
Definition: guc.c:1177

References add_placeholder_variable(), Assert, assignable_custom_variable_name(), ereport, errcode(), errmsg(), 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(), 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().

◆ get_config_handle()

config_handle* get_config_handle ( const char *  name)

Definition at line 4284 of file guc.c.

4285 {
4286  struct config_generic *gen = find_option(name, false, false, 0);
4287 
4288  if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
4289  return gen;
4290 
4291  return NULL;
4292 }

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

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

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

5332 {
5333  struct config_generic **result;
5334  dlist_iter iter;
5335 
5336  *num = 0;
5337 
5338  /*
5339  * While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
5340  * it doesn't seem worth dynamically resizing this array.
5341  */
5342  result = palloc(sizeof(struct config_generic *) * hash_get_num_entries(guc_hashtab));
5343 
5344  /* We need only consider GUCs with source not PGC_S_DEFAULT */
5346  {
5347  struct config_generic *conf = dlist_container(struct config_generic,
5348  nondef_link, iter.cur);
5349  bool modified;
5350 
5351  /* return only parameters marked for inclusion in explain */
5352  if (!(conf->flags & GUC_EXPLAIN))
5353  continue;
5354 
5355  /* return only options visible to the current user */
5356  if (!ConfigOptionIsVisible(conf))
5357  continue;
5358 
5359  /* return only options that are different from their boot values */
5360  modified = false;
5361 
5362  switch (conf->vartype)
5363  {
5364  case PGC_BOOL:
5365  {
5366  struct config_bool *lconf = (struct config_bool *) conf;
5367 
5368  modified = (lconf->boot_val != *(lconf->variable));
5369  }
5370  break;
5371 
5372  case PGC_INT:
5373  {
5374  struct config_int *lconf = (struct config_int *) conf;
5375 
5376  modified = (lconf->boot_val != *(lconf->variable));
5377  }
5378  break;
5379 
5380  case PGC_REAL:
5381  {
5382  struct config_real *lconf = (struct config_real *) conf;
5383 
5384  modified = (lconf->boot_val != *(lconf->variable));
5385  }
5386  break;
5387 
5388  case PGC_STRING:
5389  {
5390  struct config_string *lconf = (struct config_string *) conf;
5391 
5392  if (lconf->boot_val == NULL &&
5393  *lconf->variable == NULL)
5394  modified = false;
5395  else if (lconf->boot_val == NULL ||
5396  *lconf->variable == NULL)
5397  modified = true;
5398  else
5399  modified = (strcmp(lconf->boot_val, *(lconf->variable)) != 0);
5400  }
5401  break;
5402 
5403  case PGC_ENUM:
5404  {
5405  struct config_enum *lconf = (struct config_enum *) conf;
5406 
5407  modified = (lconf->boot_val != *(lconf->variable));
5408  }
5409  break;
5410 
5411  default:
5412  elog(ERROR, "unexpected GUC type: %d", conf->vartype);
5413  }
5414 
5415  if (!modified)
5416  continue;
5417 
5418  /* OK, report it */
5419  result[*num] = conf;
5420  *num = *num + 1;
5421  }
5422 
5423  return result;
5424 }
#define GUC_EXPLAIN
Definition: guc.h:215
bool ConfigOptionIsVisible(struct config_generic *conf)
Definition: guc_funcs.c:581
void * palloc(Size size)
Definition: mcxt.c:1317

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

873 {
874  struct config_generic **result;
876  GUCHashEntry *hentry;
877  int i;
878 
879  *num_vars = hash_get_num_entries(guc_hashtab);
880  result = palloc(sizeof(struct config_generic *) * *num_vars);
881 
882  /* Extract pointers from the hash table */
883  i = 0;
885  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
886  result[i++] = hentry->gucvar;
887  Assert(i == *num_vars);
888 
889  /* Sort by name */
890  qsort(result, *num_vars,
891  sizeof(struct config_generic *), guc_var_compare);
892 
893  return result;
894 }
static int guc_var_compare(const void *a, const void *b)
Definition: guc.c:1288
#define qsort(a, b, c, d)
Definition: port.h:447

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

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

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

5433 {
5434  struct config_generic *record;
5435 
5436  record = find_option(name, false, missing_ok, ERROR);
5437  if (record == NULL)
5438  {
5439  if (varname)
5440  *varname = NULL;
5441  return NULL;
5442  }
5443 
5444  if (!ConfigOptionIsVisible(record))
5445  ereport(ERROR,
5446  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
5447  errmsg("permission denied to examine \"%s\"", name),
5448  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
5449  "pg_read_all_settings")));
5450 
5451  if (varname)
5452  *varname = record->name;
5453 
5454  return ShowGUCOption(record, true);
5455 }
char * ShowGUCOption(struct config_generic *record, bool use_units)
Definition: guc.c:5465

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

4453 {
4454  struct config_generic *record;
4455 
4456  record = find_option(name, false, missing_ok, ERROR);
4457  if (record == NULL)
4458  return 0;
4459  return record->flags;
4460 }

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

4406 {
4407  struct config_generic *record;
4408  static char buffer[256];
4409 
4410  record = find_option(name, false, false, ERROR);
4411  Assert(record != NULL);
4412  if (!ConfigOptionIsVisible(record))
4413  ereport(ERROR,
4414  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4415  errmsg("permission denied to examine \"%s\"", name),
4416  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4417  "pg_read_all_settings")));
4418 
4419  switch (record->vartype)
4420  {
4421  case PGC_BOOL:
4422  return ((struct config_bool *) record)->reset_val ? "on" : "off";
4423 
4424  case PGC_INT:
4425  snprintf(buffer, sizeof(buffer), "%d",
4426  ((struct config_int *) record)->reset_val);
4427  return buffer;
4428 
4429  case PGC_REAL:
4430  snprintf(buffer, sizeof(buffer), "%g",
4431  ((struct config_real *) record)->reset_val);
4432  return buffer;
4433 
4434  case PGC_STRING:
4435  return ((struct config_string *) record)->reset_val ?
4436  ((struct config_string *) record)->reset_val : "";
4437 
4438  case PGC_ENUM:
4439  return config_enum_lookup_by_value((struct config_enum *) record,
4440  ((struct config_enum *) record)->reset_val);
4441  }
4442  return NULL;
4443 }

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

◆ guc_free()

void guc_free ( void *  ptr)

Definition at line 689 of file guc.c.

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

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

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

◆ guc_malloc()

◆ guc_name_compare()

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

Definition at line 1300 of file guc.c.

1301 {
1302  /*
1303  * The temptation to use strcasecmp() here must be resisted, because the
1304  * hash mapping has to remain stable across setlocale() calls. So, build
1305  * our own with a simple ASCII-only downcasing.
1306  */
1307  while (*namea && *nameb)
1308  {
1309  char cha = *namea++;
1310  char chb = *nameb++;
1311 
1312  if (cha >= 'A' && cha <= 'Z')
1313  cha += 'a' - 'A';
1314  if (chb >= 'A' && chb <= 'Z')
1315  chb += 'a' - 'A';
1316  if (cha != chb)
1317  return cha - chb;
1318  }
1319  if (*namea)
1320  return 1; /* a is longer */
1321  if (*nameb)
1322  return -1; /* b is longer */
1323  return 0;
1324 }

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

◆ guc_name_hash()

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

Definition at line 1330 of file guc.c.

1331 {
1332  uint32 result = 0;
1333  const char *name = *(const char *const *) key;
1334 
1335  while (*name)
1336  {
1337  char ch = *name++;
1338 
1339  /* Case-fold in the same way as guc_name_compare */
1340  if (ch >= 'A' && ch <= 'Z')
1341  ch += 'a' - 'A';
1342 
1343  /* Merge into hash ... not very bright, but it needn't be */
1344  result = pg_rotate_left32(result, 5);
1345  result ^= (uint32) ch;
1346  }
1347  return result;
1348 }
unsigned int uint32
Definition: c.h:518
static uint32 pg_rotate_left32(uint32 word, int n)
Definition: pg_bitutils.h:404

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

1355 {
1356  const char *name1 = *(const char *const *) key1;
1357  const char *name2 = *(const char *const *) key2;
1358 
1359  return guc_name_compare(name1, name2);
1360 }

References guc_name_compare().

Referenced by build_guc_variables().

◆ guc_realloc()

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

Definition at line 652 of file guc.c.

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

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

◆ guc_restore_error_context_callback()

static void guc_restore_error_context_callback ( void *  arg)
static

Definition at line 6171 of file guc.c.

6172 {
6173  char **error_context_name_and_value = (char **) arg;
6174 
6175  if (error_context_name_and_value)
6176  errcontext("while setting parameter \"%s\" to \"%s\"",
6177  error_context_name_and_value[0],
6178  error_context_name_and_value[1]);
6179 }
#define errcontext
Definition: elog.h:196
void * arg

References arg, and errcontext.

Referenced by RestoreGUCState().

◆ guc_strdup()

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

Definition at line 677 of file guc.c.

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

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

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

◆ guc_var_compare()

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

Definition at line 1288 of file guc.c.

1289 {
1290  const char *namea = **(const char **const *) a;
1291  const char *nameb = **(const char **const *) b;
1292 
1293  return guc_name_compare(namea, nameb);
1294 }
int b
Definition: isn.c:69
int a
Definition: isn.c:68

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

6489 {
6490  struct config_generic *record;
6491  Datum datum;
6492  char *newval;
6493  ArrayType *a;
6494 
6495  Assert(name);
6496  Assert(value);
6497 
6498  /* test if the option is valid and we're allowed to set it */
6499  (void) validate_option_array_item(name, value, false);
6500 
6501  /* normalize name (converts obsolete GUC names to modern spellings) */
6502  record = find_option(name, false, true, WARNING);
6503  if (record)
6504  name = record->name;
6505 
6506  /* build new item for array */
6507  newval = psprintf("%s=%s", name, value);
6508  datum = CStringGetTextDatum(newval);
6509 
6510  if (array)
6511  {
6512  int index;
6513  bool isnull;
6514  int i;
6515 
6516  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6517  Assert(ARR_NDIM(array) == 1);
6518  Assert(ARR_LBOUND(array)[0] == 1);
6519 
6520  index = ARR_DIMS(array)[0] + 1; /* add after end */
6521 
6522  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6523  {
6524  Datum d;
6525  char *current;
6526 
6527  d = array_ref(array, 1, &i,
6528  -1 /* varlenarray */ ,
6529  -1 /* TEXT's typlen */ ,
6530  false /* TEXT's typbyval */ ,
6531  TYPALIGN_INT /* TEXT's typalign */ ,
6532  &isnull);
6533  if (isnull)
6534  continue;
6535  current = TextDatumGetCString(d);
6536 
6537  /* check for match up through and including '=' */
6538  if (strncmp(current, newval, strlen(name) + 1) == 0)
6539  {
6540  index = i;
6541  break;
6542  }
6543  }
6544 
6545  a = array_set(array, 1, &index,
6546  datum,
6547  false,
6548  -1 /* varlena array */ ,
6549  -1 /* TEXT's typlen */ ,
6550  false /* TEXT's typbyval */ ,
6551  TYPALIGN_INT /* TEXT's typalign */ );
6552  }
6553  else
6554  a = construct_array_builtin(&datum, 1, TEXTOID);
6555 
6556  return a;
6557 }
#define ARR_NDIM(a)
Definition: array.h:290
#define ARR_ELEMTYPE(a)
Definition: array.h:292
#define ARR_DIMS(a)
Definition: array.h:294
#define ARR_LBOUND(a)
Definition: array.h:296
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3381
ArrayType * array_set(ArrayType *array, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3163
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:3146
#define CStringGetTextDatum(s)
Definition: builtins.h:97
#define TextDatumGetCString(d)
Definition: builtins.h:98
static bool validate_option_array_item(const char *name, const char *value, bool skipIfNoPermissions)
Definition: guc.c:6708
uintptr_t Datum
Definition: postgres.h:64
char * psprintf(const char *fmt,...)
Definition: psprintf.c:43
Definition: type.h:95

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

Referenced by AlterSetting(), and update_proconfig_value().

◆ GUCArrayDelete()

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

Definition at line 6566 of file guc.c.

6567 {
6568  struct config_generic *record;
6569  ArrayType *newarray;
6570  int i;
6571  int index;
6572 
6573  Assert(name);
6574 
6575  /* test if the option is valid and we're allowed to set it */
6576  (void) validate_option_array_item(name, NULL, false);
6577 
6578  /* normalize name (converts obsolete GUC names to modern spellings) */
6579  record = find_option(name, false, true, WARNING);
6580  if (record)
6581  name = record->name;
6582 
6583  /* if array is currently null, then surely nothing to delete */
6584  if (!array)
6585  return NULL;
6586 
6587  newarray = NULL;
6588  index = 1;
6589 
6590  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6591  {
6592  Datum d;
6593  char *val;
6594  bool isnull;
6595 
6596  d = array_ref(array, 1, &i,
6597  -1 /* varlenarray */ ,
6598  -1 /* TEXT's typlen */ ,
6599  false /* TEXT's typbyval */ ,
6600  TYPALIGN_INT /* TEXT's typalign */ ,
6601  &isnull);
6602  if (isnull)
6603  continue;
6604  val = TextDatumGetCString(d);
6605 
6606  /* ignore entry if it's what we want to delete */
6607  if (strncmp(val, name, strlen(name)) == 0
6608  && val[strlen(name)] == '=')
6609  continue;
6610 
6611  /* else add it to the output array */
6612  if (newarray)
6613  newarray = array_set(newarray, 1, &index,
6614  d,
6615  false,
6616  -1 /* varlenarray */ ,
6617  -1 /* TEXT's typlen */ ,
6618  false /* TEXT's typbyval */ ,
6619  TYPALIGN_INT /* TEXT's typalign */ );
6620  else
6621  newarray = construct_array_builtin(&d, 1, TEXTOID);
6622 
6623  index++;
6624  }
6625 
6626  return newarray;
6627 }

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

6637 {
6638  ArrayType *newarray;
6639  int i;
6640  int index;
6641 
6642  /* if array is currently null, nothing to do */
6643  if (!array)
6644  return NULL;
6645 
6646  /* if we're superuser, we can delete everything, so just do it */
6647  if (superuser())
6648  return NULL;
6649 
6650  newarray = NULL;
6651  index = 1;
6652 
6653  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6654  {
6655  Datum d;
6656  char *val;
6657  char *eqsgn;
6658  bool isnull;
6659 
6660  d = array_ref(array, 1, &i,
6661  -1 /* varlenarray */ ,
6662  -1 /* TEXT's typlen */ ,
6663  false /* TEXT's typbyval */ ,
6664  TYPALIGN_INT /* TEXT's typalign */ ,
6665  &isnull);
6666  if (isnull)
6667  continue;
6668  val = TextDatumGetCString(d);
6669 
6670  eqsgn = strchr(val, '=');
6671  *eqsgn = '\0';
6672 
6673  /* skip if we have permission to delete it */
6674  if (validate_option_array_item(val, NULL, true))
6675  continue;
6676 
6677  /* else add it to the output array */
6678  if (newarray)
6679  newarray = array_set(newarray, 1, &index,
6680  d,
6681  false,
6682  -1 /* varlenarray */ ,
6683  -1 /* TEXT's typlen */ ,
6684  false /* TEXT's typbyval */ ,
6685  TYPALIGN_INT /* TEXT's typalign */ );
6686  else
6687  newarray = construct_array_builtin(&d, 1, TEXTOID);
6688 
6689  index++;
6690  pfree(val);
6691  }
6692 
6693  return newarray;
6694 }

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

4878 {
4879  struct config_generic *gen;
4880 
4881  /*
4882  * Only allow custom PGC_POSTMASTER variables to be created during shared
4883  * library preload; any later than that, we can't ensure that the value
4884  * doesn't change after startup. This is a fatal elog if it happens; just
4885  * erroring out isn't safe because we don't know what the calling loadable
4886  * module might already have hooked into.
4887  */
4888  if (context == PGC_POSTMASTER &&
4890  elog(FATAL, "cannot create PGC_POSTMASTER variables after startup");
4891 
4892  /*
4893  * We can't support custom GUC_LIST_QUOTE variables, because the wrong
4894  * things would happen if such a variable were set or pg_dump'd when the
4895  * defining extension isn't loaded. Again, treat this as fatal because
4896  * the loadable module may be partly initialized already.
4897  */
4898  if (flags & GUC_LIST_QUOTE)
4899  elog(FATAL, "extensions cannot define GUC_LIST_QUOTE variables");
4900 
4901  /*
4902  * Before pljava commit 398f3b876ed402bdaec8bc804f29e2be95c75139
4903  * (2015-12-15), two of that module's PGC_USERSET variables facilitated
4904  * trivial escalation to superuser privileges. Restrict the variables to
4905  * protect sites that have yet to upgrade pljava.
4906  */
4907  if (context == PGC_USERSET &&
4908  (strcmp(name, "pljava.classpath") == 0 ||
4909  strcmp(name, "pljava.vmoptions") == 0))
4910  context = PGC_SUSET;
4911 
4912  gen = (struct config_generic *) guc_malloc(ERROR, sz);
4913  memset(gen, 0, sz);
4914 
4915  gen->name = guc_strdup(ERROR, name);
4916  gen->context = context;
4917  gen->group = CUSTOM_OPTIONS;
4918  gen->short_desc = short_desc;
4919  gen->long_desc = long_desc;
4920  gen->flags = flags;
4921  gen->vartype = type;
4922 
4923  return gen;
4924 }
#define FATAL
Definition: elog.h:41
#define GUC_LIST_QUOTE
Definition: guc.h:211
@ PGC_SUSET
Definition: guc.h:74
bool process_shared_preload_libraries_in_progress
Definition: miscinit.c:1839
const char * long_desc
Definition: guc_tables.h:160
const char * type

References context, config_generic::context, CUSTOM_OPTIONS, elog, ERROR, 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 1530 of file guc.c.

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

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

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

◆ InitializeGUCOptionsFromEnvironment()

static void InitializeGUCOptionsFromEnvironment ( void  )
static

Definition at line 1589 of file guc.c.

1590 {
1591  char *env;
1592  long stack_rlimit;
1593 
1594  env = getenv("PGPORT");
1595  if (env != NULL)
1597 
1598  env = getenv("PGDATESTYLE");
1599  if (env != NULL)
1600  SetConfigOption("datestyle", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
1601 
1602  env = getenv("PGCLIENTENCODING");
1603  if (env != NULL)
1604  SetConfigOption("client_encoding", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
1605 
1606  /*
1607  * rlimit isn't exactly an "environment variable", but it behaves about
1608  * the same. If we can identify the platform stack depth rlimit, increase
1609  * default stack depth setting up to whatever is safe (but at most 2MB).
1610  * Report the value's source as PGC_S_DYNAMIC_DEFAULT if it's 2MB, or as
1611  * PGC_S_ENV_VAR if it's reflecting the rlimit limit.
1612  */
1613  stack_rlimit = get_stack_depth_rlimit();
1614  if (stack_rlimit > 0)
1615  {
1616  long new_limit = (stack_rlimit - STACK_DEPTH_SLOP) / 1024L;
1617 
1618  if (new_limit > 100)
1619  {
1620  GucSource source;
1621  char limbuf[16];
1622 
1623  if (new_limit < 2048)
1625  else
1626  {
1627  new_limit = 2048;
1629  }
1630  snprintf(limbuf, sizeof(limbuf), "%ld", new_limit);
1631  SetConfigOption("max_stack_depth", limbuf,
1633  }
1634  }
1635 }
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:110
@ PGC_S_ENV_VAR
Definition: guc.h:111
long get_stack_depth_rlimit(void)
Definition: postgres.c:5079
#define STACK_DEPTH_SLOP
Definition: tcopprot.h:25

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

1645 {
1646  gconf->status = 0;
1647  gconf->source = PGC_S_DEFAULT;
1648  gconf->reset_source = PGC_S_DEFAULT;
1649  gconf->scontext = PGC_INTERNAL;
1650  gconf->reset_scontext = PGC_INTERNAL;
1651  gconf->srole = BOOTSTRAP_SUPERUSERID;
1652  gconf->reset_srole = BOOTSTRAP_SUPERUSERID;
1653  gconf->stack = NULL;
1654  gconf->extra = NULL;
1655  gconf->last_reported = NULL;
1656  gconf->sourcefile = NULL;
1657  gconf->sourceline = 0;
1658 
1659  switch (gconf->vartype)
1660  {
1661  case PGC_BOOL:
1662  {
1663  struct config_bool *conf = (struct config_bool *) gconf;
1664  bool newval = conf->boot_val;
1665  void *extra = NULL;
1666 
1667  if (!call_bool_check_hook(conf, &newval, &extra,
1668  PGC_S_DEFAULT, LOG))
1669  elog(FATAL, "failed to initialize %s to %d",
1670  conf->gen.name, (int) newval);
1671  if (conf->assign_hook)
1672  conf->assign_hook(newval, extra);
1673  *conf->variable = conf->reset_val = newval;
1674  conf->gen.extra = conf->reset_extra = extra;
1675  break;
1676  }
1677  case PGC_INT:
1678  {
1679  struct config_int *conf = (struct config_int *) gconf;
1680  int newval = conf->boot_val;
1681  void *extra = NULL;
1682 
1683  Assert(newval >= conf->min);
1684  Assert(newval <= conf->max);
1685  if (!call_int_check_hook(conf, &newval, &extra,
1686  PGC_S_DEFAULT, LOG))
1687  elog(FATAL, "failed to initialize %s to %d",
1688  conf->gen.name, newval);
1689  if (conf->assign_hook)
1690  conf->assign_hook(newval, extra);
1691  *conf->variable = conf->reset_val = newval;
1692  conf->gen.extra = conf->reset_extra = extra;
1693  break;
1694  }
1695  case PGC_REAL:
1696  {
1697  struct config_real *conf = (struct config_real *) gconf;
1698  double newval = conf->boot_val;
1699  void *extra = NULL;
1700 
1701  Assert(newval >= conf->min);
1702  Assert(newval <= conf->max);
1703  if (!call_real_check_hook(conf, &newval, &extra,
1704  PGC_S_DEFAULT, LOG))
1705  elog(FATAL, "failed to initialize %s to %g",
1706  conf->gen.name, newval);
1707  if (conf->assign_hook)
1708  conf->assign_hook(newval, extra);
1709  *conf->variable = conf->reset_val = newval;
1710  conf->gen.extra = conf->reset_extra = extra;
1711  break;
1712  }
1713  case PGC_STRING:
1714  {
1715  struct config_string *conf = (struct config_string *) gconf;
1716  char *newval;
1717  void *extra = NULL;
1718 
1719  /* non-NULL boot_val must always get strdup'd */
1720  if (conf->boot_val != NULL)
1721  newval = guc_strdup(FATAL, conf->boot_val);
1722  else
1723  newval = NULL;
1724 
1725  if (!call_string_check_hook(conf, &newval, &extra,
1726  PGC_S_DEFAULT, LOG))
1727  elog(FATAL, "failed to initialize %s to \"%s\"",
1728  conf->gen.name, newval ? newval : "");
1729  if (conf->assign_hook)
1730  conf->assign_hook(newval, extra);
1731  *conf->variable = conf->reset_val = newval;
1732  conf->gen.extra = conf->reset_extra = extra;
1733  break;
1734  }
1735  case PGC_ENUM:
1736  {
1737  struct config_enum *conf = (struct config_enum *) gconf;
1738  int newval = conf->boot_val;
1739  void *extra = NULL;
1740 
1741  if (!call_enum_check_hook(conf, &newval, &extra,
1742  PGC_S_DEFAULT, LOG))
1743  elog(FATAL, "failed to initialize %s to %d",
1744  conf->gen.name, newval);
1745  if (conf->assign_hook)
1746  conf->assign_hook(newval, extra);
1747  *conf->variable = conf->reset_val = newval;
1748  conf->gen.extra = conf->reset_extra = extra;
1749  break;
1750  }
1751  }
1752 }
static bool call_string_check_hook(struct config_string *conf, char **newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6900
static void static bool call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6798
static bool call_int_check_hook(struct config_int *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6832
static bool call_real_check_hook(struct config_real *conf, double *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6866
static bool call_enum_check_hook(struct config_enum *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6950
void * reset_extra
Definition: guc_tables.h:209
void * reset_extra
Definition: guc_tables.h:280
char * last_reported
Definition: guc_tables.h:179
void * reset_extra
Definition: guc_tables.h:225
void * reset_extra
Definition: guc_tables.h:241
void * reset_extra
Definition: guc_tables.h:265

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

5280 {
5281  int classLen = strlen(className);
5282  HASH_SEQ_STATUS status;
5283  GUCHashEntry *hentry;
5284  MemoryContext oldcontext;
5285 
5286  /*
5287  * Check for existing placeholders. We must actually remove invalid
5288  * placeholders, else future parallel worker startups will fail. (We
5289  * don't bother trying to free associated memory, since this shouldn't
5290  * happen often.)
5291  */
5292  hash_seq_init(&status, guc_hashtab);
5293  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5294  {
5295  struct config_generic *var = hentry->gucvar;
5296 
5297  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5298  strncmp(className, var->name, classLen) == 0 &&
5299  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5300  {
5301  ereport(WARNING,
5302  (errcode(ERRCODE_INVALID_NAME),
5303  errmsg("invalid configuration parameter name \"%s\", removing it",
5304  var->name),
5305  errdetail("\"%s\" is now a reserved prefix.",
5306  className)));
5307  /* Remove it from the hash table */
5309  &var->name,
5310  HASH_REMOVE,
5311  NULL);
5312  /* Remove it from any lists it's in, too */
5313  RemoveGUCFromLists(var);
5314  }
5315  }
5316 
5317  /* And remember the name so we can prevent future mistakes. */
5320  MemoryContextSwitchTo(oldcontext);
5321 }
@ HASH_REMOVE
Definition: hsearch.h:115
List * lappend(List *list, void *datum)
Definition: list.c:339
MemoryContextSwitchTo(old_ctx)

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

Referenced by _PG_init().

◆ NewGUCNestLevel()

◆ parse_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 3129 of file guc.c.

3133 {
3134  switch (record->vartype)
3135  {
3136  case PGC_BOOL:
3137  {
3138  struct config_bool *conf = (struct config_bool *) record;
3139 
3140  if (!parse_bool(value, &newval->boolval))
3141  {
3142  ereport(elevel,
3143  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3144  errmsg("parameter \"%s\" requires a Boolean value",
3145  conf->gen.name)));
3146  return false;
3147  }
3148 
3149  if (!call_bool_check_hook(conf, &newval->boolval, newextra,
3150  source, elevel))
3151  return false;
3152  }
3153  break;
3154  case PGC_INT:
3155  {
3156  struct config_int *conf = (struct config_int *) record;
3157  const char *hintmsg;
3158 
3159  if (!parse_int(value, &newval->intval,
3160  conf->gen.flags, &hintmsg))
3161  {
3162  ereport(elevel,
3163  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3164  errmsg("invalid value for parameter \"%s\": \"%s\"",
3165  conf->gen.name, value),
3166  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3167  return false;
3168  }
3169 
3170  if (newval->intval < conf->min || newval->intval > conf->max)
3171  {
3172  const char *unit = get_config_unit_name(conf->gen.flags);
3173  const char *unitspace;
3174 
3175  if (unit)
3176  unitspace = " ";
3177  else
3178  unit = unitspace = "";
3179 
3180  ereport(elevel,
3181  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3182  errmsg("%d%s%s is outside the valid range for parameter \"%s\" (%d%s%s .. %d%s%s)",
3183  newval->intval, unitspace, unit,
3184  conf->gen.name,
3185  conf->min, unitspace, unit,
3186  conf->max, unitspace, unit)));
3187  return false;
3188  }
3189 
3190  if (!call_int_check_hook(conf, &newval->intval, newextra,
3191  source, elevel))
3192  return false;
3193  }
3194  break;
3195  case PGC_REAL:
3196  {
3197  struct config_real *conf = (struct config_real *) record;
3198  const char *hintmsg;
3199 
3200  if (!parse_real(value, &newval->realval,
3201  conf->gen.flags, &hintmsg))
3202  {
3203  ereport(elevel,
3204  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3205  errmsg("invalid value for parameter \"%s\": \"%s\"",
3206  conf->gen.name, value),
3207  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3208  return false;
3209  }
3210 
3211  if (newval->realval < conf->min || newval->realval > conf->max)
3212  {
3213  const char *unit = get_config_unit_name(conf->gen.flags);
3214  const char *unitspace;
3215 
3216  if (unit)
3217  unitspace = " ";
3218  else
3219  unit = unitspace = "";
3220 
3221  ereport(elevel,
3222  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3223  errmsg("%g%s%s is outside the valid range for parameter \"%s\" (%g%s%s .. %g%s%s)",
3224  newval->realval, unitspace, unit,
3225  conf->gen.name,
3226  conf->min, unitspace, unit,
3227  conf->max, unitspace, unit)));
3228  return false;
3229  }
3230 
3231  if (!call_real_check_hook(conf, &newval->realval, newextra,
3232  source, elevel))
3233  return false;
3234  }
3235  break;
3236  case PGC_STRING:
3237  {
3238  struct config_string *conf = (struct config_string *) record;
3239 
3240  /*
3241  * The value passed by the caller could be transient, so we
3242  * always strdup it.
3243  */
3244  newval->stringval = guc_strdup(elevel, value);
3245  if (newval->stringval == NULL)
3246  return false;
3247 
3248  /*
3249  * The only built-in "parsing" check we have is to apply
3250  * truncation if GUC_IS_NAME.
3251  */
3252  if (conf->gen.flags & GUC_IS_NAME)
3253  truncate_identifier(newval->stringval,
3254  strlen(newval->stringval),
3255  true);
3256 
3257  if (!call_string_check_hook(conf, &newval->stringval, newextra,
3258  source, elevel))
3259  {
3260  guc_free(newval->stringval);
3261  newval->stringval = NULL;
3262  return false;
3263  }
3264  }
3265  break;
3266  case PGC_ENUM:
3267  {
3268  struct config_enum *conf = (struct config_enum *) record;
3269 
3270  if (!config_enum_lookup_by_name(conf, value, &newval->enumval))
3271  {
3272  char *hintmsg;
3273 
3274  hintmsg = config_enum_get_options(conf,
3275  "Available values: ",
3276  ".", ", ");
3277 
3278  ereport(elevel,
3279  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3280  errmsg("invalid value for parameter \"%s\": \"%s\"",
3281  conf->gen.name, value),
3282  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3283 
3284  if (hintmsg)
3285  pfree(hintmsg);
3286  return false;
3287  }
3288 
3289  if (!call_enum_check_hook(conf, &newval->enumval, newextra,
3290  source, elevel))
3291  return false;
3292  }
3293  break;
3294  }
3295 
3296  return true;
3297 }
bool parse_bool(const char *value, bool *result)
Definition: bool.c:31
#define _(x)
Definition: elog.c:90
bool parse_int(const char *value, int *result, int flags, const char **hintmsg)
Definition: guc.c:2871
bool config_enum_lookup_by_name(struct config_enum *record, const char *value, int *retval)
Definition: guc.c:3046
bool parse_real(const char *value, double *result, int flags, const char **hintmsg)
Definition: guc.c:2961
const char * get_config_unit_name(int flags)
Definition: guc.c:2814
char * config_enum_get_options(struct config_enum *record, const char *prefix, const char *suffix, const char *separator)
Definition: guc.c:3072
#define GUC_IS_NAME
Definition: guc.h:221
void truncate_identifier(char *ident, int len, bool warn)
Definition: scansup.c:93

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

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

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

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

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

6363 {
6364  size_t equal_pos;
6365  char *cp;
6366 
6367  Assert(string);
6368  Assert(name);
6369  Assert(value);
6370 
6371  equal_pos = strcspn(string, "=");
6372 
6373  if (string[equal_pos] == '=')
6374  {
6375  *name = palloc(equal_pos + 1);
6376  strlcpy(*name, string, equal_pos + 1);
6377 
6378  *value = pstrdup(&string[equal_pos + 1]);
6379  }
6380  else
6381  {
6382  /* no equal sign in string */
6383  *name = pstrdup(string);
6384  *value = NULL;
6385  }
6386 
6387  for (cp = *name; *cp; cp++)
6388  if (*cp == '-')
6389  *cp = '_';
6390 }
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45

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

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

◆ pg_timezone_abbrev_initialize()

static void pg_timezone_abbrev_initialize ( void  )
static

Definition at line 1992 of file guc.c.

1993 {
1994  SetConfigOption("timezone_abbreviations", "Default",
1996 }

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

283 {
284  bool error = false;
285  bool applying = false;
286  const char *ConfFileWithError;
287  ConfigVariable *item,
288  *head,
289  *tail;
290  HASH_SEQ_STATUS status;
291  GUCHashEntry *hentry;
292 
293  /* Parse the main config file into a list of option names and values */
294  ConfFileWithError = ConfigFileName;
295  head = tail = NULL;
296 
297  if (!ParseConfigFile(ConfigFileName, true,
298  NULL, 0, CONF_FILE_START_DEPTH, elevel,
299  &head, &tail))
300  {
301  /* Syntax error(s) detected in the file, so bail out */
302  error = true;
303  goto bail_out;
304  }
305 
306  /*
307  * Parse the PG_AUTOCONF_FILENAME file, if present, after the main file to
308  * replace any parameters set by ALTER SYSTEM command. Because this file
309  * is in the data directory, we can't read it until the DataDir has been
310  * set.
311  */
312  if (DataDir)
313  {
315  NULL, 0, CONF_FILE_START_DEPTH, elevel,
316  &head, &tail))
317  {
318  /* Syntax error(s) detected in the file, so bail out */
319  error = true;
320  ConfFileWithError = PG_AUTOCONF_FILENAME;
321  goto bail_out;
322  }
323  }
324  else
325  {
326  /*
327  * If DataDir is not set, the PG_AUTOCONF_FILENAME file cannot be
328  * read. In this case, we don't want to accept any settings but
329  * data_directory from postgresql.conf, because they might be
330  * overwritten with settings in the PG_AUTOCONF_FILENAME file which
331  * will be read later. OTOH, since data_directory isn't allowed in the
332  * PG_AUTOCONF_FILENAME file, it will never be overwritten later.
333  */
334  ConfigVariable *newlist = NULL;
335 
336  /*
337  * Prune all items except the last "data_directory" from the list.
338  */
339  for (item = head; item; item = item->next)
340  {
341  if (!item->ignore &&
342  strcmp(item->name, "data_directory") == 0)
343  newlist = item;
344  }
345 
346  if (newlist)
347  newlist->next = NULL;
348  head = tail = newlist;
349 
350  /*
351  * Quick exit if data_directory is not present in file.
352  *
353  * We need not do any further processing, in particular we don't set
354  * PgReloadTime; that will be set soon by subsequent full loading of
355  * the config file.
356  */
357  if (head == NULL)
358  goto bail_out;
359  }
360 
361  /*
362  * Mark all extant GUC variables as not present in the config file. We
363  * need this so that we can tell below which ones have been removed from
364  * the file since we last processed it.
365  */
366  hash_seq_init(&status, guc_hashtab);
367  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
368  {
369  struct config_generic *gconf = hentry->gucvar;
370 
371  gconf->status &= ~GUC_IS_IN_FILE;
372  }
373 
374  /*
375  * Check if all the supplied option names are valid, as an additional
376  * quasi-syntactic check on the validity of the config file. It is
377  * important that the postmaster and all backends agree on the results of
378  * this phase, else we will have strange inconsistencies about which
379  * processes accept a config file update and which don't. Hence, unknown
380  * custom variable names have to be accepted without complaint. For the
381  * same reason, we don't attempt to validate the options' values here.
382  *
383  * In addition, the GUC_IS_IN_FILE flag is set on each existing GUC
384  * variable mentioned in the file; and we detect duplicate entries in the
385  * file and mark the earlier occurrences as ignorable.
386  */
387  for (item = head; item; item = item->next)
388  {
389  struct config_generic *record;
390 
391  /* Ignore anything already marked as ignorable */
392  if (item->ignore)
393  continue;
394 
395  /*
396  * Try to find the variable; but do not create a custom placeholder if
397  * it's not there already.
398  */
399  record = find_option(item->name, false, true, elevel);
400 
401  if (record)
402  {
403  /* If it's already marked, then this is a duplicate entry */
404  if (record->status & GUC_IS_IN_FILE)
405  {
406  /*
407  * Mark the earlier occurrence(s) as dead/ignorable. We could
408  * avoid the O(N^2) behavior here with some additional state,
409  * but it seems unlikely to be worth the trouble.
410  */
411  ConfigVariable *pitem;
412 
413  for (pitem = head; pitem != item; pitem = pitem->next)
414  {
415  if (!pitem->ignore &&
416  strcmp(pitem->name, item->name) == 0)
417  pitem->ignore = true;
418  }
419  }
420  /* Now mark it as present in file */
421  record->status |= GUC_IS_IN_FILE;
422  }
423  else if (!valid_custom_variable_name(item->name))
424  {
425  /* Invalid non-custom variable, so complain */
426  ereport(elevel,
427  (errcode(ERRCODE_UNDEFINED_OBJECT),
428  errmsg("unrecognized configuration parameter \"%s\" in file \"%s\" line %d",
429  item->name,
430  item->filename, item->sourceline)));
431  item->errmsg = pstrdup("unrecognized configuration parameter");
432  error = true;
433  ConfFileWithError = item->filename;
434  }
435  }
436 
437  /*
438  * If we've detected any errors so far, we don't want to risk applying any
439  * changes.
440  */
441  if (error)
442  goto bail_out;
443 
444  /* Otherwise, set flag that we're beginning to apply changes */
445  applying = true;
446 
447  /*
448  * Check for variables having been removed from the config file, and
449  * revert their reset values (and perhaps also effective values) to the
450  * boot-time defaults. If such a variable can't be changed after startup,
451  * report that and continue.
452  */
454  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
455  {
456  struct config_generic *gconf = hentry->gucvar;
457  GucStack *stack;
458 
459  if (gconf->reset_source != PGC_S_FILE ||
460  (gconf->status & GUC_IS_IN_FILE))
461  continue;
462  if (gconf->context < PGC_SIGHUP)
463  {
464  /* The removal can't be effective without a restart */
465  gconf->status |= GUC_PENDING_RESTART;
466  ereport(elevel,
467  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
468  errmsg("parameter \"%s\" cannot be changed without restarting the server",
469  gconf->name)));
470  record_config_file_error(psprintf("parameter \"%s\" cannot be changed without restarting the server",
471  gconf->name),
472  NULL, 0,
473  &head, &tail);
474  error = true;
475  continue;
476  }
477 
478  /* No more to do if we're just doing show_all_file_settings() */
479  if (!applySettings)
480  continue;
481 
482  /*
483  * Reset any "file" sources to "default", else set_config_option will
484  * not override those settings.
485  */
486  if (gconf->reset_source == PGC_S_FILE)
487  gconf->reset_source = PGC_S_DEFAULT;
488  if (gconf->source == PGC_S_FILE)
490  for (stack = gconf->stack; stack; stack = stack->prev)
491  {
492  if (stack->source == PGC_S_FILE)
494  }
495 
496  /* Now we can re-apply the wired-in default (i.e., the boot_val) */
497  if (set_config_option(gconf->name, NULL,
499  GUC_ACTION_SET, true, 0, false) > 0)
500  {
501  /* Log the change if appropriate */
502  if (context == PGC_SIGHUP)
503  ereport(elevel,
504  (errmsg("parameter \"%s\" removed from configuration file, reset to default",
505  gconf->name)));
506  }
507  }
508 
509  /*
510  * Restore any variables determined by environment variables or
511  * dynamically-computed defaults. This is a no-op except in the case
512  * where one of these had been in the config file and is now removed.
513  *
514  * In particular, we *must not* do this during the postmaster's initial
515  * loading of the file, since the timezone functions in particular should
516  * be run only after initialization is complete.
517  *
518  * XXX this is an unmaintainable crock, because we have to know how to set
519  * (or at least what to call to set) every non-PGC_INTERNAL variable that
520  * could potentially have PGC_S_DYNAMIC_DEFAULT or PGC_S_ENV_VAR source.
521  */
522  if (context == PGC_SIGHUP && applySettings)
523  {
526  /* this selects SQL_ASCII in processes not connected to a database */
527  SetConfigOption("client_encoding", GetDatabaseEncodingName(),
529  }
530 
531  /*
532  * Now apply the values from the config file.
533  */
534  for (item = head; item; item = item->next)
535  {
536  char *pre_value = NULL;
537  int scres;
538 
539  /* Ignore anything marked as ignorable */
540  if (item->ignore)
541  continue;
542 
543  /* In SIGHUP cases in the postmaster, we want to report changes */
544  if (context == PGC_SIGHUP && applySettings && !IsUnderPostmaster)
545  {
546  const char *preval = GetConfigOption(item->name, true, false);
547 
548  /* If option doesn't exist yet or is NULL, treat as empty string */
549  if (!preval)
550  preval = "";
551  /* must dup, else might have dangling pointer below */
552  pre_value = pstrdup(preval);
553  }
554 
555  scres = set_config_option(item->name, item->value,
557  GUC_ACTION_SET, applySettings, 0, false);
558  if (scres > 0)
559  {
560  /* variable was updated, so log the change if appropriate */
561  if (pre_value)
562  {
563  const char *post_value = GetConfigOption(item->name, true, false);
564 
565  if (!post_value)
566  post_value = "";
567  if (strcmp(pre_value, post_value) != 0)
568  ereport(elevel,
569  (errmsg("parameter \"%s\" changed to \"%s\"",
570  item->name, item->value)));
571  }
572  item->applied = true;
573  }
574  else if (scres == 0)
575  {
576  error = true;
577  item->errmsg = pstrdup("setting could not be applied");
578  ConfFileWithError = item->filename;
579  }
580  else
581  {
582  /* no error, but variable's active value was not changed */
583  item->applied = true;
584  }
585 
586  /*
587  * We should update source location unless there was an error, since
588  * even if the active value didn't change, the reset value might have.
589  * (In the postmaster, there won't be a difference, but it does matter
590  * in backends.)
591  */
592  if (scres != 0 && applySettings)
593  set_config_sourcefile(item->name, item->filename,
594  item->sourceline);
595 
596  if (pre_value)
597  pfree(pre_value);
598  }
599 
600  /* Remember when we last successfully loaded the config file. */
601  if (applySettings)
603 
604 bail_out:
605  if (error && applySettings)
606  {
607  /* During postmaster startup, any error is fatal */
608  if (context == PGC_POSTMASTER)
609  ereport(ERROR,
610  (errcode(ERRCODE_CONFIG_FILE_ERROR),
611  errmsg("configuration file \"%s\" contains errors",
612  ConfFileWithError)));
613  else if (applying)
614  ereport(elevel,
615  (errcode(ERRCODE_CONFIG_FILE_ERROR),
616  errmsg("configuration file \"%s\" contains errors; unaffected changes were applied",
617  ConfFileWithError)));
618  else
619  ereport(elevel,
620  (errcode(ERRCODE_CONFIG_FILE_ERROR),
621  errmsg("configuration file \"%s\" contains errors; no changes were applied",
622  ConfFileWithError)));
623  }
624 
625  /* Successful or otherwise, return the collected data list */
626  return head;
627 }
TimestampTz PgReloadTime
Definition: timestamp.c:56
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1644
bool IsUnderPostmaster
Definition: globals.c:119
char * DataDir
Definition: globals.c:70
static void pg_timezone_abbrev_initialize(void)
Definition: guc.c:1992
const char * GetConfigOption(const char *name, bool missing_ok, bool restrict_privileged)
Definition: guc.c:4355
int set_config_option(const char *name, const char *value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3342
bool ParseConfigFile(const char *config_file, bool strict, const char *calling_file, int calling_lineno, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
@ PGC_SIGHUP
Definition: guc.h:71
@ PGC_BACKEND
Definition: guc.h:73
void record_config_file_error(const char *errmsg, const char *config_file, int lineno, ConfigVariable **head_p, ConfigVariable **tail_p)
char * ConfigFileName
Definition: guc_tables.c:538
#define GUC_IS_IN_FILE
Definition: guc_tables.h:187
#define GUC_PENDING_RESTART
Definition: guc_tables.h:192
const char * GetDatabaseEncodingName(void)
Definition: mbutils.c:1267
static void bail_out(bool noatexit, const char *fmt,...) pg_attribute_printf(2
Definition: pg_regress.c:255
static void error(void)
Definition: sql-dyntest.c:147
char * name
Definition: guc.h:137
bool ignore
Definition: guc.h:142
struct ConfigVariable * next
Definition: guc.h:144
bool applied
Definition: guc.h:143
char * filename
Definition: guc.h:140
int sourceline
Definition: guc.h:141
char * value
Definition: guc.h:138
char * errmsg
Definition: guc.h:139

References ConfigVariable::applied, bail_out(), CONF_FILE_START_DEPTH, ConfigFileName, context, 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 show_all_file_settings().

◆ ProcessGUCArray()

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

Definition at line 6456 of file guc.c.

6458 {
6459  List *gucNames;
6460  List *gucValues;
6461  ListCell *lc1;
6462  ListCell *lc2;
6463 
6464  TransformGUCArray(array, &gucNames, &gucValues);
6465  forboth(lc1, gucNames, lc2, gucValues)
6466  {
6467  char *name = lfirst(lc1);
6468  char *value = lfirst(lc2);
6469 
6470  (void) set_config_option(name, value,
6471  context, source,
6472  action, true, 0, false);
6473 
6474  pfree(name);
6475  pfree(value);
6476  }
6477 
6478  list_free(gucNames);
6479  list_free(gucValues);
6480 }
void TransformGUCArray(ArrayType *array, List **names, List **values)
Definition: guc.c:6399
void list_free(List *list)
Definition: list.c:1546
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:518
Definition: pg_list.h:54

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

Referenced by ApplySetting(), and ProcedureCreate().

◆ push_old_value()

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

Definition at line 2134 of file guc.c.

2135 {
2136  GucStack *stack;
2137 
2138  /* If we're not inside a nest level, do nothing */
2139  if (GUCNestLevel == 0)
2140  return;
2141 
2142  /* Do we already have a stack entry of the current nest level? */
2143  stack = gconf->stack;
2144  if (stack && stack->nest_level >= GUCNestLevel)
2145  {
2146  /* Yes, so adjust its state if necessary */
2147  Assert(stack->nest_level == GUCNestLevel);
2148  switch (action)
2149  {
2150  case GUC_ACTION_SET:
2151  /* SET overrides any prior action at same nest level */
2152  if (stack->state == GUC_SET_LOCAL)
2153  {
2154  /* must discard old masked value */
2155  discard_stack_value(gconf, &stack->masked);
2156  }
2157  stack->state = GUC_SET;
2158  break;
2159  case GUC_ACTION_LOCAL:
2160  if (stack->state == GUC_SET)
2161  {
2162  /* SET followed by SET LOCAL, remember SET's value */
2163  stack->masked_scontext = gconf->scontext;
2164  stack->masked_srole = gconf->srole;
2165  set_stack_value(gconf, &stack->masked);
2166  stack->state = GUC_SET_LOCAL;
2167  }
2168  /* in all other cases, no change to stack entry */
2169  break;
2170  case GUC_ACTION_SAVE:
2171  /* Could only have a prior SAVE of same variable */
2172  Assert(stack->state == GUC_SAVE);
2173  break;
2174  }
2175  return;
2176  }
2177 
2178  /*
2179  * Push a new stack entry
2180  *
2181  * We keep all the stack entries in TopTransactionContext for simplicity.
2182  */
2184  sizeof(GucStack));
2185 
2186  stack->prev = gconf->stack;
2187  stack->nest_level = GUCNestLevel;
2188  switch (action)
2189  {
2190  case GUC_ACTION_SET:
2191  stack->state = GUC_SET;
2192  break;
2193  case GUC_ACTION_LOCAL:
2194  stack->state = GUC_LOCAL;
2195  break;
2196  case GUC_ACTION_SAVE:
2197  stack->state = GUC_SAVE;
2198  break;
2199  }
2200  stack->source = gconf->source;
2201  stack->scontext = gconf->scontext;
2202  stack->srole = gconf->srole;
2203  set_stack_value(gconf, &stack->prior);
2204 
2205  if (gconf->stack == NULL)
2207  gconf->stack = stack;
2208 }
static void set_stack_value(struct config_generic *gconf, config_var_value *val)
Definition: guc.c:812
@ GUC_ACTION_SAVE
Definition: guc.h:201
@ GUC_ACTION_LOCAL
Definition: guc.h:200
MemoryContext TopTransactionContext
Definition: mcxt.c:154
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1215

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

6135 {
6136  char *retptr = *srcptr;
6137  char *ptr;
6138 
6139  if (*srcptr >= srcend)
6140  elog(ERROR, "incomplete GUC state");
6141 
6142  /* The string variables are all null terminated */
6143  for (ptr = *srcptr; ptr < srcend && *ptr != '\0'; ptr++)
6144  ;
6145 
6146  if (ptr >= srcend)
6147  elog(ERROR, "could not find null terminator in GUC state");
6148 
6149  /* Set the new position to the byte following the terminating NUL */
6150  *srcptr = ptr + 1;
6151 
6152  return retptr;
6153 }

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

6158 {
6159  if (*srcptr + size > srcend)
6160  elog(ERROR, "incomplete GUC state");
6161 
6162  memcpy(dest, *srcptr, size);
6163  *srcptr += size;
6164 }

References generate_unaccent_rules::dest, elog, ERROR, and size.

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

5046 {
5047  const char *name = variable->name;
5048  GucStack *oldvarstack = variable->stack;
5049 
5050  if (stack != NULL)
5051  {
5052  /* First, recurse, so that stack items are processed bottom to top */
5053  reapply_stacked_values(variable, pHolder, stack->prev,
5054  stack->prior.val.stringval,
5055  stack->scontext, stack->source, stack->srole);
5056 
5057  /* See how to apply the passed-in value */
5058  switch (stack->state)
5059  {
5060  case GUC_SAVE:
5061  (void) set_config_option_ext(name, curvalue,
5062  curscontext, cursource, cursrole,
5063  GUC_ACTION_SAVE, true,
5064  WARNING, false);
5065  break;
5066 
5067  case GUC_SET:
5068  (void) set_config_option_ext(name, curvalue,
5069  curscontext, cursource, cursrole,
5070  GUC_ACTION_SET, true,
5071  WARNING, false);
5072  break;
5073 
5074  case GUC_LOCAL:
5075  (void) set_config_option_ext(name, curvalue,
5076  curscontext, cursource, cursrole,
5077  GUC_ACTION_LOCAL, true,
5078  WARNING, false);
5079  break;
5080 
5081  case GUC_SET_LOCAL:
5082  /* first, apply the masked value as SET */
5084  stack->masked_scontext,
5085  PGC_S_SESSION,
5086  stack->masked_srole,
5087  GUC_ACTION_SET, true,
5088  WARNING, false);
5089  /* then apply the current value as LOCAL */
5090  (void) set_config_option_ext(name, curvalue,
5091  curscontext, cursource, cursrole,
5092  GUC_ACTION_LOCAL, true,
5093  WARNING, false);
5094  break;
5095  }
5096 
5097  /* If we successfully made a stack entry, adjust its nest level */
5098  if (variable->stack != oldvarstack)
5099  variable->stack->nest_level = stack->nest_level;
5100  }
5101  else
5102  {
5103  /*
5104  * We are at the end of the stack. If the active/previous value is
5105  * different from the reset value, it must represent a previously
5106  * committed session value. Apply it, and then drop the stack entry
5107  * that set_config_option will have created under the impression that
5108  * this is to be just a transactional assignment. (We leak the stack
5109  * entry.)
5110  */
5111  if (curvalue != pHolder->reset_val ||
5112  curscontext != pHolder->gen.reset_scontext ||
5113  cursource != pHolder->gen.reset_source ||
5114  cursrole != pHolder->gen.reset_srole)
5115  {
5116  (void) set_config_option_ext(name, curvalue,
5117  curscontext, cursource, cursrole,
5118  GUC_ACTION_SET, true, WARNING, false);
5119  if (variable->stack != NULL)
5120  {
5121  slist_delete(&guc_stack_list, &variable->stack_link);
5122  variable->stack = NULL;
5123  }
5124  }
5125  }
5126 }
void slist_delete(slist_head *head, const slist_node *node)
Definition: ilist.c:31

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

◆ RemoveGUCFromLists()

static void RemoveGUCFromLists ( struct config_generic gconf)
static

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

4539 {
4540  ConfigVariable *item,
4541  *next,
4542  *prev = NULL;
4543 
4544  /*
4545  * Remove any existing match(es) for "name". Normally there'd be at most
4546  * one, but if external tools have modified the config file, there could
4547  * be more.
4548  */
4549  for (item = *head_p; item != NULL; item = next)
4550  {
4551  next = item->next;
4552  if (guc_name_compare(item->name, name) == 0)
4553  {
4554  /* found a match, delete it */
4555  if (prev)
4556  prev->next = next;
4557  else
4558  *head_p = next;
4559  if (next == NULL)
4560  *tail_p = prev;
4561 
4562  pfree(item->name);
4563  pfree(item->value);
4564  pfree(item->filename);
4565  pfree(item);
4566  }
4567  else
4568  prev = item;
4569  }
4570 
4571  /* Done if we're trying to delete it */
4572  if (value == NULL)
4573  return;
4574 
4575  /* OK, append a new entry */
4576  item = palloc(sizeof *item);
4577  item->name = pstrdup(name);
4578  item->value = pstrdup(value);
4579  item->errmsg = NULL;
4580  item->filename = pstrdup(""); /* new item has no location */
4581  item->sourceline = 0;
4582  item->ignore = false;
4583  item->applied = false;
4584  item->next = NULL;
4585 
4586  if (*head_p == NULL)
4587  *head_p = item;
4588  else
4589  (*tail_p)->next = item;
4590  *tail_p = item;
4591 }
static int32 next
Definition: blutils.c:219

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

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

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

Referenced by PostgresMain().

◆ ReportGUCOption()

static void ReportGUCOption ( struct config_generic record)
static

Definition at line 2634 of file guc.c.

2635 {
2636  char *val = ShowGUCOption(record, false);
2637 
2638  if (record->last_reported == NULL ||
2639  strcmp(val, record->last_reported) != 0)
2640  {
2641  StringInfoData msgbuf;
2642 
2644  pq_sendstring(&msgbuf, record->name);
2645  pq_sendstring(&msgbuf, val);
2646  pq_endmessage(&msgbuf);
2647 
2648  /*
2649  * We need a long-lifespan copy. If guc_strdup() fails due to OOM,
2650  * we'll set last_reported to NULL and thereby possibly make a
2651  * duplicate report later.
2652  */
2653  guc_free(record->last_reported);
2654  record->last_reported = guc_strdup(LOG, val);
2655  }
2656 
2657  pfree(val);
2658 }
void pq_sendstring(StringInfo buf, const char *str)
Definition: pqformat.c:195
void pq_endmessage(StringInfo buf)
Definition: pqformat.c:296
void pq_beginmessage(StringInfo buf, char msgtype)
Definition: pqformat.c:88
#define PqMsg_ParameterStatus
Definition: protocol.h:51

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

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

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

Referenced by DiscardAll(), and ExecSetVariableStmt().

◆ RestoreGUCState()

void RestoreGUCState ( void *  gucstate)

Definition at line 6193 of file guc.c.

6194 {
6195  char *varname,
6196  *varvalue,
6197  *varsourcefile;
6198  int varsourceline;
6199  GucSource varsource;
6200  GucContext varscontext;
6201  Oid varsrole;
6202  char *srcptr = (char *) gucstate;
6203  char *srcend;
6204  Size len;
6205  dlist_mutable_iter iter;
6206  ErrorContextCallback error_context_callback;
6207 
6208  /*
6209  * First, ensure that all potentially-shippable GUCs are reset to their
6210  * default values. We must not touch those GUCs that the leader will
6211  * never ship, while there is no need to touch those that are shippable
6212  * but already have their default values. Thus, this ends up being the
6213  * same test that SerializeGUCState uses, even though the sets of
6214  * variables involved may well be different since the leader's set of
6215  * variables-not-at-default-values can differ from the set that are
6216  * not-default in this freshly started worker.
6217  *
6218  * Once we have set all the potentially-shippable GUCs to default values,
6219  * restoring the GUCs that the leader sent (because they had non-default
6220  * values over there) leads us to exactly the set of GUC values that the
6221  * leader has. This is true even though the worker may have initially
6222  * absorbed postgresql.conf settings that the leader hasn't yet seen, or
6223  * ALTER USER/DATABASE SET settings that were established after the leader
6224  * started.
6225  *
6226  * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
6227  * also ensures that set_config_option won't refuse to set them because of
6228  * source-priority comparisons.
6229  */
6231  {
6232  struct config_generic *gconf = dlist_container(struct config_generic,
6233  nondef_link, iter.cur);
6234 
6235  /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
6236  if (can_skip_gucvar(gconf))
6237  continue;
6238 
6239  /*
6240  * We can use InitializeOneGUCOption to reset the GUC to default, but
6241  * first we must free any existing subsidiary data to avoid leaking
6242  * memory. The stack must be empty, but we have to clean up all other
6243  * fields. Beware that there might be duplicate value or "extra"
6244  * pointers. We also have to be sure to take it out of any lists it's
6245  * in.
6246  */
6247  Assert(gconf->stack == NULL);
6248  guc_free(gconf->extra);
6249  guc_free(gconf->last_reported);
6250  guc_free(gconf->sourcefile);
6251  switch (gconf->vartype)
6252  {
6253  case PGC_BOOL:
6254  {
6255  struct config_bool *conf = (struct config_bool *) gconf;
6256 
6257  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6258  guc_free(conf->reset_extra);
6259  break;
6260  }
6261  case PGC_INT:
6262  {
6263  struct config_int *conf = (struct config_int *) gconf;
6264 
6265  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6266  guc_free(conf->reset_extra);
6267  break;
6268  }
6269  case PGC_REAL:
6270  {
6271  struct config_real *conf = (struct config_real *) gconf;
6272 
6273  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6274  guc_free(conf->reset_extra);
6275  break;
6276  }
6277  case PGC_STRING:
6278  {
6279  struct config_string *conf = (struct config_string *) gconf;
6280 
6281  guc_free(*conf->variable);
6282  if (conf->reset_val && conf->reset_val != *conf->variable)
6283  guc_free(conf->reset_val);
6284  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6285  guc_free(conf->reset_extra);
6286  break;
6287  }
6288  case PGC_ENUM:
6289  {
6290  struct config_enum *conf = (struct config_enum *) gconf;
6291 
6292  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6293  guc_free(conf->reset_extra);
6294  break;
6295  }
6296  }
6297  /* Remove it from any lists it's in. */
6298  RemoveGUCFromLists(gconf);
6299  /* Now we can reset the struct to PGS_S_DEFAULT state. */
6300  InitializeOneGUCOption(gconf);
6301  }
6302 
6303  /* First item is the length of the subsequent data */
6304  memcpy(&len, gucstate, sizeof(len));
6305 
6306  srcptr += sizeof(len);
6307  srcend = srcptr + len;
6308 
6309  /* If the GUC value check fails, we want errors to show useful context. */
6310  error_context_callback.callback = guc_restore_error_context_callback;
6311  error_context_callback.previous = error_context_stack;
6312  error_context_callback.arg = NULL;
6313  error_context_stack = &error_context_callback;
6314 
6315  /* Restore all the listed GUCs. */
6316  while (srcptr < srcend)
6317  {
6318  int result;
6319  char *error_context_name_and_value[2];
6320 
6321  varname = read_gucstate(&srcptr, srcend);
6322  varvalue = read_gucstate(&srcptr, srcend);
6323  varsourcefile = read_gucstate(&srcptr, srcend);
6324  if (varsourcefile[0])
6325  read_gucstate_binary(&srcptr, srcend,
6326  &varsourceline, sizeof(varsourceline));
6327  else
6328  varsourceline = 0;
6329  read_gucstate_binary(&srcptr, srcend,
6330  &varsource, sizeof(varsource));
6331  read_gucstate_binary(&srcptr, srcend,
6332  &varscontext, sizeof(varscontext));
6333  read_gucstate_binary(&srcptr, srcend,
6334  &varsrole, sizeof(varsrole));
6335 
6336  error_context_name_and_value[0] = varname;
6337  error_context_name_and_value[1] = varvalue;
6338  error_context_callback.arg = &error_context_name_and_value[0];
6339  result = set_config_option_ext(varname, varvalue,
6340  varscontext, varsource, varsrole,
6341  GUC_ACTION_SET, true, ERROR, true);
6342  if (result <= 0)
6343  ereport(ERROR,
6344  (errcode(ERRCODE_INTERNAL_ERROR),
6345  errmsg("parameter \"%s\" could not be set", varname)));
6346  if (varsourcefile[0])
6347  set_config_sourcefile(varname, varsourcefile, varsourceline);
6348  error_context_callback.arg = NULL;
6349  }
6350 
6351  error_context_stack = error_context_callback.previous;
6352 }
ErrorContextCallback * error_context_stack
Definition: elog.c:94
static void guc_restore_error_context_callback(void *arg)
Definition: guc.c:6171
static char * read_gucstate(char **srcptr, char *srcend)
Definition: guc.c:6134
static void read_gucstate_binary(char **srcptr, char *srcend, void *dest, Size size)
Definition: guc.c:6157
struct ErrorContextCallback * previous
Definition: elog.h:296
void(* callback)(void *arg)
Definition: elog.h:297

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

Referenced by ParallelWorkerMain().

◆ RestrictSearchPath()

◆ SelectConfigFiles()

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

Definition at line 1784 of file guc.c.

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

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

6026 {
6027  /* Ignore skippable GUCs. */
6028  if (can_skip_gucvar(gconf))
6029  return;
6030 
6031  do_serialize(destptr, maxbytes, "%s", gconf->name);
6032 
6033  switch (gconf->vartype)
6034  {
6035  case PGC_BOOL:
6036  {
6037  struct config_bool *conf = (struct config_bool *) gconf;
6038 
6039  do_serialize(destptr, maxbytes,
6040  (*conf->variable ? "true" : "false"));
6041  }
6042  break;
6043 
6044  case PGC_INT:
6045  {
6046  struct config_int *conf = (struct config_int *) gconf;
6047 
6048  do_serialize(destptr, maxbytes, "%d", *conf->variable);
6049  }
6050  break;
6051 
6052  case PGC_REAL:
6053  {
6054  struct config_real *conf = (struct config_real *) gconf;
6055 
6056  do_serialize(destptr, maxbytes, "%.*e",
6057  REALTYPE_PRECISION, *conf->variable);
6058  }
6059  break;
6060 
6061  case PGC_STRING:
6062  {
6063  struct config_string *conf = (struct config_string *) gconf;
6064 
6065  /* NULL becomes empty string, see estimate_variable_size() */
6066  do_serialize(destptr, maxbytes, "%s",
6067  *conf->variable ? *conf->variable : "");
6068  }
6069  break;
6070 
6071  case PGC_ENUM:
6072  {
6073  struct config_enum *conf = (struct config_enum *) gconf;
6074 
6075  do_serialize(destptr, maxbytes, "%s",
6076  config_enum_lookup_by_value(conf, *conf->variable));
6077  }
6078  break;
6079  }
6080 
6081  do_serialize(destptr, maxbytes, "%s",
6082  (gconf->sourcefile ? gconf->sourcefile : ""));
6083 
6084  if (gconf->sourcefile && gconf->sourcefile[0])
6085  do_serialize_binary(destptr, maxbytes, &gconf->sourceline,
6086  sizeof(gconf->sourceline));
6087 
6088  do_serialize_binary(destptr, maxbytes, &gconf->source,
6089  sizeof(gconf->source));
6090  do_serialize_binary(destptr, maxbytes, &gconf->scontext,
6091  sizeof(gconf->scontext));
6092  do_serialize_binary(destptr, maxbytes, &gconf->srole,
6093  sizeof(gconf->srole));
6094 }
static void do_serialize(char **destptr, Size *maxbytes, const char *fmt,...) pg_attribute_printf(3
Definition: guc.c:5979
static void do_serialize_binary(char **destptr, Size *maxbytes, void *val, Size valsize)
Definition: guc.c:6009

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

6102 {
6103  char *curptr;
6104  Size actual_size;
6105  Size bytes_left;
6106  dlist_iter iter;
6107 
6108  /* Reserve space for saving the actual size of the guc state */
6109  Assert(maxsize > sizeof(actual_size));
6110  curptr = start_address + sizeof(actual_size);
6111  bytes_left = maxsize - sizeof(actual_size);
6112 
6113  /* We need only consider GUCs with source not PGC_S_DEFAULT */
6115  {
6116  struct config_generic *gconf = dlist_container(struct config_generic,
6117  nondef_link, iter.cur);
6118 
6119  serialize_variable(&curptr, &bytes_left, gconf);
6120  }
6121 
6122  /* Store actual size without assuming alignment of start_address. */
6123  actual_size = maxsize - bytes_left - sizeof(actual_size);
6124  memcpy(start_address, &actual_size, sizeof(actual_size));
6125 }
static void serialize_variable(char **destptr, Size *maxbytes, struct config_generic *gconf)
Definition: guc.c:6024

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

3346 {
3347  Oid srole;
3348 
3349  /*
3350  * Non-interactive sources should be treated as having all privileges,
3351  * except for PGC_S_CLIENT. Note in particular that this is true for
3352  * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3353  * privilege check was done when the pg_db_role_setting entry was made.
3354  */
3356  srole = GetUserId();
3357  else
3358  srole = BOOTSTRAP_SUPERUSERID;
3359 
3360  return set_config_with_handle(name, NULL, value,
3361  context, source, srole,
3362  action, changeVal, elevel,
3363  is_reload);
3364 }
int set_config_with_handle(const char *name, config_handle *handle, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3405
@ PGC_S_CLIENT
Definition: guc.h:118
@ PGC_S_INTERACTIVE
Definition: guc.h:120

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

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

◆ set_config_option_ext()

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

Definition at line 3382 of file guc.c.

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

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

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

◆ set_config_sourcefile()

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

Definition at line 4299 of file guc.c.

4300 {
4301  struct config_generic *record;
4302  int elevel;
4303 
4304  /*
4305  * To avoid cluttering the log, only the postmaster bleats loudly about
4306  * problems with the config file.
4307  */
4308  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
4309 
4310  record = find_option(name, true, false, elevel);
4311  /* should not happen */
4312  if (record == NULL)
4313  return;
4314 
4315  sourcefile = guc_strdup(elevel, sourcefile);
4316  guc_free(record->sourcefile);
4317  record->sourcefile = sourcefile;
4318  record->sourceline = sourceline;
4319 }
#define DEBUG3
Definition: elog.h:28

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

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

References ACL_SET, ACLCHECK_OK, generate_unaccent_rules::action, config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_var_val::boolval, config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), context, config_generic::context, DEBUG3, elog, config_var_val::enumval, ereport, errcode(), errmsg(), ERROR, config_var_value::extra, config_generic::extra, extra_field_used(), find_option(), config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_ACTION_SAVE, GUC_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_extra_field(), set_guc_source(), set_string_field(), slist_push_head(), source, guc_stack::source, config_generic::source, guc_stack::srole, config_generic::srole, config_generic::stack, config_generic::status, string_field_used(), config_var_val::stringval, config_var_value::val, value, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, config_generic::vartype, and WARNING.

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

◆ set_extra_field()

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

Definition at line 792 of file guc.c.

793 {
794  void *oldval = *field;
795 
796  /* Do the assignment */
797  *field = newval;
798 
799  /* Free old value if it's not NULL and isn't referenced anymore */
800  if (oldval && !extra_field_used(gconf, oldval))
801  guc_free(oldval);
802 }

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

2112 {
2113  /* Adjust nondef list membership if appropriate for change */
2114  if (gconf->source == PGC_S_DEFAULT)
2115  {
2116  if (newsource != PGC_S_DEFAULT)
2118  }
2119  else
2120  {
2121  if (newsource == PGC_S_DEFAULT)
2122  dlist_delete(&gconf->nondef_link);
2123  }
2124  /* Now update the source field */
2125  gconf->source = newsource;
2126 }
static void dlist_push_tail(dlist_head *head, dlist_node *node)
Definition: ilist.h:364

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

813 {
814  switch (gconf->vartype)
815  {
816  case PGC_BOOL:
817  val->val.boolval =
818  *((struct config_bool *) gconf)->variable;
819  break;
820  case PGC_INT:
821  val->val.intval =
822  *((struct config_int *) gconf)->variable;
823  break;
824  case PGC_REAL:
825  val->val.realval =
826  *((struct config_real *) gconf)->variable;
827  break;
828  case PGC_STRING:
829  set_string_field((struct config_string *) gconf,
830  &(val->val.stringval),
831  *((struct config_string *) gconf)->variable);
832  break;
833  case PGC_ENUM:
834  val->val.enumval =
835  *((struct config_enum *) gconf)->variable;
836  break;
837  }
838  set_extra_field(gconf, &(val->extra), gconf->extra);
839 }

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

732 {
733  char *oldval = *field;
734 
735  /* Do the assignment */
736  *field = newval;
737 
738  /* Free old value if it's not NULL and isn't referenced anymore */
739  if (oldval && !string_field_used(conf, oldval))
740  guc_free(oldval);
741 }

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

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

◆ SetConfigOption()

◆ ShowGUCOption()

char* ShowGUCOption ( struct config_generic record,
bool  use_units 
)

Definition at line 5465 of file guc.c.

5466 {
5467  char buffer[256];
5468  const char *val;
5469 
5470  switch (record->vartype)
5471  {
5472  case PGC_BOOL:
5473  {
5474  struct config_bool *conf = (struct config_bool *) record;
5475 
5476  if (conf->show_hook)
5477  val = conf->show_hook();
5478  else
5479  val = *conf->variable ? "on" : "off";
5480  }
5481  break;
5482 
5483  case PGC_INT:
5484  {
5485  struct config_int *conf = (struct config_int *) record;
5486 
5487  if (conf->show_hook)
5488  val = conf->show_hook();
5489  else
5490  {
5491  /*
5492  * Use int64 arithmetic to avoid overflows in units
5493  * conversion.
5494  */
5495  int64 result = *conf->variable;
5496  const char *unit;
5497 
5498  if (use_units && result > 0 && (record->flags & GUC_UNIT))
5500  record->flags & GUC_UNIT,
5501  &result, &unit);
5502  else
5503  unit = "";
5504 
5505  snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
5506  result, unit);
5507  val = buffer;
5508  }
5509  }
5510  break;
5511 
5512  case PGC_REAL:
5513  {
5514  struct config_real *conf = (struct config_real *) record;
5515 
5516  if (conf->show_hook)
5517  val = conf->show_hook();
5518  else
5519  {
5520  double result = *conf->variable;
5521  const char *unit;
5522 
5523  if (use_units && result > 0 && (record->flags & GUC_UNIT))
5525  record->flags & GUC_UNIT,
5526  &result, &unit);
5527  else
5528  unit = "";
5529 
5530  snprintf(buffer, sizeof(buffer), "%g%s",
5531  result, unit);
5532  val = buffer;
5533  }
5534  }
5535  break;
5536 
5537  case PGC_STRING:
5538  {
5539  struct config_string *conf = (struct config_string *) record;
5540 
5541  if (conf->show_hook)
5542  val = conf->show_hook();
5543  else if (*conf->variable && **conf->variable)
5544  val = *conf->variable;
5545  else
5546  val = "";
5547  }
5548  break;
5549 
5550  case PGC_ENUM:
5551  {
5552  struct config_enum *conf = (struct config_enum *) record;
5553 
5554  if (conf->show_hook)
5555  val = conf->show_hook();
5556  else
5557  val = config_enum_lookup_by_value(conf, *conf->variable);
5558  }
5559  break;
5560 
5561  default:
5562  /* just to keep compiler quiet */
5563  val = "???";
5564  break;
5565  }
5566 
5567  return pstrdup(val);
5568 }
#define INT64_FORMAT
Definition: c.h:551
static void convert_int_from_base_unit(int64 base_value, int base_unit, int64 *value, const char **unit)
Definition: guc.c:2729
static void convert_real_from_base_unit(double base_value, int base_unit, double *value, const char **unit)
Definition: guc.c:2771

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

709 {
710  GucStack *stack;
711 
712  if (strval == *(conf->variable) ||
713  strval == conf->reset_val ||
714  strval == conf->boot_val)
715  return true;
716  for (stack = conf->gen.stack; stack; stack = stack->prev)
717  {
718  if (strval == stack->prior.val.stringval ||
719  strval == stack->masked.val.stringval)
720  return true;
721  }
722  return false;
723 }

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

6400 {
6401  int i;
6402 
6403  Assert(array != NULL);
6404  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6405  Assert(ARR_NDIM(array) == 1);
6406  Assert(ARR_LBOUND(array)[0] == 1);
6407 
6408  *names = NIL;
6409  *values = NIL;
6410  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6411  {
6412  Datum d;
6413  bool isnull;
6414  char *s;
6415  char *name;
6416  char *value;
6417 
6418  d = array_ref(array, 1, &i,
6419  -1 /* varlenarray */ ,
6420  -1 /* TEXT's typlen */ ,
6421  false /* TEXT's typbyval */ ,
6422  TYPALIGN_INT /* TEXT's typalign */ ,
6423  &isnull);
6424 
6425  if (isnull)
6426  continue;
6427 
6428  s = TextDatumGetCString(d);
6429 
6430  ParseLongOption(s, &name, &value);
6431  if (!value)
6432  {
6433  ereport(WARNING,
6434  (errcode(ERRCODE_SYNTAX_ERROR),
6435  errmsg("could not parse setting for parameter \"%s\"",
6436  name)));
6437  pfree(name);
6438  continue;
6439  }
6440 
6441  *names = lappend(*names, name);
6442  *values = lappend(*values, value);
6443 
6444  pfree(s);
6445  }
6446 }
static Datum values[MAXATTR]
Definition: bootstrap.c:151
void ParseLongOption(const char *string, char **name, char **value)
Definition: guc.c:6362
#define NIL
Definition: pg_list.h:68

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

Referenced by fmgr_security_definer(), and ProcessGUCArray().

◆ valid_custom_variable_name()

static bool valid_custom_variable_name ( const char *  name)
static

Definition at line 1076 of file guc.c.

1077 {
1078  bool saw_sep = false;
1079  bool name_start = true;
1080 
1081  for (const char *p = name; *p; p++)
1082  {
1083  if (*p == GUC_QUALIFIER_SEPARATOR)
1084  {
1085  if (name_start)
1086  return false; /* empty name component */
1087  saw_sep = true;
1088  name_start = true;
1089  }
1090  else if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1091  "abcdefghijklmnopqrstuvwxyz_", *p) != NULL ||
1092  IS_HIGHBIT_SET(*p))
1093  {
1094  /* okay as first or non-first character */
1095  name_start = false;
1096  }
1097  else if (!name_start && strchr("0123456789$", *p) != NULL)
1098  /* okay as non-first character */ ;
1099  else
1100  return false;
1101  }
1102  if (name_start)
1103  return false; /* empty name component */
1104  /* OK if we found at least one separator */
1105  return saw_sep;
1106 }
#define IS_HIGHBIT_SET(ch)
Definition: c.h:1160

References GUC_QUALIFIER_SEPARATOR, IS_HIGHBIT_SET, and name.

Referenced by assignable_custom_variable_name(), and ProcessConfigFileInternal().

◆ validate_option_array_item()

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

Definition at line 6708 of file guc.c.

6711 {
6712  struct config_generic *gconf;
6713 
6714  /*
6715  * There are three cases to consider:
6716  *
6717  * name is a known GUC variable. Check the value normally, check
6718  * permissions normally (i.e., allow if variable is USERSET, or if it's
6719  * SUSET and user is superuser or holds ACL_SET permissions).
6720  *
6721  * name is not known, but exists or can be created as a placeholder (i.e.,
6722  * it has a valid custom name). We allow this case if you're a superuser,
6723  * otherwise not. Superusers are assumed to know what they're doing. We
6724  * can't allow it for other users, because when the placeholder is
6725  * resolved it might turn out to be a SUSET variable. (With currently
6726  * available infrastructure, we can actually handle such cases within the
6727  * current session --- but once an entry is made in pg_db_role_setting,
6728  * it's assumed to be fully validated.)
6729  *
6730  * name is not known and can't be created as a placeholder. Throw error,
6731  * unless skipIfNoPermissions is true, in which case return false.
6732  */
6733  gconf = find_option(name, true, skipIfNoPermissions, ERROR);
6734  if (!gconf)
6735  {
6736  /* not known, failed to make a placeholder */
6737  return false;
6738  }
6739 
6740  if (gconf->flags & GUC_CUSTOM_PLACEHOLDER)
6741  {
6742  /*
6743  * We cannot do any meaningful check on the value, so only permissions
6744  * are useful to check.
6745  */
6746  if (superuser() ||
6748  return true;
6749  if (skipIfNoPermissions)
6750  return false;
6751  ereport(ERROR,
6752  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
6753  errmsg("permission denied to set parameter \"%s\"", name)));
6754  }
6755 
6756  /* manual permissions check so we can avoid an error being thrown */
6757  if (gconf->context == PGC_USERSET)
6758  /* ok */ ;
6759  else if (gconf->context == PGC_SUSET &&
6760  (superuser() ||
6762  /* ok */ ;
6763  else if (skipIfNoPermissions)
6764  return false;
6765  /* if a permissions error should be thrown, let set_config_option do it */
6766 
6767  /* test for permissions and valid option value */
6768  (void) set_config_option(name, value,
6770  PGC_S_TEST, GUC_ACTION_SET, false, 0, false);
6771 
6772  return true;
6773 }
@ PGC_S_TEST
Definition: guc.h:121

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(), 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 4469 of file guc.c.

4470 {
4472  ConfigVariable *item;
4473 
4474  initStringInfo(&buf);
4475 
4476  /* Emit file header containing warning comment */
4477  appendStringInfoString(&buf, "# Do not edit this file manually!\n");
4478  appendStringInfoString(&buf, "# It will be overwritten by the ALTER SYSTEM command.\n");
4479 
4480  errno = 0;
4481  if (write(fd, buf.data, buf.len) != buf.len)
4482  {
4483  /* if write didn't set errno, assume problem is no disk space */
4484  if (errno == 0)
4485  errno = ENOSPC;
4486  ereport(ERROR,
4488  errmsg("could not write to file \"%s\": %m", filename)));
4489  }
4490 
4491  /* Emit each parameter, properly quoting the value */
4492  for (item = head; item != NULL; item = item->next)
4493  {
4494  char *escaped;
4495 
4496  resetStringInfo(&buf);
4497 
4498  appendStringInfoString(&buf, item->name);
4499  appendStringInfoString(&buf, " = '");
4500 
4501  escaped = escape_single_quotes_ascii(item->value);
4502  if (!escaped)
4503  ereport(ERROR,
4504  (errcode(ERRCODE_OUT_OF_MEMORY),
4505  errmsg("out of memory")));
4506  appendStringInfoString(&buf, escaped);
4507  free(escaped);
4508 
4509  appendStringInfoString(&buf, "'\n");
4510 
4511  errno = 0;
4512  if (write(fd, buf.data, buf.len) != buf.len)
4513  {
4514  /* if write didn't set errno, assume problem is no disk space */
4515  if (errno == 0)
4516  errno = ENOSPC;
4517  ereport(ERROR,
4519  errmsg("could not write to file \"%s\": %m", filename)));
4520  }
4521  }
4522 
4523  /* fsync before considering the write to be successful */
4524  if (pg_fsync(fd) != 0)
4525  ereport(ERROR,
4527  errmsg("could not fsync file \"%s\": %m", filename)));
4528 
4529  pfree(buf.data);
4530 }
int pg_fsync(int fd)
Definition: fd.c:385
#define write(a, b, c)
Definition: win32.h:14
static char * filename
Definition: pg_dumpall.c:119
static char * buf
Definition: pg_test_fsync.c:72
char * escape_single_quotes_ascii(const char *src)
Definition: quotes.c:33
static int fd(const char *x, int i)
Definition: preproc-init.c:105
void resetStringInfo(StringInfo str)
Definition: stringinfo.c:75

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

◆ GUC_check_errdetail_string

char* GUC_check_errdetail_string

◆ GUC_check_errhint_string

char* GUC_check_errhint_string

◆ GUC_check_errmsg_string

char* GUC_check_errmsg_string

◆ guc_hashtab

◆ guc_nondef_list

◆ guc_report_list

slist_head guc_report_list
static

◆ guc_stack_list

slist_head guc_stack_list
static

Definition at line 224 of file guc.c.

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

◆ GUCMemoryContext

MemoryContext GUCMemoryContext
static

Definition at line 199 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 231 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 190 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

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

Referenced by parse_int(), and parse_real().

◆ reporting_enabled

bool reporting_enabled
static

Definition at line 229 of file guc.c.

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

◆ reserved_class_prefix

List* reserved_class_prefix = NIL
static

Definition at line 78 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 158 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 156 of file guc.c.

Referenced by parse_int(), and parse_real().