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

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:3917
struct config_int ConfigureNamesInt[]
Definition: guc_tables.c:2028
struct config_bool ConfigureNamesBool[]
Definition: guc_tables.c:769
struct config_real ConfigureNamesReal[]
Definition: guc_tables.c:3636
struct config_enum ConfigureNamesEnum[]
Definition: guc_tables.c:4694
@ 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:137
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:153
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 6742 of file guc.c.

6744 {
6745  /* Quick success if no hook */
6746  if (!conf->check_hook)
6747  return true;
6748 
6749  /* Reset variables that might be set by hook */
6750  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6751  GUC_check_errmsg_string = NULL;
6753  GUC_check_errhint_string = NULL;
6754 
6755  if (!conf->check_hook(newval, extra, source))
6756  {
6757  ereport(elevel,
6761  errmsg("invalid value for parameter \"%s\": %d",
6762  conf->gen.name, (int) *newval),
6766  errhint("%s", GUC_check_errhint_string) : 0));
6767  /* Flush any strings created in ErrorContext */
6768  FlushErrorState();
6769  return false;
6770  }
6771 
6772  return true;
6773 }
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:1828
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 6894 of file guc.c.

6896 {
6897  /* Quick success if no hook */
6898  if (!conf->check_hook)
6899  return true;
6900 
6901  /* Reset variables that might be set by hook */
6902  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6903  GUC_check_errmsg_string = NULL;
6905  GUC_check_errhint_string = NULL;
6906 
6907  if (!conf->check_hook(newval, extra, source))
6908  {
6909  ereport(elevel,
6913  errmsg("invalid value for parameter \"%s\": \"%s\"",
6914  conf->gen.name,
6919  errhint("%s", GUC_check_errhint_string) : 0));
6920  /* Flush any strings created in ErrorContext */
6921  FlushErrorState();
6922  return false;
6923  }
6924 
6925  return true;
6926 }
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 6776 of file guc.c.

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

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

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

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

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:1683

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

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

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

5080 {
5081  struct config_bool *var;
5082 
5083  var = (struct config_bool *)
5084  init_custom_variable(name, short_desc, long_desc, context, flags,
5085  PGC_BOOL, sizeof(struct config_bool));
5086  var->variable = valueAddr;
5087  var->boot_val = bootValue;
5088  var->reset_val = bootValue;
5089  var->check_hook = check_hook;
5090  var->assign_hook = assign_hook;
5091  var->show_hook = show_hook;
5092  define_custom_variable(&var->gen);
5093 }
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:4809
static void define_custom_variable(struct config_generic *variable)
Definition: guc.c:4869
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, 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 5181 of file guc.c.

5192 {
5193  struct config_enum *var;
5194 
5195  var = (struct config_enum *)
5196  init_custom_variable(name, short_desc, long_desc, context, flags,
5197  PGC_ENUM, sizeof(struct config_enum));
5198  var->variable = valueAddr;
5199  var->boot_val = bootValue;
5200  var->reset_val = bootValue;
5201  var->options = options;
5202  var->check_hook = check_hook;
5203  var->assign_hook = assign_hook;
5204  var->show_hook = show_hook;
5205  define_custom_variable(&var->gen);
5206 }
static char ** options
GucShowHook show_hook
Definition: guc_tables.h:277

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

Referenced by _PG_init().

◆ DefineCustomIntVariable()

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

Definition at line 5096 of file guc.c.

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

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

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

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

5954 {
5955  if (valsize > *maxbytes)
5956  elog(ERROR, "not enough space to serialize GUC state");
5957 
5958  memcpy(*destptr, val, valsize);
5959  *destptr += valsize;
5960  *maxbytes -= valsize;
5961 }

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

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

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

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

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

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

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:695

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:493
static uint32 pg_rotate_left32(uint32 word, int n)
Definition: pg_bitutils.h:326

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:1569

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

6116 {
6117  char **error_context_name_and_value = (char **) arg;
6118 
6119  if (error_context_name_and_value)
6120  errcontext("while setting parameter \"%s\" to \"%s\"",
6121  error_context_name_and_value[0],
6122  error_context_name_and_value[1]);
6123 }
#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:297
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 6432 of file guc.c.

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

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

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

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

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

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

5218 {
5219  int classLen = strlen(className);
5220  HASH_SEQ_STATUS status;
5221  GUCHashEntry *hentry;
5222  MemoryContext oldcontext;
5223 
5224  /*
5225  * Check for existing placeholders. We must actually remove invalid
5226  * placeholders, else future parallel worker startups will fail. (We
5227  * don't bother trying to free associated memory, since this shouldn't
5228  * happen often.)
5229  */
5230  hash_seq_init(&status, guc_hashtab);
5231  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5232  {
5233  struct config_generic *var = hentry->gucvar;
5234 
5235  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5236  strncmp(className, var->name, classLen) == 0 &&
5237  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5238  {
5239  ereport(WARNING,
5240  (errcode(ERRCODE_INVALID_NAME),
5241  errmsg("invalid configuration parameter name \"%s\", removing it",
5242  var->name),
5243  errdetail("\"%s\" is now a reserved prefix.",
5244  className)));
5245  /* Remove it from the hash table */
5247  &var->name,
5248  HASH_REMOVE,
5249  NULL);
5250  /* Remove it from any lists it's in, too */
5251  RemoveGUCFromLists(var);
5252  }
5253  }
5254 
5255  /* And remember the name so we can prevent future mistakes. */
5258  MemoryContextSwitchTo(oldcontext);
5259 }
@ HASH_REMOVE
Definition: hsearch.h:115
List * lappend(List *list, void *datum)
Definition: list.c:339
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124

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:1183
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 6306 of file guc.c.

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

