PostgreSQL Source Code  git master
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 *name, const char *value, GucSource source, int elevel, union config_var_val *newval, void **newextra)
 
int set_config_option (const char *name, const char *value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)
 
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
 
bool in_hot_standby_guc
 
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 104 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 1049 of file guc.c.

1050 {
1051  GUCHashEntry *hentry;
1052  bool found;
1053 
1054  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1055  &var->name,
1057  &found);
1058  if (unlikely(hentry == NULL))
1059  {
1060  ereport(elevel,
1061  (errcode(ERRCODE_OUT_OF_MEMORY),
1062  errmsg("out of memory")));
1063  return false; /* out of memory */
1064  }
1065  Assert(!found);
1066  hentry->gucvar = var;
1067  return true;
1068 }
#define Assert(condition)
Definition: c.h:858
#define unlikely(x)
Definition: c.h:311
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
int errcode(int sqlerrcode)
Definition: elog.c:859
int errmsg(const char *fmt,...)
Definition: elog.c:1072
#define ereport(elevel,...)
Definition: elog.h:149
static HTAB * guc_hashtab
Definition: guc.c:214
@ HASH_ENTER_NULL
Definition: hsearch.h:116
struct config_generic * gucvar
Definition: guc.c:211
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 1179 of file guc.c.

1180 {
1181  size_t sz = sizeof(struct config_string) + sizeof(char *);
1182  struct config_string *var;
1183  struct config_generic *gen;
1184 
1185  var = (struct config_string *) guc_malloc(elevel, sz);
1186  if (var == NULL)
1187  return NULL;
1188  memset(var, 0, sz);
1189  gen = &var->gen;
1190 
1191  gen->name = guc_strdup(elevel, name);
1192  if (gen->name == NULL)
1193  {
1194  guc_free(var);
1195  return NULL;
1196  }
1197 
1198  gen->context = PGC_USERSET;
1200  gen->short_desc = "GUC placeholder variable";
1202  gen->vartype = PGC_STRING;
1203 
1204  /*
1205  * The char* is allocated at the end of the struct since we have no
1206  * 'static' place to point to. Note that the current value, as well as
1207  * the boot and reset values, start out NULL.
1208  */
1209  var->variable = (char **) (var + 1);
1210 
1211  if (!add_guc_variable((struct config_generic *) var, elevel))
1212  {
1213  guc_free(unconstify(char *, gen->name));
1214  guc_free(var);
1215  return NULL;
1216  }
1217 
1218  return gen;
1219 }
#define unconstify(underlying_type, expr)
Definition: c.h:1245
void * guc_malloc(int elevel, size_t size)
Definition: guc.c:640
void guc_free(void *ptr)
Definition: guc.c:691
static bool add_guc_variable(struct config_generic *var, int elevel)
Definition: guc.c:1049
char * guc_strdup(int elevel, const char *src)
Definition: guc.c:679
#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 4550 of file guc.c.

