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