6402 {
6403  List *gucNames;
6404  List *gucValues;
6405  ListCell *lc1;
6406  ListCell *lc2;
6407 
6408  TransformGUCArray(array, &gucNames, &gucValues);
6409  forboth(lc1, gucNames, lc2, gucValues)
6410  {
6411  char *name = lfirst(lc1);
6412  char *value = lfirst(lc2);
6413 
6414  (void) set_config_option(name, value,
6415  context, source,
6416  action, true, 0, false);
6417 
6418  pfree(name);
6419  pfree(value);
6420  }
6421 
6422  list_free(gucNames);
6423  list_free(gucValues);
6424 }
void TransformGUCArray(ArrayType *array, List **names, List **values)
Definition: guc.c:6343
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, 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 >= GUCNestLevel)
2147  {
2148  /* Yes, so adjust its state if necessary */
2149  Assert(stack->nest_level == GUCNestLevel);
2150  switch (action)
2151  {
2152  case GUC_ACTION_SET:
2153  /* SET overrides any prior action at same nest level */
2154  if (stack->state == GUC_SET_LOCAL)
2155  {
2156  /* must discard old masked value */
2157  discard_stack_value(gconf, &stack->masked);
2158  }
2159  stack->state = GUC_SET;
2160  break;
2161  case GUC_ACTION_LOCAL:
2162  if (stack->state == GUC_SET)
2163  {
2164  /* SET followed by SET LOCAL, remember SET's value */
2165  stack->masked_scontext = gconf->scontext;
2166  stack->masked_srole = gconf->srole;
2167  set_stack_value(gconf, &stack->masked);
2168  stack->state = GUC_SET_LOCAL;
2169  }
2170  /* in all other cases, no change to stack entry */
2171  break;
2172  case GUC_ACTION_SAVE:
2173  /* Could only have a prior SAVE of same variable */
2174  Assert(stack->state == GUC_SAVE);
2175  break;
2176  }
2177  return;
2178  }
2179 
2180  /*
2181  * Push a new stack entry
2182  *
2183  * We keep all the stack entries in TopTransactionContext for simplicity.
2184  */
2186  sizeof(GucStack));
2187 
2188  stack->prev = gconf->stack;
2189  stack->nest_level = GUCNestLevel;
2190  switch (action)
2191  {
2192  case GUC_ACTION_SET:
2193  stack->state = GUC_SET;
2194  break;
2195  case GUC_ACTION_LOCAL:
2196  stack->state = GUC_LOCAL;
2197  break;
2198  case GUC_ACTION_SAVE:
2199  stack->state = GUC_SAVE;
2200  break;
2201  }
2202  stack->source = gconf->source;
2203  stack->scontext = gconf->scontext;
2204  stack->srole = gconf->srole;
2205  set_stack_value(gconf, &stack->prior);
2206 
2207  if (gconf->stack == NULL)
2209  gconf->stack = stack;
2210 }
static void set_stack_value(struct config_generic *gconf, config_var_value *val)
Definition: guc.c:814
@ GUC_ACTION_SAVE
Definition: guc.h:201
@ GUC_ACTION_LOCAL
Definition: guc.h:200
MemoryContext TopTransactionContext
Definition: mcxt.c:142
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1202

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

Referenced by ResetAllOptions(), and set_config_with_handle().

◆ read_gucstate()

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

Definition at line 6078 of file guc.c.

6079 {
6080  char *retptr = *srcptr;
6081  char *ptr;
6082 
6083  if (*srcptr >= srcend)
6084  elog(ERROR, "incomplete GUC state");
6085 
6086  /* The string variables are all null terminated */
6087  for (ptr = *srcptr; ptr < srcend && *ptr != '\0'; ptr++)
6088  ;
6089 
6090  if (ptr >= srcend)
6091  elog(ERROR, "could not find null terminator in GUC state");
6092 
6093  /* Set the new position to the byte following the terminating NUL */
6094  *srcptr = ptr + 1;
6095 
6096  return retptr;
6097 }

References elog, and ERROR.

Referenced by RestoreGUCState().

◆ read_gucstate_binary()

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

Definition at line 6101 of file guc.c.

6102 {
6103  if (*srcptr + size > srcend)
6104  elog(ERROR, "incomplete GUC state");
6105 
6106  memcpy(dest, *srcptr, size);
6107  *srcptr += size;
6108 }

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

Referenced by RestoreGUCState().

◆ reapply_stacked_values()

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

Definition at line 4978 of file guc.c.