4551 {
4552  char *name;
4553  char *value;
4554  bool resetall = false;
4555  ConfigVariable *head = NULL;
4556  ConfigVariable *tail = NULL;
4557  volatile int Tmpfd;
4558  char AutoConfFileName[MAXPGPATH];
4559  char AutoConfTmpFileName[MAXPGPATH];
4560 
4561  /*
4562  * Extract statement arguments
4563  */
4564  name = altersysstmt->setstmt->name;
4565 
4566  if (!AllowAlterSystem)
4567  ereport(ERROR,
4568  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4569  errmsg("ALTER SYSTEM is not allowed in this environment")));
4570 
4571  switch (altersysstmt->setstmt->kind)
4572  {
4573  case VAR_SET_VALUE:
4574  value = ExtractSetVariableArgs(altersysstmt->setstmt);
4575  break;
4576 
4577  case VAR_SET_DEFAULT:
4578  case VAR_RESET:
4579  value = NULL;
4580  break;
4581 
4582  case VAR_RESET_ALL:
4583  value = NULL;
4584  resetall = true;
4585  break;
4586 
4587  default:
4588  elog(ERROR, "unrecognized alter system stmt type: %d",
4589  altersysstmt->setstmt->kind);
4590  break;
4591  }
4592 
4593  /*
4594  * Check permission to run ALTER SYSTEM on the target variable
4595  */
4596  if (!superuser())
4597  {
4598  if (resetall)
4599  ereport(ERROR,
4600  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4601  errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4602  else
4603  {
4604  AclResult aclresult;
4605 
4606  aclresult = pg_parameter_aclcheck(name, GetUserId(),
4608  if (aclresult != ACLCHECK_OK)
4609  ereport(ERROR,
4610  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4611  errmsg("permission denied to set parameter \"%s\"",
4612  name)));
4613  }
4614  }
4615 
4616  /*
4617  * Unless it's RESET_ALL, validate the target variable and value
4618  */
4619  if (!resetall)
4620  {
4621  struct config_generic *record;
4622 
4623  /* We don't want to create a placeholder if there's not one already */
4624  record = find_option(name, false, true, DEBUG5);
4625  if (record != NULL)
4626  {
4627  /*
4628  * Don't allow parameters that can't be set in configuration files
4629  * to be set in PG_AUTOCONF_FILENAME file.
4630  */
4631  if ((record->context == PGC_INTERNAL) ||
4632  (record->flags & GUC_DISALLOW_IN_FILE) ||
4633  (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
4634  ereport(ERROR,
4635  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4636  errmsg("parameter \"%s\" cannot be changed",
4637  name)));
4638 
4639  /*
4640  * If a value is specified, verify that it's sane.
4641  */
4642  if (value)
4643  {
4644  union config_var_val newval;
4645  void *newextra = NULL;
4646 
4647  if (!parse_and_validate_value(record, name, value,
4648  PGC_S_FILE, ERROR,
4649  &newval, &newextra))
4650  ereport(ERROR,
4651  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4652  errmsg("invalid value for parameter \"%s\": \"%s\"",
4653  name, value)));
4654 
4655  if (record->vartype == PGC_STRING && newval.stringval != NULL)
4656  guc_free(newval.stringval);
4657  guc_free(newextra);
4658  }
4659  }
4660  else
4661  {
4662  /*
4663  * Variable not known; check we'd be allowed to create it. (We
4664  * cannot validate the value, but that's fine. A non-core GUC in
4665  * the config file cannot cause postmaster start to fail, so we
4666  * don't have to be too tense about possibly installing a bad
4667  * value.)
4668  */
4669  (void) assignable_custom_variable_name(name, false, ERROR);
4670  }
4671 
4672  /*
4673  * We must also reject values containing newlines, because the grammar
4674  * for config files doesn't support embedded newlines in string
4675  * literals.
4676  */
4677  if (value && strchr(value, '\n'))
4678  ereport(ERROR,
4679  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4680  errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4681  }
4682 
4683  /*
4684  * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4685  * the data directory, so we can reference them by simple relative paths.
4686  */
4687  snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4689  snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4690  AutoConfFileName,
4691  "tmp");
4692 
4693  /*
4694  * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4695  * time. Use AutoFileLock to ensure that. We must hold the lock while
4696  * reading the old file contents.
4697  */
4698  LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4699 
4700  /*
4701  * If we're going to reset everything, then no need to open or parse the
4702  * old file. We'll just write out an empty list.
4703  */
4704  if (!resetall)
4705  {
4706  struct stat st;
4707 
4708  if (stat(AutoConfFileName, &st) == 0)
4709  {
4710  /* open old file PG_AUTOCONF_FILENAME */
4711  FILE *infile;
4712 
4713  infile = AllocateFile(AutoConfFileName, "r");
4714  if (infile == NULL)
4715  ereport(ERROR,
4717  errmsg("could not open file \"%s\": %m",
4718  AutoConfFileName)));
4719 
4720  /* parse it */
4721  if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4722  LOG, &head, &tail))
4723  ereport(ERROR,
4724  (errcode(ERRCODE_CONFIG_FILE_ERROR),
4725  errmsg("could not parse contents of file \"%s\"",
4726  AutoConfFileName)));
4727 
4728  FreeFile(infile);
4729  }
4730 
4731  /*
4732  * Now, replace any existing entry with the new value, or add it if
4733  * not present.
4734  */
4735  replace_auto_config_value(&head, &tail, name, value);
4736  }
4737 
4738  /*
4739  * Invoke the post-alter hook for setting this GUC variable. GUCs
4740  * typically do not have corresponding entries in pg_parameter_acl, so we
4741  * call the hook using the name rather than a potentially-non-existent
4742  * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4743  * context can be distinguished from others. (Note that "name" will be
4744  * NULL in the RESET ALL case.)
4745  *
4746  * We do this here rather than at the end, because ALTER SYSTEM is not
4747  * transactional. If the hook aborts our transaction, it will be cleaner
4748  * to do so before we touch any files.
4749  */
4750  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4752  altersysstmt->setstmt->kind,
4753  false);
4754 
4755  /*
4756  * To ensure crash safety, first write the new file data to a temp file,
4757  * then atomically rename it into place.
4758  *
4759  * If there is a temp file left over due to a previous crash, it's okay to
4760  * truncate and reuse it.
4761  */
4762  Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4763  O_CREAT | O_RDWR | O_TRUNC);
4764  if (Tmpfd < 0)
4765  ereport(ERROR,
4767  errmsg("could not open file \"%s\": %m",
4768  AutoConfTmpFileName)));
4769 
4770  /*
4771  * Use a TRY block to clean up the file if we fail. Since we need a TRY
4772  * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4773  */
4774  PG_TRY();
4775  {
4776  /* Write and sync the new contents to the temporary file */
4777  write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4778 
4779  /* Close before renaming; may be required on some platforms */
4780  close(Tmpfd);
4781  Tmpfd = -1;
4782 
4783  /*
4784  * As the rename is atomic operation, if any problem occurs after this
4785  * at worst it can lose the parameters set by last ALTER SYSTEM
4786  * command.
4787  */
4788  durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4789  }
4790  PG_CATCH();
4791  {
4792  /* Close file first, else unlink might fail on some platforms */
4793  if (Tmpfd >= 0)
4794  close(Tmpfd);
4795 
4796  /* Unlink, but ignore any error */
4797  (void) unlink(AutoConfTmpFileName);
4798 
4799  PG_RE_THROW();
4800  }
4801  PG_END_TRY();
4802 
4803  FreeConfigVariables(head);
4804 
4805  LWLockRelease(AutoFileLock);
4806 }
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:4104
#define CONF_FILE_START_DEPTH
Definition: conffiles.h:17
int errcode_for_file_access(void)
Definition: elog.c:882
#define LOG
Definition: elog.h:31
#define PG_RE_THROW()
Definition: elog.h:411
#define PG_TRY(...)
Definition: elog.h:370
#define PG_END_TRY(...)
Definition: elog.h:395
#define ERROR
Definition: elog.h:39
#define PG_CATCH(...)
Definition: elog.h:380
#define elog(elevel,...)
Definition: elog.h:224
#define DEBUG5
Definition: elog.h:26
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2583
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:782
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:1087
int FreeFile(FILE *file)
Definition: fd.c:2781
static bool assignable_custom_variable_name(const char *name, bool skip_errors, int elevel)
Definition: guc.c:1123
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1237
static bool parse_and_validate_value(struct config_generic *record, const char *name, const char *value, GucSource source, int elevel, union config_var_val *newval, void **newextra)
Definition: guc.c:3132
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head)
Definition: guc.c:4412
#define newval
static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
Definition: guc.c:4480
#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:498
static struct @155 value
#define close(a)
Definition: win32.h:12
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1170
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1783
@ LW_EXCLUSIVE
Definition: lwlock.h:114
Oid GetUserId(void)
Definition: miscinit.c:514
#define InvokeObjectPostAlterHookArgStr(classId, objectName, subId, auxiliaryId, is_internal)
Definition: objectaccess.h:247
@ VAR_SET_DEFAULT
Definition: parsenodes.h:2618
@ VAR_RESET
Definition: parsenodes.h:2621
@ VAR_SET_VALUE
Definition: parsenodes.h:2617
@ VAR_RESET_ALL
Definition: parsenodes.h:2622
#define ACL_ALTER_SYSTEM
Definition: parsenodes.h:89
#define MAXPGPATH
#define snprintf
Definition: port.h:238
VariableSetStmt * setstmt
Definition: parsenodes.h:3827
VariableSetKind kind
Definition: parsenodes.h:2628
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 1123 of file guc.c.

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

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

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

References elog, GUCNestLevel, and WARNING.

Referenced by StartTransaction().

◆ BeginReportingGUCOptions()

void BeginReportingGUCOptions ( void  )

Definition at line 2548 of file guc.c.

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

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

Referenced by PostgresMain().

◆ build_guc_variables()

void build_guc_variables ( void  )

Definition at line 905 of file guc.c.

