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