4984 {
4985  const char *name = variable->name;
4986  GucStack *oldvarstack = variable->stack;
4987 
4988  if (stack != NULL)
4989  {
4990  /* First, recurse, so that stack items are processed bottom to top */
4991  reapply_stacked_values(variable, pHolder, stack->prev,
4992  stack->prior.val.stringval,
4993  stack->scontext, stack->source, stack->srole);
4994 
4995  /* See how to apply the passed-in value */
4996  switch (stack->state)
4997  {
4998  case GUC_SAVE:
4999  (void) set_config_option_ext(name, curvalue,
5000  curscontext, cursource, cursrole,
5001  GUC_ACTION_SAVE, true,
5002  WARNING, false);
5003  break;
5004 
5005  case GUC_SET:
5006  (void) set_config_option_ext(name, curvalue,
5007  curscontext, cursource, cursrole,
5008  GUC_ACTION_SET, true,
5009  WARNING, false);
5010  break;
5011 
5012  case GUC_LOCAL:
5013  (void) set_config_option_ext(name, curvalue,
5014  curscontext, cursource, cursrole,
5015  GUC_ACTION_LOCAL, true,
5016  WARNING, false);
5017  break;
5018 
5019  case GUC_SET_LOCAL:
5020  /* first, apply the masked value as SET */
5022  stack->masked_scontext,
5023  PGC_S_SESSION,
5024  stack->masked_srole,
5025  GUC_ACTION_SET, true,
5026  WARNING, false);
5027  /* then apply the current value as LOCAL */
5028  (void) set_config_option_ext(name, curvalue,
5029  curscontext, cursource, cursrole,
5030  GUC_ACTION_LOCAL, true,
5031  WARNING, false);
5032  break;
5033  }
5034 
5035  /* If we successfully made a stack entry, adjust its nest level */
5036  if (variable->stack != oldvarstack)
5037  variable->stack->nest_level = stack->nest_level;
5038  }
5039  else
5040  {
5041  /*
5042  * We are at the end of the stack. If the active/previous value is
5043  * different from the reset value, it must represent a previously
5044  * committed session value. Apply it, and then drop the stack entry
5045  * that set_config_option will have created under the impression that
5046  * this is to be just a transactional assignment. (We leak the stack
5047  * entry.)
5048  */
5049  if (curvalue != pHolder->reset_val ||
5050  curscontext != pHolder->gen.reset_scontext ||
5051  cursource != pHolder->gen.reset_source ||
5052  cursrole != pHolder->gen.reset_srole)
5053  {
5054  (void) set_config_option_ext(name, curvalue,
5055  curscontext, cursource, cursrole,
5056  GUC_ACTION_SET, true, WARNING, false);
5057  if (variable->stack != NULL)
5058  {
5059  slist_delete(&guc_stack_list, &variable->stack_link);
5060  variable->stack = NULL;
5061  }
5062  }
5063  }
5064 }
void slist_delete(slist_head *head, const slist_node *node)
Definition: ilist.c:31

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

Referenced by define_custom_variable().

◆ RemoveGUCFromLists()

static void RemoveGUCFromLists ( struct config_generic gconf)
static

◆ replace_auto_config_value()

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

Definition at line 4480 of file guc.c.

4482 {
4483  ConfigVariable *item,
4484  *next,
4485  *prev = NULL;
4486 
4487  /*
4488  * Remove any existing match(es) for "name". Normally there'd be at most
4489  * one, but if external tools have modified the config file, there could
4490  * be more.
4491  */
4492  for (item = *head_p; item != NULL; item = next)
4493  {
4494  next = item->next;
4495  if (guc_name_compare(item->name, name) == 0)
4496  {
4497  /* found a match, delete it */
4498  if (prev)
4499  prev->next = next;
4500  else
4501  *head_p = next;
4502  if (next == NULL)
4503  *tail_p = prev;
4504 
4505  pfree(item->name);
4506  pfree(item->value);
4507  pfree(item->filename);
4508  pfree(item);
4509  }
4510  else
4511  prev = item;
4512  }
4513 
4514  /* Done if we're trying to delete it */
4515  if (value == NULL)
4516  return;
4517 
4518  /* OK, append a new entry */
4519  item = palloc(sizeof *item);
4520  item->name = pstrdup(name);
4521  item->value = pstrdup(value);
4522  item->errmsg = NULL;
4523  item->filename = pstrdup(""); /* new item has no location */
4524  item->sourceline = 0;
4525  item->ignore = false;
4526  item->applied = false;
4527  item->next = NULL;
4528 
4529  if (*head_p == NULL)
4530  *head_p = item;
4531  else
4532  (*tail_p)->next = item;
4533  *tail_p = item;
4534 }
static int32 next
Definition: blutils.c:221

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

Referenced by AlterSystemSetConfigFile().

◆ ReportChangedGUCOptions()

void ReportChangedGUCOptions ( void  )

Definition at line 2598 of file guc.c.

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

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

Referenced by PostgresMain().

◆ ReportGUCOption()

static void ReportGUCOption ( struct config_generic record)
static

Definition at line 2636 of file guc.c.

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

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

Referenced by BeginReportingGUCOptions(), and ReportChangedGUCOptions().

◆ ResetAllOptions()

void ResetAllOptions ( void  )

Definition at line 2005 of file guc.c.

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

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