906 {
907  int size_vars;
908  int num_vars = 0;
909  HASHCTL hash_ctl;
910  GUCHashEntry *hentry;
911  bool found;
912  int i;
913 
914  /*
915  * Create the memory context that will hold all GUC-related data.
916  */
917  Assert(GUCMemoryContext == NULL);
919  "GUCMemoryContext",
921 
922  /*
923  * Count all the built-in variables, and set their vartypes correctly.
924  */
925  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
926  {
927  struct config_bool *conf = &ConfigureNamesBool[i];
928 
929  /* Rather than requiring vartype to be filled in by hand, do this: */
930  conf->gen.vartype = PGC_BOOL;
931  num_vars++;
932  }
933 
934  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
935  {
936  struct config_int *conf = &ConfigureNamesInt[i];
937 
938  conf->gen.vartype = PGC_INT;
939  num_vars++;
940  }
941 
942  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
943  {
944  struct config_real *conf = &ConfigureNamesReal[i];
945 
946  conf->gen.vartype = PGC_REAL;
947  num_vars++;
948  }
949 
950  for (i = 0; ConfigureNamesString[i].gen.name; i++)
951  {
952  struct config_string *conf = &ConfigureNamesString[i];
953 
954  conf->gen.vartype = PGC_STRING;
955  num_vars++;
956  }
957 
958  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
959  {
960  struct config_enum *conf = &ConfigureNamesEnum[i];
961 
962  conf->gen.vartype = PGC_ENUM;
963  num_vars++;
964  }
965 
966  /*
967  * Create hash table with 20% slack
968  */
969  size_vars = num_vars + num_vars / 4;
970 
971  hash_ctl.keysize = sizeof(char *);
972  hash_ctl.entrysize = sizeof(GUCHashEntry);
973  hash_ctl.hash = guc_name_hash;
974  hash_ctl.match = guc_name_match;
975  hash_ctl.hcxt = GUCMemoryContext;
976  guc_hashtab = hash_create("GUC hash table",
977  size_vars,
978  &hash_ctl,
980 
981  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
982  {
983  struct config_generic *gucvar = &ConfigureNamesBool[i].gen;
984 
985  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
986  &gucvar->name,
987  HASH_ENTER,
988  &found);
989  Assert(!found);
990  hentry->gucvar = gucvar;
991  }
992 
993  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
994  {
995  struct config_generic *gucvar = &ConfigureNamesInt[i].gen;
996 
997  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
998  &gucvar->name,
999  HASH_ENTER,
1000  &found);
1001  Assert(!found);
1002  hentry->gucvar = gucvar;
1003  }
1004 
1005  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
1006  {
1007  struct config_generic *gucvar = &ConfigureNamesReal[i].gen;
1008 
1009  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1010  &gucvar->name,
1011  HASH_ENTER,
1012  &found);
1013  Assert(!found);
1014  hentry->gucvar = gucvar;
1015  }
1016 
1017  for (i = 0; ConfigureNamesString[i].gen.name; i++)
1018  {
1019  struct config_generic *gucvar = &ConfigureNamesString[i].gen;
1020 
1021  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1022  &gucvar->name,
1023  HASH_ENTER,
1024  &found);
1025  Assert(!found);
1026  hentry->gucvar = gucvar;
1027  }
1028 
1029  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
1030  {
1031  struct config_generic *gucvar = &ConfigureNamesEnum[i].gen;
1032 
1033  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1034  &gucvar->name,
1035  HASH_ENTER,
1036  &found);
1037  Assert(!found);
1038  hentry->gucvar = gucvar;
1039  }
1040 
1041  Assert(num_vars == hash_get_num_entries(guc_hashtab));
1042 }
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:1356
static uint32 guc_name_hash(const void *key, Size keysize)
Definition: guc.c:1332
static MemoryContext GUCMemoryContext
Definition: guc.c:201
struct config_string ConfigureNamesString[]
Definition: guc_tables.c:3959
struct config_int ConfigureNamesInt[]
Definition: guc_tables.c:2056
struct config_bool ConfigureNamesBool[]
Definition: guc_tables.c:771
struct config_real ConfigureNamesReal[]
Definition: guc_tables.c:3678
struct config_enum ConfigureNamesEnum[]
Definition: guc_tables.c:4736
@ 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:73
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 6747 of file guc.c.

6749 {
6750  /* Quick success if no hook */
6751  if (!conf->check_hook)
6752  return true;
6753 
6754  /* Reset variables that might be set by hook */
6755  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6756  GUC_check_errmsg_string = NULL;
6758  GUC_check_errhint_string = NULL;
6759 
6760  if (!conf->check_hook(newval, extra, source))
6761  {
6762  ereport(elevel,
6766  errmsg("invalid value for parameter \"%s\": %d",
6767  conf->gen.name, (int) *newval),
6771  errhint("%s", GUC_check_errhint_string) : 0));
6772  /* Flush any strings created in ErrorContext */
6773  FlushErrorState();
6774  return false;
6775  }
6776 
6777  return true;
6778 }
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1159
int errdetail_internal(const char *fmt,...)
Definition: elog.c:1232
void FlushErrorState(void)
Definition: elog.c:1836
int errhint(const char *fmt,...)
Definition: elog.c:1319
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 6899 of file guc.c.

6901 {
6902  /* Quick success if no hook */
6903  if (!conf->check_hook)
6904  return true;
6905 
6906  /* Reset variables that might be set by hook */
6907  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6908  GUC_check_errmsg_string = NULL;
6910  GUC_check_errhint_string = NULL;
6911 
6912  if (!conf->check_hook(newval, extra, source))
6913  {
6914  ereport(elevel,
6918  errmsg("invalid value for parameter \"%s\": \"%s\"",
6919  conf->gen.name,
6924  errhint("%s", GUC_check_errhint_string) : 0));
6925  /* Flush any strings created in ErrorContext */
6926  FlushErrorState();
6927  return false;
6928  }
6929 
6930  return true;
6931 }
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:3025
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 6781 of file guc.c.

6783 {
6784  /* Quick success if no hook */
6785  if (!conf->check_hook)
6786  return true;
6787 
6788  /* Reset variables that might be set by hook */
6789  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6790  GUC_check_errmsg_string = NULL;
6792  GUC_check_errhint_string = NULL;
6793 
6794  if (!conf->check_hook(newval, extra, source))
6795  {
6796  ereport(elevel,
6800  errmsg("invalid value for parameter \"%s\": %d",
6801  conf->gen.name, *newval),
6805  errhint("%s", GUC_check_errhint_string) : 0));
6806  /* Flush any strings created in ErrorContext */
6807  FlushErrorState();
6808  return false;
6809  }
6810 
6811  return true;
6812 }
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 6815 of file guc.c.

6817 {
6818  /* Quick success if no hook */
6819  if (!conf->check_hook)
6820  return true;
6821 
6822  /* Reset variables that might be set by hook */
6823  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6824  GUC_check_errmsg_string = NULL;
6826  GUC_check_errhint_string = NULL;
6827 
6828  if (!conf->check_hook(newval, extra, source))
6829  {
6830  ereport(elevel,
6834  errmsg("invalid value for parameter \"%s\": %g",
6835  conf->gen.name, *newval),
6839  errhint("%s", GUC_check_errhint_string) : 0));
6840  /* Flush any strings created in ErrorContext */
6841  FlushErrorState();
6842  return false;
6843  }
6844 
6845  return true;
6846 }
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 6849 of file guc.c.

