PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
guc.c File Reference
#include "postgres.h"
#include <ctype.h>
#include <float.h>
#include <math.h>
#include <limits.h>
#include <unistd.h>
#include <sys/stat.h>
#include "access/commit_ts.h"
#include "access/gin.h"
#include "access/rmgr.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xlog_internal.h"
#include "catalog/namespace.h"
#include "catalog/pg_authid.h"
#include "commands/async.h"
#include "commands/prepare.h"
#include "commands/user.h"
#include "commands/vacuum.h"
#include "commands/variable.h"
#include "commands/trigger.h"
#include "funcapi.h"
#include "libpq/auth.h"
#include "libpq/be-fsstubs.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "optimizer/cost.h"
#include "optimizer/geqo.h"
#include "optimizer/paths.h"
#include "optimizer/planmain.h"
#include "parser/parse_expr.h"
#include "parser/parse_type.h"
#include "parser/parser.h"
#include "parser/scansup.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "postmaster/bgworker_internals.h"
#include "postmaster/bgwriter.h"
#include "postmaster/postmaster.h"
#include "postmaster/syslogger.h"
#include "postmaster/walwriter.h"
#include "replication/logicallauncher.h"
#include "replication/slot.h"
#include "replication/syncrep.h"
#include "replication/walreceiver.h"
#include "replication/walsender.h"
#include "storage/bufmgr.h"
#include "storage/dsm_impl.h"
#include "storage/standby.h"
#include "storage/fd.h"
#include "storage/pg_shmem.h"
#include "storage/proc.h"
#include "storage/predicate.h"
#include "tcop/tcopprot.h"
#include "tsearch/ts_cache.h"
#include "utils/builtins.h"
#include "utils/bytea.h"
#include "utils/guc_tables.h"
#include "utils/memutils.h"
#include "utils/pg_locale.h"
#include "utils/plancache.h"
#include "utils/portal.h"
#include "utils/ps_status.h"
#include "utils/rls.h"
#include "utils/snapmgr.h"
#include "utils/tzparser.h"
#include "utils/varlena.h"
#include "utils/xml.h"
#include "guc-file.c"
Include dependency graph for guc.c:

Go to the source code of this file.

Data Structures

struct  unit_conversion
 

Macros

#define PG_KRB_SRVTAB   ""
 
#define CONFIG_FILENAME   "postgresql.conf"
 
#define HBA_FILENAME   "pg_hba.conf"
 
#define IDENT_FILENAME   "pg_ident.conf"
 
#define REALTYPE_PRECISION   17
 
#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)
 
#define NUM_PG_SETTINGS_ATTS   17
 
#define NUM_PG_FILE_SETTINGS_ATTS   7
 

Functions

static void do_serialize (char **destptr, Size *maxbytes, const char *fmt,...) pg_attribute_printf(3
 
static void static void set_config_sourcefile (const char *name, char *sourcefile, int sourceline)
 
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)
 
static bool check_log_destination (char **newval, void **extra, GucSource source)
 
static void assign_log_destination (const char *newval, void *extra)
 
static bool check_wal_consistency_checking (char **newval, void **extra, GucSource source)
 
static void assign_wal_consistency_checking (const char *newval, void *extra)
 
static void assign_syslog_facility (int newval, void *extra)
 
static void assign_syslog_ident (const char *newval, void *extra)
 
static void assign_session_replication_role (int newval, void *extra)
 
static bool check_temp_buffers (int *newval, void **extra, GucSource source)
 
static bool check_bonjour (bool *newval, void **extra, GucSource source)
 
static bool check_ssl (bool *newval, void **extra, GucSource source)
 
static bool check_stage_log_stats (bool *newval, void **extra, GucSource source)
 
static bool check_log_stats (bool *newval, void **extra, GucSource source)
 
static bool check_canonical_path (char **newval, void **extra, GucSource source)
 
static bool check_timezone_abbreviations (char **newval, void **extra, GucSource source)
 
static void assign_timezone_abbreviations (const char *newval, void *extra)
 
static void pg_timezone_abbrev_initialize (void)
 
static const char * show_archive_command (void)
 
static void assign_tcp_keepalives_idle (int newval, void *extra)
 
static void assign_tcp_keepalives_interval (int newval, void *extra)
 
static void assign_tcp_keepalives_count (int newval, void *extra)
 
static const char * show_tcp_keepalives_idle (void)
 
static const char * show_tcp_keepalives_interval (void)
 
static const char * show_tcp_keepalives_count (void)
 
static bool check_maxconnections (int *newval, void **extra, GucSource source)
 
static bool check_max_worker_processes (int *newval, void **extra, GucSource source)
 
static bool check_autovacuum_max_workers (int *newval, void **extra, GucSource source)
 
static bool check_autovacuum_work_mem (int *newval, void **extra, GucSource source)
 
static bool check_effective_io_concurrency (int *newval, void **extra, GucSource source)
 
static void assign_effective_io_concurrency (int newval, void *extra)
 
static void assign_pgstat_temp_directory (const char *newval, void *extra)
 
static bool check_application_name (char **newval, void **extra, GucSource source)
 
static void assign_application_name (const char *newval, void *extra)
 
static bool check_cluster_name (char **newval, void **extra, GucSource source)
 
static const char * show_unix_socket_permissions (void)
 
static const char * show_log_file_mode (void)
 
static ConfigVariableProcessConfigFileInternal (GucContext context, bool applySettings, int elevel)
 
static int guc_var_compare (const void *a, const void *b)
 
static int guc_name_compare (const char *namea, const char *nameb)
 
static void InitializeGUCOptionsFromEnvironment (void)
 
static void InitializeOneGUCOption (struct config_generic *gconf)
 
static void push_old_value (struct config_generic *gconf, GucAction action)
 
static void ReportGUCOption (struct config_generic *record)
 
static void reapply_stacked_values (struct config_generic *variable, struct config_string *pHolder, GucStack *stack, const char *curvalue, GucContext curscontext, GucSource cursource)
 
static void ShowGUCConfigOption (const char *name, DestReceiver *dest)
 
static void ShowAllGUCConfig (DestReceiver *dest)
 
static char * _ShowOption (struct config_generic *record, bool use_units)
 
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_p)
 
static void replace_auto_config_value (ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
 
static void * guc_malloc (int elevel, size_t size)
 
static void * guc_realloc (int elevel, void *old, size_t size)
 
static char * guc_strdup (int elevel, const char *src)
 
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 (void)
 
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)
 
static struct config_genericfind_option (const char *name, bool create_placeholders, int elevel)
 
void InitializeGUCOptions (void)
 
bool SelectConfigFiles (const char *userDoption, const char *progname)
 
void ResetAllOptions (void)
 
void AtStart_GUC (void)
 
int NewGUCNestLevel (void)
 
void AtEOXact_GUC (bool isCommit, int nestLevel)
 
void BeginReportingGUCOptions (void)
 
static bool convert_to_base_unit (int64 value, const char *unit, int base_unit, int64 *base_value)
 
static void convert_from_base_unit (int64 base_value, int base_unit, int64 *value, const char **unit)
 
bool parse_int (const char *value, int *result, int flags, const char **hintmsg)
 
bool parse_real (const char *value, double *result)
 
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)
 
static 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)
 
void SetConfigOption (const char *name, const char *value, GucContext context, GucSource source)
 
const char * GetConfigOption (const char *name, bool missing_ok, bool restrict_superuser)
 
const char * GetConfigOptionResetString (const char *name)
 
static char * flatten_set_variable_args (const char *name, List *args)
 
void AlterSystemSetConfigFile (AlterSystemStmt *altersysstmt)
 
void ExecSetVariableStmt (VariableSetStmt *stmt, bool isTopLevel)
 
char * ExtractSetVariableArgs (VariableSetStmt *stmt)
 
void SetPGVariable (const char *name, List *args, bool is_local)
 
Datum set_config_by_name (PG_FUNCTION_ARGS)
 
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 EmitWarningsOnPlaceholders (const char *className)
 
void GetPGVariable (const char *name, DestReceiver *dest)
 
TupleDesc GetPGVariableResultDesc (const char *name)
 
char * GetConfigOptionByName (const char *name, const char **varname, bool missing_ok)
 
void GetConfigOptionByNum (int varnum, const char **values, bool *noshow)
 
int GetNumConfigOptions (void)
 
Datum show_config_by_name (PG_FUNCTION_ARGS)
 
Datum show_config_by_name_missing_ok (PG_FUNCTION_ARGS)
 
Datum show_all_settings (PG_FUNCTION_ARGS)
 
Datum show_all_file_settings (PG_FUNCTION_ARGS)
 
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)
 
void RestoreGUCState (void *gucstate)
 
void ParseLongOption (const char *string, char **name, char **value)
 
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

bool Log_disconnections
 
int CommitDelay
 
int CommitSiblings
 
char * default_tablespace
 
char * temp_tablespaces
 
bool ignore_checksum_failure
 
bool synchronize_seqscans
 
static int GUC_check_errcode_value
 
char * GUC_check_errmsg_string
 
char * GUC_check_errdetail_string
 
char * GUC_check_errhint_string
 
static int syslog_facility = 0
 
static const struct
config_enum_entry 
bytea_output_options []
 
static const struct
config_enum_entry 
client_message_level_options []
 
static const struct
config_enum_entry 
server_message_level_options []
 
static const struct
config_enum_entry 
intervalstyle_options []
 
static const struct
config_enum_entry 
log_error_verbosity_options []
 
static const struct
config_enum_entry 
log_statement_options []
 
static const struct
config_enum_entry 
isolation_level_options []
 
static const struct
config_enum_entry 
session_replication_role_options []
 
static const struct
config_enum_entry 
syslog_facility_options []
 
static const struct
config_enum_entry 
track_function_options []
 
static const struct
config_enum_entry 
xmlbinary_options []
 
static const struct
config_enum_entry 
xmloption_options []
 
static const struct
config_enum_entry 
backslash_quote_options []
 
static const struct
config_enum_entry 
constraint_exclusion_options []
 
static const struct
config_enum_entry 
synchronous_commit_options []
 
static const struct
config_enum_entry 
huge_pages_options []
 
static const struct
config_enum_entry 
force_parallel_mode_options []
 
static const struct
config_enum_entry 
password_encryption_options []
 
const struct config_enum_entry wal_level_options []
 
const struct config_enum_entry archive_mode_options []
 
const struct config_enum_entry sync_method_options []
 
const struct config_enum_entry dynamic_shared_memory_options []
 
bool log_duration = false
 
bool Debug_print_plan = false
 
bool Debug_print_parse = false
 
bool Debug_print_rewritten = false
 
bool Debug_pretty_print = true
 
bool log_parser_stats = false
 
bool log_planner_stats = false
 
bool log_executor_stats = false
 
bool log_statement_stats = false
 
bool log_btree_build_stats = false
 
char * event_source
 
bool row_security
 
bool check_function_bodies = true
 
bool default_with_oids = false
 
int log_min_error_statement = ERROR
 
int log_min_messages = WARNING
 
int client_min_messages = NOTICE
 
int log_min_duration_statement = -1
 
int log_temp_files = -1
 
int trace_recovery_messages = LOG
 
int temp_file_limit = -1
 
int num_temp_buffers = 1024
 
char * cluster_name = ""
 
char * ConfigFileName
 
char * HbaFileName
 
char * IdentFileName
 
char * external_pid_file
 
char * pgstat_temp_directory
 
char * application_name
 
int tcp_keepalives_idle
 
int tcp_keepalives_interval
 
int tcp_keepalives_count
 
int ssl_renegotiation_limit
 
int huge_pages
 
static char * syslog_ident_str
 
static bool session_auth_is_superuser
 
static double phony_random_seed
 
static char * client_encoding_string
 
static char * datestyle_string
 
static char * locale_collate
 
static char * locale_ctype
 
static char * server_encoding_string
 
static char * server_version_string
 
static int server_version_num
 
static char * timezone_string
 
static char * log_timezone_string
 
static char * timezone_abbreviations_string
 
static char * XactIsoLevel_string
 
static char * data_directory
 
static char * session_authorization_string
 
static int max_function_args
 
static int max_index_keys
 
static int max_identifier_length
 
static int block_size
 
static int segment_size
 
static int wal_block_size
 
static bool data_checksums
 
static bool integer_datetimes
 
static bool assert_enabled
 
char * role_string
 
const char *const GucContext_Names []
 
const char *const GucSource_Names []
 
const char *const config_group_names []
 
const char *const config_type_names []
 
static const char * memory_units_hint = gettext_noop("Valid units for this parameter are \"kB\", \"MB\", \"GB\", and \"TB\".")
 
static const unit_conversion memory_unit_conversion_table []
 
static const char * time_units_hint = gettext_noop("Valid units for this parameter are \"ms\", \"s\", \"min\", \"h\", and \"d\".")
 
static const unit_conversion time_unit_conversion_table []
 
static struct config_bool ConfigureNamesBool []
 
static struct config_int ConfigureNamesInt []
 
static struct config_real ConfigureNamesReal []
 
static struct config_string ConfigureNamesString []
 
static struct config_enum ConfigureNamesEnum []
 
static const char *const map_old_guc_names []
 
static struct config_generic ** guc_variables
 
static int num_guc_variables
 
static int size_guc_variables
 
static bool guc_dirty
 
static bool reporting_enabled
 
static int GUCNestLevel = 0
 

Macro Definition Documentation

#define CONFIG_FILENAME   "postgresql.conf"

Definition at line 97 of file guc.c.

Referenced by SelectConfigFiles().

#define HBA_FILENAME   "pg_hba.conf"

Definition at line 98 of file guc.c.

Referenced by SelectConfigFiles().

#define IDENT_FILENAME   "pg_ident.conf"

Definition at line 99 of file guc.c.

Referenced by SelectConfigFiles().

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

Definition at line 697 of file guc.c.

Referenced by parse_int().

#define newval   (newval_union.intval)
#define newval   (newval_union.realval)
#define newval   (newval_union.stringval)
#define newval   (newval_union.enumval)
#define NUM_PG_FILE_SETTINGS_ATTS   7

Referenced by show_all_file_settings().

#define NUM_PG_SETTINGS_ATTS   17

Definition at line 8397 of file guc.c.

Referenced by show_all_settings().

#define PG_KRB_SRVTAB   ""

Definition at line 94 of file guc.c.

#define REALTYPE_PRECISION   17

Definition at line 110 of file guc.c.

Referenced by estimate_variable_size(), and serialize_variable().

Function Documentation

static char * _ShowOption ( struct config_generic record,
bool  use_units 
)
static

Definition at line 8644 of file guc.c.

References buffer, config_enum_lookup_by_value(), convert_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(), GetConfigOptionByNum(), ReportGUCOption(), and ShowAllGUCConfig().

8645 {
8646  char buffer[256];
8647  const char *val;
8648 
8649  switch (record->vartype)
8650  {
8651  case PGC_BOOL:
8652  {
8653  struct config_bool *conf = (struct config_bool *) record;
8654 
8655  if (conf->show_hook)
8656  val = conf->show_hook();
8657  else
8658  val = *conf->variable ? "on" : "off";
8659  }
8660  break;
8661 
8662  case PGC_INT:
8663  {
8664  struct config_int *conf = (struct config_int *) record;
8665 
8666  if (conf->show_hook)
8667  val = conf->show_hook();
8668  else
8669  {
8670  /*
8671  * Use int64 arithmetic to avoid overflows in units
8672  * conversion.
8673  */
8674  int64 result = *conf->variable;
8675  const char *unit;
8676 
8677  if (use_units && result > 0 && (record->flags & GUC_UNIT))
8678  {
8679  convert_from_base_unit(result, record->flags & GUC_UNIT,
8680  &result, &unit);
8681  }
8682  else
8683  unit = "";
8684 
8685  snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
8686  result, unit);
8687  val = buffer;
8688  }
8689  }
8690  break;
8691 
8692  case PGC_REAL:
8693  {
8694  struct config_real *conf = (struct config_real *) record;
8695 
8696  if (conf->show_hook)
8697  val = conf->show_hook();
8698  else
8699  {
8700  snprintf(buffer, sizeof(buffer), "%g",
8701  *conf->variable);
8702  val = buffer;
8703  }
8704  }
8705  break;
8706 
8707  case PGC_STRING:
8708  {
8709  struct config_string *conf = (struct config_string *) record;
8710 
8711  if (conf->show_hook)
8712  val = conf->show_hook();
8713  else if (*conf->variable && **conf->variable)
8714  val = *conf->variable;
8715  else
8716  val = "";
8717  }
8718  break;
8719 
8720  case PGC_ENUM:
8721  {
8722  struct config_enum *conf = (struct config_enum *) record;
8723 
8724  if (conf->show_hook)
8725  val = conf->show_hook();
8726  else
8727  val = config_enum_lookup_by_value(conf, *conf->variable);
8728  }
8729  break;
8730 
8731  default:
8732  /* just to keep compiler quiet */
8733  val = "???";
8734  break;
8735  }
8736 
8737  return pstrdup(val);
8738 }
char ** variable
Definition: guc_tables.h:227
char * pstrdup(const char *in)
Definition: mcxt.c:1076
bool * variable
Definition: guc_tables.h:181
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:5626
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
#define GUC_UNIT
Definition: guc.h:230
GucShowHook show_hook
Definition: guc_tables.h:201
int * variable
Definition: guc_tables.h:195
int * variable
Definition: guc_tables.h:241
GucShowHook show_hook
Definition: guc_tables.h:231
GucShowHook show_hook
Definition: guc_tables.h:217
double * variable
Definition: guc_tables.h:211
enum config_type vartype
Definition: guc_tables.h:153
GucShowHook show_hook
Definition: guc_tables.h:246
GucShowHook show_hook
Definition: guc_tables.h:185
WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE]
Definition: walsender.c:214
#define INT64_FORMAT
Definition: c.h:300
static void convert_from_base_unit(int64 base_value, int base_unit, int64 *value, const char **unit)
Definition: guc.c:5454
long val
Definition: informix.c:689
static bool add_guc_variable ( struct config_generic var,
int  elevel 
)
static