Referenced by DiscardAll(), and ExecSetVariableStmt().

◆ RestoreGUCState()

void RestoreGUCState ( void *  gucstate)

Definition at line 6137 of file guc.c.

6138 {
6139  char *varname,
6140  *varvalue,
6141  *varsourcefile;
6142  int varsourceline;
6143  GucSource varsource;
6144  GucContext varscontext;
6145  Oid varsrole;
6146  char *srcptr = (char *) gucstate;
6147  char *srcend;
6148  Size len;
6149  dlist_mutable_iter iter;
6150  ErrorContextCallback error_context_callback;
6151 
6152  /*
6153  * First, ensure that all potentially-shippable GUCs are reset to their
6154  * default values. We must not touch those GUCs that the leader will
6155  * never ship, while there is no need to touch those that are shippable
6156  * but already have their default values. Thus, this ends up being the
6157  * same test that SerializeGUCState uses, even though the sets of
6158  * variables involved may well be different since the leader's set of
6159  * variables-not-at-default-values can differ from the set that are
6160  * not-default in this freshly started worker.
6161  *
6162  * Once we have set all the potentially-shippable GUCs to default values,
6163  * restoring the GUCs that the leader sent (because they had non-default
6164  * values over there) leads us to exactly the set of GUC values that the
6165  * leader has. This is true even though the worker may have initially
6166  * absorbed postgresql.conf settings that the leader hasn't yet seen, or
6167  * ALTER USER/DATABASE SET settings that were established after the leader
6168  * started.
6169  *
6170  * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
6171  * also ensures that set_config_option won't refuse to set them because of
6172  * source-priority comparisons.
6173  */
6175  {
6176  struct config_generic *gconf = dlist_container(struct config_generic,
6177  nondef_link, iter.cur);
6178 
6179  /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
6180  if (can_skip_gucvar(gconf))
6181  continue;
6182 
6183  /*
6184  * We can use InitializeOneGUCOption to reset the GUC to default, but
6185  * first we must free any existing subsidiary data to avoid leaking
6186  * memory. The stack must be empty, but we have to clean up all other
6187  * fields. Beware that there might be duplicate value or "extra"
6188  * pointers. We also have to be sure to take it out of any lists it's
6189  * in.
6190  */
6191  Assert(gconf->stack == NULL);
6192  guc_free(gconf->extra);
6193  guc_free(gconf->last_reported);
6194  guc_free(gconf->sourcefile);
6195  switch (gconf->vartype)
6196  {
6197  case PGC_BOOL:
6198  {
6199  struct config_bool *conf = (struct config_bool *) gconf;
6200 
6201  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6202  guc_free(conf->reset_extra);
6203  break;
6204  }
6205  case PGC_INT:
6206  {
6207  struct config_int *conf = (struct config_int *) gconf;
6208 
6209  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6210  guc_free(conf->reset_extra);
6211  break;
6212  }
6213  case PGC_REAL:
6214  {
6215  struct config_real *conf = (struct config_real *) gconf;
6216 
6217  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6218  guc_free(conf->reset_extra);
6219  break;
6220  }
6221  case PGC_STRING:
6222  {
6223  struct config_string *conf = (struct config_string *) gconf;
6224 
6225  guc_free(*conf->variable);
6226  if (conf->reset_val && conf->reset_val != *conf->variable)
6227  guc_free(conf->reset_val);
6228  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6229  guc_free(conf->reset_extra);
6230  break;
6231  }
6232  case PGC_ENUM:
6233  {
6234  struct config_enum *conf = (struct config_enum *) gconf;
6235 
6236  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6237  guc_free(conf->reset_extra);
6238  break;
6239  }
6240  }
6241  /* Remove it from any lists it's in. */
6242  RemoveGUCFromLists(gconf);
6243  /* Now we can reset the struct to PGS_S_DEFAULT state. */
6244  InitializeOneGUCOption(gconf);
6245  }
6246 
6247  /* First item is the length of the subsequent data */
6248  memcpy(&len, gucstate, sizeof(len));
6249 
6250  srcptr += sizeof(len);
6251  srcend = srcptr + len;
6252 
6253  /* If the GUC value check fails, we want errors to show useful context. */
6254  error_context_callback.callback = guc_restore_error_context_callback;
6255  error_context_callback.previous = error_context_stack;
6256  error_context_callback.arg = NULL;
6257  error_context_stack = &error_context_callback;
6258 
6259  /* Restore all the listed GUCs. */
6260  while (srcptr < srcend)
6261  {
6262  int result;
6263  char *error_context_name_and_value[2];
6264 
6265  varname = read_gucstate(&srcptr, srcend);
6266  varvalue = read_gucstate(&srcptr, srcend);
6267  varsourcefile = read_gucstate(&srcptr, srcend);
6268  if (varsourcefile[0])
6269  read_gucstate_binary(&srcptr, srcend,
6270  &varsourceline, sizeof(varsourceline));
6271  else
6272  varsourceline = 0;
6273  read_gucstate_binary(&srcptr, srcend,
6274  &varsource, sizeof(varsource));
6275  read_gucstate_binary(&srcptr, srcend,
6276  &varscontext, sizeof(varscontext));
6277  read_gucstate_binary(&srcptr, srcend,
6278  &varsrole, sizeof(varsrole));
6279 
6280  error_context_name_and_value[0] = varname;
6281  error_context_name_and_value[1] = varvalue;
6282  error_context_callback.arg = &error_context_name_and_value[0];
6283  result = set_config_option_ext(varname, varvalue,
6284  varscontext, varsource, varsrole,
6285  GUC_ACTION_SET, true, ERROR, true);
6286  if (result <= 0)
6287  ereport(ERROR,
6288  (errcode(ERRCODE_INTERNAL_ERROR),
6289  errmsg("parameter \"%s\" could not be set", varname)));
6290  if (varsourcefile[0])
6291  set_config_sourcefile(varname, varsourcefile, varsourceline);
6292  error_context_callback.arg = NULL;
6293  }
6294 
6295  error_context_stack = error_context_callback.previous;
6296 }
ErrorContextCallback * error_context_stack
Definition: elog.c:94
static void guc_restore_error_context_callback(void *arg)
Definition: guc.c:6115
static char * read_gucstate(char **srcptr, char *srcend)
Definition: guc.c:6078
static void read_gucstate_binary(char **srcptr, char *srcend, void *dest, Size size)
Definition: guc.c:6101
struct ErrorContextCallback * previous
Definition: elog.h:295
void(* callback)(void *arg)
Definition: elog.h:296

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