6851 {
6852  volatile bool result = true;
6853 
6854  /* Quick success if no hook */
6855  if (!conf->check_hook)
6856  return true;
6857 
6858  /*
6859  * If elevel is ERROR, or if the check_hook itself throws an elog
6860  * (undesirable, but not always avoidable), make sure we don't leak the
6861  * already-malloc'd newval string.
6862  */
6863  PG_TRY();
6864  {
6865  /* Reset variables that might be set by hook */
6866  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6867  GUC_check_errmsg_string = NULL;
6869  GUC_check_errhint_string = NULL;
6870 
6871  if (!conf->check_hook(newval, extra, source))
6872  {
6873  ereport(elevel,
6877  errmsg("invalid value for parameter \"%s\": \"%s\"",
6878  conf->gen.name, *newval ? *newval : ""),
6882  errhint("%s", GUC_check_errhint_string) : 0));
6883  /* Flush any strings created in ErrorContext */
6884  FlushErrorState();
6885  result = false;
6886  }
6887  }
6888  PG_CATCH();
6889  {
6890  guc_free(*newval);
6891  PG_RE_THROW();
6892  }
6893  PG_END_TRY();
6894 
6895  return result;
6896 }
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 5757 of file guc.c.

5758 {
5759  /*
5760  * We can skip GUCs that are guaranteed to have the same values in leaders
5761  * and workers. (Note it is critical that the leader and worker have the
5762  * same idea of which GUCs fall into this category. It's okay to consider
5763  * context and name for this purpose, since those are unchanging
5764  * properties of a GUC.)
5765  *
5766  * PGC_POSTMASTER variables always have the same value in every child of a
5767  * particular postmaster, so the worker will certainly have the right
5768  * value already. Likewise, PGC_INTERNAL variables are set by special
5769  * mechanisms (if indeed they aren't compile-time constants). So we may
5770  * always skip these.
5771  *
5772  * Role must be handled specially because its current value can be an
5773  * invalid value (for instance, if someone dropped the role since we set
5774  * it). So if we tried to serialize it normally, we might get a failure.
5775  * We skip it here, and use another mechanism to ensure the worker has the
5776  * right value.
5777  *
5778  * For all other GUCs, we skip if the GUC has its compiled-in default
5779  * value (i.e., source == PGC_S_DEFAULT). On the leader side, this means
5780  * we don't send GUCs that have their default values, which typically
5781  * saves lots of work. On the worker side, this means we don't need to
5782  * reset the GUC to default because it already has that value. See
5783  * comments in RestoreGUCState for more info.
5784  */
5785  return gconf->context == PGC_POSTMASTER ||
5786  gconf->context == PGC_INTERNAL || gconf->source == PGC_S_DEFAULT ||
5787  strcmp(gconf->name, "role") == 0;
5788 }
@ PGC_S_DEFAULT
Definition: guc.h:109
@ PGC_POSTMASTER
Definition: guc.h:70
GucSource source
Definition: guc_tables.h:165

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

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

◆ check_GUC_name_for_parameter_acl()

void check_GUC_name_for_parameter_acl ( const char *  name)

Definition at line 1412 of file guc.c.

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

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

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

3050 {
3051  const struct config_enum_entry *entry;
3052 
3053  for (entry = record->options; entry && entry->name; entry++)
3054  {
3055  if (pg_strcasecmp(value, entry->name) == 0)
3056  {
3057  *retval = entry->val;
3058  return true;
3059  }
3060  }
3061 
3062  *retval = 0;
3063  return false;
3064 }
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 3025 of file guc.c.

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

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

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

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

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

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

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

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

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

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

4875 {
4876  const char *name = variable->name;
4877  GUCHashEntry *hentry;
4878  struct config_string *pHolder;
4879 
4880  /* Check mapping between initial and default value */
4881  Assert(check_GUC_init(variable));
4882 
4883  /*
4884  * See if there's a placeholder by the same name.
4885  */
4886  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
4887  &name,
4888  HASH_FIND,
4889  NULL);
4890  if (hentry == NULL)
4891  {
4892  /*
4893  * No placeholder to replace, so we can just add it ... but first,
4894  * make sure it's initialized to its default value.
4895  */
4898  return;
4899  }
4900 
4901  /*
4902  * This better be a placeholder
4903  */
4904  if ((hentry->gucvar->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
4905  ereport(ERROR,
4906  (errcode(ERRCODE_INTERNAL_ERROR),
4907  errmsg("attempt to redefine parameter \"%s\"", name)));
4908 
4909  Assert(hentry->gucvar->vartype == PGC_STRING);
4910  pHolder = (struct config_string *) hentry->gucvar;
4911 
4912  /*
4913  * First, set the variable to its default value. We must do this even
4914  * though we intend to immediately apply a new value, since it's possible
4915  * that the new value is invalid.
4916  */
4918 
4919  /*
4920  * Replace the placeholder in the hash table. We aren't changing the name
4921  * (at least up to case-folding), so the hash value is unchanged.
4922  */
4923  hentry->gucname = name;
4924  hentry->gucvar = variable;
4925 
4926  /*
4927  * Remove the placeholder from any lists it's in, too.
4928  */
4929  RemoveGUCFromLists(&pHolder->gen);
4930 
4931  /*
4932  * Assign the string value(s) stored in the placeholder to the real
4933  * variable. Essentially, we need to duplicate all the active and stacked
4934  * values, but with appropriate validation and datatype adjustment.
4935  *
4936  * If an assignment fails, we report a WARNING and keep going. We don't
4937  * want to throw ERROR for bad values, because it'd bollix the add-on
4938  * module that's presumably halfway through getting loaded. In such cases
4939  * the default or previous state will become active instead.
4940  */
4941 
4942  /* First, apply the reset value if any */
4943  if (pHolder->reset_val)
4944  (void) set_config_option_ext(name, pHolder->reset_val,
4945  pHolder->gen.reset_scontext,
4946  pHolder->gen.reset_source,
4947  pHolder->gen.reset_srole,
4948  GUC_ACTION_SET, true, WARNING, false);
4949  /* That should not have resulted in stacking anything */
4950  Assert(variable->stack == NULL);
4951 
4952  /* Now, apply current and stacked values, in the order they were stacked */
4953  reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
4954  *(pHolder->variable),
4955  pHolder->gen.scontext, pHolder->gen.source,
4956  pHolder->gen.srole);
4957 
4958  /* Also copy over any saved source-location information */
4959  if (pHolder->gen.sourcefile)
4961  pHolder->gen.sourceline);
4962 
4963  /*
4964  * Free up as much as we conveniently can of the placeholder structure.
4965  * (This neglects any stack items, so it's possible for some memory to be
4966  * leaked. Since this can only happen once per session per variable, it
4967  * doesn't seem worth spending much code on.)
4968  */
4969  set_string_field(pHolder, pHolder->variable, NULL);
4970  set_string_field(pHolder, &pHolder->reset_val, NULL);
4971 
4972  guc_free(pHolder);
4973 }
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:3373
static void set_config_sourcefile(const char *name, char *sourcefile, int sourceline)
Definition: guc.c:4242
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:4983
static void InitializeOneGUCOption(struct config_generic *gconf)
Definition: guc.c:1646
static void RemoveGUCFromLists(struct config_generic *gconf)
Definition: guc.c:1763
@ GUC_ACTION_SET
Definition: guc.h:199
@ HASH_FIND
Definition: hsearch.h:113
const char * gucname
Definition: guc.c:210
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 5075 of file guc.c.

