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