Referenced by ParallelWorkerMain().

◆ RestrictSearchPath()

◆ SelectConfigFiles()

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

Definition at line 1786 of file guc.c.

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

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

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

◆ serialize_variable()

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

Definition at line 5968 of file guc.c.

5970 {
5971  /* Ignore skippable GUCs. */
5972  if (can_skip_gucvar(gconf))
5973  return;
5974 
5975  do_serialize(destptr, maxbytes, "%s", gconf->name);
5976 
5977  switch (gconf->vartype)
5978  {
5979  case PGC_BOOL:
5980  {
5981  struct config_bool *conf = (struct config_bool *) gconf;
5982 
5983  do_serialize(destptr, maxbytes,
5984  (*conf->variable ? "true" : "false"));
5985  }
5986  break;
5987 
5988  case PGC_INT:
5989  {
5990  struct config_int *conf = (struct config_int *) gconf;
5991 
5992  do_serialize(destptr, maxbytes, "%d", *conf->variable);
5993  }
5994  break;
5995 
5996  case PGC_REAL:
5997  {
5998  struct config_real *conf = (struct config_real *) gconf;
5999 
6000  do_serialize(destptr, maxbytes, "%.*e",
6001  REALTYPE_PRECISION, *conf->variable);
6002  }
6003  break;
6004 
6005  case PGC_STRING:
6006  {
6007  struct config_string *conf = (struct config_string *) gconf;
6008 
6009  /* NULL becomes empty string, see estimate_variable_size() */
6010  do_serialize(destptr, maxbytes, "%s",
6011  *conf->variable ? *conf->variable : "");
6012  }
6013  break;
6014 
6015  case PGC_ENUM:
6016  {
6017  struct config_enum *conf = (struct config_enum *) gconf;
6018 
6019  do_serialize(destptr, maxbytes, "%s",
6020  config_enum_lookup_by_value(conf, *conf->variable));
6021  }
6022  break;
6023  }
6024 
6025  do_serialize(destptr, maxbytes, "%s",
6026  (gconf->sourcefile ? gconf->sourcefile : ""));
6027 
6028  if (gconf->sourcefile && gconf->sourcefile[0])
6029  do_serialize_binary(destptr, maxbytes, &gconf->sourceline,
6030  sizeof(gconf->sourceline));
6031 
6032  do_serialize_binary(destptr, maxbytes, &gconf->source,
6033  sizeof(gconf->source));
6034  do_serialize_binary(destptr, maxbytes, &gconf->scontext,
6035  sizeof(gconf->scontext));
6036  do_serialize_binary(destptr, maxbytes, &gconf->srole,
6037  sizeof(gconf->srole));
6038 }
static void do_serialize(char **destptr, Size *maxbytes, const char *fmt,...) pg_attribute_printf(3
Definition: guc.c:5923
static void do_serialize_binary(char **destptr, Size *maxbytes, void *val, Size valsize)
Definition: guc.c:5953

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

Referenced by SerializeGUCState().

◆ SerializeGUCState()

void SerializeGUCState ( Size  maxsize,
char *  start_address 
)

Definition at line 6045 of file guc.c.

6046 {
6047  char *curptr;
6048  Size actual_size;
6049  Size bytes_left;
6050  dlist_iter iter;
6051 
6052  /* Reserve space for saving the actual size of the guc state */
6053  Assert(maxsize > sizeof(actual_size));
6054  curptr = start_address + sizeof(actual_size);
6055  bytes_left = maxsize - sizeof(actual_size);
6056 
6057  /* We need only consider GUCs with source not PGC_S_DEFAULT */
6059  {
6060  struct config_generic *gconf = dlist_container(struct config_generic,
6061  nondef_link, iter.cur);
6062 
6063  serialize_variable(&curptr, &bytes_left, gconf);
6064  }
6065 
6066  /* Store actual size without assuming alignment of start_address. */
6067  actual_size = maxsize - bytes_left - sizeof(actual_size);
6068  memcpy(start_address, &actual_size, sizeof(actual_size));
6069 }
static void serialize_variable(char **destptr, Size *maxbytes, struct config_generic *gconf)
Definition: guc.c:5968

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

Referenced by InitializeParallelDSM().

◆ set_config_option()

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

Definition at line 3333 of file guc.c.

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

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

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

◆ set_config_option_ext()

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

Definition at line 3373 of file guc.c.

3377 {
3378  return set_config_with_handle(name, NULL, value,
3379  context, source, srole,
3380  action, changeVal, elevel,
3381  is_reload);
3382 }

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

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

◆ set_config_sourcefile()

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

Definition at line 4242 of file guc.c.

4243 {
4244  struct config_generic *record;
4245  int elevel;
4246 
4247  /*
4248  * To avoid cluttering the log, only the postmaster bleats loudly about
4249  * problems with the config file.
4250  */
4251  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
4252 
4253  record = find_option(name, true, false, elevel);
4254  /* should not happen */
4255  if (record == NULL)
4256  return;
4257 
4258  sourcefile = guc_strdup(elevel, sourcefile);
4259  guc_free(record->sourcefile);
4260  record->sourcefile = sourcefile;
4261  record->sourceline = sourceline;
4262 }
#define DEBUG3
Definition: elog.h:28

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

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

◆ set_config_with_handle()

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

Definition at line 3393 of file guc.c.

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

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

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

◆ set_extra_field()

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

Definition at line 794 of file guc.c.

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

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

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

◆ set_guc_source()

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

Definition at line 2113 of file guc.c.

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

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

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

◆ set_stack_value()

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

Definition at line 814 of file guc.c.

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

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

Referenced by push_old_value().

◆ set_string_field()

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

Definition at line 733 of file guc.c.

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

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

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

◆ SetConfigOption()

◆ ShowGUCOption()

char* ShowGUCOption ( struct config_generic record,
bool  use_units 
)

Definition at line 5403 of file guc.c.

5404 {
5405  char buffer[256];
5406  const char *val;
5407 
5408  switch (record->vartype)
5409  {
5410  case PGC_BOOL:
5411  {
5412  struct config_bool *conf = (struct config_bool *) record;
5413 
5414  if (conf->show_hook)
5415  val = conf->show_hook();
5416  else
5417  val = *conf->variable ? "on" : "off";
5418  }
5419  break;
5420 
5421  case PGC_INT:
5422  {
5423  struct config_int *conf = (struct config_int *) record;
5424 
5425  if (conf->show_hook)
5426  val = conf->show_hook();
5427  else
5428  {
5429  /*
5430  * Use int64 arithmetic to avoid overflows in units
5431  * conversion.
5432  */
5433  int64 result = *conf->variable;
5434  const char *unit;
5435 
5436  if (use_units && result > 0 && (record->flags & GUC_UNIT))
5438  record->flags & GUC_UNIT,
5439  &result, &unit);
5440  else
5441  unit = "";
5442 
5443  snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
5444  result, unit);
5445  val = buffer;
5446  }
5447  }
5448  break;
5449 
5450  case PGC_REAL:
5451  {
5452  struct config_real *conf = (struct config_real *) record;
5453 
5454  if (conf->show_hook)
5455  val = conf->show_hook();
5456  else
5457  {
5458  double result = *conf->variable;
5459  const char *unit;
5460 
5461  if (use_units && result > 0 && (record->flags & GUC_UNIT))
5463  record->flags & GUC_UNIT,
5464  &result, &unit);
5465  else
5466  unit = "";
5467 
5468  snprintf(buffer, sizeof(buffer), "%g%s",
5469  result, unit);
5470  val = buffer;
5471  }
5472  }
5473  break;
5474 
5475  case PGC_STRING:
5476  {
5477  struct config_string *conf = (struct config_string *) record;
5478 
5479  if (conf->show_hook)
5480  val = conf->show_hook();
5481  else if (*conf->variable && **conf->variable)
5482  val = *conf->variable;
5483  else
5484  val = "";
5485  }
5486  break;
5487 
5488  case PGC_ENUM:
5489  {
5490  struct config_enum *conf = (struct config_enum *) record;
5491 
5492  if (conf->show_hook)
5493  val = conf->show_hook();
5494  else
5495  val = config_enum_lookup_by_value(conf, *conf->variable);
5496  }
5497  break;
5498 
5499  default:
5500  /* just to keep compiler quiet */
5501  val = "???";
5502  break;
5503  }
5504 
5505  return pstrdup(val);
5506 }
#define INT64_FORMAT
Definition: c.h:535
static void convert_int_from_base_unit(int64 base_value, int base_unit, int64 *value, const char **unit)
Definition: guc.c:2731
static void convert_real_from_base_unit(double base_value, int base_unit, double *value, const char **unit)
Definition: guc.c:2773

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

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