5085 {
5086  struct config_bool *var;
5087 
5088  var = (struct config_bool *)
5089  init_custom_variable(name, short_desc, long_desc, context, flags,
5090  PGC_BOOL, sizeof(struct config_bool));
5091  var->variable = valueAddr;
5092  var->boot_val = bootValue;
5093  var->reset_val = bootValue;
5094  var->check_hook = check_hook;
5095  var->assign_hook = assign_hook;
5096  var->show_hook = show_hook;
5097  define_custom_variable(&var->gen);
5098 }
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:4814
static void define_custom_variable(struct config_generic *variable)
Definition: guc.c:4874
tree context
Definition: radixtree.h:1829
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 5186 of file guc.c.

5197 {
5198  struct config_enum *var;
5199 
5200  var = (struct config_enum *)
5201  init_custom_variable(name, short_desc, long_desc, context, flags,
5202  PGC_ENUM, sizeof(struct config_enum));
5203  var->variable = valueAddr;
5204  var->boot_val = bootValue;
5205  var->reset_val = bootValue;
5206  var->options = options;
5207  var->check_hook = check_hook;
5208  var->assign_hook = assign_hook;
5209  var->show_hook = show_hook;
5210  define_custom_variable(&var->gen);
5211 }
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 5101 of file guc.c.

5113 {
5114  struct config_int *var;
5115 
5116  var = (struct config_int *)
5117  init_custom_variable(name, short_desc, long_desc, context, flags,
5118  PGC_INT, sizeof(struct config_int));
5119  var->variable = valueAddr;
5120  var->boot_val = bootValue;
5121  var->reset_val = bootValue;
5122  var->min = minValue;
5123  var->max = maxValue;
5124  var->check_hook = check_hook;
5125  var->assign_hook = assign_hook;
5126  var->show_hook = show_hook;
5127  define_custom_variable(&var->gen);
5128 }
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 5131 of file guc.c.

5143 {
5144  struct config_real *var;
5145 
5146  var = (struct config_real *)
5147  init_custom_variable(name, short_desc, long_desc, context, flags,
5148  PGC_REAL, sizeof(struct config_real));
5149  var->variable = valueAddr;
5150  var->boot_val = bootValue;
5151  var->reset_val = bootValue;
5152  var->min = minValue;
5153  var->max = maxValue;
5154  var->check_hook = check_hook;
5155  var->assign_hook = assign_hook;
5156  var->show_hook = show_hook;
5157  define_custom_variable(&var->gen);
5158 }
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 5161 of file guc.c.

5171 {
5172  struct config_string *var;
5173 
5174  var = (struct config_string *)
5175  init_custom_variable(name, short_desc, long_desc, context, flags,
5176  PGC_STRING, sizeof(struct config_string));
5177  var->variable = valueAddr;
5178  var->boot_val = bootValue;
5179  var->check_hook = check_hook;
5180  var->assign_hook = assign_hook;
5181  var->show_hook = show_hook;
5182  define_custom_variable(&var->gen);
5183 }
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 848 of file guc.c.

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

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

5929 {
5930  va_list vargs;
5931  int n;
5932 
5933  if (*maxbytes <= 0)
5934  elog(ERROR, "not enough space to serialize GUC state");
5935 
5936  va_start(vargs, fmt);
5937  n = vsnprintf(*destptr, *maxbytes, fmt, vargs);
5938  va_end(vargs);
5939 
5940  if (n < 0)
5941  {
5942  /* Shouldn't happen. Better show errno description. */
5943  elog(ERROR, "vsnprintf failed: %m with format string \"%s\"", fmt);
5944  }
5945  if (n >= *maxbytes)
5946  {
5947  /* This shouldn't happen either, really. */
5948  elog(ERROR, "not enough space to serialize GUC state");
5949  }
5950 
5951  /* Shift the destptr ahead of the null terminator */
5952  *destptr += n + 1;
5953  *maxbytes -= n + 1;
5954 }
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 5958 of file guc.c.

5959 {
5960  if (valsize > *maxbytes)
5961  elog(ERROR, "not enough space to serialize GUC state");
5962 
5963  memcpy(*destptr, val, valsize);
5964  *destptr += valsize;
5965  *maxbytes -= valsize;
5966 }

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

5798 {
5799  Size size;
5800  Size valsize = 0;
5801 
5802  /* Skippable GUCs consume zero space. */
5803  if (can_skip_gucvar(gconf))
5804  return 0;
5805 
5806  /* Name, plus trailing zero byte. */
5807  size = strlen(gconf->name) + 1;
5808 
5809  /* Get the maximum display length of the GUC value. */
5810  switch (gconf->vartype)
5811  {
5812  case PGC_BOOL:
5813  {
5814  valsize = 5; /* max(strlen('true'), strlen('false')) */
5815  }
5816  break;
5817 
5818  case PGC_INT:
5819  {
5820  struct config_int *conf = (struct config_int *) gconf;
5821 
5822  /*
5823  * Instead of getting the exact display length, use max
5824  * length. Also reduce the max length for typical ranges of
5825  * small values. Maximum value is 2147483647, i.e. 10 chars.
5826  * Include one byte for sign.
5827  */
5828  if (abs(*conf->variable) < 1000)
5829  valsize = 3 + 1;
5830  else
5831  valsize = 10 + 1;
5832  }
5833  break;
5834 
5835  case PGC_REAL:
5836  {
5837  /*
5838  * We are going to print it with %e with REALTYPE_PRECISION
5839  * fractional digits. Account for sign, leading digit,
5840  * decimal point, and exponent with up to 3 digits. E.g.
5841  * -3.99329042340000021e+110
5842  */
5843  valsize = 1 + 1 + 1 + REALTYPE_PRECISION + 5;
5844  }
5845  break;
5846 
5847  case PGC_STRING:
5848  {
5849  struct config_string *conf = (struct config_string *) gconf;
5850 
5851  /*
5852  * If the value is NULL, we transmit it as an empty string.
5853  * Although this is not physically the same value, GUC
5854  * generally treats a NULL the same as empty string.
5855  */
5856  if (*conf->variable)
5857  valsize = strlen(*conf->variable);
5858  else
5859  valsize = 0;
5860  }
5861  break;
5862 
5863  case PGC_ENUM:
5864  {
5865  struct config_enum *conf = (struct config_enum *) gconf;
5866 
5867  valsize = strlen(config_enum_lookup_by_value(conf, *conf->variable));
5868  }
5869  break;
5870  }
5871 
5872  /* Allow space for terminating zero-byte for value */
5873  size = add_size(size, valsize + 1);
5874 
5875  if (gconf->sourcefile)
5876  size = add_size(size, strlen(gconf->sourcefile));
5877 
5878  /* Allow space for terminating zero-byte for sourcefile */
5879  size = add_size(size, 1);
5880 
5881  /* Include line whenever file is nonempty. */
5882  if (gconf->sourcefile && gconf->sourcefile[0])
5883  size = add_size(size, sizeof(gconf->sourceline));
5884 
5885  size = add_size(size, sizeof(gconf->source));
5886  size = add_size(size, sizeof(gconf->scontext));
5887  size = add_size(size, sizeof(gconf->srole));
5888 
5889  return size;
5890 }
size_t Size
Definition: c.h:605
static bool can_skip_gucvar(struct config_generic *gconf)
Definition: guc.c:5757
#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 5897 of file guc.c.