Definition at line 4295 of file guc.c.

References guc_malloc(), guc_realloc(), guc_var_compare(), and qsort.

Referenced by add_placeholder_variable(), and define_custom_variable().

4296 {
4298  {
4299  /*
4300  * Increase the vector by 25%
4301  */
4302  int size_vars = size_guc_variables + size_guc_variables / 4;
4303  struct config_generic **guc_vars;
4304 
4305  if (size_vars == 0)
4306  {
4307  size_vars = 100;
4308  guc_vars = (struct config_generic **)
4309  guc_malloc(elevel, size_vars * sizeof(struct config_generic *));
4310  }
4311  else
4312  {
4313  guc_vars = (struct config_generic **)
4314  guc_realloc(elevel, guc_variables, size_vars * sizeof(struct config_generic *));
4315  }
4316 
4317  if (guc_vars == NULL)
4318  return false; /* out of memory */
4319 
4320  guc_variables = guc_vars;
4321  size_guc_variables = size_vars;
4322  }
4325  sizeof(struct config_generic *), guc_var_compare);
4326  return true;
4327 }
static int guc_var_compare(const void *a, const void *b)
Definition: guc.c:4430
static int num_guc_variables
Definition: guc.c:3947
static void * guc_realloc(int elevel, void *old, size_t size)
Definition: guc.c:4001
static struct config_generic ** guc_variables
Definition: guc.c:3944
static int size_guc_variables
Definition: guc.c:3950
static int elevel
Definition: vacuumlazy.c:136
#define qsort(a, b, c, d)
Definition: port.h:447
static void * guc_malloc(int elevel, size_t size)
Definition: guc.c:3985
static struct config_generic* add_placeholder_variable ( const char *  name,
int  elevel 
)
static

Definition at line 4333 of file guc.c.

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

Referenced by find_option().

4334 {
4335  size_t sz = sizeof(struct config_string) + sizeof(char *);
4336  struct config_string *var;
4337  struct config_generic *gen;
4338 
4339  var = (struct config_string *) guc_malloc(elevel, sz);
4340  if (var == NULL)
4341  return NULL;
4342  memset(var, 0, sz);
4343  gen = &var->gen;
4344 
4345  gen->name = guc_strdup(elevel, name);
4346  if (gen->name == NULL)
4347  {
4348  free(var);
4349  return NULL;
4350  }
4351 
4352  gen->context = PGC_USERSET;
4353  gen->group = CUSTOM_OPTIONS;
4354  gen->short_desc = "GUC placeholder variable";
4356  gen->vartype = PGC_STRING;
4357 
4358  /*
4359  * The char* is allocated at the end of the struct since we have no
4360  * 'static' place to point to. Note that the current value, as well as
4361  * the boot and reset values, start out NULL.
4362  */
4363  var->variable = (char **) (var + 1);
4364 
4365  if (!add_guc_variable((struct config_generic *) var, elevel))
4366  {
4367  free((void *) gen->name);
4368  free(var);
4369  return NULL;
4370  }
4371 
4372  return gen;
4373 }
char ** variable
Definition: guc_tables.h:227
const char * name
Definition: guc_tables.h:146
const char * short_desc
Definition: guc_tables.h:149
static char * guc_strdup(int elevel, const char *src)
Definition: guc.c:4017
#define GUC_NO_SHOW_ALL
Definition: guc.h:206
#define GUC_NOT_IN_SAMPLE
Definition: guc.h:209
enum config_type vartype
Definition: guc_tables.h:153
static int elevel
Definition: vacuumlazy.c:136
struct config_generic gen
Definition: guc_tables.h:225
#define free(a)
Definition: header.h:65
#define GUC_CUSTOM_PLACEHOLDER
Definition: guc.h:211
const char * name
Definition: encode.c:521
enum config_group group
Definition: guc_tables.h:148
static void * guc_malloc(int elevel, size_t size)
Definition: guc.c:3985
GucContext context
Definition: guc_tables.h:147
static bool add_guc_variable(struct config_generic *var, int elevel)
Definition: guc.c:4295
void AlterSystemSetConfigFile ( AlterSystemStmt altersysstmt)

Definition at line 7079 of file guc.c.

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

Referenced by standard_ProcessUtility().