◆ string_field_used()

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

Definition at line 710 of file guc.c.

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

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

Referenced by set_config_with_handle(), and set_string_field().

◆ TransformGUCArray()

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

Definition at line 6343 of file guc.c.

6344 {
6345  int i;
6346 
6347  Assert(array != NULL);
6348  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6349  Assert(ARR_NDIM(array) == 1);
6350  Assert(ARR_LBOUND(array)[0] == 1);
6351 
6352  *names = NIL;
6353  *values = NIL;
6354  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6355  {
6356  Datum d;
6357  bool isnull;
6358  char *s;
6359  char *name;
6360  char *value;
6361 
6362  d = array_ref(array, 1, &i,
6363  -1 /* varlenarray */ ,
6364  -1 /* TEXT's typlen */ ,
6365  false /* TEXT's typbyval */ ,
6366  TYPALIGN_INT /* TEXT's typalign */ ,
6367  &isnull);
6368 
6369  if (isnull)
6370  continue;
6371 
6372  s = TextDatumGetCString(d);
6373 
6374  ParseLongOption(s, &name, &value);
6375  if (!value)
6376  {
6377  ereport(WARNING,
6378  (errcode(ERRCODE_SYNTAX_ERROR),
6379  errmsg("could not parse setting for parameter \"%s\"",
6380  name)));
6381  pfree(name);
6382  continue;
6383  }
6384 
6385  *names = lappend(*names, name);
6386  *values = lappend(*values, value);
6387 
6388  pfree(s);
6389  }
6390 }
static Datum values[MAXATTR]
Definition: bootstrap.c:152
void ParseLongOption(const char *string, char **name, char **value)
Definition: guc.c:6306
#define NIL
Definition: pg_list.h:68

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