5898 {
5899  Size size;
5900  dlist_iter iter;
5901 
5902  /* Add space reqd for saving the data size of the guc state */
5903  size = sizeof(Size);
5904 
5905  /*
5906  * Add up the space needed for each GUC variable.
5907  *
5908  * We need only process non-default GUCs.
5909  */
5911  {
5912  struct config_generic *gconf = dlist_container(struct config_generic,
5913  nondef_link, iter.cur);
5914 
5916  }
5917 
5918  return size;
5919 }
static dlist_head guc_nondef_list
Definition: guc.c:224
static Size estimate_variable_size(struct config_generic *gconf)
Definition: guc.c:5797
#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 749 of file guc.c.

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

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

Referenced by set_config_with_handle(), and set_extra_field().

◆ find_option()

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

Definition at line 1237 of file guc.c.

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

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

4228 {
4229  struct config_generic *gen = find_option(name, false, false, 0);
4230 
4231  if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
4232  return gen;
4233 
4234  return NULL;
4235 }

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

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

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

5275 {
5276  struct config_generic **result;
5277  dlist_iter iter;
5278 
5279  *num = 0;
5280 
5281  /*
5282  * While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
5283  * it doesn't seem worth dynamically resizing this array.
5284  */
5285  result = palloc(sizeof(struct config_generic *) * hash_get_num_entries(guc_hashtab));
5286 
5287  /* We need only consider GUCs with source not PGC_S_DEFAULT */
5289  {
5290  struct config_generic *conf = dlist_container(struct config_generic,
5291  nondef_link, iter.cur);
5292  bool modified;
5293 
5294  /* return only parameters marked for inclusion in explain */
5295  if (!(conf->flags & GUC_EXPLAIN))
5296  continue;
5297 
5298  /* return only options visible to the current user */
5299  if (!ConfigOptionIsVisible(conf))
5300  continue;
5301 
5302  /* return only options that are different from their boot values */
5303  modified = false;
5304 
5305  switch (conf->vartype)
5306  {
5307  case PGC_BOOL:
5308  {
5309  struct config_bool *lconf = (struct config_bool *) conf;
5310 
5311  modified = (lconf->boot_val != *(lconf->variable));
5312  }
5313  break;
5314 
5315  case PGC_INT:
5316  {
5317  struct config_int *lconf = (struct config_int *) conf;
5318 
5319  modified = (lconf->boot_val != *(lconf->variable));
5320  }
5321  break;
5322 
5323  case PGC_REAL:
5324  {
5325  struct config_real *lconf = (struct config_real *) conf;
5326 
5327  modified = (lconf->boot_val != *(lconf->variable));
5328  }
5329  break;
5330 
5331  case PGC_STRING:
5332  {
5333  struct config_string *lconf = (struct config_string *) conf;
5334 
5335  if (lconf->boot_val == NULL &&
5336  *lconf->variable == NULL)
5337  modified = false;
5338  else if (lconf->boot_val == NULL ||
5339  *lconf->variable == NULL)
5340  modified = true;
5341  else
5342  modified = (strcmp(lconf->boot_val, *(lconf->variable)) != 0);
5343  }
5344  break;
5345 
5346  case PGC_ENUM:
5347  {
5348  struct config_enum *lconf = (struct config_enum *) conf;
5349 
5350  modified = (lconf->boot_val != *(lconf->variable));
5351  }
5352  break;
5353 
5354  default:
5355  elog(ERROR, "unexpected GUC type: %d", conf->vartype);
5356  }
5357 
5358  if (!modified)
5359  continue;
5360 
5361  /* OK, report it */
5362  result[*num] = conf;
5363  *num = *num + 1;
5364  }
5365 
5366  return result;
5367 }
#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:1316

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

Referenced by ExplainPrintSettings().

◆ get_guc_variables()

struct config_generic** get_guc_variables ( int *  num_vars)

Definition at line 874 of file guc.c.

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

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

4299 {
4300  struct config_generic *record;
4301  static char buffer[256];
4302 
4303  record = find_option(name, false, missing_ok, ERROR);
4304  if (record == NULL)
4305  return NULL;
4306  if (restrict_privileged &&
4307  !ConfigOptionIsVisible(record))
4308  ereport(ERROR,
4309  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4310  errmsg("permission denied to examine \"%s\"", name),
4311  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4312  "pg_read_all_settings")));
4313 
4314  switch (record->vartype)
4315  {
4316  case PGC_BOOL:
4317  return *((struct config_bool *) record)->variable ? "on" : "off";
4318 
4319  case PGC_INT:
4320  snprintf(buffer, sizeof(buffer), "%d",
4321  *((struct config_int *) record)->variable);
4322  return buffer;
4323 
4324  case PGC_REAL:
4325  snprintf(buffer, sizeof(buffer), "%g",
4326  *((struct config_real *) record)->variable);
4327  return buffer;
4328 
4329  case PGC_STRING:
4330  return *((struct config_string *) record)->variable ?
4331  *((struct config_string *) record)->variable : "";
4332 
4333  case PGC_ENUM:
4334  return config_enum_lookup_by_value((struct config_enum *) record,
4335  *((struct config_enum *) record)->variable);
4336  }
4337  return NULL;
4338 }

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

5376 {
5377  struct config_generic *record;
5378 
5379  record = find_option(name, false, missing_ok, ERROR);
5380  if (record == NULL)
5381  {
5382  if (varname)
5383  *varname = NULL;
5384  return NULL;
5385  }
5386 
5387  if (!ConfigOptionIsVisible(record))
5388  ereport(ERROR,
5389  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
5390  errmsg("permission denied to examine \"%s\"", name),
5391  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
5392  "pg_read_all_settings")));
5393 
5394  if (varname)
5395  *varname = record->name;
5396 
5397  return ShowGUCOption(record, true);
5398 }
char * ShowGUCOption(struct config_generic *record, bool use_units)
Definition: guc.c:5408

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

4396 {
4397  struct config_generic *record;
4398 
4399  record = find_option(name, false, missing_ok, ERROR);
4400  if (record == NULL)
4401  return 0;
4402  return record->flags;
4403 }

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

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

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