7080 {
7081  char *name;
7082  char *value;
7083  bool resetall = false;
7084  ConfigVariable *head = NULL;
7085  ConfigVariable *tail = NULL;
7086  volatile int Tmpfd;
7087  char AutoConfFileName[MAXPGPATH];
7088  char AutoConfTmpFileName[MAXPGPATH];
7089 
7090  if (!superuser())
7091  ereport(ERROR,
7092  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
7093  (errmsg("must be superuser to execute ALTER SYSTEM command"))));
7094 
7095  /*
7096  * Extract statement arguments
7097  */
7098  name = altersysstmt->setstmt->name;
7099 
7100  switch (altersysstmt->setstmt->kind)
7101  {
7102  case VAR_SET_VALUE:
7103  value = ExtractSetVariableArgs(altersysstmt->setstmt);
7104  break;
7105 
7106  case VAR_SET_DEFAULT:
7107  case VAR_RESET:
7108  value = NULL;
7109  break;
7110 
7111  case VAR_RESET_ALL:
7112  value = NULL;
7113  resetall = true;
7114  break;
7115 
7116  default:
7117  elog(ERROR, "unrecognized alter system stmt type: %d",
7118  altersysstmt->setstmt->kind);
7119  break;
7120  }
7121 
7122  /*
7123  * Unless it's RESET_ALL, validate the target variable and value
7124  */
7125  if (!resetall)
7126  {
7127  struct config_generic *record;
7128 
7129  record = find_option(name, false, ERROR);
7130  if (record == NULL)
7131  ereport(ERROR,
7132  (errcode(ERRCODE_UNDEFINED_OBJECT),
7133  errmsg("unrecognized configuration parameter \"%s\"",
7134  name)));
7135 
7136  /*
7137  * Don't allow parameters that can't be set in configuration files to
7138  * be set in PG_AUTOCONF_FILENAME file.
7139  */
7140  if ((record->context == PGC_INTERNAL) ||
7141  (record->flags & GUC_DISALLOW_IN_FILE) ||
7142  (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
7143  ereport(ERROR,
7144  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
7145  errmsg("parameter \"%s\" cannot be changed",
7146  name)));
7147 
7148  /*
7149  * If a value is specified, verify that it's sane.
7150  */
7151  if (value)
7152  {
7153  union config_var_val newval;
7154  void *newextra = NULL;
7155 
7156  /* Check that it's acceptable for the indicated parameter */
7157  if (!parse_and_validate_value(record, name, value,
7158  PGC_S_FILE, ERROR,
7159  &newval, &newextra))
7160  ereport(ERROR,
7161  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
7162  errmsg("invalid value for parameter \"%s\": \"%s\"",
7163  name, value)));
7164 
7165  if (record->vartype == PGC_STRING && newval.stringval != NULL)
7166  free(newval.stringval);
7167  if (newextra)
7168  free(newextra);
7169 
7170  /*
7171  * We must also reject values containing newlines, because the
7172  * grammar for config files doesn't support embedded newlines in
7173  * string literals.
7174  */
7175  if (strchr(value, '\n'))
7176  ereport(ERROR,
7177  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
7178  errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
7179  }
7180  }
7181 
7182  /*
7183  * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
7184  * the data directory, so we can reference them by simple relative paths.
7185  */
7186  snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
7188  snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
7189  AutoConfFileName,
7190  "tmp");
7191 
7192  /*
7193  * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
7194  * time. Use AutoFileLock to ensure that. We must hold the lock while
7195  * reading the old file contents.
7196  */
7197  LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
7198 
7199  /*
7200  * If we're going to reset everything, then no need to open or parse the
7201  * old file. We'll just write out an empty list.
7202  */
7203  if (!resetall)
7204  {
7205  struct stat st;
7206 
7207  if (stat(AutoConfFileName, &st) == 0)
7208  {
7209  /* open old file PG_AUTOCONF_FILENAME */
7210  FILE *infile;
7211 
7212  infile = AllocateFile(AutoConfFileName, "r");
7213  if (infile == NULL)
7214  ereport(ERROR,
7216  errmsg("could not open file \"%s\": %m",
7217  AutoConfFileName)));
7218 
7219  /* parse it */
7220  if (!ParseConfigFp(infile, AutoConfFileName, 0, LOG, &head, &tail))
7221  ereport(ERROR,
7222  (errcode(ERRCODE_CONFIG_FILE_ERROR),
7223  errmsg("could not parse contents of file \"%s\"",
7224  AutoConfFileName)));
7225 
7226  FreeFile(infile);
7227  }
7228 
7229  /*
7230  * Now, replace any existing entry with the new value, or add it if
7231  * not present.
7232  */
7233  replace_auto_config_value(&head, &tail, name, value);
7234  }
7235 
7236  /*
7237  * To ensure crash safety, first write the new file data to a temp file,
7238  * then atomically rename it into place.
7239  *
7240  * If there is a temp file left over due to a previous crash, it's okay to
7241  * truncate and reuse it.
7242  */
7243  Tmpfd = BasicOpenFile(AutoConfTmpFileName,
7244  O_CREAT | O_RDWR | O_TRUNC);
7245  if (Tmpfd < 0)
7246  ereport(ERROR,
7248  errmsg("could not open file \"%s\": %m",
7249  AutoConfTmpFileName)));
7250 
7251  /*
7252  * Use a TRY block to clean up the file if we fail. Since we need a TRY
7253  * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
7254  */
7255  PG_TRY();
7256  {
7257  /* Write and sync the new contents to the temporary file */
7258  write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
7259 
7260  /* Close before renaming; may be required on some platforms */
7261  close(Tmpfd);
7262  Tmpfd = -1;
7263 
7264  /*
7265  * As the rename is atomic operation, if any problem occurs after this
7266  * at worst it can lose the parameters set by last ALTER SYSTEM
7267  * command.
7268  */
7269  durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
7270  }
7271  PG_CATCH();
7272  {
7273  /* Close file first, else unlink might fail on some platforms */
7274  if (Tmpfd >= 0)
7275  close(Tmpfd);
7276 
7277  /* Unlink, but ignore any error */
7278  (void) unlink(AutoConfTmpFileName);
7279 
7280  PG_RE_THROW();
7281  }
7282  PG_END_TRY();
7283 
7284  FreeConfigVariables(head);
7285 
7286  LWLockRelease(AutoFileLock);
7287 }
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:5733
VariableSetKind kind
Definition: parsenodes.h:1973
int errcode(int sqlerrcode)
Definition: elog.c:575
bool superuser(void)
Definition: superuser.c:47
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
#define LOG
Definition: elog.h:26
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1721
#define ERROR
Definition: elog.h:43
#define MAXPGPATH
static struct @121 value
VariableSetStmt * setstmt
Definition: parsenodes.h:3066
int errcode_for_file_access(void)
Definition: elog.c:598
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2117
#define ereport(elevel, rest)
Definition: elog.h:122
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:598
enum config_type vartype
Definition: guc_tables.h:153
#define GUC_DISALLOW_IN_FILE
Definition: guc.h:210
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head_p)
Definition: guc.c:6938
static void infile(const char *filename)
Definition: zic.c:1159
#define free(a)
Definition: header.h:65
static struct config_generic * find_option(const char *name, bool create_placeholders, int elevel)
Definition: guc.c:4381
#define PG_CATCH()
Definition: elog.h:293
#define newval
#define PG_AUTOCONF_FILENAME
Definition: guc.h:34
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1117
#define PG_RE_THROW()
Definition: elog.h:314
const char * name
Definition: encode.c:521
#define GUC_DISALLOW_IN_AUTO_FILE
Definition: guc.h:215
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:929
int FreeFile(FILE *file)
Definition: fd.c:2309
int errmsg(const char *fmt,...)
Definition: elog.c:797
bool ParseConfigFp(FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
Definition: guc.c:7006
void FreeConfigVariables(ConfigVariable *list)
#define elog
Definition: elog.h:219
#define close(a)
Definition: win32.h:12
#define PG_TRY()
Definition: elog.h:284
char * ExtractSetVariableArgs(VariableSetStmt *stmt)
Definition: guc.c:7417
#define PG_END_TRY()
Definition: elog.h:300
GucContext context
Definition: guc_tables.h:147
static void assign_application_name ( const char *  newval,
void *  extra 
)
static

Definition at line 10474 of file guc.c.

References pgstat_report_appname().

10475 {
10476  /* Update the pg_stat_activity view */
10478 }
void pgstat_report_appname(const char *appname)
Definition: pgstat.c:3167
#define newval
static void assign_effective_io_concurrency ( int  newval,
void *  extra 
)
static

Definition at line 10422 of file guc.c.

References target_prefetch_pages.

10423 {
10424 #ifdef USE_PREFETCH
10425  target_prefetch_pages = *((int *) extra);
10426 #endif /* USE_PREFETCH */
10427 }
int target_prefetch_pages
Definition: bufmgr.c:129
static void assign_log_destination ( const char *  newval,
void *  extra 
)
static

Definition at line 10110 of file guc.c.

References Log_destination.

10111 {
10112  Log_destination = *((int *) extra);
10113 }
int Log_destination
Definition: elog.c:106
static void assign_pgstat_temp_directory ( const char *  newval,
void *  extra 
)
static

Definition at line 10430 of file guc.c.

References ERROR, free, guc_malloc(), pgstat_stat_directory, pgstat_stat_filename, and pgstat_stat_tmpname.

10431 {
10432  /* check_canonical_path already canonicalized newval for us */
10433  char *dname;
10434  char *tname;
10435  char *fname;
10436 
10437  /* directory */
10438  dname = guc_malloc(ERROR, strlen(newval) + 1); /* runtime dir */
10439  sprintf(dname, "%s", newval);
10440 
10441  /* global stats */
10442  tname = guc_malloc(ERROR, strlen(newval) + 12); /* /global.tmp */
10443  sprintf(tname, "%s/global.tmp", newval);
10444  fname = guc_malloc(ERROR, strlen(newval) + 13); /* /global.stat */
10445  sprintf(fname, "%s/global.stat", newval);
10446 
10449  pgstat_stat_directory = dname;
10450  if (pgstat_stat_tmpname)
10452  pgstat_stat_tmpname = tname;
10455  pgstat_stat_filename = fname;
10456 }
char * pgstat_stat_filename
Definition: pgstat.c:135
#define ERROR
Definition: elog.h:43
char * pgstat_stat_directory
Definition: pgstat.c:134
#define free(a)
Definition: header.h:65
#define newval
char * pgstat_stat_tmpname
Definition: pgstat.c:136
static void * guc_malloc(int elevel, size_t size)
Definition: guc.c:3985
static void assign_session_replication_role ( int  newval,
void *  extra 
)
static

Definition at line 10136 of file guc.c.

References ResetPlanCache(), and SessionReplicationRole.

10137 {
10138  /*
10139  * Must flush the plan cache when changing replication role; but don't
10140  * flush unnecessarily.
10141  */
10143  ResetPlanCache();
10144 }
int SessionReplicationRole
Definition: trigger.c:65
void ResetPlanCache(void)
Definition: plancache.c:1860
#define newval
static void assign_syslog_facility ( int  newval,
void *  extra 
)
static

Definition at line 10116 of file guc.c.

10117 {
10118 #ifdef HAVE_SYSLOG
10119  set_syslog_parameters(syslog_ident_str ? syslog_ident_str : "postgres",
10120  newval);
10121 #endif
10122  /* Without syslog support, just ignore it */
10123 }
static char * syslog_ident_str
Definition: guc.c:494
#define newval
static void assign_syslog_ident ( const char *  newval,
void *  extra 
)
static

Definition at line 10126 of file guc.c.

10127 {
10128 #ifdef HAVE_SYSLOG
10129  set_syslog_parameters(newval, syslog_facility);
10130 #endif
10131  /* Without syslog support, it will always be set to "none", so ignore */
10132 }
static int syslog_facility
Definition: guc.c:160
#define newval
static void assign_tcp_keepalives_count ( int  newval,
void *  extra 
)
static

Definition at line 10335 of file guc.c.

References MyProcPort, and pq_setkeepalivescount().

10336 {
10337  /* See comments in assign_tcp_keepalives_idle */
10339 }
struct Port * MyProcPort
Definition: globals.c:41
int pq_setkeepalivescount(int count, Port *port)
Definition: pqcomm.c:1888
#define newval
static void assign_tcp_keepalives_idle ( int  newval,
void *  extra 
)
static

Definition at line 10291 of file guc.c.

References MyProcPort, and pq_setkeepalivesidle().

10292 {
10293  /*
10294  * The kernel API provides no way to test a value without setting it; and
10295  * once we set it we might fail to unset it. So there seems little point
10296  * in fully implementing the check-then-assign GUC API for these
10297  * variables. Instead we just do the assignment on demand. pqcomm.c
10298  * reports any problems via elog(LOG).
10299  *
10300  * This approach means that the GUC value might have little to do with the
10301  * actual kernel value, so we use a show_hook that retrieves the kernel
10302  * value rather than trusting GUC's copy.
10303  */
10305 }
struct Port * MyProcPort
Definition: globals.c:41
int pq_setkeepalivesidle(int idle, Port *port)
Definition: pqcomm.c:1730
#define newval
static void assign_tcp_keepalives_interval ( int  newval,
void *  extra 
)
static

Definition at line 10318 of file guc.c.

References MyProcPort, and pq_setkeepalivesinterval().

10319 {
10320  /* See comments in assign_tcp_keepalives_idle */
10322 }
struct Port * MyProcPort
Definition: globals.c:41
int pq_setkeepalivesinterval(int interval, Port *port)
Definition: pqcomm.c:1812
#define newval
static void assign_timezone_abbreviations ( const char *  newval,
void *  extra 
)
static

Definition at line 10255 of file guc.c.

References InstallTimeZoneAbbrevs().

10256 {
10257  /* Do nothing for the boot_val default of NULL */
10258  if (!extra)
10259  return;
10260 
10262 }
void InstallTimeZoneAbbrevs(TimeZoneAbbrevTable *tbl)
Definition: datetime.c:4603
static void assign_wal_consistency_checking ( const char *  newval,
void *  extra 
)
static

Definition at line 10047 of file guc.c.

References wal_consistency_checking.

10048 {
10049  wal_consistency_checking = (bool *) extra;
10050 }
bool * wal_consistency_checking
Definition: xlog.c:101
void AtEOXact_GUC ( bool  isCommit,
int  nestLevel 
)

Definition at line 5088 of file guc.c.

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

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

5089 {
5090  bool still_dirty;
5091  int i;
5092 
5093  /*
5094  * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
5095  * abort, if there is a failure during transaction start before
5096  * AtStart_GUC is called.
5097  */
5098  Assert(nestLevel > 0 &&
5099  (nestLevel <= GUCNestLevel ||
5100  (nestLevel == GUCNestLevel + 1 && !isCommit)));
5101 
5102  /* Quick exit if nothing's changed in this transaction */
5103  if (!guc_dirty)
5104  {
5105  GUCNestLevel = nestLevel - 1;
5106  return;
5107  }
5108 
5109  still_dirty = false;
5110  for (i = 0; i < num_guc_variables; i++)
5111  {
5112  struct config_generic *gconf = guc_variables[i];
5113  GucStack *stack;
5114 
5115  /*
5116  * Process and pop each stack entry within the nest level. To simplify
5117  * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
5118  * we allow failure exit from code that uses a local nest level to be
5119  * recovered at the surrounding transaction or subtransaction abort;
5120  * so there could be more than one stack entry to pop.
5121  */
5122  while ((stack = gconf->stack) != NULL &&
5123  stack->nest_level >= nestLevel)
5124  {
5125  GucStack *prev = stack->prev;
5126  bool restorePrior = false;
5127  bool restoreMasked = false;
5128  bool changed;
5129 
5130  /*
5131  * In this next bit, if we don't set either restorePrior or
5132  * restoreMasked, we must "discard" any unwanted fields of the
5133  * stack entries to avoid leaking memory. If we do set one of
5134  * those flags, unused fields will be cleaned up after restoring.
5135  */
5136  if (!isCommit) /* if abort, always restore prior value */
5137  restorePrior = true;
5138  else if (stack->state == GUC_SAVE)
5139  restorePrior = true;
5140  else if (stack->nest_level == 1)
5141  {
5142  /* transaction commit */
5143  if (stack->state == GUC_SET_LOCAL)
5144  restoreMasked = true;
5145  else if (stack->state == GUC_SET)
5146  {
5147  /* we keep the current active value */
5148  discard_stack_value(gconf, &stack->prior);
5149  }
5150  else /* must be GUC_LOCAL */
5151  restorePrior = true;
5152  }
5153  else if (prev == NULL ||
5154  prev->nest_level < stack->nest_level - 1)
5155  {
5156  /* decrement entry's level and do not pop it */
5157  stack->nest_level--;
5158  continue;
5159  }
5160  else
5161  {
5162  /*
5163  * We have to merge this stack entry into prev. See README for
5164  * discussion of this bit.
5165  */
5166  switch (stack->state)
5167  {
5168  case GUC_SAVE:
5169  Assert(false); /* can't get here */
5170 
5171  case GUC_SET:
5172  /* next level always becomes SET */
5173  discard_stack_value(gconf, &stack->prior);
5174  if (prev->state == GUC_SET_LOCAL)
5175  discard_stack_value(gconf, &prev->masked);
5176  prev->state = GUC_SET;
5177  break;
5178 
5179  case GUC_LOCAL:
5180  if (prev->state == GUC_SET)
5181  {
5182  /* LOCAL migrates down */
5183  prev->masked_scontext = stack->scontext;
5184  prev->masked = stack->prior;
5185  prev->state = GUC_SET_LOCAL;
5186  }
5187  else
5188  {
5189  /* else just forget this stack level */
5190  discard_stack_value(gconf, &stack->prior);
5191  }
5192  break;
5193 
5194  case GUC_SET_LOCAL:
5195  /* prior state at this level no longer wanted */
5196  discard_stack_value(gconf, &stack->prior);
5197  /* copy down the masked state */
5198  prev->masked_scontext = stack->masked_scontext;
5199  if (prev->state == GUC_SET_LOCAL)
5200  discard_stack_value(gconf, &prev->masked);
5201  prev->masked = stack->masked;
5202  prev->state = GUC_SET_LOCAL;
5203  break;
5204  }
5205  }
5206 
5207  changed = false;
5208 
5209  if (restorePrior || restoreMasked)
5210  {
5211  /* Perform appropriate restoration of the stacked value */
5212  config_var_value newvalue;
5213  GucSource newsource;
5214  GucContext newscontext;
5215 
5216  if (restoreMasked)
5217  {
5218  newvalue = stack->masked;
5219  newsource = PGC_S_SESSION;
5220  newscontext = stack->masked_scontext;
5221  }
5222  else
5223  {
5224  newvalue = stack->prior;
5225  newsource = stack->source;
5226  newscontext = stack->scontext;
5227  }
5228 
5229  switch (gconf->vartype)
5230  {
5231  case PGC_BOOL:
5232  {
5233  struct config_bool *conf = (struct config_bool *) gconf;
5234  bool newval = newvalue.val.boolval;
5235  void *newextra = newvalue.extra;
5236 
5237  if (*conf->variable != newval ||
5238  conf->gen.extra != newextra)
5239  {
5240  if (conf->assign_hook)
5241  conf->assign_hook(newval, newextra);
5242  *conf->variable = newval;
5243  set_extra_field(&conf->gen, &conf->gen.extra,
5244  newextra);
5245  changed = true;
5246  }
5247  break;
5248  }
5249  case PGC_INT:
5250  {
5251  struct config_int *conf = (struct config_int *) gconf;
5252  int newval = newvalue.val.intval;
5253  void *newextra = newvalue.extra;
5254 
5255  if (*conf->variable != newval ||
5256  conf->gen.extra != newextra)
5257  {
5258  if (conf->assign_hook)
5259  conf->assign_hook(newval, newextra);
5260  *conf->variable = newval;
5261  set_extra_field(&conf->gen, &conf->gen.extra,
5262  newextra);
5263  changed = true;
5264  }
5265  break;
5266  }
5267  case PGC_REAL:
5268  {
5269  struct config_real *conf = (struct config_real *) gconf;
5270  double newval = newvalue.val.realval;
5271  void *newextra = newvalue.extra;
5272 
5273  if (*conf->variable != newval ||
5274  conf->gen.extra != newextra)
5275  {
5276  if (conf->assign_hook)
5277  conf->assign_hook(newval, newextra);
5278  *conf->variable = newval;
5279  set_extra_field(&conf->gen, &conf->gen.extra,
5280  newextra);
5281  changed = true;
5282  }
5283  break;
5284  }
5285  case PGC_STRING:
5286  {
5287  struct config_string *conf = (struct config_string *) gconf;
5288  char *newval = newvalue.val.stringval;
5289  void *newextra = newvalue.extra;
5290 
5291  if (*conf->variable != newval ||
5292  conf->gen.extra != newextra)
5293  {
5294  if (conf->assign_hook)
5295  conf->assign_hook(newval, newextra);
5296  set_string_field(conf, conf->variable, newval);
5297  set_extra_field(&conf->gen, &conf->gen.extra,
5298  newextra);
5299  changed = true;
5300  }
5301 
5302  /*
5303  * Release stacked values if not used anymore. We
5304  * could use discard_stack_value() here, but since
5305  * we have type-specific code anyway, might as
5306  * well inline it.
5307  */
5308  set_string_field(conf, &stack->prior.val.stringval, NULL);
5309  set_string_field(conf, &stack->masked.val.stringval, NULL);
5310  break;
5311  }
5312  case PGC_ENUM:
5313  {
5314  struct config_enum *conf = (struct config_enum *) gconf;
5315  int newval = newvalue.val.enumval;
5316  void *newextra = newvalue.extra;
5317 
5318  if (*conf->variable != newval ||
5319  conf->gen.extra != newextra)
5320  {
5321  if (conf->assign_hook)
5322  conf->assign_hook(newval, newextra);
5323  *conf->variable = newval;
5324  set_extra_field(&conf->gen, &conf->gen.extra,
5325  newextra);
5326  changed = true;
5327  }
5328  break;
5329  }
5330  }
5331 
5332  /*
5333  * Release stacked extra values if not used anymore.
5334  */
5335  set_extra_field(gconf, &(stack->prior.extra), NULL);
5336  set_extra_field(gconf, &(stack->masked.extra), NULL);
5337 
5338  /* And restore source information */
5339  gconf->source = newsource;
5340  gconf->scontext = newscontext;
5341  }
5342 
5343  /* Finish popping the state stack */
5344  gconf->stack = prev;
5345  pfree(stack);
5346 
5347  /* Report new value if we changed it */
5348  if (changed && (gconf->flags & GUC_REPORT))
5349  ReportGUCOption(gconf);
5350  } /* end of stack-popping loop */
5351 
5352  if (stack != NULL)
5353  still_dirty = true;
5354  }
5355 
5356  /* If there are no remaining stack entries, we can reset guc_dirty */
5357  guc_dirty = still_dirty;
5358 
5359  /* Update nesting level */
5360  GUCNestLevel = nestLevel - 1;
5361 }
struct guc_stack * prev
Definition: guc_tables.h:120
GucSource source
Definition: guc_tables.h:155
GucContext
Definition: guc.h:68
union config_var_val val
Definition: guc_tables.h:46
int nest_level
Definition: guc_tables.h:121
GucRealAssignHook assign_hook
Definition: guc_tables.h:216
char ** variable
Definition: guc_tables.h:227
static int GUCNestLevel
Definition: guc.c:3957
bool * variable
Definition: guc_tables.h:181
GucEnumAssignHook assign_hook
Definition: guc_tables.h:245
GucBoolAssignHook assign_hook
Definition: guc_tables.h:184
config_var_value masked
Definition: guc_tables.h:128
GucContext scontext
Definition: guc_tables.h:157
GucIntAssignHook assign_hook
Definition: guc_tables.h:200
GucSource
Definition: guc.h:105
int * variable
Definition: guc_tables.h:195
int * variable
Definition: guc_tables.h:241
void pfree(void *pointer)
Definition: mcxt.c:949
static int num_guc_variables
Definition: guc.c:3947
static void discard_stack_value(struct config_generic *gconf, config_var_value *val)
Definition: guc.c:4172
GucSource source
Definition: guc_tables.h:123
static void set_extra_field(struct config_generic *gconf, void **field, void *newval)
Definition: guc.c:4118
struct config_generic gen
Definition: guc_tables.h:179
struct config_generic gen
Definition: guc_tables.h:193
GucContext masked_scontext
Definition: guc_tables.h:126
#define GUC_REPORT
Definition: guc.h:208
double * variable
Definition: guc_tables.h:211
static void set_string_field(struct config_string *conf, char **field, char *newval)
Definition: guc.c:4057
static struct config_generic ** guc_variables
Definition: guc.c:3944
enum config_type vartype
Definition: guc_tables.h:153
GucContext scontext
Definition: guc_tables.h:125
struct config_generic gen
Definition: guc_tables.h:239
struct config_generic gen
Definition: guc_tables.h:225
GucStackState state
Definition: guc_tables.h:122
GucStringAssignHook assign_hook
Definition: guc_tables.h:230
#define Assert(condition)
Definition: c.h:681
#define newval
char * stringval
Definition: guc_tables.h:36
int i
static void ReportGUCOption(struct config_generic *record)
Definition: guc.c:5397
GucStack * stack
Definition: guc_tables.h:159
double realval
Definition: guc_tables.h:35
static bool guc_dirty
Definition: guc.c:3953
config_var_value prior
Definition: guc_tables.h:127
struct config_generic gen
Definition: guc_tables.h:209
void AtStart_GUC ( void  )

Definition at line 5054 of file guc.c.

References elog, and WARNING.

Referenced by StartTransaction().

5055 {
5056  /*
5057  * The nest level should be 0 between transactions; if it isn't, somebody
5058  * didn't call AtEOXact_GUC, or called it with the wrong nestLevel. We
5059  * throw a warning but make no other effort to clean up.
5060  */
5061  if (GUCNestLevel != 0)
5062  elog(WARNING, "GUC nest level = %d at transaction start",
5063  GUCNestLevel);
5064  GUCNestLevel = 1;
5065 }
static int GUCNestLevel
Definition: guc.c:3957
#define WARNING
Definition: elog.h:40
#define elog
Definition: elog.h:219
void BeginReportingGUCOptions ( void  )

Definition at line 5369 of file guc.c.

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

Referenced by PostgresMain().

5370 {
5371  int i;
5372 
5373  /*
5374  * Don't do anything unless talking to an interactive frontend of protocol
5375  * 3.0 or later.
5376  */
5377  if (whereToSendOutput != DestRemote ||
5379  return;
5380 
5381  reporting_enabled = true;
5382 
5383  /* Transmit initial values of interesting variables */
5384  for (i = 0; i < num_guc_variables; i++)
5385  {
5386  struct config_generic *conf = guc_variables[i];
5387 
5388  if (conf->flags & GUC_REPORT)
5389  ReportGUCOption(conf);
5390  }
5391 }
#define PG_PROTOCOL_MAJOR(v)
Definition: pqcomm.h:104
static int num_guc_variables
Definition: guc.c:3947
#define GUC_REPORT
Definition: guc.h:208
static struct config_generic ** guc_variables
Definition: guc.c:3944
int i
static void ReportGUCOption(struct config_generic *record)
Definition: guc.c:5397
CommandDest whereToSendOutput
Definition: postgres.c:88
static bool reporting_enabled
Definition: guc.c:3955
ProtocolVersion FrontendProtocol
Definition: globals.c:27
void build_guc_variables ( void  )

Definition at line 4208 of file guc.c.

References FATAL, free, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, guc_malloc(), guc_var_compare(), i, config_generic::name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, qsort, and config_generic::vartype.

Referenced by GucInfoMain(), and InitializeGUCOptions().

4209 {
4210  int size_vars;
4211  int num_vars = 0;
4212  struct config_generic **guc_vars;
4213  int i;
4214 
4215  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
4216  {
4217  struct config_bool *conf = &ConfigureNamesBool[i];
4218 
4219  /* Rather than requiring vartype to be filled in by hand, do this: */
4220  conf->gen.vartype = PGC_BOOL;
4221  num_vars++;
4222  }
4223 
4224  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
4225  {
4226  struct config_int *conf = &ConfigureNamesInt[i];
4227 
4228  conf->gen.vartype = PGC_INT;
4229  num_vars++;
4230  }
4231 
4232  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
4233  {
4234  struct config_real *conf = &ConfigureNamesReal[i];
4235 
4236  conf->gen.vartype = PGC_REAL;
4237  num_vars++;
4238  }
4239 
4240  for (i = 0; ConfigureNamesString[i].gen.name; i++)
4241  {
4242  struct config_string *conf = &ConfigureNamesString[i];
4243 
4244  conf->gen.vartype = PGC_STRING;
4245  num_vars++;
4246  }
4247 
4248  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
4249  {
4250  struct config_enum *conf = &ConfigureNamesEnum[i];
4251 
4252  conf->gen.vartype = PGC_ENUM;
4253  num_vars++;
4254  }
4255 
4256  /*
4257  * Create table with 20% slack
4258  */
4259  size_vars = num_vars + num_vars / 4;
4260 
4261  guc_vars = (struct config_generic **)
4262  guc_malloc(FATAL, size_vars * sizeof(struct config_generic *));
4263 
4264  num_vars = 0;
4265 
4266  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
4267  guc_vars[num_vars++] = &ConfigureNamesBool[i].gen;
4268 
4269  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
4270  guc_vars[num_vars++] = &ConfigureNamesInt[i].gen;
4271 
4272  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
4273  guc_vars[num_vars++] = &ConfigureNamesReal[i].gen;
4274 
4275  for (i = 0; ConfigureNamesString[i].gen.name; i++)
4276  guc_vars[num_vars++] = &ConfigureNamesString[i].gen;
4277 
4278  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
4279  guc_vars[num_vars++] = &ConfigureNamesEnum[i].gen;
4280 
4281  if (guc_variables)
4283  guc_variables = guc_vars;
4284  num_guc_variables = num_vars;
4285  size_guc_variables = size_vars;
4287  sizeof(struct config_generic *), guc_var_compare);
4288 }
static struct config_int ConfigureNamesInt[]
Definition: guc.c:1686
const char * name
Definition: guc_tables.h:146
static struct config_enum ConfigureNamesEnum[]
Definition: guc.c:3658
static struct config_bool ConfigureNamesBool[]
Definition: guc.c:804
static int guc_var_compare(const void *a, const void *b)
Definition: guc.c:4430
static int num_guc_variables
Definition: guc.c:3947
#define FATAL
Definition: elog.h:52
struct config_generic gen
Definition: guc_tables.h:179
struct config_generic gen
Definition: guc_tables.h:193
static struct config_generic ** guc_variables
Definition: guc.c:3944
enum config_type vartype
Definition: guc_tables.h:153
static int size_guc_variables
Definition: guc.c:3950
static struct config_real ConfigureNamesReal[]
Definition: guc.c:2893
struct config_generic gen
Definition: guc_tables.h:239
struct config_generic gen
Definition: guc_tables.h:225
#define free(a)
Definition: header.h:65
static struct config_string ConfigureNamesString[]
Definition: guc.c:3054
int i
#define qsort(a, b, c, d)
Definition: port.h:447
static void * guc_malloc(int elevel, size_t size)
Definition: guc.c:3985
struct config_generic gen
Definition: guc_tables.h:209
static bool call_bool_check_hook ( struct config_bool conf,
bool newval,
void **  extra,
GucSource  source,
int  elevel 
)
static

Definition at line 9797 of file guc.c.

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

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

9799 {
9800  /* Quick success if no hook */
9801  if (!conf->check_hook)
9802  return true;
9803 
9804  /* Reset variables that might be set by hook */
9805  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
9806  GUC_check_errmsg_string = NULL;
9808  GUC_check_errhint_string = NULL;
9809 
9810  if (!conf->check_hook(newval, extra, source))
9811  {
9812  ereport(elevel,
9816  errmsg("invalid value for parameter \"%s\": %d",
9817  conf->gen.name, (int) *newval),
9821  errhint("%s", GUC_check_errhint_string) : 0));
9822  /* Flush any strings created in ErrorContext */
9823  FlushErrorState();
9824  return false;
9825  }
9826 
9827  return true;
9828 }
char * GUC_check_errhint_string
Definition: guc.c:133
GucSource source
Definition: guc_tables.h:155
int errhint(const char *fmt,...)
Definition: elog.c:987
const char * name
Definition: guc_tables.h:146
int errcode(int sqlerrcode)
Definition: elog.c:575
static int GUC_check_errcode_value
Definition: guc.c:128
void FlushErrorState(void)
Definition: elog.c:1587
int errdetail_internal(const char *fmt,...)
Definition: elog.c:900
struct config_generic gen
Definition: guc_tables.h:179
char * GUC_check_errdetail_string
Definition: guc.c:132
#define ereport(elevel, rest)
Definition: elog.h:122
static int elevel
Definition: vacuumlazy.c:136
GucBoolCheckHook check_hook
Definition: guc_tables.h:183
int errmsg_internal(const char *fmt,...)
Definition: elog.c:827
#define newval
char * GUC_check_errmsg_string
Definition: guc.c:131
int errmsg(const char *fmt,...)
Definition: elog.c:797
static bool call_enum_check_hook ( struct config_enum conf,
int *  newval,
void **  extra,
GucSource  source,
int  elevel 
)
static

