PostgreSQL Source Code  git master
guc.c
Go to the documentation of this file.
1 /*--------------------------------------------------------------------
2  * guc.c
3  *
4  * Support for grand unified configuration scheme, including SET
5  * command, configuration file, and command line options.
6  *
7  * This file contains the generic option processing infrastructure.
8  * guc_funcs.c contains SQL-level functionality, including SET/SHOW
9  * commands and various system-administration SQL functions.
10  * guc_tables.c contains the arrays that define all the built-in
11  * GUC variables. Code that implements variable-specific behavior
12  * is scattered around the system in check, assign, and show hooks.
13  *
14  * See src/backend/utils/misc/README for more information.
15  *
16  *
17  * Copyright (c) 2000-2024, PostgreSQL Global Development Group
18  * Written by Peter Eisentraut <peter_e@gmx.net>.
19  *
20  * IDENTIFICATION
21  * src/backend/utils/misc/guc.c
22  *
23  *--------------------------------------------------------------------
24  */
25 #include "postgres.h"
26 
27 #include <limits.h>
28 #include <math.h>
29 #include <sys/stat.h>
30 #include <unistd.h>
31 
32 #include "access/xact.h"
33 #include "access/xlog.h"
34 #include "catalog/objectaccess.h"
35 #include "catalog/pg_authid.h"
37 #include "guc_internal.h"
38 #include "libpq/pqformat.h"
39 #include "libpq/protocol.h"
40 #include "miscadmin.h"
41 #include "parser/scansup.h"
42 #include "port/pg_bitutils.h"
43 #include "storage/fd.h"
44 #include "storage/lwlock.h"
45 #include "storage/shmem.h"
46 #include "tcop/tcopprot.h"
47 #include "utils/acl.h"
48 #include "utils/builtins.h"
49 #include "utils/conffiles.h"
50 #include "utils/guc_tables.h"
51 #include "utils/memutils.h"
52 #include "utils/timestamp.h"
53 
54 
55 #define CONFIG_FILENAME "postgresql.conf"
56 #define HBA_FILENAME "pg_hba.conf"
57 #define IDENT_FILENAME "pg_ident.conf"
58 
59 #ifdef EXEC_BACKEND
60 #define CONFIG_EXEC_PARAMS "global/config_exec_params"
61 #define CONFIG_EXEC_PARAMS_NEW "global/config_exec_params.new"
62 #endif
63 
64 /*
65  * Precision with which REAL type guc values are to be printed for GUC
66  * serialization.
67  */
68 #define REALTYPE_PRECISION 17
69 
70 /*
71  * Safe search path when executing code as the table owner, such as during
72  * maintenance operations.
73  */
74 #define GUC_SAFE_SEARCH_PATH "pg_catalog, pg_temp"
75 
77 
79 
80 /* global variables for check hook support */
84 
85 /* Kluge: for speed, we examine this GUC variable's value directly */
86 extern bool in_hot_standby_guc;
87 
88 
89 /*
90  * Unit conversion tables.
91  *
92  * There are two tables, one for memory units, and another for time units.
93  * For each supported conversion from one unit to another, we have an entry
94  * in the table.
95  *
96  * To keep things simple, and to avoid possible roundoff error,
97  * conversions are never chained. There needs to be a direct conversion
98  * between all units (of the same type).
99  *
100  * The conversions for each base unit must be kept in order from greatest to
101  * smallest human-friendly unit; convert_xxx_from_base_unit() rely on that.
102  * (The order of the base-unit groups does not matter.)
103  */
104 #define MAX_UNIT_LEN 3 /* length of longest recognized unit string */
105 
106 typedef struct
107 {
108  char unit[MAX_UNIT_LEN + 1]; /* unit, as a string, like "kB" or
109  * "min" */
110  int base_unit; /* GUC_UNIT_XXX */
111  double multiplier; /* Factor for converting unit -> base_unit */
113 
114 /* Ensure that the constants in the tables don't overflow or underflow */
115 #if BLCKSZ < 1024 || BLCKSZ > (1024*1024)
116 #error BLCKSZ must be between 1KB and 1MB
117 #endif
118 #if XLOG_BLCKSZ < 1024 || XLOG_BLCKSZ > (1024*1024)
119 #error XLOG_BLCKSZ must be between 1KB and 1MB
120 #endif
121 
122 static const char *const memory_units_hint = gettext_noop("Valid units for this parameter are \"B\", \"kB\", \"MB\", \"GB\", and \"TB\".");
123 
125 {
126  {"TB", GUC_UNIT_BYTE, 1024.0 * 1024.0 * 1024.0 * 1024.0},
127  {"GB", GUC_UNIT_BYTE, 1024.0 * 1024.0 * 1024.0},
128  {"MB", GUC_UNIT_BYTE, 1024.0 * 1024.0},
129  {"kB", GUC_UNIT_BYTE, 1024.0},
130  {"B", GUC_UNIT_BYTE, 1.0},
131 
132  {"TB", GUC_UNIT_KB, 1024.0 * 1024.0 * 1024.0},
133  {"GB", GUC_UNIT_KB, 1024.0 * 1024.0},
134  {"MB", GUC_UNIT_KB, 1024.0},
135  {"kB", GUC_UNIT_KB, 1.0},
136  {"B", GUC_UNIT_KB, 1.0 / 1024.0},
137 
138  {"TB", GUC_UNIT_MB, 1024.0 * 1024.0},
139  {"GB", GUC_UNIT_MB, 1024.0},
140  {"MB", GUC_UNIT_MB, 1.0},
141  {"kB", GUC_UNIT_MB, 1.0 / 1024.0},
142  {"B", GUC_UNIT_MB, 1.0 / (1024.0 * 1024.0)},
143 
144  {"TB", GUC_UNIT_BLOCKS, (1024.0 * 1024.0 * 1024.0) / (BLCKSZ / 1024)},
145  {"GB", GUC_UNIT_BLOCKS, (1024.0 * 1024.0) / (BLCKSZ / 1024)},
146  {"MB", GUC_UNIT_BLOCKS, 1024.0 / (BLCKSZ / 1024)},
147  {"kB", GUC_UNIT_BLOCKS, 1.0 / (BLCKSZ / 1024)},
148  {"B", GUC_UNIT_BLOCKS, 1.0 / BLCKSZ},
149 
150  {"TB", GUC_UNIT_XBLOCKS, (1024.0 * 1024.0 * 1024.0) / (XLOG_BLCKSZ / 1024)},
151  {"GB", GUC_UNIT_XBLOCKS, (1024.0 * 1024.0) / (XLOG_BLCKSZ / 1024)},
152  {"MB", GUC_UNIT_XBLOCKS, 1024.0 / (XLOG_BLCKSZ / 1024)},
153  {"kB", GUC_UNIT_XBLOCKS, 1.0 / (XLOG_BLCKSZ / 1024)},
154  {"B", GUC_UNIT_XBLOCKS, 1.0 / XLOG_BLCKSZ},
155 
156  {""} /* end of table marker */
157 };
158 
159 static const char *const time_units_hint = gettext_noop("Valid units for this parameter are \"us\", \"ms\", \"s\", \"min\", \"h\", and \"d\".");
160 
162 {
163  {"d", GUC_UNIT_MS, 1000 * 60 * 60 * 24},
164  {"h", GUC_UNIT_MS, 1000 * 60 * 60},
165  {"min", GUC_UNIT_MS, 1000 * 60},
166  {"s", GUC_UNIT_MS, 1000},
167  {"ms", GUC_UNIT_MS, 1},
168  {"us", GUC_UNIT_MS, 1.0 / 1000},
169 
170  {"d", GUC_UNIT_S, 60 * 60 * 24},
171  {"h", GUC_UNIT_S, 60 * 60},
172  {"min", GUC_UNIT_S, 60},
173  {"s", GUC_UNIT_S, 1},
174  {"ms", GUC_UNIT_S, 1.0 / 1000},
175  {"us", GUC_UNIT_S, 1.0 / (1000 * 1000)},
176 
177  {"d", GUC_UNIT_MIN, 60 * 24},
178  {"h", GUC_UNIT_MIN, 60},
179  {"min", GUC_UNIT_MIN, 1},
180  {"s", GUC_UNIT_MIN, 1.0 / 60},
181  {"ms", GUC_UNIT_MIN, 1.0 / (1000 * 60)},
182  {"us", GUC_UNIT_MIN, 1.0 / (1000 * 1000 * 60)},
183 
184  {""} /* end of table marker */
185 };
186 
187 /*
188  * To allow continued support of obsolete names for GUC variables, we apply
189  * the following mappings to any unrecognized name. Note that an old name
190  * should be mapped to a new one only if the new variable has very similar
191  * semantics to the old.
192  */
193 static const char *const map_old_guc_names[] = {
194  "sort_mem", "work_mem",
195  "vacuum_mem", "maintenance_work_mem",
196  NULL
197 };
198 
199 
200 /* Memory context holding all GUC-related data */
202 
203 /*
204  * We use a dynahash table to look up GUCs by name, or to iterate through
205  * all the GUCs. The gucname field is redundant with gucvar->name, but
206  * dynahash makes it too painful to not store the hash key separately.
207  */
208 typedef struct
209 {
210  const char *gucname; /* hash key */
211  struct config_generic *gucvar; /* -> GUC's defining structure */
212 } GUCHashEntry;
213 
214 static HTAB *guc_hashtab; /* entries are GUCHashEntrys */
215 
216 /*
217  * In addition to the hash table, variables having certain properties are
218  * linked into these lists, so that we can find them without scanning the
219  * whole hash table. In most applications, only a small fraction of the
220  * GUCs appear in these lists at any given time. The usage of the stack
221  * and report lists is stylized enough that they can be slists, but the
222  * nondef list has to be a dlist to avoid O(N) deletes in common cases.
223  */
224 static dlist_head guc_nondef_list; /* list of variables that have source
225  * different from PGC_S_DEFAULT */
226 static slist_head guc_stack_list; /* list of variables that have non-NULL
227  * stack */
228 static slist_head guc_report_list; /* list of variables that have the
229  * GUC_NEEDS_REPORT bit set in status */
230 
231 static bool reporting_enabled; /* true to enable GUC_REPORT */
232 
233 static int GUCNestLevel = 0; /* 1 when in main transaction */
234 
235 
236 static int guc_var_compare(const void *a, const void *b);
237 static uint32 guc_name_hash(const void *key, Size keysize);
238 static int guc_name_match(const void *key1, const void *key2, Size keysize);
239 static void InitializeGUCOptionsFromEnvironment(void);
240 static void InitializeOneGUCOption(struct config_generic *gconf);
241 static void RemoveGUCFromLists(struct config_generic *gconf);
242 static void set_guc_source(struct config_generic *gconf, GucSource newsource);
243 static void pg_timezone_abbrev_initialize(void);
244 static void push_old_value(struct config_generic *gconf, GucAction action);
245 static void ReportGUCOption(struct config_generic *record);
246 static void set_config_sourcefile(const char *name, char *sourcefile,
247  int sourceline);
249  struct config_string *pHolder,
250  GucStack *stack,
251  const char *curvalue,
252  GucContext curscontext, GucSource cursource,
253  Oid cursrole);
254 static bool validate_option_array_item(const char *name, const char *value,
255  bool skipIfNoPermissions);
256 static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head);
257 static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p,
258  const char *name, const char *value);
259 static bool valid_custom_variable_name(const char *name);
260 static bool assignable_custom_variable_name(const char *name, bool skip_errors,
261  int elevel);
262 static void do_serialize(char **destptr, Size *maxbytes,
263  const char *fmt,...) pg_attribute_printf(3, 4);
264 static bool call_bool_check_hook(struct config_bool *conf, bool *newval,
265  void **extra, GucSource source, int elevel);
266 static bool call_int_check_hook(struct config_int *conf, int *newval,
267  void **extra, GucSource source, int elevel);
268 static bool call_real_check_hook(struct config_real *conf, double *newval,
269  void **extra, GucSource source, int elevel);
270 static bool call_string_check_hook(struct config_string *conf, char **newval,
271  void **extra, GucSource source, int elevel);
272 static bool call_enum_check_hook(struct config_enum *conf, int *newval,
273  void **extra, GucSource source, int elevel);
274 
275 
276 /*
277  * This function handles both actual config file (re)loads and execution of
278  * show_all_file_settings() (i.e., the pg_file_settings view). In the latter
279  * case we don't apply any of the settings, but we make all the usual validity
280  * checks, and we return the ConfigVariable list so that it can be printed out
281  * by show_all_file_settings().
282  */
284 ProcessConfigFileInternal(GucContext context, bool applySettings, int elevel)
285 {
286  bool error = false;
287  bool applying = false;
288  const char *ConfFileWithError;
289  ConfigVariable *item,
290  *head,
291  *tail;
293  GUCHashEntry *hentry;
294 
295  /* Parse the main config file into a list of option names and values */
296  ConfFileWithError = ConfigFileName;
297  head = tail = NULL;
298 
299  if (!ParseConfigFile(ConfigFileName, true,
300  NULL, 0, CONF_FILE_START_DEPTH, elevel,
301  &head, &tail))
302  {
303  /* Syntax error(s) detected in the file, so bail out */
304  error = true;
305  goto bail_out;
306  }
307 
308  /*
309  * Parse the PG_AUTOCONF_FILENAME file, if present, after the main file to
310  * replace any parameters set by ALTER SYSTEM command. Because this file
311  * is in the data directory, we can't read it until the DataDir has been
312  * set.
313  */
314  if (DataDir)
315  {
317  NULL, 0, CONF_FILE_START_DEPTH, elevel,
318  &head, &tail))
319  {
320  /* Syntax error(s) detected in the file, so bail out */
321  error = true;
322  ConfFileWithError = PG_AUTOCONF_FILENAME;
323  goto bail_out;
324  }
325  }
326  else
327  {
328  /*
329  * If DataDir is not set, the PG_AUTOCONF_FILENAME file cannot be
330  * read. In this case, we don't want to accept any settings but
331  * data_directory from postgresql.conf, because they might be
332  * overwritten with settings in the PG_AUTOCONF_FILENAME file which
333  * will be read later. OTOH, since data_directory isn't allowed in the
334  * PG_AUTOCONF_FILENAME file, it will never be overwritten later.
335  */
336  ConfigVariable *newlist = NULL;
337 
338  /*
339  * Prune all items except the last "data_directory" from the list.
340  */
341  for (item = head; item; item = item->next)
342  {
343  if (!item->ignore &&
344  strcmp(item->name, "data_directory") == 0)
345  newlist = item;
346  }
347 
348  if (newlist)
349  newlist->next = NULL;
350  head = tail = newlist;
351 
352  /*
353  * Quick exit if data_directory is not present in file.
354  *
355  * We need not do any further processing, in particular we don't set
356  * PgReloadTime; that will be set soon by subsequent full loading of
357  * the config file.
358  */
359  if (head == NULL)
360  goto bail_out;
361  }
362 
363  /*
364  * Mark all extant GUC variables as not present in the config file. We
365  * need this so that we can tell below which ones have been removed from
366  * the file since we last processed it.
367  */
369  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
370  {
371  struct config_generic *gconf = hentry->gucvar;
372 
373  gconf->status &= ~GUC_IS_IN_FILE;
374  }
375 
376  /*
377  * Check if all the supplied option names are valid, as an additional
378  * quasi-syntactic check on the validity of the config file. It is
379  * important that the postmaster and all backends agree on the results of
380  * this phase, else we will have strange inconsistencies about which
381  * processes accept a config file update and which don't. Hence, unknown
382  * custom variable names have to be accepted without complaint. For the
383  * same reason, we don't attempt to validate the options' values here.
384  *
385  * In addition, the GUC_IS_IN_FILE flag is set on each existing GUC
386  * variable mentioned in the file; and we detect duplicate entries in the
387  * file and mark the earlier occurrences as ignorable.
388  */
389  for (item = head; item; item = item->next)
390  {
391  struct config_generic *record;
392 
393  /* Ignore anything already marked as ignorable */
394  if (item->ignore)
395  continue;
396 
397  /*
398  * Try to find the variable; but do not create a custom placeholder if
399  * it's not there already.
400  */
401  record = find_option(item->name, false, true, elevel);
402 
403  if (record)
404  {
405  /* If it's already marked, then this is a duplicate entry */
406  if (record->status & GUC_IS_IN_FILE)
407  {
408  /*
409  * Mark the earlier occurrence(s) as dead/ignorable. We could
410  * avoid the O(N^2) behavior here with some additional state,
411  * but it seems unlikely to be worth the trouble.
412  */
413  ConfigVariable *pitem;
414 
415  for (pitem = head; pitem != item; pitem = pitem->next)
416  {
417  if (!pitem->ignore &&
418  strcmp(pitem->name, item->name) == 0)
419  pitem->ignore = true;
420  }
421  }
422  /* Now mark it as present in file */
423  record->status |= GUC_IS_IN_FILE;
424  }
425  else if (!valid_custom_variable_name(item->name))
426  {
427  /* Invalid non-custom variable, so complain */
428  ereport(elevel,
429  (errcode(ERRCODE_UNDEFINED_OBJECT),
430  errmsg("unrecognized configuration parameter \"%s\" in file \"%s\" line %d",
431  item->name,
432  item->filename, item->sourceline)));
433  item->errmsg = pstrdup("unrecognized configuration parameter");
434  error = true;
435  ConfFileWithError = item->filename;
436  }
437  }
438 
439  /*
440  * If we've detected any errors so far, we don't want to risk applying any
441  * changes.
442  */
443  if (error)
444  goto bail_out;
445 
446  /* Otherwise, set flag that we're beginning to apply changes */
447  applying = true;
448 
449  /*
450  * Check for variables having been removed from the config file, and
451  * revert their reset values (and perhaps also effective values) to the
452  * boot-time defaults. If such a variable can't be changed after startup,
453  * report that and continue.
454  */
456  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
457  {
458  struct config_generic *gconf = hentry->gucvar;
459  GucStack *stack;
460 
461  if (gconf->reset_source != PGC_S_FILE ||
462  (gconf->status & GUC_IS_IN_FILE))
463  continue;
464  if (gconf->context < PGC_SIGHUP)
465  {
466  /* The removal can't be effective without a restart */
467  gconf->status |= GUC_PENDING_RESTART;
468  ereport(elevel,
469  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
470  errmsg("parameter \"%s\" cannot be changed without restarting the server",
471  gconf->name)));
472  record_config_file_error(psprintf("parameter \"%s\" cannot be changed without restarting the server",
473  gconf->name),
474  NULL, 0,
475  &head, &tail);
476  error = true;
477  continue;
478  }
479 
480  /* No more to do if we're just doing show_all_file_settings() */
481  if (!applySettings)
482  continue;
483 
484  /*
485  * Reset any "file" sources to "default", else set_config_option will
486  * not override those settings.
487  */
488  if (gconf->reset_source == PGC_S_FILE)
489  gconf->reset_source = PGC_S_DEFAULT;
490  if (gconf->source == PGC_S_FILE)
492  for (stack = gconf->stack; stack; stack = stack->prev)
493  {
494  if (stack->source == PGC_S_FILE)
496  }
497 
498  /* Now we can re-apply the wired-in default (i.e., the boot_val) */
499  if (set_config_option(gconf->name, NULL,
501  GUC_ACTION_SET, true, 0, false) > 0)
502  {
503  /* Log the change if appropriate */
504  if (context == PGC_SIGHUP)
505  ereport(elevel,
506  (errmsg("parameter \"%s\" removed from configuration file, reset to default",
507  gconf->name)));
508  }
509  }
510 
511  /*
512  * Restore any variables determined by environment variables or
513  * dynamically-computed defaults. This is a no-op except in the case
514  * where one of these had been in the config file and is now removed.
515  *
516  * In particular, we *must not* do this during the postmaster's initial
517  * loading of the file, since the timezone functions in particular should
518  * be run only after initialization is complete.
519  *
520  * XXX this is an unmaintainable crock, because we have to know how to set
521  * (or at least what to call to set) every non-PGC_INTERNAL variable that
522  * could potentially have PGC_S_DYNAMIC_DEFAULT or PGC_S_ENV_VAR source.
523  */
524  if (context == PGC_SIGHUP && applySettings)
525  {
528  /* this selects SQL_ASCII in processes not connected to a database */
529  SetConfigOption("client_encoding", GetDatabaseEncodingName(),
531  }
532 
533  /*
534  * Now apply the values from the config file.
535  */
536  for (item = head; item; item = item->next)
537  {
538  char *pre_value = NULL;
539  int scres;
540 
541  /* Ignore anything marked as ignorable */
542  if (item->ignore)
543  continue;
544 
545  /* In SIGHUP cases in the postmaster, we want to report changes */
546  if (context == PGC_SIGHUP && applySettings && !IsUnderPostmaster)
547  {
548  const char *preval = GetConfigOption(item->name, true, false);
549 
550  /* If option doesn't exist yet or is NULL, treat as empty string */
551  if (!preval)
552  preval = "";
553  /* must dup, else might have dangling pointer below */
554  pre_value = pstrdup(preval);
555  }
556 
557  scres = set_config_option(item->name, item->value,
559  GUC_ACTION_SET, applySettings, 0, false);
560  if (scres > 0)
561  {
562  /* variable was updated, so log the change if appropriate */
563  if (pre_value)
564  {
565  const char *post_value = GetConfigOption(item->name, true, false);
566 
567  if (!post_value)
568  post_value = "";
569  if (strcmp(pre_value, post_value) != 0)
570  ereport(elevel,
571  (errmsg("parameter \"%s\" changed to \"%s\"",
572  item->name, item->value)));
573  }
574  item->applied = true;
575  }
576  else if (scres == 0)
577  {
578  error = true;
579  item->errmsg = pstrdup("setting could not be applied");
580  ConfFileWithError = item->filename;
581  }
582  else
583  {
584  /* no error, but variable's active value was not changed */
585  item->applied = true;
586  }
587 
588  /*
589  * We should update source location unless there was an error, since
590  * even if the active value didn't change, the reset value might have.
591  * (In the postmaster, there won't be a difference, but it does matter
592  * in backends.)
593  */
594  if (scres != 0 && applySettings)
595  set_config_sourcefile(item->name, item->filename,
596  item->sourceline);
597 
598  if (pre_value)
599  pfree(pre_value);
600  }
601 
602  /* Remember when we last successfully loaded the config file. */
603  if (applySettings)
605 
606 bail_out:
607  if (error && applySettings)
608  {
609  /* During postmaster startup, any error is fatal */
610  if (context == PGC_POSTMASTER)
611  ereport(ERROR,
612  (errcode(ERRCODE_CONFIG_FILE_ERROR),
613  errmsg("configuration file \"%s\" contains errors",
614  ConfFileWithError)));
615  else if (applying)
616  ereport(elevel,
617  (errcode(ERRCODE_CONFIG_FILE_ERROR),
618  errmsg("configuration file \"%s\" contains errors; unaffected changes were applied",
619  ConfFileWithError)));
620  else
621  ereport(elevel,
622  (errcode(ERRCODE_CONFIG_FILE_ERROR),
623  errmsg("configuration file \"%s\" contains errors; no changes were applied",
624  ConfFileWithError)));
625  }
626 
627  /* Successful or otherwise, return the collected data list */
628  return head;
629 }
630 
631 
632 /*
633  * Some infrastructure for GUC-related memory allocation
634  *
635  * These functions are generally modeled on libc's malloc/realloc/etc,
636  * but any OOM issue is reported at the specified elevel.
637  * (Thus, control returns only if that's less than ERROR.)
638  */
639 void *
640 guc_malloc(int elevel, size_t size)
641 {
642  void *data;
643 
646  if (unlikely(data == NULL))
647  ereport(elevel,
648  (errcode(ERRCODE_OUT_OF_MEMORY),
649  errmsg("out of memory")));
650  return data;
651 }
652 
653 void *
654 guc_realloc(int elevel, void *old, size_t size)
655 {
656  void *data;
657 
658  if (old != NULL)
659  {
660  /* This is to help catch old code that malloc's GUC data. */
662  data = repalloc_extended(old, size,
664  }
665  else
666  {
667  /* Like realloc(3), but not like repalloc(), we allow old == NULL. */
670  }
671  if (unlikely(data == NULL))
672  ereport(elevel,
673  (errcode(ERRCODE_OUT_OF_MEMORY),
674  errmsg("out of memory")));
675  return data;
676 }
677 
678 char *
679 guc_strdup(int elevel, const char *src)
680 {
681  char *data;
682  size_t len = strlen(src) + 1;
683 
684  data = guc_malloc(elevel, len);
685  if (likely(data != NULL))
686  memcpy(data, src, len);
687  return data;
688 }
689 
690 void
691 guc_free(void *ptr)
692 {
693  /*
694  * Historically, GUC-related code has relied heavily on the ability to do
695  * free(NULL), so we allow that here even though pfree() doesn't.
696  */
697  if (ptr != NULL)
698  {
699  /* This is to help catch old code that malloc's GUC data. */
701  pfree(ptr);
702  }
703 }
704 
705 
706 /*
707  * Detect whether strval is referenced anywhere in a GUC string item
708  */
709 static bool
710 string_field_used(struct config_string *conf, char *strval)
711 {
712  GucStack *stack;
713 
714  if (strval == *(conf->variable) ||
715  strval == conf->reset_val ||
716  strval == conf->boot_val)
717  return true;
718  for (stack = conf->gen.stack; stack; stack = stack->prev)
719  {
720  if (strval == stack->prior.val.stringval ||
721  strval == stack->masked.val.stringval)
722  return true;
723  }
724  return false;
725 }
726 
727 /*
728  * Support for assigning to a field of a string GUC item. Free the prior
729  * value if it's not referenced anywhere else in the item (including stacked
730  * states).
731  */
732 static void
733 set_string_field(struct config_string *conf, char **field, char *newval)
734 {
735  char *oldval = *field;
736 
737  /* Do the assignment */
738  *field = newval;
739 
740  /* Free old value if it's not NULL and isn't referenced anymore */
741  if (oldval && !string_field_used(conf, oldval))
742  guc_free(oldval);
743 }
744 
745 /*
746  * Detect whether an "extra" struct is referenced anywhere in a GUC item
747  */
748 static bool
749 extra_field_used(struct config_generic *gconf, void *extra)
750 {
751  GucStack *stack;
752 
753  if (extra == gconf->extra)
754  return true;
755  switch (gconf->vartype)
756  {
757  case PGC_BOOL:
758  if (extra == ((struct config_bool *) gconf)->reset_extra)
759  return true;
760  break;
761  case PGC_INT:
762  if (extra == ((struct config_int *) gconf)->reset_extra)
763  return true;
764  break;
765  case PGC_REAL:
766  if (extra == ((struct config_real *) gconf)->reset_extra)
767  return true;
768  break;
769  case PGC_STRING:
770  if (extra == ((struct config_string *) gconf)->reset_extra)
771  return true;
772  break;
773  case PGC_ENUM:
774  if (extra == ((struct config_enum *) gconf)->reset_extra)
775  return true;
776  break;
777  }
778  for (stack = gconf->stack; stack; stack = stack->prev)
779  {
780  if (extra == stack->prior.extra ||
781  extra == stack->masked.extra)
782  return true;
783  }
784 
785  return false;
786 }
787 
788 /*
789  * Support for assigning to an "extra" field of a GUC item. Free the prior
790  * value if it's not referenced anywhere else in the item (including stacked
791  * states).
792  */
793 static void
794 set_extra_field(struct config_generic *gconf, void **field, void *newval)
795 {
796  void *oldval = *field;
797 
798  /* Do the assignment */
799  *field = newval;
800 
801  /* Free old value if it's not NULL and isn't referenced anymore */
802  if (oldval && !extra_field_used(gconf, oldval))
803  guc_free(oldval);
804 }
805 
806 /*
807  * Support for copying a variable's active value into a stack entry.
808  * The "extra" field associated with the active value is copied, too.
809  *
810  * NB: be sure stringval and extra fields of a new stack entry are
811  * initialized to NULL before this is used, else we'll try to guc_free() them.
812  */
813 static void
815 {
816  switch (gconf->vartype)
817  {
818  case PGC_BOOL:
819  val->val.boolval =
820  *((struct config_bool *) gconf)->variable;
821  break;
822  case PGC_INT:
823  val->val.intval =
824  *((struct config_int *) gconf)->variable;
825  break;
826  case PGC_REAL:
827  val->val.realval =
828  *((struct config_real *) gconf)->variable;
829  break;
830  case PGC_STRING:
831  set_string_field((struct config_string *) gconf,
832  &(val->val.stringval),
833  *((struct config_string *) gconf)->variable);
834  break;
835  case PGC_ENUM:
836  val->val.enumval =
837  *((struct config_enum *) gconf)->variable;
838  break;
839  }
840  set_extra_field(gconf, &(val->extra), gconf->extra);
841 }
842 
843 /*
844  * Support for discarding a no-longer-needed value in a stack entry.
845  * The "extra" field associated with the stack entry is cleared, too.
846  */
847 static void
849 {
850  switch (gconf->vartype)
851  {
852  case PGC_BOOL:
853  case PGC_INT:
854  case PGC_REAL:
855  case PGC_ENUM:
856  /* no need to do anything */
857  break;
858  case PGC_STRING:
859  set_string_field((struct config_string *) gconf,
860  &(val->val.stringval),
861  NULL);
862  break;
863  }
864  set_extra_field(gconf, &(val->extra), NULL);
865 }
866 
867 
868 /*
869  * Fetch a palloc'd, sorted array of GUC struct pointers
870  *
871  * The array length is returned into *num_vars.
872  */
873 struct config_generic **
874 get_guc_variables(int *num_vars)
875 {
876  struct config_generic **result;
878  GUCHashEntry *hentry;
879  int i;
880 
881  *num_vars = hash_get_num_entries(guc_hashtab);
882  result = palloc(sizeof(struct config_generic *) * *num_vars);
883 
884  /* Extract pointers from the hash table */
885  i = 0;
887  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
888  result[i++] = hentry->gucvar;
889  Assert(i == *num_vars);
890 
891  /* Sort by name */
892  qsort(result, *num_vars,
893  sizeof(struct config_generic *), guc_var_compare);
894 
895  return result;
896 }
897 
898 
899 /*
900  * Build the GUC hash table. This is split out so that help_config.c can
901  * extract all the variables without running all of InitializeGUCOptions.
902  * It's not meant for use anyplace else.
903  */
904 void
906 {
907  int size_vars;
908  int num_vars = 0;
909  HASHCTL hash_ctl;
910  GUCHashEntry *hentry;
911  bool found;
912  int i;
913 
914  /*
915  * Create the memory context that will hold all GUC-related data.
916  */
917  Assert(GUCMemoryContext == NULL);
919  "GUCMemoryContext",
921 
922  /*
923  * Count all the built-in variables, and set their vartypes correctly.
924  */
925  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
926  {
927  struct config_bool *conf = &ConfigureNamesBool[i];
928 
929  /* Rather than requiring vartype to be filled in by hand, do this: */
930  conf->gen.vartype = PGC_BOOL;
931  num_vars++;
932  }
933 
934  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
935  {
936  struct config_int *conf = &ConfigureNamesInt[i];
937 
938  conf->gen.vartype = PGC_INT;
939  num_vars++;
940  }
941 
942  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
943  {
944  struct config_real *conf = &ConfigureNamesReal[i];
945 
946  conf->gen.vartype = PGC_REAL;
947  num_vars++;
948  }
949 
950  for (i = 0; ConfigureNamesString[i].gen.name; i++)
951  {
952  struct config_string *conf = &ConfigureNamesString[i];
953 
954  conf->gen.vartype = PGC_STRING;
955  num_vars++;
956  }
957 
958  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
959  {
960  struct config_enum *conf = &ConfigureNamesEnum[i];
961 
962  conf->gen.vartype = PGC_ENUM;
963  num_vars++;
964  }
965 
966  /*
967  * Create hash table with 20% slack
968  */
969  size_vars = num_vars + num_vars / 4;
970 
971  hash_ctl.keysize = sizeof(char *);
972  hash_ctl.entrysize = sizeof(GUCHashEntry);
973  hash_ctl.hash = guc_name_hash;
974  hash_ctl.match = guc_name_match;
975  hash_ctl.hcxt = GUCMemoryContext;
976  guc_hashtab = hash_create("GUC hash table",
977  size_vars,
978  &hash_ctl,
980 
981  for (i = 0; ConfigureNamesBool[i].gen.name; i++)
982  {
983  struct config_generic *gucvar = &ConfigureNamesBool[i].gen;
984 
985  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
986  &gucvar->name,
987  HASH_ENTER,
988  &found);
989  Assert(!found);
990  hentry->gucvar = gucvar;
991  }
992 
993  for (i = 0; ConfigureNamesInt[i].gen.name; i++)
994  {
995  struct config_generic *gucvar = &ConfigureNamesInt[i].gen;
996 
997  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
998  &gucvar->name,
999  HASH_ENTER,
1000  &found);
1001  Assert(!found);
1002  hentry->gucvar = gucvar;
1003  }
1004 
1005  for (i = 0; ConfigureNamesReal[i].gen.name; i++)
1006  {
1007  struct config_generic *gucvar = &ConfigureNamesReal[i].gen;
1008 
1009  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1010  &gucvar->name,
1011  HASH_ENTER,
1012  &found);
1013  Assert(!found);
1014  hentry->gucvar = gucvar;
1015  }
1016 
1017  for (i = 0; ConfigureNamesString[i].gen.name; i++)
1018  {
1019  struct config_generic *gucvar = &ConfigureNamesString[i].gen;
1020 
1021  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1022  &gucvar->name,
1023  HASH_ENTER,
1024  &found);
1025  Assert(!found);
1026  hentry->gucvar = gucvar;
1027  }
1028 
1029  for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
1030  {
1031  struct config_generic *gucvar = &ConfigureNamesEnum[i].gen;
1032 
1033  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1034  &gucvar->name,
1035  HASH_ENTER,
1036  &found);
1037  Assert(!found);
1038  hentry->gucvar = gucvar;
1039  }
1040 
1041  Assert(num_vars == hash_get_num_entries(guc_hashtab));
1042 }
1043 
1044 /*
1045  * Add a new GUC variable to the hash of known variables. The
1046  * hash is expanded if needed.
1047  */
1048 static bool
1049 add_guc_variable(struct config_generic *var, int elevel)
1050 {
1051  GUCHashEntry *hentry;
1052  bool found;
1053 
1054  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1055  &var->name,
1057  &found);
1058  if (unlikely(hentry == NULL))
1059  {
1060  ereport(elevel,
1061  (errcode(ERRCODE_OUT_OF_MEMORY),
1062  errmsg("out of memory")));
1063  return false; /* out of memory */
1064  }
1065  Assert(!found);
1066  hentry->gucvar = var;
1067  return true;
1068 }
1069 
1070 /*
1071  * Decide whether a proposed custom variable name is allowed.
1072  *
1073  * It must be two or more identifiers separated by dots, where the rules
1074  * for what is an identifier agree with scan.l. (If you change this rule,
1075  * adjust the errdetail in assignable_custom_variable_name().)
1076  */
1077 static bool
1079 {
1080  bool saw_sep = false;
1081  bool name_start = true;
1082 
1083  for (const char *p = name; *p; p++)
1084  {
1085  if (*p == GUC_QUALIFIER_SEPARATOR)
1086  {
1087  if (name_start)
1088  return false; /* empty name component */
1089  saw_sep = true;
1090  name_start = true;
1091  }
1092  else if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1093  "abcdefghijklmnopqrstuvwxyz_", *p) != NULL ||
1094  IS_HIGHBIT_SET(*p))
1095  {
1096  /* okay as first or non-first character */
1097  name_start = false;
1098  }
1099  else if (!name_start && strchr("0123456789$", *p) != NULL)
1100  /* okay as non-first character */ ;
1101  else
1102  return false;
1103  }
1104  if (name_start)
1105  return false; /* empty name component */
1106  /* OK if we found at least one separator */
1107  return saw_sep;
1108 }
1109 
1110 /*
1111  * Decide whether an unrecognized variable name is allowed to be SET.
1112  *
1113  * It must pass the syntactic rules of valid_custom_variable_name(),
1114  * and it must not be in any namespace already reserved by an extension.
1115  * (We make this separate from valid_custom_variable_name() because we don't
1116  * apply the reserved-namespace test when reading configuration files.)
1117  *
1118  * If valid, return true. Otherwise, return false if skip_errors is true,
1119  * else throw a suitable error at the specified elevel (and return false
1120  * if that's less than ERROR).
1121  */
1122 static bool
1123 assignable_custom_variable_name(const char *name, bool skip_errors, int elevel)
1124 {
1125  /* If there's no separator, it can't be a custom variable */
1126  const char *sep = strchr(name, GUC_QUALIFIER_SEPARATOR);
1127 
1128  if (sep != NULL)
1129  {
1130  size_t classLen = sep - name;
1131  ListCell *lc;
1132 
1133  /* The name must be syntactically acceptable ... */
1135  {
1136  if (!skip_errors)
1137  ereport(elevel,
1138  (errcode(ERRCODE_INVALID_NAME),
1139  errmsg("invalid configuration parameter name \"%s\"",
1140  name),
1141  errdetail("Custom parameter names must be two or more simple identifiers separated by dots.")));
1142  return false;
1143  }
1144  /* ... and it must not match any previously-reserved prefix */
1145  foreach(lc, reserved_class_prefix)
1146  {
1147  const char *rcprefix = lfirst(lc);
1148 
1149  if (strlen(rcprefix) == classLen &&
1150  strncmp(name, rcprefix, classLen) == 0)
1151  {
1152  if (!skip_errors)
1153  ereport(elevel,
1154  (errcode(ERRCODE_INVALID_NAME),
1155  errmsg("invalid configuration parameter name \"%s\"",
1156  name),
1157  errdetail("\"%s\" is a reserved prefix.",
1158  rcprefix)));
1159  return false;
1160  }
1161  }
1162  /* OK to create it */
1163  return true;
1164  }
1165 
1166  /* Unrecognized single-part name */
1167  if (!skip_errors)
1168  ereport(elevel,
1169  (errcode(ERRCODE_UNDEFINED_OBJECT),
1170  errmsg("unrecognized configuration parameter \"%s\"",
1171  name)));
1172  return false;
1173 }
1174 
1175 /*
1176  * Create and add a placeholder variable for a custom variable name.
1177  */
1178 static struct config_generic *
1179 add_placeholder_variable(const char *name, int elevel)
1180 {
1181  size_t sz = sizeof(struct config_string) + sizeof(char *);
1182  struct config_string *var;
1183  struct config_generic *gen;
1184 
1185  var = (struct config_string *) guc_malloc(elevel, sz);
1186  if (var == NULL)
1187  return NULL;
1188  memset(var, 0, sz);
1189  gen = &var->gen;
1190 
1191  gen->name = guc_strdup(elevel, name);
1192  if (gen->name == NULL)
1193  {
1194  guc_free(var);
1195  return NULL;
1196  }
1197 
1198  gen->context = PGC_USERSET;
1200  gen->short_desc = "GUC placeholder variable";
1202  gen->vartype = PGC_STRING;
1203 
1204  /*
1205  * The char* is allocated at the end of the struct since we have no
1206  * 'static' place to point to. Note that the current value, as well as
1207  * the boot and reset values, start out NULL.
1208  */
1209  var->variable = (char **) (var + 1);
1210 
1211  if (!add_guc_variable((struct config_generic *) var, elevel))
1212  {
1213  guc_free(unconstify(char *, gen->name));
1214  guc_free(var);
1215  return NULL;
1216  }
1217 
1218  return gen;
1219 }
1220 
1221 /*
1222  * Look up option "name". If it exists, return a pointer to its record.
1223  * Otherwise, if create_placeholders is true and name is a valid-looking
1224  * custom variable name, we'll create and return a placeholder record.
1225  * Otherwise, if skip_errors is true, then we silently return NULL for
1226  * an unrecognized or invalid name. Otherwise, the error is reported at
1227  * error level elevel (and we return NULL if that's less than ERROR).
1228  *
1229  * Note: internal errors, primarily out-of-memory, draw an elevel-level
1230  * report and NULL return regardless of skip_errors. Hence, callers must
1231  * handle a NULL return whenever elevel < ERROR, but they should not need
1232  * to emit any additional error message. (In practice, internal errors
1233  * can only happen when create_placeholders is true, so callers passing
1234  * false need not think terribly hard about this.)
1235  */
1236 struct config_generic *
1237 find_option(const char *name, bool create_placeholders, bool skip_errors,
1238  int elevel)
1239 {
1240  GUCHashEntry *hentry;
1241  int i;
1242 
1243  Assert(name);
1244 
1245  /* Look it up using the hash table. */
1246  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1247  &name,
1248  HASH_FIND,
1249  NULL);
1250  if (hentry)
1251  return hentry->gucvar;
1252 
1253  /*
1254  * See if the name is an obsolete name for a variable. We assume that the
1255  * set of supported old names is short enough that a brute-force search is
1256  * the best way.
1257  */
1258  for (i = 0; map_old_guc_names[i] != NULL; i += 2)
1259  {
1261  return find_option(map_old_guc_names[i + 1], false,
1262  skip_errors, elevel);
1263  }
1264 
1265  if (create_placeholders)
1266  {
1267  /*
1268  * Check if the name is valid, and if so, add a placeholder.
1269  */
1270  if (assignable_custom_variable_name(name, skip_errors, elevel))
1271  return add_placeholder_variable(name, elevel);
1272  else
1273  return NULL; /* error message, if any, already emitted */
1274  }
1275 
1276  /* Unknown name and we're not supposed to make a placeholder */
1277  if (!skip_errors)
1278  ereport(elevel,
1279  (errcode(ERRCODE_UNDEFINED_OBJECT),
1280  errmsg("unrecognized configuration parameter \"%s\"",
1281  name)));
1282  return NULL;
1283 }
1284 
1285 
1286 /*
1287  * comparator for qsorting an array of GUC pointers
1288  */
1289 static int
1290 guc_var_compare(const void *a, const void *b)
1291 {
1292  const struct config_generic *confa = *(struct config_generic *const *) a;
1293  const struct config_generic *confb = *(struct config_generic *const *) b;
1294 
1295  return guc_name_compare(confa->name, confb->name);
1296 }
1297 
1298 /*
1299  * the bare comparison function for GUC names
1300  */
1301 int
1302 guc_name_compare(const char *namea, const char *nameb)
1303 {
1304  /*
1305  * The temptation to use strcasecmp() here must be resisted, because the
1306  * hash mapping has to remain stable across setlocale() calls. So, build
1307  * our own with a simple ASCII-only downcasing.
1308  */
1309  while (*namea && *nameb)
1310  {
1311  char cha = *namea++;
1312  char chb = *nameb++;
1313 
1314  if (cha >= 'A' && cha <= 'Z')
1315  cha += 'a' - 'A';
1316  if (chb >= 'A' && chb <= 'Z')
1317  chb += 'a' - 'A';
1318  if (cha != chb)
1319  return cha - chb;
1320  }
1321  if (*namea)
1322  return 1; /* a is longer */
1323  if (*nameb)
1324  return -1; /* b is longer */
1325  return 0;
1326 }
1327 
1328 /*
1329  * Hash function that's compatible with guc_name_compare
1330  */
1331 static uint32
1332 guc_name_hash(const void *key, Size keysize)
1333 {
1334  uint32 result = 0;
1335  const char *name = *(const char *const *) key;
1336 
1337  while (*name)
1338  {
1339  char ch = *name++;
1340 
1341  /* Case-fold in the same way as guc_name_compare */
1342  if (ch >= 'A' && ch <= 'Z')
1343  ch += 'a' - 'A';
1344 
1345  /* Merge into hash ... not very bright, but it needn't be */
1346  result = pg_rotate_left32(result, 5);
1347  result ^= (uint32) ch;
1348  }
1349  return result;
1350 }
1351 
1352 /*
1353  * Dynahash match function to use in guc_hashtab
1354  */
1355 static int
1356 guc_name_match(const void *key1, const void *key2, Size keysize)
1357 {
1358  const char *name1 = *(const char *const *) key1;
1359  const char *name2 = *(const char *const *) key2;
1360 
1361  return guc_name_compare(name1, name2);
1362 }
1363 
1364 
1365 /*
1366  * Convert a GUC name to the form that should be used in pg_parameter_acl.
1367  *
1368  * We need to canonicalize entries since, for example, case should not be
1369  * significant. In addition, we apply the map_old_guc_names[] mapping so that
1370  * any obsolete names will be converted when stored in a new PG version.
1371  * Note however that this function does not verify legality of the name.
1372  *
1373  * The result is a palloc'd string.
1374  */
1375 char *
1377 {
1378  char *result;
1379 
1380  /* Apply old-GUC-name mapping. */
1381  for (int i = 0; map_old_guc_names[i] != NULL; i += 2)
1382  {
1384  {
1385  name = map_old_guc_names[i + 1];
1386  break;
1387  }
1388  }
1389 
1390  /* Apply case-folding that matches guc_name_compare(). */
1391  result = pstrdup(name);
1392  for (char *ptr = result; *ptr != '\0'; ptr++)
1393  {
1394  char ch = *ptr;
1395 
1396  if (ch >= 'A' && ch <= 'Z')
1397  {
1398  ch += 'a' - 'A';
1399  *ptr = ch;
1400  }
1401  }
1402 
1403  return result;
1404 }
1405 
1406 /*
1407  * Check whether we should allow creation of a pg_parameter_acl entry
1408  * for the given name. (This can be applied either before or after
1409  * canonicalizing it.) Throws error if not.
1410  */
1411 void
1413 {
1414  /* OK if the GUC exists. */
1415  if (find_option(name, false, true, DEBUG5) != NULL)
1416  return;
1417  /* Otherwise, it'd better be a valid custom GUC name. */
1418  (void) assignable_custom_variable_name(name, false, ERROR);
1419 }
1420 
1421 /*
1422  * Routine in charge of checking various states of a GUC.
1423  *
1424  * This performs two sanity checks. First, it checks that the initial
1425  * value of a GUC is the same when declared and when loaded to prevent
1426  * anybody looking at the C declarations of these GUCs from being fooled by
1427  * mismatched values. Second, it checks for incorrect flag combinations.
1428  *
1429  * The following validation rules apply for the values:
1430  * bool - can be false, otherwise must be same as the boot_val
1431  * int - can be 0, otherwise must be same as the boot_val
1432  * real - can be 0.0, otherwise must be same as the boot_val
1433  * string - can be NULL, otherwise must be strcmp equal to the boot_val
1434  * enum - must be same as the boot_val
1435  */
1436 #ifdef USE_ASSERT_CHECKING
1437 static bool
1438 check_GUC_init(struct config_generic *gconf)
1439 {
1440  /* Checks on values */
1441  switch (gconf->vartype)
1442  {
1443  case PGC_BOOL:
1444  {
1445  struct config_bool *conf = (struct config_bool *) gconf;
1446 
1447  if (*conf->variable && !conf->boot_val)
1448  {
1449  elog(LOG, "GUC (PGC_BOOL) %s, boot_val=%d, C-var=%d",
1450  conf->gen.name, conf->boot_val, *conf->variable);
1451  return false;
1452  }
1453  break;
1454  }
1455  case PGC_INT:
1456  {
1457  struct config_int *conf = (struct config_int *) gconf;
1458 
1459  if (*conf->variable != 0 && *conf->variable != conf->boot_val)
1460  {
1461  elog(LOG, "GUC (PGC_INT) %s, boot_val=%d, C-var=%d",
1462  conf->gen.name, conf->boot_val, *conf->variable);
1463  return false;
1464  }
1465  break;
1466  }
1467  case PGC_REAL:
1468  {
1469  struct config_real *conf = (struct config_real *) gconf;
1470 
1471  if (*conf->variable != 0.0 && *conf->variable != conf->boot_val)
1472  {
1473  elog(LOG, "GUC (PGC_REAL) %s, boot_val=%g, C-var=%g",
1474  conf->gen.name, conf->boot_val, *conf->variable);
1475  return false;
1476  }
1477  break;
1478  }
1479  case PGC_STRING:
1480  {
1481  struct config_string *conf = (struct config_string *) gconf;
1482 
1483  if (*conf->variable != NULL &&
1484  (conf->boot_val == NULL ||
1485  strcmp(*conf->variable, conf->boot_val) != 0))
1486  {
1487  elog(LOG, "GUC (PGC_STRING) %s, boot_val=%s, C-var=%s",
1488  conf->gen.name, conf->boot_val ? conf->boot_val : "<null>", *conf->variable);
1489  return false;
1490  }
1491  break;
1492  }
1493  case PGC_ENUM:
1494  {
1495  struct config_enum *conf = (struct config_enum *) gconf;
1496 
1497  if (*conf->variable != conf->boot_val)
1498  {
1499  elog(LOG, "GUC (PGC_ENUM) %s, boot_val=%d, C-var=%d",
1500  conf->gen.name, conf->boot_val, *conf->variable);
1501  return false;
1502  }
1503  break;
1504  }
1505  }
1506 
1507  /* Flag combinations */
1508 
1509  /*
1510  * GUC_NO_SHOW_ALL requires GUC_NOT_IN_SAMPLE, as a parameter not part of
1511  * SHOW ALL should not be hidden in postgresql.conf.sample.
1512  */
1513  if ((gconf->flags & GUC_NO_SHOW_ALL) &&
1514  !(gconf->flags & GUC_NOT_IN_SAMPLE))
1515  {
1516  elog(LOG, "GUC %s flags: NO_SHOW_ALL and !NOT_IN_SAMPLE",
1517  gconf->name);
1518  return false;
1519  }
1520 
1521  return true;
1522 }
1523 #endif
1524 
1525 /*
1526  * Initialize GUC options during program startup.
1527  *
1528  * Note that we cannot read the config file yet, since we have not yet
1529  * processed command-line switches.
1530  */
1531 void
1533 {
1534  HASH_SEQ_STATUS status;
1535  GUCHashEntry *hentry;
1536 
1537  /*
1538  * Before log_line_prefix could possibly receive a nonempty setting, make
1539  * sure that timezone processing is minimally alive (see elog.c).
1540  */
1542 
1543  /*
1544  * Create GUCMemoryContext and build hash table of all GUC variables.
1545  */
1547 
1548  /*
1549  * Load all variables with their compiled-in defaults, and initialize
1550  * status fields as needed.
1551  */
1552  hash_seq_init(&status, guc_hashtab);
1553  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
1554  {
1555  /* Check mapping between initial and default value */
1556  Assert(check_GUC_init(hentry->gucvar));
1557 
1558  InitializeOneGUCOption(hentry->gucvar);
1559  }
1560 
1561  reporting_enabled = false;
1562 
1563  /*
1564  * Prevent any attempt to override the transaction modes from
1565  * non-interactive sources.
1566  */
1567  SetConfigOption("transaction_isolation", "read committed",
1569  SetConfigOption("transaction_read_only", "no",
1571  SetConfigOption("transaction_deferrable", "no",
1573 
1574  /*
1575  * For historical reasons, some GUC parameters can receive defaults from
1576  * environment variables. Process those settings.
1577  */
1579 }
1580 
1581 /*
1582  * Assign any GUC values that can come from the server's environment.
1583  *
1584  * This is called from InitializeGUCOptions, and also from ProcessConfigFile
1585  * to deal with the possibility that a setting has been removed from
1586  * postgresql.conf and should now get a value from the environment.
1587  * (The latter is a kludge that should probably go away someday; if so,
1588  * fold this back into InitializeGUCOptions.)
1589  */
1590 static void
1592 {
1593  char *env;
1594  long stack_rlimit;
1595 
1596  env = getenv("PGPORT");
1597  if (env != NULL)
1599 
1600  env = getenv("PGDATESTYLE");
1601  if (env != NULL)
1602  SetConfigOption("datestyle", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
1603 
1604  env = getenv("PGCLIENTENCODING");
1605  if (env != NULL)
1606  SetConfigOption("client_encoding", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
1607 
1608  /*
1609  * rlimit isn't exactly an "environment variable", but it behaves about
1610  * the same. If we can identify the platform stack depth rlimit, increase
1611  * default stack depth setting up to whatever is safe (but at most 2MB).
1612  * Report the value's source as PGC_S_DYNAMIC_DEFAULT if it's 2MB, or as
1613  * PGC_S_ENV_VAR if it's reflecting the rlimit limit.
1614  */
1615  stack_rlimit = get_stack_depth_rlimit();
1616  if (stack_rlimit > 0)
1617  {
1618  long new_limit = (stack_rlimit - STACK_DEPTH_SLOP) / 1024L;
1619 
1620  if (new_limit > 100)
1621  {
1622  GucSource source;
1623  char limbuf[16];
1624 
1625  if (new_limit < 2048)
1627  else
1628  {
1629  new_limit = 2048;
1631  }
1632  snprintf(limbuf, sizeof(limbuf), "%ld", new_limit);
1633  SetConfigOption("max_stack_depth", limbuf,
1635  }
1636  }
1637 }
1638 
1639 /*
1640  * Initialize one GUC option variable to its compiled-in default.
1641  *
1642  * Note: the reason for calling check_hooks is not that we think the boot_val
1643  * might fail, but that the hooks might wish to compute an "extra" struct.
1644  */
1645 static void
1647 {
1648  gconf->status = 0;
1649  gconf->source = PGC_S_DEFAULT;
1650  gconf->reset_source = PGC_S_DEFAULT;
1651  gconf->scontext = PGC_INTERNAL;
1652  gconf->reset_scontext = PGC_INTERNAL;
1653  gconf->srole = BOOTSTRAP_SUPERUSERID;
1654  gconf->reset_srole = BOOTSTRAP_SUPERUSERID;
1655  gconf->stack = NULL;
1656  gconf->extra = NULL;
1657  gconf->last_reported = NULL;
1658  gconf->sourcefile = NULL;
1659  gconf->sourceline = 0;
1660 
1661  switch (gconf->vartype)
1662  {
1663  case PGC_BOOL:
1664  {
1665  struct config_bool *conf = (struct config_bool *) gconf;
1666  bool newval = conf->boot_val;
1667  void *extra = NULL;
1668 
1669  if (!call_bool_check_hook(conf, &newval, &extra,
1670  PGC_S_DEFAULT, LOG))
1671  elog(FATAL, "failed to initialize %s to %d",
1672  conf->gen.name, (int) newval);
1673  if (conf->assign_hook)
1674  conf->assign_hook(newval, extra);
1675  *conf->variable = conf->reset_val = newval;
1676  conf->gen.extra = conf->reset_extra = extra;
1677  break;
1678  }
1679  case PGC_INT:
1680  {
1681  struct config_int *conf = (struct config_int *) gconf;
1682  int newval = conf->boot_val;
1683  void *extra = NULL;
1684 
1685  Assert(newval >= conf->min);
1686  Assert(newval <= conf->max);
1687  if (!call_int_check_hook(conf, &newval, &extra,
1688  PGC_S_DEFAULT, LOG))
1689  elog(FATAL, "failed to initialize %s to %d",
1690  conf->gen.name, newval);
1691  if (conf->assign_hook)
1692  conf->assign_hook(newval, extra);
1693  *conf->variable = conf->reset_val = newval;
1694  conf->gen.extra = conf->reset_extra = extra;
1695  break;
1696  }
1697  case PGC_REAL:
1698  {
1699  struct config_real *conf = (struct config_real *) gconf;
1700  double newval = conf->boot_val;
1701  void *extra = NULL;
1702 
1703  Assert(newval >= conf->min);
1704  Assert(newval <= conf->max);
1705  if (!call_real_check_hook(conf, &newval, &extra,
1706  PGC_S_DEFAULT, LOG))
1707  elog(FATAL, "failed to initialize %s to %g",
1708  conf->gen.name, newval);
1709  if (conf->assign_hook)
1710  conf->assign_hook(newval, extra);
1711  *conf->variable = conf->reset_val = newval;
1712  conf->gen.extra = conf->reset_extra = extra;
1713  break;
1714  }
1715  case PGC_STRING:
1716  {
1717  struct config_string *conf = (struct config_string *) gconf;
1718  char *newval;
1719  void *extra = NULL;
1720 
1721  /* non-NULL boot_val must always get strdup'd */
1722  if (conf->boot_val != NULL)
1723  newval = guc_strdup(FATAL, conf->boot_val);
1724  else
1725  newval = NULL;
1726 
1727  if (!call_string_check_hook(conf, &newval, &extra,
1728  PGC_S_DEFAULT, LOG))
1729  elog(FATAL, "failed to initialize %s to \"%s\"",
1730  conf->gen.name, newval ? newval : "");
1731  if (conf->assign_hook)
1732  conf->assign_hook(newval, extra);
1733  *conf->variable = conf->reset_val = newval;
1734  conf->gen.extra = conf->reset_extra = extra;
1735  break;
1736  }
1737  case PGC_ENUM:
1738  {
1739  struct config_enum *conf = (struct config_enum *) gconf;
1740  int newval = conf->boot_val;
1741  void *extra = NULL;
1742 
1743  if (!call_enum_check_hook(conf, &newval, &extra,
1744  PGC_S_DEFAULT, LOG))
1745  elog(FATAL, "failed to initialize %s to %d",
1746  conf->gen.name, newval);
1747  if (conf->assign_hook)
1748  conf->assign_hook(newval, extra);
1749  *conf->variable = conf->reset_val = newval;
1750  conf->gen.extra = conf->reset_extra = extra;
1751  break;
1752  }
1753  }
1754 }
1755 
1756 /*
1757  * Summarily remove a GUC variable from any linked lists it's in.
1758  *
1759  * We use this in cases where the variable is about to be deleted or reset.
1760  * These aren't common operations, so it's okay if this is a bit slow.
1761  */
1762 static void
1764 {
1765  if (gconf->source != PGC_S_DEFAULT)
1766  dlist_delete(&gconf->nondef_link);
1767  if (gconf->stack != NULL)
1769  if (gconf->status & GUC_NEEDS_REPORT)
1771 }
1772 
1773 
1774 /*
1775  * Select the configuration files and data directory to be used, and
1776  * do the initial read of postgresql.conf.
1777  *
1778  * This is called after processing command-line switches.
1779  * userDoption is the -D switch value if any (NULL if unspecified).
1780  * progname is just for use in error messages.
1781  *
1782  * Returns true on success; on failure, prints a suitable error message
1783  * to stderr and returns false.
1784  */
1785 bool
1786 SelectConfigFiles(const char *userDoption, const char *progname)
1787 {
1788  char *configdir;
1789  char *fname;
1790  bool fname_is_malloced;
1791  struct stat stat_buf;
1792  struct config_string *data_directory_rec;
1793 
1794  /* configdir is -D option, or $PGDATA if no -D */
1795  if (userDoption)
1796  configdir = make_absolute_path(userDoption);
1797  else
1798  configdir = make_absolute_path(getenv("PGDATA"));
1799 
1800  if (configdir && stat(configdir, &stat_buf) != 0)
1801  {
1802  write_stderr("%s: could not access directory \"%s\": %m\n",
1803  progname,
1804  configdir);
1805  if (errno == ENOENT)
1806  write_stderr("Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n");
1807  return false;
1808  }
1809 
1810  /*
1811  * Find the configuration file: if config_file was specified on the
1812  * command line, use it, else use configdir/postgresql.conf. In any case
1813  * ensure the result is an absolute path, so that it will be interpreted
1814  * the same way by future backends.
1815  */
1816  if (ConfigFileName)
1817  {
1819  fname_is_malloced = true;
1820  }
1821  else if (configdir)
1822  {
1823  fname = guc_malloc(FATAL,
1824  strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
1825  sprintf(fname, "%s/%s", configdir, CONFIG_FILENAME);
1826  fname_is_malloced = false;
1827  }
1828  else
1829  {
1830  write_stderr("%s does not know where to find the server configuration file.\n"
1831  "You must specify the --config-file or -D invocation "
1832  "option or set the PGDATA environment variable.\n",
1833  progname);
1834  return false;
1835  }
1836 
1837  /*
1838  * Set the ConfigFileName GUC variable to its final value, ensuring that
1839  * it can't be overridden later.
1840  */
1841  SetConfigOption("config_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1842 
1843  if (fname_is_malloced)
1844  free(fname);
1845  else
1846  guc_free(fname);
1847 
1848  /*
1849  * Now read the config file for the first time.
1850  */
1851  if (stat(ConfigFileName, &stat_buf) != 0)
1852  {
1853  write_stderr("%s: could not access the server configuration file \"%s\": %m\n",
1855  free(configdir);
1856  return false;
1857  }
1858 
1859  /*
1860  * Read the configuration file for the first time. This time only the
1861  * data_directory parameter is picked up to determine the data directory,
1862  * so that we can read the PG_AUTOCONF_FILENAME file next time.
1863  */
1865 
1866  /*
1867  * If the data_directory GUC variable has been set, use that as DataDir;
1868  * otherwise use configdir if set; else punt.
1869  *
1870  * Note: SetDataDir will copy and absolute-ize its argument, so we don't
1871  * have to.
1872  */
1873  data_directory_rec = (struct config_string *)
1874  find_option("data_directory", false, false, PANIC);
1875  if (*data_directory_rec->variable)
1876  SetDataDir(*data_directory_rec->variable);
1877  else if (configdir)
1878  SetDataDir(configdir);
1879  else
1880  {
1881  write_stderr("%s does not know where to find the database system data.\n"
1882  "This can be specified as data_directory in \"%s\", "
1883  "or by the -D invocation option, or by the "
1884  "PGDATA environment variable.\n",
1886  return false;
1887  }
1888 
1889  /*
1890  * Reflect the final DataDir value back into the data_directory GUC var.
1891  * (If you are wondering why we don't just make them a single variable,
1892  * it's because the EXEC_BACKEND case needs DataDir to be transmitted to
1893  * child backends specially. XXX is that still true? Given that we now
1894  * chdir to DataDir, EXEC_BACKEND can read the config file without knowing
1895  * DataDir in advance.)
1896  */
1898 
1899  /*
1900  * Now read the config file a second time, allowing any settings in the
1901  * PG_AUTOCONF_FILENAME file to take effect. (This is pretty ugly, but
1902  * since we have to determine the DataDir before we can find the autoconf
1903  * file, the alternatives seem worse.)
1904  */
1906 
1907  /*
1908  * If timezone_abbreviations wasn't set in the configuration file, install
1909  * the default value. We do it this way because we can't safely install a
1910  * "real" value until my_exec_path is set, which may not have happened
1911  * when InitializeGUCOptions runs, so the bootstrap default value cannot
1912  * be the real desired default.
1913  */
1915 
1916  /*
1917  * Figure out where pg_hba.conf is, and make sure the path is absolute.
1918  */
1919  if (HbaFileName)
1920  {
1922  fname_is_malloced = true;
1923  }
1924  else if (configdir)
1925  {
1926  fname = guc_malloc(FATAL,
1927  strlen(configdir) + strlen(HBA_FILENAME) + 2);
1928  sprintf(fname, "%s/%s", configdir, HBA_FILENAME);
1929  fname_is_malloced = false;
1930  }
1931  else
1932  {
1933  write_stderr("%s does not know where to find the \"hba\" configuration file.\n"
1934  "This can be specified as \"hba_file\" in \"%s\", "
1935  "or by the -D invocation option, or by the "
1936  "PGDATA environment variable.\n",
1938  return false;
1939  }
1940  SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1941 
1942  if (fname_is_malloced)
1943  free(fname);
1944  else
1945  guc_free(fname);
1946 
1947  /*
1948  * Likewise for pg_ident.conf.
1949  */
1950  if (IdentFileName)
1951  {
1953  fname_is_malloced = true;
1954  }
1955  else if (configdir)
1956  {
1957  fname = guc_malloc(FATAL,
1958  strlen(configdir) + strlen(IDENT_FILENAME) + 2);
1959  sprintf(fname, "%s/%s", configdir, IDENT_FILENAME);
1960  fname_is_malloced = false;
1961  }
1962  else
1963  {
1964  write_stderr("%s does not know where to find the \"ident\" configuration file.\n"
1965  "This can be specified as \"ident_file\" in \"%s\", "
1966  "or by the -D invocation option, or by the "
1967  "PGDATA environment variable.\n",
1969  return false;
1970  }
1971  SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1972 
1973  if (fname_is_malloced)
1974  free(fname);
1975  else
1976  guc_free(fname);
1977 
1978  free(configdir);
1979 
1980  return true;
1981 }
1982 
1983 /*
1984  * pg_timezone_abbrev_initialize --- set default value if not done already
1985  *
1986  * This is called after initial loading of postgresql.conf. If no
1987  * timezone_abbreviations setting was found therein, select default.
1988  * If a non-default value is already installed, nothing will happen.
1989  *
1990  * This can also be called from ProcessConfigFile to establish the default
1991  * value after a postgresql.conf entry for it is removed.
1992  */
1993 static void
1995 {
1996  SetConfigOption("timezone_abbreviations", "Default",
1998 }
1999 
2000 
2001 /*
2002  * Reset all options to their saved default values (implements RESET ALL)
2003  */
2004 void
2006 {
2007  dlist_mutable_iter iter;
2008 
2009  /* We need only consider GUCs not already at PGC_S_DEFAULT */
2011  {
2012  struct config_generic *gconf = dlist_container(struct config_generic,
2013  nondef_link, iter.cur);
2014 
2015  /* Don't reset non-SET-able values */
2016  if (gconf->context != PGC_SUSET &&
2017  gconf->context != PGC_USERSET)
2018  continue;
2019  /* Don't reset if special exclusion from RESET ALL */
2020  if (gconf->flags & GUC_NO_RESET_ALL)
2021  continue;
2022  /* No need to reset if wasn't SET */
2023  if (gconf->source <= PGC_S_OVERRIDE)
2024  continue;
2025 
2026  /* Save old value to support transaction abort */
2028 
2029  switch (gconf->vartype)
2030  {
2031  case PGC_BOOL:
2032  {
2033  struct config_bool *conf = (struct config_bool *) gconf;
2034 
2035  if (conf->assign_hook)
2036  conf->assign_hook(conf->reset_val,
2037  conf->reset_extra);
2038  *conf->variable = conf->reset_val;
2039  set_extra_field(&conf->gen, &conf->gen.extra,
2040  conf->reset_extra);
2041  break;
2042  }
2043  case PGC_INT:
2044  {
2045  struct config_int *conf = (struct config_int *) gconf;
2046 
2047  if (conf->assign_hook)
2048  conf->assign_hook(conf->reset_val,
2049  conf->reset_extra);
2050  *conf->variable = conf->reset_val;
2051  set_extra_field(&conf->gen, &conf->gen.extra,
2052  conf->reset_extra);
2053  break;
2054  }
2055  case PGC_REAL:
2056  {
2057  struct config_real *conf = (struct config_real *) gconf;
2058 
2059  if (conf->assign_hook)
2060  conf->assign_hook(conf->reset_val,
2061  conf->reset_extra);
2062  *conf->variable = conf->reset_val;
2063  set_extra_field(&conf->gen, &conf->gen.extra,
2064  conf->reset_extra);
2065  break;
2066  }
2067  case PGC_STRING:
2068  {
2069  struct config_string *conf = (struct config_string *) gconf;
2070 
2071  if (conf->assign_hook)
2072  conf->assign_hook(conf->reset_val,
2073  conf->reset_extra);
2074  set_string_field(conf, conf->variable, conf->reset_val);
2075  set_extra_field(&conf->gen, &conf->gen.extra,
2076  conf->reset_extra);
2077  break;
2078  }
2079  case PGC_ENUM:
2080  {
2081  struct config_enum *conf = (struct config_enum *) gconf;
2082 
2083  if (conf->assign_hook)
2084  conf->assign_hook(conf->reset_val,
2085  conf->reset_extra);
2086  *conf->variable = conf->reset_val;
2087  set_extra_field(&conf->gen, &conf->gen.extra,
2088  conf->reset_extra);
2089  break;
2090  }
2091  }
2092 
2093  set_guc_source(gconf, gconf->reset_source);
2094  gconf->scontext = gconf->reset_scontext;
2095  gconf->srole = gconf->reset_srole;
2096 
2097  if ((gconf->flags & GUC_REPORT) && !(gconf->status & GUC_NEEDS_REPORT))
2098  {
2099  gconf->status |= GUC_NEEDS_REPORT;
2101  }
2102  }
2103 }
2104 
2105 
2106 /*
2107  * Apply a change to a GUC variable's "source" field.
2108  *
2109  * Use this rather than just assigning, to ensure that the variable's
2110  * membership in guc_nondef_list is updated correctly.
2111  */
2112 static void
2113 set_guc_source(struct config_generic *gconf, GucSource newsource)
2114 {
2115  /* Adjust nondef list membership if appropriate for change */
2116  if (gconf->source == PGC_S_DEFAULT)
2117  {
2118  if (newsource != PGC_S_DEFAULT)
2120  }
2121  else
2122  {
2123  if (newsource == PGC_S_DEFAULT)
2124  dlist_delete(&gconf->nondef_link);
2125  }
2126  /* Now update the source field */
2127  gconf->source = newsource;
2128 }
2129 
2130 
2131 /*
2132  * push_old_value
2133  * Push previous state during transactional assignment to a GUC variable.
2134  */
2135 static void
2137 {
2138  GucStack *stack;
2139 
2140  /* If we're not inside a nest level, do nothing */
2141  if (GUCNestLevel == 0)
2142  return;
2143 
2144  /* Do we already have a stack entry of the current nest level? */
2145  stack = gconf->stack;
2146  if (stack && stack->nest_level >= GUCNestLevel)
2147  {
2148  /* Yes, so adjust its state if necessary */
2149  Assert(stack->nest_level == GUCNestLevel);
2150  switch (action)
2151  {
2152  case GUC_ACTION_SET:
2153  /* SET overrides any prior action at same nest level */
2154  if (stack->state == GUC_SET_LOCAL)
2155  {
2156  /* must discard old masked value */
2157  discard_stack_value(gconf, &stack->masked);
2158  }
2159  stack->state = GUC_SET;
2160  break;
2161  case GUC_ACTION_LOCAL:
2162  if (stack->state == GUC_SET)
2163  {
2164  /* SET followed by SET LOCAL, remember SET's value */
2165  stack->masked_scontext = gconf->scontext;
2166  stack->masked_srole = gconf->srole;
2167  set_stack_value(gconf, &stack->masked);
2168  stack->state = GUC_SET_LOCAL;
2169  }
2170  /* in all other cases, no change to stack entry */
2171  break;
2172  case GUC_ACTION_SAVE:
2173  /* Could only have a prior SAVE of same variable */
2174  Assert(stack->state == GUC_SAVE);
2175  break;
2176  }
2177  return;
2178  }
2179 
2180  /*
2181  * Push a new stack entry
2182  *
2183  * We keep all the stack entries in TopTransactionContext for simplicity.
2184  */
2186  sizeof(GucStack));
2187 
2188  stack->prev = gconf->stack;
2189  stack->nest_level = GUCNestLevel;
2190  switch (action)
2191  {
2192  case GUC_ACTION_SET:
2193  stack->state = GUC_SET;
2194  break;
2195  case GUC_ACTION_LOCAL:
2196  stack->state = GUC_LOCAL;
2197  break;
2198  case GUC_ACTION_SAVE:
2199  stack->state = GUC_SAVE;
2200  break;
2201  }
2202  stack->source = gconf->source;
2203  stack->scontext = gconf->scontext;
2204  stack->srole = gconf->srole;
2205  set_stack_value(gconf, &stack->prior);
2206 
2207  if (gconf->stack == NULL)
2209  gconf->stack = stack;
2210 }
2211 
2212 
2213 /*
2214  * Do GUC processing at main transaction start.
2215  */
2216 void
2218 {
2219  /*
2220  * The nest level should be 0 between transactions; if it isn't, somebody
2221  * didn't call AtEOXact_GUC, or called it with the wrong nestLevel. We
2222  * throw a warning but make no other effort to clean up.
2223  */
2224  if (GUCNestLevel != 0)
2225  elog(WARNING, "GUC nest level = %d at transaction start",
2226  GUCNestLevel);
2227  GUCNestLevel = 1;
2228 }
2229 
2230 /*
2231  * Enter a new nesting level for GUC values. This is called at subtransaction
2232  * start, and when entering a function that has proconfig settings, and in
2233  * some other places where we want to set GUC variables transiently.
2234  * NOTE we must not risk error here, else subtransaction start will be unhappy.
2235  */
2236 int
2238 {
2239  return ++GUCNestLevel;
2240 }
2241 
2242 /*
2243  * Set search_path to a fixed value for maintenance operations. No effect
2244  * during bootstrap, when the search_path is already set to a fixed value and
2245  * cannot be changed.
2246  */
2247 void
2249 {
2252  PGC_S_SESSION, GUC_ACTION_SAVE, true, 0, false);
2253 }
2254 
2255 /*
2256  * Do GUC processing at transaction or subtransaction commit or abort, or
2257  * when exiting a function that has proconfig settings, or when undoing a
2258  * transient assignment to some GUC variables. (The name is thus a bit of
2259  * a misnomer; perhaps it should be ExitGUCNestLevel or some such.)
2260  * During abort, we discard all GUC settings that were applied at nesting
2261  * levels >= nestLevel. nestLevel == 1 corresponds to the main transaction.
2262  */
2263 void
2264 AtEOXact_GUC(bool isCommit, int nestLevel)
2265 {
2266  slist_mutable_iter iter;
2267 
2268  /*
2269  * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
2270  * abort, if there is a failure during transaction start before
2271  * AtStart_GUC is called.
2272  */
2273  Assert(nestLevel > 0 &&
2274  (nestLevel <= GUCNestLevel ||
2275  (nestLevel == GUCNestLevel + 1 && !isCommit)));
2276 
2277  /* We need only process GUCs having nonempty stacks */
2279  {
2280  struct config_generic *gconf = slist_container(struct config_generic,
2281  stack_link, iter.cur);
2282  GucStack *stack;
2283 
2284  /*
2285  * Process and pop each stack entry within the nest level. To simplify
2286  * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
2287  * we allow failure exit from code that uses a local nest level to be
2288  * recovered at the surrounding transaction or subtransaction abort;
2289  * so there could be more than one stack entry to pop.
2290  */
2291  while ((stack = gconf->stack) != NULL &&
2292  stack->nest_level >= nestLevel)
2293  {
2294  GucStack *prev = stack->prev;
2295  bool restorePrior = false;
2296  bool restoreMasked = false;
2297  bool changed;
2298 
2299  /*
2300  * In this next bit, if we don't set either restorePrior or
2301  * restoreMasked, we must "discard" any unwanted fields of the
2302  * stack entries to avoid leaking memory. If we do set one of
2303  * those flags, unused fields will be cleaned up after restoring.
2304  */
2305  if (!isCommit) /* if abort, always restore prior value */
2306  restorePrior = true;
2307  else if (stack->state == GUC_SAVE)
2308  restorePrior = true;
2309  else if (stack->nest_level == 1)
2310  {
2311  /* transaction commit */
2312  if (stack->state == GUC_SET_LOCAL)
2313  restoreMasked = true;
2314  else if (stack->state == GUC_SET)
2315  {
2316  /* we keep the current active value */
2317  discard_stack_value(gconf, &stack->prior);
2318  }
2319  else /* must be GUC_LOCAL */
2320  restorePrior = true;
2321  }
2322  else if (prev == NULL ||
2323  prev->nest_level < stack->nest_level - 1)
2324  {
2325  /* decrement entry's level and do not pop it */
2326  stack->nest_level--;
2327  continue;
2328  }
2329  else
2330  {
2331  /*
2332  * We have to merge this stack entry into prev. See README for
2333  * discussion of this bit.
2334  */
2335  switch (stack->state)
2336  {
2337  case GUC_SAVE:
2338  Assert(false); /* can't get here */
2339  break;
2340 
2341  case GUC_SET:
2342  /* next level always becomes SET */
2343  discard_stack_value(gconf, &stack->prior);
2344  if (prev->state == GUC_SET_LOCAL)
2345  discard_stack_value(gconf, &prev->masked);
2346  prev->state = GUC_SET;
2347  break;
2348 
2349  case GUC_LOCAL:
2350  if (prev->state == GUC_SET)
2351  {
2352  /* LOCAL migrates down */
2353  prev->masked_scontext = stack->scontext;
2354  prev->masked_srole = stack->srole;
2355  prev->masked = stack->prior;
2356  prev->state = GUC_SET_LOCAL;
2357  }
2358  else
2359  {
2360  /* else just forget this stack level */
2361  discard_stack_value(gconf, &stack->prior);
2362  }
2363  break;
2364 
2365  case GUC_SET_LOCAL:
2366  /* prior state at this level no longer wanted */
2367  discard_stack_value(gconf, &stack->prior);
2368  /* copy down the masked state */
2370  prev->masked_srole = stack->masked_srole;
2371  if (prev->state == GUC_SET_LOCAL)
2372  discard_stack_value(gconf, &prev->masked);
2373  prev->masked = stack->masked;
2374  prev->state = GUC_SET_LOCAL;
2375  break;
2376  }
2377  }
2378 
2379  changed = false;
2380 
2381  if (restorePrior || restoreMasked)
2382  {
2383  /* Perform appropriate restoration of the stacked value */
2384  config_var_value newvalue;
2385  GucSource newsource;
2386  GucContext newscontext;
2387  Oid newsrole;
2388 
2389  if (restoreMasked)
2390  {
2391  newvalue = stack->masked;
2392  newsource = PGC_S_SESSION;
2393  newscontext = stack->masked_scontext;
2394  newsrole = stack->masked_srole;
2395  }
2396  else
2397  {
2398  newvalue = stack->prior;
2399  newsource = stack->source;
2400  newscontext = stack->scontext;
2401  newsrole = stack->srole;
2402  }
2403 
2404  switch (gconf->vartype)
2405  {
2406  case PGC_BOOL:
2407  {
2408  struct config_bool *conf = (struct config_bool *) gconf;
2409  bool newval = newvalue.val.boolval;
2410  void *newextra = newvalue.extra;
2411 
2412  if (*conf->variable != newval ||
2413  conf->gen.extra != newextra)
2414  {
2415  if (conf->assign_hook)
2416  conf->assign_hook(newval, newextra);
2417  *conf->variable = newval;
2418  set_extra_field(&conf->gen, &conf->gen.extra,
2419  newextra);
2420  changed = true;
2421  }
2422  break;
2423  }
2424  case PGC_INT:
2425  {
2426  struct config_int *conf = (struct config_int *) gconf;
2427  int newval = newvalue.val.intval;
2428  void *newextra = newvalue.extra;
2429 
2430  if (*conf->variable != newval ||
2431  conf->gen.extra != newextra)
2432  {
2433  if (conf->assign_hook)
2434  conf->assign_hook(newval, newextra);
2435  *conf->variable = newval;
2436  set_extra_field(&conf->gen, &conf->gen.extra,
2437  newextra);
2438  changed = true;
2439  }
2440  break;
2441  }
2442  case PGC_REAL:
2443  {
2444  struct config_real *conf = (struct config_real *) gconf;
2445  double newval = newvalue.val.realval;
2446  void *newextra = newvalue.extra;
2447 
2448  if (*conf->variable != newval ||
2449  conf->gen.extra != newextra)
2450  {
2451  if (conf->assign_hook)
2452  conf->assign_hook(newval, newextra);
2453  *conf->variable = newval;
2454  set_extra_field(&conf->gen, &conf->gen.extra,
2455  newextra);
2456  changed = true;
2457  }
2458  break;
2459  }
2460  case PGC_STRING:
2461  {
2462  struct config_string *conf = (struct config_string *) gconf;
2463  char *newval = newvalue.val.stringval;
2464  void *newextra = newvalue.extra;
2465 
2466  if (*conf->variable != newval ||
2467  conf->gen.extra != newextra)
2468  {
2469  if (conf->assign_hook)
2470  conf->assign_hook(newval, newextra);
2471  set_string_field(conf, conf->variable, newval);
2472  set_extra_field(&conf->gen, &conf->gen.extra,
2473  newextra);
2474  changed = true;
2475  }
2476 
2477  /*
2478  * Release stacked values if not used anymore. We
2479  * could use discard_stack_value() here, but since
2480  * we have type-specific code anyway, might as
2481  * well inline it.
2482  */
2483  set_string_field(conf, &stack->prior.val.stringval, NULL);
2484  set_string_field(conf, &stack->masked.val.stringval, NULL);
2485  break;
2486  }
2487  case PGC_ENUM:
2488  {
2489  struct config_enum *conf = (struct config_enum *) gconf;
2490  int newval = newvalue.val.enumval;
2491  void *newextra = newvalue.extra;
2492 
2493  if (*conf->variable != newval ||
2494  conf->gen.extra != newextra)
2495  {
2496  if (conf->assign_hook)
2497  conf->assign_hook(newval, newextra);
2498  *conf->variable = newval;
2499  set_extra_field(&conf->gen, &conf->gen.extra,
2500  newextra);
2501  changed = true;
2502  }
2503  break;
2504  }
2505  }
2506 
2507  /*
2508  * Release stacked extra values if not used anymore.
2509  */
2510  set_extra_field(gconf, &(stack->prior.extra), NULL);
2511  set_extra_field(gconf, &(stack->masked.extra), NULL);
2512 
2513  /* And restore source information */
2514  set_guc_source(gconf, newsource);
2515  gconf->scontext = newscontext;
2516  gconf->srole = newsrole;
2517  }
2518 
2519  /*
2520  * Pop the GUC's state stack; if it's now empty, remove the GUC
2521  * from guc_stack_list.
2522  */
2523  gconf->stack = prev;
2524  if (prev == NULL)
2525  slist_delete_current(&iter);
2526  pfree(stack);
2527 
2528  /* Report new value if we changed it */
2529  if (changed && (gconf->flags & GUC_REPORT) &&
2530  !(gconf->status & GUC_NEEDS_REPORT))
2531  {
2532  gconf->status |= GUC_NEEDS_REPORT;
2534  }
2535  } /* end of stack-popping loop */
2536  }
2537 
2538  /* Update nesting level */
2539  GUCNestLevel = nestLevel - 1;
2540 }
2541 
2542 
2543 /*
2544  * Start up automatic reporting of changes to variables marked GUC_REPORT.
2545  * This is executed at completion of backend startup.
2546  */
2547 void
2549 {
2550  HASH_SEQ_STATUS status;
2551  GUCHashEntry *hentry;
2552 
2553  /*
2554  * Don't do anything unless talking to an interactive frontend.
2555  */
2557  return;
2558 
2559  reporting_enabled = true;
2560 
2561  /*
2562  * Hack for in_hot_standby: set the GUC value true if appropriate. This
2563  * is kind of an ugly place to do it, but there's few better options.
2564  *
2565  * (This could be out of date by the time we actually send it, in which
2566  * case the next ReportChangedGUCOptions call will send a duplicate
2567  * report.)
2568  */
2569  if (RecoveryInProgress())
2570  SetConfigOption("in_hot_standby", "true",
2572 
2573  /* Transmit initial values of interesting variables */
2574  hash_seq_init(&status, guc_hashtab);
2575  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
2576  {
2577  struct config_generic *conf = hentry->gucvar;
2578 
2579  if (conf->flags & GUC_REPORT)
2580  ReportGUCOption(conf);
2581  }
2582 }
2583 
2584 /*
2585  * ReportChangedGUCOptions: report recently-changed GUC_REPORT variables
2586  *
2587  * This is called just before we wait for a new client query.
2588  *
2589  * By handling things this way, we ensure that a ParameterStatus message
2590  * is sent at most once per variable per query, even if the variable
2591  * changed multiple times within the query. That's quite possible when
2592  * using features such as function SET clauses. Function SET clauses
2593  * also tend to cause values to change intraquery but eventually revert
2594  * to their prevailing values; ReportGUCOption is responsible for avoiding
2595  * redundant reports in such cases.
2596  */
2597 void
2599 {
2600  slist_mutable_iter iter;
2601 
2602  /* Quick exit if not (yet) enabled */
2603  if (!reporting_enabled)
2604  return;
2605 
2606  /*
2607  * Since in_hot_standby isn't actually changed by normal GUC actions, we
2608  * need a hack to check whether a new value needs to be reported to the
2609  * client. For speed, we rely on the assumption that it can never
2610  * transition from false to true.
2611  */
2613  SetConfigOption("in_hot_standby", "false",
2615 
2616  /* Transmit new values of interesting variables */
2618  {
2619  struct config_generic *conf = slist_container(struct config_generic,
2620  report_link, iter.cur);
2621 
2622  Assert((conf->flags & GUC_REPORT) && (conf->status & GUC_NEEDS_REPORT));
2623  ReportGUCOption(conf);
2624  conf->status &= ~GUC_NEEDS_REPORT;
2625  slist_delete_current(&iter);
2626  }
2627 }
2628 
2629 /*
2630  * ReportGUCOption: if appropriate, transmit option value to frontend
2631  *
2632  * We need not transmit the value if it's the same as what we last
2633  * transmitted.
2634  */
2635 static void
2637 {
2638  char *val = ShowGUCOption(record, false);
2639 
2640  if (record->last_reported == NULL ||
2641  strcmp(val, record->last_reported) != 0)
2642  {
2643  StringInfoData msgbuf;
2644 
2646  pq_sendstring(&msgbuf, record->name);
2647  pq_sendstring(&msgbuf, val);
2648  pq_endmessage(&msgbuf);
2649 
2650  /*
2651  * We need a long-lifespan copy. If guc_strdup() fails due to OOM,
2652  * we'll set last_reported to NULL and thereby possibly make a
2653  * duplicate report later.
2654  */
2655  guc_free(record->last_reported);
2656  record->last_reported = guc_strdup(LOG, val);
2657  }
2658 
2659  pfree(val);
2660 }
2661 
2662 /*
2663  * Convert a value from one of the human-friendly units ("kB", "min" etc.)
2664  * to the given base unit. 'value' and 'unit' are the input value and unit
2665  * to convert from (there can be trailing spaces in the unit string).
2666  * The converted value is stored in *base_value.
2667  * It's caller's responsibility to round off the converted value as necessary
2668  * and check for out-of-range.
2669  *
2670  * Returns true on success, false if the input unit is not recognized.
2671  */
2672 static bool
2673 convert_to_base_unit(double value, const char *unit,
2674  int base_unit, double *base_value)
2675 {
2676  char unitstr[MAX_UNIT_LEN + 1];
2677  int unitlen;
2678  const unit_conversion *table;
2679  int i;
2680 
2681  /* extract unit string to compare to table entries */
2682  unitlen = 0;
2683  while (*unit != '\0' && !isspace((unsigned char) *unit) &&
2684  unitlen < MAX_UNIT_LEN)
2685  unitstr[unitlen++] = *(unit++);
2686  unitstr[unitlen] = '\0';
2687  /* allow whitespace after unit */
2688  while (isspace((unsigned char) *unit))
2689  unit++;
2690  if (*unit != '\0')
2691  return false; /* unit too long, or garbage after it */
2692 
2693  /* now search the appropriate table */
2694  if (base_unit & GUC_UNIT_MEMORY)
2696  else
2698 
2699  for (i = 0; *table[i].unit; i++)
2700  {
2701  if (base_unit == table[i].base_unit &&
2702  strcmp(unitstr, table[i].unit) == 0)
2703  {
2704  double cvalue = value * table[i].multiplier;
2705 
2706  /*
2707  * If the user gave a fractional value such as "30.1GB", round it
2708  * off to the nearest multiple of the next smaller unit, if there
2709  * is one.
2710  */
2711  if (*table[i + 1].unit &&
2712  base_unit == table[i + 1].base_unit)
2713  cvalue = rint(cvalue / table[i + 1].multiplier) *
2714  table[i + 1].multiplier;
2715 
2716  *base_value = cvalue;
2717  return true;
2718  }
2719  }
2720  return false;
2721 }
2722 
2723 /*
2724  * Convert an integer value in some base unit to a human-friendly unit.
2725  *
2726  * The output unit is chosen so that it's the greatest unit that can represent
2727  * the value without loss. For example, if the base unit is GUC_UNIT_KB, 1024
2728  * is converted to 1 MB, but 1025 is represented as 1025 kB.
2729  */
2730 static void
2731 convert_int_from_base_unit(int64 base_value, int base_unit,
2732  int64 *value, const char **unit)
2733 {
2734  const unit_conversion *table;
2735  int i;
2736 
2737  *unit = NULL;
2738 
2739  if (base_unit & GUC_UNIT_MEMORY)
2741  else
2743 
2744  for (i = 0; *table[i].unit; i++)
2745  {
2746  if (base_unit == table[i].base_unit)
2747  {
2748  /*
2749  * Accept the first conversion that divides the value evenly. We
2750  * assume that the conversions for each base unit are ordered from
2751  * greatest unit to the smallest!
2752  */
2753  if (table[i].multiplier <= 1.0 ||
2754  base_value % (int64) table[i].multiplier == 0)
2755  {
2756  *value = (int64) rint(base_value / table[i].multiplier);
2757  *unit = table[i].unit;
2758  break;
2759  }
2760  }
2761  }
2762 
2763  Assert(*unit != NULL);
2764 }
2765 
2766 /*
2767  * Convert a floating-point value in some base unit to a human-friendly unit.
2768  *
2769  * Same as above, except we have to do the math a bit differently, and
2770  * there's a possibility that we don't find any exact divisor.
2771  */
2772 static void
2773 convert_real_from_base_unit(double base_value, int base_unit,
2774  double *value, const char **unit)
2775 {
2776  const unit_conversion *table;
2777  int i;
2778 
2779  *unit = NULL;
2780 
2781  if (base_unit & GUC_UNIT_MEMORY)
2783  else
2785 
2786  for (i = 0; *table[i].unit; i++)
2787  {
2788  if (base_unit == table[i].base_unit)
2789  {
2790  /*
2791  * Accept the first conversion that divides the value evenly; or
2792  * if there is none, use the smallest (last) target unit.
2793  *
2794  * What we actually care about here is whether snprintf with "%g"
2795  * will print the value as an integer, so the obvious test of
2796  * "*value == rint(*value)" is too strict; roundoff error might
2797  * make us choose an unreasonably small unit. As a compromise,
2798  * accept a divisor that is within 1e-8 of producing an integer.
2799  */
2800  *value = base_value / table[i].multiplier;
2801  *unit = table[i].unit;
2802  if (*value > 0 &&
2803  fabs((rint(*value) / *value) - 1.0) <= 1e-8)
2804  break;
2805  }
2806  }
2807 
2808  Assert(*unit != NULL);
2809 }
2810 
2811 /*
2812  * Return the name of a GUC's base unit (e.g. "ms") given its flags.
2813  * Return NULL if the GUC is unitless.
2814  */
2815 const char *
2817 {
2818  switch (flags & GUC_UNIT)
2819  {
2820  case 0:
2821  return NULL; /* GUC has no units */
2822  case GUC_UNIT_BYTE:
2823  return "B";
2824  case GUC_UNIT_KB:
2825  return "kB";
2826  case GUC_UNIT_MB:
2827  return "MB";
2828  case GUC_UNIT_BLOCKS:
2829  {
2830  static char bbuf[8];
2831 
2832  /* initialize if first time through */
2833  if (bbuf[0] == '\0')
2834  snprintf(bbuf, sizeof(bbuf), "%dkB", BLCKSZ / 1024);
2835  return bbuf;
2836  }
2837  case GUC_UNIT_XBLOCKS:
2838  {
2839  static char xbuf[8];
2840 
2841  /* initialize if first time through */
2842  if (xbuf[0] == '\0')
2843  snprintf(xbuf, sizeof(xbuf), "%dkB", XLOG_BLCKSZ / 1024);
2844  return xbuf;
2845  }
2846  case GUC_UNIT_MS:
2847  return "ms";
2848  case GUC_UNIT_S:
2849  return "s";
2850  case GUC_UNIT_MIN:
2851  return "min";
2852  default:
2853  elog(ERROR, "unrecognized GUC units value: %d",
2854  flags & GUC_UNIT);
2855  return NULL;
2856  }
2857 }
2858 
2859 
2860 /*
2861  * Try to parse value as an integer. The accepted formats are the
2862  * usual decimal, octal, or hexadecimal formats, as well as floating-point
2863  * formats (which will be rounded to integer after any units conversion).
2864  * Optionally, the value can be followed by a unit name if "flags" indicates
2865  * a unit is allowed.
2866  *
2867  * If the string parses okay, return true, else false.
2868  * If okay and result is not NULL, return the value in *result.
2869  * If not okay and hintmsg is not NULL, *hintmsg is set to a suitable
2870  * HINT message, or NULL if no hint provided.
2871  */
2872 bool
2873 parse_int(const char *value, int *result, int flags, const char **hintmsg)
2874 {
2875  /*
2876  * We assume here that double is wide enough to represent any integer
2877  * value with adequate precision.
2878  */
2879  double val;
2880  char *endptr;
2881 
2882  /* To suppress compiler warnings, always set output params */
2883  if (result)
2884  *result = 0;
2885  if (hintmsg)
2886  *hintmsg = NULL;
2887 
2888  /*
2889  * Try to parse as an integer (allowing octal or hex input). If the
2890  * conversion stops at a decimal point or 'e', or overflows, re-parse as
2891  * float. This should work fine as long as we have no unit names starting
2892  * with 'e'. If we ever do, the test could be extended to check for a
2893  * sign or digit after 'e', but for now that's unnecessary.
2894  */
2895  errno = 0;
2896  val = strtol(value, &endptr, 0);
2897  if (*endptr == '.' || *endptr == 'e' || *endptr == 'E' ||
2898  errno == ERANGE)
2899  {
2900  errno = 0;
2901  val = strtod(value, &endptr);
2902  }
2903 
2904  if (endptr == value || errno == ERANGE)
2905  return false; /* no HINT for these cases */
2906 
2907  /* reject NaN (infinities will fail range check below) */
2908  if (isnan(val))
2909  return false; /* treat same as syntax error; no HINT */
2910 
2911  /* allow whitespace between number and unit */
2912  while (isspace((unsigned char) *endptr))
2913  endptr++;
2914 
2915  /* Handle possible unit */
2916  if (*endptr != '\0')
2917  {
2918  if ((flags & GUC_UNIT) == 0)
2919  return false; /* this setting does not accept a unit */
2920 
2922  endptr, (flags & GUC_UNIT),
2923  &val))
2924  {
2925  /* invalid unit, or garbage after the unit; set hint and fail. */
2926  if (hintmsg)
2927  {
2928  if (flags & GUC_UNIT_MEMORY)
2929  *hintmsg = memory_units_hint;
2930  else
2931  *hintmsg = time_units_hint;
2932  }
2933  return false;
2934  }
2935  }
2936 
2937  /* Round to int, then check for overflow */
2938  val = rint(val);
2939 
2940  if (val > INT_MAX || val < INT_MIN)
2941  {
2942  if (hintmsg)
2943  *hintmsg = gettext_noop("Value exceeds integer range.");
2944  return false;
2945  }
2946 
2947  if (result)
2948  *result = (int) val;
2949  return true;
2950 }
2951 
2952 /*
2953  * Try to parse value as a floating point number in the usual format.
2954  * Optionally, the value can be followed by a unit name if "flags" indicates
2955  * a unit is allowed.
2956  *
2957  * If the string parses okay, return true, else false.
2958  * If okay and result is not NULL, return the value in *result.
2959  * If not okay and hintmsg is not NULL, *hintmsg is set to a suitable
2960  * HINT message, or NULL if no hint provided.
2961  */
2962 bool
2963 parse_real(const char *value, double *result, int flags, const char **hintmsg)
2964 {
2965  double val;
2966  char *endptr;
2967 
2968  /* To suppress compiler warnings, always set output params */
2969  if (result)
2970  *result = 0;
2971  if (hintmsg)
2972  *hintmsg = NULL;
2973 
2974  errno = 0;
2975  val = strtod(value, &endptr);
2976 
2977  if (endptr == value || errno == ERANGE)
2978  return false; /* no HINT for these cases */
2979 
2980  /* reject NaN (infinities will fail range checks later) */
2981  if (isnan(val))
2982  return false; /* treat same as syntax error; no HINT */
2983 
2984  /* allow whitespace between number and unit */
2985  while (isspace((unsigned char) *endptr))
2986  endptr++;
2987 
2988  /* Handle possible unit */
2989  if (*endptr != '\0')
2990  {
2991  if ((flags & GUC_UNIT) == 0)
2992  return false; /* this setting does not accept a unit */
2993 
2995  endptr, (flags & GUC_UNIT),
2996  &val))
2997  {
2998  /* invalid unit, or garbage after the unit; set hint and fail. */
2999  if (hintmsg)
3000  {
3001  if (flags & GUC_UNIT_MEMORY)
3002  *hintmsg = memory_units_hint;
3003  else
3004  *hintmsg = time_units_hint;
3005  }
3006  return false;
3007  }
3008  }
3009 
3010  if (result)
3011  *result = val;
3012  return true;
3013 }
3014 
3015 
3016 /*
3017  * Lookup the name for an enum option with the selected value.
3018  * Should only ever be called with known-valid values, so throws
3019  * an elog(ERROR) if the enum option is not found.
3020  *
3021  * The returned string is a pointer to static data and not
3022  * allocated for modification.
3023  */
3024 const char *
3026 {
3027  const struct config_enum_entry *entry;
3028 
3029  for (entry = record->options; entry && entry->name; entry++)
3030  {
3031  if (entry->val == val)
3032  return entry->name;
3033  }
3034 
3035  elog(ERROR, "could not find enum option %d for %s",
3036  val, record->gen.name);
3037  return NULL; /* silence compiler */
3038 }
3039 
3040 
3041 /*
3042  * Lookup the value for an enum option with the selected name
3043  * (case-insensitive).
3044  * If the enum option is found, sets the retval value and returns
3045  * true. If it's not found, return false and retval is set to 0.
3046  */
3047 bool
3048 config_enum_lookup_by_name(struct config_enum *record, const char *value,
3049  int *retval)
3050 {
3051  const struct config_enum_entry *entry;
3052 
3053  for (entry = record->options; entry && entry->name; entry++)
3054  {
3055  if (pg_strcasecmp(value, entry->name) == 0)
3056  {
3057  *retval = entry->val;
3058  return true;
3059  }
3060  }
3061 
3062  *retval = 0;
3063  return false;
3064 }
3065 
3066 
3067 /*
3068  * Return a palloc'd string listing all the available options for an enum GUC
3069  * (excluding hidden ones), separated by the given separator.
3070  * If prefix is non-NULL, it is added before the first enum value.
3071  * If suffix is non-NULL, it is added to the end of the string.
3072  */
3073 char *
3074 config_enum_get_options(struct config_enum *record, const char *prefix,
3075  const char *suffix, const char *separator)
3076 {
3077  const struct config_enum_entry *entry;
3078  StringInfoData retstr;
3079  int seplen;
3080 
3081  initStringInfo(&retstr);
3082  appendStringInfoString(&retstr, prefix);
3083 
3084  seplen = strlen(separator);
3085  for (entry = record->options; entry && entry->name; entry++)
3086  {
3087  if (!entry->hidden)
3088  {
3089  appendStringInfoString(&retstr, entry->name);
3090  appendBinaryStringInfo(&retstr, separator, seplen);
3091  }
3092  }
3093 
3094  /*
3095  * All the entries may have been hidden, leaving the string empty if no
3096  * prefix was given. This indicates a broken GUC setup, since there is no
3097  * use for an enum without any values, so we just check to make sure we
3098  * don't write to invalid memory instead of actually trying to do
3099  * something smart with it.
3100  */
3101  if (retstr.len >= seplen)
3102  {
3103  /* Replace final separator */
3104  retstr.data[retstr.len - seplen] = '\0';
3105  retstr.len -= seplen;
3106  }
3107 
3108  appendStringInfoString(&retstr, suffix);
3109 
3110  return retstr.data;
3111 }
3112 
3113 /*
3114  * Parse and validate a proposed value for the specified configuration
3115  * parameter.
3116  *
3117  * This does built-in checks (such as range limits for an integer parameter)
3118  * and also calls any check hook the parameter may have.
3119  *
3120  * record: GUC variable's info record
3121  * name: variable name (should match the record of course)
3122  * value: proposed value, as a string
3123  * source: identifies source of value (check hooks may need this)
3124  * elevel: level to log any error reports at
3125  * newval: on success, converted parameter value is returned here
3126  * newextra: on success, receives any "extra" data returned by check hook
3127  * (caller must initialize *newextra to NULL)
3128  *
3129  * Returns true if OK, false if not (or throws error, if elevel >= ERROR)
3130  */
3131 static bool
3133  const char *name, const char *value,
3134  GucSource source, int elevel,
3135  union config_var_val *newval, void **newextra)
3136 {
3137  switch (record->vartype)
3138  {
3139  case PGC_BOOL:
3140  {
3141  struct config_bool *conf = (struct config_bool *) record;
3142 
3143  if (!parse_bool(value, &newval->boolval))
3144  {
3145  ereport(elevel,
3146  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3147  errmsg("parameter \"%s\" requires a Boolean value",
3148  name)));
3149  return false;
3150  }
3151 
3152  if (!call_bool_check_hook(conf, &newval->boolval, newextra,
3153  source, elevel))
3154  return false;
3155  }
3156  break;
3157  case PGC_INT:
3158  {
3159  struct config_int *conf = (struct config_int *) record;
3160  const char *hintmsg;
3161 
3162  if (!parse_int(value, &newval->intval,
3163  conf->gen.flags, &hintmsg))
3164  {
3165  ereport(elevel,
3166  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3167  errmsg("invalid value for parameter \"%s\": \"%s\"",
3168  name, value),
3169  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3170  return false;
3171  }
3172 
3173  if (newval->intval < conf->min || newval->intval > conf->max)
3174  {
3175  const char *unit = get_config_unit_name(conf->gen.flags);
3176 
3177  ereport(elevel,
3178  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3179  errmsg("%d%s%s is outside the valid range for parameter \"%s\" (%d .. %d)",
3180  newval->intval,
3181  unit ? " " : "",
3182  unit ? unit : "",
3183  name,
3184  conf->min, conf->max)));
3185  return false;
3186  }
3187 
3188  if (!call_int_check_hook(conf, &newval->intval, newextra,
3189  source, elevel))
3190  return false;
3191  }
3192  break;
3193  case PGC_REAL:
3194  {
3195  struct config_real *conf = (struct config_real *) record;
3196  const char *hintmsg;
3197 
3198  if (!parse_real(value, &newval->realval,
3199  conf->gen.flags, &hintmsg))
3200  {
3201  ereport(elevel,
3202  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3203  errmsg("invalid value for parameter \"%s\": \"%s\"",
3204  name, value),
3205  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3206  return false;
3207  }
3208 
3209  if (newval->realval < conf->min || newval->realval > conf->max)
3210  {
3211  const char *unit = get_config_unit_name(conf->gen.flags);
3212 
3213  ereport(elevel,
3214  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3215  errmsg("%g%s%s is outside the valid range for parameter \"%s\" (%g .. %g)",
3216  newval->realval,
3217  unit ? " " : "",
3218  unit ? unit : "",
3219  name,
3220  conf->min, conf->max)));
3221  return false;
3222  }
3223 
3224  if (!call_real_check_hook(conf, &newval->realval, newextra,
3225  source, elevel))
3226  return false;
3227  }
3228  break;
3229  case PGC_STRING:
3230  {
3231  struct config_string *conf = (struct config_string *) record;
3232 
3233  /*
3234  * The value passed by the caller could be transient, so we
3235  * always strdup it.
3236  */
3237  newval->stringval = guc_strdup(elevel, value);
3238  if (newval->stringval == NULL)
3239  return false;
3240 
3241  /*
3242  * The only built-in "parsing" check we have is to apply
3243  * truncation if GUC_IS_NAME.
3244  */
3245  if (conf->gen.flags & GUC_IS_NAME)
3246  truncate_identifier(newval->stringval,
3247  strlen(newval->stringval),
3248  true);
3249 
3250  if (!call_string_check_hook(conf, &newval->stringval, newextra,
3251  source, elevel))
3252  {
3253  guc_free(newval->stringval);
3254  newval->stringval = NULL;
3255  return false;
3256  }
3257  }
3258  break;
3259  case PGC_ENUM:
3260  {
3261  struct config_enum *conf = (struct config_enum *) record;
3262 
3263  if (!config_enum_lookup_by_name(conf, value, &newval->enumval))
3264  {
3265  char *hintmsg;
3266 
3267  hintmsg = config_enum_get_options(conf,
3268  "Available values: ",
3269  ".", ", ");
3270 
3271  ereport(elevel,
3272  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3273  errmsg("invalid value for parameter \"%s\": \"%s\"",
3274  name, value),
3275  hintmsg ? errhint("%s", _(hintmsg)) : 0));
3276 
3277  if (hintmsg)
3278  pfree(hintmsg);
3279  return false;
3280  }
3281 
3282  if (!call_enum_check_hook(conf, &newval->enumval, newextra,
3283  source, elevel))
3284  return false;
3285  }
3286  break;
3287  }
3288 
3289  return true;
3290 }
3291 
3292 
3293 /*
3294  * set_config_option: sets option `name' to given value.
3295  *
3296  * The value should be a string, which will be parsed and converted to
3297  * the appropriate data type. The context and source parameters indicate
3298  * in which context this function is being called, so that it can apply the
3299  * access restrictions properly.
3300  *
3301  * If value is NULL, set the option to its default value (normally the
3302  * reset_val, but if source == PGC_S_DEFAULT we instead use the boot_val).
3303  *
3304  * action indicates whether to set the value globally in the session, locally
3305  * to the current top transaction, or just for the duration of a function call.
3306  *
3307  * If changeVal is false then don't really set the option but do all
3308  * the checks to see if it would work.
3309  *
3310  * elevel should normally be passed as zero, allowing this function to make
3311  * its standard choice of ereport level. However some callers need to be
3312  * able to override that choice; they should pass the ereport level to use.
3313  *
3314  * is_reload should be true only when called from read_nondefault_variables()
3315  * or RestoreGUCState(), where we are trying to load some other process's
3316  * GUC settings into a new process.
3317  *
3318  * Return value:
3319  * +1: the value is valid and was successfully applied.
3320  * 0: the name or value is invalid (but see below).
3321  * -1: the value was not applied because of context, priority, or changeVal.
3322  *
3323  * If there is an error (non-existing option, invalid value) then an
3324  * ereport(ERROR) is thrown *unless* this is called for a source for which
3325  * we don't want an ERROR (currently, those are defaults, the config file,
3326  * and per-database or per-user settings, as well as callers who specify
3327  * a less-than-ERROR elevel). In those cases we write a suitable error
3328  * message via ereport() and return 0.
3329  *
3330  * See also SetConfigOption for an external interface.
3331  */
3332 int
3333 set_config_option(const char *name, const char *value,
3334  GucContext context, GucSource source,
3335  GucAction action, bool changeVal, int elevel,
3336  bool is_reload)
3337 {
3338  Oid srole;
3339 
3340  /*
3341  * Non-interactive sources should be treated as having all privileges,
3342  * except for PGC_S_CLIENT. Note in particular that this is true for
3343  * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3344  * privilege check was done when the pg_db_role_setting entry was made.
3345  */
3347  srole = GetUserId();
3348  else
3349  srole = BOOTSTRAP_SUPERUSERID;
3350 
3351  return set_config_with_handle(name, NULL, value,
3352  context, source, srole,
3353  action, changeVal, elevel,
3354  is_reload);
3355 }
3356 
3357 /*
3358  * set_config_option_ext: sets option `name' to given value.
3359  *
3360  * This API adds the ability to explicitly specify which role OID
3361  * is considered to be setting the value. Most external callers can use
3362  * set_config_option() and let it determine that based on the GucSource,
3363  * but there are a few that are supplying a value that was determined
3364  * in some special way and need to override the decision. Also, when
3365  * restoring a previously-assigned value, it's important to supply the
3366  * same role OID that set the value originally; so all guc.c callers
3367  * that are doing that type of thing need to call this directly.
3368  *
3369  * Generally, srole should be GetUserId() when the source is a SQL operation,
3370  * or BOOTSTRAP_SUPERUSERID if the source is a config file or similar.
3371  */
3372 int
3373 set_config_option_ext(const char *name, const char *value,
3374  GucContext context, GucSource source, Oid srole,
3375  GucAction action, bool changeVal, int elevel,
3376  bool is_reload)
3377 {
3378  return set_config_with_handle(name, NULL, value,
3379  context, source, srole,
3380  action, changeVal, elevel,
3381  is_reload);
3382 }
3383 
3384 
3385 /*
3386  * set_config_with_handle: takes an optional 'handle' argument, which can be
3387  * obtained by the caller from get_config_handle().
3388  *
3389  * This should be used by callers which repeatedly set the same config
3390  * option(s), and want to avoid the overhead of a hash lookup each time.
3391  */
3392 int
3394  const char *value,
3395  GucContext context, GucSource source, Oid srole,
3396  GucAction action, bool changeVal, int elevel,
3397  bool is_reload)
3398 {
3399  struct config_generic *record;
3400  union config_var_val newval_union;
3401  void *newextra = NULL;
3402  bool prohibitValueChange = false;
3403  bool makeDefault;
3404 
3405  if (elevel == 0)
3406  {
3407  if (source == PGC_S_DEFAULT || source == PGC_S_FILE)
3408  {
3409  /*
3410  * To avoid cluttering the log, only the postmaster bleats loudly
3411  * about problems with the config file.
3412  */
3413  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
3414  }
3415  else if (source == PGC_S_GLOBAL ||
3416  source == PGC_S_DATABASE ||
3417  source == PGC_S_USER ||
3419  elevel = WARNING;
3420  else
3421  elevel = ERROR;
3422  }
3423 
3424  /*
3425  * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
3426  * because the current worker will also pop the change. We're probably
3427  * dealing with a function having a proconfig entry. Only the function's
3428  * body should observe the change, and peer workers do not share in the
3429  * execution of a function call started by this worker.
3430  *
3431  * Other changes might need to affect other workers, so forbid them.
3432  */
3433  if (IsInParallelMode() && changeVal && action != GUC_ACTION_SAVE)
3434  {
3435  ereport(elevel,
3436  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3437  errmsg("cannot set parameters during a parallel operation")));
3438  return -1;
3439  }
3440 
3441  /* if handle is specified, no need to look up option */
3442  if (!handle)
3443  {
3444  record = find_option(name, true, false, elevel);
3445  if (record == NULL)
3446  return 0;
3447  }
3448  else
3449  record = handle;
3450 
3451  /*
3452  * Check if the option can be set at this time. See guc.h for the precise
3453  * rules.
3454  */
3455  switch (record->context)
3456  {
3457  case PGC_INTERNAL:
3458  if (context != PGC_INTERNAL)
3459  {
3460  ereport(elevel,
3461  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3462  errmsg("parameter \"%s\" cannot be changed",
3463  name)));
3464  return 0;
3465  }
3466  break;
3467  case PGC_POSTMASTER:
3468  if (context == PGC_SIGHUP)
3469  {
3470  /*
3471  * We are re-reading a PGC_POSTMASTER variable from
3472  * postgresql.conf. We can't change the setting, so we should
3473  * give a warning if the DBA tries to change it. However,
3474  * because of variant formats, canonicalization by check
3475  * hooks, etc, we can't just compare the given string directly
3476  * to what's stored. Set a flag to check below after we have
3477  * the final storable value.
3478  */
3479  prohibitValueChange = true;
3480  }
3481  else if (context != PGC_POSTMASTER)
3482  {
3483  ereport(elevel,
3484  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3485  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3486  name)));
3487  return 0;
3488  }
3489  break;
3490  case PGC_SIGHUP:
3491  if (context != PGC_SIGHUP && context != PGC_POSTMASTER)
3492  {
3493  ereport(elevel,
3494  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3495  errmsg("parameter \"%s\" cannot be changed now",
3496  name)));
3497  return 0;
3498  }
3499 
3500  /*
3501  * Hmm, the idea of the SIGHUP context is "ought to be global, but
3502  * can be changed after postmaster start". But there's nothing
3503  * that prevents a crafty administrator from sending SIGHUP
3504  * signals to individual backends only.
3505  */
3506  break;
3507  case PGC_SU_BACKEND:
3508  if (context == PGC_BACKEND)
3509  {
3510  /*
3511  * Check whether the requesting user has been granted
3512  * privilege to set this GUC.
3513  */
3514  AclResult aclresult;
3515 
3516  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3517  if (aclresult != ACLCHECK_OK)
3518  {
3519  /* No granted privilege */
3520  ereport(elevel,
3521  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3522  errmsg("permission denied to set parameter \"%s\"",
3523  name)));
3524  return 0;
3525  }
3526  }
3527  /* fall through to process the same as PGC_BACKEND */
3528  /* FALLTHROUGH */
3529  case PGC_BACKEND:
3530  if (context == PGC_SIGHUP)
3531  {
3532  /*
3533  * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
3534  * the config file, we want to accept the new value in the
3535  * postmaster (whence it will propagate to
3536  * subsequently-started backends), but ignore it in existing
3537  * backends. This is a tad klugy, but necessary because we
3538  * don't re-read the config file during backend start.
3539  *
3540  * However, if changeVal is false then plow ahead anyway since
3541  * we are trying to find out if the value is potentially good,
3542  * not actually use it.
3543  *
3544  * In EXEC_BACKEND builds, this works differently: we load all
3545  * non-default settings from the CONFIG_EXEC_PARAMS file
3546  * during backend start. In that case we must accept
3547  * PGC_SIGHUP settings, so as to have the same value as if
3548  * we'd forked from the postmaster. This can also happen when
3549  * using RestoreGUCState() within a background worker that
3550  * needs to have the same settings as the user backend that
3551  * started it. is_reload will be true when either situation
3552  * applies.
3553  */
3554  if (IsUnderPostmaster && changeVal && !is_reload)
3555  return -1;
3556  }
3557  else if (context != PGC_POSTMASTER &&
3558  context != PGC_BACKEND &&
3559  context != PGC_SU_BACKEND &&
3560  source != PGC_S_CLIENT)
3561  {
3562  ereport(elevel,
3563  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3564  errmsg("parameter \"%s\" cannot be set after connection start",
3565  name)));
3566  return 0;
3567  }
3568  break;
3569  case PGC_SUSET:
3570  if (context == PGC_USERSET || context == PGC_BACKEND)
3571  {
3572  /*
3573  * Check whether the requesting user has been granted
3574  * privilege to set this GUC.
3575  */
3576  AclResult aclresult;
3577 
3578  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3579  if (aclresult != ACLCHECK_OK)
3580  {
3581  /* No granted privilege */
3582  ereport(elevel,
3583  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3584  errmsg("permission denied to set parameter \"%s\"",
3585  name)));
3586  return 0;
3587  }
3588  }
3589  break;
3590  case PGC_USERSET:
3591  /* always okay */
3592  break;
3593  }
3594 
3595  /*
3596  * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
3597  * security restriction context. We can reject this regardless of the GUC
3598  * context or source, mainly because sources that it might be reasonable
3599  * to override for won't be seen while inside a function.
3600  *
3601  * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
3602  * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
3603  * An exception might be made if the reset value is assumed to be "safe".
3604  *
3605  * Note: this flag is currently used for "session_authorization" and
3606  * "role". We need to prohibit changing these inside a local userid
3607  * context because when we exit it, GUC won't be notified, leaving things
3608  * out of sync. (This could be fixed by forcing a new GUC nesting level,
3609  * but that would change behavior in possibly-undesirable ways.) Also, we
3610  * prohibit changing these in a security-restricted operation because
3611  * otherwise RESET could be used to regain the session user's privileges.
3612  */
3613  if (record->flags & GUC_NOT_WHILE_SEC_REST)
3614  {
3615  if (InLocalUserIdChange())
3616  {
3617  /*
3618  * Phrasing of this error message is historical, but it's the most
3619  * common case.
3620  */
3621  ereport(elevel,
3622  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3623  errmsg("cannot set parameter \"%s\" within security-definer function",
3624  name)));
3625  return 0;
3626  }
3628  {
3629  ereport(elevel,
3630  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3631  errmsg("cannot set parameter \"%s\" within security-restricted operation",
3632  name)));
3633  return 0;
3634  }
3635  }
3636 
3637  /* Disallow resetting and saving GUC_NO_RESET values */
3638  if (record->flags & GUC_NO_RESET)
3639  {
3640  if (value == NULL)
3641  {
3642  ereport(elevel,
3643  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3644  errmsg("parameter \"%s\" cannot be reset", name)));
3645  return 0;
3646  }
3647  if (action == GUC_ACTION_SAVE)
3648  {
3649  ereport(elevel,
3650  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3651  errmsg("parameter \"%s\" cannot be set locally in functions",
3652  name)));
3653  return 0;
3654  }
3655  }
3656 
3657  /*
3658  * Should we set reset/stacked values? (If so, the behavior is not
3659  * transactional.) This is done either when we get a default value from
3660  * the database's/user's/client's default settings or when we reset a
3661  * value to its default.
3662  */
3663  makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
3664  ((value != NULL) || source == PGC_S_DEFAULT);
3665 
3666  /*
3667  * Ignore attempted set if overridden by previously processed setting.
3668  * However, if changeVal is false then plow ahead anyway since we are
3669  * trying to find out if the value is potentially good, not actually use
3670  * it. Also keep going if makeDefault is true, since we may want to set
3671  * the reset/stacked values even if we can't set the variable itself.
3672  */
3673  if (record->source > source)
3674  {
3675  if (changeVal && !makeDefault)
3676  {
3677  elog(DEBUG3, "\"%s\": setting ignored because previous source is higher priority",
3678  name);
3679  return -1;
3680  }
3681  changeVal = false;
3682  }
3683 
3684  /*
3685  * Evaluate value and set variable.
3686  */
3687  switch (record->vartype)
3688  {
3689  case PGC_BOOL:
3690  {
3691  struct config_bool *conf = (struct config_bool *) record;
3692 
3693 #define newval (newval_union.boolval)
3694 
3695  if (value)
3696  {
3697  if (!parse_and_validate_value(record, name, value,
3698  source, elevel,
3699  &newval_union, &newextra))
3700  return 0;
3701  }
3702  else if (source == PGC_S_DEFAULT)
3703  {
3704  newval = conf->boot_val;
3705  if (!call_bool_check_hook(conf, &newval, &newextra,
3706  source, elevel))
3707  return 0;
3708  }
3709  else
3710  {
3711  newval = conf->reset_val;
3712  newextra = conf->reset_extra;
3713  source = conf->gen.reset_source;
3714  context = conf->gen.reset_scontext;
3715  srole = conf->gen.reset_srole;
3716  }
3717 
3718  if (prohibitValueChange)
3719  {
3720  /* Release newextra, unless it's reset_extra */
3721  if (newextra && !extra_field_used(&conf->gen, newextra))
3722  guc_free(newextra);
3723 
3724  if (*conf->variable != newval)
3725  {
3726  record->status |= GUC_PENDING_RESTART;
3727  ereport(elevel,
3728  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3729  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3730  name)));
3731  return 0;
3732  }
3733  record->status &= ~GUC_PENDING_RESTART;
3734  return -1;
3735  }
3736 
3737  if (changeVal)
3738  {
3739  /* Save old value to support transaction abort */
3740  if (!makeDefault)
3741  push_old_value(&conf->gen, action);
3742 
3743  if (conf->assign_hook)
3744  conf->assign_hook(newval, newextra);
3745  *conf->variable = newval;
3746  set_extra_field(&conf->gen, &conf->gen.extra,
3747  newextra);
3748  set_guc_source(&conf->gen, source);
3749  conf->gen.scontext = context;
3750  conf->gen.srole = srole;
3751  }
3752  if (makeDefault)
3753  {
3754  GucStack *stack;
3755 
3756  if (conf->gen.reset_source <= source)
3757  {
3758  conf->reset_val = newval;
3759  set_extra_field(&conf->gen, &conf->reset_extra,
3760  newextra);
3761  conf->gen.reset_source = source;
3762  conf->gen.reset_scontext = context;
3763  conf->gen.reset_srole = srole;
3764  }
3765  for (stack = conf->gen.stack; stack; stack = stack->prev)
3766  {
3767  if (stack->source <= source)
3768  {
3769  stack->prior.val.boolval = newval;
3770  set_extra_field(&conf->gen, &stack->prior.extra,
3771  newextra);
3772  stack->source = source;
3773  stack->scontext = context;
3774  stack->srole = srole;
3775  }
3776  }
3777  }
3778 
3779  /* Perhaps we didn't install newextra anywhere */
3780  if (newextra && !extra_field_used(&conf->gen, newextra))
3781  guc_free(newextra);
3782  break;
3783 
3784 #undef newval
3785  }
3786 
3787  case PGC_INT:
3788  {
3789  struct config_int *conf = (struct config_int *) record;
3790 
3791 #define newval (newval_union.intval)
3792 
3793  if (value)
3794  {
3795  if (!parse_and_validate_value(record, name, value,
3796  source, elevel,
3797  &newval_union, &newextra))
3798  return 0;
3799  }
3800  else if (source == PGC_S_DEFAULT)
3801  {
3802  newval = conf->boot_val;
3803  if (!call_int_check_hook(conf, &newval, &newextra,
3804  source, elevel))
3805  return 0;
3806  }
3807  else
3808  {
3809  newval = conf->reset_val;
3810  newextra = conf->reset_extra;
3811  source = conf->gen.reset_source;
3812  context = conf->gen.reset_scontext;
3813  srole = conf->gen.reset_srole;
3814  }
3815 
3816  if (prohibitValueChange)
3817  {
3818  /* Release newextra, unless it's reset_extra */
3819  if (newextra && !extra_field_used(&conf->gen, newextra))
3820  guc_free(newextra);
3821 
3822  if (*conf->variable != newval)
3823  {
3824  record->status |= GUC_PENDING_RESTART;
3825  ereport(elevel,
3826  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3827  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3828  name)));
3829  return 0;
3830  }
3831  record->status &= ~GUC_PENDING_RESTART;
3832  return -1;
3833  }
3834 
3835  if (changeVal)
3836  {
3837  /* Save old value to support transaction abort */
3838  if (!makeDefault)
3839  push_old_value(&conf->gen, action);
3840 
3841  if (conf->assign_hook)
3842  conf->assign_hook(newval, newextra);
3843  *conf->variable = newval;
3844  set_extra_field(&conf->gen, &conf->gen.extra,
3845  newextra);
3846  set_guc_source(&conf->gen, source);
3847  conf->gen.scontext = context;
3848  conf->gen.srole = srole;
3849  }
3850  if (makeDefault)
3851  {
3852  GucStack *stack;
3853 
3854  if (conf->gen.reset_source <= source)
3855  {
3856  conf->reset_val = newval;
3857  set_extra_field(&conf->gen, &conf->reset_extra,
3858  newextra);
3859  conf->gen.reset_source = source;
3860  conf->gen.reset_scontext = context;
3861  conf->gen.reset_srole = srole;
3862  }
3863  for (stack = conf->gen.stack; stack; stack = stack->prev)
3864  {
3865  if (stack->source <= source)
3866  {
3867  stack->prior.val.intval = newval;
3868  set_extra_field(&conf->gen, &stack->prior.extra,
3869  newextra);
3870  stack->source = source;
3871  stack->scontext = context;
3872  stack->srole = srole;
3873  }
3874  }
3875  }
3876 
3877  /* Perhaps we didn't install newextra anywhere */
3878  if (newextra && !extra_field_used(&conf->gen, newextra))
3879  guc_free(newextra);
3880  break;
3881 
3882 #undef newval
3883  }
3884 
3885  case PGC_REAL:
3886  {
3887  struct config_real *conf = (struct config_real *) record;
3888 
3889 #define newval (newval_union.realval)
3890 
3891  if (value)
3892  {
3893  if (!parse_and_validate_value(record, name, value,
3894  source, elevel,
3895  &newval_union, &newextra))
3896  return 0;
3897  }
3898  else if (source == PGC_S_DEFAULT)
3899  {
3900  newval = conf->boot_val;
3901  if (!call_real_check_hook(conf, &newval, &newextra,
3902  source, elevel))
3903  return 0;
3904  }
3905  else
3906  {
3907  newval = conf->reset_val;
3908  newextra = conf->reset_extra;
3909  source = conf->gen.reset_source;
3910  context = conf->gen.reset_scontext;
3911  srole = conf->gen.reset_srole;
3912  }
3913 
3914  if (prohibitValueChange)
3915  {
3916  /* Release newextra, unless it's reset_extra */
3917  if (newextra && !extra_field_used(&conf->gen, newextra))
3918  guc_free(newextra);
3919 
3920  if (*conf->variable != newval)
3921  {
3922  record->status |= GUC_PENDING_RESTART;
3923  ereport(elevel,
3924  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3925  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3926  name)));
3927  return 0;
3928  }
3929  record->status &= ~GUC_PENDING_RESTART;
3930  return -1;
3931  }
3932 
3933  if (changeVal)
3934  {
3935  /* Save old value to support transaction abort */
3936  if (!makeDefault)
3937  push_old_value(&conf->gen, action);
3938 
3939  if (conf->assign_hook)
3940  conf->assign_hook(newval, newextra);
3941  *conf->variable = newval;
3942  set_extra_field(&conf->gen, &conf->gen.extra,
3943  newextra);
3944  set_guc_source(&conf->gen, source);
3945  conf->gen.scontext = context;
3946  conf->gen.srole = srole;
3947  }
3948  if (makeDefault)
3949  {
3950  GucStack *stack;
3951 
3952  if (conf->gen.reset_source <= source)
3953  {
3954  conf->reset_val = newval;
3955  set_extra_field(&conf->gen, &conf->reset_extra,
3956  newextra);
3957  conf->gen.reset_source = source;
3958  conf->gen.reset_scontext = context;
3959  conf->gen.reset_srole = srole;
3960  }
3961  for (stack = conf->gen.stack; stack; stack = stack->prev)
3962  {
3963  if (stack->source <= source)
3964  {
3965  stack->prior.val.realval = newval;
3966  set_extra_field(&conf->gen, &stack->prior.extra,
3967  newextra);
3968  stack->source = source;
3969  stack->scontext = context;
3970  stack->srole = srole;
3971  }
3972  }
3973  }
3974 
3975  /* Perhaps we didn't install newextra anywhere */
3976  if (newextra && !extra_field_used(&conf->gen, newextra))
3977  guc_free(newextra);
3978  break;
3979 
3980 #undef newval
3981  }
3982 
3983  case PGC_STRING:
3984  {
3985  struct config_string *conf = (struct config_string *) record;
3986 
3987 #define newval (newval_union.stringval)
3988 
3989  if (value)
3990  {
3991  if (!parse_and_validate_value(record, name, value,
3992  source, elevel,
3993  &newval_union, &newextra))
3994  return 0;
3995  }
3996  else if (source == PGC_S_DEFAULT)
3997  {
3998  /* non-NULL boot_val must always get strdup'd */
3999  if (conf->boot_val != NULL)
4000  {
4001  newval = guc_strdup(elevel, conf->boot_val);
4002  if (newval == NULL)
4003  return 0;
4004  }
4005  else
4006  newval = NULL;
4007 
4008  if (!call_string_check_hook(conf, &newval, &newextra,
4009  source, elevel))
4010  {
4011  guc_free(newval);
4012  return 0;
4013  }
4014  }
4015  else
4016  {
4017  /*
4018  * strdup not needed, since reset_val is already under
4019  * guc.c's control
4020  */
4021  newval = conf->reset_val;
4022  newextra = conf->reset_extra;
4023  source = conf->gen.reset_source;
4024  context = conf->gen.reset_scontext;
4025  srole = conf->gen.reset_srole;
4026  }
4027 
4028  if (prohibitValueChange)
4029  {
4030  bool newval_different;
4031 
4032  /* newval shouldn't be NULL, so we're a bit sloppy here */
4033  newval_different = (*conf->variable == NULL ||
4034  newval == NULL ||
4035  strcmp(*conf->variable, newval) != 0);
4036 
4037  /* Release newval, unless it's reset_val */
4038  if (newval && !string_field_used(conf, newval))
4039  guc_free(newval);
4040  /* Release newextra, unless it's reset_extra */
4041  if (newextra && !extra_field_used(&conf->gen, newextra))
4042  guc_free(newextra);
4043 
4044  if (newval_different)
4045  {
4046  record->status |= GUC_PENDING_RESTART;
4047  ereport(elevel,
4048  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4049  errmsg("parameter \"%s\" cannot be changed without restarting the server",
4050  name)));
4051  return 0;
4052  }
4053  record->status &= ~GUC_PENDING_RESTART;
4054  return -1;
4055  }
4056 
4057  if (changeVal)
4058  {
4059  /* Save old value to support transaction abort */
4060  if (!makeDefault)
4061  push_old_value(&conf->gen, action);
4062 
4063  if (conf->assign_hook)
4064  conf->assign_hook(newval, newextra);
4065  set_string_field(conf, conf->variable, newval);
4066  set_extra_field(&conf->gen, &conf->gen.extra,
4067  newextra);
4068  set_guc_source(&conf->gen, source);
4069  conf->gen.scontext = context;
4070  conf->gen.srole = srole;
4071  }
4072 
4073  if (makeDefault)
4074  {
4075  GucStack *stack;
4076 
4077  if (conf->gen.reset_source <= source)
4078  {
4079  set_string_field(conf, &conf->reset_val, newval);
4080  set_extra_field(&conf->gen, &conf->reset_extra,
4081  newextra);
4082  conf->gen.reset_source = source;
4083  conf->gen.reset_scontext = context;
4084  conf->gen.reset_srole = srole;
4085  }
4086  for (stack = conf->gen.stack; stack; stack = stack->prev)
4087  {
4088  if (stack->source <= source)
4089  {
4090  set_string_field(conf, &stack->prior.val.stringval,
4091  newval);
4092  set_extra_field(&conf->gen, &stack->prior.extra,
4093  newextra);
4094  stack->source = source;
4095  stack->scontext = context;
4096  stack->srole = srole;
4097  }
4098  }
4099  }
4100 
4101  /* Perhaps we didn't install newval anywhere */
4102  if (newval && !string_field_used(conf, newval))
4103  guc_free(newval);
4104  /* Perhaps we didn't install newextra anywhere */
4105  if (newextra && !extra_field_used(&conf->gen, newextra))
4106  guc_free(newextra);
4107  break;
4108 
4109 #undef newval
4110  }
4111 
4112  case PGC_ENUM:
4113  {
4114  struct config_enum *conf = (struct config_enum *) record;
4115 
4116 #define newval (newval_union.enumval)
4117 
4118  if (value)
4119  {
4120  if (!parse_and_validate_value(record, name, value,
4121  source, elevel,
4122  &newval_union, &newextra))
4123  return 0;
4124  }
4125  else if (source == PGC_S_DEFAULT)
4126  {
4127  newval = conf->boot_val;
4128  if (!call_enum_check_hook(conf, &newval, &newextra,
4129  source, elevel))
4130  return 0;
4131  }
4132  else
4133  {
4134  newval = conf->reset_val;
4135  newextra = conf->reset_extra;
4136  source = conf->gen.reset_source;
4137  context = conf->gen.reset_scontext;
4138  srole = conf->gen.reset_srole;
4139  }
4140 
4141  if (prohibitValueChange)
4142  {
4143  /* Release newextra, unless it's reset_extra */
4144  if (newextra && !extra_field_used(&conf->gen, newextra))
4145  guc_free(newextra);
4146 
4147  if (*conf->variable != newval)
4148  {
4149  record->status |= GUC_PENDING_RESTART;
4150  ereport(elevel,
4151  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4152  errmsg("parameter \"%s\" cannot be changed without restarting the server",
4153  name)));
4154  return 0;
4155  }
4156  record->status &= ~GUC_PENDING_RESTART;
4157  return -1;
4158  }
4159 
4160  if (changeVal)
4161  {
4162  /* Save old value to support transaction abort */
4163  if (!makeDefault)
4164  push_old_value(&conf->gen, action);
4165 
4166  if (conf->assign_hook)
4167  conf->assign_hook(newval, newextra);
4168  *conf->variable = newval;
4169  set_extra_field(&conf->gen, &conf->gen.extra,
4170  newextra);
4171  set_guc_source(&conf->gen, source);
4172  conf->gen.scontext = context;
4173  conf->gen.srole = srole;
4174  }
4175  if (makeDefault)
4176  {
4177  GucStack *stack;
4178 
4179  if (conf->gen.reset_source <= source)
4180  {
4181  conf->reset_val = newval;
4182  set_extra_field(&conf->gen, &conf->reset_extra,
4183  newextra);
4184  conf->gen.reset_source = source;
4185  conf->gen.reset_scontext = context;
4186  conf->gen.reset_srole = srole;
4187  }
4188  for (stack = conf->gen.stack; stack; stack = stack->prev)
4189  {
4190  if (stack->source <= source)
4191  {
4192  stack->prior.val.enumval = newval;
4193  set_extra_field(&conf->gen, &stack->prior.extra,
4194  newextra);
4195  stack->source = source;
4196  stack->scontext = context;
4197  stack->srole = srole;
4198  }
4199  }
4200  }
4201 
4202  /* Perhaps we didn't install newextra anywhere */
4203  if (newextra && !extra_field_used(&conf->gen, newextra))
4204  guc_free(newextra);
4205  break;
4206 
4207 #undef newval
4208  }
4209  }
4210 
4211  if (changeVal && (record->flags & GUC_REPORT) &&
4212  !(record->status & GUC_NEEDS_REPORT))
4213  {
4214  record->status |= GUC_NEEDS_REPORT;
4216  }
4217 
4218  return changeVal ? 1 : -1;
4219 }
4220 
4221 
4222 /*
4223  * Retrieve a config_handle for the given name, suitable for calling
4224  * set_config_with_handle(). Only return handle to permanent GUC.
4225  */
4226 config_handle *
4228 {
4229  struct config_generic *gen = find_option(name, false, false, 0);
4230 
4231  if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
4232  return gen;
4233 
4234  return NULL;
4235 }
4236 
4237 
4238 /*
4239  * Set the fields for source file and line number the setting came from.
4240  */
4241 static void
4243 {
4244  struct config_generic *record;
4245  int elevel;
4246 
4247  /*
4248  * To avoid cluttering the log, only the postmaster bleats loudly about
4249  * problems with the config file.
4250  */
4251  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
4252 
4253  record = find_option(name, true, false, elevel);
4254  /* should not happen */
4255  if (record == NULL)
4256  return;
4257 
4258  sourcefile = guc_strdup(elevel, sourcefile);
4259  guc_free(record->sourcefile);
4260  record->sourcefile = sourcefile;
4261  record->sourceline = sourceline;
4262 }
4263 
4264 /*
4265  * Set a config option to the given value.
4266  *
4267  * See also set_config_option; this is just the wrapper to be called from
4268  * outside GUC. (This function should be used when possible, because its API
4269  * is more stable than set_config_option's.)
4270  *
4271  * Note: there is no support here for setting source file/line, as it
4272  * is currently not needed.
4273  */
4274 void
4275 SetConfigOption(const char *name, const char *value,
4277 {
4279  GUC_ACTION_SET, true, 0, false);
4280 }
4281 
4282 
4283 
4284 /*
4285  * Fetch the current value of the option `name', as a string.
4286  *
4287  * If the option doesn't exist, return NULL if missing_ok is true,
4288  * otherwise throw an ereport and don't return.
4289  *
4290  * If restrict_privileged is true, we also enforce that only superusers and
4291  * members of the pg_read_all_settings role can see GUC_SUPERUSER_ONLY
4292  * variables. This should only be passed as true in user-driven calls.
4293  *
4294  * The string is *not* allocated for modification and is really only
4295  * valid until the next call to configuration related functions.
4296  */
4297 const char *
4298 GetConfigOption(const char *name, bool missing_ok, bool restrict_privileged)
4299 {
4300  struct config_generic *record;
4301  static char buffer[256];
4302 
4303  record = find_option(name, false, missing_ok, ERROR);
4304  if (record == NULL)
4305  return NULL;
4306  if (restrict_privileged &&
4307  !ConfigOptionIsVisible(record))
4308  ereport(ERROR,
4309  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4310  errmsg("permission denied to examine \"%s\"", name),
4311  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4312  "pg_read_all_settings")));
4313 
4314  switch (record->vartype)
4315  {
4316  case PGC_BOOL:
4317  return *((struct config_bool *) record)->variable ? "on" : "off";
4318 
4319  case PGC_INT:
4320  snprintf(buffer, sizeof(buffer), "%d",
4321  *((struct config_int *) record)->variable);
4322  return buffer;
4323 
4324  case PGC_REAL:
4325  snprintf(buffer, sizeof(buffer), "%g",
4326  *((struct config_real *) record)->variable);
4327  return buffer;
4328 
4329  case PGC_STRING:
4330  return *((struct config_string *) record)->variable ?
4331  *((struct config_string *) record)->variable : "";
4332 
4333  case PGC_ENUM:
4334  return config_enum_lookup_by_value((struct config_enum *) record,
4335  *((struct config_enum *) record)->variable);
4336  }
4337  return NULL;
4338 }
4339 
4340 /*
4341  * Get the RESET value associated with the given option.
4342  *
4343  * Note: this is not re-entrant, due to use of static result buffer;
4344  * not to mention that a string variable could have its reset_val changed.
4345  * Beware of assuming the result value is good for very long.
4346  */
4347 const char *
4349 {
4350  struct config_generic *record;
4351  static char buffer[256];
4352 
4353  record = find_option(name, false, false, ERROR);
4354  Assert(record != NULL);
4355  if (!ConfigOptionIsVisible(record))
4356  ereport(ERROR,
4357  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4358  errmsg("permission denied to examine \"%s\"", name),
4359  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4360  "pg_read_all_settings")));
4361 
4362  switch (record->vartype)
4363  {
4364  case PGC_BOOL:
4365  return ((struct config_bool *) record)->reset_val ? "on" : "off";
4366 
4367  case PGC_INT:
4368  snprintf(buffer, sizeof(buffer), "%d",
4369  ((struct config_int *) record)->reset_val);
4370  return buffer;
4371 
4372  case PGC_REAL:
4373  snprintf(buffer, sizeof(buffer), "%g",
4374  ((struct config_real *) record)->reset_val);
4375  return buffer;
4376 
4377  case PGC_STRING:
4378  return ((struct config_string *) record)->reset_val ?
4379  ((struct config_string *) record)->reset_val : "";
4380 
4381  case PGC_ENUM:
4382  return config_enum_lookup_by_value((struct config_enum *) record,
4383  ((struct config_enum *) record)->reset_val);
4384  }
4385  return NULL;
4386 }
4387 
4388 /*
4389  * Get the GUC flags associated with the given option.
4390  *
4391  * If the option doesn't exist, return 0 if missing_ok is true,
4392  * otherwise throw an ereport and don't return.
4393  */
4394 int
4395 GetConfigOptionFlags(const char *name, bool missing_ok)
4396 {
4397  struct config_generic *record;
4398 
4399  record = find_option(name, false, missing_ok, ERROR);
4400  if (record == NULL)
4401  return 0;
4402  return record->flags;
4403 }
4404 
4405 
4406 /*
4407  * Write updated configuration parameter values into a temporary file.
4408  * This function traverses the list of parameters and quotes the string
4409  * values before writing them.
4410  */
4411 static void
4413 {
4415  ConfigVariable *item;
4416 
4417  initStringInfo(&buf);
4418 
4419  /* Emit file header containing warning comment */
4420  appendStringInfoString(&buf, "# Do not edit this file manually!\n");
4421  appendStringInfoString(&buf, "# It will be overwritten by the ALTER SYSTEM command.\n");
4422 
4423  errno = 0;
4424  if (write(fd, buf.data, buf.len) != buf.len)
4425  {
4426  /* if write didn't set errno, assume problem is no disk space */
4427  if (errno == 0)
4428  errno = ENOSPC;
4429  ereport(ERROR,
4431  errmsg("could not write to file \"%s\": %m", filename)));
4432  }
4433 
4434  /* Emit each parameter, properly quoting the value */
4435  for (item = head; item != NULL; item = item->next)
4436  {
4437  char *escaped;
4438 
4439  resetStringInfo(&buf);
4440 
4441  appendStringInfoString(&buf, item->name);
4442  appendStringInfoString(&buf, " = '");
4443 
4444  escaped = escape_single_quotes_ascii(item->value);
4445  if (!escaped)
4446  ereport(ERROR,
4447  (errcode(ERRCODE_OUT_OF_MEMORY),
4448  errmsg("out of memory")));
4449  appendStringInfoString(&buf, escaped);
4450  free(escaped);
4451 
4452  appendStringInfoString(&buf, "'\n");
4453 
4454  errno = 0;
4455  if (write(fd, buf.data, buf.len) != buf.len)
4456  {
4457  /* if write didn't set errno, assume problem is no disk space */
4458  if (errno == 0)
4459  errno = ENOSPC;
4460  ereport(ERROR,
4462  errmsg("could not write to file \"%s\": %m", filename)));
4463  }
4464  }
4465 
4466  /* fsync before considering the write to be successful */
4467  if (pg_fsync(fd) != 0)
4468  ereport(ERROR,
4470  errmsg("could not fsync file \"%s\": %m", filename)));
4471 
4472  pfree(buf.data);
4473 }
4474 
4475 /*
4476  * Update the given list of configuration parameters, adding, replacing
4477  * or deleting the entry for item "name" (delete if "value" == NULL).
4478  */
4479 static void
4481  const char *name, const char *value)
4482 {
4483  ConfigVariable *item,
4484  *next,
4485  *prev = NULL;
4486 
4487  /*
4488  * Remove any existing match(es) for "name". Normally there'd be at most
4489  * one, but if external tools have modified the config file, there could
4490  * be more.
4491  */
4492  for (item = *head_p; item != NULL; item = next)
4493  {
4494  next = item->next;
4495  if (guc_name_compare(item->name, name) == 0)
4496  {
4497  /* found a match, delete it */
4498  if (prev)
4499  prev->next = next;
4500  else
4501  *head_p = next;
4502  if (next == NULL)
4503  *tail_p = prev;
4504 
4505  pfree(item->name);
4506  pfree(item->value);
4507  pfree(item->filename);
4508  pfree(item);
4509  }
4510  else
4511  prev = item;
4512  }
4513 
4514  /* Done if we're trying to delete it */
4515  if (value == NULL)
4516  return;
4517 
4518  /* OK, append a new entry */
4519  item = palloc(sizeof *item);
4520  item->name = pstrdup(name);
4521  item->value = pstrdup(value);
4522  item->errmsg = NULL;
4523  item->filename = pstrdup(""); /* new item has no location */
4524  item->sourceline = 0;
4525  item->ignore = false;
4526  item->applied = false;
4527  item->next = NULL;
4528 
4529  if (*head_p == NULL)
4530  *head_p = item;
4531  else
4532  (*tail_p)->next = item;
4533  *tail_p = item;
4534 }
4535 
4536 
4537 /*
4538  * Execute ALTER SYSTEM statement.
4539  *
4540  * Read the old PG_AUTOCONF_FILENAME file, merge in the new variable value,
4541  * and write out an updated file. If the command is ALTER SYSTEM RESET ALL,
4542  * we can skip reading the old file and just write an empty file.
4543  *
4544  * An LWLock is used to serialize updates of the configuration file.
4545  *
4546  * In case of an error, we leave the original automatic
4547  * configuration file (PG_AUTOCONF_FILENAME) intact.
4548  */
4549 void
4551 {
4552  char *name;
4553  char *value;
4554  bool resetall = false;
4555  ConfigVariable *head = NULL;
4556  ConfigVariable *tail = NULL;
4557  volatile int Tmpfd;
4558  char AutoConfFileName[MAXPGPATH];
4559  char AutoConfTmpFileName[MAXPGPATH];
4560 
4561  /*
4562  * Extract statement arguments
4563  */
4564  name = altersysstmt->setstmt->name;
4565 
4566  switch (altersysstmt->setstmt->kind)
4567  {
4568  case VAR_SET_VALUE:
4569  value = ExtractSetVariableArgs(altersysstmt->setstmt);
4570  break;
4571 
4572  case VAR_SET_DEFAULT:
4573  case VAR_RESET:
4574  value = NULL;
4575  break;
4576 
4577  case VAR_RESET_ALL:
4578  value = NULL;
4579  resetall = true;
4580  break;
4581 
4582  default:
4583  elog(ERROR, "unrecognized alter system stmt type: %d",
4584  altersysstmt->setstmt->kind);
4585  break;
4586  }
4587 
4588  /*
4589  * Check permission to run ALTER SYSTEM on the target variable
4590  */
4591  if (!superuser())
4592  {
4593  if (resetall)
4594  ereport(ERROR,
4595  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4596  errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4597  else
4598  {
4599  AclResult aclresult;
4600 
4601  aclresult = pg_parameter_aclcheck(name, GetUserId(),
4603  if (aclresult != ACLCHECK_OK)
4604  ereport(ERROR,
4605  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4606  errmsg("permission denied to set parameter \"%s\"",
4607  name)));
4608  }
4609  }
4610 
4611  /*
4612  * Unless it's RESET_ALL, validate the target variable and value
4613  */
4614  if (!resetall)
4615  {
4616  struct config_generic *record;
4617 
4618  /* We don't want to create a placeholder if there's not one already */
4619  record = find_option(name, false, true, DEBUG5);
4620  if (record != NULL)
4621  {
4622  /*
4623  * Don't allow parameters that can't be set in configuration files
4624  * to be set in PG_AUTOCONF_FILENAME file.
4625  */
4626  if ((record->context == PGC_INTERNAL) ||
4627  (record->flags & GUC_DISALLOW_IN_FILE) ||
4628  (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
4629  ereport(ERROR,
4630  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4631  errmsg("parameter \"%s\" cannot be changed",
4632  name)));
4633 
4634  /*
4635  * If a value is specified, verify that it's sane.
4636  */
4637  if (value)
4638  {
4639  union config_var_val newval;
4640  void *newextra = NULL;
4641 
4642  if (!parse_and_validate_value(record, name, value,
4643  PGC_S_FILE, ERROR,
4644  &newval, &newextra))
4645  ereport(ERROR,
4646  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4647  errmsg("invalid value for parameter \"%s\": \"%s\"",
4648  name, value)));
4649 
4650  if (record->vartype == PGC_STRING && newval.stringval != NULL)
4651  guc_free(newval.stringval);
4652  guc_free(newextra);
4653  }
4654  }
4655  else
4656  {
4657  /*
4658  * Variable not known; check we'd be allowed to create it. (We
4659  * cannot validate the value, but that's fine. A non-core GUC in
4660  * the config file cannot cause postmaster start to fail, so we
4661  * don't have to be too tense about possibly installing a bad
4662  * value.)
4663  */
4664  (void) assignable_custom_variable_name(name, false, ERROR);
4665  }
4666 
4667  /*
4668  * We must also reject values containing newlines, because the grammar
4669  * for config files doesn't support embedded newlines in string
4670  * literals.
4671  */
4672  if (value && strchr(value, '\n'))
4673  ereport(ERROR,
4674  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4675  errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4676  }
4677 
4678  /*
4679  * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4680  * the data directory, so we can reference them by simple relative paths.
4681  */
4682  snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4684  snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4685  AutoConfFileName,
4686  "tmp");
4687 
4688  /*
4689  * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4690  * time. Use AutoFileLock to ensure that. We must hold the lock while
4691  * reading the old file contents.
4692  */
4693  LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4694 
4695  /*
4696  * If we're going to reset everything, then no need to open or parse the
4697  * old file. We'll just write out an empty list.
4698  */
4699  if (!resetall)
4700  {
4701  struct stat st;
4702 
4703  if (stat(AutoConfFileName, &st) == 0)
4704  {
4705  /* open old file PG_AUTOCONF_FILENAME */
4706  FILE *infile;
4707 
4708  infile = AllocateFile(AutoConfFileName, "r");
4709  if (infile == NULL)
4710  ereport(ERROR,
4712  errmsg("could not open file \"%s\": %m",
4713  AutoConfFileName)));
4714 
4715  /* parse it */
4716  if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4717  LOG, &head, &tail))
4718  ereport(ERROR,
4719  (errcode(ERRCODE_CONFIG_FILE_ERROR),
4720  errmsg("could not parse contents of file \"%s\"",
4721  AutoConfFileName)));
4722 
4723  FreeFile(infile);
4724  }
4725 
4726  /*
4727  * Now, replace any existing entry with the new value, or add it if
4728  * not present.
4729  */
4730  replace_auto_config_value(&head, &tail, name, value);
4731  }
4732 
4733  /*
4734  * Invoke the post-alter hook for setting this GUC variable. GUCs
4735  * typically do not have corresponding entries in pg_parameter_acl, so we
4736  * call the hook using the name rather than a potentially-non-existent
4737  * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4738  * context can be distinguished from others. (Note that "name" will be
4739  * NULL in the RESET ALL case.)
4740  *
4741  * We do this here rather than at the end, because ALTER SYSTEM is not
4742  * transactional. If the hook aborts our transaction, it will be cleaner
4743  * to do so before we touch any files.
4744  */
4745  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4747  altersysstmt->setstmt->kind,
4748  false);
4749 
4750  /*
4751  * To ensure crash safety, first write the new file data to a temp file,
4752  * then atomically rename it into place.
4753  *
4754  * If there is a temp file left over due to a previous crash, it's okay to
4755  * truncate and reuse it.
4756  */
4757  Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4758  O_CREAT | O_RDWR | O_TRUNC);
4759  if (Tmpfd < 0)
4760  ereport(ERROR,
4762  errmsg("could not open file \"%s\": %m",
4763  AutoConfTmpFileName)));
4764 
4765  /*
4766  * Use a TRY block to clean up the file if we fail. Since we need a TRY
4767  * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4768  */
4769  PG_TRY();
4770  {
4771  /* Write and sync the new contents to the temporary file */
4772  write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4773 
4774  /* Close before renaming; may be required on some platforms */
4775  close(Tmpfd);
4776  Tmpfd = -1;
4777 
4778  /*
4779  * As the rename is atomic operation, if any problem occurs after this
4780  * at worst it can lose the parameters set by last ALTER SYSTEM
4781  * command.
4782  */
4783  durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4784  }
4785  PG_CATCH();
4786  {
4787  /* Close file first, else unlink might fail on some platforms */
4788  if (Tmpfd >= 0)
4789  close(Tmpfd);
4790 
4791  /* Unlink, but ignore any error */
4792  (void) unlink(AutoConfTmpFileName);
4793 
4794  PG_RE_THROW();
4795  }
4796  PG_END_TRY();
4797 
4798  FreeConfigVariables(head);
4799 
4800  LWLockRelease(AutoFileLock);
4801 }
4802 
4803 
4804 /*
4805  * Common code for DefineCustomXXXVariable subroutines: allocate the
4806  * new variable's config struct and fill in generic fields.
4807  */
4808 static struct config_generic *
4810  const char *short_desc,
4811  const char *long_desc,
4813  int flags,
4814  enum config_type type,
4815  size_t sz)
4816 {
4817  struct config_generic *gen;
4818 
4819  /*
4820  * Only allow custom PGC_POSTMASTER variables to be created during shared
4821  * library preload; any later than that, we can't ensure that the value
4822  * doesn't change after startup. This is a fatal elog if it happens; just
4823  * erroring out isn't safe because we don't know what the calling loadable
4824  * module might already have hooked into.
4825  */
4826  if (context == PGC_POSTMASTER &&
4828  elog(FATAL, "cannot create PGC_POSTMASTER variables after startup");
4829 
4830  /*
4831  * We can't support custom GUC_LIST_QUOTE variables, because the wrong
4832  * things would happen if such a variable were set or pg_dump'd when the
4833  * defining extension isn't loaded. Again, treat this as fatal because
4834  * the loadable module may be partly initialized already.
4835  */
4836  if (flags & GUC_LIST_QUOTE)
4837  elog(FATAL, "extensions cannot define GUC_LIST_QUOTE variables");
4838 
4839  /*
4840  * Before pljava commit 398f3b876ed402bdaec8bc804f29e2be95c75139
4841  * (2015-12-15), two of that module's PGC_USERSET variables facilitated
4842  * trivial escalation to superuser privileges. Restrict the variables to
4843  * protect sites that have yet to upgrade pljava.
4844  */
4845  if (context == PGC_USERSET &&
4846  (strcmp(name, "pljava.classpath") == 0 ||
4847  strcmp(name, "pljava.vmoptions") == 0))
4848  context = PGC_SUSET;
4849 
4850  gen = (struct config_generic *) guc_malloc(ERROR, sz);
4851  memset(gen, 0, sz);
4852 
4853  gen->name = guc_strdup(ERROR, name);
4854  gen->context = context;
4855  gen->group = CUSTOM_OPTIONS;
4856  gen->short_desc = short_desc;
4857  gen->long_desc = long_desc;
4858  gen->flags = flags;
4859  gen->vartype = type;
4860 
4861  return gen;
4862 }
4863 
4864 /*
4865  * Common code for DefineCustomXXXVariable subroutines: insert the new
4866  * variable into the GUC variable hash, replacing any placeholder.
4867  */
4868 static void
4870 {
4871  const char *name = variable->name;
4872  GUCHashEntry *hentry;
4873  struct config_string *pHolder;
4874 
4875  /* Check mapping between initial and default value */
4876  Assert(check_GUC_init(variable));
4877 
4878  /*
4879  * See if there's a placeholder by the same name.
4880  */
4881  hentry = (GUCHashEntry *) hash_search(guc_hashtab,
4882  &name,
4883  HASH_FIND,
4884  NULL);
4885  if (hentry == NULL)
4886  {
4887  /*
4888  * No placeholder to replace, so we can just add it ... but first,
4889  * make sure it's initialized to its default value.
4890  */
4893  return;
4894  }
4895 
4896  /*
4897  * This better be a placeholder
4898  */
4899  if ((hentry->gucvar->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
4900  ereport(ERROR,
4901  (errcode(ERRCODE_INTERNAL_ERROR),
4902  errmsg("attempt to redefine parameter \"%s\"", name)));
4903 
4904  Assert(hentry->gucvar->vartype == PGC_STRING);
4905  pHolder = (struct config_string *) hentry->gucvar;
4906 
4907  /*
4908  * First, set the variable to its default value. We must do this even
4909  * though we intend to immediately apply a new value, since it's possible
4910  * that the new value is invalid.
4911  */
4913 
4914  /*
4915  * Replace the placeholder in the hash table. We aren't changing the name
4916  * (at least up to case-folding), so the hash value is unchanged.
4917  */
4918  hentry->gucname = name;
4919  hentry->gucvar = variable;
4920 
4921  /*
4922  * Remove the placeholder from any lists it's in, too.
4923  */
4924  RemoveGUCFromLists(&pHolder->gen);
4925 
4926  /*
4927  * Assign the string value(s) stored in the placeholder to the real
4928  * variable. Essentially, we need to duplicate all the active and stacked
4929  * values, but with appropriate validation and datatype adjustment.
4930  *
4931  * If an assignment fails, we report a WARNING and keep going. We don't
4932  * want to throw ERROR for bad values, because it'd bollix the add-on
4933  * module that's presumably halfway through getting loaded. In such cases
4934  * the default or previous state will become active instead.
4935  */
4936 
4937  /* First, apply the reset value if any */
4938  if (pHolder->reset_val)
4939  (void) set_config_option_ext(name, pHolder->reset_val,
4940  pHolder->gen.reset_scontext,
4941  pHolder->gen.reset_source,
4942  pHolder->gen.reset_srole,
4943  GUC_ACTION_SET, true, WARNING, false);
4944  /* That should not have resulted in stacking anything */
4945  Assert(variable->stack == NULL);
4946 
4947  /* Now, apply current and stacked values, in the order they were stacked */
4948  reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
4949  *(pHolder->variable),
4950  pHolder->gen.scontext, pHolder->gen.source,
4951  pHolder->gen.srole);
4952 
4953  /* Also copy over any saved source-location information */
4954  if (pHolder->gen.sourcefile)
4956  pHolder->gen.sourceline);
4957 
4958  /*
4959  * Free up as much as we conveniently can of the placeholder structure.
4960  * (This neglects any stack items, so it's possible for some memory to be
4961  * leaked. Since this can only happen once per session per variable, it
4962  * doesn't seem worth spending much code on.)
4963  */
4964  set_string_field(pHolder, pHolder->variable, NULL);
4965  set_string_field(pHolder, &pHolder->reset_val, NULL);
4966 
4967  guc_free(pHolder);
4968 }
4969 
4970 /*
4971  * Recursive subroutine for define_custom_variable: reapply non-reset values
4972  *
4973  * We recurse so that the values are applied in the same order as originally.
4974  * At each recursion level, apply the upper-level value (passed in) in the
4975  * fashion implied by the stack entry.
4976  */
4977 static void
4979  struct config_string *pHolder,
4980  GucStack *stack,
4981  const char *curvalue,
4982  GucContext curscontext, GucSource cursource,
4983  Oid cursrole)
4984 {
4985  const char *name = variable->name;
4986  GucStack *oldvarstack = variable->stack;
4987 
4988  if (stack != NULL)
4989  {
4990  /* First, recurse, so that stack items are processed bottom to top */
4991  reapply_stacked_values(variable, pHolder, stack->prev,
4992  stack->prior.val.stringval,
4993  stack->scontext, stack->source, stack->srole);
4994 
4995  /* See how to apply the passed-in value */
4996  switch (stack->state)
4997  {
4998  case GUC_SAVE:
4999  (void) set_config_option_ext(name, curvalue,
5000  curscontext, cursource, cursrole,
5001  GUC_ACTION_SAVE, true,
5002  WARNING, false);
5003  break;
5004 
5005  case GUC_SET:
5006  (void) set_config_option_ext(name, curvalue,
5007  curscontext, cursource, cursrole,
5008  GUC_ACTION_SET, true,
5009  WARNING, false);
5010  break;
5011 
5012  case GUC_LOCAL:
5013  (void) set_config_option_ext(name, curvalue,
5014  curscontext, cursource, cursrole,
5015  GUC_ACTION_LOCAL, true,
5016  WARNING, false);
5017  break;
5018 
5019  case GUC_SET_LOCAL:
5020  /* first, apply the masked value as SET */
5022  stack->masked_scontext,
5023  PGC_S_SESSION,
5024  stack->masked_srole,
5025  GUC_ACTION_SET, true,
5026  WARNING, false);
5027  /* then apply the current value as LOCAL */
5028  (void) set_config_option_ext(name, curvalue,
5029  curscontext, cursource, cursrole,
5030  GUC_ACTION_LOCAL, true,
5031  WARNING, false);
5032  break;
5033  }
5034 
5035  /* If we successfully made a stack entry, adjust its nest level */
5036  if (variable->stack != oldvarstack)
5037  variable->stack->nest_level = stack->nest_level;
5038  }
5039  else
5040  {
5041  /*
5042  * We are at the end of the stack. If the active/previous value is
5043  * different from the reset value, it must represent a previously
5044  * committed session value. Apply it, and then drop the stack entry
5045  * that set_config_option will have created under the impression that
5046  * this is to be just a transactional assignment. (We leak the stack
5047  * entry.)
5048  */
5049  if (curvalue != pHolder->reset_val ||
5050  curscontext != pHolder->gen.reset_scontext ||
5051  cursource != pHolder->gen.reset_source ||
5052  cursrole != pHolder->gen.reset_srole)
5053  {
5054  (void) set_config_option_ext(name, curvalue,
5055  curscontext, cursource, cursrole,
5056  GUC_ACTION_SET, true, WARNING, false);
5057  if (variable->stack != NULL)
5058  {
5059  slist_delete(&guc_stack_list, &variable->stack_link);
5060  variable->stack = NULL;
5061  }
5062  }
5063  }
5064 }
5065 
5066 /*
5067  * Functions for extensions to call to define their custom GUC variables.
5068  */
5069 void
5071  const char *short_desc,
5072  const char *long_desc,
5073  bool *valueAddr,
5074  bool bootValue,
5075  GucContext context,
5076  int flags,
5080 {
5081  struct config_bool *var;
5082 
5083  var = (struct config_bool *)
5084  init_custom_variable(name, short_desc, long_desc, context, flags,
5085  PGC_BOOL, sizeof(struct config_bool));
5086  var->variable = valueAddr;
5087  var->boot_val = bootValue;
5088  var->reset_val = bootValue;
5089  var->check_hook = check_hook;
5090  var->assign_hook = assign_hook;
5091  var->show_hook = show_hook;
5092  define_custom_variable(&var->gen);
5093 }
5094 
5095 void
5097  const char *short_desc,
5098  const char *long_desc,
5099  int *valueAddr,
5100  int bootValue,
5101  int minValue,
5102  int maxValue,
5103  GucContext context,
5104  int flags,
5108 {
5109  struct config_int *var;
5110 
5111  var = (struct config_int *)
5112  init_custom_variable(name, short_desc, long_desc, context, flags,
5113  PGC_INT, sizeof(struct config_int));
5114  var->variable = valueAddr;
5115  var->boot_val = bootValue;
5116  var->reset_val = bootValue;
5117  var->min = minValue;
5118  var->max = maxValue;
5119  var->check_hook = check_hook;
5120  var->assign_hook = assign_hook;
5121  var->show_hook = show_hook;
5122  define_custom_variable(&var->gen);
5123 }
5124 
5125 void
5127  const char *short_desc,
5128  const char *long_desc,
5129  double *valueAddr,
5130  double bootValue,
5131  double minValue,
5132  double maxValue,
5133  GucContext context,
5134  int flags,
5138 {
5139  struct config_real *var;
5140 
5141  var = (struct config_real *)
5142  init_custom_variable(name, short_desc, long_desc, context, flags,
5143  PGC_REAL, sizeof(struct config_real));
5144  var->variable = valueAddr;
5145  var->boot_val = bootValue;
5146  var->reset_val = bootValue;
5147  var->min = minValue;
5148  var->max = maxValue;
5149  var->check_hook = check_hook;
5150  var->assign_hook = assign_hook;
5151  var->show_hook = show_hook;
5152  define_custom_variable(&var->gen);
5153 }
5154 
5155 void
5157  const char *short_desc,
5158  const char *long_desc,
5159  char **valueAddr,
5160  const char *bootValue,
5161  GucContext context,
5162  int flags,
5166 {
5167  struct config_string *var;
5168 
5169  var = (struct config_string *)
5170  init_custom_variable(name, short_desc, long_desc, context, flags,
5171  PGC_STRING, sizeof(struct config_string));
5172  var->variable = valueAddr;
5173  var->boot_val = bootValue;
5174  var->check_hook = check_hook;
5175  var->assign_hook = assign_hook;
5176  var->show_hook = show_hook;
5177  define_custom_variable(&var->gen);
5178 }
5179 
5180 void
5182  const char *short_desc,
5183  const char *long_desc,
5184  int *valueAddr,
5185  int bootValue,
5186  const struct config_enum_entry *options,
5187  GucContext context,
5188  int flags,
5192 {
5193  struct config_enum *var;
5194 
5195  var = (struct config_enum *)
5196  init_custom_variable(name, short_desc, long_desc, context, flags,
5197  PGC_ENUM, sizeof(struct config_enum));
5198  var->variable = valueAddr;
5199  var->boot_val = bootValue;
5200  var->reset_val = bootValue;
5201  var->options = options;
5202  var->check_hook = check_hook;
5203  var->assign_hook = assign_hook;
5204  var->show_hook = show_hook;
5205  define_custom_variable(&var->gen);
5206 }
5207 
5208 /*
5209  * Mark the given GUC prefix as "reserved".
5210  *
5211  * This deletes any existing placeholders matching the prefix,
5212  * and then prevents new ones from being created.
5213  * Extensions should call this after they've defined all of their custom
5214  * GUCs, to help catch misspelled config-file entries.
5215  */
5216 void
5217 MarkGUCPrefixReserved(const char *className)
5218 {
5219  int classLen = strlen(className);
5220  HASH_SEQ_STATUS status;
5221  GUCHashEntry *hentry;
5222  MemoryContext oldcontext;
5223 
5224  /*
5225  * Check for existing placeholders. We must actually remove invalid
5226  * placeholders, else future parallel worker startups will fail. (We
5227  * don't bother trying to free associated memory, since this shouldn't
5228  * happen often.)
5229  */
5230  hash_seq_init(&status, guc_hashtab);
5231  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5232  {
5233  struct config_generic *var = hentry->gucvar;
5234 
5235  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5236  strncmp(className, var->name, classLen) == 0 &&
5237  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5238  {
5239  ereport(WARNING,
5240  (errcode(ERRCODE_INVALID_NAME),
5241  errmsg("invalid configuration parameter name \"%s\", removing it",
5242  var->name),
5243  errdetail("\"%s\" is now a reserved prefix.",
5244  className)));
5245  /* Remove it from the hash table */
5247  &var->name,
5248  HASH_REMOVE,
5249  NULL);
5250  /* Remove it from any lists it's in, too */
5251  RemoveGUCFromLists(var);
5252  }
5253  }
5254 
5255  /* And remember the name so we can prevent future mistakes. */
5258  MemoryContextSwitchTo(oldcontext);
5259 }
5260 
5261 
5262 /*
5263  * Return an array of modified GUC options to show in EXPLAIN.
5264  *
5265  * We only report options related to query planning (marked with GUC_EXPLAIN),
5266  * with values different from their built-in defaults.
5267  */
5268 struct config_generic **
5270 {
5271  struct config_generic **result;
5272  dlist_iter iter;
5273 
5274  *num = 0;
5275 
5276  /*
5277  * While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
5278  * it doesn't seem worth dynamically resizing this array.
5279  */
5280  result = palloc(sizeof(struct config_generic *) * hash_get_num_entries(guc_hashtab));
5281 
5282  /* We need only consider GUCs with source not PGC_S_DEFAULT */
5284  {
5285  struct config_generic *conf = dlist_container(struct config_generic,
5286  nondef_link, iter.cur);
5287  bool modified;
5288 
5289  /* return only parameters marked for inclusion in explain */
5290  if (!(conf->flags & GUC_EXPLAIN))
5291  continue;
5292 
5293  /* return only options visible to the current user */
5294  if (!ConfigOptionIsVisible(conf))
5295  continue;
5296 
5297  /* return only options that are different from their boot values */
5298  modified = false;
5299 
5300  switch (conf->vartype)
5301  {
5302  case PGC_BOOL:
5303  {
5304  struct config_bool *lconf = (struct config_bool *) conf;
5305 
5306  modified = (lconf->boot_val != *(lconf->variable));
5307  }
5308  break;
5309 
5310  case PGC_INT:
5311  {
5312  struct config_int *lconf = (struct config_int *) conf;
5313 
5314  modified = (lconf->boot_val != *(lconf->variable));
5315  }
5316  break;
5317 
5318  case PGC_REAL:
5319  {
5320  struct config_real *lconf = (struct config_real *) conf;
5321 
5322  modified = (lconf->boot_val != *(lconf->variable));
5323  }
5324  break;
5325 
5326  case PGC_STRING:
5327  {
5328  struct config_string *lconf = (struct config_string *) conf;
5329 
5330  if (lconf->boot_val == NULL &&
5331  *lconf->variable == NULL)
5332  modified = false;
5333  else if (lconf->boot_val == NULL ||
5334  *lconf->variable == NULL)
5335  modified = true;
5336  else
5337  modified = (strcmp(lconf->boot_val, *(lconf->variable)) != 0);
5338  }
5339  break;
5340 
5341  case PGC_ENUM:
5342  {
5343  struct config_enum *lconf = (struct config_enum *) conf;
5344 
5345  modified = (lconf->boot_val != *(lconf->variable));
5346  }
5347  break;
5348 
5349  default:
5350  elog(ERROR, "unexpected GUC type: %d", conf->vartype);
5351  }
5352 
5353  if (!modified)
5354  continue;
5355 
5356  /* OK, report it */
5357  result[*num] = conf;
5358  *num = *num + 1;
5359  }
5360 
5361  return result;
5362 }
5363 
5364 /*
5365  * Return GUC variable value by name; optionally return canonical form of
5366  * name. If the GUC is unset, then throw an error unless missing_ok is true,
5367  * in which case return NULL. Return value is palloc'd (but *varname isn't).
5368  */
5369 char *
5370 GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
5371 {
5372  struct config_generic *record;
5373 
5374  record = find_option(name, false, missing_ok, ERROR);
5375  if (record == NULL)
5376  {
5377  if (varname)
5378  *varname = NULL;
5379  return NULL;
5380  }
5381 
5382  if (!ConfigOptionIsVisible(record))
5383  ereport(ERROR,
5384  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
5385  errmsg("permission denied to examine \"%s\"", name),
5386  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
5387  "pg_read_all_settings")));
5388 
5389  if (varname)
5390  *varname = record->name;
5391 
5392  return ShowGUCOption(record, true);
5393 }
5394 
5395 /*
5396  * ShowGUCOption: get string value of variable
5397  *
5398  * We express a numeric value in appropriate units if it has units and
5399  * use_units is true; else you just get the raw number.
5400  * The result string is palloc'd.
5401  */
5402 char *
5403 ShowGUCOption(struct config_generic *record, bool use_units)
5404 {
5405  char buffer[256];
5406  const char *val;
5407 
5408  switch (record->vartype)
5409  {
5410  case PGC_BOOL:
5411  {
5412  struct config_bool *conf = (struct config_bool *) record;
5413 
5414  if (conf->show_hook)
5415  val = conf->show_hook();
5416  else
5417  val = *conf->variable ? "on" : "off";
5418  }
5419  break;
5420 
5421  case PGC_INT:
5422  {
5423  struct config_int *conf = (struct config_int *) record;
5424 
5425  if (conf->show_hook)
5426  val = conf->show_hook();
5427  else
5428  {
5429  /*
5430  * Use int64 arithmetic to avoid overflows in units
5431  * conversion.
5432  */
5433  int64 result = *conf->variable;
5434  const char *unit;
5435 
5436  if (use_units && result > 0 && (record->flags & GUC_UNIT))
5438  record->flags & GUC_UNIT,
5439  &result, &unit);
5440  else
5441  unit = "";
5442 
5443  snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
5444  result, unit);
5445  val = buffer;
5446  }
5447  }
5448  break;
5449 
5450  case PGC_REAL:
5451  {
5452  struct config_real *conf = (struct config_real *) record;
5453 
5454  if (conf->show_hook)
5455  val = conf->show_hook();
5456  else
5457  {
5458  double result = *conf->variable;
5459  const char *unit;
5460 
5461  if (use_units && result > 0 && (record->flags & GUC_UNIT))
5463  record->flags & GUC_UNIT,
5464  &result, &unit);
5465  else
5466  unit = "";
5467 
5468  snprintf(buffer, sizeof(buffer), "%g%s",
5469  result, unit);
5470  val = buffer;
5471  }
5472  }
5473  break;
5474 
5475  case PGC_STRING:
5476  {
5477  struct config_string *conf = (struct config_string *) record;
5478 
5479  if (conf->show_hook)
5480  val = conf->show_hook();
5481  else if (*conf->variable && **conf->variable)
5482  val = *conf->variable;
5483  else
5484  val = "";
5485  }
5486  break;
5487 
5488  case PGC_ENUM:
5489  {
5490  struct config_enum *conf = (struct config_enum *) record;
5491 
5492  if (conf->show_hook)
5493  val = conf->show_hook();
5494  else
5495  val = config_enum_lookup_by_value(conf, *conf->variable);
5496  }
5497  break;
5498 
5499  default:
5500  /* just to keep compiler quiet */
5501  val = "???";
5502  break;
5503  }
5504 
5505  return pstrdup(val);
5506 }
5507 
5508 
5509 #ifdef EXEC_BACKEND
5510 
5511 /*
5512  * These routines dump out all non-default GUC options into a binary
5513  * file that is read by all exec'ed backends. The format is:
5514  *
5515  * variable name, string, null terminated
5516  * variable value, string, null terminated
5517  * variable sourcefile, string, null terminated (empty if none)
5518  * variable sourceline, integer
5519  * variable source, integer
5520  * variable scontext, integer
5521 * variable srole, OID
5522  */
5523 static void
5524 write_one_nondefault_variable(FILE *fp, struct config_generic *gconf)
5525 {
5526  Assert(gconf->source != PGC_S_DEFAULT);
5527 
5528  fprintf(fp, "%s", gconf->name);
5529  fputc(0, fp);
5530 
5531  switch (gconf->vartype)
5532  {
5533  case PGC_BOOL:
5534  {
5535  struct config_bool *conf = (struct config_bool *) gconf;
5536 
5537  if (*conf->variable)
5538  fprintf(fp, "true");
5539  else
5540  fprintf(fp, "false");
5541  }
5542  break;
5543 
5544  case PGC_INT:
5545  {
5546  struct config_int *conf = (struct config_int *) gconf;
5547 
5548  fprintf(fp, "%d", *conf->variable);
5549  }
5550  break;
5551 
5552  case PGC_REAL:
5553  {
5554  struct config_real *conf = (struct config_real *) gconf;
5555 
5556  fprintf(fp, "%.17g", *conf->variable);
5557  }
5558  break;
5559 
5560  case PGC_STRING:
5561  {
5562  struct config_string *conf = (struct config_string *) gconf;
5563 
5564  if (*conf->variable)
5565  fprintf(fp, "%s", *conf->variable);
5566  }
5567  break;
5568 
5569  case PGC_ENUM:
5570  {
5571  struct config_enum *conf = (struct config_enum *) gconf;
5572 
5573  fprintf(fp, "%s",
5574  config_enum_lookup_by_value(conf, *conf->variable));
5575  }
5576  break;
5577  }
5578 
5579  fputc(0, fp);
5580 
5581  if (gconf->sourcefile)
5582  fprintf(fp, "%s", gconf->sourcefile);
5583  fputc(0, fp);
5584 
5585  fwrite(&gconf->sourceline, 1, sizeof(gconf->sourceline), fp);
5586  fwrite(&gconf->source, 1, sizeof(gconf->source), fp);
5587  fwrite(&gconf->scontext, 1, sizeof(gconf->scontext), fp);
5588  fwrite(&gconf->srole, 1, sizeof(gconf->srole), fp);
5589 }
5590 
5591 void
5592 write_nondefault_variables(GucContext context)
5593 {
5594  int elevel;
5595  FILE *fp;
5596  dlist_iter iter;
5597 
5598  Assert(context == PGC_POSTMASTER || context == PGC_SIGHUP);
5599 
5600  elevel = (context == PGC_SIGHUP) ? LOG : ERROR;
5601 
5602  /*
5603  * Open file
5604  */
5605  fp = AllocateFile(CONFIG_EXEC_PARAMS_NEW, "w");
5606  if (!fp)
5607  {
5608  ereport(elevel,
5610  errmsg("could not write to file \"%s\": %m",
5611  CONFIG_EXEC_PARAMS_NEW)));
5612  return;
5613  }
5614 
5615  /* We need only consider GUCs with source not PGC_S_DEFAULT */
5617  {
5618  struct config_generic *gconf = dlist_container(struct config_generic,
5619  nondef_link, iter.cur);
5620 
5621  write_one_nondefault_variable(fp, gconf);
5622  }
5623 
5624  if (FreeFile(fp))
5625  {
5626  ereport(elevel,
5628  errmsg("could not write to file \"%s\": %m",
5629  CONFIG_EXEC_PARAMS_NEW)));
5630  return;
5631  }
5632 
5633  /*
5634  * Put new file in place. This could delay on Win32, but we don't hold
5635  * any exclusive locks.
5636  */
5637  rename(CONFIG_EXEC_PARAMS_NEW, CONFIG_EXEC_PARAMS);
5638 }
5639 
5640 
5641 /*
5642  * Read string, including null byte from file
5643  *
5644  * Return NULL on EOF and nothing read
5645  */
5646 static char *
5647 read_string_with_null(FILE *fp)
5648 {
5649  int i = 0,
5650  ch,
5651  maxlen = 256;
5652  char *str = NULL;
5653 
5654  do
5655  {
5656  if ((ch = fgetc(fp)) == EOF)
5657  {
5658  if (i == 0)
5659  return NULL;
5660  else
5661  elog(FATAL, "invalid format of exec config params file");
5662  }
5663  if (i == 0)
5664  str = guc_malloc(FATAL, maxlen);
5665  else if (i == maxlen)
5666  str = guc_realloc(FATAL, str, maxlen *= 2);
5667  str[i++] = ch;
5668  } while (ch != 0);
5669 
5670  return str;
5671 }
5672 
5673 
5674 /*
5675  * This routine loads a previous postmaster dump of its non-default
5676  * settings.
5677  */
5678 void
5679 read_nondefault_variables(void)
5680 {
5681  FILE *fp;
5682  char *varname,
5683  *varvalue,
5684  *varsourcefile;
5685  int varsourceline;
5686  GucSource varsource;
5687  GucContext varscontext;
5688  Oid varsrole;
5689 
5690  /*
5691  * Open file
5692  */
5693  fp = AllocateFile(CONFIG_EXEC_PARAMS, "r");
5694  if (!fp)
5695  {
5696  /* File not found is fine */
5697  if (errno != ENOENT)
5698  ereport(FATAL,
5700  errmsg("could not read from file \"%s\": %m",
5701  CONFIG_EXEC_PARAMS)));
5702  return;
5703  }
5704 
5705  for (;;)
5706  {
5707  if ((varname = read_string_with_null(fp)) == NULL)
5708  break;
5709 
5710  if (find_option(varname, true, false, FATAL) == NULL)
5711  elog(FATAL, "failed to locate variable \"%s\" in exec config params file", varname);
5712 
5713  if ((varvalue = read_string_with_null(fp)) == NULL)
5714  elog(FATAL, "invalid format of exec config params file");
5715  if ((varsourcefile = read_string_with_null(fp)) == NULL)
5716  elog(FATAL, "invalid format of exec config params file");
5717  if (fread(&varsourceline, 1, sizeof(varsourceline), fp) != sizeof(varsourceline))
5718  elog(FATAL, "invalid format of exec config params file");
5719  if (fread(&varsource, 1, sizeof(varsource), fp) != sizeof(varsource))
5720  elog(FATAL, "invalid format of exec config params file");
5721  if (fread(&varscontext, 1, sizeof(varscontext), fp) != sizeof(varscontext))
5722  elog(FATAL, "invalid format of exec config params file");
5723  if (fread(&varsrole, 1, sizeof(varsrole), fp) != sizeof(varsrole))
5724  elog(FATAL, "invalid format of exec config params file");
5725 
5726  (void) set_config_option_ext(varname, varvalue,
5727  varscontext, varsource, varsrole,
5728  GUC_ACTION_SET, true, 0, true);
5729  if (varsourcefile[0])
5730  set_config_sourcefile(varname, varsourcefile, varsourceline);
5731 
5732  guc_free(varname);
5733  guc_free(varvalue);
5734  guc_free(varsourcefile);
5735  }
5736 
5737  FreeFile(fp);
5738 }
5739 #endif /* EXEC_BACKEND */
5740 
5741 /*
5742  * can_skip_gucvar:
5743  * Decide whether SerializeGUCState can skip sending this GUC variable,
5744  * or whether RestoreGUCState can skip resetting this GUC to default.
5745  *
5746  * It is somewhat magical and fragile that the same test works for both cases.
5747  * Realize in particular that we are very likely selecting different sets of
5748  * GUCs on the leader and worker sides! Be sure you've understood the
5749  * comments here and in RestoreGUCState thoroughly before changing this.
5750  */
5751 static bool
5753 {
5754  /*
5755  * We can skip GUCs that are guaranteed to have the same values in leaders
5756  * and workers. (Note it is critical that the leader and worker have the
5757  * same idea of which GUCs fall into this category. It's okay to consider
5758  * context and name for this purpose, since those are unchanging
5759  * properties of a GUC.)
5760  *
5761  * PGC_POSTMASTER variables always have the same value in every child of a
5762  * particular postmaster, so the worker will certainly have the right
5763  * value already. Likewise, PGC_INTERNAL variables are set by special
5764  * mechanisms (if indeed they aren't compile-time constants). So we may
5765  * always skip these.
5766  *
5767  * Role must be handled specially because its current value can be an
5768  * invalid value (for instance, if someone dropped the role since we set
5769  * it). So if we tried to serialize it normally, we might get a failure.
5770  * We skip it here, and use another mechanism to ensure the worker has the
5771  * right value.
5772  *
5773  * For all other GUCs, we skip if the GUC has its compiled-in default
5774  * value (i.e., source == PGC_S_DEFAULT). On the leader side, this means
5775  * we don't send GUCs that have their default values, which typically
5776  * saves lots of work. On the worker side, this means we don't need to
5777  * reset the GUC to default because it already has that value. See
5778  * comments in RestoreGUCState for more info.
5779  */
5780  return gconf->context == PGC_POSTMASTER ||
5781  gconf->context == PGC_INTERNAL || gconf->source == PGC_S_DEFAULT ||
5782  strcmp(gconf->name, "role") == 0;
5783 }
5784 
5785 /*
5786  * estimate_variable_size:
5787  * Compute space needed for dumping the given GUC variable.
5788  *
5789  * It's OK to overestimate, but not to underestimate.
5790  */
5791 static Size
5793 {
5794  Size size;
5795  Size valsize = 0;
5796 
5797  /* Skippable GUCs consume zero space. */
5798  if (can_skip_gucvar(gconf))
5799  return 0;
5800 
5801  /* Name, plus trailing zero byte. */
5802  size = strlen(gconf->name) + 1;
5803 
5804  /* Get the maximum display length of the GUC value. */
5805  switch (gconf->vartype)
5806  {
5807  case PGC_BOOL:
5808  {
5809  valsize = 5; /* max(strlen('true'), strlen('false')) */
5810  }
5811  break;
5812 
5813  case PGC_INT:
5814  {
5815  struct config_int *conf = (struct config_int *) gconf;
5816 
5817  /*
5818  * Instead of getting the exact display length, use max
5819  * length. Also reduce the max length for typical ranges of
5820  * small values. Maximum value is 2147483647, i.e. 10 chars.
5821  * Include one byte for sign.
5822  */
5823  if (abs(*conf->variable) < 1000)
5824  valsize = 3 + 1;
5825  else
5826  valsize = 10 + 1;
5827  }
5828  break;
5829 
5830  case PGC_REAL:
5831  {
5832  /*
5833  * We are going to print it with %e with REALTYPE_PRECISION
5834  * fractional digits. Account for sign, leading digit,
5835  * decimal point, and exponent with up to 3 digits. E.g.
5836  * -3.99329042340000021e+110
5837  */
5838  valsize = 1 + 1 + 1 + REALTYPE_PRECISION + 5;
5839  }
5840  break;
5841 
5842  case PGC_STRING:
5843  {
5844  struct config_string *conf = (struct config_string *) gconf;
5845 
5846  /*
5847  * If the value is NULL, we transmit it as an empty string.
5848  * Although this is not physically the same value, GUC
5849  * generally treats a NULL the same as empty string.
5850  */
5851  if (*conf->variable)
5852  valsize = strlen(*conf->variable);
5853  else
5854  valsize = 0;
5855  }
5856  break;
5857 
5858  case PGC_ENUM:
5859  {
5860  struct config_enum *conf = (struct config_enum *) gconf;
5861 
5862  valsize = strlen(config_enum_lookup_by_value(conf, *conf->variable));
5863  }
5864  break;
5865  }
5866 
5867  /* Allow space for terminating zero-byte for value */
5868  size = add_size(size, valsize + 1);
5869 
5870  if (gconf->sourcefile)
5871  size = add_size(size, strlen(gconf->sourcefile));
5872 
5873  /* Allow space for terminating zero-byte for sourcefile */
5874  size = add_size(size, 1);
5875 
5876  /* Include line whenever file is nonempty. */
5877  if (gconf->sourcefile && gconf->sourcefile[0])
5878  size = add_size(size, sizeof(gconf->sourceline));
5879 
5880  size = add_size(size, sizeof(gconf->source));
5881  size = add_size(size, sizeof(gconf->scontext));
5882  size = add_size(size, sizeof(gconf->srole));
5883 
5884  return size;
5885 }
5886 
5887 /*
5888  * EstimateGUCStateSpace:
5889  * Returns the size needed to store the GUC state for the current process
5890  */
5891 Size
5893 {
5894  Size size;
5895  dlist_iter iter;
5896 
5897  /* Add space reqd for saving the data size of the guc state */
5898  size = sizeof(Size);
5899 
5900  /*
5901  * Add up the space needed for each GUC variable.
5902  *
5903  * We need only process non-default GUCs.
5904  */
5906  {
5907  struct config_generic *gconf = dlist_container(struct config_generic,
5908  nondef_link, iter.cur);
5909 
5911  }
5912 
5913  return size;
5914 }
5915 
5916 /*
5917  * do_serialize:
5918  * Copies the formatted string into the destination. Moves ahead the
5919  * destination pointer, and decrements the maxbytes by that many bytes. If
5920  * maxbytes is not sufficient to copy the string, error out.
5921  */
5922 static void
5923 do_serialize(char **destptr, Size *maxbytes, const char *fmt,...)
5924 {
5925  va_list vargs;
5926  int n;
5927 
5928  if (*maxbytes <= 0)
5929  elog(ERROR, "not enough space to serialize GUC state");
5930 
5931  va_start(vargs, fmt);
5932  n = vsnprintf(*destptr, *maxbytes, fmt, vargs);
5933  va_end(vargs);
5934 
5935  if (n < 0)
5936  {
5937  /* Shouldn't happen. Better show errno description. */
5938  elog(ERROR, "vsnprintf failed: %m with format string \"%s\"", fmt);
5939  }
5940  if (n >= *maxbytes)
5941  {
5942  /* This shouldn't happen either, really. */
5943  elog(ERROR, "not enough space to serialize GUC state");
5944  }
5945 
5946  /* Shift the destptr ahead of the null terminator */
5947  *destptr += n + 1;
5948  *maxbytes -= n + 1;
5949 }
5950 
5951 /* Binary copy version of do_serialize() */
5952 static void
5953 do_serialize_binary(char **destptr, Size *maxbytes, void *val, Size valsize)
5954 {
5955  if (valsize > *maxbytes)
5956  elog(ERROR, "not enough space to serialize GUC state");
5957 
5958  memcpy(*destptr, val, valsize);
5959  *destptr += valsize;
5960  *maxbytes -= valsize;
5961 }
5962 
5963 /*
5964  * serialize_variable:
5965  * Dumps name, value and other information of a GUC variable into destptr.
5966  */
5967 static void
5968 serialize_variable(char **destptr, Size *maxbytes,
5969  struct config_generic *gconf)
5970 {
5971  /* Ignore skippable GUCs. */
5972  if (can_skip_gucvar(gconf))
5973  return;
5974 
5975  do_serialize(destptr, maxbytes, "%s", gconf->name);
5976 
5977  switch (gconf->vartype)
5978  {
5979  case PGC_BOOL:
5980  {
5981  struct config_bool *conf = (struct config_bool *) gconf;
5982 
5983  do_serialize(destptr, maxbytes,
5984  (*conf->variable ? "true" : "false"));
5985  }
5986  break;
5987 
5988  case PGC_INT:
5989  {
5990  struct config_int *conf = (struct config_int *) gconf;
5991 
5992  do_serialize(destptr, maxbytes, "%d", *conf->variable);
5993  }
5994  break;
5995 
5996  case PGC_REAL:
5997  {
5998  struct config_real *conf = (struct config_real *) gconf;
5999 
6000  do_serialize(destptr, maxbytes, "%.*e",
6001  REALTYPE_PRECISION, *conf->variable);
6002  }
6003  break;
6004 
6005  case PGC_STRING:
6006  {
6007  struct config_string *conf = (struct config_string *) gconf;
6008 
6009  /* NULL becomes empty string, see estimate_variable_size() */
6010  do_serialize(destptr, maxbytes, "%s",
6011  *conf->variable ? *conf->variable : "");
6012  }
6013  break;
6014 
6015  case PGC_ENUM:
6016  {
6017  struct config_enum *conf = (struct config_enum *) gconf;
6018 
6019  do_serialize(destptr, maxbytes, "%s",
6020  config_enum_lookup_by_value(conf, *conf->variable));
6021  }
6022  break;
6023  }
6024 
6025  do_serialize(destptr, maxbytes, "%s",
6026  (gconf->sourcefile ? gconf->sourcefile : ""));
6027 
6028  if (gconf->sourcefile && gconf->sourcefile[0])
6029  do_serialize_binary(destptr, maxbytes, &gconf->sourceline,
6030  sizeof(gconf->sourceline));
6031 
6032  do_serialize_binary(destptr, maxbytes, &gconf->source,
6033  sizeof(gconf->source));
6034  do_serialize_binary(destptr, maxbytes, &gconf->scontext,
6035  sizeof(gconf->scontext));
6036  do_serialize_binary(destptr, maxbytes, &gconf->srole,
6037  sizeof(gconf->srole));
6038 }
6039 
6040 /*
6041  * SerializeGUCState:
6042  * Dumps the complete GUC state onto the memory location at start_address.
6043  */
6044 void
6045 SerializeGUCState(Size maxsize, char *start_address)
6046 {
6047  char *curptr;
6048  Size actual_size;
6049  Size bytes_left;
6050  dlist_iter iter;
6051 
6052  /* Reserve space for saving the actual size of the guc state */
6053  Assert(maxsize > sizeof(actual_size));
6054  curptr = start_address + sizeof(actual_size);
6055  bytes_left = maxsize - sizeof(actual_size);
6056 
6057  /* We need only consider GUCs with source not PGC_S_DEFAULT */
6059  {
6060  struct config_generic *gconf = dlist_container(struct config_generic,
6061  nondef_link, iter.cur);
6062 
6063  serialize_variable(&curptr, &bytes_left, gconf);
6064  }
6065 
6066  /* Store actual size without assuming alignment of start_address. */
6067  actual_size = maxsize - bytes_left - sizeof(actual_size);
6068  memcpy(start_address, &actual_size, sizeof(actual_size));
6069 }
6070 
6071 /*
6072  * read_gucstate:
6073  * Actually it does not read anything, just returns the srcptr. But it does
6074  * move the srcptr past the terminating zero byte, so that the caller is ready
6075  * to read the next string.
6076  */
6077 static char *
6078 read_gucstate(char **srcptr, char *srcend)
6079 {
6080  char *retptr = *srcptr;
6081  char *ptr;
6082 
6083  if (*srcptr >= srcend)
6084  elog(ERROR, "incomplete GUC state");
6085 
6086  /* The string variables are all null terminated */
6087  for (ptr = *srcptr; ptr < srcend && *ptr != '\0'; ptr++)
6088  ;
6089 
6090  if (ptr >= srcend)
6091  elog(ERROR, "could not find null terminator in GUC state");
6092 
6093  /* Set the new position to the byte following the terminating NUL */
6094  *srcptr = ptr + 1;
6095 
6096  return retptr;
6097 }
6098 
6099 /* Binary read version of read_gucstate(). Copies into dest */
6100 static void
6101 read_gucstate_binary(char **srcptr, char *srcend, void *dest, Size size)
6102 {
6103  if (*srcptr + size > srcend)
6104  elog(ERROR, "incomplete GUC state");
6105 
6106  memcpy(dest, *srcptr, size);
6107  *srcptr += size;
6108 }
6109 
6110 /*
6111  * Callback used to add a context message when reporting errors that occur
6112  * while trying to restore GUCs in parallel workers.
6113  */
6114 static void
6116 {
6117  char **error_context_name_and_value = (char **) arg;
6118 
6119  if (error_context_name_and_value)
6120  errcontext("while setting parameter \"%s\" to \"%s\"",
6121  error_context_name_and_value[0],
6122  error_context_name_and_value[1]);
6123 }
6124 
6125 /*
6126  * RestoreGUCState:
6127  * Reads the GUC state at the specified address and sets this process's
6128  * GUCs to match.
6129  *
6130  * Note that this provides the worker with only a very shallow view of the
6131  * leader's GUC state: we'll know about the currently active values, but not
6132  * about stacked or reset values. That's fine since the worker is just
6133  * executing one part of a query, within which the active values won't change
6134  * and the stacked values are invisible.
6135  */
6136 void
6137 RestoreGUCState(void *gucstate)
6138 {
6139  char *varname,
6140  *varvalue,
6141  *varsourcefile;
6142  int varsourceline;
6143  GucSource varsource;
6144  GucContext varscontext;
6145  Oid varsrole;
6146  char *srcptr = (char *) gucstate;
6147  char *srcend;
6148  Size len;
6149  dlist_mutable_iter iter;
6150  ErrorContextCallback error_context_callback;
6151 
6152  /*
6153  * First, ensure that all potentially-shippable GUCs are reset to their
6154  * default values. We must not touch those GUCs that the leader will
6155  * never ship, while there is no need to touch those that are shippable
6156  * but already have their default values. Thus, this ends up being the
6157  * same test that SerializeGUCState uses, even though the sets of
6158  * variables involved may well be different since the leader's set of
6159  * variables-not-at-default-values can differ from the set that are
6160  * not-default in this freshly started worker.
6161  *
6162  * Once we have set all the potentially-shippable GUCs to default values,
6163  * restoring the GUCs that the leader sent (because they had non-default
6164  * values over there) leads us to exactly the set of GUC values that the
6165  * leader has. This is true even though the worker may have initially
6166  * absorbed postgresql.conf settings that the leader hasn't yet seen, or
6167  * ALTER USER/DATABASE SET settings that were established after the leader
6168  * started.
6169  *
6170  * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
6171  * also ensures that set_config_option won't refuse to set them because of
6172  * source-priority comparisons.
6173  */
6175  {
6176  struct config_generic *gconf = dlist_container(struct config_generic,
6177  nondef_link, iter.cur);
6178 
6179  /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
6180  if (can_skip_gucvar(gconf))
6181  continue;
6182 
6183  /*
6184  * We can use InitializeOneGUCOption to reset the GUC to default, but
6185  * first we must free any existing subsidiary data to avoid leaking
6186  * memory. The stack must be empty, but we have to clean up all other
6187  * fields. Beware that there might be duplicate value or "extra"
6188  * pointers. We also have to be sure to take it out of any lists it's
6189  * in.
6190  */
6191  Assert(gconf->stack == NULL);
6192  guc_free(gconf->extra);
6193  guc_free(gconf->last_reported);
6194  guc_free(gconf->sourcefile);
6195  switch (gconf->vartype)
6196  {
6197  case PGC_BOOL:
6198  {
6199  struct config_bool *conf = (struct config_bool *) gconf;
6200 
6201  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6202  guc_free(conf->reset_extra);
6203  break;
6204  }
6205  case PGC_INT:
6206  {
6207  struct config_int *conf = (struct config_int *) gconf;
6208 
6209  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6210  guc_free(conf->reset_extra);
6211  break;
6212  }
6213  case PGC_REAL:
6214  {
6215  struct config_real *conf = (struct config_real *) gconf;
6216 
6217  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6218  guc_free(conf->reset_extra);
6219  break;
6220  }
6221  case PGC_STRING:
6222  {
6223  struct config_string *conf = (struct config_string *) gconf;
6224 
6225  guc_free(*conf->variable);
6226  if (conf->reset_val && conf->reset_val != *conf->variable)
6227  guc_free(conf->reset_val);
6228  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6229  guc_free(conf->reset_extra);
6230  break;
6231  }
6232  case PGC_ENUM:
6233  {
6234  struct config_enum *conf = (struct config_enum *) gconf;
6235 
6236  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6237  guc_free(conf->reset_extra);
6238  break;
6239  }
6240  }
6241  /* Remove it from any lists it's in. */
6242  RemoveGUCFromLists(gconf);
6243  /* Now we can reset the struct to PGS_S_DEFAULT state. */
6244  InitializeOneGUCOption(gconf);
6245  }
6246 
6247  /* First item is the length of the subsequent data */
6248  memcpy(&len, gucstate, sizeof(len));
6249 
6250  srcptr += sizeof(len);
6251  srcend = srcptr + len;
6252 
6253  /* If the GUC value check fails, we want errors to show useful context. */
6254  error_context_callback.callback = guc_restore_error_context_callback;
6255  error_context_callback.previous = error_context_stack;
6256  error_context_callback.arg = NULL;
6257  error_context_stack = &error_context_callback;
6258 
6259  /* Restore all the listed GUCs. */
6260  while (srcptr < srcend)
6261  {
6262  int result;
6263  char *error_context_name_and_value[2];
6264 
6265  varname = read_gucstate(&srcptr, srcend);
6266  varvalue = read_gucstate(&srcptr, srcend);
6267  varsourcefile = read_gucstate(&srcptr, srcend);
6268  if (varsourcefile[0])
6269  read_gucstate_binary(&srcptr, srcend,
6270  &varsourceline, sizeof(varsourceline));
6271  else
6272  varsourceline = 0;
6273  read_gucstate_binary(&srcptr, srcend,
6274  &varsource, sizeof(varsource));
6275  read_gucstate_binary(&srcptr, srcend,
6276  &varscontext, sizeof(varscontext));
6277  read_gucstate_binary(&srcptr, srcend,
6278  &varsrole, sizeof(varsrole));
6279 
6280  error_context_name_and_value[0] = varname;
6281  error_context_name_and_value[1] = varvalue;
6282  error_context_callback.arg = &error_context_name_and_value[0];
6283  result = set_config_option_ext(varname, varvalue,
6284  varscontext, varsource, varsrole,
6285  GUC_ACTION_SET, true, ERROR, true);
6286  if (result <= 0)
6287  ereport(ERROR,
6288  (errcode(ERRCODE_INTERNAL_ERROR),
6289  errmsg("parameter \"%s\" could not be set", varname)));
6290  if (varsourcefile[0])
6291  set_config_sourcefile(varname, varsourcefile, varsourceline);
6292  error_context_callback.arg = NULL;
6293  }
6294 
6295  error_context_stack = error_context_callback.previous;
6296 }
6297 
6298 /*
6299  * A little "long argument" simulation, although not quite GNU
6300  * compliant. Takes a string of the form "some-option=some value" and
6301  * returns name = "some_option" and value = "some value" in palloc'ed
6302  * storage. Note that '-' is converted to '_' in the option name. If
6303  * there is no '=' in the input string then value will be NULL.
6304  */
6305 void
6306 ParseLongOption(const char *string, char **name, char **value)
6307 {
6308  size_t equal_pos;
6309  char *cp;
6310 
6311  Assert(string);
6312  Assert(name);
6313  Assert(value);
6314 
6315  equal_pos = strcspn(string, "=");
6316 
6317  if (string[equal_pos] == '=')
6318  {
6319  *name = palloc(equal_pos + 1);
6320  strlcpy(*name, string, equal_pos + 1);
6321 
6322  *value = pstrdup(&string[equal_pos + 1]);
6323  }
6324  else
6325  {
6326  /* no equal sign in string */
6327  *name = pstrdup(string);
6328  *value = NULL;
6329  }
6330 
6331  for (cp = *name; *cp; cp++)
6332  if (*cp == '-')
6333  *cp = '_';
6334 }
6335 
6336 
6337 /*
6338  * Transform array of GUC settings into lists of names and values. The lists
6339  * are faster to process in cases where the settings must be applied
6340  * repeatedly (e.g. for each function invocation).
6341  */
6342 void
6344 {
6345  int i;
6346 
6347  Assert(array != NULL);
6348  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6349  Assert(ARR_NDIM(array) == 1);
6350  Assert(ARR_LBOUND(array)[0] == 1);
6351 
6352  *names = NIL;
6353  *values = NIL;
6354  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6355  {
6356  Datum d;
6357  bool isnull;
6358  char *s;
6359  char *name;
6360  char *value;
6361 
6362  d = array_ref(array, 1, &i,
6363  -1 /* varlenarray */ ,
6364  -1 /* TEXT's typlen */ ,
6365  false /* TEXT's typbyval */ ,
6366  TYPALIGN_INT /* TEXT's typalign */ ,
6367  &isnull);
6368 
6369  if (isnull)
6370  continue;
6371 
6372  s = TextDatumGetCString(d);
6373 
6374  ParseLongOption(s, &name, &value);
6375  if (!value)
6376  {
6377  ereport(WARNING,
6378  (errcode(ERRCODE_SYNTAX_ERROR),
6379  errmsg("could not parse setting for parameter \"%s\"",
6380  name)));
6381  pfree(name);
6382  continue;
6383  }
6384 
6385  *names = lappend(*names, name);
6386  *values = lappend(*values, value);
6387 
6388  pfree(s);
6389  }
6390 }
6391 
6392 
6393 /*
6394  * Handle options fetched from pg_db_role_setting.setconfig,
6395  * pg_proc.proconfig, etc. Caller must specify proper context/source/action.
6396  *
6397  * The array parameter must be an array of TEXT (it must not be NULL).
6398  */
6399 void
6402 {
6403  List *gucNames;
6404  List *gucValues;
6405  ListCell *lc1;
6406  ListCell *lc2;
6407 
6408  TransformGUCArray(array, &gucNames, &gucValues);
6409  forboth(lc1, gucNames, lc2, gucValues)
6410  {
6411  char *name = lfirst(lc1);
6412  char *value = lfirst(lc2);
6413 
6414  (void) set_config_option(name, value,
6415  context, source,
6416  action, true, 0, false);
6417 
6418  pfree(name);
6419  pfree(value);
6420  }
6421 
6422  list_free(gucNames);
6423  list_free(gucValues);
6424 }
6425 
6426 
6427 /*
6428  * Add an entry to an option array. The array parameter may be NULL
6429  * to indicate the current table entry is NULL.
6430  */
6431 ArrayType *
6432 GUCArrayAdd(ArrayType *array, const char *name, const char *value)
6433 {
6434  struct config_generic *record;
6435  Datum datum;
6436  char *newval;
6437  ArrayType *a;
6438 
6439  Assert(name);
6440  Assert(value);
6441 
6442  /* test if the option is valid and we're allowed to set it */
6443  (void) validate_option_array_item(name, value, false);
6444 
6445  /* normalize name (converts obsolete GUC names to modern spellings) */
6446  record = find_option(name, false, true, WARNING);
6447  if (record)
6448  name = record->name;
6449 
6450  /* build new item for array */
6451  newval = psprintf("%s=%s", name, value);
6452  datum = CStringGetTextDatum(newval);
6453 
6454  if (array)
6455  {
6456  int index;
6457  bool isnull;
6458  int i;
6459 
6460  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6461  Assert(ARR_NDIM(array) == 1);
6462  Assert(ARR_LBOUND(array)[0] == 1);
6463 
6464  index = ARR_DIMS(array)[0] + 1; /* add after end */
6465 
6466  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6467  {
6468  Datum d;
6469  char *current;
6470 
6471  d = array_ref(array, 1, &i,
6472  -1 /* varlenarray */ ,
6473  -1 /* TEXT's typlen */ ,
6474  false /* TEXT's typbyval */ ,
6475  TYPALIGN_INT /* TEXT's typalign */ ,
6476  &isnull);
6477  if (isnull)
6478  continue;
6479  current = TextDatumGetCString(d);
6480 
6481  /* check for match up through and including '=' */
6482  if (strncmp(current, newval, strlen(name) + 1) == 0)
6483  {
6484  index = i;
6485  break;
6486  }
6487  }
6488 
6489  a = array_set(array, 1, &index,
6490  datum,
6491  false,
6492  -1 /* varlena array */ ,
6493  -1 /* TEXT's typlen */ ,
6494  false /* TEXT's typbyval */ ,
6495  TYPALIGN_INT /* TEXT's typalign */ );
6496  }
6497  else
6498  a = construct_array_builtin(&datum, 1, TEXTOID);
6499 
6500  return a;
6501 }
6502 
6503 
6504 /*
6505  * Delete an entry from an option array. The array parameter may be NULL
6506  * to indicate the current table entry is NULL. Also, if the return value
6507  * is NULL then a null should be stored.
6508  */
6509 ArrayType *
6510 GUCArrayDelete(ArrayType *array, const char *name)
6511 {
6512  struct config_generic *record;
6513  ArrayType *newarray;
6514  int i;
6515  int index;
6516 
6517  Assert(name);
6518 
6519  /* test if the option is valid and we're allowed to set it */
6520  (void) validate_option_array_item(name, NULL, false);
6521 
6522  /* normalize name (converts obsolete GUC names to modern spellings) */
6523  record = find_option(name, false, true, WARNING);
6524  if (record)
6525  name = record->name;
6526 
6527  /* if array is currently null, then surely nothing to delete */
6528  if (!array)
6529  return NULL;
6530 
6531  newarray = NULL;
6532  index = 1;
6533 
6534  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6535  {
6536  Datum d;
6537  char *val;
6538  bool isnull;
6539 
6540  d = array_ref(array, 1, &i,
6541  -1 /* varlenarray */ ,
6542  -1 /* TEXT's typlen */ ,
6543  false /* TEXT's typbyval */ ,
6544  TYPALIGN_INT /* TEXT's typalign */ ,
6545  &isnull);
6546  if (isnull)
6547  continue;
6548  val = TextDatumGetCString(d);
6549 
6550  /* ignore entry if it's what we want to delete */
6551  if (strncmp(val, name, strlen(name)) == 0
6552  && val[strlen(name)] == '=')
6553  continue;
6554 
6555  /* else add it to the output array */
6556  if (newarray)
6557  newarray = array_set(newarray, 1, &index,
6558  d,
6559  false,
6560  -1 /* varlenarray */ ,
6561  -1 /* TEXT's typlen */ ,
6562  false /* TEXT's typbyval */ ,
6563  TYPALIGN_INT /* TEXT's typalign */ );
6564  else
6565  newarray = construct_array_builtin(&d, 1, TEXTOID);
6566 
6567  index++;
6568  }
6569 
6570  return newarray;
6571 }
6572 
6573 
6574 /*
6575  * Given a GUC array, delete all settings from it that our permission
6576  * level allows: if superuser, delete them all; if regular user, only
6577  * those that are PGC_USERSET or we have permission to set
6578  */
6579 ArrayType *
6581 {
6582  ArrayType *newarray;
6583  int i;
6584  int index;
6585 
6586  /* if array is currently null, nothing to do */
6587  if (!array)
6588  return NULL;
6589 
6590  /* if we're superuser, we can delete everything, so just do it */
6591  if (superuser())
6592  return NULL;
6593 
6594  newarray = NULL;
6595  index = 1;
6596 
6597  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6598  {
6599  Datum d;
6600  char *val;
6601  char *eqsgn;
6602  bool isnull;
6603 
6604  d = array_ref(array, 1, &i,
6605  -1 /* varlenarray */ ,
6606  -1 /* TEXT's typlen */ ,
6607  false /* TEXT's typbyval */ ,
6608  TYPALIGN_INT /* TEXT's typalign */ ,
6609  &isnull);
6610  if (isnull)
6611  continue;
6612  val = TextDatumGetCString(d);
6613 
6614  eqsgn = strchr(val, '=');
6615  *eqsgn = '\0';
6616 
6617  /* skip if we have permission to delete it */
6618  if (validate_option_array_item(val, NULL, true))
6619  continue;
6620 
6621  /* else add it to the output array */
6622  if (newarray)
6623  newarray = array_set(newarray, 1, &index,
6624  d,
6625  false,
6626  -1 /* varlenarray */ ,
6627  -1 /* TEXT's typlen */ ,
6628  false /* TEXT's typbyval */ ,
6629  TYPALIGN_INT /* TEXT's typalign */ );
6630  else
6631  newarray = construct_array_builtin(&d, 1, TEXTOID);
6632 
6633  index++;
6634  pfree(val);
6635  }
6636 
6637  return newarray;
6638 }
6639 
6640 /*
6641  * Validate a proposed option setting for GUCArrayAdd/Delete/Reset.
6642  *
6643  * name is the option name. value is the proposed value for the Add case,
6644  * or NULL for the Delete/Reset cases. If skipIfNoPermissions is true, it's
6645  * not an error to have no permissions to set the option.
6646  *
6647  * Returns true if OK, false if skipIfNoPermissions is true and user does not
6648  * have permission to change this option (all other error cases result in an
6649  * error being thrown).
6650  */
6651 static bool
6652 validate_option_array_item(const char *name, const char *value,
6653  bool skipIfNoPermissions)
6654 
6655 {
6656  struct config_generic *gconf;
6657 
6658  /*
6659  * There are three cases to consider:
6660  *
6661  * name is a known GUC variable. Check the value normally, check
6662  * permissions normally (i.e., allow if variable is USERSET, or if it's
6663  * SUSET and user is superuser or holds ACL_SET permissions).
6664  *
6665  * name is not known, but exists or can be created as a placeholder (i.e.,
6666  * it has a valid custom name). We allow this case if you're a superuser,
6667  * otherwise not. Superusers are assumed to know what they're doing. We
6668  * can't allow it for other users, because when the placeholder is
6669  * resolved it might turn out to be a SUSET variable. (With currently
6670  * available infrastructure, we can actually handle such cases within the
6671  * current session --- but once an entry is made in pg_db_role_setting,
6672  * it's assumed to be fully validated.)
6673  *
6674  * name is not known and can't be created as a placeholder. Throw error,
6675  * unless skipIfNoPermissions is true, in which case return false.
6676  */
6677  gconf = find_option(name, true, skipIfNoPermissions, ERROR);
6678  if (!gconf)
6679  {
6680  /* not known, failed to make a placeholder */
6681  return false;
6682  }
6683 
6684  if (gconf->flags & GUC_CUSTOM_PLACEHOLDER)
6685  {
6686  /*
6687  * We cannot do any meaningful check on the value, so only permissions
6688  * are useful to check.
6689  */
6690  if (superuser() ||
6692  return true;
6693  if (skipIfNoPermissions)
6694  return false;
6695  ereport(ERROR,
6696  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
6697  errmsg("permission denied to set parameter \"%s\"", name)));
6698  }
6699 
6700  /* manual permissions check so we can avoid an error being thrown */
6701  if (gconf->context == PGC_USERSET)
6702  /* ok */ ;
6703  else if (gconf->context == PGC_SUSET &&
6704  (superuser() ||
6706  /* ok */ ;
6707  else if (skipIfNoPermissions)
6708  return false;
6709  /* if a permissions error should be thrown, let set_config_option do it */
6710 
6711  /* test for permissions and valid option value */
6712  (void) set_config_option(name, value,
6714  PGC_S_TEST, GUC_ACTION_SET, false, 0, false);
6715 
6716  return true;
6717 }
6718 
6719 
6720 /*
6721  * Called by check_hooks that want to override the normal
6722  * ERRCODE_INVALID_PARAMETER_VALUE SQLSTATE for check hook failures.
6723  *
6724  * Note that GUC_check_errmsg() etc are just macros that result in a direct
6725  * assignment to the associated variables. That is ugly, but forced by the
6726  * limitations of C's macro mechanisms.
6727  */
6728 void
6729 GUC_check_errcode(int sqlerrcode)
6730 {
6731  GUC_check_errcode_value = sqlerrcode;
6732 }
6733 
6734 
6735 /*
6736  * Convenience functions to manage calling a variable's check_hook.
6737  * These mostly take care of the protocol for letting check hooks supply
6738  * portions of the error report on failure.
6739  */
6740 
6741 static bool
6742 call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra,
6743  GucSource source, int elevel)
6744 {
6745  /* Quick success if no hook */
6746  if (!conf->check_hook)
6747  return true;
6748 
6749  /* Reset variables that might be set by hook */
6750  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6751  GUC_check_errmsg_string = NULL;
6753  GUC_check_errhint_string = NULL;
6754 
6755  if (!conf->check_hook(newval, extra, source))
6756  {
6757  ereport(elevel,
6761  errmsg("invalid value for parameter \"%s\": %d",
6762  conf->gen.name, (int) *newval),
6766  errhint("%s", GUC_check_errhint_string) : 0));
6767  /* Flush any strings created in ErrorContext */
6768  FlushErrorState();
6769  return false;
6770  }
6771 
6772  return true;
6773 }
6774 
6775 static bool
6776 call_int_check_hook(struct config_int *conf, int *newval, void **extra,
6777  GucSource source, int elevel)
6778 {
6779  /* Quick success if no hook */
6780  if (!conf->check_hook)
6781  return true;
6782 
6783  /* Reset variables that might be set by hook */
6784  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6785  GUC_check_errmsg_string = NULL;
6787  GUC_check_errhint_string = NULL;
6788 
6789  if (!conf->check_hook(newval, extra, source))
6790  {
6791  ereport(elevel,
6795  errmsg("invalid value for parameter \"%s\": %d",
6796  conf->gen.name, *newval),
6800  errhint("%s", GUC_check_errhint_string) : 0));
6801  /* Flush any strings created in ErrorContext */
6802  FlushErrorState();
6803  return false;
6804  }
6805 
6806  return true;
6807 }
6808 
6809 static bool
6810 call_real_check_hook(struct config_real *conf, double *newval, void **extra,
6811  GucSource source, int elevel)
6812 {
6813  /* Quick success if no hook */
6814  if (!conf->check_hook)
6815  return true;
6816 
6817  /* Reset variables that might be set by hook */
6818  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6819  GUC_check_errmsg_string = NULL;
6821  GUC_check_errhint_string = NULL;
6822 
6823  if (!conf->check_hook(newval, extra, source))
6824  {
6825  ereport(elevel,
6829  errmsg("invalid value for parameter \"%s\": %g",
6830  conf->gen.name, *newval),
6834  errhint("%s", GUC_check_errhint_string) : 0));
6835  /* Flush any strings created in ErrorContext */
6836  FlushErrorState();
6837  return false;
6838  }
6839 
6840  return true;
6841 }
6842 
6843 static bool
6844 call_string_check_hook(struct config_string *conf, char **newval, void **extra,
6845  GucSource source, int elevel)
6846 {
6847  volatile bool result = true;
6848 
6849  /* Quick success if no hook */
6850  if (!conf->check_hook)
6851  return true;
6852 
6853  /*
6854  * If elevel is ERROR, or if the check_hook itself throws an elog
6855  * (undesirable, but not always avoidable), make sure we don't leak the
6856  * already-malloc'd newval string.
6857  */
6858  PG_TRY();
6859  {
6860  /* Reset variables that might be set by hook */
6861  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6862  GUC_check_errmsg_string = NULL;
6864  GUC_check_errhint_string = NULL;
6865 
6866  if (!conf->check_hook(newval, extra, source))
6867  {
6868  ereport(elevel,
6872  errmsg("invalid value for parameter \"%s\": \"%s\"",
6873  conf->gen.name, *newval ? *newval : ""),
6877  errhint("%s", GUC_check_errhint_string) : 0));
6878  /* Flush any strings created in ErrorContext */
6879  FlushErrorState();
6880  result = false;
6881  }
6882  }
6883  PG_CATCH();
6884  {
6885  guc_free(*newval);
6886  PG_RE_THROW();
6887  }
6888  PG_END_TRY();
6889 
6890  return result;
6891 }
6892 
6893 static bool
6894 call_enum_check_hook(struct config_enum *conf, int *newval, void **extra,
6895  GucSource source, int elevel)
6896 {
6897  /* Quick success if no hook */
6898  if (!conf->check_hook)
6899  return true;
6900 
6901  /* Reset variables that might be set by hook */
6902  GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6903  GUC_check_errmsg_string = NULL;
6905  GUC_check_errhint_string = NULL;
6906 
6907  if (!conf->check_hook(newval, extra, source))
6908  {
6909  ereport(elevel,
6913  errmsg("invalid value for parameter \"%s\": \"%s\"",
6914  conf->gen.name,
6919  errhint("%s", GUC_check_errhint_string) : 0));
6920  /* Flush any strings created in ErrorContext */
6921  FlushErrorState();
6922  return false;
6923  }
6924 
6925  return true;
6926 }
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
AclResult pg_parameter_aclcheck(const char *name, Oid roleid, AclMode mode)
Definition: aclchk.c:4104
#define ARR_NDIM(a)
Definition: array.h:290
#define ARR_ELEMTYPE(a)
Definition: array.h:292
#define ARR_DIMS(a)
Definition: array.h:294
#define ARR_LBOUND(a)
Definition: array.h:296
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3374
ArrayType * array_set(ArrayType *array, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3156
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:3139
TimestampTz PgReloadTime
Definition: timestamp.c:55
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1654
#define write_stderr(str)
Definition: parallel.c:184
static int32 next
Definition: blutils.c:221
bool parse_bool(const char *value, bool *result)
Definition: bool.c:30
static Datum values[MAXATTR]
Definition: bootstrap.c:152
#define CStringGetTextDatum(s)
Definition: builtins.h:97
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define unconstify(underlying_type, expr)
Definition: c.h:1232
unsigned int uint32
Definition: c.h:493
#define likely(x)
Definition: c.h:297
#define IS_HIGHBIT_SET(ch)
Definition: c.h:1142
#define gettext_noop(x)
Definition: c.h:1183
#define INT64_FORMAT
Definition: c.h:535
#define pg_attribute_printf(f, a)
Definition: c.h:178
#define unlikely(x)
Definition: c.h:298
size_t Size
Definition: c.h:592
#define CONF_FILE_START_DEPTH
Definition: conffiles.h:17
@ DestRemote
Definition: dest.h:89
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:352
long hash_get_num_entries(HTAB *hashp)
Definition: dynahash.c:1341
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1395
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1385
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1159
int errdetail_internal(const char *fmt,...)
Definition: elog.c:1232
int errcode_for_file_access(void)
Definition: elog.c:882
int errdetail(const char *fmt,...)
Definition: elog.c:1205
ErrorContextCallback * error_context_stack
Definition: elog.c:94
void FlushErrorState(void)
Definition: elog.c:1828
int errhint(const char *fmt,...)
Definition: elog.c:1319
int errcode(int sqlerrcode)
Definition: elog.c:859
int errmsg(const char *fmt,...)
Definition: elog.c:1072
#define _(x)
Definition: elog.c:90
#define LOG
Definition: elog.h:31
#define PG_RE_THROW()
Definition: elog.h:411
#define errcontext
Definition: elog.h:196
#define DEBUG3
Definition: elog.h:28
#define FATAL
Definition: elog.h:41
#define PG_TRY(...)
Definition: elog.h:370
#define WARNING
Definition: elog.h:36
#define PG_END_TRY(...)
Definition: elog.h:395
#define PANIC
Definition: elog.h:42
#define ERROR
Definition: elog.h:39
#define PG_CATCH(...)
Definition: elog.h:380
#define elog(elevel,...)
Definition: elog.h:224
#define ereport(elevel,...)
Definition: elog.h:149
#define DEBUG5
Definition: elog.h:26
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2583
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:782
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:1087
int FreeFile(FILE *file)
Definition: fd.c:2781
int pg_fsync(int fd)
Definition: fd.c:386
#define MCXT_ALLOC_NO_OOM
Definition: fe_memutils.h:17
bool IsUnderPostmaster
Definition: globals.c:117
char * DataDir
Definition: globals.c:68
void BeginReportingGUCOptions(void)
Definition: guc.c:2548
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:3025
static bool validate_option_array_item(const char *name, const char *value, bool skipIfNoPermissions)
Definition: guc.c:6652
void GUC_check_errcode(int sqlerrcode)
Definition: guc.c:6729
static const char *const map_old_guc_names[]
Definition: guc.c:193
static void guc_restore_error_context_callback(void *arg)
Definition: guc.c:6115
static void ReportGUCOption(struct config_generic *record)
Definition: guc.c:2636
void RestoreGUCState(void *gucstate)
Definition: guc.c:6137
static bool assignable_custom_variable_name(const char *name, bool skip_errors, int elevel)
Definition: guc.c:1123
void * guc_malloc(int elevel, size_t size)
Definition: guc.c:640
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1237
static dlist_head guc_nondef_list
Definition: guc.c:224
static bool parse_and_validate_value(struct config_generic *record, const char *name, const char *value, GucSource source, int elevel, union config_var_val *newval, void **newextra)
Definition: guc.c:3132
static int guc_name_match(const void *key1, const void *key2, Size keysize)
Definition: guc.c:1356
int set_config_option_ext(const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3373
static void do_serialize(char **destptr, Size *maxbytes, const char *fmt,...) pg_attribute_printf(3
Definition: guc.c:5923
bool parse_int(const char *value, int *result, int flags, const char **hintmsg)
Definition: guc.c:2873
static struct config_generic * init_custom_variable(const char *name, const char *short_desc, const char *long_desc, GucContext context, int flags, enum config_type type, size_t sz)
Definition: guc.c:4809
void guc_free(void *ptr)
Definition: guc.c:691
#define GUC_SAFE_SEARCH_PATH
Definition: guc.c:74
static slist_head guc_report_list
Definition: guc.c:228
struct config_generic ** get_guc_variables(int *num_vars)
Definition: guc.c:874
static void set_config_sourcefile(const char *name, char *sourcefile, int sourceline)
Definition: guc.c:4242
void DefineCustomRealVariable(const char *name, const char *short_desc, const char *long_desc, double *valueAddr, double bootValue, double minValue, double maxValue, GucContext context, int flags, GucRealCheckHook check_hook, GucRealAssignHook assign_hook, GucShowHook show_hook)
Definition: guc.c:5126
void DefineCustomEnumVariable(const char *name, const char *short_desc, const char *long_desc, int *valueAddr, int bootValue, const struct config_enum_entry *options, GucContext context, int flags, GucEnumCheckHook check_hook, GucEnumAssignHook assign_hook, GucShowHook show_hook)
Definition: guc.c:5181
static bool convert_to_base_unit(double value, const char *unit, int base_unit, double *base_value)
Definition: guc.c:2673
bool config_enum_lookup_by_name(struct config_enum *record, const char *value, int *retval)
Definition: guc.c:3048
static void do_serialize_binary(char **destptr, Size *maxbytes, void *val, Size valsize)
Definition: guc.c:5953
static void serialize_variable(char **destptr, Size *maxbytes, struct config_generic *gconf)
Definition: guc.c:5968
static void define_custom_variable(struct config_generic *variable)
Definition: guc.c:4869
static void set_string_field(struct config_string *conf, char **field, char *newval)
Definition: guc.c:733
int NewGUCNestLevel(void)
Definition: guc.c:2237
ArrayType * GUCArrayReset(ArrayType *array)
Definition: guc.c:6580
void ProcessGUCArray(ArrayType *array, GucContext context, GucSource source, GucAction action)
Definition: guc.c:6400
static bool valid_custom_variable_name(const char *name)
Definition: guc.c:1078
char * GUC_check_errhint_string
Definition: guc.c:83
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4275
static int guc_var_compare(const void *a, const void *b)
Definition: guc.c:1290
#define MAX_UNIT_LEN
Definition: guc.c:104
static void reapply_stacked_values(struct config_generic *variable, struct config_string *pHolder, GucStack *stack, const char *curvalue, GucContext curscontext, GucSource cursource, Oid cursrole)
Definition: guc.c:4978
void DefineCustomStringVariable(const char *name, const char *short_desc, const char *long_desc, char **valueAddr, const char *bootValue, GucContext context, int flags, GucStringCheckHook check_hook, GucStringAssignHook assign_hook, GucShowHook show_hook)
Definition: guc.c:5156
static bool call_string_check_hook(struct config_string *conf, char **newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6844
bool parse_real(const char *value, double *result, int flags, const char **hintmsg)
Definition: guc.c:2963
static void push_old_value(struct config_generic *gconf, GucAction action)
Definition: guc.c:2136
void DefineCustomBoolVariable(const char *name, const char *short_desc, const char *long_desc, bool *valueAddr, bool bootValue, GucContext context, int flags, GucBoolCheckHook check_hook, GucBoolAssignHook assign_hook, GucShowHook show_hook)
Definition: guc.c:5070
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head)
Definition: guc.c:4412
static void InitializeOneGUCOption(struct config_generic *gconf)
Definition: guc.c:1646
config_handle * get_config_handle(const char *name)
Definition: guc.c:4227
static char * read_gucstate(char **srcptr, char *srcend)
Definition: guc.c:6078
#define newval
static bool can_skip_gucvar(struct config_generic *gconf)
Definition: guc.c:5752
const char * GetConfigOptionResetString(const char *name)
Definition: guc.c:4348
void SerializeGUCState(Size maxsize, char *start_address)
Definition: guc.c:6045
static void pg_timezone_abbrev_initialize(void)
Definition: guc.c:1994
static const unit_conversion memory_unit_conversion_table[]
Definition: guc.c:124
bool SelectConfigFiles(const char *userDoption, const char *progname)
Definition: guc.c:1786
static int GUCNestLevel
Definition: guc.c:233
#define REALTYPE_PRECISION
Definition: guc.c:68
char * GUC_check_errmsg_string
Definition: guc.c:81
void AlterSystemSetConfigFile(AlterSystemStmt *altersysstmt)
Definition: guc.c:4550
#define IDENT_FILENAME
Definition: guc.c:57
Size EstimateGUCStateSpace(void)
Definition: guc.c:5892
char * ShowGUCOption(struct config_generic *record, bool use_units)
Definition: guc.c:5403
static const char *const memory_units_hint
Definition: guc.c:122
static void discard_stack_value(struct config_generic *gconf, config_var_value *val)
Definition: guc.c:848
static int GUC_check_errcode_value
Definition: guc.c:76
void AtStart_GUC(void)
Definition: guc.c:2217
const char * get_config_unit_name(int flags)
Definition: guc.c:2816
void ParseLongOption(const char *string, char **name, char **value)
Definition: guc.c:6306
void ResetAllOptions(void)
Definition: guc.c:2005
static void convert_int_from_base_unit(int64 base_value, int base_unit, int64 *value, const char **unit)
Definition: guc.c:2731
static void RemoveGUCFromLists(struct config_generic *gconf)
Definition: guc.c:1763
void build_guc_variables(void)
Definition: guc.c:905
static void set_stack_value(struct config_generic *gconf, config_var_value *val)
Definition: guc.c:814
void InitializeGUCOptions(void)
Definition: guc.c:1532
static void read_gucstate_binary(char **srcptr, char *srcend, void *dest, Size size)
Definition: guc.c:6101
ConfigVariable * ProcessConfigFileInternal(GucContext context, bool applySettings, int elevel)
Definition: guc.c:284
struct config_generic ** get_explain_guc_options(int *num)
Definition: guc.c:5269
void MarkGUCPrefixReserved(const char *className)
Definition: guc.c:5217
const char * GetConfigOption(const char *name, bool missing_ok, bool restrict_privileged)
Definition: guc.c:4298
char * GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
Definition: guc.c:5370
ArrayType * GUCArrayAdd(ArrayType *array, const char *name, const char *value)
Definition: guc.c:6432
static bool add_guc_variable(struct config_generic *var, int elevel)
Definition: guc.c:1049
static bool extra_field_used(struct config_generic *gconf, void *extra)
Definition: guc.c:749
void * guc_realloc(int elevel, void *old, size_t size)
Definition: guc.c:654
static List * reserved_class_prefix
Definition: guc.c:78
static void static bool call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6742
void RestrictSearchPath(void)
Definition: guc.c:2248
int GetConfigOptionFlags(const char *name, bool missing_ok)
Definition: guc.c:4395
char * GUC_check_errdetail_string
Definition: guc.c:82
bool in_hot_standby_guc
Definition: guc_tables.c:621
static uint32 guc_name_hash(const void *key, Size keysize)
Definition: guc.c:1332
static bool call_int_check_hook(struct config_int *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6776
void check_GUC_name_for_parameter_acl(const char *name)
Definition: guc.c:1412
static void InitializeGUCOptionsFromEnvironment(void)
Definition: guc.c:1591
static slist_head guc_stack_list
Definition: guc.c:226
int set_config_with_handle(const char *name, config_handle *handle, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3393
static const char *const time_units_hint
Definition: guc.c:159
char * convert_GUC_name_for_parameter_acl(const char *name)
Definition: guc.c:1376
ArrayType * GUCArrayDelete(ArrayType *array, const char *name)
Definition: guc.c:6510
static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
Definition: guc.c:4480
static Size estimate_variable_size(struct config_generic *gconf)
Definition: guc.c:5792
static struct config_generic * add_placeholder_variable(const char *name, int elevel)
Definition: guc.c:1179
static void convert_real_from_base_unit(double base_value, int base_unit, double *value, const char **unit)
Definition: guc.c:2773
char * config_enum_get_options(struct config_enum *record, const char *prefix, const char *suffix, const char *separator)
Definition: guc.c:3074
char * guc_strdup(int elevel, const char *src)
Definition: guc.c:679
#define HBA_FILENAME
Definition: guc.c:56
int guc_name_compare(const char *namea, const char *nameb)
Definition: guc.c:1302
static bool string_field_used(struct config_string *conf, char *strval)
Definition: guc.c:710
static void set_guc_source(struct config_generic *gconf, GucSource newsource)
Definition: guc.c:2113
void TransformGUCArray(ArrayType *array, List **names, List **values)
Definition: guc.c:6343
static bool call_real_check_hook(struct config_real *conf, double *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6810
static void set_extra_field(struct config_generic *gconf, void **field, void *newval)
Definition: guc.c:794
static const unit_conversion time_unit_conversion_table[]
Definition: guc.c:161
static HTAB * guc_hashtab
Definition: guc.c:214
static MemoryContext GUCMemoryContext
Definition: guc.c:201
void ReportChangedGUCOptions(void)
Definition: guc.c:2598
#define CONFIG_FILENAME
Definition: guc.c:55
void AtEOXact_GUC(bool isCommit, int nestLevel)
Definition: guc.c:2264
static bool call_enum_check_hook(struct config_enum *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6894
void DefineCustomIntVariable(const char *name, const char *short_desc, const char *long_desc, int *valueAddr, int bootValue, int minValue, int maxValue, GucContext context, int flags, GucIntCheckHook check_hook, GucIntAssignHook assign_hook, GucShowHook show_hook)
Definition: guc.c:5096
static bool reporting_enabled
Definition: guc.c:231
int set_config_option(const char *name, const char *value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3333
bool(* GucBoolCheckHook)(bool *newval, void **extra, GucSource source)
Definition: guc.h:179
#define PG_AUTOCONF_FILENAME
Definition: guc.h:33
GucAction
Definition: guc.h:197
@ GUC_ACTION_SAVE
Definition: guc.h:201
@ GUC_ACTION_SET
Definition: guc.h:199
@ GUC_ACTION_LOCAL
Definition: guc.h:200
void FreeConfigVariables(ConfigVariable *list)
#define GUC_UNIT_MB
Definition: guc.h:230
#define GUC_EXPLAIN
Definition: guc.h:215
#define GUC_UNIT
Definition: guc.h:239
#define GUC_NO_RESET_ALL
Definition: guc.h:214
bool ParseConfigFp(FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
bool(* GucRealCheckHook)(double *newval, void **extra, GucSource source)
Definition: guc.h:181
void(* GucStringAssignHook)(const char *newval, void *extra)
Definition: guc.h:188
bool(* GucEnumCheckHook)(int *newval, void **extra, GucSource source)
Definition: guc.h:183
#define GUC_NO_RESET
Definition: guc.h:213
void(* GucBoolAssignHook)(bool newval, void *extra)
Definition: guc.h:185
#define GUC_CUSTOM_PLACEHOLDER
Definition: guc.h:219
#define GUC_LIST_QUOTE
Definition: guc.h:211
void(* GucEnumAssignHook)(int newval, void *extra)
Definition: guc.h:189
#define GUC_UNIT_MS
Definition: guc.h:234
#define GUC_NOT_WHILE_SEC_REST
Definition: guc.h:222
#define GUC_UNIT_BLOCKS
Definition: guc.h:228
#define GUC_UNIT_XBLOCKS
Definition: guc.h:229
#define GUC_IS_NAME
Definition: guc.h:221
#define GUC_DISALLOW_IN_FILE
Definition: guc.h:218
const char *(* GucShowHook)(void)
Definition: guc.h:191
GucSource
Definition: guc.h:108
@ PGC_S_DEFAULT
Definition: guc.h:109
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:110
@ PGC_S_FILE
Definition: guc.h:112
@ PGC_S_GLOBAL
Definition: guc.h:114
@ PGC_S_DATABASE
Definition: guc.h:115
@ PGC_S_OVERRIDE
Definition: guc.h:119
@ PGC_S_SESSION
Definition: guc.h:122
@ PGC_S_CLIENT
Definition: guc.h:118
@ PGC_S_DATABASE_USER
Definition: guc.h:117
@ PGC_S_ENV_VAR
Definition: guc.h:111
@ PGC_S_USER
Definition: guc.h:116
@ PGC_S_TEST
Definition: guc.h:121
@ PGC_S_INTERACTIVE
Definition: guc.h:120
#define GUC_NO_SHOW_ALL
Definition: guc.h:212
bool(* GucStringCheckHook)(char **newval, void **extra, GucSource source)
Definition: guc.h:182
#define GUC_DISALLOW_IN_AUTO_FILE
Definition: guc.h:223
bool ParseConfigFile(const char *config_file, bool strict, const char *calling_file, int calling_lineno, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
void(* GucIntAssignHook)(int newval, void *extra)
Definition: guc.h:186
void(* GucRealAssignHook)(double newval, void *extra)
Definition: guc.h:187
GucContext
Definition: guc.h:68
@ PGC_SUSET
Definition: guc.h:74
@ PGC_INTERNAL
Definition: guc.h:69
@ PGC_USERSET
Definition: guc.h:75
@ PGC_SU_BACKEND
Definition: guc.h:72
@ PGC_POSTMASTER
Definition: guc.h:70
@ PGC_SIGHUP
Definition: guc.h:71
@ PGC_BACKEND
Definition: guc.h:73
#define GUC_UNIT_BYTE
Definition: guc.h:231
bool(* GucIntCheckHook)(int *newval, void **extra, GucSource source)
Definition: guc.h:180
#define GUC_NOT_IN_SAMPLE
Definition: guc.h:217
#define GUC_UNIT_S
Definition: guc.h:235
#define GUC_REPORT
Definition: guc.h:216
#define GUC_UNIT_KB
Definition: guc.h:227
#define GUC_QUALIFIER_SEPARATOR
Definition: guc.h:204
void ProcessConfigFile(GucContext context)
#define GUC_UNIT_MIN
Definition: guc.h:236
#define GUC_UNIT_MEMORY
Definition: guc.h:232
char * ExtractSetVariableArgs(VariableSetStmt *stmt)
Definition: guc_funcs.c:167
bool ConfigOptionIsVisible(struct config_generic *conf)
Definition: guc_funcs.c:581
void record_config_file_error(const char *errmsg, const char *config_file, int lineno, ConfigVariable **head_p, ConfigVariable **tail_p)
struct config_string ConfigureNamesString[]
Definition: guc_tables.c:3917
char * HbaFileName
Definition: guc_tables.c:540
char * ConfigFileName
Definition: guc_tables.c:539
struct config_int ConfigureNamesInt[]
Definition: guc_tables.c:2028
struct config_bool ConfigureNamesBool[]
Definition: guc_tables.c:769
struct config_real ConfigureNamesReal[]
Definition: guc_tables.c:3636
char * IdentFileName
Definition: guc_tables.c:541
struct config_enum ConfigureNamesEnum[]
Definition: guc_tables.c:4694
#define GUC_IS_IN_FILE
Definition: guc_tables.h:187
@ GUC_SET_LOCAL
Definition: guc_tables.h:114
@ GUC_SET
Definition: guc_tables.h:112
@ GUC_SAVE
Definition: guc_tables.h:111
@ GUC_LOCAL
Definition: guc_tables.h:113
@ CUSTOM_OPTIONS
Definition: guc_tables.h:100
#define GUC_NEEDS_REPORT
Definition: guc_tables.h:193
config_type
Definition: guc_tables.h:24
@ PGC_BOOL
Definition: guc_tables.h:25
@ PGC_STRING
Definition: guc_tables.h:28
@ PGC_ENUM
Definition: guc_tables.h:29
@ PGC_REAL
Definition: guc_tables.h:27
@ PGC_INT
Definition: guc_tables.h:26
#define GUC_PENDING_RESTART
Definition: guc_tables.h:192
#define free(a)
Definition: header.h:65
@ HASH_FIND
Definition: hsearch.h:113
@ HASH_REMOVE
Definition: hsearch.h:115
@ HASH_ENTER
Definition: hsearch.h:114
@ HASH_ENTER_NULL
Definition: hsearch.h:116
#define HASH_CONTEXT
Definition: hsearch.h:102
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_COMPARE
Definition: hsearch.h:99
#define HASH_FUNCTION
Definition: hsearch.h:98
void slist_delete(slist_head *head, const slist_node *node)
Definition: ilist.c:31
static void slist_delete_current(slist_mutable_iter *iter)
Definition: ilist.h:1084
#define dlist_foreach(iter, lhead)
Definition: ilist.h:623
static void dlist_delete(dlist_node *node)
Definition: ilist.h:405
#define slist_foreach_modify(iter, lhead)
Definition: ilist.h:1148
#define dlist_foreach_modify(iter, lhead)
Definition: ilist.h:640
static void slist_push_head(slist_head *head, slist_node *node)
Definition: ilist.h:1006
static void dlist_push_tail(dlist_head *head, dlist_node *node)
Definition: ilist.h:364
#define slist_container(type, membername, ptr)
Definition: ilist.h:1106
#define dlist_container(type, membername, ptr)
Definition: ilist.h:593
long val
Definition: informix.c:664
static struct @150 value
#define close(a)
Definition: win32.h:12
#define write(a, b, c)
Definition: win32.h:14
int b
Definition: isn.c:70
int a
Definition: isn.c:69
int i
Definition: isn.c:73
static void const char * fmt
va_end(args)
Assert(fmt[strlen(fmt) - 1] !='\n')
va_start(args, fmt)
List * lappend(List *list, void *datum)
Definition: list.c:339
void list_free(List *list)
Definition: list.c:1546
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1172
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1785
@ LW_EXCLUSIVE
Definition: lwlock.h:116
const char * progname
Definition: main.c:44
const char * GetDatabaseEncodingName(void)
Definition: mbutils.c:1267
MemoryContext TopTransactionContext
Definition: mcxt.c:142
char * pstrdup(const char *in)
Definition: mcxt.c:1683
void pfree(void *pointer)
Definition: mcxt.c:1508
MemoryContext TopMemoryContext
Definition: mcxt.c:137
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1202
void * MemoryContextAllocExtended(MemoryContext context, Size size, int flags)
Definition: mcxt.c:1225
MemoryContext GetMemoryChunkContext(void *pointer)
Definition: mcxt.c:695
void * palloc(Size size)
Definition: mcxt.c:1304
void * repalloc_extended(void *pointer, Size size, int flags)
Definition: mcxt.c:1569
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:153
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:451
bool InSecurityRestrictedOperation(void)
Definition: miscinit.c:662
Oid GetUserId(void)
Definition: miscinit.c:514
bool InLocalUserIdChange(void)
Definition: miscinit.c:653
void SetDataDir(const char *dir)
Definition: miscinit.c:434
bool process_shared_preload_libraries_in_progress
Definition: miscinit.c:1778
#define InvokeObjectPostAlterHookArgStr(classId, objectName, subId, auxiliaryId, is_internal)
Definition: objectaccess.h:247
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
#define ACL_SET
Definition: parsenodes.h:88
@ VAR_SET_DEFAULT
Definition: parsenodes.h:2462
@ VAR_RESET
Definition: parsenodes.h:2465
@ VAR_SET_VALUE
Definition: parsenodes.h:2461
@ VAR_RESET_ALL
Definition: parsenodes.h:2466
#define ACL_ALTER_SYSTEM
Definition: parsenodes.h:89
void * arg
static uint32 pg_rotate_left32(uint32 word, int n)
Definition: pg_bitutils.h:326
#define MAXPGPATH
const void size_t len
const void * data
static char * filename
Definition: pg_dumpall.c:121
#define lfirst(lc)
Definition: pg_list.h:172
#define NIL
Definition: pg_list.h:68
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:518
static char ** options
static void bail_out(bool noatexit, const char *fmt,...) pg_attribute_printf(2
Definition: pg_regress.c:254
static rewind_source * source
Definition: pg_rewind.c:89
static char * buf
Definition: pg_test_fsync.c:73
void pg_timezone_initialize(void)
Definition: pgtz.c:361
#define vsnprintf
Definition: port.h:237
char * make_absolute_path(const char *path)
Definition: path.c:729
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
#define sprintf
Definition: port.h:240
#define snprintf
Definition: port.h:238
#define fprintf
Definition: port.h:242
#define qsort(a, b, c, d)
Definition: port.h:449
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
char * escape_single_quotes_ascii(const char *src)
Definition: quotes.c:33
CommandDest whereToSendOutput
Definition: postgres.c:90
long get_stack_depth_rlimit(void)
Definition: postgres.c:4961
static const char * userDoption
Definition: postgres.c:161
uintptr_t Datum
Definition: postgres.h:64
unsigned int Oid
Definition: postgres_ext.h:31
void pq_sendstring(StringInfo buf, const char *str)
Definition: pqformat.c:195
void pq_endmessage(StringInfo buf)
Definition: pqformat.c:296
void pq_beginmessage(StringInfo buf, char msgtype)
Definition: pqformat.c:88
e
Definition: preproc-init.c:82
static int fd(const char *x, int i)
Definition: preproc-init.c:105
#define PqMsg_ParameterStatus
Definition: protocol.h:51
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
void truncate_identifier(char *ident, int len, bool warn)
Definition: scansup.c:93
Size add_size(Size s1, Size s2)
Definition: shmem.c:493
static pg_noinline void Size size
Definition: slab.c:607
static void error(void)
Definition: sql-dyntest.c:147
void resetStringInfo(StringInfo str)
Definition: stringinfo.c:78
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
Definition: stringinfo.c:233
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:182
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
VariableSetStmt * setstmt
Definition: parsenodes.h:3669
char * name
Definition: guc.h:137
bool ignore
Definition: guc.h:142
struct ConfigVariable * next
Definition: guc.h:144
bool applied
Definition: guc.h:143
char * filename
Definition: guc.h:140
int sourceline
Definition: guc.h:141
char * value
Definition: guc.h:138
char * errmsg
Definition: guc.h:139
struct ErrorContextCallback * previous
Definition: elog.h:295
void(* callback)(void *arg)
Definition: elog.h:296
const char * gucname
Definition: guc.c:210
struct config_generic * gucvar
Definition: guc.c:211
Size keysize
Definition: hsearch.h:75
HashValueFunc hash
Definition: hsearch.h:78
Size entrysize
Definition: hsearch.h:76
HashCompareFunc match
Definition: hsearch.h:80
MemoryContext hcxt
Definition: hsearch.h:86
Definition: dynahash.c:220
Definition: pg_list.h:54
VariableSetKind kind
Definition: parsenodes.h:2472
void * reset_extra
Definition: guc_tables.h:209
struct config_generic gen
Definition: guc_tables.h:200
bool * variable
Definition: guc_tables.h:202
GucBoolCheckHook check_hook
Definition: guc_tables.h:204
bool reset_val
Definition: guc_tables.h:208
GucBoolAssignHook assign_hook
Definition: guc_tables.h:205
bool boot_val
Definition: guc_tables.h:203
GucShowHook show_hook
Definition: guc_tables.h:206
Definition: guc.h:170
const char * name
Definition: guc.h:171
int val
Definition: guc.h:172
bool hidden
Definition: guc.h:173
const struct config_enum_entry * options
Definition: guc_tables.h:274
int * variable
Definition: guc_tables.h:272
GucEnumAssignHook assign_hook
Definition: guc_tables.h:276
struct config_generic gen
Definition: guc_tables.h:270
void * reset_extra
Definition: guc_tables.h:280
GucEnumCheckHook check_hook
Definition: guc_tables.h:275
GucShowHook show_hook
Definition: guc_tables.h:277
dlist_node nondef_link
Definition: guc_tables.h:173
char * last_reported
Definition: guc_tables.h:179
enum config_group group
Definition: guc_tables.h:158
GucContext context
Definition: guc_tables.h:157
const char * long_desc
Definition: guc_tables.h:160
GucContext scontext
Definition: guc_tables.h:167
const char * name
Definition: guc_tables.h:156
slist_node stack_link
Definition: guc_tables.h:175
const char * short_desc
Definition: guc_tables.h:159
char * sourcefile
Definition: guc_tables.h:181
GucContext reset_scontext
Definition: guc_tables.h:168
GucStack * stack
Definition: guc_tables.h:171
enum config_type vartype
Definition: guc_tables.h:163
GucSource source
Definition: guc_tables.h:165
GucSource reset_source
Definition: guc_tables.h:166
slist_node report_link
Definition: guc_tables.h:177
void * reset_extra
Definition: guc_tables.h:225
int reset_val
Definition: guc_tables.h:224
int boot_val
Definition: guc_tables.h:217
GucIntAssignHook assign_hook
Definition: guc_tables.h:221
int * variable
Definition: guc_tables.h:216
GucIntCheckHook check_hook
Definition: guc_tables.h:220
GucShowHook show_hook
Definition: guc_tables.h:222
struct config_generic gen
Definition: guc_tables.h:214
double boot_val
Definition: guc_tables.h:233
void * reset_extra
Definition: guc_tables.h:241
double reset_val
Definition: guc_tables.h:240
GucRealAssignHook assign_hook
Definition: guc_tables.h:237
double * variable
Definition: guc_tables.h:232
double min
Definition: guc_tables.h:234
double max
Definition: guc_tables.h:235
struct config_generic gen
Definition: guc_tables.h:230
GucShowHook show_hook
Definition: guc_tables.h:238
GucRealCheckHook check_hook
Definition: guc_tables.h:236
struct config_generic gen
Definition: guc_tables.h:256
char * reset_val
Definition: guc_tables.h:264
GucStringCheckHook check_hook
Definition: guc_tables.h:260
GucStringAssignHook assign_hook
Definition: guc_tables.h:261
GucShowHook show_hook
Definition: guc_tables.h:262
char ** variable
Definition: guc_tables.h:258
void * reset_extra
Definition: guc_tables.h:265
const char * boot_val
Definition: guc_tables.h:259
union config_var_val val
Definition: guc_tables.h:47
dlist_node * cur
Definition: ilist.h:179
dlist_node * cur
Definition: ilist.h:200
struct guc_stack * prev
Definition: guc_tables.h:119
Oid masked_srole
Definition: guc_tables.h:127
int nest_level
Definition: guc_tables.h:120
config_var_value masked
Definition: guc_tables.h:129
config_var_value prior
Definition: guc_tables.h:128
GucContext scontext
Definition: guc_tables.h:124
GucStackState state
Definition: guc_tables.h:121
GucSource source
Definition: guc_tables.h:122
GucContext masked_scontext
Definition: guc_tables.h:125
Definition: type.h:95
slist_node * cur
Definition: ilist.h:274
double multiplier
Definition: guc.c:111
int base_unit
Definition: guc.c:110
char unit[MAX_UNIT_LEN+1]
Definition: guc.c:108
char * name
Definition: type.h:178
bool superuser(void)
Definition: superuser.c:46
#define STACK_DEPTH_SLOP
Definition: tcopprot.h:25
double realval
Definition: guc_tables.h:36
char * stringval
Definition: guc_tables.h:37
const char * type
const char * name
#define stat
Definition: win32_port.h:284
bool IsInParallelMode(void)
Definition: xact.c:1070
bool RecoveryInProgress(void)
Definition: xlog.c:6201
static void infile(const char *name)
Definition: zic.c:1243