692 {
693  /*
694  * Historically, GUC-related code has relied heavily on the ability to do
695  * free(NULL), so we allow that here even though pfree() doesn't.
696  */
697  if (ptr != NULL)
698  {
699  /* This is to help catch old code that malloc's GUC data. */
701  pfree(ptr);
702  }
703 }
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 1302 of file guc.c.

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

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

1333 {
1334  uint32 result = 0;
1335  const char *name = *(const char *const *) key;
1336 
1337  while (*name)
1338  {
1339  char ch = *name++;
1340 
1341  /* Case-fold in the same way as guc_name_compare */
1342  if (ch >= 'A' && ch <= 'Z')
1343  ch += 'a' - 'A';
1344 
1345  /* Merge into hash ... not very bright, but it needn't be */
1346  result = pg_rotate_left32(result, 5);
1347  result ^= (uint32) ch;
1348  }
1349  return result;
1350 }
unsigned int uint32
Definition: c.h:506
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 1356 of file guc.c.

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

References guc_name_compare().

Referenced by build_guc_variables().

◆ guc_realloc()

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

Definition at line 654 of file guc.c.

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

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

6121 {
6122  char **error_context_name_and_value = (char **) arg;
6123 
6124  if (error_context_name_and_value)
6125  errcontext("while setting parameter \"%s\" to \"%s\"",
6126  error_context_name_and_value[0],
6127  error_context_name_and_value[1]);
6128 }
#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 679 of file guc.c.

680 {
681  char *data;
682  size_t len = strlen(src) + 1;
683 
684  data = guc_malloc(elevel, len);
685  if (likely(data != NULL))
686  memcpy(data, src, len);
687  return data;
688 }
#define likely(x)
Definition: c.h:310
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 1290 of file guc.c.

1291 {
1292  const struct config_generic *confa = *(struct config_generic *const *) a;
1293  const struct config_generic *confb = *(struct config_generic *const *) b;
1294 
1295  return guc_name_compare(confa->name, confb->name);
1296 }
int b
Definition: isn.c:70
int a
Definition: isn.c:69

References a, b, guc_name_compare(), and config_generic::name.

Referenced by get_guc_variables().

◆ GUCArrayAdd()

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

Definition at line 6437 of file guc.c.