Definition at line 9933 of file guc.c.

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

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

9935 {
9936  /* Quick success if no hook */
9937  if (!conf->check_hook)
9938  return true;
9939 
9940  /* Reset variables that might be set by hook */
9941  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
9942  GUC_check_errmsg_string = NULL;
9944  GUC_check_errhint_string = NULL;
9945 
9946  if (!conf->check_hook(newval, extra, source))
9947  {
9948  ereport(elevel,
9952  errmsg("invalid value for parameter \"%s\": \"%s\"",
9953  conf->gen.name,
9958  errhint("%s", GUC_check_errhint_string) : 0));
9959  /* Flush any strings created in ErrorContext */
9960  FlushErrorState();
9961  return false;
9962  }
9963 
9964  return true;
9965 }
char * GUC_check_errhint_string
Definition: guc.c:133
GucSource source
Definition: guc_tables.h:155
GucEnumCheckHook check_hook
Definition: guc_tables.h:244
int errhint(const char *fmt,...)
Definition: elog.c:987
const char * name
Definition: guc_tables.h:146
int errcode(int sqlerrcode)
Definition: elog.c:575
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:5626
static int GUC_check_errcode_value
Definition: guc.c:128
void FlushErrorState(void)
Definition: elog.c:1587
int errdetail_internal(const char *fmt,...)
Definition: elog.c:900
char * GUC_check_errdetail_string
Definition: guc.c:132
#define ereport(elevel, rest)
Definition: elog.h:122
static int elevel
Definition: vacuumlazy.c:136
struct config_generic gen
Definition: guc_tables.h:239
int errmsg_internal(const char *fmt,...)
Definition: elog.c:827
#define newval
char * GUC_check_errmsg_string
Definition: guc.c:131
int errmsg(const char *fmt,...)
Definition: elog.c:797
static bool call_int_check_hook ( struct config_int conf,
int *  newval,
void **  extra,
GucSource  source,
int  elevel 
)
static

Definition at line 9831 of file guc.c.

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

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

9833 {
9834  /* Quick success if no hook */
9835  if (!conf->check_hook)
9836  return true;
9837 
9838  /* Reset variables that might be set by hook */
9839  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
9840  GUC_check_errmsg_string = NULL;
9842  GUC_check_errhint_string = NULL;
9843 
9844  if (!conf->check_hook(newval, extra, source))
9845  {
9846  ereport(elevel,
9850  errmsg("invalid value for parameter \"%s\": %d",
9851  conf->gen.name, *newval),
9855  errhint("%s", GUC_check_errhint_string) : 0));
9856  /* Flush any strings created in ErrorContext */
9857  FlushErrorState();
9858  return false;
9859  }
9860 
9861  return true;
9862 }
char * GUC_check_errhint_string
Definition: guc.c:133
GucSource source
Definition: guc_tables.h:155
int errhint(const char *fmt,...)
Definition: elog.c:987
const char * name
Definition: guc_tables.h:146
int errcode(int sqlerrcode)
Definition: elog.c:575
static int GUC_check_errcode_value
Definition: guc.c:128
GucIntCheckHook check_hook
Definition: guc_tables.h:199
void FlushErrorState(void)
Definition: elog.c:1587
int errdetail_internal(const char *fmt,...)
Definition: elog.c:900
struct config_generic gen
Definition: guc_tables.h:193
char * GUC_check_errdetail_string
Definition: guc.c:132
#define ereport(elevel, rest)
Definition: elog.h:122
static int elevel
Definition: vacuumlazy.c:136
int errmsg_internal(const char *fmt,...)
Definition: elog.c:827
#define newval
char * GUC_check_errmsg_string
Definition: guc.c:131
int errmsg(const char *fmt,...)
Definition: elog.c:797
static bool call_real_check_hook ( struct config_real conf,
double *  newval,
void **  extra,
GucSource  source,
int  elevel 
)
static

Definition at line 9865 of file guc.c.

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

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

9867 {
9868  /* Quick success if no hook */
9869  if (!conf->check_hook)
9870  return true;
9871 
9872  /* Reset variables that might be set by hook */
9873  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
9874  GUC_check_errmsg_string = NULL;
9876  GUC_check_errhint_string = NULL;
9877 
9878  if (!conf->check_hook(newval, extra, source))
9879  {
9880  ereport(elevel,
9884  errmsg("invalid value for parameter \"%s\": %g",
9885  conf->gen.name, *newval),
9889  errhint("%s", GUC_check_errhint_string) : 0));
9890  /* Flush any strings created in ErrorContext */
9891  FlushErrorState();
9892  return false;
9893  }
9894 
9895  return true;
9896 }
char * GUC_check_errhint_string
Definition: guc.c:133
GucSource source
Definition: guc_tables.h:155
int errhint(const char *fmt,...)
Definition: elog.c:987
const char * name
Definition: guc_tables.h:146
int errcode(int sqlerrcode)
Definition: elog.c:575
static int GUC_check_errcode_value
Definition: guc.c:128
GucRealCheckHook check_hook
Definition: guc_tables.h:215
void FlushErrorState(void)
Definition: elog.c:1587
int errdetail_internal(const char *fmt,...)
Definition: elog.c:900
char * GUC_check_errdetail_string
Definition: guc.c:132
#define ereport(elevel, rest)
Definition: elog.h:122
static int elevel
Definition: vacuumlazy.c:136
int errmsg_internal(const char *fmt,...)
Definition: elog.c:827
#define newval
char * GUC_check_errmsg_string
Definition: guc.c:131
int errmsg(const char *fmt,...)
Definition: elog.c:797
struct config_generic gen
Definition: guc_tables.h:209
static bool call_string_check_hook ( struct config_string conf,
char **  newval,
void **  extra,
GucSource  source,
int  elevel 
)
static

Definition at line 9899 of file guc.c.

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

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

9901 {
9902  /* Quick success if no hook */
9903  if (!conf->check_hook)
9904  return true;
9905 
9906  /* Reset variables that might be set by hook */
9907  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
9908  GUC_check_errmsg_string = NULL;
9910  GUC_check_errhint_string = NULL;
9911 
9912  if (!conf->check_hook(newval, extra, source))
9913  {
9914  ereport(elevel,
9918  errmsg("invalid value for parameter \"%s\": \"%s\"",
9919  conf->gen.name, *newval ? *newval : ""),
9923  errhint("%s", GUC_check_errhint_string) : 0));
9924  /* Flush any strings created in ErrorContext */
9925  FlushErrorState();
9926  return false;
9927  }
9928 
9929  return true;
9930 }
char * GUC_check_errhint_string
Definition: guc.c:133
GucSource source
Definition: guc_tables.h:155
int errhint(const char *fmt,...)
Definition: elog.c:987
const char * name
Definition: guc_tables.h:146
GucStringCheckHook check_hook
Definition: guc_tables.h:229
int errcode(int sqlerrcode)
Definition: elog.c:575
static int GUC_check_errcode_value
Definition: guc.c:128
void FlushErrorState(void)
Definition: elog.c:1587
int errdetail_internal(const char *fmt,...)
Definition: elog.c:900
char * GUC_check_errdetail_string
Definition: guc.c:132
#define ereport(elevel, rest)
Definition: elog.h:122
static int elevel
Definition: vacuumlazy.c:136
struct config_generic gen
Definition: guc_tables.h:225
int errmsg_internal(const char *fmt,...)
Definition: elog.c:827
#define newval
char * GUC_check_errmsg_string
Definition: guc.c:131
int errmsg(const char *fmt,...)
Definition: elog.c:797
static bool can_skip_gucvar ( struct config_generic gconf)
static

Definition at line 8991 of file guc.c.

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

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

