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  const char *unitspace;
3177 
3178  if (unit)
3179  unitspace = " ";
3180  else
3181  unit = unitspace = "";
3182 
3183  ereport(elevel,
3184  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3185  errmsg("%d%s%s is outside the valid range for parameter \"%s\" (%d%s%s .. %d%s%s)",
3186  newval->intval, unitspace, unit,
3187  name,
3188  conf->min, unitspace, unit,
3189  conf->max, unitspace, unit)));
3190  return false;
3191  }
3192 
3193  if (!call_int_check_hook(conf, &newval->intval, newextra,
3194  source, elevel))
3195  return false;
3196  }
3197  break;
3198  case PGC_REAL:
3199  {
3200  struct config_real *conf = (struct config_real *) record;
3201  const char *hintmsg;
3202 
3203  if (!parse_real(value, &newval->realval,
3204  conf->gen.flags, &hintmsg))
3205  {
3206  ereport(elevel,
3207  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3208  errmsg("invalid value for parameter \"%s\": \"%s\"",
3209  name, value),
3210  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3211  return false;
3212  }
3213 
3214  if (newval->realval < conf->min || newval->realval > conf->max)
3215  {
3216  const char *unit = get_config_unit_name(conf->gen.flags);
3217  const char *unitspace;
3218 
3219  if (unit)
3220  unitspace = " ";
3221  else
3222  unit = unitspace = "";
3223 
3224  ereport(elevel,
3225  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3226  errmsg("%g%s%s is outside the valid range for parameter \"%s\" (%g%s%s .. %g%s%s)",
3227  newval->realval, unitspace, unit,
3228  name,
3229  conf->min, unitspace, unit,
3230  conf->max, unitspace, unit)));
3231  return false;
3232  }
3233 
3234  if (!call_real_check_hook(conf, &newval->realval, newextra,
3235  source, elevel))
3236  return false;
3237  }
3238  break;
3239  case PGC_STRING:
3240  {
3241  struct config_string *conf = (struct config_string *) record;
3242 
3243  /*
3244  * The value passed by the caller could be transient, so we
3245  * always strdup it.
3246  */
3247  newval->stringval = guc_strdup(elevel, value);
3248  if (newval->stringval == NULL)
3249  return false;
3250 
3251  /*
3252  * The only built-in "parsing" check we have is to apply
3253  * truncation if GUC_IS_NAME.
3254  */
3255  if (conf->gen.flags & GUC_IS_NAME)
3256  truncate_identifier(newval->stringval,
3257  strlen(newval->stringval),
3258  true);
3259 
3260  if (!call_string_check_hook(conf, &newval->stringval, newextra,
3261  source, elevel))
3262  {
3263  guc_free(newval->stringval);
3264  newval->stringval = NULL;
3265  return false;
3266  }
3267  }
3268  break;
3269  case PGC_ENUM:
3270  {
3271  struct config_enum *conf = (struct config_enum *) record;
3272 
3273  if (!config_enum_lookup_by_name(conf, value, &newval->enumval))
3274  {
3275  char *hintmsg;
3276 
3277  hintmsg = config_enum_get_options(conf,
3278  "Available values: ",
3279  ".", ", ");
3280 
3281  ereport(elevel,
3282  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3283  errmsg("invalid value for parameter \"%s\": \"%s\"",
3284  name, value),
3285  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3286 
3287  if (hintmsg)
3288  pfree(hintmsg);
3289  return false;
3290  }
3291 
3292  if (!call_enum_check_hook(conf, &newval->enumval, newextra,
3293  source, elevel))
3294  return false;
3295  }
3296  break;
3297  }
3298 
3299  return true;
3300 }
3301 
3302 
3303 /*
3304  * set_config_option: sets option `name' to given value.
3305  *
3306  * The value should be a string, which will be parsed and converted to
3307  * the appropriate data type. The context and source parameters indicate
3308  * in which context this function is being called, so that it can apply the
3309  * access restrictions properly.
3310  *
3311  * If value is NULL, set the option to its default value (normally the
3312  * reset_val, but if source == PGC_S_DEFAULT we instead use the boot_val).
3313  *
3314  * action indicates whether to set the value globally in the session, locally
3315  * to the current top transaction, or just for the duration of a function call.
3316  *
3317  * If changeVal is false then don't really set the option but do all
3318  * the checks to see if it would work.
3319  *
3320  * elevel should normally be passed as zero, allowing this function to make
3321  * its standard choice of ereport level. However some callers need to be
3322  * able to override that choice; they should pass the ereport level to use.
3323  *
3324  * is_reload should be true only when called from read_nondefault_variables()
3325  * or RestoreGUCState(), where we are trying to load some other process's
3326  * GUC settings into a new process.
3327  *
3328  * Return value:
3329  * +1: the value is valid and was successfully applied.
3330  * 0: the name or value is invalid (but see below).
3331  * -1: the value was not applied because of context, priority, or changeVal.
3332  *
3333  * If there is an error (non-existing option, invalid value) then an
3334  * ereport(ERROR) is thrown *unless* this is called for a source for which
3335  * we don't want an ERROR (currently, those are defaults, the config file,
3336  * and per-database or per-user settings, as well as callers who specify
3337  * a less-than-ERROR elevel). In those cases we write a suitable error
3338  * message via ereport() and return 0.
3339  *
3340  * See also SetConfigOption for an external interface.
3341  */
3342 int
3343 set_config_option(const char *name, const char *value,
3345  GucAction action, bool changeVal, int elevel,
3346  bool is_reload)
3347 {
3348  Oid srole;
3349 
3350  /*
3351  * Non-interactive sources should be treated as having all privileges,
3352  * except for PGC_S_CLIENT. Note in particular that this is true for
3353  * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3354  * privilege check was done when the pg_db_role_setting entry was made.
3355  */
3357  srole = GetUserId();
3358  else
3359  srole = BOOTSTRAP_SUPERUSERID;
3360 
3361  return set_config_with_handle(name, NULL, value,
3362  context, source, srole,
3363  action, changeVal, elevel,
3364  is_reload);
3365 }
3366 
3367 /*
3368  * set_config_option_ext: sets option `name' to given value.
3369  *
3370  * This API adds the ability to explicitly specify which role OID
3371  * is considered to be setting the value. Most external callers can use
3372  * set_config_option() and let it determine that based on the GucSource,
3373  * but there are a few that are supplying a value that was determined
3374  * in some special way and need to override the decision. Also, when
3375  * restoring a previously-assigned value, it's important to supply the
3376  * same role OID that set the value originally; so all guc.c callers
3377  * that are doing that type of thing need to call this directly.
3378  *
3379  * Generally, srole should be GetUserId() when the source is a SQL operation,
3380  * or BOOTSTRAP_SUPERUSERID if the source is a config file or similar.
3381  */
3382 int
3383 set_config_option_ext(const char *name, const char *value,
3385  GucAction action, bool changeVal, int elevel,
3386  bool is_reload)
3387 {
3388  return set_config_with_handle(name, NULL, value,
3389  context, source, srole,
3390  action, changeVal, elevel,
3391  is_reload);
3392 }
3393 
3394 
3395 /*
3396  * set_config_with_handle: takes an optional 'handle' argument, which can be
3397  * obtained by the caller from get_config_handle().
3398  *
3399  * This should be used by callers which repeatedly set the same config
3400  * option(s), and want to avoid the overhead of a hash lookup each time.
3401  */
3402 int
3404  const char *value,
3406  GucAction action, bool changeVal, int elevel,
3407  bool is_reload)
3408 {
3409  struct config_generic *record;
3410  union config_var_val newval_union;
3411  void *newextra = NULL;
3412  bool prohibitValueChange = false;
3413  bool makeDefault;
3414 
3415  if (elevel == 0)
3416  {
3417  if (source == PGC_S_DEFAULT || source == PGC_S_FILE)
3418  {
3419  /*
3420  * To avoid cluttering the log, only the postmaster bleats loudly
3421  * about problems with the config file.
3422  */
3423  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
3424  }
3425  else if (source == PGC_S_GLOBAL ||
3426  source == PGC_S_DATABASE ||
3427  source == PGC_S_USER ||
3429  elevel = WARNING;
3430  else
3431  elevel = ERROR;
3432  }
3433 
3434  /*
3435  * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
3436  * because the current worker will also pop the change. We're probably
3437  * dealing with a function having a proconfig entry. Only the function's
3438  * body should observe the change, and peer workers do not share in the
3439  * execution of a function call started by this worker.
3440  *
3441  * Other changes might need to affect other workers, so forbid them.
3442  */
3443  if (IsInParallelMode() && changeVal && action != GUC_ACTION_SAVE)
3444  {
3445  ereport(elevel,
3446  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3447  errmsg("cannot set parameters during a parallel operation")));
3448  return -1;
3449  }
3450 
3451  /* if handle is specified, no need to look up option */
3452  if (!handle)
3453  {
3454  record = find_option(name, true, false, elevel);
3455  if (record == NULL)
3456  return 0;
3457  }
3458  else
3459  record = handle;
3460 
3461  /*
3462  * Check if the option can be set at this time. See guc.h for the precise
3463  * rules.
3464  */
3465  switch (record->context)
3466  {
3467  case PGC_INTERNAL:
3468  if (context != PGC_INTERNAL)
3469  {
3470  ereport(elevel,
3471  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3472  errmsg("parameter \"%s\" cannot be changed",
3473  name)));
3474  return 0;
3475  }
3476  break;
3477  case PGC_POSTMASTER:
3478  if (context == PGC_SIGHUP)
3479  {
3480  /*
3481  * We are re-reading a PGC_POSTMASTER variable from
3482  * postgresql.conf. We can't change the setting, so we should
3483  * give a warning if the DBA tries to change it. However,
3484  * because of variant formats, canonicalization by check
3485  * hooks, etc, we can't just compare the given string directly
3486  * to what's stored. Set a flag to check below after we have
3487  * the final storable value.
3488  */
3489  prohibitValueChange = true;
3490  }
3491  else if (context != PGC_POSTMASTER)
3492  {
3493  ereport(elevel,
3494  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3495  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3496  name)));
3497  return 0;
3498  }
3499  break;
3500  case PGC_SIGHUP:
3502  {
3503  ereport(elevel,
3504  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3505  errmsg("parameter \"%s\" cannot be changed now",
3506  name)));
3507  return 0;
3508  }
3509 
3510  /*
3511  * Hmm, the idea of the SIGHUP context is "ought to be global, but
3512  * can be changed after postmaster start". But there's nothing
3513  * that prevents a crafty administrator from sending SIGHUP
3514  * signals to individual backends only.
3515  */
3516  break;
3517  case PGC_SU_BACKEND:
3518  if (context == PGC_BACKEND)
3519  {
3520  /*
3521  * Check whether the requesting user has been granted
3522  * privilege to set this GUC.
3523  */
3524  AclResult aclresult;
3525 
3526  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3527  if (aclresult != ACLCHECK_OK)
3528  {
3529  /* No granted privilege */
3530  ereport(elevel,
3531  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3532  errmsg("permission denied to set parameter \"%s\"",
3533  name)));
3534  return 0;
3535  }
3536  }
3537  /* fall through to process the same as PGC_BACKEND */
3538  /* FALLTHROUGH */
3539  case PGC_BACKEND:
3540  if (context == PGC_SIGHUP)
3541  {
3542  /*
3543  * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
3544  * the config file, we want to accept the new value in the
3545  * postmaster (whence it will propagate to
3546  * subsequently-started backends), but ignore it in existing
3547  * backends. This is a tad klugy, but necessary because we
3548  * don't re-read the config file during backend start.
3549  *
3550  * However, if changeVal is false then plow ahead anyway since
3551  * we are trying to find out if the value is potentially good,
3552  * not actually use it.
3553  *
3554  * In EXEC_BACKEND builds, this works differently: we load all
3555  * non-default settings from the CONFIG_EXEC_PARAMS file
3556  * during backend start. In that case we must accept
3557  * PGC_SIGHUP settings, so as to have the same value as if
3558  * we'd forked from the postmaster. This can also happen when
3559  * using RestoreGUCState() within a background worker that
3560  * needs to have the same settings as the user backend that
3561  * started it. is_reload will be true when either situation
3562  * applies.
3563  */
3564  if (IsUnderPostmaster && changeVal && !is_reload)
3565  return -1;
3566  }
3567  else if (context != PGC_POSTMASTER &&
3568  context != PGC_BACKEND &&
3569  context != PGC_SU_BACKEND &&
3570  source != PGC_S_CLIENT)
3571  {
3572  ereport(elevel,
3573  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3574  errmsg("parameter \"%s\" cannot be set after connection start",
3575  name)));
3576  return 0;
3577  }
3578  break;
3579  case PGC_SUSET:
3580  if (context == PGC_USERSET || context == PGC_BACKEND)
3581  {
3582  /*
3583  * Check whether the requesting user has been granted
3584  * privilege to set this GUC.
3585  */
3586  AclResult aclresult;
3587 
3588  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3589  if (aclresult != ACLCHECK_OK)
3590  {
3591  /* No granted privilege */
3592  ereport(elevel,
3593  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3594  errmsg("permission denied to set parameter \"%s\"",
3595  name)));
3596  return 0;
3597  }
3598  }
3599  break;
3600  case PGC_USERSET:
3601  /* always okay */
3602  break;
3603  }
3604 
3605  /*
3606  * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
3607  * security restriction context. We can reject this regardless of the GUC
3608  * context or source, mainly because sources that it might be reasonable
3609  * to override for won't be seen while inside a function.
3610  *
3611  * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
3612  * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
3613  * An exception might be made if the reset value is assumed to be "safe".
3614  *
3615  * Note: this flag is currently used for "session_authorization" and
3616  * "role". We need to prohibit changing these inside a local userid
3617  * context because when we exit it, GUC won't be notified, leaving things
3618  * out of sync. (This could be fixed by forcing a new GUC nesting level,
3619  * but that would change behavior in possibly-undesirable ways.) Also, we
3620  * prohibit changing these in a security-restricted operation because
3621  * otherwise RESET could be used to regain the session user's privileges.
3622  */
3623  if (record->flags & GUC_NOT_WHILE_SEC_REST)
3624  {
3625  if (InLocalUserIdChange())
3626  {
3627  /*
3628  * Phrasing of this error message is historical, but it's the most
3629  * common case.
3630  */
3631  ereport(elevel,
3632  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3633  errmsg("cannot set parameter \"%s\" within security-definer function",
3634  name)));
3635  return 0;
3636  }
3638  {
3639  ereport(elevel,
3640  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3641  errmsg("cannot set parameter \"%s\" within security-restricted operation",
3642  name)));
3643  return 0;
3644  }
3645  }
3646 
3647  /* Disallow resetting and saving GUC_NO_RESET values */
3648  if (record->flags & GUC_NO_RESET)
3649  {
3650  if (value == NULL)
3651  {
3652  ereport(elevel,
3653  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3654  errmsg("parameter \"%s\" cannot be reset", name)));
3655  return 0;
3656  }
3657  if (action == GUC_ACTION_SAVE)
3658  {
3659  ereport(elevel,
3660  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3661  errmsg("parameter \"%s\" cannot be set locally in functions",
3662  name)));
3663  return 0;
3664  }
3665  }
3666 
3667  /*
3668  * Should we set reset/stacked values? (If so, the behavior is not
3669  * transactional.) This is done either when we get a default value from
3670  * the database's/user's/client's default settings or when we reset a
3671  * value to its default.
3672  */
3673  makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
3674  ((value != NULL) || source == PGC_S_DEFAULT);
3675 
3676  /*
3677  * Ignore attempted set if overridden by previously processed setting.
3678  * However, if changeVal is false then plow ahead anyway since we are
3679  * trying to find out if the value is potentially good, not actually use
3680  * it. Also keep going if makeDefault is true, since we may want to set
3681  * the reset/stacked values even if we can't set the variable itself.
3682  */
3683  if (record->source > source)
3684  {
3685  if (changeVal && !makeDefault)
3686  {
3687  elog(DEBUG3, "\"%s\": setting ignored because previous source is higher priority",
3688  name);
3689  return -1;
3690  }
3691  changeVal = false;
3692  }
3693 
3694  /*
3695  * Evaluate value and set variable.
3696  */
3697  switch (record->vartype)
3698  {
3699  case PGC_BOOL:
3700  {
3701  struct config_bool *conf = (struct config_bool *) record;
3702 
3703 #define newval (newval_union.boolval)
3704 
3705  if (value)
3706  {
3707  if (!parse_and_validate_value(record, name, value,
3708  source, elevel,
3709  &newval_union, &newextra))
3710  return 0;
3711  }
3712  else if (source == PGC_S_DEFAULT)
3713  {
3714  newval = conf->boot_val;
3715  if (!call_bool_check_hook(conf, &newval, &newextra,
3716  source, elevel))
3717  return 0;
3718  }
3719  else
3720  {
3721  newval = conf->reset_val;
3722  newextra = conf->reset_extra;
3723  source = conf->gen.reset_source;
3724  context = conf->gen.reset_scontext;
3725  srole = conf->gen.reset_srole;
3726  }
3727 
3728  if (prohibitValueChange)
3729  {
3730  /* Release newextra, unless it's reset_extra */
3731  if (newextra && !extra_field_used(&conf->gen, newextra))
3732  guc_free(newextra);
3733 
3734  if (*conf->variable != newval)
3735  {
3736  record->status |= GUC_PENDING_RESTART;
3737  ereport(elevel,
3738  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3739  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3740  name)));
3741  return 0;
3742  }
3743  record->status &= ~GUC_PENDING_RESTART;
3744  return -1;
3745  }
3746 
3747  if (changeVal)
3748  {
3749  /* Save old value to support transaction abort */
3750  if (!makeDefault)
3751  push_old_value(&conf->gen, action);
3752 
3753  if (conf->assign_hook)
3754  conf->assign_hook(newval, newextra);
3755  *conf->variable = newval;
3756  set_extra_field(&conf->gen, &conf->gen.extra,
3757  newextra);
3758  set_guc_source(&conf->gen, source);
3759  conf->gen.scontext = context;
3760  conf->gen.srole = srole;
3761  }
3762  if (makeDefault)
3763  {
3764  GucStack *stack;
3765 
3766  if (conf->gen.reset_source <= source)
3767  {
3768  conf->reset_val = newval;
3769  set_extra_field(&conf->gen, &conf->reset_extra,
3770  newextra);
3771  conf->gen.reset_source = source;
3772  conf->gen.reset_scontext = context;
3773  conf->gen.reset_srole = srole;
3774  }
3775  for (stack = conf->gen.stack; stack; stack = stack->prev)
3776  {
3777  if (stack->source <= source)
3778  {
3779  stack->prior.val.boolval = newval;
3780  set_extra_field(&conf->gen, &stack->prior.extra,
3781  newextra);
3782  stack->source = source;
3783  stack->scontext = context;
3784  stack->srole = srole;
3785  }
3786  }
3787  }
3788 
3789  /* Perhaps we didn't install newextra anywhere */
3790  if (newextra && !extra_field_used(&conf->gen, newextra))
3791  guc_free(newextra);
3792  break;
3793 
3794 #undef newval
3795  }
3796 
3797  case PGC_INT:
3798  {
3799  struct config_int *conf = (struct config_int *) record;
3800 
3801 #define newval (newval_union.intval)
3802 
3803  if (value)
3804  {
3805  if (!parse_and_validate_value(record, name, value,
3806  source, elevel,
3807  &newval_union, &newextra))
3808  return 0;
3809  }
3810  else if (source == PGC_S_DEFAULT)
3811  {
3812  newval = conf->boot_val;
3813  if (!call_int_check_hook(conf, &newval, &newextra,
3814  source, elevel))
3815  return 0;
3816  }
3817  else
3818  {
3819  newval = conf->reset_val;
3820  newextra = conf->reset_extra;
3821  source = conf->gen.reset_source;
3822  context = conf->gen.reset_scontext;
3823  srole = conf->gen.reset_srole;
3824  }
3825 
3826  if (prohibitValueChange)
3827  {
3828  /* Release newextra, unless it's reset_extra */
3829  if (newextra && !extra_field_used(&conf->gen, newextra))
3830  guc_free(newextra);
3831 
3832  if (*conf->variable != newval)
3833  {
3834  record->status |= GUC_PENDING_RESTART;
3835  ereport(elevel,
3836  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3837  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3838  name)));
3839  return 0;
3840  }
3841  record->status &= ~GUC_PENDING_RESTART;
3842  return -1;
3843  }
3844 
3845  if (changeVal)
3846  {
3847  /* Save old value to support transaction abort */
3848  if (!makeDefault)
3849  push_old_value(&conf->gen, action);
3850 
3851  if (conf->assign_hook)
3852  conf->assign_hook(newval, newextra);
3853  *conf->variable = newval;
3854  set_extra_field(&conf->gen, &conf->gen.extra,
3855  newextra);
3856  set_guc_source(&conf->gen, source);
3857  conf->gen.scontext = context;
3858  conf->gen.srole = srole;
3859  }
3860  if (makeDefault)
3861  {
3862  GucStack *stack;
3863 
3864  if (conf->gen.reset_source <= source)
3865  {
3866  conf->reset_val = newval;
3867  set_extra_field(&conf->gen, &conf->reset_extra,
3868  newextra);
3869  conf->gen.reset_source = source;
3870  conf->gen.reset_scontext = context;
3871  conf->gen.reset_srole = srole;
3872  }
3873  for (stack = conf->gen.stack; stack; stack = stack->prev)
3874  {
3875  if (stack->source <= source)
3876  {
3877  stack->prior.val.intval = newval;
3878  set_extra_field(&conf->gen, &stack->prior.extra,
3879  newextra);
3880  stack->source = source;
3881  stack->scontext = context;
3882  stack->srole = srole;
3883  }
3884  }
3885  }
3886 
3887  /* Perhaps we didn't install newextra anywhere */
3888  if (newextra && !extra_field_used(&conf->gen, newextra))
3889  guc_free(newextra);
3890  break;
3891 
3892 #undef newval
3893  }
3894 
3895  case PGC_REAL:
3896  {
3897  struct config_real *conf = (struct config_real *) record;
3898 
3899 #define newval (newval_union.realval)
3900 
3901  if (value)
3902  {
3903  if (!parse_and_validate_value(record, name, value,
3904  source, elevel,
3905  &newval_union, &newextra))
3906  return 0;
3907  }
3908  else if (source == PGC_S_DEFAULT)
3909  {
3910  newval = conf->boot_val;
3911  if (!call_real_check_hook(conf, &newval, &newextra,
3912  source, elevel))
3913  return 0;
3914  }
3915  else
3916  {
3917  newval = conf->reset_val;
3918  newextra = conf->reset_extra;
3919  source = conf->gen.reset_source;
3920  context = conf->gen.reset_scontext;
3921  srole = conf->gen.reset_srole;
3922  }
3923 
3924  if (prohibitValueChange)
3925  {
3926  /* Release newextra, unless it's reset_extra */
3927  if (newextra && !extra_field_used(&conf->gen, newextra))
3928  guc_free(newextra);
3929 
3930  if (*conf->variable != newval)
3931  {
3932  record->status |= GUC_PENDING_RESTART;
3933  ereport(elevel,
3934  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3935  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3936  name)));
3937  return 0;
3938  }
3939  record->status &= ~GUC_PENDING_RESTART;
3940  return -1;
3941  }
3942 
3943  if (changeVal)
3944  {
3945  /* Save old value to support transaction abort */
3946  if (!makeDefault)
3947  push_old_value(&conf->gen, action);
3948 
3949  if (conf->assign_hook)
3950  conf->assign_hook(newval, newextra);
3951  *conf->variable = newval;
3952  set_extra_field(&conf->gen, &conf->gen.extra,
3953  newextra);
3954  set_guc_source(&conf->gen, source);
3955  conf->gen.scontext = context;
3956  conf->gen.srole = srole;
3957  }
3958  if (makeDefault)
3959  {
3960  GucStack *stack;
3961 
3962  if (conf->gen.reset_source <= source)
3963  {
3964  conf->reset_val = newval;
3965  set_extra_field(&conf->gen, &conf->reset_extra,
3966  newextra);
3967  conf->gen.reset_source = source;
3968  conf->gen.reset_scontext = context;
3969  conf->gen.reset_srole = srole;
3970  }
3971  for (stack = conf->gen.stack; stack; stack = stack->prev)
3972  {
3973  if (stack->source <= source)
3974  {
3975  stack->prior.val.realval = newval;
3976  set_extra_field(&conf->gen, &stack->prior.extra,
3977  newextra);
3978  stack->source = source;
3979  stack->scontext = context;
3980  stack->srole = srole;
3981  }
3982  }
3983  }
3984 
3985  /* Perhaps we didn't install newextra anywhere */
3986  if (newextra && !extra_field_used(&conf->gen, newextra))
3987  guc_free(newextra);
3988  break;
3989 
3990 #undef newval
3991  }
3992 
3993  case PGC_STRING:
3994  {
3995  struct config_string *conf = (struct config_string *) record;
3996 
3997 #define newval (newval_union.stringval)
3998 
3999  if (value)
4000  {
4001  if (!parse_and_validate_value(record, name, value,
4002  source, elevel,
4003  &newval_union, &newextra))
4004  return 0;
4005  }
4006  else if (source == PGC_S_DEFAULT)
4007  {
4008  /* non-NULL boot_val must always get strdup'd */
4009  if (conf->boot_val != NULL)
4010  {
4011  newval = guc_strdup(elevel, conf->boot_val);
4012  if (newval == NULL)
4013  return 0;
4014  }
4015  else
4016  newval = NULL;
4017 
4018  if (!call_string_check_hook(conf, &newval, &newextra,
4019  source, elevel))
4020  {
4021  guc_free(newval);
4022  return 0;
4023  }
4024  }
4025  else
4026  {
4027  /*
4028  * strdup not needed, since reset_val is already under
4029  * guc.c's control
4030  */
4031  newval = conf->reset_val;
4032  newextra = conf->reset_extra;
4033  source = conf->gen.reset_source;
4034  context = conf->gen.reset_scontext;
4035  srole = conf->gen.reset_srole;
4036  }
4037 
4038  if (prohibitValueChange)
4039  {
4040  bool newval_different;
4041 
4042  /* newval shouldn't be NULL, so we're a bit sloppy here */
4043  newval_different = (*conf->variable == NULL ||
4044  newval == NULL ||
4045  strcmp(*conf->variable, newval) != 0);
4046 
4047  /* Release newval, unless it's reset_val */
4048  if (newval && !string_field_used(conf, newval))
4049  guc_free(newval);
4050  /* Release newextra, unless it's reset_extra */
4051  if (newextra && !extra_field_used(&conf->gen, newextra))
4052  guc_free(newextra);
4053 
4054  if (newval_different)
4055  {
4056  record->status |= GUC_PENDING_RESTART;
4057  ereport(elevel,
4058  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4059  errmsg("parameter \"%s\" cannot be changed without restarting the server",
4060  name)));
4061  return 0;
4062  }
4063  record->status &= ~GUC_PENDING_RESTART;
4064  return -1;
4065  }
4066 
4067  if (changeVal)
4068  {
4069  /* Save old value to support transaction abort */
4070  if (!makeDefault)
4071  push_old_value(&conf->gen, action);
4072 
4073  if (conf->assign_hook)
4074  conf->assign_hook(newval, newextra);
4075  set_string_field(conf, conf->variable, newval);
4076  set_extra_field(&conf->gen, &conf->gen.extra,
4077  newextra);
4078  set_guc_source(&conf->gen, source);
4079  conf->gen.scontext = context;
4080  conf->gen.srole = srole;
4081  }
4082 
4083  if (makeDefault)
4084  {
4085  GucStack *stack;
4086 
4087  if (conf->gen.reset_source <= source)
4088  {
4089  set_string_field(conf, &conf->reset_val, newval);
4090  set_extra_field(&conf->gen, &conf->reset_extra,
4091  newextra);
4092  conf->gen.reset_source = source;
4093  conf->gen.reset_scontext = context;
4094  conf->gen.reset_srole = srole;
4095  }
4096  for (stack = conf->gen.stack; stack; stack = stack->prev)
4097  {
4098  if (stack->source <= source)
4099  {
4100  set_string_field(conf, &stack->prior.val.stringval,
4101  newval);
4102  set_extra_field(&conf->gen, &stack->prior.extra,
4103  newextra);
4104  stack->source = source;
4105  stack->scontext = context;
4106  stack->srole = srole;
4107  }
4108  }
4109  }
4110 
4111  /* Perhaps we didn't install newval anywhere */
4112  if (newval && !string_field_used(conf, newval))
4113  guc_free(newval);
4114  /* Perhaps we didn't install newextra anywhere */
4115  if (newextra && !extra_field_used(&conf->gen, newextra))
4116  guc_free(newextra);
4117  break;
4118 
4119 #undef newval
4120  }
4121 
4122  case PGC_ENUM:
4123  {
4124  struct config_enum *conf = (struct config_enum *) record;
4125 
4126 #define newval (newval_union.enumval)
4127 
4128  if (value)
4129  {
4130  if (!parse_and_validate_value(record, name, value,
4131  source, elevel,
4132  &newval_union, &newextra))
4133  return 0;
4134  }
4135  else if (source == PGC_S_DEFAULT)
4136  {
4137  newval = conf->boot_val;
4138  if (!call_enum_check_hook(conf, &newval, &newextra,
4139  source, elevel))
4140  return 0;
4141  }
4142  else
4143  {
4144  newval = conf->reset_val;
4145  newextra = conf->reset_extra;
4146  source = conf->gen.reset_source;
4147  context = conf->gen.reset_scontext;
4148  srole = conf->gen.reset_srole;
4149  }
4150 
4151  if (prohibitValueChange)
4152  {
4153  /* Release newextra, unless it's reset_extra */
4154  if (newextra && !extra_field_used(&conf->gen, newextra))
4155  guc_free(newextra);
4156 
4157  if (*conf->variable != newval)
4158  {
4159  record->status |= GUC_PENDING_RESTART;
4160  ereport(elevel,
4161  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4162  errmsg("parameter \"%s\" cannot be changed without restarting the server",
4163  name)));
4164  return 0;
4165  }
4166  record->status &= ~GUC_PENDING_RESTART;
4167  return -1;
4168  }
4169 
4170  if (changeVal)
4171  {
4172  /* Save old value to support transaction abort */
4173  if (!makeDefault)
4174  push_old_value(&conf->gen, action);
4175 
4176  if (conf->assign_hook)
4177  conf->assign_hook(newval, newextra);
4178  *conf->variable = newval;
4179  set_extra_field(&conf->gen, &conf->gen.extra,
4180  newextra);
4181  set_guc_source(&conf->gen, source);
4182  conf->gen.scontext = context;
4183  conf->gen.srole = srole;
4184  }
4185  if (makeDefault)
4186  {
4187  GucStack *stack;
4188 
4189  if (conf->gen.reset_source <= source)
4190  {
4191  conf->reset_val = newval;
4192  set_extra_field(&conf->gen, &conf->reset_extra,
4193  newextra);
4194  conf->gen.reset_source = source;
4195  conf->gen.reset_scontext = context;
4196  conf->gen.reset_srole = srole;
4197  }
4198  for (stack = conf->gen.stack; stack; stack = stack->prev)
4199  {
4200  if (stack->source <= source)
4201  {
4202  stack->prior.val.enumval = newval;
4203  set_extra_field(&conf->gen, &stack->prior.extra,
4204  newextra);
4205  stack->source = source;
4206  stack->scontext = context;
4207  stack->srole = srole;
4208  }
4209  }
4210  }
4211 
4212  /* Perhaps we didn't install newextra anywhere */
4213  if (newextra && !extra_field_used(&conf->gen, newextra))
4214  guc_free(newextra);
4215  break;
4216 
4217 #undef newval
4218  }
4219  }
4220 
4221  if (changeVal && (record->flags & GUC_REPORT) &&
4222  !(record->status & GUC_NEEDS_REPORT))
4223  {
4224  record->status |= GUC_NEEDS_REPORT;
4226  }
4227 
4228  return changeVal ? 1 : -1;
4229 }
4230 
4231 
4232 /*
4233  * Retrieve a config_handle for the given name, suitable for calling
4234  * set_config_with_handle(). Only return handle to permanent GUC.
4235  */
4236 config_handle *
4238 {
4239  struct config_generic *gen = find_option(name, false, false, 0);
4240 
4241  if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
4242  return gen;
4243 
4244  return NULL;
4245 }
4246 
4247 
4248 /*
4249  * Set the fields for source file and line number the setting came from.
4250  */
4251 static void
4253 {
4254  struct config_generic *record;
4255  int elevel;
4256 
4257  /*
4258  * To avoid cluttering the log, only the postmaster bleats loudly about
4259  * problems with the config file.
4260  */
4261  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
4262 
4263  record = find_option(name, true, false, elevel);
4264  /* should not happen */
4265  if (record == NULL)
4266  return;
4267 
4268  sourcefile = guc_strdup(elevel, sourcefile);
4269  guc_free(record->sourcefile);
4270  record->sourcefile = sourcefile;
4271  record->sourceline = sourceline;
4272 }
4273 
4274 /*
4275  * Set a config option to the given value.
4276  *
4277  * See also set_config_option; this is just the wrapper to be called from
4278  * outside GUC. (This function should be used when possible, because its API
4279  * is more stable than set_config_option's.)
4280  *
4281  * Note: there is no support here for setting source file/line, as it
4282  * is currently not needed.
4283  */
4284 void
4285 SetConfigOption(const char *name, const char *value,
4287 {
4289  GUC_ACTION_SET, true, 0, false);
4290 }
4291 
4292 
4293 
4294 /*
4295  * Fetch the current value of the option `name', as a string.
4296  *
4297  * If the option doesn't exist, return NULL if missing_ok is true,
4298  * otherwise throw an ereport and don't return.
4299  *
4300  * If restrict_privileged is true, we also enforce that only superusers and
4301  * members of the pg_read_all_settings role can see GUC_SUPERUSER_ONLY
4302  * variables. This should only be passed as true in user-driven calls.
4303  *
4304  * The string is *not* allocated for modification and is really only
4305  * valid until the next call to configuration related functions.
4306  */
4307 const char *
4308 GetConfigOption(const char *name, bool missing_ok, bool restrict_privileged)
4309 {
4310  struct config_generic *record;
4311  static char buffer[256];
4312 
4313  record = find_option(name, false, missing_ok, ERROR);
4314  if (record == NULL)
4315  return NULL;
4316  if (restrict_privileged &&
4317  !ConfigOptionIsVisible(record))
4318  ereport(ERROR,
4319  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4320  errmsg("permission denied to examine \"%s\"", name),
4321  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4322  "pg_read_all_settings")));
4323 
4324  switch (record->vartype)
4325  {
4326  case PGC_BOOL:
4327  return *((struct config_bool *) record)->variable ? "on" : "off";
4328 
4329  case PGC_INT:
4330  snprintf(buffer, sizeof(buffer), "%d",
4331  *((struct config_int *) record)->variable);
4332  return buffer;
4333 
4334  case PGC_REAL:
4335  snprintf(buffer, sizeof(buffer), "%g",
4336  *((struct config_real *) record)->variable);
4337  return buffer;
4338 
4339  case PGC_STRING:
4340  return *((struct config_string *) record)->variable ?
4341  *((struct config_string *) record)->variable : "";
4342 
4343  case PGC_ENUM:
4344  return config_enum_lookup_by_value((struct config_enum *) record,
4345  *((struct config_enum *) record)->variable);
4346  }
4347  return NULL;
4348 }
4349 
4350 /*
4351  * Get the RESET value associated with the given option.
4352  *
4353  * Note: this is not re-entrant, due to use of static result buffer;
4354  * not to mention that a string variable could have its reset_val changed.
4355  * Beware of assuming the result value is good for very long.
4356  */
4357 const char *
4359 {
4360  struct config_generic *record;
4361  static char buffer[256];
4362 
4363  record = find_option(name, false, false, ERROR);
4364  Assert(record != NULL);
4365  if (!ConfigOptionIsVisible(record))
4366  ereport(ERROR,
4367  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4368  errmsg("permission denied to examine \"%s\"", name),
4369  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4370  "pg_read_all_settings")));
4371 
4372  switch (record->vartype)
4373  {
4374  case PGC_BOOL:
4375  return ((struct config_bool *) record)->reset_val ? "on" : "off";
4376 
4377  case PGC_INT:
4378  snprintf(buffer, sizeof(buffer), "%d",
4379  ((struct config_int *) record)->reset_val);
4380  return buffer;
4381 
4382  case PGC_REAL:
4383  snprintf(buffer, sizeof(buffer), "%g",
4384  ((struct config_real *) record)->reset_val);
4385  return buffer;
4386 
4387  case PGC_STRING:
4388  return ((struct config_string *) record)->reset_val ?
4389  ((struct config_string *) record)->reset_val : "";
4390 
4391  case PGC_ENUM:
4392  return config_enum_lookup_by_value((struct config_enum *) record,
4393  ((struct config_enum *) record)->reset_val);
4394  }
4395  return NULL;
4396 }
4397 
4398 /*
4399  * Get the GUC flags associated with the given option.
4400  *
4401  * If the option doesn't exist, return 0 if missing_ok is true,
4402  * otherwise throw an ereport and don't return.
4403  */
4404 int
4405 GetConfigOptionFlags(const char *name, bool missing_ok)
4406 {
4407  struct config_generic *record;
4408 
4409  record = find_option(name, false, missing_ok, ERROR);
4410  if (record == NULL)
4411  return 0;
4412  return record->flags;
4413 }
4414 
4415 
4416 /*
4417  * Write updated configuration parameter values into a temporary file.
4418  * This function traverses the list of parameters and quotes the string
4419  * values before writing them.
4420  */
4421 static void
4423 {
4425  ConfigVariable *item;
4426 
4427  initStringInfo(&buf);
4428 
4429  /* Emit file header containing warning comment */
4430  appendStringInfoString(&buf, "# Do not edit this file manually!\n");
4431  appendStringInfoString(&buf, "# It will be overwritten by the ALTER SYSTEM command.\n");
4432 
4433  errno = 0;
4434  if (write(fd, buf.data, buf.len) != buf.len)
4435  {
4436  /* if write didn't set errno, assume problem is no disk space */
4437  if (errno == 0)
4438  errno = ENOSPC;
4439  ereport(ERROR,
4441  errmsg("could not write to file \"%s\": %m", filename)));
4442  }
4443 
4444  /* Emit each parameter, properly quoting the value */
4445  for (item = head; item != NULL; item = item->next)
4446  {
4447  char *escaped;
4448 
4449  resetStringInfo(&buf);
4450 
4451  appendStringInfoString(&buf, item->name);
4452  appendStringInfoString(&buf, " = '");
4453 
4454  escaped = escape_single_quotes_ascii(item->value);
4455  if (!escaped)
4456  ereport(ERROR,
4457  (errcode(ERRCODE_OUT_OF_MEMORY),
4458  errmsg("out of memory")));
4459  appendStringInfoString(&buf, escaped);
4460  free(escaped);
4461 
4462  appendStringInfoString(&buf, "'\n");
4463 
4464  errno = 0;
4465  if (write(fd, buf.data, buf.len) != buf.len)
4466  {
4467  /* if write didn't set errno, assume problem is no disk space */
4468  if (errno == 0)
4469  errno = ENOSPC;
4470  ereport(ERROR,
4472  errmsg("could not write to file \"%s\": %m", filename)));
4473  }
4474  }
4475 
4476  /* fsync before considering the write to be successful */
4477  if (pg_fsync(fd) != 0)
4478  ereport(ERROR,
4480  errmsg("could not fsync file \"%s\": %m", filename)));
4481 
4482  pfree(buf.data);
4483 }
4484 
4485 /*
4486  * Update the given list of configuration parameters, adding, replacing
4487  * or deleting the entry for item "name" (delete if "value" == NULL).
4488  */
4489 static void
4491  const char *name, const char *value)
4492 {
4493  ConfigVariable *item,
4494  *next,
4495  *prev = NULL;
4496 
4497  /*
4498  * Remove any existing match(es) for "name". Normally there'd be at most
4499  * one, but if external tools have modified the config file, there could
4500  * be more.
4501  */
4502  for (item = *head_p; item != NULL; item = next)
4503  {
4504  next = item->next;
4505  if (guc_name_compare(item->name, name) == 0)
4506  {
4507  /* found a match, delete it */
4508  if (prev)
4509  prev->next = next;
4510  else
4511  *head_p = next;
4512  if (next == NULL)
4513  *tail_p = prev;
4514 
4515  pfree(item->name);
4516  pfree(item->value);
4517  pfree(item->filename);
4518  pfree(item);
4519  }
4520  else
4521  prev = item;
4522  }
4523 
4524  /* Done if we're trying to delete it */
4525  if (value == NULL)
4526  return;
4527 
4528  /* OK, append a new entry */
4529  item = palloc(sizeof *item);
4530  item->name = pstrdup(name);
4531  item->value = pstrdup(value);
4532  item->errmsg = NULL;
4533  item->filename = pstrdup(""); /* new item has no location */
4534  item->sourceline = 0;
4535  item->ignore = false;
4536  item->applied = false;
4537  item->next = NULL;
4538 
4539  if (*head_p == NULL)
4540  *head_p = item;
4541  else
4542  (*tail_p)->next = item;
4543  *tail_p = item;
4544 }
4545 
4546 
4547 /*
4548  * Execute ALTER SYSTEM statement.
4549  *
4550  * Read the old PG_AUTOCONF_FILENAME file, merge in the new variable value,
4551  * and write out an updated file. If the command is ALTER SYSTEM RESET ALL,
4552  * we can skip reading the old file and just write an empty file.
4553  *
4554  * An LWLock is used to serialize updates of the configuration file.
4555  *
4556  * In case of an error, we leave the original automatic
4557  * configuration file (PG_AUTOCONF_FILENAME) intact.
4558  */
4559 void
4561 {
4562  char *name;
4563  char *value;
4564  bool resetall = false;
4565  ConfigVariable *head = NULL;
4566  ConfigVariable *tail = NULL;
4567  volatile int Tmpfd;
4568  char AutoConfFileName[MAXPGPATH];
4569  char AutoConfTmpFileName[MAXPGPATH];
4570 
4571  /*
4572  * Extract statement arguments
4573  */
4574  name = altersysstmt->setstmt->name;
4575 
4576  if (!AllowAlterSystem)
4577  ereport(ERROR,
4578  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4579  errmsg("ALTER SYSTEM is not allowed in this environment")));
4580 
4581  switch (altersysstmt->setstmt->kind)
4582  {
4583  case VAR_SET_VALUE:
4584  value = ExtractSetVariableArgs(altersysstmt->setstmt);
4585  break;
4586 
4587  case VAR_SET_DEFAULT:
4588  case VAR_RESET:
4589  value = NULL;
4590  break;
4591 
4592  case VAR_RESET_ALL:
4593  value = NULL;
4594  resetall = true;
4595  break;
4596 
4597  default:
4598  elog(ERROR, "unrecognized alter system stmt type: %d",
4599  altersysstmt->setstmt->kind);
4600  break;
4601  }
4602 
4603  /*
4604  * Check permission to run ALTER SYSTEM on the target variable
4605  */
4606  if (!superuser())
4607  {
4608  if (resetall)
4609  ereport(ERROR,
4610  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4611  errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4612  else
4613  {
4614  AclResult aclresult;
4615 
4616  aclresult = pg_parameter_aclcheck(name, GetUserId(),
4618  if (aclresult != ACLCHECK_OK)
4619  ereport(ERROR,
4620  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4621  errmsg("permission denied to set parameter \"%s\"",
4622  name)));
4623  }
4624  }
4625 
4626  /*
4627  * Unless it's RESET_ALL, validate the target variable and value
4628  */
4629  if (!resetall)
4630  {
4631  struct config_generic *record;
4632 
4633  /* We don't want to create a placeholder if there's not one already */
4634  record = find_option(name, false, true, DEBUG5);
4635  if (record != NULL)
4636  {
4637  /*
4638  * Don't allow parameters that can't be set in configuration files
4639  * to be set in PG_AUTOCONF_FILENAME file.
4640  */
4641  if ((record->context == PGC_INTERNAL) ||
4642  (record->flags & GUC_DISALLOW_IN_FILE) ||
4643  (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
4644  ereport(ERROR,
4645  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4646  errmsg("parameter \"%s\" cannot be changed",
4647  name)));
4648 
4649  /*
4650  * If a value is specified, verify that it's sane.
4651  */
4652  if (value)
4653  {
4654  union config_var_val newval;
4655  void *newextra = NULL;
4656 
4657  if (!parse_and_validate_value(record, name, value,
4658  PGC_S_FILE, ERROR,
4659  &newval, &newextra))
4660  ereport(ERROR,
4661  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4662  errmsg("invalid value for parameter \"%s\": \"%s\"",
4663  name, value)));
4664 
4665  if (record->vartype == PGC_STRING && newval.stringval != NULL)
4666  guc_free(newval.stringval);
4667  guc_free(newextra);
4668  }
4669  }
4670  else
4671  {
4672  /*
4673  * Variable not known; check we'd be allowed to create it. (We
4674  * cannot validate the value, but that's fine. A non-core GUC in
4675  * the config file cannot cause postmaster start to fail, so we
4676  * don't have to be too tense about possibly installing a bad
4677  * value.)
4678  */
4679  (void) assignable_custom_variable_name(name, false, ERROR);
4680  }
4681 
4682  /*
4683  * We must also reject values containing newlines, because the grammar
4684  * for config files doesn't support embedded newlines in string
4685  * literals.
4686  */
4687  if (value && strchr(value, '\n'))
4688  ereport(ERROR,
4689  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4690  errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4691  }
4692 
4693  /*
4694  * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4695  * the data directory, so we can reference them by simple relative paths.
4696  */
4697  snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4699  snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4700  AutoConfFileName,
4701  "tmp");
4702 
4703  /*
4704  * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4705  * time. Use AutoFileLock to ensure that. We must hold the lock while
4706  * reading the old file contents.
4707  */
4708  LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4709 
4710  /*
4711  * If we're going to reset everything, then no need to open or parse the
4712  * old file. We'll just write out an empty list.
4713  */
4714  if (!resetall)
4715  {
4716  struct stat st;
4717 
4718  if (stat(AutoConfFileName, &st) == 0)
4719  {
4720  /* open old file PG_AUTOCONF_FILENAME */
4721  FILE *infile;
4722 
4723  infile = AllocateFile(AutoConfFileName, "r");
4724  if (infile == NULL)
4725  ereport(ERROR,
4727  errmsg("could not open file \"%s\": %m",
4728  AutoConfFileName)));
4729 
4730  /* parse it */
4731  if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4732  LOG, &head, &tail))
4733  ereport(ERROR,
4734  (errcode(ERRCODE_CONFIG_FILE_ERROR),
4735  errmsg("could not parse contents of file \"%s\"",
4736  AutoConfFileName)));
4737 
4738  FreeFile(infile);
4739  }
4740 
4741  /*
4742  * Now, replace any existing entry with the new value, or add it if
4743  * not present.
4744  */
4745  replace_auto_config_value(&head, &tail, name, value);
4746  }
4747 
4748  /*
4749  * Invoke the post-alter hook for setting this GUC variable. GUCs
4750  * typically do not have corresponding entries in pg_parameter_acl, so we
4751  * call the hook using the name rather than a potentially-non-existent
4752  * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4753  * context can be distinguished from others. (Note that "name" will be
4754  * NULL in the RESET ALL case.)
4755  *
4756  * We do this here rather than at the end, because ALTER SYSTEM is not
4757  * transactional. If the hook aborts our transaction, it will be cleaner
4758  * to do so before we touch any files.
4759  */
4760  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4762  altersysstmt->setstmt->kind,
4763  false);
4764 
4765  /*
4766  * To ensure crash safety, first write the new file data to a temp file,
4767  * then atomically rename it into place.
4768  *
4769  * If there is a temp file left over due to a previous crash, it's okay to
4770  * truncate and reuse it.
4771  */
4772  Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4773  O_CREAT | O_RDWR | O_TRUNC);
4774  if (Tmpfd < 0)
4775  ereport(ERROR,
4777  errmsg("could not open file \"%s\": %m",
4778  AutoConfTmpFileName)));
4779 
4780  /*
4781  * Use a TRY block to clean up the file if we fail. Since we need a TRY
4782  * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4783  */
4784  PG_TRY();
4785  {
4786  /* Write and sync the new contents to the temporary file */
4787  write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4788 
4789  /* Close before renaming; may be required on some platforms */
4790  close(Tmpfd);
4791  Tmpfd = -1;
4792 
4793  /*
4794  * As the rename is atomic operation, if any problem occurs after this
4795  * at worst it can lose the parameters set by last ALTER SYSTEM
4796  * command.
4797  */
4798  durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4799  }
4800  PG_CATCH();
4801  {
4802  /* Close file first, else unlink might fail on some platforms */
4803  if (Tmpfd >= 0)
4804  close(Tmpfd);
4805 
4806  /* Unlink, but ignore any error */
4807  (void) unlink(AutoConfTmpFileName);
4808 
4809  PG_RE_THROW();
4810  }
4811  PG_END_TRY();
4812 
4813  FreeConfigVariables(head);
4814 
4815  LWLockRelease(AutoFileLock);
4816 }
4817 
4818 
4819 /*
4820  * Common code for DefineCustomXXXVariable subroutines: allocate the
4821  * new variable's config struct and fill in generic fields.
4822  */
4823 static struct config_generic *
4825  const char *short_desc,
4826  const char *long_desc,
4828  int flags,
4829  enum config_type type,
4830  size_t sz)
4831 {
4832  struct config_generic *gen;
4833 
4834  /*
4835  * Only allow custom PGC_POSTMASTER variables to be created during shared
4836  * library preload; any later than that, we can't ensure that the value
4837  * doesn't change after startup. This is a fatal elog if it happens; just
4838  * erroring out isn't safe because we don't know what the calling loadable
4839  * module might already have hooked into.
4840  */
4841  if (context == PGC_POSTMASTER &&
4843  elog(FATAL, "cannot create PGC_POSTMASTER variables after startup");
4844 
4845  /*
4846  * We can't support custom GUC_LIST_QUOTE variables, because the wrong
4847  * things would happen if such a variable were set or pg_dump'd when the
4848  * defining extension isn't loaded. Again, treat this as fatal because
4849  * the loadable module may be partly initialized already.
4850  */
4851  if (flags & GUC_LIST_QUOTE)
4852  elog(FATAL, "extensions cannot define GUC_LIST_QUOTE variables");
4853 
4854  /*
4855  * Before pljava commit 398f3b876ed402bdaec8bc804f29e2be95c75139
4856  * (2015-12-15), two of that module's PGC_USERSET variables facilitated
4857  * trivial escalation to superuser privileges. Restrict the variables to
4858  * protect sites that have yet to upgrade pljava.
4859  */
4860  if (context == PGC_USERSET &&
4861  (strcmp(name, "pljava.classpath") == 0 ||
4862  strcmp(name, "pljava.vmoptions") == 0))
4863  context = PGC_SUSET;
4864 
4865  gen = (struct config_generic *) guc_malloc(ERROR, sz);
4866  memset(gen, 0, sz);
4867 
4868  gen->name = guc_strdup(ERROR, name);
4869  gen->context = context;
4870  gen->group = CUSTOM_OPTIONS;
4871  gen->short_desc = short_desc;
4872  gen->long_desc = long_desc;
4873  gen->flags = flags;
4874  gen->vartype = type;
4875 
4876  return gen;
4877 }
4878 
4879 /*
4880  * Common code for DefineCustomXXXVariable subroutines: insert the new
4881  * variable into the GUC variable hash, replacing any placeholder.
4882  */
4883 static void
4885 {
4886  const char *name = variable->name;
4887  GUCHashEntry *hentry;
4888  struct config_string *pHolder;
4889 
4890  /* Check mapping between initial and default value */
4891  Assert(check_GUC_init(variable));
4892 
4893  /*
4894  * See if there's a placeholder by the same name.
4895  */
4896  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
4897  &name,
4898  HASH_FIND,
4899  NULL);
4900  if (hentry == NULL)
4901  {
4902  /*
4903  * No placeholder to replace, so we can just add it ... but first,
4904  * make sure it's initialized to its default value.
4905  */
4908  return;
4909  }
4910 
4911  /*
4912  * This better be a placeholder
4913  */
4914  if ((hentry->gucvar->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
4915  ereport(ERROR,
4916  (errcode(ERRCODE_INTERNAL_ERROR),
4917  errmsg("attempt to redefine parameter \"%s\"", name)));
4918 
4919  Assert(hentry->gucvar->vartype == PGC_STRING);
4920  pHolder = (struct config_string *) hentry->gucvar;
4921 
4922  /*
4923  * First, set the variable to its default value. We must do this even
4924  * though we intend to immediately apply a new value, since it's possible
4925  * that the new value is invalid.
4926  */
4928 
4929  /*
4930  * Replace the placeholder in the hash table. We aren't changing the name
4931  * (at least up to case-folding), so the hash value is unchanged.
4932  */
4933  hentry->gucname = name;
4934  hentry->gucvar = variable;
4935 
4936  /*
4937  * Remove the placeholder from any lists it's in, too.
4938  */
4939  RemoveGUCFromLists(&pHolder->gen);
4940 
4941  /*
4942  * Assign the string value(s) stored in the placeholder to the real
4943  * variable. Essentially, we need to duplicate all the active and stacked
4944  * values, but with appropriate validation and datatype adjustment.
4945  *
4946  * If an assignment fails, we report a WARNING and keep going. We don't
4947  * want to throw ERROR for bad values, because it'd bollix the add-on
4948  * module that's presumably halfway through getting loaded. In such cases
4949  * the default or previous state will become active instead.
4950  */
4951 
4952  /* First, apply the reset value if any */
4953  if (pHolder->reset_val)
4954  (void) set_config_option_ext(name, pHolder->reset_val,
4955  pHolder->gen.reset_scontext,
4956  pHolder->gen.reset_source,
4957  pHolder->gen.reset_srole,
4958  GUC_ACTION_SET, true, WARNING, false);
4959  /* That should not have resulted in stacking anything */
4960  Assert(variable->stack == NULL);
4961 
4962  /* Now, apply current and stacked values, in the order they were stacked */
4963  reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
4964  *(pHolder->variable),
4965  pHolder->gen.scontext, pHolder->gen.source,
4966  pHolder->gen.srole);
4967 
4968  /* Also copy over any saved source-location information */
4969  if (pHolder->gen.sourcefile)
4971  pHolder->gen.sourceline);
4972 
4973  /*
4974  * Free up as much as we conveniently can of the placeholder structure.
4975  * (This neglects any stack items, so it's possible for some memory to be
4976  * leaked. Since this can only happen once per session per variable, it
4977  * doesn't seem worth spending much code on.)
4978  */
4979  set_string_field(pHolder, pHolder->variable, NULL);
4980  set_string_field(pHolder, &pHolder->reset_val, NULL);
4981 
4982  guc_free(pHolder);
4983 }
4984 
4985 /*
4986  * Recursive subroutine for define_custom_variable: reapply non-reset values
4987  *
4988  * We recurse so that the values are applied in the same order as originally.
4989  * At each recursion level, apply the upper-level value (passed in) in the
4990  * fashion implied by the stack entry.
4991  */
4992 static void
4994  struct config_string *pHolder,
4995  GucStack *stack,
4996  const char *curvalue,
4997  GucContext curscontext, GucSource cursource,
4998  Oid cursrole)
4999 {
5000  const char *name = variable->name;
5001  GucStack *oldvarstack = variable->stack;
5002 
5003  if (stack != NULL)
5004  {
5005  /* First, recurse, so that stack items are processed bottom to top */
5006  reapply_stacked_values(variable, pHolder, stack->prev,
5007  stack->prior.val.stringval,
5008  stack->scontext, stack->source, stack->srole);
5009 
5010  /* See how to apply the passed-in value */
5011  switch (stack->state)
5012  {
5013  case GUC_SAVE:
5014  (void) set_config_option_ext(name, curvalue,
5015  curscontext, cursource, cursrole,
5016  GUC_ACTION_SAVE, true,
5017  WARNING, false);
5018  break;
5019 
5020  case GUC_SET:
5021  (void) set_config_option_ext(name, curvalue,
5022  curscontext, cursource, cursrole,
5023  GUC_ACTION_SET, true,
5024  WARNING, false);
5025  break;
5026 
5027  case GUC_LOCAL:
5028  (void) set_config_option_ext(name, curvalue,
5029  curscontext, cursource, cursrole,
5030  GUC_ACTION_LOCAL, true,
5031  WARNING, false);
5032  break;
5033 
5034  case GUC_SET_LOCAL:
5035  /* first, apply the masked value as SET */
5037  stack->masked_scontext,
5038  PGC_S_SESSION,
5039  stack->masked_srole,
5040  GUC_ACTION_SET, true,
5041  WARNING, false);
5042  /* then apply the current value as LOCAL */
5043  (void) set_config_option_ext(name, curvalue,
5044  curscontext, cursource, cursrole,
5045  GUC_ACTION_LOCAL, true,
5046  WARNING, false);
5047  break;
5048  }
5049 
5050  /* If we successfully made a stack entry, adjust its nest level */
5051  if (variable->stack != oldvarstack)
5052  variable->stack->nest_level = stack->nest_level;
5053  }
5054  else
5055  {
5056  /*
5057  * We are at the end of the stack. If the active/previous value is
5058  * different from the reset value, it must represent a previously
5059  * committed session value. Apply it, and then drop the stack entry
5060  * that set_config_option will have created under the impression that
5061  * this is to be just a transactional assignment. (We leak the stack
5062  * entry.)
5063  */
5064  if (curvalue != pHolder->reset_val ||
5065  curscontext != pHolder->gen.reset_scontext ||
5066  cursource != pHolder->gen.reset_source ||
5067  cursrole != pHolder->gen.reset_srole)
5068  {
5069  (void) set_config_option_ext(name, curvalue,
5070  curscontext, cursource, cursrole,
5071  GUC_ACTION_SET, true, WARNING, false);
5072  if (variable->stack != NULL)
5073  {
5074  slist_delete(&guc_stack_list, &variable->stack_link);
5075  variable->stack = NULL;
5076  }
5077  }
5078  }
5079 }
5080 
5081 /*
5082  * Functions for extensions to call to define their custom GUC variables.
5083  */
5084 void
5086  const char *short_desc,
5087  const char *long_desc,
5088  bool *valueAddr,
5089  bool bootValue,
5091  int flags,
5095 {
5096  struct config_bool *var;
5097 
5098  var = (struct config_bool *)
5099  init_custom_variable(name, short_desc, long_desc, context, flags,
5100  PGC_BOOL, sizeof(struct config_bool));
5101  var->variable = valueAddr;
5102  var->boot_val = bootValue;
5103  var->reset_val = bootValue;
5104  var->check_hook = check_hook;
5105  var->assign_hook = assign_hook;
5106  var->show_hook = show_hook;
5107  define_custom_variable(&var->gen);
5108 }
5109 
5110 void
5112  const char *short_desc,
5113  const char *long_desc,
5114  int *valueAddr,
5115  int bootValue,
5116  int minValue,
5117  int maxValue,
5119  int flags,
5123 {
5124  struct config_int *var;
5125 
5126  var = (struct config_int *)
5127  init_custom_variable(name, short_desc, long_desc, context, flags,
5128  PGC_INT, sizeof(struct config_int));
5129  var->variable = valueAddr;
5130  var->boot_val = bootValue;
5131  var->reset_val = bootValue;
5132  var->min = minValue;
5133  var->max = maxValue;
5134  var->check_hook = check_hook;
5135  var->assign_hook = assign_hook;
5136  var->show_hook = show_hook;
5137  define_custom_variable(&var->gen);
5138 }
5139 
5140 void
5142  const char *short_desc,
5143  const char *long_desc,
5144  double *valueAddr,
5145  double bootValue,
5146  double minValue,
5147  double maxValue,
5149  int flags,
5153 {
5154  struct config_real *var;
5155 
5156  var = (struct config_real *)
5157  init_custom_variable(name, short_desc, long_desc, context, flags,
5158  PGC_REAL, sizeof(struct config_real));
5159  var->variable = valueAddr;
5160  var->boot_val = bootValue;
5161  var->reset_val = bootValue;
5162  var->min = minValue;
5163  var->max = maxValue;
5164  var->check_hook = check_hook;
5165  var->assign_hook = assign_hook;
5166  var->show_hook = show_hook;
5167  define_custom_variable(&var->gen);
5168 }
5169 
5170 void
5172  const char *short_desc,
5173  const char *long_desc,
5174  char **valueAddr,
5175  const char *bootValue,
5177  int flags,
5181 {
5182  struct config_string *var;
5183 
5184  var = (struct config_string *)
5185  init_custom_variable(name, short_desc, long_desc, context, flags,
5186  PGC_STRING, sizeof(struct config_string));
5187  var->variable = valueAddr;
5188  var->boot_val = bootValue;
5189  var->check_hook = check_hook;
5190  var->assign_hook = assign_hook;
5191  var->show_hook = show_hook;
5192  define_custom_variable(&var->gen);
5193 }
5194 
5195 void
5197  const char *short_desc,
5198  const char *long_desc,
5199  int *valueAddr,
5200  int bootValue,
5201  const struct config_enum_entry *options,
5203  int flags,
5207 {
5208  struct config_enum *var;
5209 
5210  var = (struct config_enum *)
5211  init_custom_variable(name, short_desc, long_desc, context, flags,
5212  PGC_ENUM, sizeof(struct config_enum));
5213  var->variable = valueAddr;
5214  var->boot_val = bootValue;
5215  var->reset_val = bootValue;
5216  var->options = options;
5217  var->check_hook = check_hook;
5218  var->assign_hook = assign_hook;
5219  var->show_hook = show_hook;
5220  define_custom_variable(&var->gen);
5221 }
5222 
5223 /*
5224  * Mark the given GUC prefix as "reserved".
5225  *
5226  * This deletes any existing placeholders matching the prefix,
5227  * and then prevents new ones from being created.
5228  * Extensions should call this after they've defined all of their custom
5229  * GUCs, to help catch misspelled config-file entries.
5230  */
5231 void
5232 MarkGUCPrefixReserved(const char *className)
5233 {
5234  int classLen = strlen(className);
5235  HASH_SEQ_STATUS status;
5236  GUCHashEntry *hentry;
5237  MemoryContext oldcontext;
5238 
5239  /*
5240  * Check for existing placeholders. We must actually remove invalid
5241  * placeholders, else future parallel worker startups will fail. (We
5242  * don't bother trying to free associated memory, since this shouldn't
5243  * happen often.)
5244  */
5245  hash_seq_init(&status, guc_hashtab);
5246  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5247  {
5248  struct config_generic *var = hentry->gucvar;
5249 
5250  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5251  strncmp(className, var->name, classLen) == 0 &&
5252  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5253  {
5254  ereport(WARNING,
5255  (errcode(ERRCODE_INVALID_NAME),
5256  errmsg("invalid configuration parameter name \"%s\", removing it",
5257  var->name),
5258  errdetail("\"%s\" is now a reserved prefix.",
5259  className)));
5260  /* Remove it from the hash table */
5262  &var->name,
5263  HASH_REMOVE,
5264  NULL);
5265  /* Remove it from any lists it's in, too */
5266  RemoveGUCFromLists(var);
5267  }
5268  }
5269 
5270  /* And remember the name so we can prevent future mistakes. */
5273  MemoryContextSwitchTo(oldcontext);
5274 }
5275 
5276 
5277 /*
5278  * Return an array of modified GUC options to show in EXPLAIN.
5279  *
5280  * We only report options related to query planning (marked with GUC_EXPLAIN),
5281  * with values different from their built-in defaults.
5282  */
5283 struct config_generic **
5285 {
5286  struct config_generic **result;
5287  dlist_iter iter;
5288 
5289  *num = 0;
5290 
5291  /*
5292  * While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
5293  * it doesn't seem worth dynamically resizing this array.
5294  */
5295  result = palloc(sizeof(struct config_generic *) * hash_get_num_entries(guc_hashtab));
5296 
5297  /* We need only consider GUCs with source not PGC_S_DEFAULT */
5299  {
5300  struct config_generic *conf = dlist_container(struct config_generic,
5301  nondef_link, iter.cur);
5302  bool modified;
5303 
5304  /* return only parameters marked for inclusion in explain */
5305  if (!(conf->flags & GUC_EXPLAIN))
5306  continue;
5307 
5308  /* return only options visible to the current user */
5309  if (!ConfigOptionIsVisible(conf))
5310  continue;
5311 
5312  /* return only options that are different from their boot values */
5313  modified = false;
5314 
5315  switch (conf->vartype)
5316  {
5317  case PGC_BOOL:
5318  {
5319  struct config_bool *lconf = (struct config_bool *) conf;
5320 
5321  modified = (lconf->boot_val != *(lconf->variable));
5322  }
5323  break;
5324 
5325  case PGC_INT:
5326  {
5327  struct config_int *lconf = (struct config_int *) conf;
5328 
5329  modified = (lconf->boot_val != *(lconf->variable));
5330  }
5331  break;
5332 
5333  case PGC_REAL:
5334  {
5335  struct config_real *lconf = (struct config_real *) conf;
5336 
5337  modified = (lconf->boot_val != *(lconf->variable));
5338  }
5339  break;
5340 
5341  case PGC_STRING:
5342  {
5343  struct config_string *lconf = (struct config_string *) conf;
5344 
5345  if (lconf->boot_val == NULL &&
5346  *lconf->variable == NULL)
5347  modified = false;
5348  else if (lconf->boot_val == NULL ||
5349  *lconf->variable == NULL)
5350  modified = true;
5351  else
5352  modified = (strcmp(lconf->boot_val, *(lconf->variable)) != 0);
5353  }