6438 {
6439  struct config_generic *record;
6440  Datum datum;
6441  char *newval;
6442  ArrayType *a;
6443 
6444  Assert(name);
6445  Assert(value);
6446 
6447  /* test if the option is valid and we're allowed to set it */
6448  (void) validate_option_array_item(name, value, false);
6449 
6450  /* normalize name (converts obsolete GUC names to modern spellings) */
6451  record = find_option(name, false, true, WARNING);
6452  if (record)
6453  name = record->name;
6454 
6455  /* build new item for array */
6456  newval = psprintf("%s=%s", name, value);
6457  datum = CStringGetTextDatum(newval);
6458 
6459  if (array)
6460  {
6461  int index;
6462  bool isnull;
6463  int i;
6464 
6465  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6466  Assert(ARR_NDIM(array) == 1);
6467  Assert(ARR_LBOUND(array)[0] == 1);
6468 
6469  index = ARR_DIMS(array)[0] + 1; /* add after end */
6470 
6471  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6472  {
6473  Datum d;
6474  char *current;
6475 
6476  d = array_ref(array, 1, &i,
6477  -1 /* varlenarray */ ,
6478  -1 /* TEXT's typlen */ ,
6479  false /* TEXT's typbyval */ ,
6480  TYPALIGN_INT /* TEXT's typalign */ ,
6481  &isnull);
6482  if (isnull)
6483  continue;
6484  current = TextDatumGetCString(d);
6485 
6486  /* check for match up through and including '=' */
6487  if (strncmp(current, newval, strlen(name) + 1) == 0)
6488  {
6489  index = i;
6490  break;
6491  }
6492  }
6493 
6494  a = array_set(array, 1, &index,
6495  datum,
6496  false,
6497  -1 /* varlena array */ ,
6498  -1 /* TEXT's typlen */ ,
6499  false /* TEXT's typbyval */ ,
6500  TYPALIGN_INT /* TEXT's typalign */ );
6501  }
6502  else
6503  a = construct_array_builtin(&datum, 1, TEXTOID);
6504 
6505  return a;
6506 }
#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:3374
ArrayType * array_set(ArrayType *array, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3156
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:3139
#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:6657
uintptr_t Datum
Definition: postgres.h:64
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
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 6515 of file guc.c.

6516 {
6517  struct config_generic *record;
6518  ArrayType *newarray;
6519  int i;
6520  int index;
6521 
6522  Assert(name);
6523 
6524  /* test if the option is valid and we're allowed to set it */
6525  (void) validate_option_array_item(name, NULL, false);
6526 
6527  /* normalize name (converts obsolete GUC names to modern spellings) */
6528  record = find_option(name, false, true, WARNING);
6529  if (record)
6530  name = record->name;
6531 
6532  /* if array is currently null, then surely nothing to delete */
6533  if (!array)
6534  return NULL;
6535 
6536  newarray = NULL;
6537  index = 1;
6538 
6539  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6540  {
6541  Datum d;
6542  char *val;
6543  bool isnull;
6544 
6545  d = array_ref(array, 1, &i,
6546  -1 /* varlenarray */ ,
6547  -1 /* TEXT's typlen */ ,
6548  false /* TEXT's typbyval */ ,
6549  TYPALIGN_INT /* TEXT's typalign */ ,
6550  &isnull);
6551  if (isnull)
6552  continue;
6553  val = TextDatumGetCString(d);
6554 
6555  /* ignore entry if it's what we want to delete */
6556  if (strncmp(val, name, strlen(name)) == 0
6557  && val[strlen(name)] == '=')
6558  continue;
6559 
6560  /* else add it to the output array */
6561  if (newarray)
6562  newarray = array_set(newarray, 1, &index,
6563  d,
6564  false,
6565  -1 /* varlenarray */ ,
6566  -1 /* TEXT's typlen */ ,
6567  false /* TEXT's typbyval */ ,
6568  TYPALIGN_INT /* TEXT's typalign */ );
6569  else
6570  newarray = construct_array_builtin(&d, 1, TEXTOID);
6571 
6572  index++;
6573  }
6574 
6575  return newarray;
6576 }

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

6586 {
6587  ArrayType *newarray;
6588  int i;
6589  int index;
6590 
6591  /* if array is currently null, nothing to do */
6592  if (!array)
6593  return NULL;
6594 
6595  /* if we're superuser, we can delete everything, so just do it */
6596  if (superuser())
6597  return NULL;
6598 
6599  newarray = NULL;
6600  index = 1;
6601 
6602  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6603  {
6604  Datum d;
6605  char *val;
6606  char *eqsgn;
6607  bool isnull;
6608 
6609  d = array_ref(array, 1, &i,
6610  -1 /* varlenarray */ ,
6611  -1 /* TEXT's typlen */ ,
6612  false /* TEXT's typbyval */ ,
6613  TYPALIGN_INT /* TEXT's typalign */ ,
6614  &isnull);
6615  if (isnull)
6616  continue;
6617  val = TextDatumGetCString(d);
6618 
6619  eqsgn = strchr(val, '=');
6620  *eqsgn = '\0';
6621 
6622  /* skip if we have permission to delete it */
6623  if (validate_option_array_item(val, NULL, true))
6624  continue;
6625 
6626  /* else add it to the output array */
6627  if (newarray)
6628  newarray = array_set(newarray, 1, &index,
6629  d,
6630  false,
6631  -1 /* varlenarray */ ,
6632  -1 /* TEXT's typlen */ ,
6633  false /* TEXT's typbyval */ ,
6634  TYPALIGN_INT /* TEXT's typalign */ );
6635  else
6636  newarray = construct_array_builtin(&d, 1, TEXTOID);
6637 
6638  index++;
6639  pfree(val);
6640  }
6641 
6642  return newarray;
6643 }

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

4821 {
4822  struct config_generic *gen;
4823 
4824  /*
4825  * Only allow custom PGC_POSTMASTER variables to be created during shared
4826  * library preload; any later than that, we can't ensure that the value
4827  * doesn't change after startup. This is a fatal elog if it happens; just
4828  * erroring out isn't safe because we don't know what the calling loadable
4829  * module might already have hooked into.
4830  */
4831  if (context == PGC_POSTMASTER &&
4833  elog(FATAL, "cannot create PGC_POSTMASTER variables after startup");
4834 
4835  /*
4836  * We can't support custom GUC_LIST_QUOTE variables, because the wrong
4837  * things would happen if such a variable were set or pg_dump'd when the
4838  * defining extension isn't loaded. Again, treat this as fatal because
4839  * the loadable module may be partly initialized already.
4840  */
4841  if (flags & GUC_LIST_QUOTE)
4842  elog(FATAL, "extensions cannot define GUC_LIST_QUOTE variables");
4843 
4844  /*
4845  * Before pljava commit 398f3b876ed402bdaec8bc804f29e2be95c75139
4846  * (2015-12-15), two of that module's PGC_USERSET variables facilitated
4847  * trivial escalation to superuser privileges. Restrict the variables to
4848  * protect sites that have yet to upgrade pljava.
4849  */
4850  if (context == PGC_USERSET &&
4851  (strcmp(name, "pljava.classpath") == 0 ||
4852  strcmp(name, "pljava.vmoptions") == 0))
4853  context = PGC_SUSET;
4854 
4855  gen = (struct config_generic *) guc_malloc(ERROR, sz);
4856  memset(gen, 0, sz);
4857 
4858  gen->name = guc_strdup(ERROR, name);
4859  gen->context = context;
4860  gen->group = CUSTOM_OPTIONS;
4861  gen->short_desc = short_desc;
4862  gen->long_desc = long_desc;
4863  gen->flags = flags;
4864  gen->vartype = type;
4865 
4866  return gen;
4867 }
#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:1778
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 1532 of file guc.c.

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

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

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

5223 {
5224  int classLen = strlen(className);
5225  HASH_SEQ_STATUS status;
5226  GUCHashEntry *hentry;
5227  MemoryContext oldcontext;
5228 
5229  /*
5230  * Check for existing placeholders. We must actually remove invalid
5231  * placeholders, else future parallel worker startups will fail. (We
5232  * don't bother trying to free associated memory, since this shouldn't
5233  * happen often.)
5234  */
5235  hash_seq_init(&status, guc_hashtab);
5236  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5237  {
5238  struct config_generic *var = hentry->gucvar;
5239 
5240  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5241  strncmp(className, var->name, classLen) == 0 &&
5242  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5243  {
5244  ereport(WARNING,
5245  (errcode(ERRCODE_INVALID_NAME),
5246  errmsg("invalid configuration parameter name \"%s\", removing it",
5247  var->name),
5248  errdetail("\"%s\" is now a reserved prefix.",
5249  className)));
5250  /* Remove it from the hash table */
5252  &var->name,
5253  HASH_REMOVE,
5254  NULL);
5255  /* Remove it from any lists it's in, too */
5256  RemoveGUCFromLists(var);
5257  }
5258  }
5259 
5260  /* And remember the name so we can prevent future mistakes. */
5263  MemoryContextSwitchTo(oldcontext);
5264 }
@ 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 *  name,
const char *  value,
GucSource  source,
int  elevel,
union config_var_val newval,
void **  newextra 
)
static

Definition at line 3132 of file guc.c.

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

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

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

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

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

6312 {
6313  size_t equal_pos;
6314  char *cp;
6315 
6316  Assert(string);
6317  Assert(name);
6318  Assert(value);
6319 
6320  equal_pos = strcspn(string, "=");
6321 
6322  if (string[equal_pos] == '=')
6323  {
6324  *name = palloc(equal_pos + 1);
6325  strlcpy(*name, string, equal_pos + 1);
6326 
6327  *value = pstrdup(&string[equal_pos + 1]);
6328  }
6329  else
6330  {
6331  /* no equal sign in string */
6332  *name = pstrdup(string);
6333  *value = NULL;
6334  }
6335 
6336  for (cp = *name; *cp; cp++)
6337  if (*cp == '-')
6338  *cp = '_';
6339 }
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 1994 of file guc.c.

1995 {
1996  SetConfigOption("timezone_abbreviations", "Default",
1998 }

References PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, and SetConfigOption().

Referenced by ProcessConfigFileInternal(), and SelectConfigFiles().

◆ ProcessConfigFileInternal()

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

Definition at line 284 of file guc.c.

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

6407 {
6408  List *gucNames;
6409  List *gucValues;
6410  ListCell *lc1;
6411  ListCell *lc2;
6412 
6413  TransformGUCArray(array, &gucNames, &gucValues);
6414  forboth(lc1, gucNames, lc2, gucValues)
6415  {
6416  char *name = lfirst(lc1);
6417  char *value = lfirst(lc2);
6418 
6419  (void) set_config_option(name, value,
6420  context, source,
6421  action, true, 0, false);
6422 
6423  pfree(name);
6424  pfree(value);
6425  }
6426 
6427  list_free(gucNames);
6428  list_free(gucValues);
6429 }
void TransformGUCArray(ArrayType *array, List **names, List **values)
Definition: guc.c:6348
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 2136 of file guc.c.

2137 {
2138  GucStack *stack;
2139 
2140  /* If we're not inside a nest level, do nothing */
2141  if (GUCNestLevel == 0)
2142  return;
2143 
2144  /* Do we already have a stack entry of the current nest level? */
2145  stack = gconf->stack;
2146  if (stack && stack->nest_level