Referenced by fmgr_security_definer(), and ProcessGUCArray().

◆ valid_custom_variable_name()

static bool valid_custom_variable_name ( const char *  name)
static

Definition at line 1078 of file guc.c.

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

References GUC_QUALIFIER_SEPARATOR, IS_HIGHBIT_SET, and name.

Referenced by assignable_custom_variable_name(), and ProcessConfigFileInternal().

◆ validate_option_array_item()

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

Definition at line 6652 of file guc.c.

6655 {
6656  struct config_generic *gconf;
6657 
6658  /*
6659  * There are three cases to consider:
6660  *
6661  * name is a known GUC variable. Check the value normally, check
6662  * permissions normally (i.e., allow if variable is USERSET, or if it's
6663  * SUSET and user is superuser or holds ACL_SET permissions).
6664  *
6665  * name is not known, but exists or can be created as a placeholder (i.e.,
6666  * it has a valid custom name). We allow this case if you're a superuser,
6667  * otherwise not. Superusers are assumed to know what they're doing. We
6668  * can't allow it for other users, because when the placeholder is
6669  * resolved it might turn out to be a SUSET variable. (With currently
6670  * available infrastructure, we can actually handle such cases within the
6671  * current session --- but once an entry is made in pg_db_role_setting,
6672  * it's assumed to be fully validated.)
6673  *
6674  * name is not known and can't be created as a placeholder. Throw error,
6675  * unless skipIfNoPermissions is true, in which case return false.
6676  */
6677  gconf = find_option(name, true, skipIfNoPermissions, ERROR);
6678  if (!gconf)
6679  {
6680  /* not known, failed to make a placeholder */
6681  return false;
6682  }
6683 
6684  if (gconf->flags & GUC_CUSTOM_PLACEHOLDER)
6685  {
6686  /*
6687  * We cannot do any meaningful check on the value, so only permissions
6688  * are useful to check.
6689  */
6690  if (superuser() ||
6692  return true;
6693  if (skipIfNoPermissions)
6694  return false;
6695  ereport(ERROR,
6696  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
6697  errmsg("permission denied to set parameter \"%s\"", name)));
6698  }
6699 
6700  /* manual permissions check so we can avoid an error being thrown */
6701  if (gconf->context == PGC_USERSET)
6702  /* ok */ ;
6703  else if (gconf->context == PGC_SUSET &&
6704  (superuser() ||
6706  /* ok */ ;
6707  else if (skipIfNoPermissions)
6708  return false;
6709  /* if a permissions error should be thrown, let set_config_option do it */
6710 
6711  /* test for permissions and valid option value */
6712  (void) set_config_option(name, value,
6714  PGC_S_TEST, GUC_ACTION_SET, false, 0, false);
6715 
6716  return true;
6717 }
@ PGC_S_TEST
Definition: guc.h:121

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

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

◆ write_auto_conf_file()

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

Definition at line 4412 of file guc.c.

4413 {
4415  ConfigVariable *item;
4416 
4417  initStringInfo(&buf);
4418 
4419  /* Emit file header containing warning comment */
4420  appendStringInfoString(&buf, "# Do not edit this file manually!\n");
4421  appendStringInfoString(&buf, "# It will be overwritten by the ALTER SYSTEM command.\n");
4422 
4423  errno = 0;
4424  if (write(fd, buf.data, buf.len) != buf.len)
4425  {
4426  /* if write didn't set errno, assume problem is no disk space */
4427  if (errno == 0)
4428  errno = ENOSPC;
4429  ereport(ERROR,
4431  errmsg("could not write to file \"%s\": %m", filename)));
4432  }
4433 
4434  /* Emit each parameter, properly quoting the value */
4435  for (item = head; item != NULL; item = item->next)
4436  {
4437  char *escaped;
4438 
4439  resetStringInfo(&buf);
4440 
4441  appendStringInfoString(&buf, item->name);
4442  appendStringInfoString(&buf, " = '");
4443 
4444  escaped = escape_single_quotes_ascii(item->value);
4445  if (!escaped)
4446  ereport(ERROR,
4447  (errcode(ERRCODE_OUT_OF_MEMORY),
4448  errmsg("out of memory")));
4449  appendStringInfoString(&buf, escaped);
4450  free(escaped);
4451 
4452  appendStringInfoString(&buf, "'\n");
4453 
4454  errno = 0;
4455  if (write(fd, buf.data, buf.len) != buf.len)
4456  {
4457  /* if write didn't set errno, assume problem is no disk space */
4458  if (errno == 0)
4459  errno = ENOSPC;
4460  ereport(ERROR,
4462  errmsg("could not write to file \"%s\": %m", filename)));
4463  }
4464  }
4465 
4466  /* fsync before considering the write to be successful */
4467  if (pg_fsync(fd) != 0)
4468  ereport(ERROR,
4470  errmsg("could not fsync file \"%s\": %m", filename)));
4471 
4472  pfree(buf.data);
4473 }
int pg_fsync(int fd)
Definition: fd.c:386
#define write(a, b, c)
Definition: win32.h:14
static char * filename
Definition: pg_dumpall.c:121
static char * buf
Definition: pg_test_fsync.c:73
char * escape_single_quotes_ascii(const char *src)
Definition: quotes.c:33
static int fd(const char *x, int i)
Definition: preproc-init.c:105
void resetStringInfo(StringInfo str)
Definition: stringinfo.c:78

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

