PostgreSQL Source Code  git master
guc.c
Go to the documentation of this file.
1 /*--------------------------------------------------------------------
2  * guc.c
3  *
4  * Support for grand unified configuration scheme, including SET
5  * command, configuration file, and command line options.
6  *
7  * This file contains the generic option processing infrastructure.
8  * guc_funcs.c contains SQL-level functionality, including SET/SHOW
9  * commands and various system-administration SQL functions.
10  * guc_tables.c contains the arrays that define all the built-in
11  * GUC variables. Code that implements variable-specific behavior
12  * is scattered around the system in check, assign, and show hooks.
13  *
14  * See src/backend/utils/misc/README for more information.
15  *
16  *
17  * Copyright (c) 2000-2024, PostgreSQL Global Development Group
18  * Written by Peter Eisentraut <peter_e@gmx.net>.
19  *
20  * IDENTIFICATION
21  * src/backend/utils/misc/guc.c
22  *
23  *--------------------------------------------------------------------
24  */
25 #include "postgres.h"
26 
27 #include <limits.h>
28 #include <math.h>
29 #include <sys/stat.h>
30 #include <unistd.h>
31 
32 #include "access/xact.h"
33 #include "access/xlog.h"
34 #include "catalog/objectaccess.h"
35 #include "catalog/pg_authid.h"
37 #include "guc_internal.h"
38 #include "libpq/pqformat.h"
39 #include "libpq/protocol.h"
40 #include "miscadmin.h"
41 #include "parser/scansup.h"
42 #include "port/pg_bitutils.h"
43 #include "storage/fd.h"
44 #include "storage/lwlock.h"
45 #include "storage/shmem.h"
46 #include "tcop/tcopprot.h"
47 #include "utils/acl.h"
48 #include "utils/builtins.h"
49 #include "utils/conffiles.h"
50 #include "utils/guc_tables.h"
51 #include "utils/memutils.h"
52 #include "utils/timestamp.h"
53 
54 
55 #define CONFIG_FILENAME "postgresql.conf"
56 #define HBA_FILENAME "pg_hba.conf"
57 #define IDENT_FILENAME "pg_ident.conf"
58 
59 #ifdef EXEC_BACKEND
60 #define CONFIG_EXEC_PARAMS "global/config_exec_params"
61 #define CONFIG_EXEC_PARAMS_NEW "global/config_exec_params.new"
62 #endif
63 
64 /*
65  * Precision with which REAL type guc values are to be printed for GUC
66  * serialization.
67  */
68 #define REALTYPE_PRECISION 17
69 
70 /*
71  * Safe search path when executing code as the table owner, such as during
72  * maintenance operations.
73  */
74 #define GUC_SAFE_SEARCH_PATH "pg_catalog, pg_temp"
75 
77 
79 
80 /* global variables for check hook support */
84 
85 /* Kluge: for speed, we examine this GUC variable's value directly */
86 extern bool in_hot_standby_guc;
87 
88 
89 /*
90  * Unit conversion tables.
91  *
92  * There are two tables, one for memory units, and another for time units.
93  * For each supported conversion from one unit to another, we have an entry
94  * in the table.
95  *
96  * To keep things simple, and to avoid possible roundoff error,
97  * conversions are never chained. There needs to be a direct conversion
98  * between all units (of the same type).
99  *
100  * The conversions for each base unit must be kept in order from greatest to
101  * smallest human-friendly unit; convert_xxx_from_base_unit() rely on that.
102  * (The order of the base-unit groups does not matter.)
103  */
104 #define MAX_UNIT_LEN 3 /* length of longest recognized unit string */
105 
106 typedef struct
107 {
108  char unit[MAX_UNIT_LEN + 1]; /* unit, as a string, like "kB" or
109  * "min" */
110  int base_unit; /* GUC_UNIT_XXX */
111  double multiplier; /* Factor for converting unit -> base_unit */
113 
114 /* Ensure that the constants in the tables don't overflow or underflow */
115 #if BLCKSZ < 1024 || BLCKSZ > (1024*1024)
116 #error BLCKSZ must be between 1KB and 1MB
117 #endif
118 #if XLOG_BLCKSZ < 1024 || XLOG_BLCKSZ > (1024*1024)
119 #error XLOG_BLCKSZ must be between 1KB and 1MB
120 #endif
121 
122 static const char *const memory_units_hint = gettext_noop("Valid units for this parameter are \"B\", \"kB\", \"MB\", \"GB\", and \"TB\".");
123 
125 {
126  {"TB", GUC_UNIT_BYTE, 1024.0 * 1024.0 * 1024.0 * 1024.0},
127  {"GB", GUC_UNIT_BYTE, 1024.0 * 1024.0 * 1024.0},
128  {"MB", GUC_UNIT_BYTE, 1024.0 * 1024.0},
129  {"kB", GUC_UNIT_BYTE, 1024.0},
130  {"B", GUC_UNIT_BYTE, 1.0},
131 
132  {"TB", GUC_UNIT_KB, 1024.0 * 1024.0 * 1024.0},
133  {"GB", GUC_UNIT_KB, 1024.0 * 1024.0},
134  {"MB", GUC_UNIT_KB, 1024.0},
135  {"kB", GUC_UNIT_KB, 1.0},
136  {"B", GUC_UNIT_KB, 1.0 / 1024.0},
137 
138  {"TB", GUC_UNIT_MB, 1024.0 * 1024.0},
139  {"GB", GUC_UNIT_MB, 1024.0},
140  {"MB", GUC_UNIT_MB, 1.0},
141  {"kB", GUC_UNIT_MB, 1.0 / 1024.0},
142  {"B", GUC_UNIT_MB, 1.0 / (1024.0 * 1024.0)},
143 
144  {"TB", GUC_UNIT_BLOCKS, (1024.0 * 1024.0 * 1024.0) / (BLCKSZ / 1024)},
145  {"GB", GUC_UNIT_BLOCKS, (1024.0 * 1024.0) / (BLCKSZ / 1024)},
146  {"MB", GUC_UNIT_BLOCKS, 1024.0 / (BLCKSZ / 1024)},
147  {"kB", GUC_UNIT_BLOCKS, 1.0 / (BLCKSZ / 1024)},
148  {"B", GUC_UNIT_BLOCKS, 1.0 / BLCKSZ},
149 
150  {"TB", GUC_UNIT_XBLOCKS, (1024.0 * 1024.0 * 1024.0) / (XLOG_BLCKSZ / 1024)},
151  {"GB", GUC_UNIT_XBLOCKS, (1024.0 * 1024.0) / (XLOG_BLCKSZ / 1024)},
152  {"MB", GUC_UNIT_XBLOCKS, 1024.0 / (XLOG_BLCKSZ / 1024)},
153  {"kB", GUC_UNIT_XBLOCKS, 1.0 / (XLOG_BLCKSZ / 1024)},
154  {"B", GUC_UNIT_XBLOCKS, 1.0 / XLOG_BLCKSZ},
155 
156  {""} /* end of table marker */
157 };
158 
159 static const char *const time_units_hint = gettext_noop("Valid units for this parameter are \"us\", \"ms\", \"s\", \"min\", \"h\", and \"d\".");
160 
162 {
163  {"d", GUC_UNIT_MS, 1000 * 60 * 60 * 24},
164  {"h", GUC_UNIT_MS, 1000 * 60 * 60},
165  {"min", GUC_UNIT_MS, 1000 * 60},
166  {"s", GUC_UNIT_MS, 1000},
167  {"ms", GUC_UNIT_MS, 1},
168  {"us", GUC_UNIT_MS, 1.0 / 1000},
169 
170  {"d", GUC_UNIT_S, 60 * 60 * 24},
171  {"h", GUC_UNIT_S, 60 * 60},
172  {"min", GUC_UNIT_S, 60},
173  {"s", GUC_UNIT_S, 1},
174  {"ms", GUC_UNIT_S, 1.0 / 1000},
175  {"us", GUC_UNIT_S, 1.0 / (1000 * 1000)},
176 
177  {"d", GUC_UNIT_MIN, 60 * 24},
178  {"h", GUC_UNIT_MIN, 60},
179  {"min", GUC_UNIT_MIN, 1},
180  {"s", GUC_UNIT_MIN, 1.0 / 60},
181  {"ms", GUC_UNIT_MIN, 1.0 / (1000 * 60)},
182  {"us", GUC_UNIT_MIN, 1.0 / (1000 * 1000 * 60)},
183 
184  {""} /* end of table marker */
185 };
186 
187 /*
188  * To allow continued support of obsolete names for GUC variables, we apply
189  * the following mappings to any unrecognized name. Note that an old name
190  * should be mapped to a new one only if the new variable has very similar
191  * semantics to the old.
192  */
193 static const char *const map_old_guc_names[] = {
194  "sort_mem", "work_mem",
195  "vacuum_mem", "maintenance_work_mem",
196  NULL
197 };
198 
199 
200 /* Memory context holding all GUC-related data */
202 
203 /*
204  * We use a dynahash table to look up GUCs by name, or to iterate through
205  * all the GUCs. The gucname field is redundant with gucvar->name, but
206  * dynahash makes it too painful to not store the hash key separately.
207  */
208 typedef struct
209 {
210  const char *gucname; /* hash key */
211  struct config_generic *gucvar; /* -> GUC's defining structure */
212 } GUCHashEntry;
213 
214 static HTAB *guc_hashtab; /* entries are GUCHashEntrys */
215 
216 /*
217  * In addition to the hash table, variables having certain properties are
218  * linked into these lists, so that we can find them without scanning the
219  * whole hash table. In most applications, only a small fraction of the
220  * GUCs appear in these lists at any given time. The usage of the stack
221  * and report lists is stylized enough that they can be slists, but the
222  * nondef list has to be a dlist to avoid O(N) deletes in common cases.
223  */
224 static dlist_head guc_nondef_list; /* list of variables that have source
225  * different from PGC_S_DEFAULT */
226 static slist_head guc_stack_list; /* list of variables that have non-NULL
227  * stack */
228 static slist_head guc_report_list; /* list of variables that have the
229  * GUC_NEEDS_REPORT bit set in status */
230 
231 static bool reporting_enabled; /* true to enable GUC_REPORT */
232 
233 static int GUCNestLevel = 0; /* 1 when in main transaction */
234 
235 
236 static int guc_var_compare(const void *a, const void *b);
237 static uint32 guc_name_hash(const void *key, Size keysize);
238 static int guc_name_match(const void *key1, const void *key2, Size keysize);
239 static void InitializeGUCOptionsFromEnvironment(void);
240 static void InitializeOneGUCOption(struct config_generic *gconf);
241 static void RemoveGUCFromLists(struct config_generic *gconf);
242 static void set_guc_source(struct config_generic *gconf, GucSource newsource);
243 static void pg_timezone_abbrev_initialize(void);
244 static void push_old_value(struct config_generic *gconf, GucAction action);
245 static void ReportGUCOption(struct config_generic *record);
246 static void set_config_sourcefile(const char *name, char *sourcefile,
247  int sourceline);
249  struct config_string *pHolder,
250  GucStack *stack,
251  const char *curvalue,
252  GucContext curscontext, GucSource cursource,
253  Oid cursrole);
254 static bool validate_option_array_item(const char *name, const char *value,
255  bool skipIfNoPermissions);
256 static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head);
257 static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p,
258  const char *name, const char *value);
259 static bool valid_custom_variable_name(const char *name);
260 static bool assignable_custom_variable_name(const char *name, bool skip_errors,
261  int elevel);
262 static void do_serialize(char **destptr, Size *maxbytes,
263  const char *fmt,...) pg_attribute_printf(3, 4);
264 static bool call_bool_check_hook(struct config_bool *conf, bool *newval,
265  void **extra, GucSource source, int elevel);
266 static bool call_int_check_hook(struct config_int *conf, int *newval,
267  void **extra, GucSource source, int elevel);
268 static bool call_real_check_hook(struct config_real *conf, double *newval,
269  void **extra, GucSource source, int elevel);
270 static bool call_string_check_hook(struct config_string *conf, char **newval,
271  void **extra, GucSource source, int elevel);
272 static bool call_enum_check_hook(struct config_enum *conf, int *newval,
273  void **extra, GucSource source, int elevel);
274 
275 
276 /*
277  * This function handles both actual config file (re)loads and execution of
278  * show_all_file_settings() (i.e., the pg_file_settings view). In the latter
279  * case we don't apply any of the settings, but we make all the usual validity
280  * checks, and we return the ConfigVariable list so that it can be printed out
281  * by show_all_file_settings().
282  */
284 ProcessConfigFileInternal(GucContext context, bool applySettings, int elevel)
285 {
286  bool error = false;
287  bool applying = false;
288  const char *ConfFileWithError;
289  ConfigVariable *item,
290  *head,
291  *tail;
293  GUCHashEntry *hentry;
294 
295  /* Parse the main config file into a list of option names and values */
296  ConfFileWithError = ConfigFileName;
297  head = tail = NULL;
298 
299  if (!ParseConfigFile(ConfigFileName, true,
300  NULL, 0, CONF_FILE_START_DEPTH, elevel,
301  &head, &tail))
302  {
303  /* Syntax error(s) detected in the file, so bail out */
304  error = true;
305  goto bail_out;
306  }
307 
308  /*
309  * Parse the PG_AUTOCONF_FILENAME file, if present, after the main file to
310  * replace any parameters set by ALTER SYSTEM command. Because this file
311  * is in the data directory, we can't read it until the DataDir has been
312  * set.
313  */
314  if (DataDir)
315  {
317  NULL, 0, CONF_FILE_START_DEPTH, elevel,
318  &head, &tail))
319  {
320  /* Syntax error(s) detected in the file, so bail out */
321  error = true;
322  ConfFileWithError = PG_AUTOCONF_FILENAME;
323  goto bail_out;
324  }
325  }
326  else
327  {
328  /*
329  * If DataDir is not set, the PG_AUTOCONF_FILENAME file cannot be
330  * read. In this case, we don't want to accept any settings but
331  * data_directory from postgresql.conf, because they might be
332  * overwritten with settings in the PG_AUTOCONF_FILENAME file which
333  * will be read later. OTOH, since data_directory isn't allowed in the
334  * PG_AUTOCONF_FILENAME file, it will never be overwritten later.
335  */
336  ConfigVariable *newlist = NULL;
337 
338  /*
339  * Prune all items except the last "data_directory" from the list.
340  */
341  for (item = head; item; item = item->next)
342  {
343  if (!item->ignore &&
344  strcmp(item->name, "data_directory") == 0)
345  newlist = item;
346  }
347 
348  if (newlist)
349  newlist->next = NULL;
350  head = tail = newlist;
351 
352  /*
353  * Quick exit if data_directory is not present in file.
354  *
355  * We need not do any further processing, in particular we don't set
356  * PgReloadTime; that will be set soon by subsequent full loading of
357  * the config file.
358  */
359  if (head == NULL)
360  goto bail_out;
361  }
362 
363  /*
364  * Mark all extant GUC variables as not present in the config file. We
365  * need this so that we can tell below which ones have been removed from
366  * the file since we last processed it.
367  */
369  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
370  {
371  struct config_generic *gconf = hentry->gucvar;
372 
373  gconf->status &= ~GUC_IS_IN_FILE;
374  }
375 
376  /*
377  * Check if all the supplied option names are valid, as an additional
378  * quasi-syntactic check on the validity of the config file. It is
379  * important that the postmaster and all backends agree on the results of
380  * this phase, else we will have strange inconsistencies about which
381  * processes accept a config file update and which don't. Hence, unknown
382  * custom variable names have to be accepted without complaint. For the
383  * same reason, we don't attempt to validate the options' values here.
384  *
385  * In addition, the GUC_IS_IN_FILE flag is set on each existing GUC
386  * variable mentioned in the file; and we detect duplicate entries in the
387  * file and mark the earlier occurrences as ignorable.
388  */
389  for (item = head; item; item = item->next)
390  {
391  struct config_generic *record;
392 
393  /* Ignore anything already marked as ignorable */
394  if (item->ignore)
395  continue;
396 
397  /*
398  * Try to find the variable; but do not create a custom placeholder if
399  * it's not there already.
400  */
401  record = find_option(item->name, false, true, elevel);
402 
403  if (record)
404  {
405  /* If it's already marked, then this is a duplicate entry */
406  if (record->status & GUC_IS_IN_FILE)
407  {
408  /*
409  * Mark the earlier occurrence(s) as dead/ignorable. We could
410  * avoid the O(N^2) behavior here with some additional state,
411  * but it seems unlikely to be worth the trouble.
412  */
413  ConfigVariable *pitem;
414 
415  for (pitem = head; pitem != item; pitem = pitem->next)
416  {
417  if (!pitem->ignore &&
418  strcmp(pitem->name, item->name) == 0)
419  pitem->ignore = true;
420  }
421  }
422  /* Now mark it as present in file */
423  record->status |= GUC_IS_IN_FILE;
424  }
425  else if (!valid_custom_variable_name(item->name))
426  {
427  /* Invalid non-custom variable, so complain */
428  ereport(elevel,
429  (errcode(ERRCODE_UNDEFINED_OBJECT),
430  errmsg("unrecognized configuration parameter \"%s\" in file \"%s\" line %d",
431  item->name,
432  item->filename, item->sourceline)));
433  item->errmsg = pstrdup("unrecognized configuration parameter");
434  error = true;
435  ConfFileWithError = item->filename;
436  }
437  }
438 
439  /*
440  * If we've detected any errors so far, we don't want to risk applying any
441  * changes.
442  */
443  if (error)
444  goto bail_out;
445 
446  /* Otherwise, set flag that we're beginning to apply changes */
447  applying = true;
448 
449  /*
450  * Check for variables having been removed from the config file, and
451  * revert their reset values (and perhaps also effective values) to the
452  * boot-time defaults. If such a variable can't be changed after startup,
453  * report that and continue.
454  */
456  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
457  {
458  struct config_generic *gconf = hentry->gucvar;
459  GucStack *stack;
460 
461  if (gconf->reset_source != PGC_S_FILE ||
462  (gconf->status & GUC_IS_IN_FILE))
463  continue;
464  if (gconf->context < PGC_SIGHUP)
465  {
466  /* The removal can't be effective without a restart */
467  gconf->status |= GUC_PENDING_RESTART;
468  ereport(elevel,
469  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
470  errmsg("parameter \"%s\" cannot be changed without restarting the server",
471  gconf->name)));
472  record_config_file_error(psprintf("parameter \"%s\" cannot be changed without restarting the server",
473  gconf->name),
474  NULL, 0,
475  &head, &tail);
476  error = true;
477  continue;
478  }
479 
480  /* No more to do if we're just doing show_all_file_settings() */
481  if (!applySettings)
482  continue;
483 
484  /*
485  * Reset any "file" sources to "default", else set_config_option will
486  * not override those settings.
487  */
488  if (gconf->reset_source == PGC_S_FILE)
489  gconf->reset_source = PGC_S_DEFAULT;
490  if (gconf->source == PGC_S_FILE)
492  for (stack = gconf->stack; stack; stack = stack->prev)
493  {
494  if (stack->source == PGC_S_FILE)
496  }
497 
498  /* Now we can re-apply the wired-in default (i.e., the boot_val) */
499  if (set_config_option(gconf->name, NULL,
501  GUC_ACTION_SET, true, 0, false) > 0)
502  {
503  /* Log the change if appropriate */
504  if (context == PGC_SIGHUP)
505  ereport(elevel,
506  (errmsg("parameter \"%s\" removed from configuration file, reset to default",
507  gconf->name)));
508  }
509  }
510 
511  /*
512  * Restore any variables determined by environment variables or
513  * dynamically-computed defaults. This is a no-op except in the case
514  * where one of these had been in the config file and is now removed.
515  *
516  * In particular, we *must not* do this during the postmaster's initial
517  * loading of the file, since the timezone functions in particular should
518  * be run only after initialization is complete.
519  *
520  * XXX this is an unmaintainable crock, because we have to know how to set
521  * (or at least what to call to set) every non-PGC_INTERNAL variable that
522  * could potentially have PGC_S_DYNAMIC_DEFAULT or PGC_S_ENV_VAR source.
523  */
524  if (context == PGC_SIGHUP && applySettings)
525  {
528  /* this selects SQL_ASCII in processes not connected to a database */
529  SetConfigOption("client_encoding", GetDatabaseEncodingName(),
531  }
532 
533  /*
534  * Now apply the values from the config file.
535  */
536  for (item = head; item; item = item->next)
537  {
538  char *pre_value = NULL;
539  int scres;
540 
541  /* Ignore anything marked as ignorable */
542  if (item->ignore)
543  continue;
544 
545  /* In SIGHUP cases in the postmaster, we want to report changes */
546  if (context == PGC_SIGHUP && applySettings && !IsUnderPostmaster)
547  {
548  const char *preval = GetConfigOption(item->name, true, false);
549 
550  /* If option doesn't exist yet or is NULL, treat as empty string */
551  if (!preval)
552  preval = "";
553  /* must dup, else might have dangling pointer below */
554  pre_value = pstrdup(preval);
555  }
556 
557  scres = set_config_option(item->name, item->value,
559  GUC_ACTION_SET, applySettings, 0, false);
560  if (scres > 0)
561  {
562  /* variable was updated, so log the change if appropriate */
563  if (pre_value)
564  {
565  const char *post_value = GetConfigOption(item->name, true, false);
566 
567  if (!post_value)
568  post_value = "";
569  if (strcmp(pre_value, post_value) != 0)
570  ereport(elevel,
571  (errmsg("parameter \"%s\" changed to \"%s\"",
572  item->name, item->value)));
573  }
574  item->applied = true;
575  }
576  else if (scres == 0)
577  {
578  error = true;
579  item->errmsg = pstrdup("setting could not be applied");
580  ConfFileWithError = item->filename;
581  }
582  else
583  {
584  /* no error, but variable's active value was not changed */
585  item->applied = true;
586  }
587 
588  /*
589  * We should update source location unless there was an error, since
590  * even if the active value didn't change, the reset value might have.
591  * (In the postmaster, there won't be a difference, but it does matter
592  * in backends.)
593  */
594  if (scres != 0 && applySettings)
595  set_config_sourcefile(item->name, item->filename,
596  item->sourceline);
597 
598  if (pre_value)
599  pfree(pre_value);
600  }
601 
602  /* Remember when we last successfully loaded the config file. */
603  if (applySettings)
605 
606 bail_out:
607  if (error && applySettings)
608  {
609  /* During postmaster startup, any error is fatal */
610  if (context == PGC_POSTMASTER)
611  ereport(ERROR,
612  (errcode(ERRCODE_CONFIG_FILE_ERROR),
613  errmsg("configuration file \"%s\" contains errors",
614  ConfFileWithError)));
615  else if (applying)
616  ereport(elevel,
617  (errcode(ERRCODE_CONFIG_FILE_ERROR),
618  errmsg("configuration file \"%s\" contains errors; unaffected changes were applied",
619  ConfFileWithError)));
620  else
621  ereport(elevel,
622  (errcode(ERRCODE_CONFIG_FILE_ERROR),
623  errmsg("configuration file \"%s\" contains errors; no changes were applied",
624  ConfFileWithError)));
625  }
626 
627  /* Successful or otherwise, return the collected data list */
628  return head;
629 }
630 
631 
632 /*
633  * Some infrastructure for GUC-related memory allocation
634  *
635  * These functions are generally modeled on libc's malloc/realloc/etc,
636  * but any OOM issue is reported at the specified elevel.
637  * (Thus, control returns only if that's less than ERROR.)
638  */
639 void *
640 guc_malloc(int elevel, size_t size)
641 {
642  void *data;
643 
646  if (unlikely(data == NULL))
647  ereport(elevel,
648  (errcode(ERRCODE_OUT_OF_MEMORY),
649  errmsg("out of memory")));
650  return data;
651 }
652 
653 void *
654 guc_realloc(int elevel, void *old, size_t size)
655 {
656  void *data;
657 
658  if (old != NULL)
659  {
660  /* This is to help catch old code that malloc's GUC data. */
662  data = repalloc_extended(old, size,
664  }
665  else
666  {
667  /* Like realloc(3), but not like repalloc(), we allow old == NULL. */
670  }
671  if (unlikely(data == NULL))
672  ereport(elevel,
673  (errcode(ERRCODE_OUT_OF_MEMORY),
674  errmsg("out of memory")));
675  return data;
676 }
677 
678 char *
679 guc_strdup(int elevel, const char *src)
680 {
681  char *data;
682  size_t len = strlen(src) + 1;
683 
684  data = guc_malloc(elevel, len);
685  if (likely(data != NULL))
686  memcpy(data, src, len);
687  return data;
688 }
689 
690 void
691 guc_free(void *ptr)
692 {
693  /*
694  * Historically, GUC-related code has relied heavily on the ability to do
695  * free(NULL), so we allow that here even though pfree() doesn't.
696  */
697  if (ptr != NULL)
698  {
699  /* This is to help catch old code that malloc's GUC data. */
701  pfree(ptr);
702  }
703 }
704 
705 
706 /*
707  * Detect whether strval is referenced anywhere in a GUC string item
708  */
709 static bool
710 string_field_used(struct config_string *conf, char *strval)
711 {
712  GucStack *stack;
713 
714  if (strval == *(conf->variable) ||
715  strval == conf->reset_val ||
716  strval == conf->boot_val)
717  return true;
718  for (stack = conf->gen.stack; stack; stack = stack->prev)
719  {
720  if (strval == stack->prior.val.stringval ||
721  strval == stack->masked.val.stringval)
722  return true;
723  }
724  return false;
725 }
726 
727 /*
728  * Support for assigning to a field of a string GUC item. Free the prior
729  * value if it's not referenced anywhere else in the item (including stacked
730  * states).
731  */
732 static void
733 set_string_field(struct config_string *conf, char **field, char *newval)
734 {
735  char *oldval = *field;
736 
737  /* Do the assignment */
738  *field = newval;
739 
740  /* Free old value if it's not NULL and isn't referenced anymore */
741  if (oldval && !string_field_used(conf, oldval))
742  guc_free(oldval);
743 }
744 
745 /*
746  * Detect whether an "extra" struct is referenced anywhere in a GUC item
747  */
748 static bool
749 extra_field_used(struct config_generic *gconf, void *extra)
750 {
751  GucStack *stack;
752 
753  if (extra == gconf->extra)
754  return true;
755  switch (gconf->vartype)
756  {
757  case PGC_BOOL:
758  if (extra == ((struct config_bool *) gconf)->reset_extra)
759  return true;
760  break;
761  case PGC_INT:
762  if (extra == ((struct config_int *) gconf)->reset_extra)
763  return true;
764  break;
765  case PGC_REAL:
766  if (extra == ((struct config_real *) gconf)->reset_extra)
767  return true;
768  break;
769  case PGC_STRING:
770  if (extra == ((struct config_string *) gconf)->reset_extra)
771  return true;
772  break;
773  case PGC_ENUM:
774  if (extra == ((struct config_enum *) gconf)->reset_extra)
775  return true;
776  break;
777  }
778  for (stack = gconf->stack; stack; stack = stack->prev)
779  {
780  if (extra == stack->prior.extra ||
781  extra == stack->masked.extra)
782  return true;
783  }
784 
785  return false;
786 }
787 
788 /*
789  * Support for assigning to an "extra" field of a GUC item. Free the prior
790  * value if it's not referenced anywhere else in the item (including stacked
791  * states).
792  */
793 static void
794 set_extra_field(struct config_generic *gconf, void **field, void *newval)
795 {
796  void *oldval = *field;
797 
798  /* Do the assignment */
799  *field = newval;
800 
801  /* Free old value if it's not NULL and isn't referenced anymore */
802  if (oldval && !extra_field_used(gconf, oldval))
803  guc_free(oldval);
804 }
805 
806 /*
807  * Support for copying a variable's active value into a stack entry.
808  * The "extra" field associated with the active value is copied, too.
809  *
810  * NB: be sure stringval and extra fields of a new stack entry are
811  * initialized to NULL before this is used, else we'll try to guc_free() them.
812  */
813 static void
815 {
816  switch (gconf->vartype)
817  {
818  case PGC_BOOL:
819  val->val.boolval =
820  *((struct config_bool *) gconf)->variable;
821  break;
822  case PGC_INT:
823  val->val.intval =
824  *((struct config_int *) gconf)->variable;
825  break;
826  case PGC_REAL:
827  val->val.realval =
828  *((struct config_real *) gconf)->variable;
829  break;
830  case PGC_STRING:
831  set_string_field((struct config_string *) gconf,
832  &(val->val.stringval),
833  *((struct config_string *) gconf)->variable);
834  break;
835  case PGC_ENUM:
836  val->val.enumval =
837  *((struct config_enum *) gconf)->variable;
838  break;
839  }
840  set_extra_field(gconf, &(val->extra), gconf->extra);
841 }
842 
843 /*
844  * Support for discarding a no-longer-needed value in a stack entry.
845  * The "extra" field associated with the stack entry is cleared, too.
846  */
847 static void
849 {
850  switch (gconf->vartype)
851  {
852  case PGC_BOOL:
853  case PGC_INT:
854  case PGC_REAL:
855  case PGC_ENUM:
856  /* no need to do anything */
857  break;
858  case PGC_STRING:
859  set_string_field((struct config_string *) gconf,
860  &(val->val.stringval),
861  NULL);
862  break;
863  }
864  set_extra_field(gconf, &(val->extra), NULL);
865 }
866 
867 
868 /*
869  * Fetch a palloc'd, sorted array of GUC struct pointers
870  *
871  * The array length is returned into *num_vars.
872  */
873 struct config_generic **
874 get_guc_variables(int *num_vars)
875 {
876  struct config_generic **result;
878  GUCHashEntry *hentry;
879  int i;
880 
881  *num_vars = hash_get_num_entries(guc_hashtab);
882  result = palloc(sizeof(struct config_generic *) * *num_vars);
883 
884  /* Extract pointers from the hash table */
885  i = 0;
887  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
888  result[i++] = hentry->gucvar;
889  Assert(i == *num_vars);
890 
891  /* Sort by name */
892  qsort(result, *num_vars,
893  sizeof(struct config_generic *), guc_var_compare);
894 
895  return result;
896 }
897 
898 
899 /*
900  * Build the GUC hash table. This is split out so that help_config.c can
901  * extract all the variables without running all of InitializeGUCOptions.
902  * It's not meant for use anyplace else.
903  */
904 void
906 {
907  int size_vars;
908  int num_vars = 0;
909  HASHCTL hash_ctl;
910  GUCHashEntry *hentry;
911  bool found;
912  int i;
913 
914  /*
915  * Create the memory context that will hold all GUC-related data.
916  */
917  Assert(GUCMemoryContext == NULL);
919  "GUCMemoryContext",
921 
922  /*
923  * Count all the built-in variables, and set their vartypes correctly.
924  */
925  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
926  {
927  struct config_bool *conf = &ConfigureNamesBool[i];
928 
929  /* Rather than requiring vartype to be filled in by hand, do this: */
930  conf->gen.vartype = PGC_BOOL;
931  num_vars++;
932  }
933 
934  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
935  {
936  struct config_int *conf = &ConfigureNamesInt[i];
937 
938  conf->gen.vartype = PGC_INT;
939  num_vars++;
940  }
941 
942  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
943  {
944  struct config_real *conf = &ConfigureNamesReal[i];
945 
946  conf->gen.vartype = PGC_REAL;
947  num_vars++;
948  }
949 
950  for (i = 0; ConfigureNamesString[i].gen.name; i++)
951  {
952  struct config_string *conf = &ConfigureNamesString[i];
953 
954  conf->gen.vartype = PGC_STRING;
955  num_vars++;
956  }
957 
958  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
959  {
960  struct config_enum *conf = &ConfigureNamesEnum[i];
961 
962  conf->gen.vartype = PGC_ENUM;
963  num_vars++;
964  }
965 
966  /*
967  * Create hash table with 20% slack
968  */
969  size_vars = num_vars + num_vars / 4;
970 
971  hash_ctl.keysize = sizeof(char *);
972  hash_ctl.entrysize = sizeof(GUCHashEntry);
973  hash_ctl.hash = guc_name_hash;
974  hash_ctl.match = guc_name_match;
975  hash_ctl.hcxt = GUCMemoryContext;
976  guc_hashtab = hash_create("GUC hash table",
977  size_vars,
978  &hash_ctl,
980 
981  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
982  {
983  struct config_generic *gucvar = &ConfigureNamesBool[i].gen;
984 
985  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
986  &gucvar->name,
987  HASH_ENTER,
988  &found);
989  Assert(!found);
990  hentry->gucvar = gucvar;
991  }
992 
993  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
994  {
995  struct config_generic *gucvar = &ConfigureNamesInt[i].gen;
996 
997  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
998  &gucvar->name,
999  HASH_ENTER,
1000  &found);
1001  Assert(!found);
1002  hentry->gucvar = gucvar;
1003  }
1004 
1005  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
1006  {
1007  struct config_generic *gucvar = &ConfigureNamesReal[i].gen;
1008 
1009  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1010  &gucvar->name,
1011  HASH_ENTER,
1012  &found);
1013  Assert(!found);
1014  hentry->gucvar = gucvar;
1015  }
1016 
1017  for (i = 0; ConfigureNamesString[i].gen.name; i++)
1018  {
1019  struct config_generic *gucvar = &ConfigureNamesString[i].gen;
1020 
1021  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1022  &gucvar->name,
1023  HASH_ENTER,
1024  &found);
1025  Assert(!found);
1026  hentry->gucvar = gucvar;
1027  }
1028 
1029  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
1030  {
1031  struct config_generic *gucvar = &ConfigureNamesEnum[i].gen;
1032 
1033  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1034  &gucvar->name,
1035  HASH_ENTER,
1036  &found);
1037  Assert(!found);
1038  hentry->gucvar = gucvar;
1039  }
1040 
1041  Assert(num_vars == hash_get_num_entries(guc_hashtab));
1042 }
1043 
1044 /*
1045  * Add a new GUC variable to the hash of known variables. The
1046  * hash is expanded if needed.
1047  */
1048 static bool
1049 add_guc_variable(struct config_generic *var, int elevel)
1050 {
1051  GUCHashEntry *hentry;
1052  bool found;
1053 
1054  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1055  &var->name,
1057  &found);
1058  if (unlikely(hentry == NULL))
1059  {
1060  ereport(elevel,
1061  (errcode(ERRCODE_OUT_OF_MEMORY),
1062  errmsg("out of memory")));
1063  return false; /* out of memory */
1064  }
1065  Assert(!found);
1066  hentry->gucvar = var;
1067  return true;
1068 }
1069 
1070 /*
1071  * Decide whether a proposed custom variable name is allowed.
1072  *
1073  * It must be two or more identifiers separated by dots, where the rules
1074  * for what is an identifier agree with scan.l. (If you change this rule,
1075  * adjust the errdetail in assignable_custom_variable_name().)
1076  */
1077 static bool
1079 {
1080  bool saw_sep = false;
1081  bool name_start = true;
1082 
1083  for (const char *p = name; *p; p++)
1084  {
1085  if (*p == GUC_QUALIFIER_SEPARATOR)
1086  {
1087  if (name_start)
1088  return false; /* empty name component */
1089  saw_sep = true;
1090  name_start = true;
1091  }
1092  else if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1093  "abcdefghijklmnopqrstuvwxyz_", *p) != NULL ||
1094  IS_HIGHBIT_SET(*p))
1095  {
1096  /* okay as first or non-first character */
1097  name_start = false;
1098  }
1099  else if (!name_start && strchr("0123456789$", *p) != NULL)
1100  /* okay as non-first character */ ;
1101  else
1102  return false;
1103  }
1104  if (name_start)
1105  return false; /* empty name component */
1106  /* OK if we found at least one separator */
1107  return saw_sep;
1108 }
1109 
1110 /*
1111  * Decide whether an unrecognized variable name is allowed to be SET.
1112  *
1113  * It must pass the syntactic rules of valid_custom_variable_name(),
1114  * and it must not be in any namespace already reserved by an extension.
1115  * (We make this separate from valid_custom_variable_name() because we don't
1116  * apply the reserved-namespace test when reading configuration files.)
1117  *
1118  * If valid, return true. Otherwise, return false if skip_errors is true,
1119  * else throw a suitable error at the specified elevel (and return false
1120  * if that's less than ERROR).
1121  */
1122 static bool
1123 assignable_custom_variable_name(const char *name, bool skip_errors, int elevel)
1124 {
1125  /* If there's no separator, it can't be a custom variable */
1126  const char *sep = strchr(name, GUC_QUALIFIER_SEPARATOR);
1127 
1128  if (sep != NULL)
1129  {
1130  size_t classLen = sep - name;
1131  ListCell *lc;
1132 
1133  /* The name must be syntactically acceptable ... */
1135  {
1136  if (!skip_errors)
1137  ereport(elevel,
1138  (errcode(ERRCODE_INVALID_NAME),
1139  errmsg("invalid configuration parameter name \"%s\"",
1140  name),
1141  errdetail("Custom parameter names must be two or more simple identifiers separated by dots.")));
1142  return false;
1143  }
1144  /* ... and it must not match any previously-reserved prefix */
1145  foreach(lc, reserved_class_prefix)
1146  {
1147  const char *rcprefix = lfirst(lc);
1148 
1149  if (strlen(rcprefix) == classLen &&
1150  strncmp(name, rcprefix, classLen) == 0)
1151  {
1152  if (!skip_errors)
1153  ereport(elevel,
1154  (errcode(ERRCODE_INVALID_NAME),
1155  errmsg("invalid configuration parameter name \"%s\"",
1156  name),
1157  errdetail("\"%s\" is a reserved prefix.",
1158  rcprefix)));
1159  return false;
1160  }
1161  }
1162  /* OK to create it */
1163  return true;
1164  }
1165 
1166  /* Unrecognized single-part name */
1167  if (!skip_errors)
1168  ereport(elevel,
1169  (errcode(ERRCODE_UNDEFINED_OBJECT),
1170  errmsg("unrecognized configuration parameter \"%s\"",
1171  name)));
1172  return false;
1173 }
1174 
1175 /*
1176  * Create and add a placeholder variable for a custom variable name.
1177  */
1178 static struct config_generic *
1179 add_placeholder_variable(const char *name, int elevel)
1180 {
1181  size_t sz = sizeof(struct config_string) + sizeof(char *);
1182  struct config_string *var;
1183  struct config_generic *gen;
1184 
1185  var = (struct config_string *) guc_malloc(elevel, sz);
1186  if (var == NULL)
1187  return NULL;
1188  memset(var, 0, sz);
1189  gen = &var->gen;
1190 
1191  gen->name = guc_strdup(elevel, name);
1192  if (gen->name == NULL)
1193  {
1194  guc_free(var);
1195  return NULL;
1196  }
1197 
1198  gen->context = PGC_USERSET;
1200  gen->short_desc = "GUC placeholder variable";
1202  gen->vartype = PGC_STRING;
1203 
1204  /*
1205  * The char* is allocated at the end of the struct since we have no
1206  * 'static' place to point to. Note that the current value, as well as
1207  * the boot and reset values, start out NULL.
1208  */
1209  var->variable = (char **) (var + 1);
1210 
1211  if (!add_guc_variable((struct config_generic *) var, elevel))
1212  {
1213  guc_free(unconstify(char *, gen->name));
1214  guc_free(var);
1215  return NULL;
1216  }
1217 
1218  return gen;
1219 }
1220 
1221 /*
1222  * Look up option "name". If it exists, return a pointer to its record.
1223  * Otherwise, if create_placeholders is true and name is a valid-looking
1224  * custom variable name, we'll create and return a placeholder record.
1225  * Otherwise, if skip_errors is true, then we silently return NULL for
1226  * an unrecognized or invalid name. Otherwise, the error is reported at
1227  * error level elevel (and we return NULL if that's less than ERROR).
1228  *
1229  * Note: internal errors, primarily out-of-memory, draw an elevel-level
1230  * report and NULL return regardless of skip_errors. Hence, callers must
1231  * handle a NULL return whenever elevel < ERROR, but they should not need
1232  * to emit any additional error message. (In practice, internal errors
1233  * can only happen when create_placeholders is true, so callers passing
1234  * false need not think terribly hard about this.)
1235  */
1236 struct config_generic *
1237 find_option(const char *name, bool create_placeholders, bool skip_errors,
1238  int elevel)
1239 {
1240  GUCHashEntry *hentry;
1241  int i;
1242 
1243  Assert(name);
1244 
1245  /* Look it up using the hash table. */
1246  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1247  &name,
1248  HASH_FIND,
1249  NULL);
1250  if (hentry)
1251  return hentry->gucvar;
1252 
1253  /*
1254  * See if the name is an obsolete name for a variable. We assume that the
1255  * set of supported old names is short enough that a brute-force search is
1256  * the best way.
1257  */
1258  for (i = 0; map_old_guc_names[i] != NULL; i += 2)
1259  {
1261  return find_option(map_old_guc_names[i + 1], false,
1262  skip_errors, elevel);
1263  }
1264 
1265  if (create_placeholders)
1266  {
1267  /*
1268  * Check if the name is valid, and if so, add a placeholder.
1269  */
1270  if (assignable_custom_variable_name(name, skip_errors, elevel))
1271  return add_placeholder_variable(name, elevel);
1272  else
1273  return NULL; /* error message, if any, already emitted */
1274  }
1275 
1276  /* Unknown name and we're not supposed to make a placeholder */
1277  if (!skip_errors)
1278  ereport(elevel,
1279  (errcode(ERRCODE_UNDEFINED_OBJECT),
1280  errmsg("unrecognized configuration parameter \"%s\"",
1281  name)));
1282  return NULL;
1283 }
1284 
1285 
1286 /*
1287  * comparator for qsorting an array of GUC pointers
1288  */
1289 static int
1290 guc_var_compare(const void *a, const void *b)
1291 {
1292  const struct config_generic *confa = *(struct config_generic *const *) a;
1293  const struct config_generic *confb = *(struct config_generic *const *) b;
1294 
1295  return guc_name_compare(confa->name, confb->name);
1296 }
1297 
1298 /*
1299  * the bare comparison function for GUC names
1300  */
1301 int
1302 guc_name_compare(const char *namea, const char *nameb)
1303 {
1304  /*
1305  * The temptation to use strcasecmp() here must be resisted, because the
1306  * hash mapping has to remain stable across setlocale() calls. So, build
1307  * our own with a simple ASCII-only downcasing.
1308  */
1309  while (*namea && *nameb)
1310  {
1311  char cha = *namea++;
1312  char chb = *nameb++;
1313 
1314  if (cha >= 'A' && cha <= 'Z')
1315  cha += 'a' - 'A';
1316  if (chb >= 'A' && chb <= 'Z')
1317  chb += 'a' - 'A';
1318  if (cha != chb)
1319  return cha - chb;
1320  }
1321  if (*namea)
1322  return 1; /* a is longer */
1323  if (*nameb)
1324  return -1; /* b is longer */
1325  return 0;
1326 }
1327 
1328 /*
1329  * Hash function that's compatible with guc_name_compare
1330  */
1331 static uint32
1332 guc_name_hash(const void *key, Size keysize)
1333 {
1334  uint32 result = 0;
1335  const char *name = *(const char *const *) key;
1336 
1337  while (*name)
1338  {
1339  char ch = *name++;
1340 
1341  /* Case-fold in the same way as guc_name_compare */
1342  if (ch >= 'A' && ch <= 'Z')
1343  ch += 'a' - 'A';
1344 
1345  /* Merge into hash ... not very bright, but it needn't be */
1346  result = pg_rotate_left32(result, 5);
1347  result ^= (uint32) ch;
1348  }
1349  return result;
1350 }
1351 
1352 /*
1353  * Dynahash match function to use in guc_hashtab
1354  */
1355 static int
1356 guc_name_match(const void *key1, const void *key2, Size keysize)
1357 {
1358  const char *name1 = *(const char *const *) key1;
1359  const char *name2 = *(const char *const *) key2;
1360 
1361  return guc_name_compare(name1, name2);
1362 }
1363 
1364 
1365 /*
1366  * Convert a GUC name to the form that should be used in pg_parameter_acl.
1367  *
1368  * We need to canonicalize entries since, for example, case should not be
1369  * significant. In addition, we apply the map_old_guc_names[] mapping so that
1370  * any obsolete names will be converted when stored in a new PG version.
1371  * Note however that this function does not verify legality of the name.
1372  *
1373  * The result is a palloc'd string.
1374  */
1375 char *
1377 {
1378  char *result;
1379 
1380  /* Apply old-GUC-name mapping. */
1381  for (int i = 0; map_old_guc_names[i] != NULL; i += 2)
1382  {
1384  {
1385  name = map_old_guc_names[i + 1];
1386  break;
1387  }
1388  }
1389 
1390  /* Apply case-folding that matches guc_name_compare(). */
1391  result = pstrdup(name);
1392  for (char *ptr = result; *ptr != '\0'; ptr++)
1393  {
1394  char ch = *ptr;
1395 
1396  if (ch >= 'A' && ch <= 'Z')
1397  {
1398  ch += 'a' - 'A';
1399  *ptr = ch;
1400  }
1401  }
1402 
1403  return result;
1404 }
1405 
1406 /*
1407  * Check whether we should allow creation of a pg_parameter_acl entry
1408  * for the given name. (This can be applied either before or after
1409  * canonicalizing it.) Throws error if not.
1410  */
1411 void
1413 {
1414  /* OK if the GUC exists. */
1415  if (find_option(name, false, true, DEBUG5) != NULL)
1416  return;
1417  /* Otherwise, it'd better be a valid custom GUC name. */
1418  (void) assignable_custom_variable_name(name, false, ERROR);
1419 }
1420 
1421 /*
1422  * Routine in charge of checking various states of a GUC.
1423  *
1424  * This performs two sanity checks. First, it checks that the initial
1425  * value of a GUC is the same when declared and when loaded to prevent
1426  * anybody looking at the C declarations of these GUCs from being fooled by
1427  * mismatched values. Second, it checks for incorrect flag combinations.
1428  *
1429  * The following validation rules apply for the values:
1430  * bool - can be false, otherwise must be same as the boot_val
1431  * int - can be 0, otherwise must be same as the boot_val
1432  * real - can be 0.0, otherwise must be same as the boot_val
1433  * string - can be NULL, otherwise must be strcmp equal to the boot_val
1434  * enum - must be same as the boot_val
1435  */
1436 #ifdef USE_ASSERT_CHECKING
1437 static bool
1438 check_GUC_init(struct config_generic *gconf)
1439 {
1440  /* Checks on values */
1441  switch (gconf->vartype)
1442  {
1443  case PGC_BOOL:
1444  {
1445  struct config_bool *conf = (struct config_bool *) gconf;
1446 
1447  if (*conf->variable && !conf->boot_val)
1448  {
1449  elog(LOG, "GUC (PGC_BOOL) %s, boot_val=%d, C-var=%d",
1450  conf->gen.name, conf->boot_val, *conf->variable);
1451  return false;
1452  }
1453  break;
1454  }
1455  case PGC_INT:
1456  {
1457  struct config_int *conf = (struct config_int *) gconf;
1458 
1459  if (*conf->variable != 0 && *conf->variable != conf->boot_val)
1460  {
1461  elog(LOG, "GUC (PGC_INT) %s, boot_val=%d, C-var=%d",
1462  conf->gen.name, conf->boot_val, *conf->variable);
1463  return false;
1464  }
1465  break;
1466  }
1467  case PGC_REAL:
1468  {
1469  struct config_real *conf = (struct config_real *) gconf;
1470 
1471  if (*conf->variable != 0.0 && *conf->variable != conf->boot_val)
1472  {
1473  elog(LOG, "GUC (PGC_REAL) %s, boot_val=%g, C-var=%g",
1474  conf->gen.name, conf->boot_val, *conf->variable);
1475  return false;
1476  }
1477  break;
1478  }
1479  case PGC_STRING:
1480  {
1481  struct config_string *conf = (struct config_string *) gconf;
1482 
1483  if (*conf->variable != NULL &&
1484  (conf->boot_val == NULL ||
1485  strcmp(*conf->variable, conf->boot_val) != 0))
1486  {
1487  elog(LOG, "GUC (PGC_STRING) %s, boot_val=%s, C-var=%s",
1488  conf->gen.name, conf->boot_val ? conf->boot_val : "<null>", *conf->variable);
1489  return false;
1490  }
1491  break;
1492  }
1493  case PGC_ENUM:
1494  {
1495  struct config_enum *conf = (struct config_enum *) gconf;
1496 
1497  if (*conf->variable != conf->boot_val)
1498  {
1499  elog(LOG, "GUC (PGC_ENUM) %s, boot_val=%d, C-var=%d",
1500  conf->gen.name, conf->boot_val, *conf->variable);
1501  return false;
1502  }
1503  break;
1504  }
1505  }
1506 
1507  /* Flag combinations */
1508 
1509  /*
1510  * GUC_NO_SHOW_ALL requires GUC_NOT_IN_SAMPLE, as a parameter not part of
1511  * SHOW ALL should not be hidden in postgresql.conf.sample.
1512  */
1513  if ((gconf->flags & GUC_NO_SHOW_ALL) &&
1514  !(gconf->flags & GUC_NOT_IN_SAMPLE))
1515  {
1516  elog(LOG, "GUC %s flags: NO_SHOW_ALL and !NOT_IN_SAMPLE",
1517  gconf->name);
1518  return false;
1519  }
1520 
1521  return true;
1522 }
1523 #endif
1524 
1525 /*
1526  * Initialize GUC options during program startup.
1527  *
1528  * Note that we cannot read the config file yet, since we have not yet
1529  * processed command-line switches.
1530  */
1531 void
1533 {
1534  HASH_SEQ_STATUS status;
1535  GUCHashEntry *hentry;
1536 
1537  /*
1538  * Before log_line_prefix could possibly receive a nonempty setting, make
1539  * sure that timezone processing is minimally alive (see elog.c).
1540  */
1542 
1543  /*
1544  * Create GUCMemoryContext and build hash table of all GUC variables.
1545  */
1547 
1548  /*
1549  * Load all variables with their compiled-in defaults, and initialize
1550  * status fields as needed.
1551  */
1552  hash_seq_init(&status, guc_hashtab);
1553  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
1554  {
1555  /* Check mapping between initial and default value */
1556  Assert(check_GUC_init(hentry->gucvar));
1557 
1558  InitializeOneGUCOption(hentry->gucvar);
1559  }
1560 
1561  reporting_enabled = false;
1562 
1563  /*
1564  * Prevent any attempt to override the transaction modes from
1565  * non-interactive sources.
1566  */
1567  SetConfigOption("transaction_isolation", "read committed",
1569  SetConfigOption("transaction_read_only", "no",
1571  SetConfigOption("transaction_deferrable", "no",
1573 
1574  /*
1575  * For historical reasons, some GUC parameters can receive defaults from
1576  * environment variables. Process those settings.
1577  */
1579 }
1580 
1581 /*
1582  * Assign any GUC values that can come from the server's environment.
1583  *
1584  * This is called from InitializeGUCOptions, and also from ProcessConfigFile
1585  * to deal with the possibility that a setting has been removed from
1586  * postgresql.conf and should now get a value from the environment.
1587  * (The latter is a kludge that should probably go away someday; if so,
1588  * fold this back into InitializeGUCOptions.)
1589  */
1590 static void
1592 {
1593  char *env;
1594  long stack_rlimit;
1595 
1596  env = getenv("PGPORT");
1597  if (env != NULL)
1599 
1600  env = getenv("PGDATESTYLE");
1601  if (env != NULL)
1602  SetConfigOption("datestyle", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
1603 
1604  env = getenv("PGCLIENTENCODING");
1605  if (env != NULL)
1606  SetConfigOption("client_encoding", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
1607 
1608  /*
1609  * rlimit isn't exactly an "environment variable", but it behaves about
1610  * the same. If we can identify the platform stack depth rlimit, increase
1611  * default stack depth setting up to whatever is safe (but at most 2MB).
1612  * Report the value's source as PGC_S_DYNAMIC_DEFAULT if it's 2MB, or as
1613  * PGC_S_ENV_VAR if it's reflecting the rlimit limit.
1614  */
1615  stack_rlimit = get_stack_depth_rlimit();
1616  if (stack_rlimit > 0)
1617  {
1618  long new_limit = (stack_rlimit - STACK_DEPTH_SLOP) / 1024L;
1619 
1620  if (new_limit > 100)
1621  {
1622  GucSource source;
1623  char limbuf[16];
1624 
1625  if (new_limit < 2048)
1627  else
1628  {
1629  new_limit = 2048;
1631  }
1632  snprintf(limbuf, sizeof(limbuf), "%ld", new_limit);
1633  SetConfigOption("max_stack_depth", limbuf,
1635  }
1636  }
1637 }
1638 
1639 /*
1640  * Initialize one GUC option variable to its compiled-in default.
1641  *
1642  * Note: the reason for calling check_hooks is not that we think the boot_val
1643  * might fail, but that the hooks might wish to compute an "extra" struct.
1644  */
1645 static void
1647 {
1648  gconf->status = 0;
1649  gconf->source = PGC_S_DEFAULT;
1650  gconf->reset_source = PGC_S_DEFAULT;
1651  gconf->scontext = PGC_INTERNAL;
1652  gconf->reset_scontext = PGC_INTERNAL;
1653  gconf->srole = BOOTSTRAP_SUPERUSERID;
1654  gconf->reset_srole = BOOTSTRAP_SUPERUSERID;
1655  gconf->stack = NULL;
1656  gconf->extra = NULL;
1657  gconf->last_reported = NULL;
1658  gconf->sourcefile = NULL;
1659  gconf->sourceline = 0;
1660 
1661  switch (gconf->vartype)
1662  {
1663  case PGC_BOOL:
1664  {
1665  struct config_bool *conf = (struct config_bool *) gconf;
1666  bool newval = conf->boot_val;
1667  void *extra = NULL;
1668 
1669  if (!call_bool_check_hook(conf, &newval, &extra,
1670  PGC_S_DEFAULT, LOG))
1671  elog(FATAL, "failed to initialize %s to %d",
1672  conf->gen.name, (int) newval);
1673  if (conf->assign_hook)
1674  conf->assign_hook(newval, extra);
1675  *conf->variable = conf->reset_val = newval;
1676  conf->gen.extra = conf->reset_extra = extra;
1677  break;
1678  }
1679  case PGC_INT:
1680  {
1681  struct config_int *conf = (struct config_int *) gconf;
1682  int newval = conf->boot_val;
1683  void *extra = NULL;
1684 
1685  Assert(newval >= conf->min);
1686  Assert(newval <= conf->max);
1687  if (!call_int_check_hook(conf, &newval, &extra,
1688  PGC_S_DEFAULT, LOG))
1689  elog(FATAL, "failed to initialize %s to %d",
1690  conf->gen.name, newval);
1691  if (conf->assign_hook)
1692  conf->assign_hook(newval, extra);
1693  *conf->variable = conf->reset_val = newval;
1694  conf->gen.extra = conf->reset_extra = extra;
1695  break;
1696  }
1697  case PGC_REAL:
1698  {
1699  struct config_real *conf = (struct config_real *) gconf;
1700  double newval = conf->boot_val;
1701  void *extra = NULL;
1702 
1703  Assert(newval >= conf->min);
1704  Assert(newval <= conf->max);
1705  if (!call_real_check_hook(conf, &newval, &extra,
1706  PGC_S_DEFAULT, LOG))
1707  elog(FATAL, "failed to initialize %s to %g",
1708  conf->gen.name, newval);
1709  if (conf->assign_hook)
1710  conf->assign_hook(newval, extra);
1711  *conf->variable = conf->reset_val = newval;
1712  conf->gen.extra = conf->reset_extra = extra;
1713  break;
1714  }
1715  case PGC_STRING:
1716  {
1717  struct config_string *conf = (struct config_string *) gconf;
1718  char *newval;
1719  void *extra = NULL;
1720 
1721  /* non-NULL boot_val must always get strdup'd */
1722  if (conf->boot_val != NULL)
1723  newval = guc_strdup(FATAL, conf->boot_val);
1724  else
1725  newval = NULL;
1726 
1727  if (!call_string_check_hook(conf, &newval, &extra,
1728  PGC_S_DEFAULT, LOG))
1729  elog(FATAL, "failed to initialize %s to \"%s\"",
1730  conf->gen.name, newval ? newval : "");
1731  if (conf->assign_hook)
1732  conf->assign_hook(newval, extra);
1733  *conf->variable = conf->reset_val = newval;
1734  conf->gen.extra = conf->reset_extra = extra;
1735  break;
1736  }
1737  case PGC_ENUM:
1738  {
1739  struct config_enum *conf = (struct config_enum *) gconf;
1740  int newval = conf->boot_val;
1741  void *extra = NULL;
1742 
1743  if (!call_enum_check_hook(conf, &newval, &extra,
1744  PGC_S_DEFAULT, LOG))
1745  elog(FATAL, "failed to initialize %s to %d",
1746  conf->gen.name, newval);
1747  if (conf->assign_hook)
1748  conf->assign_hook(newval, extra);
1749  *conf->variable = conf->reset_val = newval;
1750  conf->gen.extra = conf->reset_extra = extra;
1751  break;
1752  }
1753  }
1754 }
1755 
1756 /*
1757  * Summarily remove a GUC variable from any linked lists it's in.
1758  *
1759  * We use this in cases where the variable is about to be deleted or reset.
1760  * These aren't common operations, so it's okay if this is a bit slow.
1761  */
1762 static void
1764 {
1765  if (gconf->source != PGC_S_DEFAULT)
1766  dlist_delete(&gconf->nondef_link);
1767  if (gconf->stack != NULL)
1769  if (gconf->status & GUC_NEEDS_REPORT)
1771 }
1772 
1773 
1774 /*
1775  * Select the configuration files and data directory to be used, and
1776  * do the initial read of postgresql.conf.
1777  *
1778  * This is called after processing command-line switches.
1779  * userDoption is the -D switch value if any (NULL if unspecified).
1780  * progname is just for use in error messages.
1781  *
1782  * Returns true on success; on failure, prints a suitable error message
1783  * to stderr and returns false.
1784  */
1785 bool
1786 SelectConfigFiles(const char *userDoption, const char *progname)
1787 {
1788  char *configdir;
1789  char *fname;
1790  bool fname_is_malloced;
1791  struct stat stat_buf;
1792  struct config_string *data_directory_rec;
1793 
1794  /* configdir is -D option, or $PGDATA if no -D */
1795  if (userDoption)
1796  configdir = make_absolute_path(userDoption);
1797  else
1798  configdir = make_absolute_path(getenv("PGDATA"));
1799 
1800  if (configdir && stat(configdir, &stat_buf) != 0)
1801  {
1802  write_stderr("%s: could not access directory \"%s\": %m\n",
1803  progname,
1804  configdir);
1805  if (errno == ENOENT)
1806  write_stderr("Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n");
1807  return false;
1808  }
1809 
1810  /*
1811  * Find the configuration file: if config_file was specified on the
1812  * command line, use it, else use configdir/postgresql.conf. In any case
1813  * ensure the result is an absolute path, so that it will be interpreted
1814  * the same way by future backends.
1815  */
1816  if (ConfigFileName)
1817  {
1819  fname_is_malloced = true;
1820  }
1821  else if (configdir)
1822  {
1823  fname = guc_malloc(FATAL,
1824  strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
1825  sprintf(fname, "%s/%s", configdir, CONFIG_FILENAME);
1826  fname_is_malloced = false;
1827  }
1828  else
1829  {
1830  write_stderr("%s does not know where to find the server configuration file.\n"
1831  "You must specify the --config-file or -D invocation "
1832  "option or set the PGDATA environment variable.\n",
1833  progname);
1834  return false;
1835  }
1836 
1837  /*
1838  * Set the ConfigFileName GUC variable to its final value, ensuring that
1839  * it can't be overridden later.
1840  */
1841  SetConfigOption("config_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1842 
1843  if (fname_is_malloced)
1844  free(fname);
1845  else
1846  guc_free(fname);
1847 
1848  /*
1849  * Now read the config file for the first time.
1850  */
1851  if (stat(ConfigFileName, &stat_buf) != 0)
1852  {
1853  write_stderr("%s: could not access the server configuration file \"%s\": %m\n",
1855  free(configdir);
1856  return false;
1857  }
1858 
1859  /*
1860  * Read the configuration file for the first time. This time only the
1861  * data_directory parameter is picked up to determine the data directory,
1862  * so that we can read the PG_AUTOCONF_FILENAME file next time.
1863  */
1865 
1866  /*
1867  * If the data_directory GUC variable has been set, use that as DataDir;
1868  * otherwise use configdir if set; else punt.
1869  *
1870  * Note: SetDataDir will copy and absolute-ize its argument, so we don't
1871  * have to.
1872  */
1873  data_directory_rec = (struct config_string *)
1874  find_option("data_directory", false, false, PANIC);
1875  if (*data_directory_rec->variable)
1876  SetDataDir(*data_directory_rec->variable);
1877  else if (configdir)
1878  SetDataDir(configdir);
1879  else
1880  {
1881  write_stderr("%s does not know where to find the database system data.\n"
1882  "This can be specified as data_directory in \"%s\", "
1883  "or by the -D invocation option, or by the "
1884  "PGDATA environment variable.\n",
1886  return false;
1887  }
1888 
1889  /*
1890  * Reflect the final DataDir value back into the data_directory GUC var.
1891  * (If you are wondering why we don't just make them a single variable,
1892  * it's because the EXEC_BACKEND case needs DataDir to be transmitted to
1893  * child backends specially. XXX is that still true? Given that we now
1894  * chdir to DataDir, EXEC_BACKEND can read the config file without knowing
1895  * DataDir in advance.)
1896  */
1898 
1899  /*
1900  * Now read the config file a second time, allowing any settings in the
1901  * PG_AUTOCONF_FILENAME file to take effect. (This is pretty ugly, but
1902  * since we have to determine the DataDir before we can find the autoconf
1903  * file, the alternatives seem worse.)
1904  */
1906 
1907  /*
1908  * If timezone_abbreviations wasn't set in the configuration file, install
1909  * the default value. We do it this way because we can't safely install a
1910  * "real" value until my_exec_path is set, which may not have happened
1911  * when InitializeGUCOptions runs, so the bootstrap default value cannot
1912  * be the real desired default.
1913  */
1915 
1916  /*
1917  * Figure out where pg_hba.conf is, and make sure the path is absolute.
1918  */
1919  if (HbaFileName)
1920  {
1922  fname_is_malloced = true;
1923  }
1924  else if (configdir)
1925  {
1926  fname = guc_malloc(FATAL,
1927  strlen(configdir) + strlen(HBA_FILENAME) + 2);
1928  sprintf(fname, "%s/%s", configdir, HBA_FILENAME);
1929  fname_is_malloced = false;
1930  }
1931  else
1932  {
1933  write_stderr("%s does not know where to find the \"hba\" configuration file.\n"
1934  "This can be specified as \"hba_file\" in \"%s\", "
1935  "or by the -D invocation option, or by the "
1936  "PGDATA environment variable.\n",
1938  return false;
1939  }
1940  SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1941 
1942  if (fname_is_malloced)
1943  free(fname);
1944  else
1945  guc_free(fname);
1946 
1947  /*
1948  * Likewise for pg_ident.conf.
1949  */
1950  if (IdentFileName)
1951  {
1953  fname_is_malloced = true;
1954  }
1955  else if (configdir)
1956  {
1957  fname = guc_malloc(FATAL,
1958  strlen(configdir) + strlen(IDENT_FILENAME) + 2);
1959  sprintf(fname, "%s/%s", configdir, IDENT_FILENAME);
1960  fname_is_malloced = false;
1961  }
1962  else
1963  {
1964  write_stderr("%s does not know where to find the \"ident\" configuration file.\n"
1965  "This can be specified as \"ident_file\" in \"%s\", "
1966  "or by the -D invocation option, or by the "
1967  "PGDATA environment variable.\n",
1969  return false;
1970  }
1971  SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1972 
1973  if (fname_is_malloced)
1974  free(fname);
1975  else
1976  guc_free(fname);
1977 
1978  free(configdir);
1979 
1980  return true;
1981 }
1982 
1983 /*
1984  * pg_timezone_abbrev_initialize --- set default value if not done already
1985  *
1986  * This is called after initial loading of postgresql.conf. If no
1987  * timezone_abbreviations setting was found therein, select default.
1988  * If a non-default value is already installed, nothing will happen.
1989  *
1990  * This can also be called from ProcessConfigFile to establish the default
1991  * value after a postgresql.conf entry for it is removed.
1992  */
1993 static void
1995 {
1996  SetConfigOption("timezone_abbreviations", "Default",
1998 }
1999 
2000 
2001 /*
2002  * Reset all options to their saved default values (implements RESET ALL)
2003  */
2004 void
2006 {
2007  dlist_mutable_iter iter;
2008 
2009  /* We need only consider GUCs not already at PGC_S_DEFAULT */
2011  {
2012  struct config_generic *gconf = dlist_container(struct config_generic,
2013  nondef_link, iter.cur);
2014 
2015  /* Don't reset non-SET-able values */
2016  if (gconf->context != PGC_SUSET &&
2017  gconf->context != PGC_USERSET)
2018  continue;
2019  /* Don't reset if special exclusion from RESET ALL */
2020  if (gconf->flags & GUC_NO_RESET_ALL)
2021  continue;
2022  /* No need to reset if wasn't SET */
2023  if (gconf->source <= PGC_S_OVERRIDE)
2024  continue;
2025 
2026  /* Save old value to support transaction abort */
2028 
2029  switch (gconf->vartype)
2030  {
2031  case PGC_BOOL:
2032  {
2033  struct config_bool *conf = (struct config_bool *) gconf;
2034 
2035  if (conf->assign_hook)
2036  conf->assign_hook(conf->reset_val,
2037  conf->reset_extra);
2038  *conf->variable = conf->reset_val;
2039  set_extra_field(&conf->gen, &conf->gen.extra,
2040  conf->reset_extra);
2041  break;
2042  }
2043  case PGC_INT:
2044  {
2045  struct config_int *conf = (struct config_int *) gconf;
2046 
2047  if (conf->assign_hook)
2048  conf->assign_hook(conf->reset_val,
2049  conf->reset_extra);
2050  *conf->variable = conf->reset_val;
2051  set_extra_field(&conf->gen, &conf->gen.extra,
2052  conf->reset_extra);
2053  break;
2054  }
2055  case PGC_REAL:
2056  {
2057  struct config_real *conf = (struct config_real *) gconf;
2058 
2059  if (conf->assign_hook)
2060  conf->assign_hook(conf->reset_val,
2061  conf->reset_extra);
2062  *conf->variable = conf->reset_val;
2063  set_extra_field(&conf->gen, &conf->gen.extra,
2064  conf->reset_extra);
2065  break;
2066  }
2067  case PGC_STRING:
2068  {
2069  struct config_string *conf = (struct config_string *) gconf;
2070 
2071  if (conf->assign_hook)
2072  conf->assign_hook(conf->reset_val,
2073  conf->reset_extra);
2074  set_string_field(conf, conf->variable, conf->reset_val);
2075  set_extra_field(&conf->gen, &conf->gen.extra,
2076  conf->reset_extra);
2077  break;
2078  }
2079  case PGC_ENUM:
2080  {
2081  struct config_enum *conf = (struct config_enum *) gconf;
2082 
2083  if (conf->assign_hook)
2084  conf->assign_hook(conf->reset_val,
2085  conf->reset_extra);
2086  *conf->variable = conf->reset_val;
2087  set_extra_field(&conf->gen, &conf->gen.extra,
2088  conf->reset_extra);
2089  break;
2090  }
2091  }
2092 
2093  set_guc_source(gconf, gconf->reset_source);
2094  gconf->scontext = gconf->reset_scontext;
2095  gconf->srole = gconf->reset_srole;
2096 
2097  if ((gconf->flags & GUC_REPORT) && !(gconf->status & GUC_NEEDS_REPORT))
2098  {
2099  gconf->status |= GUC_NEEDS_REPORT;
2101  }
2102  }
2103 }
2104 
2105 
2106 /*
2107  * Apply a change to a GUC variable's "source" field.
2108  *
2109  * Use this rather than just assigning, to ensure that the variable's
2110  * membership in guc_nondef_list is updated correctly.
2111  */
2112 static void
2113 set_guc_source(struct config_generic *gconf, GucSource newsource)
2114 {
2115  /* Adjust nondef list membership if appropriate for change */
2116  if (gconf->source == PGC_S_DEFAULT)
2117  {
2118  if (newsource != PGC_S_DEFAULT)
2120  }
2121  else
2122  {
2123  if (newsource == PGC_S_DEFAULT)
2124  dlist_delete(&gconf->nondef_link);
2125  }
2126  /* Now update the source field */
2127  gconf->source = newsource;
2128 }
2129 
2130 
2131 /*
2132  * push_old_value
2133  * Push previous state during transactional assignment to a GUC variable.
2134  */
2135 static void
2137 {
2138  GucStack *stack;
2139 
2140  /* If we're not inside a nest level, do nothing */
2141  if (GUCNestLevel == 0)
2142  return;
2143 
2144  /* Do we already have a stack entry of the current nest level? */
2145  stack = gconf->stack;
2146  if (stack && stack->nest_level >= GUCNestLevel)
2147  {
2148  /* Yes, so adjust its state if necessary */
2149  Assert(stack->nest_level == GUCNestLevel);
2150  switch (action)
2151  {
2152  case GUC_ACTION_SET:
2153  /* SET overrides any prior action at same nest level */
2154  if (stack->state == GUC_SET_LOCAL)
2155  {
2156  /* must discard old masked value */
2157  discard_stack_value(gconf, &stack->masked);
2158  }
2159  stack->state = GUC_SET;
2160  break;
2161  case GUC_ACTION_LOCAL:
2162  if (stack->state == GUC_SET)
2163  {
2164  /* SET followed by SET LOCAL, remember SET's value */
2165  stack->masked_scontext = gconf->scontext;
2166  stack->masked_srole = gconf->srole;
2167  set_stack_value(gconf, &stack->masked);
2168  stack->state = GUC_SET_LOCAL;
2169  }
2170  /* in all other cases, no change to stack entry */
2171  break;
2172  case GUC_ACTION_SAVE:
2173  /* Could only have a prior SAVE of same variable */
2174  Assert(stack->state == GUC_SAVE);
2175  break;
2176  }
2177  return;
2178  }
2179 
2180  /*
2181  * Push a new stack entry
2182  *
2183  * We keep all the stack entries in TopTransactionContext for simplicity.
2184  */
2186  sizeof(GucStack));
2187 
2188  stack->prev = gconf->stack;
2189  stack->nest_level = GUCNestLevel;
2190  switch (action)
2191  {
2192  case GUC_ACTION_SET:
2193  stack->state = GUC_SET;
2194  break;
2195  case GUC_ACTION_LOCAL:
2196  stack->state = GUC_LOCAL;
2197  break;
2198  case GUC_ACTION_SAVE:
2199  stack->state = GUC_SAVE;
2200  break;
2201  }
2202  stack->source = gconf->source;
2203  stack->scontext = gconf->scontext;
2204  stack->srole = gconf->srole;
2205  set_stack_value(gconf, &stack->prior);
2206 
2207  if (gconf->stack == NULL)
2209  gconf->stack = stack;
2210 }
2211 
2212 
2213 /*
2214  * Do GUC processing at main transaction start.
2215  */
2216 void
2218 {
2219  /*
2220  * The nest level should be 0 between transactions; if it isn't, somebody
2221  * didn't call AtEOXact_GUC, or called it with the wrong nestLevel. We
2222  * throw a warning but make no other effort to clean up.
2223  */
2224  if (GUCNestLevel != 0)
2225  elog(WARNING, "GUC nest level = %d at transaction start",
2226  GUCNestLevel);
2227  GUCNestLevel = 1;
2228 }
2229 
2230 /*
2231  * Enter a new nesting level for GUC values. This is called at subtransaction
2232  * start, and when entering a function that has proconfig settings, and in
2233  * some other places where we want to set GUC variables transiently.
2234  * NOTE we must not risk error here, else subtransaction start will be unhappy.
2235  */
2236 int
2238 {
2239  return ++GUCNestLevel;
2240 }
2241 
2242 /*
2243  * Set search_path to a fixed value for maintenance operations. No effect
2244  * during bootstrap, when the search_path is already set to a fixed value and
2245  * cannot be changed.
2246  */
2247 void
2249 {
2252  PGC_S_SESSION, GUC_ACTION_SAVE, true, 0, false);
2253 }
2254 
2255 /*
2256  * Do GUC processing at transaction or subtransaction commit or abort, or
2257  * when exiting a function that has proconfig settings, or when undoing a
2258  * transient assignment to some GUC variables. (The name is thus a bit of
2259  * a misnomer; perhaps it should be ExitGUCNestLevel or some such.)
2260  * During abort, we discard all GUC settings that were applied at nesting
2261  * levels >= nestLevel. nestLevel == 1 corresponds to the main transaction.
2262  */
2263 void
2264 AtEOXact_GUC(bool isCommit, int nestLevel)
2265 {
2266  slist_mutable_iter iter;
2267 
2268  /*
2269  * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
2270  * abort, if there is a failure during transaction start before
2271  * AtStart_GUC is called.
2272  */
2273  Assert(nestLevel > 0 &&
2274  (nestLevel <= GUCNestLevel ||
2275  (nestLevel == GUCNestLevel + 1 && !isCommit)));
2276 
2277  /* We need only process GUCs having nonempty stacks */
2279  {
2280  struct config_generic *gconf = slist_container(struct config_generic,
2281  stack_link, iter.cur);
2282  GucStack *stack;
2283 
2284  /*
2285  * Process and pop each stack entry within the nest level. To simplify
2286  * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
2287  * we allow failure exit from code that uses a local nest level to be
2288  * recovered at the surrounding transaction or subtransaction abort;
2289  * so there could be more than one stack entry to pop.
2290  */
2291  while ((stack = gconf->stack) != NULL &&
2292  stack->nest_level >= nestLevel)
2293  {
2294  GucStack *prev = stack->prev;
2295  bool restorePrior = false;
2296  bool restoreMasked = false;
2297  bool changed;
2298 
2299  /*
2300  * In this next bit, if we don't set either restorePrior or
2301  * restoreMasked, we must "discard" any unwanted fields of the
2302  * stack entries to avoid leaking memory. If we do set one of
2303  * those flags, unused fields will be cleaned up after restoring.
2304  */
2305  if (!isCommit) /* if abort, always restore prior value */
2306  restorePrior = true;
2307  else if (stack->state == GUC_SAVE)
2308  restorePrior = true;
2309  else if (stack->nest_level == 1)
2310  {
2311  /* transaction commit */
2312  if (stack->state == GUC_SET_LOCAL)
2313  restoreMasked = true;
2314  else if (stack->state == GUC_SET)
2315  {
2316  /* we keep the current active value */
2317  discard_stack_value(gconf, &stack->prior);
2318  }
2319  else /* must be GUC_LOCAL */
2320  restorePrior = true;
2321  }
2322  else if (prev == NULL ||
2323  prev->nest_level < stack->nest_level - 1)
2324  {
2325  /* decrement entry's level and do not pop it */
2326  stack->nest_level--;
2327  continue;
2328  }
2329  else
2330  {
2331  /*
2332  * We have to merge this stack entry into prev. See README for
2333  * discussion of this bit.
2334  */
2335  switch (stack->state)
2336  {
2337  case GUC_SAVE:
2338  Assert(false); /* can't get here */
2339  break;
2340 
2341  case GUC_SET:
2342  /* next level always becomes SET */
2343  discard_stack_value(gconf, &stack->prior);
2344  if (prev->state == GUC_SET_LOCAL)
2345  discard_stack_value(gconf, &prev->masked);
2346  prev->state = GUC_SET;
2347  break;
2348 
2349  case GUC_LOCAL:
2350  if (prev->state == GUC_SET)
2351  {
2352  /* LOCAL migrates down */
2353  prev->masked_scontext = stack->scontext;
2354  prev->masked_srole = stack->srole;
2355  prev->masked = stack->prior;
2356  prev->state = GUC_SET_LOCAL;
2357  }
2358  else
2359  {
2360  /* else just forget this stack level */
2361  discard_stack_value(gconf, &stack->prior);
2362  }
2363  break;
2364 
2365  case GUC_SET_LOCAL:
2366  /* prior state at this level no longer wanted */
2367  discard_stack_value(gconf, &stack->prior);
2368  /* copy down the masked state */
2370  prev->masked_srole = stack->masked_srole;
2371  if (prev->state == GUC_SET_LOCAL)
2372  discard_stack_value(gconf, &prev->masked);
2373  prev->masked = stack->masked;
2374  prev->state = GUC_SET_LOCAL;
2375  break;
2376  }
2377  }
2378 
2379  changed = false;
2380 
2381  if (restorePrior || restoreMasked)
2382  {
2383  /* Perform appropriate restoration of the stacked value */
2384  config_var_value newvalue;
2385  GucSource newsource;
2386  GucContext newscontext;
2387  Oid newsrole;
2388 
2389  if (restoreMasked)
2390  {
2391  newvalue = stack->masked;
2392  newsource = PGC_S_SESSION;
2393  newscontext = stack->masked_scontext;
2394  newsrole = stack->masked_srole;
2395  }
2396  else
2397  {
2398  newvalue = stack->prior;
2399  newsource = stack->source;
2400  newscontext = stack->scontext;
2401  newsrole = stack->srole;
2402  }
2403 
2404  switch (gconf->vartype)
2405  {
2406  case PGC_BOOL:
2407  {
2408  struct config_bool *conf = (struct config_bool *) gconf;
2409  bool newval = newvalue.val.boolval;
2410  void *newextra = newvalue.extra;
2411 
2412  if (*conf->variable != newval ||
2413  conf->gen.extra != newextra)
2414  {
2415  if (conf->assign_hook)
2416  conf->assign_hook(newval, newextra);
2417  *conf->variable = newval;
2418  set_extra_field(&conf->gen, &conf->gen.extra,
2419  newextra);
2420  changed = true;
2421  }
2422  break;
2423  }
2424  case PGC_INT:
2425  {
2426  struct config_int *conf = (struct config_int *) gconf;
2427  int newval = newvalue.val.intval;
2428  void *newextra = newvalue.extra;
2429 
2430  if (*conf->variable != newval ||
2431  conf->gen.extra != newextra)
2432  {
2433  if (conf->assign_hook)
2434  conf->assign_hook(newval, newextra);
2435  *conf->variable = newval;
2436  set_extra_field(&conf->gen, &conf->gen.extra,
2437  newextra);
2438  changed = true;
2439  }
2440  break;
2441  }
2442  case PGC_REAL:
2443  {
2444  struct config_real *conf = (struct config_real *) gconf;
2445  double newval = newvalue.val.realval;
2446  void *newextra = newvalue.extra;
2447 
2448  if (*conf->variable != newval ||
2449  conf->gen.extra != newextra)
2450  {
2451  if (conf->assign_hook)
2452  conf->assign_hook(newval, newextra);
2453  *conf->variable = newval;
2454  set_extra_field(&conf->gen, &conf->gen.extra,
2455  newextra);
2456  changed = true;
2457  }
2458  break;
2459  }
2460  case PGC_STRING:
2461  {
2462  struct config_string *conf = (struct config_string *) gconf;
2463  char *newval = newvalue.val.stringval;
2464  void *newextra = newvalue.extra;
2465 
2466  if (*conf->variable != newval ||
2467  conf->gen.extra != newextra)
2468  {
2469  if (conf->assign_hook)
2470  conf->assign_hook(newval, newextra);
2471  set_string_field(conf, conf->variable, newval);
2472  set_extra_field(&conf->gen, &conf->gen.extra,
2473  newextra);
2474  changed = true;
2475  }
2476 
2477  /*
2478  * Release stacked values if not used anymore. We
2479  * could use discard_stack_value() here, but since
2480  * we have type-specific code anyway, might as
2481  * well inline it.
2482  */
2483  set_string_field(conf, &stack->prior.val.stringval, NULL);
2484  set_string_field(conf, &stack->masked.val.stringval, NULL);
2485  break;
2486  }
2487  case PGC_ENUM:
2488  {
2489  struct config_enum *conf = (struct config_enum *) gconf;
2490  int newval = newvalue.val.enumval;
2491  void *newextra = newvalue.extra;
2492 
2493  if (*conf->variable != newval ||
2494  conf->gen.extra != newextra)
2495  {
2496  if (conf->assign_hook)
2497  conf->assign_hook(newval, newextra);
2498  *conf->variable = newval;
2499  set_extra_field(&conf->gen, &conf->gen.extra,
2500  newextra);
2501  changed = true;
2502  }
2503  break;
2504  }
2505  }
2506 
2507  /*
2508  * Release stacked extra values if not used anymore.
2509  */
2510  set_extra_field(gconf, &(stack->prior.extra), NULL);
2511  set_extra_field(gconf, &(stack->masked.extra), NULL);
2512 
2513  /* And restore source information */
2514  set_guc_source(gconf, newsource);
2515  gconf->scontext = newscontext;
2516  gconf->srole = newsrole;
2517  }
2518 
2519  /*
2520  * Pop the GUC's state stack; if it's now empty, remove the GUC
2521  * from guc_stack_list.
2522  */
2523  gconf->stack = prev;
2524  if (prev == NULL)
2525  slist_delete_current(&iter);
2526  pfree(stack);
2527 
2528  /* Report new value if we changed it */
2529  if (changed && (gconf->flags & GUC_REPORT) &&
2530  !(gconf->status & GUC_NEEDS_REPORT))
2531  {
2532  gconf->status |= GUC_NEEDS_REPORT;
2534  }
2535  } /* end of stack-popping loop */
2536  }
2537 
2538  /* Update nesting level */
2539  GUCNestLevel = nestLevel - 1;
2540 }
2541 
2542 
2543 /*
2544  * Start up automatic reporting of changes to variables marked GUC_REPORT.
2545  * This is executed at completion of backend startup.
2546  */
2547 void
2549 {
2550  HASH_SEQ_STATUS status;
2551  GUCHashEntry *hentry;
2552 
2553  /*
2554  * Don't do anything unless talking to an interactive frontend.
2555  */
2557  return;
2558 
2559  reporting_enabled = true;
2560 
2561  /*
2562  * Hack for in_hot_standby: set the GUC value true if appropriate. This
2563  * is kind of an ugly place to do it, but there's few better options.
2564  *
2565  * (This could be out of date by the time we actually send it, in which
2566  * case the next ReportChangedGUCOptions call will send a duplicate
2567  * report.)
2568  */
2569  if (RecoveryInProgress())
2570  SetConfigOption("in_hot_standby", "true",
2572 
2573  /* Transmit initial values of interesting variables */
2574  hash_seq_init(&status, guc_hashtab);
2575  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
2576  {
2577  struct config_generic *conf = hentry->gucvar;
2578 
2579  if (conf->flags & GUC_REPORT)
2580  ReportGUCOption(conf);
2581  }
2582 }
2583 
2584 /*
2585  * ReportChangedGUCOptions: report recently-changed GUC_REPORT variables
2586  *
2587  * This is called just before we wait for a new client query.
2588  *
2589  * By handling things this way, we ensure that a ParameterStatus message
2590  * is sent at most once per variable per query, even if the variable
2591  * changed multiple times within the query. That's quite possible when
2592  * using features such as function SET clauses. Function SET clauses
2593  * also tend to cause values to change intraquery but eventually revert
2594  * to their prevailing values; ReportGUCOption is responsible for avoiding
2595  * redundant reports in such cases.
2596  */
2597 void
2599 {
2600  slist_mutable_iter iter;
2601 
2602  /* Quick exit if not (yet) enabled */
2603  if (!reporting_enabled)
2604  return;
2605 
2606  /*
2607  * Since in_hot_standby isn't actually changed by normal GUC actions, we
2608  * need a hack to check whether a new value needs to be reported to the
2609  * client. For speed, we rely on the assumption that it can never
2610  * transition from false to true.
2611  */
2613  SetConfigOption("in_hot_standby", "false",
2615 
2616  /* Transmit new values of interesting variables */
2618  {
2619  struct config_generic *conf = slist_container(struct config_generic,
2620  report_link, iter.cur);
2621 
2622  Assert((conf->flags & GUC_REPORT) && (conf->status & GUC_NEEDS_REPORT));
2623  ReportGUCOption(conf);
2624  conf->status &= ~GUC_NEEDS_REPORT;
2625  slist_delete_current(&iter);
2626  }
2627 }
2628 
2629 /*
2630  * ReportGUCOption: if appropriate, transmit option value to frontend
2631  *
2632  * We need not transmit the value if it's the same as what we last
2633  * transmitted.
2634  */
2635 static void
2637 {
2638  char *val = ShowGUCOption(record, false);
2639 
2640  if (record->last_reported == NULL ||
2641  strcmp(val, record->last_reported) != 0)
2642  {
2643  StringInfoData msgbuf;
2644 
2646  pq_sendstring(&msgbuf, record->name);
2647  pq_sendstring(&msgbuf, val);
2648  pq_endmessage(&msgbuf);
2649 
2650  /*
2651  * We need a long-lifespan copy. If guc_strdup() fails due to OOM,
2652  * we'll set last_reported to NULL and thereby possibly make a
2653  * duplicate report later.
2654  */
2655  guc_free(record->last_reported);
2656  record->last_reported = guc_strdup(LOG, val);
2657  }
2658 
2659  pfree(val);
2660 }
2661 
2662 /*
2663  * Convert a value from one of the human-friendly units ("kB", "min" etc.)
2664  * to the given base unit. 'value' and 'unit' are the input value and unit
2665  * to convert from (there can be trailing spaces in the unit string).
2666  * The converted value is stored in *base_value.
2667  * It's caller's responsibility to round off the converted value as necessary
2668  * and check for out-of-range.
2669  *
2670  * Returns true on success, false if the input unit is not recognized.
2671  */
2672 static bool
2673 convert_to_base_unit(double value, const char *unit,
2674  int base_unit, double *base_value)
2675 {
2676  char unitstr[MAX_UNIT_LEN + 1];
2677  int unitlen;
2678  const unit_conversion *table;
2679  int i;
2680 
2681  /* extract unit string to compare to table entries */
2682  unitlen = 0;
2683  while (*unit != '\0' && !isspace((unsigned char) *unit) &&
2684  unitlen < MAX_UNIT_LEN)
2685  unitstr[unitlen++] = *(unit++);
2686  unitstr[unitlen] = '\0';
2687  /* allow whitespace after unit */
2688  while (isspace((unsigned char) *unit))
2689  unit++;
2690  if (*unit != '\0')
2691  return false; /* unit too long, or garbage after it */
2692 
2693  /* now search the appropriate table */
2694  if (base_unit & GUC_UNIT_MEMORY)
2696  else
2698 
2699  for (i = 0; *table[i].unit; i++)
2700  {
2701  if (base_unit == table[i].base_unit &&
2702  strcmp(unitstr, table[i].unit) == 0)
2703  {
2704  double cvalue = value * table[i].multiplier;
2705 
2706  /*
2707  * If the user gave a fractional value such as "30.1GB", round it
2708  * off to the nearest multiple of the next smaller unit, if there
2709  * is one.
2710  */
2711  if (*table[i + 1].unit &&
2712  base_unit == table[i + 1].base_unit)
2713  cvalue = rint(cvalue / table[i + 1].multiplier) *
2714  table[i + 1].multiplier;
2715 
2716  *base_value = cvalue;
2717  return true;
2718  }
2719  }
2720  return false;
2721 }
2722 
2723 /*
2724  * Convert an integer value in some base unit to a human-friendly unit.
2725  *
2726  * The output unit is chosen so that it's the greatest unit that can represent
2727  * the value without loss. For example, if the base unit is GUC_UNIT_KB, 1024
2728  * is converted to 1 MB, but 1025 is represented as 1025 kB.
2729  */
2730 static void
2731 convert_int_from_base_unit(int64 base_value, int base_unit,
2732  int64 *value, const char **unit)
2733 {
2734  const unit_conversion *table;
2735  int i;
2736 
2737  *unit = NULL;
2738 
2739  if (base_unit & GUC_UNIT_MEMORY)
2741  else
2743 
2744  for (i = 0; *table[i].unit; i++)
2745  {
2746  if (base_unit == table[i].base_unit)
2747  {
2748  /*
2749  * Accept the first conversion that divides the value evenly. We
2750  * assume that the conversions for each base unit are ordered from
2751  * greatest unit to the smallest!
2752  */
2753  if (table[i].multiplier <= 1.0 ||
2754  base_value % (int64) table[i].multiplier == 0)
2755  {
2756  *value = (int64) rint(base_value / table[i].multiplier);
2757  *unit = table[i].unit;
2758  break;
2759  }
2760  }
2761  }
2762 
2763  Assert(*unit != NULL);
2764 }
2765 
2766 /*
2767  * Convert a floating-point value in some base unit to a human-friendly unit.
2768  *
2769  * Same as above, except we have to do the math a bit differently, and
2770  * there's a possibility that we don't find any exact divisor.
2771  */
2772 static void
2773 convert_real_from_base_unit(double base_value, int base_unit,
2774  double *value, const char **unit)
2775 {
2776  const unit_conversion *table;
2777  int i;
2778 
2779  *unit = NULL;
2780 
2781  if (base_unit & GUC_UNIT_MEMORY)
2783  else
2785 
2786  for (i = 0; *table[i].unit; i++)
2787  {
2788  if (base_unit == table[i].base_unit)
2789  {
2790  /*
2791  * Accept the first conversion that divides the value evenly; or
2792  * if there is none, use the smallest (last) target unit.
2793  *
2794  * What we actually care about here is whether snprintf with "%g"
2795  * will print the value as an integer, so the obvious test of
2796  * "*value == rint(*value)" is too strict; roundoff error might
2797  * make us choose an unreasonably small unit. As a compromise,
2798  * accept a divisor that is within 1e-8 of producing an integer.
2799  */
2800  *value = base_value / table[i].multiplier;
2801  *unit = table[i].unit;
2802  if (*value > 0 &&
2803  fabs((rint(*value) / *value) - 1.0) <= 1e-8)
2804  break;
2805  }
2806  }
2807 
2808  Assert(*unit != NULL);
2809 }
2810 
2811 /*
2812  * Return the name of a GUC's base unit (e.g. "ms") given its flags.
2813  * Return NULL if the GUC is unitless.
2814  */
2815 const char *
2817 {
2818  switch (flags & GUC_UNIT)
2819  {
2820  case 0:
2821  return NULL; /* GUC has no units */
2822  case GUC_UNIT_BYTE:
2823  return "B";
2824  case GUC_UNIT_KB:
2825  return "kB";
2826  case GUC_UNIT_MB:
2827  return "MB";
2828  case GUC_UNIT_BLOCKS:
2829  {
2830  static char bbuf[8];
2831 
2832  /* initialize if first time through */
2833  if (bbuf[0] == '\0')
2834  snprintf(bbuf, sizeof(bbuf), "%dkB", BLCKSZ / 1024);
2835  return bbuf;
2836  }
2837  case GUC_UNIT_XBLOCKS:
2838  {
2839  static char xbuf[8];
2840 
2841  /* initialize if first time through */
2842  if (xbuf[0] == '\0')
2843  snprintf(xbuf, sizeof(xbuf), "%dkB", XLOG_BLCKSZ / 1024);
2844  return xbuf;
2845  }
2846  case GUC_UNIT_MS:
2847  return "ms";
2848  case GUC_UNIT_S:
2849  return "s";
2850  case GUC_UNIT_MIN:
2851  return "min";
2852  default:
2853  elog(ERROR, "unrecognized GUC units value: %d",
2854  flags & GUC_UNIT);
2855  return NULL;
2856  }
2857 }
2858 
2859 
2860 /*
2861  * Try to parse value as an integer. The accepted formats are the
2862  * usual decimal, octal, or hexadecimal formats, as well as floating-point
2863  * formats (which will be rounded to integer after any units conversion).
2864  * Optionally, the value can be followed by a unit name if "flags" indicates
2865  * a unit is allowed.
2866  *
2867  * If the string parses okay, return true, else false.
2868  * If okay and result is not NULL, return the value in *result.
2869  * If not okay and hintmsg is not NULL, *hintmsg is set to a suitable
2870  * HINT message, or NULL if no hint provided.
2871  */
2872 bool
2873 parse_int(const char *value, int *result, int flags, const char **hintmsg)
2874 {
2875  /*
2876  * We assume here that double is wide enough to represent any integer
2877  * value with adequate precision.
2878  */
2879  double val;
2880  char *endptr;
2881 
2882  /* To suppress compiler warnings, always set output params */
2883  if (result)
2884  *result = 0;
2885  if (hintmsg)
2886  *hintmsg = NULL;
2887 
2888  /*
2889  * Try to parse as an integer (allowing octal or hex input). If the
2890  * conversion stops at a decimal point or 'e', or overflows, re-parse as
2891  * float. This should work fine as long as we have no unit names starting
2892  * with 'e'. If we ever do, the test could be extended to check for a
2893  * sign or digit after 'e', but for now that's unnecessary.
2894  */
2895  errno = 0;
2896  val = strtol(value, &endptr, 0);
2897  if (*endptr == '.' || *endptr == 'e' || *endptr == 'E' ||
2898  errno == ERANGE)
2899  {
2900  errno = 0;
2901  val = strtod(value, &endptr);
2902  }
2903 
2904  if (endptr == value || errno == ERANGE)
2905  return false; /* no HINT for these cases */
2906 
2907  /* reject NaN (infinities will fail range check below) */
2908  if (isnan(val))
2909  return false; /* treat same as syntax error; no HINT */
2910 
2911  /* allow whitespace between number and unit */
2912  while (isspace((unsigned char) *endptr))
2913  endptr++;
2914 
2915  /* Handle possible unit */
2916  if (*endptr != '\0')
2917  {
2918  if ((flags & GUC_UNIT) == 0)
2919  return false; /* this setting does not accept a unit */
2920 
2922  endptr, (flags & GUC_UNIT),
2923  &val))
2924  {
2925  /* invalid unit, or garbage after the unit; set hint and fail. */
2926  if (hintmsg)
2927  {
2928  if (flags & GUC_UNIT_MEMORY)
2929  *hintmsg = memory_units_hint;
2930  else
2931  *hintmsg = time_units_hint;
2932  }
2933  return false;
2934  }
2935  }
2936 
2937  /* Round to int, then check for overflow */
2938  val = rint(val);
2939 
2940  if (val > INT_MAX || val < INT_MIN)
2941  {
2942  if (hintmsg)
2943  *hintmsg = gettext_noop("Value exceeds integer range.");
2944  return false;
2945  }
2946 
2947  if (result)
2948  *result = (int) val;
2949  return true;
2950 }
2951 
2952 /*
2953  * Try to parse value as a floating point number in the usual format.
2954  * Optionally, the value can be followed by a unit name if "flags" indicates
2955  * a unit is allowed.
2956  *
2957  * If the string parses okay, return true, else false.
2958  * If okay and result is not NULL, return the value in *result.
2959  * If not okay and hintmsg is not NULL, *hintmsg is set to a suitable
2960  * HINT message, or NULL if no hint provided.
2961  */
2962 bool
2963 parse_real(const char *value, double *result, int flags, const char **hintmsg)
2964 {
2965  double val;
2966  char *endptr;
2967 
2968  /* To suppress compiler warnings, always set output params */
2969  if (result)
2970  *result = 0;
2971  if (hintmsg)
2972  *hintmsg = NULL;
2973 
2974  errno = 0;
2975  val = strtod(value, &endptr);
2976 
2977  if (endptr == value || errno == ERANGE)
2978  return false; /* no HINT for these cases */
2979 
2980  /* reject NaN (infinities will fail range checks later) */
2981  if (isnan(val))
2982  return false; /* treat same as syntax error; no HINT */
2983 
2984  /* allow whitespace between number and unit */
2985  while (isspace((unsigned char) *endptr))
2986  endptr++;
2987 
2988  /* Handle possible unit */
2989  if (*endptr != '\0')
2990  {
2991  if ((flags & GUC_UNIT) == 0)
2992  return false; /* this setting does not accept a unit */
2993 
2995  endptr, (flags & GUC_UNIT),
2996  &val))
2997  {
2998  /* invalid unit, or garbage after the unit; set hint and fail. */
2999  if (hintmsg)
3000  {
3001  if (flags & GUC_UNIT_MEMORY)
3002  *hintmsg = memory_units_hint;
3003  else
3004  *hintmsg = time_units_hint;
3005  }
3006  return false;
3007  }
3008  }
3009 
3010  if (result)
3011  *result = val;
3012  return true;
3013 }
3014 
3015 
3016 /*
3017  * Lookup the name for an enum option with the selected value.
3018  * Should only ever be called with known-valid values, so throws
3019  * an elog(ERROR) if the enum option is not found.
3020  *
3021  * The returned string is a pointer to static data and not
3022  * allocated for modification.
3023  */
3024 const char *
3026 {
3027  const struct config_enum_entry *entry;
3028 
3029  for (entry = record->options; entry && entry->name; entry++)
3030  {
3031  if (entry->val == val)
3032  return entry->name;
3033  }
3034 
3035  elog(ERROR, "could not find enum option %d for %s",
3036  val, record->gen.name);
3037  return NULL; /* silence compiler */
3038 }
3039 
3040 
3041 /*
3042  * Lookup the value for an enum option with the selected name
3043  * (case-insensitive).
3044  * If the enum option is found, sets the retval value and returns
3045  * true. If it's not found, return false and retval is set to 0.
3046  */
3047 bool
3048 config_enum_lookup_by_name(struct config_enum *record, const char *value,
3049  int *retval)
3050 {
3051  const struct config_enum_entry *entry;
3052 
3053  for (entry = record->options; entry && entry->name; entry++)
3054  {
3055  if (pg_strcasecmp(value, entry->name) == 0)
3056  {
3057  *retval = entry->val;
3058  return true;
3059  }
3060  }
3061 
3062  *retval = 0;
3063  return false;
3064 }
3065 
3066 
3067 /*
3068  * Return a palloc'd string listing all the available options for an enum GUC
3069  * (excluding hidden ones), separated by the given separator.
3070  * If prefix is non-NULL, it is added before the first enum value.
3071  * If suffix is non-NULL, it is added to the end of the string.
3072  */
3073 char *
3074 config_enum_get_options(struct config_enum *record, const char *prefix,
3075  const char *suffix, const char *separator)
3076 {
3077  const struct config_enum_entry *entry;
3078  StringInfoData retstr;
3079  int seplen;
3080 
3081  initStringInfo(&retstr);
3082  appendStringInfoString(&retstr, prefix);
3083 
3084  seplen = strlen(separator);
3085  for (entry = record->options; entry && entry->name; entry++)
3086  {
3087  if (!entry->hidden)
3088  {
3089  appendStringInfoString(&retstr, entry->name);
3090  appendBinaryStringInfo(&retstr, separator, seplen);
3091  }
3092  }
3093 
3094  /*
3095  * All the entries may have been hidden, leaving the string empty if no
3096  * prefix was given. This indicates a broken GUC setup, since there is no
3097  * use for an enum without any values, so we just check to make sure we
3098  * don't write to invalid memory instead of actually trying to do
3099  * something smart with it.
3100  */
3101  if (retstr.len >= seplen)
3102  {
3103  /* Replace final separator */
3104  retstr.data[retstr.len - seplen] = '\0';
3105  retstr.len -= seplen;
3106  }
3107 
3108  appendStringInfoString(&retstr, suffix);
3109 
3110  return retstr.data;
3111 }
3112 
3113 /*
3114  * Parse and validate a proposed value for the specified configuration
3115  * parameter.
3116  *
3117  * This does built-in checks (such as range limits for an integer parameter)
3118  * and also calls any check hook the parameter may have.
3119  *
3120  * record: GUC variable's info record
3121  * name: variable name (should match the record of course)
3122  * value: proposed value, as a string
3123  * source: identifies source of value (check hooks may need this)
3124  * elevel: level to log any error reports at
3125  * newval: on success, converted parameter value is returned here
3126  * newextra: on success, receives any "extra" data returned by check hook
3127  * (caller must initialize *newextra to NULL)
3128  *
3129  * Returns true if OK, false if not (or throws error, if elevel >= ERROR)
3130  */
3131 static bool
3133  const char *name, const char *value,
3134  GucSource source, int elevel,
3135  union config_var_val *newval, void **newextra)
3136 {
3137  switch (record->vartype)
3138  {
3139  case PGC_BOOL:
3140  {
3141  struct config_bool *conf = (struct config_bool *) record;
3142 
3143  if (!parse_bool(value, &newval->boolval))
3144  {
3145  ereport(elevel,
3146  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3147  errmsg("parameter \"%s\" requires a Boolean value",
3148  name)));
3149  return false;
3150  }
3151 
3152  if (!call_bool_check_hook(conf, &newval->boolval, newextra,
3153  source, elevel))
3154  return false;
3155  }
3156  break;
3157  case PGC_INT:
3158  {
3159  struct config_int *conf = (struct config_int *) record;
3160  const char *hintmsg;
3161 
3162  if (!parse_int(value, &newval->intval,
3163  conf->gen.flags, &hintmsg))
3164  {
3165  ereport(elevel,
3166  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3167  errmsg("invalid value for parameter \"%s\": \"%s\"",
3168  name, value),
3169  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3170  return false;
3171  }
3172 
3173  if (newval->intval < conf->min || newval->intval > conf->max)
3174  {
3175  const char *unit = get_config_unit_name(conf->gen.flags);
3176 
3177  ereport(elevel,
3178  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3179  errmsg("%d%s%s is outside the valid range for parameter \"%s\" (%d .. %d)",
3180  newval->intval,
3181  unit ? " " : "",
3182  unit ? unit : "",
3183  name,
3184  conf->min, conf->max)));
3185  return false;
3186  }
3187 
3188  if (!call_int_check_hook(conf, &newval->intval, newextra,
3189  source, elevel))
3190  return false;
3191  }
3192  break;
3193  case PGC_REAL:
3194  {
3195  struct config_real *conf = (struct config_real *) record;
3196  const char *hintmsg;
3197 
3198  if (!parse_real(value, &newval->realval,
3199  conf->gen.flags, &hintmsg))
3200  {
3201  ereport(elevel,
3202  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3203  errmsg("invalid value for parameter \"%s\": \"%s\"",
3204  name, value),
3205  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3206  return false;
3207  }
3208 
3209  if (newval->realval < conf->min || newval->realval > conf->max)
3210  {
3211  const char *unit = get_config_unit_name(conf->gen.flags);
3212 
3213  ereport(elevel,
3214  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3215  errmsg("%g%s%s is outside the valid range for parameter \"%s\" (%g .. %g)",
3216  newval->realval,
3217  unit ? " " : "",
3218  unit ? unit : "",
3219  name,
3220  conf->min, conf->max)));
3221  return false;
3222  }
3223 
3224  if (!call_real_check_hook(conf, &newval->realval, newextra,
3225  source, elevel))
3226  return false;
3227  }
3228  break;
3229  case PGC_STRING:
3230  {
3231  struct config_string *conf = (struct config_string *) record;
3232 
3233  /*
3234  * The value passed by the caller could be transient, so we
3235  * always strdup it.
3236  */
3237  newval->stringval = guc_strdup(elevel, value);
3238  if (newval->stringval == NULL)
3239  return false;
3240 
3241  /*
3242  * The only built-in "parsing" check we have is to apply
3243  * truncation if GUC_IS_NAME.
3244  */
3245  if (conf->gen.flags & GUC_IS_NAME)
3246  truncate_identifier(newval->stringval,
3247  strlen(newval->stringval),
3248  true);
3249 
3250  if (!call_string_check_hook(conf, &newval->stringval, newextra,
3251  source, elevel))
3252  {
3253  guc_free(newval->stringval);
3254  newval->stringval = NULL;
3255  return false;
3256  }
3257  }
3258  break;
3259  case PGC_ENUM:
3260  {
3261  struct config_enum *conf = (struct config_enum *) record;
3262 
3263  if (!config_enum_lookup_by_name(conf, value, &newval->enumval))
3264  {
3265  char *hintmsg;
3266 
3267  hintmsg = config_enum_get_options(conf,
3268  "Available values: ",
3269  ".", ", ");
3270 
3271  ereport(elevel,
3272  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3273  errmsg("invalid value for parameter \"%s\": \"%s\"",
3274  name, value),
3275  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3276 
3277  if (hintmsg)
3278  pfree(hintmsg);
3279  return false;
3280  }
3281 
3282  if (!call_enum_check_hook(conf, &newval->enumval, newextra,
3283  source, elevel))
3284  return false;
3285  }
3286  break;
3287  }
3288 
3289  return true;
3290 }
3291 
3292 
3293 /*
3294  * set_config_option: sets option `name' to given value.
3295  *
3296  * The value should be a string, which will be parsed and converted to
3297  * the appropriate data type. The context and source parameters indicate
3298  * in which context this function is being called, so that it can apply the
3299  * access restrictions properly.
3300  *
3301  * If value is NULL, set the option to its default value (normally the
3302  * reset_val, but if source == PGC_S_DEFAULT we instead use the boot_val).
3303  *
3304  * action indicates whether to set the value globally in the session, locally
3305  * to the current top transaction, or just for the duration of a function call.
3306  *
3307  * If changeVal is false then don't really set the option but do all
3308  * the checks to see if it would work.
3309  *
3310  * elevel should normally be passed as zero, allowing this function to make
3311  * its standard choice of ereport level. However some callers need to be
3312  * able to override that choice; they should pass the ereport level to use.
3313  *
3314  * is_reload should be true only when called from read_nondefault_variables()
3315  * or RestoreGUCState(), where we are trying to load some other process's
3316  * GUC settings into a new process.
3317  *
3318  * Return value:
3319  * +1: the value is valid and was successfully applied.
3320  * 0: the name or value is invalid (but see below).
3321  * -1: the value was not applied because of context, priority, or changeVal.
3322  *
3323  * If there is an error (non-existing option, invalid value) then an
3324  * ereport(ERROR) is thrown *unless* this is called for a source for which
3325  * we don't want an ERROR (currently, those are defaults, the config file,
3326  * and per-database or per-user settings, as well as callers who specify
3327  * a less-than-ERROR elevel). In those cases we write a suitable error
3328  * message via ereport() and return 0.
3329  *
3330  * See also SetConfigOption for an external interface.
3331  */
3332 int
3333 set_config_option(const char *name, const char *value,
3335  GucAction action, bool changeVal, int elevel,
3336  bool is_reload)
3337 {
3338  Oid srole;
3339 
3340  /*
3341  * Non-interactive sources should be treated as having all privileges,
3342  * except for PGC_S_CLIENT. Note in particular that this is true for
3343  * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3344  * privilege check was done when the pg_db_role_setting entry was made.
3345  */
3347  srole = GetUserId();
3348  else
3349  srole = BOOTSTRAP_SUPERUSERID;
3350 
3351  return set_config_with_handle(name, NULL, value,
3352  context, source, srole,
3353  action, changeVal, elevel,
3354  is_reload);
3355 }
3356 
3357 /*
3358  * set_config_option_ext: sets option `name' to given value.
3359  *
3360  * This API adds the ability to explicitly specify which role OID
3361  * is considered to be setting the value. Most external callers can use
3362  * set_config_option() and let it determine that based on the GucSource,
3363  * but there are a few that are supplying a value that was determined
3364  * in some special way and need to override the decision. Also, when
3365  * restoring a previously-assigned value, it's important to supply the
3366  * same role OID that set the value originally; so all guc.c callers
3367  * that are doing that type of thing need to call this directly.
3368  *
3369  * Generally, srole should be GetUserId() when the source is a SQL operation,
3370  * or BOOTSTRAP_SUPERUSERID if the source is a config file or similar.
3371  */
3372 int
3373 set_config_option_ext(const char *name, const char *value,
3375  GucAction action, bool changeVal, int elevel,
3376  bool is_reload)
3377 {
3378  return set_config_with_handle(name, NULL, value,
3379  context, source, srole,
3380  action, changeVal, elevel,
3381  is_reload);
3382 }
3383 
3384 
3385 /*
3386  * set_config_with_handle: takes an optional 'handle' argument, which can be
3387  * obtained by the caller from get_config_handle().
3388  *
3389  * This should be used by callers which repeatedly set the same config
3390  * option(s), and want to avoid the overhead of a hash lookup each time.
3391  */
3392 int
3394  const char *value,
3396  GucAction action, bool changeVal, int elevel,
3397  bool is_reload)
3398 {
3399  struct config_generic *record;
3400  union config_var_val newval_union;
3401  void *newextra = NULL;
3402  bool prohibitValueChange = false;
3403  bool makeDefault;
3404 
3405  if (elevel == 0)
3406  {
3407  if (source == PGC_S_DEFAULT || source == PGC_S_FILE)
3408  {
3409  /*
3410  * To avoid cluttering the log, only the postmaster bleats loudly
3411  * about problems with the config file.
3412  */
3413  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
3414  }
3415  else if (source == PGC_S_GLOBAL ||
3416  source == PGC_S_DATABASE ||
3417  source == PGC_S_USER ||
3419  elevel = WARNING;
3420  else
3421  elevel = ERROR;
3422  }
3423 
3424  /*
3425  * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
3426  * because the current worker will also pop the change. We're probably
3427  * dealing with a function having a proconfig entry. Only the function's
3428  * body should observe the change, and peer workers do not share in the
3429  * execution of a function call started by this worker.
3430  *
3431  * Other changes might need to affect other workers, so forbid them.
3432  */
3433  if (IsInParallelMode() && changeVal && action != GUC_ACTION_SAVE)
3434  {
3435  ereport(elevel,
3436  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3437  errmsg("cannot set parameters during a parallel operation")));
3438  return -1;
3439  }
3440 
3441  /* if handle is specified, no need to look up option */
3442  if (!handle)
3443  {
3444  record = find_option(name, true, false, elevel);
3445  if (record == NULL)
3446  return 0;
3447  }
3448  else
3449  record = handle;
3450 
3451  /*
3452  * Check if the option can be set at this time. See guc.h for the precise
3453  * rules.
3454  */
3455  switch (record->context)
3456  {
3457  case PGC_INTERNAL:
3458  if (context != PGC_INTERNAL)
3459  {
3460  ereport(elevel,
3461  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3462  errmsg("parameter \"%s\" cannot be changed",
3463  name)));
3464  return 0;
3465  }
3466  break;
3467  case PGC_POSTMASTER:
3468  if (context == PGC_SIGHUP)
3469  {
3470  /*
3471  * We are re-reading a PGC_POSTMASTER variable from
3472  * postgresql.conf. We can't change the setting, so we should
3473  * give a warning if the DBA tries to change it. However,
3474  * because of variant formats, canonicalization by check
3475  * hooks, etc, we can't just compare the given string directly
3476  * to what's stored. Set a flag to check below after we have
3477  * the final storable value.
3478  */
3479  prohibitValueChange = true;
3480  }
3481  else if (context != PGC_POSTMASTER)
3482  {
3483  ereport(elevel,
3484  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3485  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3486  name)));
3487  return 0;
3488  }
3489  break;
3490  case PGC_SIGHUP:
3492  {
3493  ereport(elevel,
3494  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3495  errmsg("parameter \"%s\" cannot be changed now",
3496  name)));
3497  return 0;
3498  }
3499 
3500  /*
3501  * Hmm, the idea of the SIGHUP context is "ought to be global, but
3502  * can be changed after postmaster start". But there's nothing
3503  * that prevents a crafty administrator from sending SIGHUP
3504  * signals to individual backends only.
3505  */
3506  break;
3507  case PGC_SU_BACKEND:
3508  if (context == PGC_BACKEND)
3509  {
3510  /*
3511  * Check whether the requesting user has been granted
3512  * privilege to set this GUC.
3513  */
3514  AclResult aclresult;
3515 
3516  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3517  if (aclresult != ACLCHECK_OK)
3518  {
3519  /* No granted privilege */
3520  ereport(elevel,
3521  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3522  errmsg("permission denied to set parameter \"%s\"",
3523  name)));
3524  return 0;
3525  }
3526  }
3527  /* fall through to process the same as PGC_BACKEND */
3528  /* FALLTHROUGH */
3529  case PGC_BACKEND:
3530  if (context == PGC_SIGHUP)
3531  {
3532  /*
3533  * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
3534  * the config file, we want to accept the new value in the
3535  * postmaster (whence it will propagate to
3536  * subsequently-started backends), but ignore it in existing
3537  * backends. This is a tad klugy, but necessary because we
3538  * don't re-read the config file during backend start.
3539  *
3540  * However, if changeVal is false then plow ahead anyway since
3541  * we are trying to find out if the value is potentially good,
3542  * not actually use it.
3543  *
3544  * In EXEC_BACKEND builds, this works differently: we load all
3545  * non-default settings from the CONFIG_EXEC_PARAMS file
3546  * during backend start. In that case we must accept
3547  * PGC_SIGHUP settings, so as to have the same value as if
3548  * we'd forked from the postmaster. This can also happen when
3549  * using RestoreGUCState() within a background worker that
3550  * needs to have the same settings as the user backend that
3551  * started it. is_reload will be true when either situation
3552  * applies.
3553  */
3554  if (IsUnderPostmaster && changeVal && !is_reload)
3555  return -1;
3556  }
3557  else if (context != PGC_POSTMASTER &&
3558  context != PGC_BACKEND &&
3559  context != PGC_SU_BACKEND &&
3560  source != PGC_S_CLIENT)
3561  {
3562  ereport(elevel,
3563  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3564  errmsg("parameter \"%s\" cannot be set after connection start",
3565  name)));
3566  return 0;
3567  }
3568  break;
3569  case PGC_SUSET:
3570  if (context == PGC_USERSET || context == PGC_BACKEND)
3571  {
3572  /*
3573  * Check whether the requesting user has been granted
3574  * privilege to set this GUC.
3575  */
3576  AclResult aclresult;
3577 
3578  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3579  if (aclresult != ACLCHECK_OK)
3580  {
3581  /* No granted privilege */
3582  ereport(elevel,
3583  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3584  errmsg("permission denied to set parameter \"%s\"",
3585  name)));
3586  return 0;
3587  }
3588  }
3589  break;
3590  case PGC_USERSET:
3591  /* always okay */
3592  break;
3593  }
3594 
3595  /*
3596  * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
3597  * security restriction context. We can reject this regardless of the GUC
3598  * context or source, mainly because sources that it might be reasonable
3599  * to override for won't be seen while inside a function.
3600  *
3601  * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
3602  * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
3603  * An exception might be made if the reset value is assumed to be "safe".
3604  *
3605  * Note: this flag is currently used for "session_authorization" and
3606  * "role". We need to prohibit changing these inside a local userid
3607  * context because when we exit it, GUC won't be notified, leaving things
3608  * out of sync. (This could be fixed by forcing a new GUC nesting level,
3609  * but that would change behavior in possibly-undesirable ways.) Also, we
3610  * prohibit changing these in a security-restricted operation because
3611  * otherwise RESET could be used to regain the session user's privileges.
3612  */
3613  if (record->flags & GUC_NOT_WHILE_SEC_REST)
3614  {
3615  if (InLocalUserIdChange())
3616  {
3617  /*
3618  * Phrasing of this error message is historical, but it's the most
3619  * common case.
3620  */
3621  ereport(elevel,
3622  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3623  errmsg("cannot set parameter \"%s\" within security-definer function",
3624  name)));
3625  return 0;
3626  }
3628  {
3629  ereport(elevel,
3630  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3631  errmsg("cannot set parameter \"%s\" within security-restricted operation",
3632  name)));
3633  return 0;
3634  }
3635  }
3636 
3637  /* Disallow resetting and saving GUC_NO_RESET values */
3638  if (record->flags & GUC_NO_RESET)
3639  {
3640  if (value == NULL)
3641  {
3642  ereport(elevel,
3643  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3644  errmsg("parameter \"%s\" cannot be reset", name)));
3645  return 0;
3646  }
3647  if (action == GUC_ACTION_SAVE)
3648  {
3649  ereport(elevel,
3650  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3651  errmsg("parameter \"%s\" cannot be set locally in functions",
3652  name)));
3653  return 0;
3654  }
3655  }
3656 
3657  /*
3658  * Should we set reset/stacked values? (If so, the behavior is not
3659  * transactional.) This is done either when we get a default value from
3660  * the database's/user's/client's default settings or when we reset a
3661  * value to its default.
3662  */
3663  makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
3664  ((value != NULL) || source == PGC_S_DEFAULT);
3665 
3666  /*
3667  * Ignore attempted set if overridden by previously processed setting.
3668  * However, if changeVal is false then plow ahead anyway since we are
3669  * trying to find out if the value is potentially good, not actually use
3670  * it. Also keep going if makeDefault is true, since we may want to set
3671  * the reset/stacked values even if we can't set the variable itself.
3672  */
3673  if (record->source > source)
3674  {
3675  if (changeVal && !makeDefault)
3676  {
3677  elog(DEBUG3, "\"%s\": setting ignored because previous source is higher priority",
3678  name);
3679  return -1;
3680  }
3681  changeVal = false;
3682  }
3683 
3684  /*
3685  * Evaluate value and set variable.
3686  */
3687  switch (record->vartype)
3688  {
3689  case PGC_BOOL:
3690  {
3691  struct config_bool *conf = (struct config_bool *) record;
3692 
3693 #define newval (newval_union.boolval)
3694 
3695  if (value)
3696  {
3697  if (!parse_and_validate_value(record, name, value,
3698  source, elevel,
3699  &newval_union, &newextra))
3700  return 0;
3701  }
3702  else if (source == PGC_S_DEFAULT)
3703  {
3704  newval = conf->boot_val;
3705  if (!call_bool_check_hook(conf, &newval, &newextra,
3706  source, elevel))
3707  return 0;
3708  }
3709  else
3710  {
3711  newval = conf->reset_val;
3712  newextra = conf->reset_extra;
3713  source = conf->gen.reset_source;
3714  context = conf->gen.reset_scontext;
3715  srole = conf->gen.reset_srole;
3716  }
3717 
3718  if (prohibitValueChange)
3719  {
3720  /* Release newextra, unless it's reset_extra */
3721  if (newextra && !extra_field_used(&conf->gen, newextra))
3722  guc_free(newextra);
3723 
3724  if (*conf->variable != newval)
3725  {
3726  record->status |= GUC_PENDING_RESTART;
3727  ereport(elevel,
3728  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3729  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3730  name)));
3731  return 0;
3732  }
3733  record->status &= ~GUC_PENDING_RESTART;
3734  return -1;
3735  }
3736 
3737  if (changeVal)
3738  {
3739  /* Save old value to support transaction abort */
3740  if (!makeDefault)
3741  push_old_value(&conf->gen, action);
3742 
3743  if (conf->assign_hook)
3744  conf->assign_hook(newval, newextra);
3745  *conf->variable = newval;
3746  set_extra_field(&conf->gen, &conf->gen.extra,
3747  newextra);
3748  set_guc_source(&conf->gen, source);
3749  conf->gen.scontext = context;
3750  conf->gen.srole = srole;
3751  }
3752  if (makeDefault)
3753  {
3754  GucStack *stack;
3755 
3756  if (conf->gen.reset_source <= source)
3757  {
3758  conf->reset_val = newval;
3759  set_extra_field(&conf->gen, &conf->reset_extra,
3760  newextra);
3761  conf->gen.reset_source = source;
3762  conf->gen.reset_scontext = context;
3763  conf->gen.reset_srole = srole;
3764  }
3765  for (stack = conf->gen.stack; stack; stack = stack->prev)
3766  {
3767  if (stack->source <= source)
3768  {
3769  stack->prior.val.boolval = newval;
3770  set_extra_field(&conf->gen, &stack->prior.extra,
3771  newextra);
3772  stack->source = source;
3773  stack->scontext = context;
3774  stack->srole = srole;
3775  }
3776  }
3777  }
3778 
3779  /* Perhaps we didn't install newextra anywhere */
3780  if (newextra && !extra_field_used(&conf->gen, newextra))
3781  guc_free(newextra);
3782  break;
3783 
3784 #undef newval
3785  }
3786 
3787  case PGC_INT:
3788  {
3789  struct config_int *conf = (struct config_int *) record;
3790 
3791 #define newval (newval_union.intval)
3792 
3793  if (value)
3794  {
3795  if (!parse_and_validate_value(record, name, value,
3796  source, elevel,
3797  &newval_union, &newextra))
3798  return 0;
3799  }
3800  else if (source == PGC_S_DEFAULT)
3801  {
3802  newval = conf->boot_val;
3803  if (!call_int_check_hook(conf, &newval, &newextra,
3804  source, elevel))
3805  return 0;
3806  }
3807  else
3808  {
3809  newval = conf->reset_val;
3810  newextra = conf->reset_extra;
3811  source = conf->gen.reset_source;
3812  context = conf->gen.reset_scontext;
3813  srole = conf->gen.reset_srole;
3814  }
3815 
3816  if (prohibitValueChange)
3817  {
3818  /* Release newextra, unless it's reset_extra */
3819  if (newextra && !extra_field_used(&conf->gen, newextra))
3820  guc_free(newextra);
3821 
3822  if (*conf->variable != newval)
3823  {
3824  record->status |= GUC_PENDING_RESTART;
3825  ereport(elevel,
3826  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3827  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3828  name)));
3829  return 0;
3830  }
3831  record->status &= ~GUC_PENDING_RESTART;
3832  return -1;
3833  }
3834 
3835  if (changeVal)
3836  {
3837  /* Save old value to support transaction abort */
3838  if (!makeDefault)
3839  push_old_value(&conf->gen, action);
3840 
3841  if (conf->assign_hook)
3842  conf->assign_hook(newval, newextra);
3843  *conf->variable = newval;
3844  set_extra_field(&conf->gen, &conf->gen.extra,
3845  newextra);
3846  set_guc_source(&conf->gen, source);
3847  conf->gen.scontext = context;
3848  conf->gen.srole = srole;
3849  }
3850  if (makeDefault)
3851  {
3852  GucStack *stack;
3853 
3854  if (conf->gen.reset_source <= source)
3855  {
3856  conf->reset_val = newval;
3857  set_extra_field(&conf->gen, &conf->reset_extra,
3858  newextra);
3859  conf->gen.reset_source = source;
3860  conf->gen.reset_scontext = context;
3861  conf->gen.reset_srole = srole;
3862  }
3863  for (stack = conf->gen.stack; stack; stack = stack->prev)
3864  {
3865  if (stack->source <= source)
3866  {
3867  stack->prior.val.intval = newval;
3868  set_extra_field(&conf->gen, &stack->prior.extra,
3869  newextra);
3870  stack->source = source;
3871  stack->scontext = context;
3872  stack->srole = srole;
3873  }
3874  }
3875  }
3876 
3877  /* Perhaps we didn't install newextra anywhere */
3878  if (newextra && !extra_field_used(&conf->gen, newextra))
3879  guc_free(newextra);
3880  break;
3881 
3882 #undef newval
3883  }
3884 
3885  case PGC_REAL:
3886  {
3887  struct config_real *conf = (struct config_real *) record;
3888 
3889 #define newval (newval_union.realval)
3890 
3891  if (value)
3892  {
3893  if (!parse_and_validate_value(record, name, value,
3894  source, elevel,
3895  &newval_union, &newextra))
3896  return 0;
3897  }
3898  else if (source == PGC_S_DEFAULT)
3899  {
3900  newval = conf->boot_val;
3901  if (!call_real_check_hook(conf, &newval, &newextra,
3902  source, elevel))
3903  return 0;
3904  }
3905  else
3906  {
3907  newval = conf->reset_val;
3908  newextra = conf->reset_extra;
3909  source = conf->gen.reset_source;
3910  context = conf->gen.reset_scontext;
3911  srole = conf->gen.reset_srole;
3912  }
3913 
3914  if (prohibitValueChange)
3915  {
3916  /* Release newextra, unless it's reset_extra */
3917  if (newextra && !extra_field_used(&conf->gen, newextra))
3918  guc_free(newextra);
3919 
3920  if (*conf->variable != newval)
3921  {
3922  record->status |= GUC_PENDING_RESTART;
3923  ereport(elevel,
3924  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3925  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3926  name)));
3927  return 0;
3928  }
3929  record->status &= ~GUC_PENDING_RESTART;
3930  return -1;
3931  }
3932 
3933  if (changeVal)
3934  {
3935  /* Save old value to support transaction abort */
3936  if (!makeDefault)
3937  push_old_value(&conf->gen, action);
3938 
3939  if (conf->assign_hook)
3940  conf->assign_hook(newval, newextra);
3941  *conf->variable = newval;
3942  set_extra_field(&conf->gen, &conf->gen.extra,
3943  newextra);
3944  set_guc_source(&conf->gen, source);
3945  conf->gen.scontext = context;
3946  conf->gen.srole = srole;
3947  }
3948  if (makeDefault)
3949  {
3950  GucStack *stack;
3951 
3952  if (conf->gen.reset_source <= source)
3953  {
3954  conf->reset_val = newval;
3955  set_extra_field(&conf->gen, &conf->reset_extra,
3956  newextra);
3957  conf->gen.reset_source = source;
3958  conf->gen.reset_scontext = context;
3959  conf->gen.reset_srole = srole;
3960  }
3961  for (stack = conf->gen.stack; stack; stack = stack->prev)
3962  {
3963  if (stack->source <= source)
3964  {
3965  stack->prior.val.realval = newval;
3966  set_extra_field(&conf->gen, &stack->prior.extra,
3967  newextra);
3968  stack->source = source;
3969  stack->scontext = context;
3970  stack->srole = srole;
3971  }
3972  }
3973  }
3974 
3975  /* Perhaps we didn't install newextra anywhere */
3976  if (newextra && !extra_field_used(&conf->gen, newextra))
3977  guc_free(newextra);
3978  break;
3979 
3980 #undef newval
3981  }
3982 
3983  case PGC_STRING:
3984  {
3985  struct config_string *conf = (struct config_string *) record;
3986 
3987 #define newval (newval_union.stringval)
3988 
3989  if (value)
3990  {
3991  if (!parse_and_validate_value(record, name, value,
3992  source, elevel,
3993  &newval_union, &newextra))
3994  return 0;
3995  }
3996  else if (source == PGC_S_DEFAULT)
3997  {
3998  /* non-NULL boot_val must always get strdup'd */
3999  if (conf->boot_val != NULL)
4000  {
4001  newval = guc_strdup(elevel, conf->boot_val);
4002  if (newval == NULL)
4003  return 0;
4004  }
4005  else
4006  newval = NULL;
4007 
4008  if (!call_string_check_hook(conf, &newval, &newextra,
4009  source, elevel))
4010  {
4011  guc_free(newval);
4012  return 0;
4013  }
4014  }
4015  else
4016  {
4017  /*
4018  * strdup not needed, since reset_val is already under
4019  * guc.c's control
4020  */
4021  newval = conf->reset_val;
4022  newextra = conf->reset_extra;
4023  source = conf->gen.reset_source;
4024  context = conf->gen.reset_scontext;
4025  srole = conf->gen.reset_srole;
4026  }
4027 
4028  if (prohibitValueChange)
4029  {
4030  bool newval_different;
4031 
4032  /* newval shouldn't be NULL, so we're a bit sloppy here */
4033  newval_different = (*conf->variable == NULL ||
4034  newval == NULL ||
4035  strcmp(*conf->variable, newval) != 0);
4036 
4037  /* Release newval, unless it's reset_val */
4038  if (newval && !string_field_used(conf, newval))
4039  guc_free(newval);
4040  /* Release newextra, unless it's reset_extra */
4041  if (newextra && !extra_field_used(&conf->gen, newextra))
4042  guc_free(newextra);
4043 
4044  if (newval_different)
4045  {
4046  record->status |= GUC_PENDING_RESTART;
4047  ereport(elevel,
4048  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4049  errmsg("parameter \"%s\" cannot be changed without restarting the server",
4050  name)));
4051  return 0;
4052  }
4053  record->status &= ~GUC_PENDING_RESTART;
4054  return -1;
4055  }
4056 
4057  if (changeVal)
4058  {
4059  /* Save old value to support transaction abort */
4060  if (!makeDefault)
4061  push_old_value(&conf->gen, action);
4062 
4063  if (conf->assign_hook)
4064  conf->assign_hook(newval, newextra);
4065  set_string_field(conf, conf->variable, newval);
4066  set_extra_field(&conf->gen, &conf->gen.extra,
4067  newextra);
4068  set_guc_source(&conf->gen, source);
4069  conf->gen.scontext = context;
4070  conf->gen.srole = srole;
4071  }
4072 
4073  if (makeDefault)
4074  {
4075  GucStack *stack;
4076 
4077  if (conf->gen.reset_source <= source)
4078  {
4079  set_string_field(conf, &conf->reset_val, newval);
4080  set_extra_field(&conf->gen, &conf->reset_extra,
4081  newextra);
4082  conf->gen.reset_source = source;
4083  conf->gen.reset_scontext = context;
4084  conf->gen.reset_srole = srole;
4085  }
4086  for (stack = conf->gen.stack; stack; stack = stack->prev)
4087  {
4088  if (stack->source <= source)
4089  {
4090  set_string_field(conf, &stack->prior.val.stringval,
4091  newval);
4092  set_extra_field(&conf->gen, &stack->prior.extra,
4093  newextra);
4094  stack->source = source;
4095  stack->scontext = context;
4096  stack->srole = srole;
4097  }
4098  }
4099  }
4100 
4101  /* Perhaps we didn't install newval anywhere */
4102  if (newval && !string_field_used(conf, newval))
4103  guc_free(newval);
4104  /* Perhaps we didn't install newextra anywhere */
4105  if (newextra && !extra_field_used(&conf->gen, newextra))
4106  guc_free(newextra);
4107  break;
4108 
4109 #undef newval
4110  }
4111 
4112  case PGC_ENUM:
4113  {
4114  struct config_enum *conf = (struct config_enum *) record;
4115 
4116 #define newval (newval_union.enumval)
4117 
4118  if (value)
4119  {
4120  if (!parse_and_validate_value(record, name, value,
4121  source, elevel,
4122  &newval_union, &newextra))
4123  return 0;
4124  }
4125  else if (source == PGC_S_DEFAULT)
4126  {
4127  newval = conf->boot_val;
4128  if (!call_enum_check_hook(conf, &newval, &newextra,
4129  source, elevel))
4130  return 0;
4131  }
4132  else
4133  {
4134  newval = conf->reset_val;
4135  newextra = conf->reset_extra;
4136  source = conf->gen.reset_source;
4137  context = conf->gen.reset_scontext;
4138  srole = conf->gen.reset_srole;
4139  }
4140 
4141  if (prohibitValueChange)
4142  {
4143  /* Release newextra, unless it's reset_extra */
4144  if (newextra && !extra_field_used(&conf->gen, newextra))
4145  guc_free(newextra);
4146 
4147  if (*conf->variable != newval)
4148  {
4149  record->status |= GUC_PENDING_RESTART;
4150  ereport(elevel,
4151  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4152  errmsg("parameter \"%s\" cannot be changed without restarting the server",
4153  name)));
4154  return 0;
4155  }
4156  record->status &= ~GUC_PENDING_RESTART;
4157  return -1;
4158  }
4159 
4160  if (changeVal)
4161  {
4162  /* Save old value to support transaction abort */
4163  if (!makeDefault)
4164  push_old_value(&conf->gen, action);
4165 
4166  if (conf->assign_hook)
4167  conf->assign_hook(newval, newextra);
4168  *conf->variable = newval;
4169  set_extra_field(&conf->gen, &conf->gen.extra,
4170  newextra);
4171  set_guc_source(&conf->gen, source);
4172  conf->gen.scontext = context;
4173  conf->gen.srole = srole;
4174  }
4175  if (makeDefault)
4176  {
4177  GucStack *stack;
4178 
4179  if (conf->gen.reset_source <= source)
4180  {
4181  conf->reset_val = newval;
4182  set_extra_field(&conf->gen, &conf->reset_extra,
4183  newextra);
4184  conf->gen.reset_source = source;
4185  conf->gen.reset_scontext = context;
4186  conf->gen.reset_srole = srole;
4187  }
4188  for (stack = conf->gen.stack; stack; stack = stack->prev)
4189  {
4190  if (stack->source <= source)
4191  {
4192  stack->prior.val.enumval = newval;
4193  set_extra_field(&conf->gen, &stack->prior.extra,
4194  newextra);
4195  stack->source = source;
4196  stack->scontext = context;
4197  stack->srole = srole;
4198  }
4199  }
4200  }
4201 
4202  /* Perhaps we didn't install newextra anywhere */
4203  if (newextra && !extra_field_used(&conf->gen, newextra))
4204  guc_free(newextra);
4205  break;
4206 
4207 #undef newval
4208  }
4209  }
4210 
4211  if (changeVal && (record->flags & GUC_REPORT) &&
4212  !(record->status & GUC_NEEDS_REPORT))
4213  {
4214  record->status |= GUC_NEEDS_REPORT;
4216  }
4217 
4218  return changeVal ? 1 : -1;
4219 }
4220 
4221 
4222 /*
4223  * Retrieve a config_handle for the given name, suitable for calling
4224  * set_config_with_handle(). Only return handle to permanent GUC.
4225  */
4226 config_handle *
4228 {
4229  struct config_generic *gen = find_option(name, false, false, 0);
4230 
4231  if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
4232  return gen;
4233 
4234  return NULL;
4235 }
4236 
4237 
4238 /*
4239  * Set the fields for source file and line number the setting came from.
4240  */
4241 static void
4243 {
4244  struct config_generic *record;
4245  int elevel;
4246 
4247  /*
4248  * To avoid cluttering the log, only the postmaster bleats loudly about
4249  * problems with the config file.
4250  */
4251  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
4252 
4253  record = find_option(name, true, false, elevel);
4254  /* should not happen */
4255  if (record == NULL)
4256  return;
4257 
4258  sourcefile = guc_strdup(elevel, sourcefile);
4259  guc_free(record->sourcefile);
4260  record->sourcefile = sourcefile;
4261  record->sourceline = sourceline;
4262 }
4263 
4264 /*
4265  * Set a config option to the given value.
4266  *
4267  * See also set_config_option; this is just the wrapper to be called from
4268  * outside GUC. (This function should be used when possible, because its API
4269  * is more stable than set_config_option's.)
4270  *
4271  * Note: there is no support here for setting source file/line, as it
4272  * is currently not needed.
4273  */
4274 void
4275 SetConfigOption(const char *name, const char *value,
4277 {
4279  GUC_ACTION_SET, true, 0, false);
4280 }
4281 
4282 
4283 
4284 /*
4285  * Fetch the current value of the option `name', as a string.
4286  *
4287  * If the option doesn't exist, return NULL if missing_ok is true,
4288  * otherwise throw an ereport and don't return.
4289  *
4290  * If restrict_privileged is true, we also enforce that only superusers and
4291  * members of the pg_read_all_settings role can see GUC_SUPERUSER_ONLY
4292  * variables. This should only be passed as true in user-driven calls.
4293  *
4294  * The string is *not* allocated for modification and is really only
4295  * valid until the next call to configuration related functions.
4296  */
4297 const char *
4298 GetConfigOption(const char *name, bool missing_ok, bool restrict_privileged)
4299 {
4300  struct config_generic *record;
4301  static char buffer[256];
4302 
4303  record = find_option(name, false, missing_ok, ERROR);
4304  if (record == NULL)
4305  return NULL;
4306  if (restrict_privileged &&
4307  !ConfigOptionIsVisible(record))
4308  ereport(ERROR,
4309  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4310  errmsg("permission denied to examine \"%s\"", name),
4311  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4312  "pg_read_all_settings")));
4313 
4314  switch (record->vartype)
4315  {
4316  case PGC_BOOL:
4317  return *((struct config_bool *) record)->variable ? "on" : "off";
4318 
4319  case PGC_INT:
4320  snprintf(buffer, sizeof(buffer), "%d",
4321  *((struct config_int *) record)->variable);
4322  return buffer;
4323 
4324  case PGC_REAL:
4325  snprintf(buffer, sizeof(buffer), "%g",
4326  *((struct config_real *) record)->variable);
4327  return buffer;
4328 
4329  case PGC_STRING:
4330  return *((struct config_string *) record)->variable ?
4331  *((struct config_string *) record)->variable : "";
4332 
4333  case PGC_ENUM:
4334  return config_enum_lookup_by_value((struct config_enum *) record,
4335  *((struct config_enum *) record)->variable);
4336  }
4337  return NULL;
4338 }
4339 
4340 /*
4341  * Get the RESET value associated with the given option.
4342  *
4343  * Note: this is not re-entrant, due to use of static result buffer;
4344  * not to mention that a string variable could have its reset_val changed.
4345  * Beware of assuming the result value is good for very long.
4346  */
4347 const char *
4349 {
4350  struct config_generic *record;
4351  static char buffer[256];
4352 
4353  record = find_option(name, false, false, ERROR);
4354  Assert(record != NULL);
4355  if (!ConfigOptionIsVisible(record))
4356  ereport(ERROR,
4357  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4358  errmsg("permission denied to examine \"%s\"", name),
4359  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4360  "pg_read_all_settings")));
4361 
4362  switch (record->vartype)
4363  {
4364  case PGC_BOOL:
4365  return ((struct config_bool *) record)->reset_val ? "on" : "off";
4366 
4367  case PGC_INT:
4368  snprintf(buffer, sizeof(buffer), "%d",
4369  ((struct config_int *) record)->reset_val);
4370  return buffer;
4371 
4372  case PGC_REAL:
4373  snprintf(buffer, sizeof(buffer), "%g",
4374  ((struct config_real *) record)->reset_val);
4375  return buffer;
4376 
4377  case PGC_STRING:
4378  return ((struct config_string *) record)->reset_val ?
4379  ((struct config_string *) record)->reset_val : "";
4380 
4381  case PGC_ENUM:
4382  return config_enum_lookup_by_value((struct config_enum *) record,
4383  ((struct config_enum *) record)->reset_val);
4384  }
4385  return NULL;
4386 }
4387 
4388 /*
4389  * Get the GUC flags associated with the given option.
4390  *
4391  * If the option doesn't exist, return 0 if missing_ok is true,
4392  * otherwise throw an ereport and don't return.
4393  */
4394 int
4395 GetConfigOptionFlags(const char *name, bool missing_ok)
4396 {
4397  struct config_generic *record;
4398 
4399  record = find_option(name, false, missing_ok, ERROR);
4400  if (record == NULL)
4401  return 0;
4402  return record->flags;
4403 }
4404 
4405 
4406 /*
4407  * Write updated configuration parameter values into a temporary file.
4408  * This function traverses the list of parameters and quotes the string
4409  * values before writing them.
4410  */
4411 static void
4413 {
4415  ConfigVariable *item;
4416 
4417  initStringInfo(&buf);
4418 
4419  /* Emit file header containing warning comment */
4420  appendStringInfoString(&buf, "# Do not edit this file manually!\n");
4421  appendStringInfoString(&buf, "# It will be overwritten by the ALTER SYSTEM command.\n");
4422 
4423  errno = 0;
4424  if (write(fd, buf.data, buf.len) != buf.len)
4425  {
4426  /* if write didn't set errno, assume problem is no disk space */
4427  if (errno == 0)
4428  errno = ENOSPC;
4429  ereport(ERROR,
4431  errmsg("could not write to file \"%s\": %m", filename)));
4432  }
4433 
4434  /* Emit each parameter, properly quoting the value */
4435  for (item = head; item != NULL; item = item->next)
4436  {
4437  char *escaped;
4438 
4439  resetStringInfo(&buf);
4440 
4441  appendStringInfoString(&buf, item->name);
4442  appendStringInfoString(&buf, " = '");
4443 
4444  escaped = escape_single_quotes_ascii(item->value);
4445  if (!escaped)
4446  ereport(ERROR,
4447  (errcode(ERRCODE_OUT_OF_MEMORY),
4448  errmsg("out of memory")));
4449  appendStringInfoString(&buf, escaped);
4450  free(escaped);
4451 
4452  appendStringInfoString(&buf, "'\n");
4453 
4454  errno = 0;
4455  if (write(fd, buf.data, buf.len) != buf.len)
4456  {
4457  /* if write didn't set errno, assume problem is no disk space */
4458  if (errno == 0)
4459  errno = ENOSPC;
4460  ereport(ERROR,
4462  errmsg("could not write to file \"%s\": %m", filename)));
4463  }
4464  }
4465 
4466  /* fsync before considering the write to be successful */
4467  if (pg_fsync(fd) != 0)
4468  ereport(ERROR,
4470  errmsg("could not fsync file \"%s\": %m", filename)));
4471 
4472  pfree(buf.data);
4473 }
4474 
4475 /*
4476  * Update the given list of configuration parameters, adding, replacing
4477  * or deleting the entry for item "name" (delete if "value" == NULL).
4478  */
4479 static void
4481  const char *name, const char *value)
4482 {
4483  ConfigVariable *item,
4484  *next,
4485  *prev = NULL;
4486 
4487  /*
4488  * Remove any existing match(es) for "name". Normally there'd be at most
4489  * one, but if external tools have modified the config file, there could
4490  * be more.
4491  */
4492  for (item = *head_p; item != NULL; item = next)
4493  {
4494  next = item->next;
4495  if (guc_name_compare(item->name, name) == 0)
4496  {
4497  /* found a match, delete it */
4498  if (prev)
4499  prev->next = next;
4500  else
4501  *head_p = next;
4502  if (next == NULL)
4503  *tail_p = prev;
4504 
4505  pfree(item->name);
4506  pfree(item->value);
4507  pfree(item->filename);
4508  pfree(item);
4509  }
4510  else
4511  prev = item;
4512  }
4513 
4514  /* Done if we're trying to delete it */
4515  if (value == NULL)
4516  return;
4517 
4518  /* OK, append a new entry */
4519  item = palloc(sizeof *item);
4520  item->name = pstrdup(name);
4521  item->value = pstrdup(value);
4522  item->errmsg = NULL;
4523  item->filename = pstrdup(""); /* new item has no location */
4524  item->sourceline = 0;
4525  item->ignore = false;
4526  item->applied = false;
4527  item->next = NULL;
4528 
4529  if (*head_p == NULL)
4530  *head_p = item;
4531  else
4532  (*tail_p)->next = item;
4533  *tail_p = item;
4534 }
4535 
4536 
4537 /*
4538  * Execute ALTER SYSTEM statement.
4539  *
4540  * Read the old PG_AUTOCONF_FILENAME file, merge in the new variable value,
4541  * and write out an updated file. If the command is ALTER SYSTEM RESET ALL,
4542  * we can skip reading the old file and just write an empty file.
4543  *
4544  * An LWLock is used to serialize updates of the configuration file.
4545  *
4546  * In case of an error, we leave the original automatic
4547  * configuration file (PG_AUTOCONF_FILENAME) intact.
4548  */
4549 void
4551 {
4552  char *name;
4553  char *value;
4554  bool resetall = false;
4555  ConfigVariable *head = NULL;
4556  ConfigVariable *tail = NULL;
4557  volatile int Tmpfd;
4558  char AutoConfFileName[MAXPGPATH];
4559  char AutoConfTmpFileName[MAXPGPATH];
4560 
4561  /*
4562  * Extract statement arguments
4563  */
4564  name = altersysstmt->setstmt->name;
4565 
4566  if (!AllowAlterSystem)
4567  ereport(ERROR,
4568  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4569  errmsg("ALTER SYSTEM is not allowed in this environment")));
4570 
4571  switch (altersysstmt->setstmt->kind)
4572  {
4573  case VAR_SET_VALUE:
4574  value = ExtractSetVariableArgs(altersysstmt->setstmt);
4575  break;
4576 
4577  case VAR_SET_DEFAULT:
4578  case VAR_RESET:
4579  value = NULL;
4580  break;
4581 
4582  case VAR_RESET_ALL:
4583  value = NULL;
4584  resetall = true;
4585  break;
4586 
4587  default:
4588  elog(ERROR, "unrecognized alter system stmt type: %d",
4589  altersysstmt->setstmt->kind);
4590  break;
4591  }
4592 
4593  /*
4594  * Check permission to run ALTER SYSTEM on the target variable
4595  */
4596  if (!superuser())
4597  {
4598  if (resetall)
4599  ereport(ERROR,
4600  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4601  errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4602  else
4603  {
4604  AclResult aclresult;
4605 
4606  aclresult = pg_parameter_aclcheck(name, GetUserId(),
4608  if (aclresult != ACLCHECK_OK)
4609  ereport(ERROR,
4610  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4611  errmsg("permission denied to set parameter \"%s\"",
4612  name)));
4613  }
4614  }
4615 
4616  /*
4617  * Unless it's RESET_ALL, validate the target variable and value
4618  */
4619  if (!resetall)
4620  {
4621  struct config_generic *record;
4622 
4623  /* We don't want to create a placeholder if there's not one already */
4624  record = find_option(name, false, true, DEBUG5);
4625  if (record != NULL)
4626  {
4627  /*
4628  * Don't allow parameters that can't be set in configuration files
4629  * to be set in PG_AUTOCONF_FILENAME file.
4630  */
4631  if ((record->context == PGC_INTERNAL) ||
4632  (record->flags & GUC_DISALLOW_IN_FILE) ||
4633  (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
4634  ereport(ERROR,
4635  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4636  errmsg("parameter \"%s\" cannot be changed",
4637  name)));
4638 
4639  /*
4640  * If a value is specified, verify that it's sane.
4641  */
4642  if (value)
4643  {
4644  union config_var_val newval;
4645  void *newextra = NULL;
4646 
4647  if (!parse_and_validate_value(record, name, value,
4648  PGC_S_FILE, ERROR,
4649  &newval, &newextra))
4650  ereport(ERROR,
4651  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4652  errmsg("invalid value for parameter \"%s\": \"%s\"",
4653  name, value)));
4654 
4655  if (record->vartype == PGC_STRING && newval.stringval != NULL)
4656  guc_free(newval.stringval);
4657  guc_free(newextra);
4658  }
4659  }
4660  else
4661  {
4662  /*
4663  * Variable not known; check we'd be allowed to create it. (We
4664  * cannot validate the value, but that's fine. A non-core GUC in
4665  * the config file cannot cause postmaster start to fail, so we
4666  * don't have to be too tense about possibly installing a bad
4667  * value.)
4668  */
4669  (void) assignable_custom_variable_name(name, false, ERROR);
4670  }
4671 
4672  /*
4673  * We must also reject values containing newlines, because the grammar
4674  * for config files doesn't support embedded newlines in string
4675  * literals.
4676  */
4677  if (value && strchr(value, '\n'))
4678  ereport(ERROR,
4679  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4680  errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4681  }
4682 
4683  /*
4684  * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4685  * the data directory, so we can reference them by simple relative paths.
4686  */
4687  snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4689  snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4690  AutoConfFileName,
4691  "tmp");
4692 
4693  /*
4694  * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4695  * time. Use AutoFileLock to ensure that. We must hold the lock while
4696  * reading the old file contents.
4697  */
4698  LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4699 
4700  /*
4701  * If we're going to reset everything, then no need to open or parse the
4702  * old file. We'll just write out an empty list.
4703  */
4704  if (!resetall)
4705  {
4706  struct stat st;
4707 
4708  if (stat(AutoConfFileName, &st) == 0)
4709  {
4710  /* open old file PG_AUTOCONF_FILENAME */
4711  FILE *infile;
4712 
4713  infile = AllocateFile(AutoConfFileName, "r");
4714  if (infile == NULL)
4715  ereport(ERROR,
4717  errmsg("could not open file \"%s\": %m",
4718  AutoConfFileName)));
4719 
4720  /* parse it */
4721  if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4722  LOG, &head, &tail))
4723  ereport(ERROR,
4724  (errcode(ERRCODE_CONFIG_FILE_ERROR),
4725  errmsg("could not parse contents of file \"%s\"",
4726  AutoConfFileName)));
4727 
4728  FreeFile(infile);
4729  }
4730 
4731  /*
4732  * Now, replace any existing entry with the new value, or add it if
4733  * not present.
4734  */
4735  replace_auto_config_value(&head, &tail, name, value);
4736  }
4737 
4738  /*
4739  * Invoke the post-alter hook for setting this GUC variable. GUCs
4740  * typically do not have corresponding entries in pg_parameter_acl, so we
4741  * call the hook using the name rather than a potentially-non-existent
4742  * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4743  * context can be distinguished from others. (Note that "name" will be
4744  * NULL in the RESET ALL case.)
4745  *
4746  * We do this here rather than at the end, because ALTER SYSTEM is not
4747  * transactional. If the hook aborts our transaction, it will be cleaner
4748  * to do so before we touch any files.
4749  */
4750  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4752  altersysstmt->setstmt->kind,
4753  false);
4754 
4755  /*
4756  * To ensure crash safety, first write the new file data to a temp file,
4757  * then atomically rename it into place.
4758  *
4759  * If there is a temp file left over due to a previous crash, it's okay to
4760  * truncate and reuse it.
4761  */
4762  Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4763  O_CREAT | O_RDWR | O_TRUNC);
4764  if (Tmpfd < 0)
4765  ereport(ERROR,
4767  errmsg("could not open file \"%s\": %m",
4768  AutoConfTmpFileName)));
4769 
4770  /*
4771  * Use a TRY block to clean up the file if we fail. Since we need a TRY
4772  * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4773  */
4774  PG_TRY();
4775  {
4776  /* Write and sync the new contents to the temporary file */
4777  write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4778 
4779  /* Close before renaming; may be required on some platforms */
4780  close(Tmpfd);
4781  Tmpfd = -1;
4782 
4783  /*
4784  * As the rename is atomic operation, if any problem occurs after this
4785  * at worst it can lose the parameters set by last ALTER SYSTEM
4786  * command.
4787  */
4788  durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4789  }
4790  PG_CATCH();
4791  {
4792  /* Close file first, else unlink might fail on some platforms */
4793  if (Tmpfd >= 0)
4794  close(Tmpfd);
4795 
4796  /* Unlink, but ignore any error */
4797  (void) unlink(AutoConfTmpFileName);
4798 
4799  PG_RE_THROW();
4800  }
4801  PG_END_TRY();
4802 
4803  FreeConfigVariables(head);
4804 
4805  LWLockRelease(AutoFileLock);
4806 }
4807 
4808 
4809 /*
4810  * Common code for DefineCustomXXXVariable subroutines: allocate the
4811  * new variable's config struct and fill in generic fields.
4812  */
4813 static struct config_generic *
4815  const char *short_desc,
4816  const char *long_desc,
4818  int flags,
4819  enum config_type type,
4820  size_t sz)
4821 {
4822  struct config_generic *gen;
4823 
4824  /*
4825  * Only allow custom PGC_POSTMASTER variables to be created during shared
4826  * library preload; any later than that, we can't ensure that the value
4827  * doesn't change after startup. This is a fatal elog if it happens; just
4828  * erroring out isn't safe because we don't know what the calling loadable
4829  * module might already have hooked into.
4830  */
4831  if (context == PGC_POSTMASTER &&
4833  elog(FATAL, "cannot create PGC_POSTMASTER variables after startup");
4834 
4835  /*
4836  * We can't support custom GUC_LIST_QUOTE variables, because the wrong
4837  * things would happen if such a variable were set or pg_dump'd when the
4838  * defining extension isn't loaded. Again, treat this as fatal because
4839  * the loadable module may be partly initialized already.
4840  */
4841  if (flags & GUC_LIST_QUOTE)
4842  elog(FATAL, "extensions cannot define GUC_LIST_QUOTE variables");
4843 
4844  /*
4845  * Before pljava commit 398f3b876ed402bdaec8bc804f29e2be95c75139
4846  * (2015-12-15), two of that module's PGC_USERSET variables facilitated
4847  * trivial escalation to superuser privileges. Restrict the variables to
4848  * protect sites that have yet to upgrade pljava.
4849  */
4850  if (context == PGC_USERSET &&
4851  (strcmp(name, "pljava.classpath") == 0 ||
4852  strcmp(name, "pljava.vmoptions") == 0))
4853  context = PGC_SUSET;
4854 
4855  gen = (struct config_generic *) guc_malloc(ERROR, sz);
4856  memset(gen, 0, sz);
4857 
4858  gen->name = guc_strdup(ERROR, name);
4859  gen->context = context;
4860  gen->group = CUSTOM_OPTIONS;
4861  gen->short_desc = short_desc;
4862  gen->long_desc = long_desc;
4863  gen->flags = flags;
4864  gen->vartype = type;
4865 
4866  return gen;
4867 }
4868 
4869 /*
4870  * Common code for DefineCustomXXXVariable subroutines: insert the new
4871  * variable into the GUC variable hash, replacing any placeholder.
4872  */
4873 static void
4875 {
4876  const char *name = variable->name;
4877  GUCHashEntry *hentry;
4878  struct config_string *pHolder;
4879 
4880  /* Check mapping between initial and default value */
4881  Assert(check_GUC_init(variable));
4882 
4883  /*
4884  * See if there's a placeholder by the same name.
4885  */
4886  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
4887  &name,
4888  HASH_FIND,
4889  NULL);
4890  if (hentry == NULL)
4891  {
4892  /*
4893  * No placeholder to replace, so we can just add it ... but first,
4894  * make sure it's initialized to its default value.
4895  */
4898  return;
4899  }
4900 
4901  /*
4902  * This better be a placeholder
4903  */
4904  if ((hentry->gucvar->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
4905  ereport(ERROR,
4906  (errcode(ERRCODE_INTERNAL_ERROR),
4907  errmsg("attempt to redefine parameter \"%s\"", name)));
4908 
4909  Assert(hentry->gucvar->vartype == PGC_STRING);
4910  pHolder = (struct config_string *) hentry->gucvar;
4911 
4912  /*
4913  * First, set the variable to its default value. We must do this even
4914  * though we intend to immediately apply a new value, since it's possible
4915  * that the new value is invalid.
4916  */
4918 
4919  /*
4920  * Replace the placeholder in the hash table. We aren't changing the name
4921  * (at least up to case-folding), so the hash value is unchanged.
4922  */
4923  hentry->gucname = name;
4924  hentry->gucvar = variable;
4925 
4926  /*
4927  * Remove the placeholder from any lists it's in, too.
4928  */
4929  RemoveGUCFromLists(&pHolder->gen);
4930 
4931  /*
4932  * Assign the string value(s) stored in the placeholder to the real
4933  * variable. Essentially, we need to duplicate all the active and stacked
4934  * values, but with appropriate validation and datatype adjustment.
4935  *
4936  * If an assignment fails, we report a WARNING and keep going. We don't
4937  * want to throw ERROR for bad values, because it'd bollix the add-on
4938  * module that's presumably halfway through getting loaded. In such cases
4939  * the default or previous state will become active instead.
4940  */
4941 
4942  /* First, apply the reset value if any */
4943  if (pHolder->reset_val)
4944  (void) set_config_option_ext(name, pHolder->reset_val,
4945  pHolder->gen.reset_scontext,
4946  pHolder->gen.reset_source,
4947  pHolder->gen.reset_srole,
4948  GUC_ACTION_SET, true, WARNING, false);
4949  /* That should not have resulted in stacking anything */
4950  Assert(variable->stack == NULL);
4951 
4952  /* Now, apply current and stacked values, in the order they were stacked */
4953  reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
4954  *(pHolder->variable),
4955  pHolder->gen.scontext, pHolder->gen.source,
4956  pHolder->gen.srole);
4957 
4958  /* Also copy over any saved source-location information */
4959  if (pHolder->gen.sourcefile)
4961  pHolder->gen.sourceline);
4962 
4963  /*
4964  * Free up as much as we conveniently can of the placeholder structure.
4965  * (This neglects any stack items, so it's possible for some memory to be
4966  * leaked. Since this can only happen once per session per variable, it
4967  * doesn't seem worth spending much code on.)
4968  */
4969  set_string_field(pHolder, pHolder->variable, NULL);
4970  set_string_field(pHolder, &pHolder->reset_val, NULL);
4971 
4972  guc_free(pHolder);
4973 }
4974 
4975 /*
4976  * Recursive subroutine for define_custom_variable: reapply non-reset values
4977  *
4978  * We recurse so that the values are applied in the same order as originally.
4979  * At each recursion level, apply the upper-level value (passed in) in the
4980  * fashion implied by the stack entry.
4981  */
4982 static void
4984  struct config_string *pHolder,
4985  GucStack *stack,
4986  const char *curvalue,
4987  GucContext curscontext, GucSource cursource,
4988  Oid cursrole)
4989 {
4990  const char *name = variable->name;
4991  GucStack *oldvarstack = variable->stack;
4992 
4993  if (stack != NULL)
4994  {
4995  /* First, recurse, so that stack items are processed bottom to top */
4996  reapply_stacked_values(variable, pHolder, stack->prev,
4997  stack->prior.val.stringval,
4998  stack->scontext, stack->source, stack->srole);
4999 
5000  /* See how to apply the passed-in value */
5001  switch (stack->state)
5002  {
5003  case GUC_SAVE:
5004  (void) set_config_option_ext(name, curvalue,
5005  curscontext, cursource, cursrole,
5006  GUC_ACTION_SAVE, true,
5007  WARNING, false);
5008  break;
5009 
5010  case GUC_SET:
5011  (void) set_config_option_ext(name, curvalue,
5012  curscontext, cursource, cursrole,
5013  GUC_ACTION_SET, true,
5014  WARNING, false);
5015  break;
5016 
5017  case GUC_LOCAL:
5018  (void) set_config_option_ext(name, curvalue,
5019  curscontext, cursource, cursrole,
5020  GUC_ACTION_LOCAL, true,
5021  WARNING, false);
5022  break;
5023 
5024  case GUC_SET_LOCAL:
5025  /* first, apply the masked value as SET */
5027  stack->masked_scontext,
5028  PGC_S_SESSION,
5029  stack->masked_srole,
5030  GUC_ACTION_SET, true,
5031  WARNING, false);
5032  /* then apply the current value as LOCAL */
5033  (void) set_config_option_ext(name, curvalue,
5034  curscontext, cursource, cursrole,
5035  GUC_ACTION_LOCAL, true,
5036  WARNING, false);
5037  break;
5038  }
5039 
5040  /* If we successfully made a stack entry, adjust its nest level */
5041  if (variable->stack != oldvarstack)
5042  variable->stack->nest_level = stack->nest_level;
5043  }
5044  else
5045  {
5046  /*
5047  * We are at the end of the stack. If the active/previous value is
5048  * different from the reset value, it must represent a previously
5049  * committed session value. Apply it, and then drop the stack entry
5050  * that set_config_option will have created under the impression that
5051  * this is to be just a transactional assignment. (We leak the stack
5052  * entry.)
5053  */
5054  if (curvalue != pHolder->reset_val ||
5055  curscontext != pHolder->gen.reset_scontext ||
5056  cursource != pHolder->gen.reset_source ||
5057  cursrole != pHolder->gen.reset_srole)
5058  {
5059  (void) set_config_option_ext(name, curvalue,
5060  curscontext, cursource, cursrole,
5061  GUC_ACTION_SET, true, WARNING, false);
5062  if (variable->stack != NULL)
5063  {
5064  slist_delete(&guc_stack_list, &variable->stack_link);
5065  variable->stack = NULL;
5066  }
5067  }
5068  }
5069 }
5070 
5071 /*
5072  * Functions for extensions to call to define their custom GUC variables.
5073  */
5074 void
5076  const char *short_desc,
5077  const char *long_desc,
5078  bool *valueAddr,
5079  bool bootValue,
5081  int flags,
5085 {
5086  struct config_bool *var;
5087 
5088  var = (struct config_bool *)
5089  init_custom_variable(name, short_desc, long_desc, context, flags,
5090  PGC_BOOL, sizeof(struct config_bool));
5091  var->variable = valueAddr;
5092  var->boot_val = bootValue;
5093  var->reset_val = bootValue;
5094  var->check_hook = check_hook;
5095  var->assign_hook = assign_hook;
5096  var->show_hook = show_hook;
5097  define_custom_variable(&var->gen);
5098 }
5099 
5100 void
5102  const char *short_desc,
5103  const char *long_desc,
5104  int *valueAddr,
5105  int bootValue,
5106  int minValue,
5107  int maxValue,
5109  int flags,
5113 {
5114  struct config_int *var;
5115 
5116  var = (struct config_int *)
5117  init_custom_variable(name, short_desc, long_desc, context, flags,
5118  PGC_INT, sizeof(struct config_int));
5119  var->variable = valueAddr;
5120  var->boot_val = bootValue;
5121  var->reset_val = bootValue;
5122  var->min = minValue;
5123  var->max = maxValue;
5124  var->check_hook = check_hook;
5125  var->assign_hook = assign_hook;
5126  var->show_hook = show_hook;
5127  define_custom_variable(&var->gen);
5128 }
5129 
5130 void
5132  const char *short_desc,
5133  const char *long_desc,
5134  double *valueAddr,
5135  double bootValue,
5136  double minValue,
5137  double maxValue,
5139  int flags,
5143 {
5144  struct config_real *var;
5145 
5146  var = (struct config_real *)
5147  init_custom_variable(name, short_desc, long_desc, context, flags,
5148  PGC_REAL, sizeof(struct config_real));
5149  var->variable = valueAddr;
5150  var->boot_val = bootValue;
5151  var->reset_val = bootValue;
5152  var->min = minValue;
5153  var->max = maxValue;
5154  var->check_hook = check_hook;
5155  var->assign_hook = assign_hook;
5156  var->show_hook = show_hook;
5157  define_custom_variable(&var->gen);
5158 }
5159 
5160 void
5162  const char *short_desc,
5163  const char *long_desc,
5164  char **valueAddr,
5165  const char *bootValue,
5167  int flags,
5171 {
5172  struct config_string *var;
5173 
5174  var = (struct config_string *)
5175  init_custom_variable(name, short_desc, long_desc, context, flags,
5176  PGC_STRING, sizeof(struct config_string));
5177  var->variable = valueAddr;
5178  var->boot_val = bootValue;
5179  var->check_hook = check_hook;
5180  var->assign_hook = assign_hook;
5181  var->show_hook = show_hook;
5182  define_custom_variable(&var->gen);
5183 }
5184 
5185 void
5187  const char *short_desc,
5188  const char *long_desc,
5189  int *valueAddr,
5190  int bootValue,
5191  const struct config_enum_entry *options,
5193  int flags,
5197 {
5198  struct config_enum *var;
5199 
5200  var = (struct config_enum *)
5201  init_custom_variable(name, short_desc, long_desc, context, flags,
5202  PGC_ENUM, sizeof(struct config_enum));
5203  var->variable = valueAddr;
5204  var->boot_val = bootValue;
5205  var->reset_val = bootValue;
5206  var->options = options;
5207  var->check_hook = check_hook;
5208  var->assign_hook = assign_hook;
5209  var->show_hook = show_hook;
5210  define_custom_variable(&var->gen);
5211 }
5212 
5213 /*
5214  * Mark the given GUC prefix as "reserved".
5215  *
5216  * This deletes any existing placeholders matching the prefix,
5217  * and then prevents new ones from being created.
5218  * Extensions should call this after they've defined all of their custom
5219  * GUCs, to help catch misspelled config-file entries.
5220  */
5221 void
5222 MarkGUCPrefixReserved(const char *className)
5223 {
5224  int classLen = strlen(className);
5225  HASH_SEQ_STATUS status;
5226  GUCHashEntry *hentry;
5227  MemoryContext oldcontext;
5228 
5229  /*
5230  * Check for existing placeholders. We must actually remove invalid
5231  * placeholders, else future parallel worker startups will fail. (We
5232  * don't bother trying to free associated memory, since this shouldn't
5233  * happen often.)
5234  */
5235  hash_seq_init(&status, guc_hashtab);
5236  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5237  {
5238  struct config_generic *var = hentry->gucvar;
5239 
5240  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5241  strncmp(className, var->name, classLen) == 0 &&
5242  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5243  {
5244  ereport(WARNING,
5245  (errcode(ERRCODE_INVALID_NAME),
5246  errmsg("invalid configuration parameter name \"%s\", removing it",
5247  var->name),
5248  errdetail("\"%s\" is now a reserved prefix.",
5249  className)));
5250  /* Remove it from the hash table */
5252  &var->name,
5253  HASH_REMOVE,
5254  NULL);
5255  /* Remove it from any lists it's in, too */
5256  RemoveGUCFromLists(var);
5257  }
5258  }
5259 
5260  /* And remember the name so we can prevent future mistakes. */
5263  MemoryContextSwitchTo(oldcontext);
5264 }
5265 
5266 
5267 /*
5268  * Return an array of modified GUC options to show in EXPLAIN.
5269  *
5270  * We only report options related to query planning (marked with GUC_EXPLAIN),
5271  * with values different from their built-in defaults.
5272  */
5273 struct config_generic **
5275 {
5276  struct config_generic **result;
5277  dlist_iter iter;
5278 
5279  *num = 0;
5280 
5281  /*
5282  * While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
5283  * it doesn't seem worth dynamically resizing this array.
5284  */
5285  result = palloc(sizeof(struct config_generic *) * hash_get_num_entries(guc_hashtab));
5286 
5287  /* We need only consider GUCs with source not PGC_S_DEFAULT */
5289  {
5290  struct config_generic *conf = dlist_container(struct config_generic,
5291  nondef_link, iter.cur);
5292  bool modified;
5293 
5294  /* return only parameters marked for inclusion in explain */
5295  if (!(conf->flags & GUC_EXPLAIN))
5296  continue;
5297 
5298  /* return only options visible to the current user */
5299  if (!ConfigOptionIsVisible(conf))
5300  continue;
5301 
5302  /* return only options that are different from their boot values */
5303  modified = false;
5304 
5305  switch (conf->vartype)
5306  {
5307  case PGC_BOOL:
5308  {
5309  struct config_bool *lconf = (struct config_bool *) conf;
5310 
5311  modified = (lconf->boot_val != *(lconf->variable));
5312  }
5313  break;
5314 
5315  case PGC_INT:
5316  {
5317  struct config_int *lconf = (struct config_int *) conf;
5318 
5319  modified = (lconf->boot_val != *(lconf->variable));
5320  }
5321  break;
5322 
5323  case PGC_REAL:
5324  {
5325  struct config_real *lconf = (struct config_real *) conf;
5326 
5327  modified = (lconf->boot_val != *(lconf->variable));
5328  }
5329  break;
5330 
5331  case PGC_STRING:
5332  {
5333  struct config_string *lconf = (struct config_string *) conf;
5334 
5335  if (lconf->boot_val == NULL &&
5336  *lconf->variable == NULL)
5337  modified = false;
5338  else if (lconf->boot_val == NULL ||
5339  *lconf->variable == NULL)
5340  modified = true;
5341  else
5342  modified = (strcmp(lconf->boot_val, *(lconf->variable)) != 0);
5343  }
5344  break;
5345 
5346  case PGC_ENUM:
5347  {
5348  struct config_enum *lconf = (struct config_enum *) conf;
5349 
5350  modified = (lconf->boot_val != *(lconf->variable));
5351  }