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