8992 {
8993  return gconf->context == PGC_POSTMASTER ||
8994  gconf->context == PGC_INTERNAL || gconf->source == PGC_S_DEFAULT;
8995 }
GucSource source
Definition: guc_tables.h:155
GucContext context
Definition: guc_tables.h:147
static bool check_application_name ( char **  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10459 of file guc.c.

10460 {
10461  /* Only allow clean ASCII chars in the application name */
10462  char *p;
10463 
10464  for (p = *newval; *p; p++)
10465  {
10466  if (*p < 32 || *p > 126)
10467  *p = '?';
10468  }
10469 
10470  return true;
10471 }
#define newval
static bool check_autovacuum_max_workers ( int *  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10361 of file guc.c.

References MAX_BACKENDS, max_worker_processes, and MaxConnections.

10362 {
10364  return false;
10365  return true;
10366 }
#define MAX_BACKENDS
Definition: postmaster.h:75
int MaxConnections
Definition: globals.c:123
#define newval
int max_worker_processes
Definition: globals.c:124
static bool check_autovacuum_work_mem ( int *  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10369 of file guc.c.

10370 {
10371  /*
10372  * -1 indicates fallback.
10373  *
10374  * If we haven't yet changed the boot_val default of -1, just let it be.
10375  * Autovacuum will look to maintenance_work_mem instead.
10376  */
10377  if (*newval == -1)
10378  return true;
10379 
10380  /*
10381  * We clamp manually-set values to at least 1MB. Since
10382  * maintenance_work_mem is always set to at least this value, do the same
10383  * here.
10384  */
10385  if (*newval < 1024)
10386  *newval = 1024;
10387 
10388  return true;
10389 }
#define newval
static bool check_bonjour ( bool newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10161 of file guc.c.

References GUC_check_errmsg.

10162 {
10163 #ifndef USE_BONJOUR
10164  if (*newval)
10165  {
10166  GUC_check_errmsg("Bonjour is not supported by this build");
10167  return false;
10168  }
10169 #endif
10170  return true;
10171 }
#define GUC_check_errmsg
Definition: guc.h:404
#define newval
static bool check_canonical_path ( char **  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10212 of file guc.c.

References canonicalize_path().

10213 {
10214  /*
10215  * Since canonicalize_path never enlarges the string, we can just modify
10216  * newval in-place. But watch out for NULL, which is the default value
10217  * for external_pid_file.
10218  */
10219  if (*newval)
10221  return true;
10222 }
void canonicalize_path(char *path)
Definition: path.c:254
#define newval
static bool check_cluster_name ( char **  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10481 of file guc.c.

10482 {
10483  /* Only allow clean ASCII chars in the cluster name */
10484  char *p;
10485 
10486  for (p = *newval; *p; p++)
10487  {
10488  if (*p < 32 || *p > 126)
10489  *p = '?';
10490  }
10491 
10492  return true;
10493 }
#define newval
static bool check_effective_io_concurrency ( int *  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10400 of file guc.c.

References ComputeIoConcurrency(), ERROR, guc_malloc(), and rint().

10401 {
10402 #ifdef USE_PREFETCH
10403  double new_prefetch_pages;
10404 
10405  if (ComputeIoConcurrency(*newval, &new_prefetch_pages))
10406  {
10407  int *myextra = (int *) guc_malloc(ERROR, sizeof(int));
10408 
10409  *myextra = (int) rint(new_prefetch_pages);
10410  *extra = (void *) myextra;
10411 
10412  return true;
10413  }
10414  else
10415  return false;
10416 #else
10417  return true;
10418 #endif /* USE_PREFETCH */
10419 }
bool ComputeIoConcurrency(int io_concurrency, double *target)
Definition: bufmgr.c:467
#define ERROR
Definition: elog.h:43
double rint(double x)
Definition: rint.c:22
#define newval
static void * guc_malloc(int elevel, size_t size)
Definition: guc.c:3985
static bool check_log_destination ( char **  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10053 of file guc.c.

References ERROR, GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG_DESTINATION_CSVLOG, LOG_DESTINATION_EVENTLOG, LOG_DESTINATION_STDERR, LOG_DESTINATION_SYSLOG, pfree(), pg_strcasecmp(), pstrdup(), and SplitIdentifierString().

10054 {
10055  char *rawstring;
10056  List *elemlist;
10057  ListCell *l;
10058  int newlogdest = 0;
10059  int *myextra;
10060 
10061  /* Need a modifiable copy of string */
10062  rawstring = pstrdup(*newval);
10063 
10064  /* Parse string into list of identifiers */
10065  if (!SplitIdentifierString(rawstring, ',', &elemlist))
10066  {
10067  /* syntax error in list */
10068  GUC_check_errdetail("List syntax is invalid.");
10069  pfree(rawstring);
10070  list_free(elemlist);
10071  return false;
10072  }
10073 
10074  foreach(l, elemlist)
10075  {
10076  char *tok = (char *) lfirst(l);
10077 
10078  if (pg_strcasecmp(tok, "stderr") == 0)
10079  newlogdest |= LOG_DESTINATION_STDERR;
10080  else if (pg_strcasecmp(tok, "csvlog") == 0)
10081  newlogdest |= LOG_DESTINATION_CSVLOG;
10082 #ifdef HAVE_SYSLOG
10083  else if (pg_strcasecmp(tok, "syslog") == 0)
10084  newlogdest |= LOG_DESTINATION_SYSLOG;
10085 #endif
10086 #ifdef WIN32
10087  else if (pg_strcasecmp(tok, "eventlog") == 0)
10088  newlogdest |= LOG_DESTINATION_EVENTLOG;
10089 #endif
10090  else
10091  {
10092  GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
10093  pfree(rawstring);
10094  list_free(elemlist);
10095  return false;
10096  }
10097  }
10098 
10099  pfree(rawstring);
10100  list_free(elemlist);
10101 
10102  myextra = (int *) guc_malloc(ERROR, sizeof(int));
10103  *myextra = newlogdest;
10104  *extra = (void *) myextra;
10105 
10106  return true;
10107 }
#define LOG_DESTINATION_EVENTLOG
Definition: elog.h:397
#define GUC_check_errdetail
Definition: guc.h:408
char * pstrdup(const char *in)
Definition: mcxt.c:1076
#define LOG_DESTINATION_SYSLOG
Definition: elog.h:396
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
void pfree(void *pointer)
Definition: mcxt.c:949
#define ERROR
Definition: elog.h:43
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
Definition: varlena.c:3264
#define LOG_DESTINATION_CSVLOG
Definition: elog.h:398
#define LOG_DESTINATION_STDERR
Definition: elog.h:395
#define lfirst(lc)
Definition: pg_list.h:106
#define newval
void list_free(List *list)
Definition: list.c:1133
static void * guc_malloc(int elevel, size_t size)
Definition: guc.c:3985
Definition: pg_list.h:45
static bool check_log_stats ( bool newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10198 of file guc.c.

References GUC_check_errdetail.

10199 {
10200  if (*newval &&
10202  {
10203  GUC_check_errdetail("Cannot enable \"log_statement_stats\" when "
10204  "\"log_parser_stats\", \"log_planner_stats\", "
10205  "or \"log_executor_stats\" is true.");
10206  return false;
10207  }
10208  return true;
10209 }
bool log_parser_stats
Definition: guc.c:438
#define GUC_check_errdetail
Definition: guc.h:408
#define newval
bool log_executor_stats
Definition: guc.c:440
bool log_planner_stats
Definition: guc.c:439
static bool check_max_worker_processes ( int *  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10392 of file guc.c.

References autovacuum_max_workers, MAX_BACKENDS, and MaxConnections.

10393 {
10395  return false;
10396  return true;
10397 }
#define MAX_BACKENDS
Definition: postmaster.h:75
int MaxConnections
Definition: globals.c:123
int autovacuum_max_workers
Definition: autovacuum.c:115
#define newval
static bool check_maxconnections ( int *  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10352 of file guc.c.

References autovacuum_max_workers, MAX_BACKENDS, and max_worker_processes.

10353 {
10354  if (*newval + autovacuum_max_workers + 1 +
10356  return false;
10357  return true;
10358 }
#define MAX_BACKENDS
Definition: postmaster.h:75
int autovacuum_max_workers
Definition: autovacuum.c:115
#define newval
int max_worker_processes
Definition: globals.c:124
static bool check_ssl ( bool newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10174 of file guc.c.

References GUC_check_errmsg.

10175 {
10176 #ifndef USE_SSL
10177  if (*newval)
10178  {
10179  GUC_check_errmsg("SSL is not supported by this build");
10180  return false;
10181  }
10182 #endif
10183  return true;
10184 }
#define GUC_check_errmsg
Definition: guc.h:404
#define newval
static bool check_stage_log_stats ( bool newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10187 of file guc.c.

References GUC_check_errdetail.

10188 {
10189  if (*newval && log_statement_stats)
10190  {
10191  GUC_check_errdetail("Cannot enable parameter when \"log_statement_stats\" is true.");
10192  return false;
10193  }
10194  return true;
10195 }
bool log_statement_stats
Definition: guc.c:441
#define GUC_check_errdetail
Definition: guc.h:408
#define newval
static bool check_temp_buffers ( int *  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10147 of file guc.c.

References GUC_check_errdetail, and NLocBuffer.

10148 {
10149  /*
10150  * Once local buffers have been initialized, it's too late to change this.
10151  */
10152  if (NLocBuffer && NLocBuffer != *newval)
10153  {
10154  GUC_check_errdetail("\"temp_buffers\" cannot be changed after any temporary tables have been accessed in the session.");
10155  return false;
10156  }
10157  return true;
10158 }
#define GUC_check_errdetail
Definition: guc.h:408
int NLocBuffer
Definition: localbuf.c:41
#define newval
static bool check_timezone_abbreviations ( char **  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 10225 of file guc.c.

References Assert, load_tzoffsets(), and PGC_S_DEFAULT.

10226 {
10227  /*
10228  * The boot_val given above for timezone_abbreviations is NULL. When we
10229  * see this we just do nothing. If this value isn't overridden from the
10230  * config file then pg_timezone_abbrev_initialize() will eventually
10231  * replace it with "Default". This hack has two purposes: to avoid
10232  * wasting cycles loading values that might soon be overridden from the
10233  * config file, and to avoid trying to read the timezone abbrev files
10234  * during InitializeGUCOptions(). The latter doesn't work in an
10235  * EXEC_BACKEND subprocess because my_exec_path hasn't been set yet and so
10236  * we can't locate PGSHAREDIR.
10237  */
10238  if (*newval == NULL)
10239  {
10241  return true;
10242  }
10243 
10244  /* OK, load the file and produce a malloc'd TimeZoneAbbrevTable */
10246 
10247  /* tzparser.c returns NULL on failure, reporting via GUC_check_errmsg */
10248  if (!*extra)
10249  return false;
10250 
10251  return true;
10252 }
GucSource source
Definition: guc_tables.h:155
TimeZoneAbbrevTable * load_tzoffsets(const char *filename)
Definition: tzparser.c:438
#define Assert(condition)
Definition: c.h:681
#define newval
static bool check_wal_consistency_checking ( char **  newval,
void **  extra,
GucSource  source 
)
static

Definition at line 9973 of file guc.c.

References ERROR, GUC_check_errdetail, guc_malloc(), lfirst, list_free(), MemSet, pfree(), pg_strcasecmp(), pstrdup(), RmgrData::rm_mask, RM_MAX_ID, RmgrTable, and SplitIdentifierString().

9974 {
9975  char *rawstring;
9976  List *elemlist;
9977  ListCell *l;
9978  bool newwalconsistency[RM_MAX_ID + 1];
9979 
9980  /* Initialize the array */
9981  MemSet(newwalconsistency, 0, (RM_MAX_ID + 1) * sizeof(bool));
9982 
9983  /* Need a modifiable copy of string */
9984  rawstring = pstrdup(*newval);
9985 
9986  /* Parse string into list of identifiers */
9987  if (!SplitIdentifierString(rawstring, ',', &elemlist))
9988  {
9989  /* syntax error in list */
9990  GUC_check_errdetail("List syntax is invalid.");
9991  pfree(rawstring);
9992  list_free(elemlist);
9993  return false;
9994  }
9995 
9996  foreach(l, elemlist)
9997  {
9998  char *tok = (char *) lfirst(l);
9999  bool found = false;
10000  RmgrId rmid;
10001 
10002  /* Check for 'all'. */
10003  if (pg_strcasecmp(tok, "all") == 0)
10004  {
10005  for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
10006  if (RmgrTable[rmid].rm_mask != NULL)
10007  newwalconsistency[rmid] = true;
10008  found = true;
10009  }
10010  else
10011  {
10012  /*
10013  * Check if the token matches with any individual resource
10014  * manager.
10015  */
10016  for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
10017  {
10018  if (pg_strcasecmp(tok, RmgrTable[rmid].rm_name) == 0 &&
10019  RmgrTable[rmid].rm_mask != NULL)
10020  {
10021  newwalconsistency[rmid] = true;
10022  found = true;
10023  }
10024  }
10025  }
10026 
10027  /* If a valid resource manager is found, check for the next one. */
10028  if (!found)
10029  {
10030  GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
10031  pfree(rawstring);
10032  list_free(elemlist);
10033  return false;
10034  }
10035  }
10036 
10037  pfree(rawstring);
10038  list_free(elemlist);
10039 
10040  /* assign new value */
10041  *extra = guc_malloc(ERROR, (RM_MAX_ID + 1) * sizeof(bool));
10042  memcpy(*extra, newwalconsistency, (RM_MAX_ID + 1) * sizeof(bool));
10043  return true;
10044 }
void(* rm_mask)(char *pagedata, BlockNumber blkno)
#define GUC_check_errdetail
Definition: guc.h:408
char * pstrdup(const char *in)
Definition: mcxt.c:1076
const RmgrData RmgrTable[RM_MAX_ID+1]
Definition: rmgr.c:36
#define MemSet(start, val, len)
Definition: c.h:863
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
void pfree(void *pointer)
Definition: mcxt.c:949
#define ERROR
Definition: elog.h:43
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
Definition: varlena.c:3264
#define RM_MAX_ID
Definition: rmgr.h:33
uint8 RmgrId
Definition: rmgr.h:11
#define lfirst(lc)
Definition: pg_list.h:106
#define newval
void list_free(List *list)
Definition: list.c:1133
static void * guc_malloc(int elevel, size_t size)
Definition: guc.c:3985
Definition: pg_list.h:45
static char* config_enum_get_options ( struct config_enum record,
const char *  prefix,
const char *  suffix,
const char *  separator 
)
static

Definition at line 5675 of file guc.c.

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

Referenced by GetConfigOptionByNum(), and parse_and_validate_value().

5677 {
5678  const struct config_enum_entry *entry;
5679  StringInfoData retstr;
5680  int seplen;
5681 
5682  initStringInfo(&retstr);
5683  appendStringInfoString(&retstr, prefix);
5684 
5685  seplen = strlen(separator);
5686  for (entry = record->options; entry && entry->name; entry++)
5687  {
5688  if (!entry->hidden)
5689  {
5690  appendStringInfoString(&retstr, entry->name);
5691  appendBinaryStringInfo(&retstr, separator, seplen);
5692  }
5693  }
5694 
5695  /*
5696  * All the entries may have been hidden, leaving the string empty if no
5697  * prefix was given. This indicates a broken GUC setup, since there is no
5698  * use for an enum without any values, so we just check to make sure we
5699  * don't write to invalid memory instead of actually trying to do
5700  * something smart with it.
5701  */
5702  if (retstr.len >= seplen)
5703  {
5704  /* Replace final separator */
5705  retstr.data[retstr.len - seplen] = '\0';
5706  retstr.len -= seplen;
5707  }
5708 
5709  appendStringInfoString(&retstr, suffix);
5710 
5711  return retstr.data;
5712 }
Definition: guc.h:164
const struct config_enum_entry * options
Definition: guc_tables.h:243
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:157
void initStringInfo(StringInfo str)
Definition: stringinfo.c:46
const char * name
Definition: guc.h:166
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:208
bool hidden
Definition: guc.h:168
bool config_enum_lookup_by_name ( struct config_enum record,
const char *  value,
int *  retval 
)

Definition at line 5649 of file guc.c.

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

Referenced by parse_and_validate_value().

5651 {
5652  const struct config_enum_entry *entry;
5653 
5654  for (entry = record->options; entry && entry->name; entry++)
5655  {
5656  if (pg_strcasecmp(value, entry->name) == 0)
5657  {
5658  *retval = entry->val;
5659  return TRUE;
5660  }
5661  }
5662 
5663  *retval = 0;
5664  return FALSE;
5665 }
Definition: guc.h:164
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
#define FALSE
Definition: c.h:219
static struct @121 value
const struct config_enum_entry * options
Definition: guc_tables.h:243
int val
Definition: guc.h:167
const char * name
Definition: guc.h:166
#define TRUE
Definition: c.h:215
const char* config_enum_lookup_by_value ( struct config_enum record,
int  val 
)

Definition at line 5626 of file guc.c.

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

Referenced by _ShowOption(), call_enum_check_hook(), estimate_variable_size(), GetConfigOption(), GetConfigOptionByNum(), GetConfigOptionResetString(), printMixedStruct(), and serialize_variable().

5627 {
5628  const struct config_enum_entry *entry;
5629 
5630  for (entry = record->options; entry && entry->name; entry++)
5631  {
5632  if (entry->val == val)
5633  return entry->name;
5634  }
5635 
5636  elog(ERROR, "could not find enum option %d for %s",
5637  val, record->gen.name);
5638  return NULL; /* silence compiler */
5639 }
Definition: guc.h:164
const char * name
Definition: guc_tables.h:146
#define ERROR
Definition: elog.h:43
const struct config_enum_entry * options
Definition: guc_tables.h:243
int val
Definition: guc.h:167
struct config_generic gen
Definition: guc_tables.h:239
const char * name
Definition: guc.h:166
#define elog
Definition: elog.h:219
long val
Definition: informix.c:689
static void convert_from_base_unit ( int64  base_value,
int  base_unit,
int64 *  value,
const char **  unit 
)
static

Definition at line 5454 of file guc.c.

References Assert, GUC_UNIT_MEMORY, i, memory_unit_conversion_table, unit_conversion::multiplier, time_unit_conversion_table, and unit_conversion::unit.

Referenced by _ShowOption().

5456 {
5457  const unit_conversion *table;
5458  int i;
5459 
5460  *unit = NULL;
5461 
5462  if (base_unit & GUC_UNIT_MEMORY)
5464  else
5466 
5467  for (i = 0; *table[i].unit; i++)
5468  {
5469  if (base_unit == table[i].base_unit)
5470  {
5471  /*
5472  * Accept the first conversion that divides the value evenly. We
5473  * assume that the conversions for each base unit are ordered from
5474  * greatest unit to the smallest!
5475  */
5476  if (table[i].multiplier < 0)
5477  {
5478  *value = base_value * (-table[i].multiplier);
5479  *unit = table[i].unit;
5480  break;
5481  }
5482  else if (base_value % table[i].multiplier == 0)
5483  {
5484  *value = base_value / table[i].multiplier;
5485  *unit = table[i].unit;
5486  break;
5487  }
5488  }
5489  }
5490 
5491  Assert(*unit != NULL);
5492 }
static const unit_conversion time_unit_conversion_table[]
Definition: guc.c:751
static const unit_conversion memory_unit_conversion_table[]
Definition: guc.c:719
static struct @121 value
#define Assert(condition)
Definition: c.h:681
int i
char unit[MAX_UNIT_LEN+1]
Definition: guc.c:701
#define GUC_UNIT_MEMORY
Definition: guc.h:223
int multiplier
Definition: guc.c:704
static bool convert_to_base_unit ( int64  value,
const char *  unit,
int  base_unit,
int64 *  base_value 
)
static

Definition at line 5421 of file guc.c.

References GUC_UNIT_MEMORY, i, memory_unit_conversion_table, unit_conversion::multiplier, time_unit_conversion_table, and unit_conversion::unit.

Referenced by parse_int().

5423 {
5424  const unit_conversion *table;
5425  int i;
5426 
5427  if (base_unit & GUC_UNIT_MEMORY)
5429  else
5431 
5432  for (i = 0; *table[i].unit; i++)
5433  {
5434  if (base_unit == table[i].base_unit &&
5435  strcmp(unit, table[i].unit) == 0)
5436  {
5437  if (table[i].multiplier < 0)
5438  *base_value = value / (-table[i].multiplier);
5439  else
5440  *base_value = value * table[i].multiplier;
5441  return true;
5442  }
5443  }
5444  return false;
5445 }
static const unit_conversion time_unit_conversion_table[]
Definition: guc.c:751
static const unit_conversion memory_unit_conversion_table[]
Definition: guc.c:719
static struct @121 value
int i
char unit[MAX_UNIT_LEN+1]
Definition: guc.c:701
#define GUC_UNIT_MEMORY
Definition: guc.h:223
int multiplier
Definition: guc.c:704
static void define_custom_variable ( struct config_generic variable)
static

Definition at line 7556 of file guc.c.

References add_guc_variable(), Assert, ereport, errcode(), errmsg(), ERROR, free, config_string::gen, GUC_ACTION_SET, GUC_CUSTOM_PLACEHOLDER, guc_var_compare(), InitializeOneGUCOption(), config_generic::name, name, PGC_STRING, reapply_stacked_values(), config_generic::reset_scontext, config_generic::reset_source, config_string::reset_val, config_generic::scontext, set_config_option(), set_config_sourcefile(), set_string_field(), config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_generic::stack, config_string::variable, and WARNING.

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

7557 {
7558  const char *name = variable->name;
7559  const char **nameAddr = &name;
7560  struct config_string *pHolder;
7561  struct config_generic **res;
7562 
7563  /*
7564  * See if there's a placeholder by the same name.
7565  */
7566  res = (struct config_generic **) bsearch((void *) &nameAddr,
7567  (void *) guc_variables,
7569  sizeof(struct config_generic *),
7570  guc_var_compare);
7571  if (res == NULL)
7572  {
7573  /*
7574  * No placeholder to replace, so we can just add it ... but first,
7575  * make sure it's initialized to its default value.
7576  */
7577  InitializeOneGUCOption(variable);
7578  add_guc_variable(variable, ERROR);
7579  return;
7580  }
7581 
7582  /*
7583  * This better be a placeholder
7584  */
7585  if (((*res)->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
7586  ereport(ERROR,
7587  (errcode(ERRCODE_INTERNAL_ERROR),
7588  errmsg("attempt to redefine parameter \"%s\"", name)));
7589 
7590  Assert((*res)->vartype == PGC_STRING);
7591  pHolder = (struct config_string *) (*res);
7592 
7593  /*
7594  * First, set the variable to its default value. We must do this even
7595  * though we intend to immediately apply a new value, since it's possible
7596  * that the new value is invalid.
7597  */
7598  InitializeOneGUCOption(variable);
7599 
7600  /*
7601  * Replace the placeholder. We aren't changing the name, so no re-sorting
7602  * is necessary
7603  */
7604  *res = variable;
7605 
7606  /*
7607  * Assign the string value(s) stored in the placeholder to the real
7608  * variable. Essentially, we need to duplicate all the active and stacked
7609  * values, but with appropriate validation and datatype adjustment.
7610  *
7611  * If an assignment fails, we report a WARNING and keep going. We don't
7612  * want to throw ERROR for bad values, because it'd bollix the add-on
7613  * module that's presumably halfway through getting loaded. In such cases
7614  * the default or previous state will become active instead.
7615  */
7616 
7617  /* First, apply the reset value if any */
7618  if (pHolder->reset_val)
7619  (void) set_config_option(name, pHolder->reset_val,
7620  pHolder->gen.reset_scontext,
7621  pHolder->gen.reset_source,
7622  GUC_ACTION_SET, true, WARNING, false);
7623  /* That should not have resulted in stacking anything */
7624  Assert(variable->stack == NULL);
7625 
7626  /* Now, apply current and stacked values, in the order they were stacked */
7627  reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
7628  *(pHolder->variable),
7629  pHolder->gen.scontext, pHolder->gen.source);
7630 
7631  /* Also copy over any saved source-location information */
7632  if (pHolder->gen.sourcefile)
7633  set_config_sourcefile(name, pHolder->gen.sourcefile,
7634  pHolder->gen.sourceline);
7635 
7636  /*
7637  * Free up as much as we conveniently can of the placeholder structure.
7638  * (This neglects any stack items, so it's possible for some memory to be
7639  * leaked. Since this can only happen once per session per variable, it
7640  * doesn't seem worth spending much code on.)
7641  */
7642  set_string_field(pHolder, pHolder->variable, NULL);
7643  set_string_field(pHolder, &pHolder->reset_val, NULL);
7644 
7645  free(pHolder);
7646 }
GucSource source
Definition: guc_tables.h:155
static void static void set_config_sourcefile(const char *name, char *sourcefile, int sourceline)
Definition: guc.c:6647
char ** variable
Definition: guc_tables.h:227
const char * name
Definition: guc_tables.h:146
static void reapply_stacked_values(struct config_generic *variable, struct config_string *pHolder, GucStack *stack, const char *curvalue, GucContext curscontext, GucSource cursource)
Definition: guc.c:7656
int errcode(int sqlerrcode)
Definition: elog.c:575
GucContext scontext
Definition: guc_tables.h:157
static int guc_var_compare(const void *a, const void *b)
Definition: guc.c:4430
#define ERROR
Definition: elog.h:43
static int num_guc_variables
Definition: guc.c:3947
char * sourcefile
Definition: guc_tables.h:161
GucSource reset_source
Definition: guc_tables.h:156
static void InitializeOneGUCOption(struct config_generic *gconf)
Definition: guc.c:4578
static void set_string_field(struct config_string *conf, char **field, char *newval)
Definition: guc.c:4057
#define ereport(elevel, rest)
Definition: elog.h:122
static struct config_generic ** guc_variables
Definition: guc.c:3944
#define WARNING
Definition: elog.h:40
struct config_generic gen
Definition: guc_tables.h:225
#define free(a)
Definition: header.h:65
char * reset_val
Definition: guc_tables.h:233
#define Assert(condition)
Definition: c.h:681
#define GUC_CUSTOM_PLACEHOLDER
Definition: guc.h:211
const char * name
Definition: encode.c:521
int errmsg(const char *fmt,...)
Definition: elog.c:797
GucStack * stack
Definition: guc_tables.h:159
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:5917
static bool add_guc_variable(struct config_generic *var, int elevel)
Definition: guc.c:4295
GucContext reset_scontext
Definition: guc_tables.h:158
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 7737 of file guc.c.

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

Referenced by _PG_init().

7747 {
7748  struct config_bool *var;
7749 
7750  var = (struct config_bool *)
7751  init_custom_variable(name, short_desc, long_desc, context, flags,
7752  PGC_BOOL, sizeof(struct config_bool));
7753  var->variable = valueAddr;
7754  var->boot_val = bootValue;
7755  var->reset_val = bootValue;
7756  var->check_hook = check_hook;
7757  var->assign_hook = assign_hook;
7758  var->show_hook = show_hook;
7759  define_custom_variable(&var->gen);
7760 }
bool * variable
Definition: guc_tables.h:181
GucBoolAssignHook assign_hook
Definition: guc_tables.h:184
bool boot_val
Definition: guc_tables.h:182
struct config_generic gen
Definition: guc_tables.h:179
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:7505
GucBoolCheckHook check_hook
Definition: guc_tables.h:183
GucShowHook show_hook
Definition: guc_tables.h:185
const char * name
Definition: encode.c:521
bool reset_val
Definition: guc_tables.h:187
static void define_custom_variable(struct config_generic *variable)
Definition: guc.c:7556
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 7848 of file guc.c.

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

Referenced by _PG_init().

7859 {
7860  struct config_enum *var;
7861 
7862  var = (struct config_enum *)
7863  init_custom_variable(name, short_desc, long_desc, context, flags,
7864  PGC_ENUM, sizeof(struct config_enum));
7865  var->variable = valueAddr;
7866  var->boot_val = bootValue;
7867  var->reset_val = bootValue;
7868  var->options = options;
7869  var->check_hook = check_hook;
7870  var->assign_hook = assign_hook;
7871  var->show_hook = show_hook;
7872  define_custom_variable(&var->gen);
7873 }
GucEnumCheckHook check_hook
Definition: guc_tables.h:244
GucEnumAssignHook assign_hook
Definition: guc_tables.h:245
int * variable
Definition: guc_tables.h:241
const struct config_enum_entry * options
Definition: guc_tables.h:243
static char ** options
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:7505
GucShowHook show_hook
Definition: guc_tables.h:246
struct config_generic gen
Definition: guc_tables.h:239
const char * name
Definition: encode.c:521
static void define_custom_variable(struct config_generic *variable)
Definition: guc.c:7556
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 7763 of file guc.c.

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

Referenced by _PG_init().

7775 {
7776  struct config_int *var;
7777 
7778  var = (struct config_int *)
7779  init_custom_variable(name, short_desc, long_desc, context, flags,
7780  PGC_INT, sizeof(struct config_int));
7781  var->variable = valueAddr;
7782  var->boot_val = bootValue;
7783  var->reset_val = bootValue;
7784  var->min = minValue;
7785  var->max = maxValue;
7786  var->check_hook = check_hook;
7787  var->assign_hook = assign_hook;
7788  var->show_hook = show_hook;
7789  define_custom_variable(&var->gen);
7790 }
int boot_val
Definition: guc_tables.h:196
GucIntAssignHook assign_hook
Definition: guc_tables.h:200
GucIntCheckHook check_hook
Definition: guc_tables.h:199
GucShowHook show_hook
Definition: guc_tables.h:201
int * variable
Definition: guc_tables.h:195
struct config_generic gen
Definition: guc_tables.h:193
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:7505
const char * name
Definition: encode.c:521
static void define_custom_variable(struct config_generic *variable)
Definition: guc.c:7556
int reset_val
Definition: guc_tables.h:203
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 7793 of file guc.c.

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

Referenced by _PG_init().

7805 {
7806  struct config_real *var;
7807 
7808  var = (struct config_real *)
7809  init_custom_variable(name, short_desc, long_desc, context, flags,
7810  PGC_REAL, sizeof(struct config_real));
7811  var->variable = valueAddr;
7812  var->boot_val = bootValue;
7813  var->reset_val = bootValue;
7814  var->min = minValue;
7815  var->max = maxValue;
7816  var->check_hook = check_hook;
7817  var->assign_hook = assign_hook;
7818  var->show_hook = show_hook;
7819  define_custom_variable(&var->gen);
7820 }
GucRealAssignHook assign_hook
Definition: guc_tables.h:216
double reset_val
Definition: guc_tables.h:219
GucRealCheckHook check_hook
Definition: guc_tables.h:215
GucShowHook show_hook
Definition: guc_tables.h:217
double * variable
Definition: guc_tables.h:211
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:7505
double max
Definition: guc_tables.h:214
double boot_val
Definition: guc_tables.h:212
const char * name
Definition: encode.c:521
double min
Definition: guc_tables.h:213
static void define_custom_variable(struct config_generic *variable)
Definition: guc.c:7556
struct config_generic gen
Definition: guc_tables.h:209
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 7823 of file guc.c.

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

Referenced by _PG_init().

7833 {
7834  struct config_string *var;
7835 
7836  var = (struct config_string *)
7837  init_custom_variable(name, short_desc, long_desc, context, flags,
7838  PGC_STRING, sizeof(struct config_string));
7839  var->variable = valueAddr;
7840  var->boot_val = bootValue;
7841  var->check_hook = check_hook;
7842  var->assign_hook = assign_hook;
7843  var->show_hook = show_hook;
7844  define_custom_variable(&var->gen);
7845 }
char ** variable
Definition: guc_tables.h:227
GucStringCheckHook check_hook
Definition: guc_tables.h:229
const char * boot_val
Definition: guc_tables.h:228
GucShowHook show_hook
Definition: guc_tables.h:231
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:7505
struct config_generic gen
Definition: guc_tables.h:225
GucStringAssignHook assign_hook
Definition: guc_tables.h:230
const char * name
Definition: encode.c:521
static void define_custom_variable(struct config_generic *variable)
Definition: guc.c:7556
static void discard_stack_value ( struct config_generic gconf,
config_var_value val 
)
static

Definition at line 4172 of file guc.c.

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

Referenced by AtEOXact_GUC(), and push_old_value().

4173 {
4174  switch (gconf->vartype)
4175  {
4176  case PGC_BOOL:
4177  case PGC_INT:
4178  case PGC_REAL:
4179  case PGC_ENUM:
4180  /* no need to do anything */
4181  break;
4182  case PGC_STRING:
4183  set_string_field((struct config_string *) gconf,
4184  &(val->val.stringval),
4185  NULL);
4186  break;
4187  }
4188  set_extra_field(gconf, &(val->extra), NULL);
4189 }
union config_var_val val
Definition: guc_tables.h:46
static void set_extra_field(struct config_generic *gconf, void **field, void *newval)
Definition: guc.c:4118
static void set_string_field(struct config_string *conf, char **field, char *newval)
Definition: guc.c:4057
enum config_type vartype
Definition: guc_tables.h:153
char * stringval
Definition: guc_tables.h:36
static void do_serialize ( char **  destptr,
Size maxbytes,
const char *  fmt,
  ... 
)
static

Definition at line 9125 of file guc.c.

References elog, ERROR, and vsnprintf().

Referenced by serialize_variable().

9126 {
9127  va_list vargs;
9128  int n;
9129 
9130  if (*maxbytes <= 0)
9131  elog(ERROR, "not enough space to serialize GUC state");
9132 
9133  va_start(vargs, fmt);
9134  n = vsnprintf(*destptr, *maxbytes, fmt, vargs);
9135  va_end(vargs);
9136 
9137  /*
9138  * Cater to portability hazards in the vsnprintf() return value just like
9139  * appendPQExpBufferVA() does. Note that this requires an extra byte of
9140  * slack at the end of the buffer. Since serialize_variable() ends with a
9141  * do_serialize_binary() rather than a do_serialize(), we'll always have
9142  * that slack; estimate_variable_size() need not add a byte for it.
9143  */
9144  if (n < 0 || n >= *maxbytes - 1)
9145  {
9146  if (n < 0 && errno != 0 && errno != ENOMEM)
9147  /* Shouldn't happen. Better show errno description. */
9148  elog(ERROR, "vsnprintf failed: %m");
9149  else
9150  elog(ERROR, "not enough space to serialize GUC state");
9151  }
9152 
9153  /* Shift the destptr ahead of the null terminator */
9154  *destptr += n + 1;
9155  *maxbytes -= n + 1;
9156 }
int int vsnprintf(char *str, size_t count, const char *fmt, va_list args)
#define ERROR
Definition: elog.h:43
#define elog
Definition: elog.h:219
static void do_serialize_binary ( char **  destptr,
Size maxbytes,
void *  val,
Size  valsize 
)
static

Definition at line 9160 of file guc.c.

References elog, and ERROR.

Referenced by serialize_variable().

9161 {
9162  if (valsize > *maxbytes)
9163  elog(ERROR, "not enough space to serialize GUC state");
9164 
9165  memcpy(*destptr, val, valsize);
9166  *destptr += valsize;
9167  *maxbytes -= valsize;
9168 }
#define ERROR
Definition: elog.h:43
#define elog
Definition: elog.h:219
long val
Definition: informix.c:689
void EmitWarningsOnPlaceholders ( const char *  className)

Definition at line 7876 of file guc.c.

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

Referenced by _PG_init().

7877 {
7878  int classLen = strlen(className);
7879  int i;
7880 
7881  for (i = 0; i < num_guc_variables; i++)
7882  {
7883  struct config_generic *var = guc_variables[i];
7884 
7885  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
7886  strncmp(className, var->name, classLen) == 0 &&
7887  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
7888  {
7889  ereport(WARNING,
7890  (errcode(ERRCODE_UNDEFINED_OBJECT),
7891  errmsg("unrecognized configuration parameter \"%s\"",
7892  var->name)));
7893  }
7894  }
7895 }
const char * name
Definition: guc_tables.h:146
int errcode(int sqlerrcode)
Definition: elog.c:575
#define GUC_QUALIFIER_SEPARATOR
Definition: guc.h:199
static int num_guc_variables
Definition: guc.c:3947
#define ereport(elevel, rest)
Definition: elog.h:122
static struct config_generic ** guc_variables
Definition: guc.c:3944
#define WARNING
Definition: elog.h:40
#define GUC_CUSTOM_PLACEHOLDER
Definition: guc.h:211
int errmsg(const char *fmt,...)
Definition: elog.c:797
int i
static Size estimate_variable_size ( struct config_generic gconf)
static

Definition at line 9004 of file guc.c.

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

Referenced by EstimateGUCStateSpace().

9005 {
9006  Size size;
9007  Size valsize = 0;
9008 
9009  if (can_skip_gucvar(gconf))
9010  return 0;
9011 
9012  /* Name, plus trailing zero byte. */
9013  size = strlen(gconf->name) + 1;
9014 
9015  /* Get the maximum display length of the GUC value. */
9016  switch (gconf->vartype)
9017  {
9018  case PGC_BOOL:
9019  {
9020  valsize = 5; /* max(strlen('true'), strlen('false')) */
9021  }
9022  break;
9023 
9024  case PGC_INT:
9025  {
9026  struct config_int *conf = (struct config_int *) gconf;
9027 
9028  /*
9029  * Instead of getting the exact display length, use max
9030  * length. Also reduce the max length for typical ranges of
9031  * small values. Maximum value is 2147483647, i.e. 10 chars.
9032  * Include one byte for sign.
9033  */
9034  if (Abs(*conf->variable) < 1000)
9035  valsize = 3 + 1;
9036  else
9037  valsize = 10 + 1;
9038  }
9039  break;
9040 
9041  case PGC_REAL:
9042  {
9043  /*
9044  * We are going to print it with %e with REALTYPE_PRECISION
9045  * fractional digits. Account for sign, leading digit,
9046  * decimal point, and exponent with up to 3 digits. E.g.
9047  * -3.99329042340000021e+110
9048  */
9049  valsize = 1 + 1 + 1 + REALTYPE_PRECISION + 5;
9050  }
9051  break;
9052 
9053  case PGC_STRING:
9054  {
9055  struct config_string *conf = (struct config_string *) gconf;
9056 
9057  /*
9058  * If the value is NULL, we transmit it as an empty string.
9059  * Although this is not physically the same value, GUC
9060  * generally treats a NULL the same as empty string.
9061  */
9062  if (*conf->variable)
9063  valsize = strlen(*conf->variable);
9064  else
9065  valsize = 0;
9066  }
9067  break;
9068 
9069  case PGC_ENUM:
9070  {
9071  struct config_enum *conf = (struct config_enum *) gconf;
9072 
9073  valsize = strlen(config_enum_lookup_by_value(conf, *conf->variable));
9074  }
9075  break;
9076  }
9077 
9078  /* Allow space for terminating zero-byte for value */
9079  size = add_size(size, valsize + 1);
9080 
9081  if (gconf->sourcefile)
9082  size = add_size(size, strlen(gconf->sourcefile));
9083 
9084  /* Allow space for terminating zero-byte for sourcefile */
9085  size = add_size(size, 1);
9086 
9087  /* Include line whenever file is nonempty. */
9088  if (gconf->sourcefile && gconf->sourcefile[0])
9089  size = add_size(size, sizeof(gconf->sourceline));
9090 
9091  size = add_size(size, sizeof(gconf->source));
9092  size = add_size(size, sizeof(gconf->scontext));
9093 
9094  return size;
9095 }
GucSource source
Definition: guc_tables.h:155
char ** variable
Definition: guc_tables.h:227
const char * name
Definition: guc_tables.h:146
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:5626
GucContext scontext
Definition: guc_tables.h:157
#define Abs(x)
Definition: c.h:818
int * variable
Definition: guc_tables.h:195
int * variable
Definition: guc_tables.h:241
char * sourcefile
Definition: guc_tables.h:161
static bool can_skip_gucvar(struct config_generic *gconf)
Definition: guc.c:8991
#define REALTYPE_PRECISION
Definition: guc.c:110
enum config_type vartype
Definition: guc_tables.h:153
Size add_size(Size s1, Size s2)
Definition: shmem.c:475
size_t Size
Definition: c.h:350
Size EstimateGUCStateSpace ( void  )

Definition at line 9102 of file guc.c.

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

Referenced by InitializeParallelDSM().

9103 {
9104  Size size;
9105  int i;
9106 
9107  /* Add space reqd for saving the data size of the guc state */
9108  size = sizeof(Size);
9109 
9110  /* Add up the space needed for each GUC variable */
9111  for (i = 0; i < num_guc_variables; i++)
9112  size = add_size(size,
9114 
9115  return size;
9116 }
static int num_guc_variables
Definition: guc.c:3947
static struct config_generic ** guc_variables
Definition: guc.c:3944
Size add_size(Size s1, Size s2)
Definition: shmem.c:475
size_t Size
Definition: c.h:350
static Size estimate_variable_size(struct config_generic *gconf)
Definition: guc.c:9004
int i
void ExecSetVariableStmt ( VariableSetStmt stmt,
bool  isTopLevel 
)

Definition at line 7293 of file guc.c.

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

Referenced by standard_ProcessUtility().

7294 {
7296 
7297  /*
7298  * Workers synchronize these parameters at the start of the parallel
7299  * operation; then, we block SET during the operation.
7300  */
7301  if (IsInParallelMode())
7302  ereport(ERROR,
7303  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
7304  errmsg("cannot set parameters during a parallel operation")));
7305 
7306  switch (stmt->kind)
7307  {
7308  case VAR_SET_VALUE:
7309  case VAR_SET_CURRENT:
7310  if (stmt->is_local)
7311  WarnNoTransactionChain(isTopLevel, "SET LOCAL");
7312  (void) set_config_option(stmt->name,
7313  ExtractSetVariableArgs(stmt),
7315  PGC_S_SESSION,
7316  action, true, 0, false);
7317  break;
7318  case VAR_SET_MULTI:
7319 
7320  /*
7321  * Special-case SQL syntaxes. The TRANSACTION and SESSION
7322  * CHARACTERISTICS cases effectively set more than one variable
7323  * per statement. TRANSACTION SNAPSHOT only takes one argument,
7324  * but we put it here anyway since it's a special case and not
7325  * related to any GUC variable.
7326  */
7327  if (strcmp(stmt->name, "TRANSACTION") == 0)
7328  {
7329  ListCell *head;
7330 
7331  WarnNoTransactionChain(isTopLevel, "SET TRANSACTION");
7332 
7333  foreach(head, stmt->args)
7334  {
7335  DefElem *item = (DefElem *) lfirst(head);
7336 
7337  if (strcmp(item->defname, "transaction_isolation") == 0)
7338  SetPGVariable("transaction_isolation",
7339  list_make1(item->arg), stmt->is_local);
7340  else if (strcmp(item->defname, "transaction_read_only") == 0)
7341  SetPGVariable("transaction_read_only",
7342  list_make1(item->arg), stmt->is_local);
7343  else if (strcmp(item->defname, "transaction_deferrable") == 0)
7344  SetPGVariable("transaction_deferrable",
7345  list_make1(item->arg), stmt->is_local);
7346  else
7347  elog(ERROR, "unexpected SET TRANSACTION element: %s",
7348  item->defname);
7349  }
7350  }
7351  else if (strcmp(stmt->name, "SESSION CHARACTERISTICS") == 0)
7352  {
7353  ListCell *head;
7354 
7355  foreach(head, stmt->args)
7356  {
7357  DefElem *item = (DefElem *) lfirst(head);
7358 
7359  if (strcmp(item->defname, "transaction_isolation") == 0)
7360  SetPGVariable("default_transaction_isolation",
7361  list_make1(item->arg), stmt->is_local);
7362  else if (strcmp(item->defname, "transaction_read_only") == 0)
7363  SetPGVariable("default_transaction_read_only",
7364  list_make1(item->arg), stmt->is_local);
7365  else if (strcmp(item->defname, "transaction_deferrable") == 0)
7366  SetPGVariable("default_transaction_deferrable",
7367  list_make1(item->arg), stmt->is_local);
7368  else
7369  elog(ERROR, "unexpected SET SESSION element: %s",
7370  item->defname);
7371  }
7372  }
7373  else if (strcmp(stmt->name, "TRANSACTION SNAPSHOT") == 0)
7374  {
7375  A_Const *con = linitial_node(A_Const, stmt->args);
7376 
7377  if (stmt->is_local)
7378  ereport(ERROR,
7379  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
7380  errmsg("SET LOCAL TRANSACTION SNAPSHOT is not implemented")));
7381 
7382  WarnNoTransactionChain(isTopLevel, "SET TRANSACTION");
7383  Assert(nodeTag(&con->val) == T_String);
7384  ImportSnapshot(strVal(&con->val));
7385  }
7386  else
7387  elog(ERROR, "unexpected SET MULTI element: %s",
7388  stmt->name);
7389  break;
7390  case VAR_SET_DEFAULT:
7391  if (stmt->is_local)
7392  WarnNoTransactionChain(isTopLevel, "SET LOCAL");
7393  /* fall through */
7394  case VAR_RESET:
7395  if (strcmp(stmt->name, "transaction_isolation") == 0)
7396  WarnNoTransactionChain(isTopLevel, "RESET TRANSACTION");
7397 
7398  (void) set_config_option(stmt->name,
7399  NULL,
7401  PGC_S_SESSION,
7402  action, true, 0, false);
7403  break;
7404  case VAR_RESET_ALL:
7405  ResetAllOptions();
7406  break;
7407  }
7408 }
void ImportSnapshot(const char *idstr)
Definition: snapmgr.c:1430
VariableSetKind kind
Definition: parsenodes.h:1973
#define strVal(v)
Definition: value.h:54
int errcode(int sqlerrcode)
Definition: elog.c:575
bool superuser(void)
Definition: superuser.c:47
#define linitial_node(type, l)
Definition: pg_list.h:114
GucAction
Definition: guc.h:191
#define list_make1(x1)
Definition: pg_list.h:139
bool IsInParallelMode(void)
Definition: xact.c:906
#define ERROR
Definition: elog.h:43
Definition: guc.h:75
void ResetAllOptions(void)
Definition: guc.c:4873
#define ereport(elevel, rest)
Definition: elog.h:122
Node * arg
Definition: parsenodes.h:720
void WarnNoTransactionChain(bool isTopLevel, const char *stmtType)
Definition: xact.c:3200
#define Assert(condition)
Definition: c.h:681
#define lfirst(lc)
Definition: pg_list.h:106
#define nodeTag(nodeptr)
Definition: nodes.h:515
int errmsg(const char *fmt,...)
Definition: elog.c:797
char * defname
Definition: parsenodes.h:719
#define elog
Definition: elog.h:219
char * ExtractSetVariableArgs(VariableSetStmt *stmt)
Definition: guc.c:7417
Value val
Definition: parsenodes.h:287
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:5917
void SetPGVariable(const char *name, List *args, bool is_local)
Definition: guc.c:7437
static bool extra_field_used ( struct config_generic gconf,
void *  extra 
)
static

Definition at line 4073 of file guc.c.

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

4074 {
4075  GucStack *stack;
4076 
4077  if (extra == gconf->extra)
4078  return true;
4079  switch (gconf->vartype)
4080  {
4081  case PGC_BOOL:
4082  if (extra == ((struct config_bool *) gconf)->reset_extra)
4083  return true;
4084  break;
4085  case PGC_INT:
4086  if (extra == ((struct config_int *) gconf)->reset_extra)
4087  return true;
4088  break;
4089  case PGC_REAL:
4090  if (extra == ((struct config_real *) gconf)->reset_extra)
4091  return true;
4092  break;
4093  case PGC_STRING:
4094  if (extra == ((struct config_string *) gconf)->reset_extra)
4095  return true;
4096  break;
4097  case PGC_ENUM:
4098  if (extra == ((struct config_enum *) gconf)->reset_extra)
4099  return true;
4100  break;
4101  }
4102  for (stack = gconf->stack; stack; stack = stack->prev)
4103  {
4104  if (extra == stack->prior.extra ||
4105  extra == stack->masked.extra)
4106  return true;
4107  }
4108 
4109  return false;
4110 }
struct guc_stack * prev
Definition: guc_tables.h:120
config_var_value masked
Definition: guc_tables.h:128
void * reset_extra
Definition: guc_tables.h:249
enum config_type vartype
Definition: guc_tables.h:153
GucStack * stack
Definition: guc_tables.h:159
config_var_value prior
Definition: guc_tables.h:127
char* ExtractSetVariableArgs ( VariableSetStmt stmt)

Definition at line 7417 of file guc.c.

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

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

7418 {
7419  switch (stmt->kind)
7420  {
7421  case VAR_SET_VALUE:
7422  return flatten_set_variable_args(stmt->name, stmt->args);
7423  case VAR_SET_CURRENT:
7424  return GetConfigOptionByName(stmt->name, NULL, false);
7425  default:
7426  return NULL;
7427  }
7428 }
VariableSetKind kind
Definition: parsenodes.h:1973
char * GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
Definition: guc.c:8043
static char * flatten_set_variable_args(const char *name, List *args)
Definition: guc.c:6816
static struct config_generic* find_option ( const char *  name,
bool  create_placeholders,
int  elevel 
)
static

Definition at line 4381 of file guc.c.

References add_placeholder_variable(), Assert, guc_name_compare(), GUC_QUALIFIER_SEPARATOR, guc_var_compare(), i, and name.

Referenced by AlterSystemSetConfigFile(), flatten_set_variable_args(), GetConfigOption(), GetConfigOptionByName(), GetConfigOptionResetString(), GUCArrayAdd(), GUCArrayDelete(), set_config_option(), set_config_sourcefile(), and validate_option_array_item().

4382 {
4383  const char **key = &name;
4384  struct config_generic **res;
4385  int i;
4386 
4387  Assert(name);
4388 
4389  /*
4390  * By equating const char ** with struct config_generic *, we are assuming
4391  * the name field is first in config_generic.
4392  */
4393  res = (struct config_generic **) bsearch((void *) &key,
4394  (void *) guc_variables,
4396  sizeof(struct config_generic *),
4397  guc_var_compare);
4398  if (res)
4399  return *res;
4400 
4401  /*
4402  * See if the name is an obsolete name for a variable. We assume that the
4403  * set of supported old names is short enough that a brute-force search is
4404  * the best way.
4405  */
4406  for (i = 0; map_old_guc_names[i] != NULL; i += 2)
4407  {
4408  if (guc_name_compare(name, map_old_guc_names[i]) == 0)
4409  return find_option(map_old_guc_names[i + 1], false, elevel);
4410  }
4411 
4412  if (create_placeholders)
4413  {
4414  /*
4415  * Check if the name is qualified, and if so, add a placeholder.
4416  */
4417  if (strchr(name, GUC_QUALIFIER_SEPARATOR) != NULL)
4419  }
4420 
4421  /* Unknown name */
4422  return NULL;
4423 }
#define GUC_QUALIFIER_SEPARATOR
Definition: guc.h:199
static int guc_name_compare(const char *namea, const char *nameb)
Definition: guc.c:4442
static int guc_var_compare(const void *a, const void *b)
Definition: guc.c:4430
static int num_guc_variables
Definition: guc.c:3947
static struct config_generic ** guc_variables
Definition: guc.c:3944
static int elevel
Definition: vacuumlazy.c:136
static const char *const map_old_guc_names[]
Definition: guc.c:3934
static struct config_generic * find_option(const char *name, bool create_placeholders, int elevel)
Definition: guc.c:4381
#define Assert(condition)
Definition: c.h:681
const char * name
Definition: encode.c:521
static struct config_generic * add_placeholder_variable(const char *name, int elevel)
Definition: guc.c:4333
int i
static char* flatten_set_variable_args ( const char *  name,
List args 
)
static

Definition at line 6816 of file guc.c.

References appendStringInfo(), appendStringInfoString(), arg, TypeCast::arg, Assert, buf, CStringGetDatum, StringInfoData::data, DatumGetCString, DirectFunctionCall1, DirectFunctionCall3, elog, ereport, errcode(), errmsg(), ERROR, find_option(), config_generic::flags, GUC_LIST_INPUT, GUC_LIST_QUOTE, initStringInfo(), Int32GetDatum, interval_in(), interval_out(), INTERVALOID, intVal, InvalidOid, IsA, lfirst, list_head(), list_length(), NIL, nodeTag, ObjectIdGetDatum, quote_identifier(), strVal, T_Float, T_Integer, T_String, TypeCast::typeName, typenameTypeIdAndMod(), A_Const::val, val, and WARNING.

Referenced by ExtractSetVariableArgs(), and SetPGVariable().

6817 {
6818  struct config_generic *record;
6819  int flags;
6821  ListCell *l;
6822 
6823  /* Fast path if just DEFAULT */
6824  if (args == NIL)
6825  return NULL;
6826 
6827  /*
6828  * Get flags for the variable; if it's not known, use default flags.
6829  * (Caller might throw error later, but not our business to do so here.)
6830  */
6831  record = find_option(name, false, WARNING);
6832  if (record)
6833  flags = record->flags;
6834  else
6835  flags = 0;
6836 
6837  /* Complain if list input and non-list variable */
6838  if ((flags & GUC_LIST_INPUT) == 0 &&
6839  list_length(args) != 1)
6840  ereport(ERROR,
6841  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6842  errmsg("SET %s takes only one argument", name)));
6843 
6844  initStringInfo(&buf);
6845 
6846  /*
6847  * Each list member may be a plain A_Const node, or an A_Const within a
6848  * TypeCast; the latter case is supported only for ConstInterval arguments
6849  * (for SET TIME ZONE).
6850  */
6851  foreach(l, args)
6852  {
6853  Node *arg = (Node *) lfirst(l);
6854  char *val;
6855  TypeName *typeName = NULL;
6856  A_Const *con;
6857 
6858  if (l != list_head(args))
6859  appendStringInfoString(&buf, ", ");
6860 
6861  if (IsA(arg, TypeCast))
6862  {
6863  TypeCast *tc = (TypeCast *) arg;
6864 
6865  arg = tc->arg;
6866  typeName = tc->typeName;
6867  }
6868 
6869  if (!IsA(arg, A_Const))
6870  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(arg));
6871  con = (A_Const *) arg;
6872 
6873  switch (nodeTag(&con->val))
6874  {
6875  case T_Integer:
6876  appendStringInfo(&buf, "%ld", intVal(&con->val));
6877  break;
6878  case T_Float:
6879  /* represented as a string, so just copy it */
6880  appendStringInfoString(&buf, strVal(&con->val));
6881  break;
6882  case T_String:
6883  val = strVal(&con->val);
6884  if (typeName != NULL)
6885  {
6886  /*
6887  * Must be a ConstInterval argument for TIME ZONE. Coerce
6888  * to interval and back to normalize the value and account
6889  * for any typmod.
6890  */
6891  Oid typoid;
6892  int32 typmod;
6893  Datum interval;
6894  char *intervalout;
6895 
6896  typenameTypeIdAndMod(NULL, typeName, &typoid, &typmod);
6897  Assert(typoid == INTERVALOID);
6898 
6899  interval =
6901  CStringGetDatum(val),
6903  Int32GetDatum(typmod));
6904 
6905  intervalout =
6907  interval));
6908  appendStringInfo(&buf, "INTERVAL '%s'", intervalout);
6909  }
6910  else
6911  {
6912  /*
6913  * Plain string literal or identifier. For quote mode,
6914  * quote it if it's not a vanilla identifier.
6915  */
6916  if (flags & GUC_LIST_QUOTE)
6918  else
6919  appendStringInfoString(&buf, val);
6920  }
6921  break;
6922  default:
6923  elog(ERROR, "unrecognized node type: %d",
6924  (int) nodeTag(&con->val));
6925  break;
6926  }
6927  }
6928 
6929  return buf.data;
6930 }
#define NIL
Definition: pg_list.h:69
#define IsA(nodeptr, _type_)
Definition: nodes.h:561
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:10390
Datum interval_in(PG_FUNCTION_ARGS)
Definition: timestamp.c:876
#define GUC_LIST_QUOTE
Definition: guc.h:205
Definition: nodes.h:510
#define strVal(v)
Definition: value.h:54
int errcode(int sqlerrcode)
Definition: elog.c:575
Datum interval_out(PG_FUNCTION_ARGS)
Definition: timestamp.c:958
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:585
unsigned int Oid
Definition: postgres_ext.h:31
signed int int32
Definition: c.h:246
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:78
#define ObjectIdGetDatum(X)
Definition: postgres.h:513
#define ERROR
Definition: elog.h:43
#define DatumGetCString(X)
Definition: postgres.h:572
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:157
static char * buf
Definition: pg_test_fsync.c:67
#define CStringGetDatum(X)
Definition: postgres.h:584
#define INTERVALOID
Definition: pg_type.h:529
static ListCell * list_head(const List *l)
Definition: pg_list.h:77
#define ereport(elevel, rest)
Definition: elog.h:122
#define DirectFunctionCall3(func, arg1, arg2, arg3)
Definition: fmgr.h:589
void initStringInfo(StringInfo str)
Definition: stringinfo.c:46
#define WARNING
Definition: elog.h:40
uintptr_t Datum
Definition: postgres.h:372
TypeName * typeName
Definition: parsenodes.h:298
void typenameTypeIdAndMod(ParseState *pstate, const TypeName *typeName, Oid *typeid_p, int32 *typmod_p)
Definition: parse_type.c:293
#define InvalidOid
Definition: postgres_ext.h:36
static struct config_generic * find_option(const char *name, bool create_placeholders, int elevel)
Definition: guc.c:4381
#define Assert(condition)
Definition: c.h:681
#define lfirst(lc)
Definition: pg_list.h:106
static int list_length(const List *l)
Definition: pg_list.h:89
const char * name
Definition: encode.c:521
#define nodeTag(nodeptr)
Definition: nodes.h:515
Definition: nodes.h:283
#define Int32GetDatum(X)
Definition: postgres.h:485
#define intVal(v)
Definition: value.h:52
int errmsg(const char *fmt,...)
Definition: elog.c:797
void * arg
#define elog
Definition: elog.h:219
Value val
Definition: parsenodes.h:287
long val
Definition: informix.c:689
#define GUC_LIST_INPUT
Definition: guc.h:204
Node * arg
Definition: parsenodes.h:297
struct config_generic** get_guc_variables ( void  )

Definition at line 4196 of file guc.c.

References guc_variables.

Referenced by GucInfoMain().

4197 {
4198  return guc_variables;
4199 }
static struct config_generic ** guc_variables
Definition: guc.c:3944
const char* GetConfigOption ( const char *  name,
bool  missing_ok,
bool  restrict_superuser 
)

Definition at line 6705 of file guc.c.

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

Referenced by applyRemoteGucs(), and PostmasterMain().

6706 {
6707  struct config_generic *record;
6708  static char buffer[256];
6709 
6710  record = find_option(name, false, ERROR);
6711  if (record == NULL)
6712  {
6713  if (missing_ok)
6714  return NULL;
6715  ereport(ERROR,
6716  (errcode(ERRCODE_UNDEFINED_OBJECT),
6717  errmsg("unrecognized configuration parameter \"%s\"",
6718  name)));
6719  }
6720  if (restrict_superuser &&
6721  (record->flags & GUC_SUPERUSER_ONLY) &&
6723  ereport(ERROR,
6724  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
6725  errmsg("must be superuser or a member of pg_read_all_settings to examine \"%s\"",
6726  name)));
6727 
6728  switch (record->vartype)
6729  {
6730  case PGC_BOOL:
6731  return *((struct config_bool *) record)->variable ? "on" : "off";
6732 
6733  case PGC_INT:
6734  snprintf(buffer, sizeof(buffer), "%d",
6735  *((struct config_int *) record)->variable);
6736  return buffer;
6737 
6738  case PGC_REAL:
6739  snprintf(buffer, sizeof(buffer), "%g",
6740  *((struct config_real *) record)->variable);
6741  return buffer;
6742 
6743  case PGC_STRING:
6744  return *((struct config_string *) record)->variable;
6745 
6746  case PGC_ENUM:
6747  return config_enum_lookup_by_value((struct config_enum *) record,
6748  *((struct config_enum *) record)->variable);
6749  }
6750  return NULL;
6751 }
Oid GetUserId(void)
Definition: miscinit.c:284
int errcode(int sqlerrcode)
Definition: elog.c:575
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:5626
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
enum config_type vartype
Definition: guc_tables.h:153
#define GUC_SUPERUSER_ONLY
Definition: guc.h:212
bool is_member_of_role(Oid member, Oid role)
Definition: acl.c:4854
#define DEFAULT_ROLE_READ_ALL_SETTINGS
Definition: pg_authid.h:106
static struct config_generic * find_option(const char *name, bool create_placeholders, int elevel)
Definition: guc.c:4381
WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE]
Definition: walsender.c:214
const char * name
Definition: encode.c:521
int errmsg(const char *fmt,...)
Definition: elog.c:797
char* GetConfigOptionByName ( const char *  name,
const char **  varname,
bool  missing_ok 
)

Definition at line 8043 of file guc.c.

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

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

8044 {
8045  struct config_generic *record;
8046 
8047  record = find_option(name, false, ERROR);
8048  if (record == NULL)
8049  {
8050  if (missing_ok)
8051  {
8052  if (varname)
8053  *varname = NULL;
8054  return NULL;
8055  }
8056 
8057  ereport(ERROR,
8058  (errcode(ERRCODE_UNDEFINED_OBJECT),
8059  errmsg("unrecognized configuration parameter \"%s\"", name)));
8060  }
8061 
8062  if ((record->flags & GUC_SUPERUSER_ONLY) &&
8064  ereport(ERROR,
8065  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
8066  errmsg("must be superuser or a member of pg_read_all_settings to examine \"%s\"",
8067  name)));
8068 
8069  if (varname)
8070  *varname = record->name;
8071 
8072  return _ShowOption(record, true);
8073 }
static char * _ShowOption(struct config_generic *record, bool use_units)
Definition: guc.c:8644
Oid GetUserId(void)
Definition: miscinit.c:284
const char * name
Definition: guc_tables.h:146
int errcode(int sqlerrcode)
Definition: elog.c:575
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
#define GUC_SUPERUSER_ONLY
Definition: guc.h:212
bool is_member_of_role(Oid member, Oid role)
Definition: acl.c:4854
#define DEFAULT_ROLE_READ_ALL_SETTINGS
Definition: pg_authid.h:106
static struct config_generic * find_option(const char *name, bool create_placeholders, int elevel)
Definition: guc.c:4381
const char * name
Definition: encode.c:521
int errmsg(const char *fmt,...)
Definition: elog.c:797
void GetConfigOptionByNum ( int  varnum,
const char **  values,
bool noshow 
)

Definition at line 8080 of file guc.c.

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

Referenced by show_all_settings().

8081 {
8082  char buffer[256];
8083  struct config_generic *conf;
8084 
8085  /* check requested variable number valid */
8086  Assert((varnum >= 0) && (varnum < num_guc_variables));
8087 
8088  conf = guc_variables[varnum];
8089 
8090  if (noshow)
8091  {
8092  if ((conf->flags & GUC_NO_SHOW_ALL) ||
8093  ((conf->flags & GUC_SUPERUSER_ONLY) &&
8095  *noshow = true;
8096  else
8097  *noshow = false;
8098  }
8099 
8100  /* first get the generic attributes */
8101 
8102  /* name */
8103  values[0] = conf->name;
8104 
8105  /* setting : use _ShowOption in order to avoid duplicating the logic */
8106  values[1] = _ShowOption(conf, false);
8107 
8108  /* unit */
8109  if (conf->vartype == PGC_INT)
8110  {
8111  switch (conf->flags & (GUC_UNIT_MEMORY | GUC_UNIT_TIME))
8112  {
8113  case GUC_UNIT_BYTE:
8114  values[2] = "B";
8115  break;
8116  case GUC_UNIT_KB:
8117  values[2] = "kB";
8118  break;
8119  case GUC_UNIT_MB:
8120  values[2] = "MB";
8121  break;
8122  case GUC_UNIT_BLOCKS:
8123  snprintf(buffer, sizeof(buffer), "%dkB", BLCKSZ / 1024);
8124  values[2] = pstrdup(buffer);
8125  break;
8126  case GUC_UNIT_XBLOCKS:
8127  snprintf(buffer, sizeof(buffer), "%dkB", XLOG_BLCKSZ / 1024);
8128  values[2] = pstrdup(buffer);
8129  break;
8130  case GUC_UNIT_MS:
8131  values[2] = "ms";
8132  break;
8133  case GUC_UNIT_S:
8134  values[2] = "s";
8135  break;
8136  case GUC_UNIT_MIN:
8137  values[2] = "min";
8138  break;
8139  case 0:
8140  values[2] = NULL;
8141  break;
8142  default:
8143  elog(ERROR, "unrecognized GUC units value: %d",
8144  conf->flags & (GUC_UNIT_MEMORY | GUC_UNIT_TIME));
8145  values[2] = NULL;
8146  break;
8147  }
8148  }
8149  else
8150  values[2] = NULL;
8151 
8152  /* group */
8153  values[3] = config_group_names[conf->group];
8154 
8155  /* short_desc */
8156  values[4] = conf->short_desc;
8157 
8158  /* extra_desc */
8159  values[5] = conf->long_desc;
8160 
8161  /* context */
8162  values[6] = GucContext_Names[conf->context];
8163 
8164  /* vartype */
8165  values[7] = config_type_names[conf->vartype];
8166 
8167  /* source */
8168  values[8] = GucSource_Names[conf->source];
8169 
8170  /* now get the type specific attributes */
8171  switch (conf->vartype)
8172  {
8173  case PGC_BOOL:
8174  {
8175  struct config_bool *lconf = (struct config_bool *) conf;
8176 
8177  /* min_val */
8178  values[9] = NULL;
8179 
8180  /* max_val */
8181  values[10] = NULL;
8182 
8183  /* enumvals */
8184  values[11] = NULL;
8185 
8186  /* boot_val */
8187  values[12] = pstrdup(lconf->boot_val ? "on" : "off");
8188 
8189  /* reset_val */
8190  values[13] = pstrdup(lconf->reset_val ? "on" : "off");
8191  }
8192  break;
8193 
8194  case PGC_INT:
8195  {
8196  struct config_int *lconf = (struct config_int *) conf;
8197 
8198  /* min_val */
8199  snprintf(buffer, sizeof(buffer), "%d", lconf->min);
8200  values[9] = pstrdup(buffer);
8201 
8202  /* max_val */
8203  snprintf(buffer, sizeof(buffer), "%d", lconf->max);
8204  values[10] = pstrdup(buffer);
8205 
8206  /* enumvals */
8207  values[11] = NULL;
8208 
8209  /* boot_val */
8210  snprintf(buffer, sizeof(buffer), "%d", lconf->boot_val);
8211  values[12] = pstrdup(buffer);
8212 
8213  /* reset_val */
8214  snprintf(buffer, sizeof(buffer), "%d", lconf->reset_val);
8215  values[13] = pstrdup(buffer);
8216  }
8217  break;
8218 
8219  case PGC_REAL:
8220  {
8221  struct config_real *lconf = (struct config_real *) conf;
8222 
8223  /* min_val */
8224  snprintf(buffer, sizeof(buffer), "%g", lconf->min);
8225  values[9] = pstrdup(buffer);
8226 
8227  /* max_val */
8228  snprintf(buffer, sizeof(buffer), "%g", lconf->max);
8229  values[10] = pstrdup(buffer);
8230 
8231  /* enumvals */
8232  values[11] = NULL;
8233 
8234  /* boot_val */
8235  snprintf(buffer, sizeof(buffer), "%g", lconf->boot_val);
8236  values[12] = pstrdup(buffer);
8237 
8238  /* reset_val */
8239  snprintf(buffer, sizeof(buffer), "%g", lconf->reset_val);
8240  values[13] = pstrdup(buffer);
8241  }
8242  break;
8243 
8244  case PGC_STRING:
8245  {
8246  struct config_string *lconf = (struct config_string *) conf;
8247 
8248  /* min_val */
8249  values[9] = NULL;
8250 
8251  /* max_val */
8252  values[10] = NULL;
8253 
8254  /* enumvals */
8255  values[11] = NULL;
8256 
8257  /* boot_val */
8258  if (lconf->boot_val == NULL)
8259  values[12] = NULL;
8260  else
8261  values[12] = pstrdup(lconf->boot_val);
8262 
8263  /* reset_val */
8264  if (lconf->reset_val == NULL)
8265  values[13] = NULL;
8266  else
8267  values[13] = pstrdup(lconf->reset_val);
8268  }
8269  break;
8270 
8271  case PGC_ENUM:
8272  {
8273  struct config_enum *lconf = (struct config_enum *) conf;
8274 
8275  /* min_val */
8276  values[9] = NULL;
8277 
8278  /* max_val */
8279  values[10] = NULL;
8280 
8281  /* enumvals */
8282 
8283  /*
8284  * NOTE! enumvals with double quotes in them are not
8285  * supported!
8286  */
8287  values[11] = config_enum_get_options((struct config_enum *) conf,
8288  "{\"", "\"}", "\",\"");
8289 
8290  /* boot_val */
8292  lconf->boot_val));
8293 
8294  /* reset_val */
8296  lconf->reset_val));
8297  }
8298  break;
8299 
8300  default:
8301  {
8302  /*
8303  * should never get here, but in case we do, set 'em to NULL
8304  */
8305 
8306  /* min_val */
8307  values[9] = NULL;
8308 
8309  /* max_val */
8310  values[10] = NULL;
8311 
8312  /* enumvals */
8313  values[11] = NULL;
8314 
8315  /* boot_val */
8316  values[12] = NULL;
8317 
8318  /* reset_val */
8319  values[13] = NULL;
8320  }
8321  break;
8322  }
8323 
8324  /*
8325  * If the setting came from a config file, set the source location. For
8326  * security reasons, we don't show source file/line number for
8327  * non-superusers.
8328  */
8329  if (conf->source == PGC_S_FILE && superuser())
8330  {
8331  values[14] = conf->sourcefile;
8332  snprintf(buffer, sizeof(buffer), "%d", conf->sourceline);
8333  values[15] = pstrdup(buffer);
8334  }
8335  else
8336  {
8337  values[14] = NULL;
8338  values[15] = NULL;
8339  }
8340 
8341  values[16] = (conf->status & GUC_PENDING_RESTART) ? "t" : "f";
8342 }
GucSource source
Definition: guc_tables.h:155
static char * _ShowOption(struct config_generic *record, bool use_units)
Definition: guc.c:8644
const char * long_desc
Definition: guc_tables.h:150
double reset_val
Definition: guc_tables.h:219
Oid GetUserId(void)
Definition: miscinit.c:284
const char * name
Definition: guc_tables.h:146
const char *const config_type_names[]
Definition: guc.c:673
char * pstrdup(const char *in)
Definition: mcxt.c:1076
const char * short_desc
Definition: guc_tables.h:149
int boot_val
Definition: guc_tables.h:196
const char * boot_val
Definition: guc_tables.h:228