Referenced by AlterSystemSetConfigFile().

Variable Documentation

◆ GUC_check_errcode_value

int GUC_check_errcode_value
static

◆ GUC_check_errdetail_string

char* GUC_check_errdetail_string

◆ GUC_check_errhint_string

char* GUC_check_errhint_string

◆ GUC_check_errmsg_string

char* GUC_check_errmsg_string

◆ guc_hashtab

◆ guc_nondef_list

◆ guc_report_list

slist_head guc_report_list
static

◆ guc_stack_list

slist_head guc_stack_list
static

Definition at line 226 of file guc.c.

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

◆ GUCMemoryContext

MemoryContext GUCMemoryContext
static

Definition at line 201 of file guc.c.

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

◆ GUCNestLevel

int GUCNestLevel = 0
static

Definition at line 233 of file guc.c.

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

◆ in_hot_standby_guc

bool in_hot_standby_guc
extern

Definition at line 621 of file guc_tables.c.

Referenced by ReportChangedGUCOptions().

◆ map_old_guc_names

const char* const map_old_guc_names[]
static
Initial value:
= {
"sort_mem", "work_mem",
"vacuum_mem", "maintenance_work_mem",
NULL
}

Definition at line 193 of file guc.c.

Referenced by convert_GUC_name_for_parameter_acl(), and find_option().

◆ memory_unit_conversion_table

const unit_conversion memory_unit_conversion_table[]
static

◆ memory_units_hint

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

Definition at line 122 of file guc.c.

Referenced by parse_int(), and parse_real().

◆ reporting_enabled

bool reporting_enabled
static

Definition at line 231 of file guc.c.

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

◆ reserved_class_prefix

List* reserved_class_prefix = NIL
static

Definition at line 78 of file guc.c.

Referenced by assignable_custom_variable_name(), and MarkGUCPrefixReserved().

◆ time_unit_conversion_table

const unit_conversion time_unit_conversion_table[]
static
Initial value:
=
{
{"d", GUC_UNIT_MS, 1000 * 60 * 60 * 24},
{"h", GUC_UNIT_MS, 1000 * 60 * 60},
{"min", GUC_UNIT_MS, 1000 * 60},
{"s", GUC_UNIT_MS, 1000},
{"ms", GUC_UNIT_MS, 1},
{"us", GUC_UNIT_MS, 1.0 / 1000},
{"d", GUC_UNIT_S, 60 * 60 * 24},
{"h", GUC_UNIT_S, 60 * 60},
{"min", GUC_UNIT_S, 60},
{"s", GUC_UNIT_S, 1},
{"ms", GUC_UNIT_S, 1.0 / 1000},
{"us", GUC_UNIT_S, 1.0 / (1000 * 1000)},
{"d", GUC_UNIT_MIN, 60 * 24},
{"h", GUC_UNIT_MIN, 60},
{"min", GUC_UNIT_MIN, 1},
{"s", GUC_UNIT_MIN, 1.0 / 60},
{"ms", GUC_UNIT_MIN, 1.0 / (1000 * 60)},
{"us", GUC_UNIT_MIN, 1.0 / (1000 * 1000 * 60)},
{""}
}

Definition at line 161 of file guc.c.

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

◆ time_units_hint

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

Definition at line 159 of file guc.c.

Referenced by parse_int(), and parse_real().