Age Owner Branch data TLA 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 *
579 tgl@sss.pgh.pa.us 284 :CBC 2617 : ProcessConfigFileInternal(GucContext context, bool applySettings, int elevel)
285 : : {
286 : 2617 : bool error = false;
287 : 2617 : 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 : 2617 : ConfFileWithError = ConfigFileName;
297 : 2617 : head = tail = NULL;
298 : :
299 [ - + ]: 2617 : 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 */
579 tgl@sss.pgh.pa.us 304 :UBC 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 : : */
579 tgl@sss.pgh.pa.us 314 [ + + ]:CBC 2617 : if (DataDir)
315 : : {
316 [ - + ]: 1713 : 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 */
579 tgl@sss.pgh.pa.us 321 :UBC 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 : : */
579 tgl@sss.pgh.pa.us 336 :CBC 904 : ConfigVariable *newlist = NULL;
337 : :
338 : : /*
339 : : * Prune all items except the last "data_directory" from the list.
340 : : */
341 [ + + ]: 23675 : for (item = head; item; item = item->next)
342 : : {
343 [ + - ]: 22771 : if (!item->ignore &&
344 [ - + ]: 22771 : strcmp(item->name, "data_directory") == 0)
579 tgl@sss.pgh.pa.us 345 :UBC 0 : newlist = item;
346 : : }
347 : :
579 tgl@sss.pgh.pa.us 348 [ - + ]:CBC 904 : if (newlist)
579 tgl@sss.pgh.pa.us 349 :UBC 0 : newlist->next = NULL;
579 tgl@sss.pgh.pa.us 350 :CBC 904 : 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 [ + - ]: 904 : if (head == NULL)
360 : 904 : 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 : : */
548 368 : 1713 : hash_seq_init(&status, guc_hashtab);
369 [ + + ]: 659577 : while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
370 : : {
371 : 657864 : struct config_generic *gconf = hentry->gucvar;
372 : :
579 373 : 657864 : 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 [ + + ]: 49591 : for (item = head; item; item = item->next)
390 : : {
391 : : struct config_generic *record;
392 : :
393 : : /* Ignore anything already marked as ignorable */
394 [ - + ]: 47878 : if (item->ignore)
579 tgl@sss.pgh.pa.us 395 :UBC 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 : : */
579 tgl@sss.pgh.pa.us 401 :CBC 47878 : record = find_option(item->name, false, true, elevel);
402 : :
403 [ + + ]: 47878 : if (record)
404 : : {
405 : : /* If it's already marked, then this is a duplicate entry */
406 [ + + ]: 47854 : 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 [ + + ]: 135198 : for (pitem = head; pitem != item; pitem = pitem->next)
416 : : {
417 [ + + ]: 130770 : if (!pitem->ignore &&
418 [ + + ]: 117960 : strcmp(pitem->name, item->name) == 0)
419 : 4428 : pitem->ignore = true;
420 : : }
421 : : }
422 : : /* Now mark it as present in file */
423 : 47854 : record->status |= GUC_IS_IN_FILE;
424 : : }
425 [ + + ]: 24 : else if (!valid_custom_variable_name(item->name))
426 : : {
427 : : /* Invalid non-custom variable, so complain */
428 [ + - ]: 1 : 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 : 1 : item->errmsg = pstrdup("unrecognized configuration parameter");
434 : 1 : error = true;
435 : 1 : 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 [ + + ]: 1713 : if (error)
444 : 1 : goto bail_out;
445 : :
446 : : /* Otherwise, set flag that we're beginning to apply changes */
447 : 1712 : 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 : : */
548 455 : 1712 : hash_seq_init(&status, guc_hashtab);
456 [ + + ]: 659192 : while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
457 : : {
458 : 657480 : struct config_generic *gconf = hentry->gucvar;
459 : : GucStack *stack;
460 : :
579 461 [ + + ]: 657480 : if (gconf->reset_source != PGC_S_FILE ||
462 [ + + ]: 22232 : (gconf->status & GUC_IS_IN_FILE))
463 : 657472 : continue;
464 [ - + ]: 8 : if (gconf->context < PGC_SIGHUP)
465 : : {
466 : : /* The removal can't be effective without a restart */
579 tgl@sss.pgh.pa.us 467 :UBC 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() */
579 tgl@sss.pgh.pa.us 481 [ - + ]:CBC 8 : if (!applySettings)
579 tgl@sss.pgh.pa.us 482 :UBC 0 : continue;
483 : :
484 : : /*
485 : : * Reset any "file" sources to "default", else set_config_option will
486 : : * not override those settings.
487 : : */
579 tgl@sss.pgh.pa.us 488 [ + - ]:CBC 8 : if (gconf->reset_source == PGC_S_FILE)
489 : 8 : gconf->reset_source = PGC_S_DEFAULT;
490 [ + - ]: 8 : if (gconf->source == PGC_S_FILE)
548 491 : 8 : set_guc_source(gconf, PGC_S_DEFAULT);
579 492 [ - + ]: 8 : for (stack = gconf->stack; stack; stack = stack->prev)
493 : : {
579 tgl@sss.pgh.pa.us 494 [ # # ]:UBC 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) */
579 tgl@sss.pgh.pa.us 499 [ + - ]:CBC 8 : 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 [ + - ]: 8 : if (context == PGC_SIGHUP)
505 [ + + ]: 8 : 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 [ + + + + ]: 1712 : if (context == PGC_SIGHUP && applySettings)
525 : : {
526 : 806 : InitializeGUCOptionsFromEnvironment();
527 : 806 : pg_timezone_abbrev_initialize();
528 : : /* this selects SQL_ASCII in processes not connected to a database */
529 : 806 : 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 [ + + ]: 49575 : for (item = head; item; item = item->next)
537 : : {
538 : 47864 : char *pre_value = NULL;
539 : : int scres;
540 : :
541 : : /* Ignore anything marked as ignorable */
542 [ + + ]: 47864 : if (item->ignore)
543 : 4428 : continue;
544 : :
545 : : /* In SIGHUP cases in the postmaster, we want to report changes */
546 [ + + + + : 43436 : if (context == PGC_SIGHUP && applySettings && !IsUnderPostmaster)
+ + ]
547 : : {
548 : 3561 : const char *preval = GetConfigOption(item->name, true, false);
549 : :
550 : : /* If option doesn't exist yet or is NULL, treat as empty string */
551 [ + + ]: 3561 : if (!preval)
579 tgl@sss.pgh.pa.us 552 :GBC 1 : preval = "";
553 : : /* must dup, else might have dangling pointer below */
579 tgl@sss.pgh.pa.us 554 :CBC 3561 : pre_value = pstrdup(preval);
555 : : }
556 : :
557 : 43436 : scres = set_config_option(item->name, item->value,
558 : : context, PGC_S_FILE,
559 : : GUC_ACTION_SET, applySettings, 0, false);
560 [ + + ]: 43435 : if (scres > 0)
561 : : {
562 : : /* variable was updated, so log the change if appropriate */
563 [ + + ]: 35234 : if (pre_value)
564 : : {
565 : 2338 : const char *post_value = GetConfigOption(item->name, true, false);
566 : :
567 [ - + ]: 2338 : if (!post_value)
579 tgl@sss.pgh.pa.us 568 :UBC 0 : post_value = "";
579 tgl@sss.pgh.pa.us 569 [ + + ]:CBC 2338 : if (strcmp(pre_value, post_value) != 0)
570 [ + - ]: 96 : ereport(elevel,
571 : : (errmsg("parameter \"%s\" changed to \"%s\"",
572 : : item->name, item->value)));
573 : : }
574 : 35234 : item->applied = true;
575 : : }
576 [ - + ]: 8201 : else if (scres == 0)
577 : : {
579 tgl@sss.pgh.pa.us 578 :UBC 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 */
579 tgl@sss.pgh.pa.us 585 :CBC 8201 : 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 [ + - + + ]: 43435 : if (scres != 0 && applySettings)
595 : 43359 : set_config_sourcefile(item->name, item->filename,
596 : : item->sourceline);
597 : :
598 [ + + ]: 43435 : if (pre_value)
599 : 3561 : pfree(pre_value);
600 : : }
601 : :
602 : : /* Remember when we last successfully loaded the config file. */
603 [ + + ]: 1711 : if (applySettings)
604 : 1708 : PgReloadTime = GetCurrentTimestamp();
605 : :
606 : 3 : bail_out:
607 [ + + + - ]: 2616 : if (error && applySettings)
608 : : {
609 : : /* During postmaster startup, any error is fatal */
610 [ + - ]: 1 : if (context == PGC_POSTMASTER)
611 [ + - ]: 1 : ereport(ERROR,
612 : : (errcode(ERRCODE_CONFIG_FILE_ERROR),
613 : : errmsg("configuration file \"%s\" contains errors",
614 : : ConfFileWithError)));
579 tgl@sss.pgh.pa.us 615 [ # # ]:UBC 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 */
579 tgl@sss.pgh.pa.us 628 :CBC 2615 : 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 : 688136 : guc_malloc(int elevel, size_t size)
641 : : {
642 : : void *data;
643 : :
548 644 : 688136 : data = MemoryContextAllocExtended(GUCMemoryContext, size,
645 : : MCXT_ALLOC_NO_OOM);
646 [ - + ]: 688136 : if (unlikely(data == NULL))
579 tgl@sss.pgh.pa.us 647 [ # # ]:UBC 0 : ereport(elevel,
648 : : (errcode(ERRCODE_OUT_OF_MEMORY),
649 : : errmsg("out of memory")));
579 tgl@sss.pgh.pa.us 650 :CBC 688136 : return data;
651 : : }
652 : :
653 : : void *
579 tgl@sss.pgh.pa.us 654 :UBC 0 : guc_realloc(int elevel, void *old, size_t size)
655 : : {
656 : : void *data;
657 : :
548 658 [ # # ]: 0 : if (old != NULL)
659 : : {
660 : : /* This is to help catch old code that malloc's GUC data. */
661 [ # # ]: 0 : 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))
579 672 [ # # ]: 0 : ereport(elevel,
673 : : (errcode(ERRCODE_OUT_OF_MEMORY),
674 : : errmsg("out of memory")));
675 : 0 : return data;
676 : : }
677 : :
678 : : char *
579 tgl@sss.pgh.pa.us 679 :CBC 587271 : guc_strdup(int elevel, const char *src)
680 : : {
681 : : char *data;
548 682 : 587271 : size_t len = strlen(src) + 1;
683 : :
684 : 587271 : data = guc_malloc(elevel, len);
685 [ + - ]: 587271 : if (likely(data != NULL))
686 : 587271 : memcpy(data, src, len);
579 687 : 587271 : return data;
688 : : }
689 : :
690 : : void
548 691 : 632469 : 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 [ + + ]: 632469 : if (ptr != NULL)
698 : : {
699 : : /* This is to help catch old code that malloc's GUC data. */
700 [ - + ]: 364464 : Assert(GetMemoryChunkContext(ptr) == GUCMemoryContext);
701 : 364464 : pfree(ptr);
702 : : }
703 : 632469 : }
704 : :
705 : :
706 : : /*
707 : : * Detect whether strval is referenced anywhere in a GUC string item
708 : : */
709 : : static bool
579 710 : 868256 : string_field_used(struct config_string *conf, char *strval)
711 : : {
712 : : GucStack *stack;
713 : :
714 [ + + ]: 868256 : if (strval == *(conf->variable) ||
715 [ + + ]: 475741 : strval == conf->reset_val ||
716 [ - + ]: 262588 : strval == conf->boot_val)
717 : 605668 : return true;
718 [ + + ]: 406405 : for (stack = conf->gen.stack; stack; stack = stack->prev)
719 : : {
720 [ + + ]: 171051 : if (strval == stack->prior.val.stringval ||
721 [ + + ]: 143820 : strval == stack->masked.val.stringval)
722 : 27234 : return true;
723 : : }
724 : 235354 : 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 : 926236 : set_string_field(struct config_string *conf, char **field, char *newval)
734 : : {
735 : 926236 : char *oldval = *field;
736 : :
737 : : /* Do the assignment */
738 : 926236 : *field = newval;
739 : :
740 : : /* Free old value if it's not NULL and isn't referenced anymore */
741 [ + + + + ]: 926236 : if (oldval && !string_field_used(conf, oldval))
548 742 : 233029 : guc_free(oldval);
579 743 : 926236 : }
744 : :
745 : : /*
746 : : * Detect whether an "extra" struct is referenced anywhere in a GUC item
747 : : */
748 : : static bool
749 : 142190 : extra_field_used(struct config_generic *gconf, void *extra)
750 : : {
751 : : GucStack *stack;
752 : :
753 [ + + ]: 142190 : if (extra == gconf->extra)
754 : 61204 : return true;
755 [ - - - + : 80986 : switch (gconf->vartype)
- - ]
756 : : {
579 tgl@sss.pgh.pa.us 757 :UBC 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;
579 tgl@sss.pgh.pa.us 769 :CBC 80986 : case PGC_STRING:
770 [ + + ]: 80986 : if (extra == ((struct config_string *) gconf)->reset_extra)
771 : 39914 : return true;
772 : 41072 : break;
579 tgl@sss.pgh.pa.us 773 :UBC 0 : case PGC_ENUM:
774 [ # # ]: 0 : if (extra == ((struct config_enum *) gconf)->reset_extra)
775 : 0 : return true;
776 : 0 : break;
777 : : }
579 tgl@sss.pgh.pa.us 778 [ + + ]:CBC 46910 : for (stack = gconf->stack; stack; stack = stack->prev)
779 : : {
780 [ + + ]: 7539 : if (extra == stack->prior.extra ||
781 [ + + ]: 5841 : extra == stack->masked.extra)
782 : 1701 : return true;
783 : : }
784 : :
785 : 39371 : 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 : 1274931 : set_extra_field(struct config_generic *gconf, void **field, void *newval)
795 : : {
796 : 1274931 : void *oldval = *field;
797 : :
798 : : /* Do the assignment */
799 : 1274931 : *field = newval;
800 : :
801 : : /* Free old value if it's not NULL and isn't referenced anymore */
802 [ + + + + ]: 1274931 : if (oldval && !extra_field_used(gconf, oldval))
548 803 : 39143 : guc_free(oldval);
579 804 : 1274931 : }
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 : 172830 : set_stack_value(struct config_generic *gconf, config_var_value *val)
815 : : {
816 [ + + + + : 172830 : switch (gconf->vartype)
+ - ]
817 : : {
818 : 8165 : case PGC_BOOL:
819 : 8165 : val->val.boolval =
820 : 8165 : *((struct config_bool *) gconf)->variable;
821 : 8165 : break;
822 : 9887 : case PGC_INT:
823 : 9887 : val->val.intval =
824 : 9887 : *((struct config_int *) gconf)->variable;
825 : 9887 : break;
826 : 4039 : case PGC_REAL:
827 : 4039 : val->val.realval =
828 : 4039 : *((struct config_real *) gconf)->variable;
829 : 4039 : break;
830 : 141466 : case PGC_STRING:
831 : 141466 : set_string_field((struct config_string *) gconf,
832 : : &(val->val.stringval),
833 : 141466 : *((struct config_string *) gconf)->variable);
834 : 141466 : break;
835 : 9273 : case PGC_ENUM:
836 : 9273 : val->val.enumval =
837 : 9273 : *((struct config_enum *) gconf)->variable;
838 : 9273 : break;
839 : : }
840 : 172830 : set_extra_field(gconf, &(val->extra), gconf->extra);
841 : 172830 : }
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 : 22517 : discard_stack_value(struct config_generic *gconf, config_var_value *val)
849 : : {
850 [ + + - ]: 22517 : switch (gconf->vartype)
851 : : {
852 : 16555 : case PGC_BOOL:
853 : : case PGC_INT:
854 : : case PGC_REAL:
855 : : case PGC_ENUM:
856 : : /* no need to do anything */
857 : 16555 : break;
858 : 5962 : case PGC_STRING:
859 : 5962 : set_string_field((struct config_string *) gconf,
860 : : &(val->val.stringval),
861 : : NULL);
862 : 5962 : break;
863 : : }
864 : 22517 : set_extra_field(gconf, &(val->extra), NULL);
865 : 22517 : }
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 **
548 874 : 1894 : 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 : 1894 : *num_vars = hash_get_num_entries(guc_hashtab);
882 : 1894 : result = palloc(sizeof(struct config_generic *) * *num_vars);
883 : :
884 : : /* Extract pointers from the hash table */
885 : 1894 : i = 0;
886 : 1894 : hash_seq_init(&status, guc_hashtab);
887 [ + + ]: 738489 : while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
888 : 736595 : result[i++] = hentry->gucvar;
889 [ - + ]: 1894 : Assert(i == *num_vars);
890 : :
891 : : /* Sort by name */
892 : 1894 : qsort(result, *num_vars,
893 : : sizeof(struct config_generic *), guc_var_compare);
894 : :
895 : 1894 : 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
579 905 : 928 : build_guc_variables(void)
906 : : {
907 : : int size_vars;
908 : 928 : 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 : : */
548 917 [ - + ]: 928 : Assert(GUCMemoryContext == NULL);
918 : 928 : GUCMemoryContext = AllocSetContextCreate(TopMemoryContext,
919 : : "GUCMemoryContext",
920 : : ALLOCSET_DEFAULT_SIZES);
921 : :
922 : : /*
923 : : * Count all the built-in variables, and set their vartypes correctly.
924 : : */
579 925 [ + + ]: 104864 : for (i = 0; ConfigureNamesBool[i].gen.name; i++)
926 : : {
927 : 103936 : struct config_bool *conf = &ConfigureNamesBool[i];
928 : :
929 : : /* Rather than requiring vartype to be filled in by hand, do this: */
930 : 103936 : conf->gen.vartype = PGC_BOOL;
931 : 103936 : num_vars++;
932 : : }
933 : :
934 [ + + ]: 129920 : for (i = 0; ConfigureNamesInt[i].gen.name; i++)
935 : : {
936 : 128992 : struct config_int *conf = &ConfigureNamesInt[i];
937 : :
938 : 128992 : conf->gen.vartype = PGC_INT;
939 : 128992 : num_vars++;
940 : : }
941 : :
942 [ + + ]: 24128 : for (i = 0; ConfigureNamesReal[i].gen.name; i++)
943 : : {
944 : 23200 : struct config_real *conf = &ConfigureNamesReal[i];
945 : :
946 : 23200 : conf->gen.vartype = PGC_REAL;
947 : 23200 : num_vars++;
948 : : }
949 : :
950 [ + + ]: 65888 : for (i = 0; ConfigureNamesString[i].gen.name; i++)
951 : : {
952 : 64960 : struct config_string *conf = &ConfigureNamesString[i];
953 : :
954 : 64960 : conf->gen.vartype = PGC_STRING;
955 : 64960 : num_vars++;
956 : : }
957 : :
958 [ + + ]: 36192 : for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
959 : : {
960 : 35264 : struct config_enum *conf = &ConfigureNamesEnum[i];
961 : :
962 : 35264 : conf->gen.vartype = PGC_ENUM;
963 : 35264 : num_vars++;
964 : : }
965 : :
966 : : /*
967 : : * Create hash table with 20% slack
968 : : */
969 : 928 : size_vars = num_vars + num_vars / 4;
970 : :
548 971 : 928 : hash_ctl.keysize = sizeof(char *);
972 : 928 : hash_ctl.entrysize = sizeof(GUCHashEntry);
973 : 928 : hash_ctl.hash = guc_name_hash;
974 : 928 : hash_ctl.match = guc_name_match;
975 : 928 : hash_ctl.hcxt = GUCMemoryContext;
976 : 928 : guc_hashtab = hash_create("GUC hash table",
977 : : size_vars,
978 : : &hash_ctl,
979 : : HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT);
980 : :
579 981 [ + + ]: 104864 : for (i = 0; ConfigureNamesBool[i].gen.name; i++)
982 : : {
548 983 : 103936 : struct config_generic *gucvar = &ConfigureNamesBool[i].gen;
984 : :
985 : 103936 : hentry = (GUCHashEntry *) hash_search(guc_hashtab,
986 : 103936 : &gucvar->name,
987 : : HASH_ENTER,
988 : : &found);
989 [ - + ]: 103936 : Assert(!found);
990 : 103936 : hentry->gucvar = gucvar;
991 : : }
992 : :
579 993 [ + + ]: 129920 : for (i = 0; ConfigureNamesInt[i].gen.name; i++)
994 : : {
548 995 : 128992 : struct config_generic *gucvar = &ConfigureNamesInt[i].gen;
996 : :
997 : 128992 : hentry = (GUCHashEntry *) hash_search(guc_hashtab,
998 : 128992 : &gucvar->name,
999 : : HASH_ENTER,
1000 : : &found);
1001 [ - + ]: 128992 : Assert(!found);
1002 : 128992 : hentry->gucvar = gucvar;
1003 : : }
1004 : :
579 1005 [ + + ]: 24128 : for (i = 0; ConfigureNamesReal[i].gen.name; i++)
1006 : : {
548 1007 : 23200 : struct config_generic *gucvar = &ConfigureNamesReal[i].gen;
1008 : :
1009 : 23200 : hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1010 : 23200 : &gucvar->name,
1011 : : HASH_ENTER,
1012 : : &found);
1013 [ - + ]: 23200 : Assert(!found);
1014 : 23200 : hentry->gucvar = gucvar;
1015 : : }
1016 : :
579 1017 [ + + ]: 65888 : for (i = 0; ConfigureNamesString[i].gen.name; i++)
1018 : : {
548 1019 : 64960 : struct config_generic *gucvar = &ConfigureNamesString[i].gen;
1020 : :
1021 : 64960 : hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1022 : 64960 : &gucvar->name,
1023 : : HASH_ENTER,
1024 : : &found);
1025 [ - + ]: 64960 : Assert(!found);
1026 : 64960 : hentry->gucvar = gucvar;
1027 : : }
1028 : :
579 1029 [ + + ]: 36192 : for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
1030 : : {
548 1031 : 35264 : struct config_generic *gucvar = &ConfigureNamesEnum[i].gen;
1032 : :
1033 : 35264 : hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1034 : 35264 : &gucvar->name,
1035 : : HASH_ENTER,
1036 : : &found);
1037 [ - + ]: 35264 : Assert(!found);
1038 : 35264 : hentry->gucvar = gucvar;
1039 : : }
1040 : :
1041 [ - + ]: 928 : Assert(num_vars == hash_get_num_entries(guc_hashtab));
579 1042 : 928 : }
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 : 10110 : add_guc_variable(struct config_generic *var, int elevel)
1050 : : {
1051 : : GUCHashEntry *hentry;
1052 : : bool found;
1053 : :
548 1054 : 10110 : hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1055 : 10110 : &var->name,
1056 : : HASH_ENTER_NULL,
1057 : : &found);
1058 [ - + ]: 10110 : if (unlikely(hentry == NULL))
1059 : : {
548 tgl@sss.pgh.pa.us 1060 [ # # ]:UBC 0 : ereport(elevel,
1061 : : (errcode(ERRCODE_OUT_OF_MEMORY),
1062 : : errmsg("out of memory")));
1063 : 0 : return false; /* out of memory */
1064 : : }
548 tgl@sss.pgh.pa.us 1065 [ - + ]:CBC 10110 : Assert(!found);
1066 : 10110 : hentry->gucvar = var;
579 1067 : 10110 : 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 : 89 : valid_custom_variable_name(const char *name)
1079 : : {
1080 : 89 : bool saw_sep = false;
1081 : 89 : bool name_start = true;
1082 : :
1083 [ + + ]: 1794 : for (const char *p = name; *p; p++)
1084 : : {
1085 [ + + ]: 1711 : if (*p == GUC_QUALIFIER_SEPARATOR)
1086 : : {
1087 [ - + ]: 94 : if (name_start)
579 tgl@sss.pgh.pa.us 1088 :UBC 0 : return false; /* empty name component */
579 tgl@sss.pgh.pa.us 1089 :CBC 94 : saw_sep = true;
1090 : 94 : name_start = true;
1091 : : }
1092 : 1617 : else if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1093 [ + + ]: 1617 : "abcdefghijklmnopqrstuvwxyz_", *p) != NULL ||
1094 [ - + ]: 8 : IS_HIGHBIT_SET(*p))
1095 : : {
1096 : : /* okay as first or non-first character */
1097 : 1609 : name_start = false;
1098 : : }
1099 [ + - + + ]: 8 : else if (!name_start && strchr("0123456789$", *p) != NULL)
1100 : : /* okay as non-first character */ ;
1101 : : else
1102 : 6 : return false;
1103 : : }
1104 [ - + ]: 83 : if (name_start)
579 tgl@sss.pgh.pa.us 1105 :UBC 0 : return false; /* empty name component */
1106 : : /* OK if we found at least one separator */
579 tgl@sss.pgh.pa.us 1107 :CBC 83 : 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
176 tgl@sss.pgh.pa.us 1123 :GNC 93 : 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 : 93 : const char *sep = strchr(name, GUC_QUALIFIER_SEPARATOR);
1127 : :
1128 [ + + ]: 93 : if (sep != NULL)
1129 : : {
1130 : 65 : size_t classLen = sep - name;
1131 : : ListCell *lc;
1132 : :
1133 : : /* The name must be syntactically acceptable ... */
1134 [ + + ]: 65 : if (!valid_custom_variable_name(name))
1135 : : {
1136 [ + - ]: 6 : if (!skip_errors)
1137 [ + - ]: 6 : 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.")));
176 tgl@sss.pgh.pa.us 1142 :UNC 0 : return false;
1143 : : }
1144 : : /* ... and it must not match any previously-reserved prefix */
176 tgl@sss.pgh.pa.us 1145 [ + + + + :GNC 69 : foreach(lc, reserved_class_prefix)
+ + ]
1146 : : {
1147 : 13 : const char *rcprefix = lfirst(lc);
1148 : :
1149 [ + + ]: 13 : if (strlen(rcprefix) == classLen &&
1150 [ + - ]: 3 : strncmp(name, rcprefix, classLen) == 0)
1151 : : {
1152 [ + - ]: 3 : if (!skip_errors)
1153 [ + - ]: 3 : 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)));
176 tgl@sss.pgh.pa.us 1159 :UNC 0 : return false;
1160 : : }
1161 : : }
1162 : : /* OK to create it */
176 tgl@sss.pgh.pa.us 1163 :GNC 56 : return true;
1164 : : }
1165 : :
1166 : : /* Unrecognized single-part name */
1167 [ + - ]: 28 : if (!skip_errors)
1168 [ + - ]: 28 : ereport(elevel,
1169 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
1170 : : errmsg("unrecognized configuration parameter \"%s\"",
1171 : : name)));
176 tgl@sss.pgh.pa.us 1172 :UNC 0 : return false;
1173 : : }
1174 : :
1175 : : /*
1176 : : * Create and add a placeholder variable for a custom variable name.
1177 : : */
1178 : : static struct config_generic *
579 tgl@sss.pgh.pa.us 1179 :CBC 49 : add_placeholder_variable(const char *name, int elevel)
1180 : : {
1181 : 49 : size_t sz = sizeof(struct config_string) + sizeof(char *);
1182 : : struct config_string *var;
1183 : : struct config_generic *gen;
1184 : :
1185 : 49 : var = (struct config_string *) guc_malloc(elevel, sz);
1186 [ - + ]: 49 : if (var == NULL)
579 tgl@sss.pgh.pa.us 1187 :UBC 0 : return NULL;
579 tgl@sss.pgh.pa.us 1188 :CBC 49 : memset(var, 0, sz);
1189 : 49 : gen = &var->gen;
1190 : :
1191 : 49 : gen->name = guc_strdup(elevel, name);
1192 [ - + ]: 49 : if (gen->name == NULL)
1193 : : {
548 tgl@sss.pgh.pa.us 1194 :UBC 0 : guc_free(var);
579 1195 : 0 : return NULL;
1196 : : }
1197 : :
579 tgl@sss.pgh.pa.us 1198 :CBC 49 : gen->context = PGC_USERSET;
1199 : 49 : gen->group = CUSTOM_OPTIONS;
1200 : 49 : gen->short_desc = "GUC placeholder variable";
1201 : 49 : gen->flags = GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE | GUC_CUSTOM_PLACEHOLDER;
1202 : 49 : 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 : 49 : var->variable = (char **) (var + 1);
1210 : :
1211 [ - + ]: 49 : if (!add_guc_variable((struct config_generic *) var, elevel))
1212 : : {
548 tgl@sss.pgh.pa.us 1213 :UBC 0 : guc_free(unconstify(char *, gen->name));
1214 : 0 : guc_free(var);
579 1215 : 0 : return NULL;
1216 : : }
1217 : :
579 tgl@sss.pgh.pa.us 1218 :CBC 49 : 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 : 562000 : find_option(const char *name, bool create_placeholders, bool skip_errors,
1238 : : int elevel)
1239 : : {
1240 : : GUCHashEntry *hentry;
1241 : : int i;
1242 : :
1243 [ - + ]: 562000 : Assert(name);
1244 : :
1245 : : /* Look it up using the hash table. */
548 1246 : 562000 : hentry = (GUCHashEntry *) hash_search(guc_hashtab,
1247 : : &name,
1248 : : HASH_FIND,
1249 : : NULL);
1250 [ + + ]: 562000 : if (hentry)
1251 : 561826 : 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 : : */
579 1258 [ + + ]: 522 : for (i = 0; map_old_guc_names[i] != NULL; i += 2)
1259 : : {
1260 [ - + ]: 348 : if (guc_name_compare(name, map_old_guc_names[i]) == 0)
579 tgl@sss.pgh.pa.us 1261 :UBC 0 : return find_option(map_old_guc_names[i + 1], false,
1262 : : skip_errors, elevel);
1263 : : }
1264 : :
579 tgl@sss.pgh.pa.us 1265 [ + + ]:CBC 174 : if (create_placeholders)
1266 : : {
1267 : : /*
1268 : : * Check if the name is valid, and if so, add a placeholder.
1269 : : */
176 tgl@sss.pgh.pa.us 1270 [ + - ]:GNC 85 : if (assignable_custom_variable_name(name, skip_errors, elevel))
579 tgl@sss.pgh.pa.us 1271 :CBC 49 : return add_placeholder_variable(name, elevel);
1272 : : else
176 tgl@sss.pgh.pa.us 1273 :UNC 0 : return NULL; /* error message, if any, already emitted */
1274 : : }
1275 : :
1276 : : /* Unknown name and we're not supposed to make a placeholder */
579 tgl@sss.pgh.pa.us 1277 [ + + ]:CBC 89 : if (!skip_errors)
1278 [ + - ]: 19 : ereport(elevel,
1279 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
1280 : : errmsg("unrecognized configuration parameter \"%s\"",
1281 : : name)));
1282 : 70 : return NULL;
1283 : : }
1284 : :
1285 : :
1286 : : /*
1287 : : * comparator for qsorting an array of GUC pointers
1288 : : */
1289 : : static int
1290 : 6382207 : guc_var_compare(const void *a, const void *b)
1291 : : {
1292 : 6382207 : const struct config_generic *confa = *(struct config_generic *const *) a;
1293 : 6382207 : const struct config_generic *confb = *(struct config_generic *const *) b;
1294 : :
1295 : 6382207 : return guc_name_compare(confa->name, confb->name);
1296 : : }
1297 : :
1298 : : /*
1299 : : * the bare comparison function for GUC names
1300 : : */
1301 : : int
1302 : 7183781 : 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 [ + + + + ]: 29482690 : while (*namea && *nameb)
1310 : : {
1311 : 28844096 : char cha = *namea++;
1312 : 28844096 : char chb = *nameb++;
1313 : :
1314 [ + + + + ]: 28844096 : if (cha >= 'A' && cha <= 'Z')
1315 : 147380 : cha += 'a' - 'A';
1316 [ + + + + ]: 28844096 : if (chb >= 'A' && chb <= 'Z')
1317 : 32251 : chb += 'a' - 'A';
1318 [ + + ]: 28844096 : if (cha != chb)
1319 : 6545187 : return cha - chb;
1320 : : }
1321 [ + + ]: 638594 : if (*namea)
1322 : 33187 : return 1; /* a is longer */
1323 [ + + ]: 605407 : if (*nameb)
1324 : 43448 : return -1; /* b is longer */
1325 : 561959 : return 0;
1326 : : }
1327 : :
1328 : : /*
1329 : : * Hash function that's compatible with guc_name_compare
1330 : : */
1331 : : static uint32
548 1332 : 938574 : guc_name_hash(const void *key, Size keysize)
1333 : : {
1334 : 938574 : uint32 result = 0;
1335 : 938574 : const char *name = *(const char *const *) key;
1336 : :
1337 [ + + ]: 16178802 : while (*name)
1338 : : {
1339 : 15240228 : char ch = *name++;
1340 : :
1341 : : /* Case-fold in the same way as guc_name_compare */
1342 [ + + + + ]: 15240228 : if (ch >= 'A' && ch <= 'Z')
1343 : 19086 : ch += 'a' - 'A';
1344 : :
1345 : : /* Merge into hash ... not very bright, but it needn't be */
1346 : 15240228 : result = pg_rotate_left32(result, 5);
1347 : 15240228 : result ^= (uint32) ch;
1348 : : }
1349 : 938574 : return result;
1350 : : }
1351 : :
1352 : : /*
1353 : : * Dynahash match function to use in guc_hashtab
1354 : : */
1355 : : static int
1356 : 561877 : guc_name_match(const void *key1, const void *key2, Size keysize)
1357 : : {
1358 : 561877 : const char *name1 = *(const char *const *) key1;
1359 : 561877 : const char *name2 = *(const char *const *) key2;
1360 : :
1361 : 561877 : 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 *
579 1376 : 176 : convert_GUC_name_for_parameter_acl(const char *name)
1377 : : {
1378 : : char *result;
1379 : :
1380 : : /* Apply old-GUC-name mapping. */
1381 [ + + ]: 528 : for (int i = 0; map_old_guc_names[i] != NULL; i += 2)
1382 : : {
1383 [ - + ]: 352 : if (guc_name_compare(name, map_old_guc_names[i]) == 0)
1384 : : {
579 tgl@sss.pgh.pa.us 1385 :UBC 0 : name = map_old_guc_names[i + 1];
1386 : 0 : break;
1387 : : }
1388 : : }
1389 : :
1390 : : /* Apply case-folding that matches guc_name_compare(). */
579 tgl@sss.pgh.pa.us 1391 :CBC 176 : result = pstrdup(name);
1392 [ + + ]: 2864 : for (char *ptr = result; *ptr != '\0'; ptr++)
1393 : : {
1394 : 2688 : char ch = *ptr;
1395 : :
1396 [ + + + + ]: 2688 : if (ch >= 'A' && ch <= 'Z')
1397 : : {
1398 : 6 : ch += 'a' - 'A';
1399 : 6 : *ptr = ch;
1400 : : }
1401 : : }
1402 : :
1403 : 176 : 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 : 34 : check_GUC_name_for_parameter_acl(const char *name)
1413 : : {
1414 : : /* OK if the GUC exists. */
176 tgl@sss.pgh.pa.us 1415 [ + + ]:GNC 34 : if (find_option(name, false, true, DEBUG5) != NULL)
1416 : 27 : return;
1417 : : /* Otherwise, it'd better be a valid custom GUC name. */
1418 : 7 : (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
531 michael@paquier.xyz 1438 :CBC 366461 : check_GUC_init(struct config_generic *gconf)
1439 : : {
1440 : : /* Checks on values */
1441 [ + + + + : 366461 : switch (gconf->vartype)
+ - ]
1442 : : {
1443 : 107991 : case PGC_BOOL:
1444 : : {
1445 : 107991 : struct config_bool *conf = (struct config_bool *) gconf;
1446 : :
1447 [ + + - + ]: 107991 : if (*conf->variable && !conf->boot_val)
1448 : : {
531 michael@paquier.xyz 1449 [ # # ]:UBC 0 : elog(LOG, "GUC (PGC_BOOL) %s, boot_val=%d, C-var=%d",
1450 : : conf->gen.name, conf->boot_val, *conf->variable);
1451 : 0 : return false;
1452 : : }
531 michael@paquier.xyz 1453 :CBC 107991 : break;
1454 : : }
1455 : 129035 : case PGC_INT:
1456 : : {
1457 : 129035 : struct config_int *conf = (struct config_int *) gconf;
1458 : :
1459 [ + + - + ]: 129035 : if (*conf->variable != 0 && *conf->variable != conf->boot_val)
1460 : : {
531 michael@paquier.xyz 1461 [ # # ]:UBC 0 : elog(LOG, "GUC (PGC_INT) %s, boot_val=%d, C-var=%d",
1462 : : conf->gen.name, conf->boot_val, *conf->variable);
1463 : 0 : return false;
1464 : : }
531 michael@paquier.xyz 1465 :CBC 129035 : break;
1466 : : }
1467 : 23221 : case PGC_REAL:
1468 : : {
1469 : 23221 : struct config_real *conf = (struct config_real *) gconf;
1470 : :
1471 [ + + - + ]: 23221 : if (*conf->variable != 0.0 && *conf->variable != conf->boot_val)
1472 : : {
531 michael@paquier.xyz 1473 [ # # ]:UBC 0 : elog(LOG, "GUC (PGC_REAL) %s, boot_val=%g, C-var=%g",
1474 : : conf->gen.name, conf->boot_val, *conf->variable);
1475 : 0 : return false;
1476 : : }
531 michael@paquier.xyz 1477 :CBC 23221 : break;
1478 : : }
1479 : 68971 : case PGC_STRING:
1480 : : {
1481 : 68971 : struct config_string *conf = (struct config_string *) gconf;
1482 : :
164 tgl@sss.pgh.pa.us 1483 [ + + ]: 68971 : if (*conf->variable != NULL &&
1484 [ + - ]: 3714 : (conf->boot_val == NULL ||
1485 [ - + ]: 3714 : strcmp(*conf->variable, conf->boot_val) != 0))
1486 : : {
531 michael@paquier.xyz 1487 [ # # # # ]:UBC 0 : 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 : 0 : return false;
1490 : : }
531 michael@paquier.xyz 1491 :CBC 68971 : break;
1492 : : }
1493 : 37243 : case PGC_ENUM:
1494 : : {
1495 : 37243 : struct config_enum *conf = (struct config_enum *) gconf;
1496 : :
1497 [ - + ]: 37243 : if (*conf->variable != conf->boot_val)
1498 : : {
531 michael@paquier.xyz 1499 [ # # ]:UBC 0 : elog(LOG, "GUC (PGC_ENUM) %s, boot_val=%d, C-var=%d",
1500 : : conf->gen.name, conf->boot_val, *conf->variable);
1501 : 0 : return false;
1502 : : }
531 michael@paquier.xyz 1503 :CBC 37243 : 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 : : */
433 1513 [ + + ]: 366461 : if ((gconf->flags & GUC_NO_SHOW_ALL) &&
1514 [ - + ]: 5568 : !(gconf->flags & GUC_NOT_IN_SAMPLE))
1515 : : {
433 michael@paquier.xyz 1516 [ # # ]:UBC 0 : elog(LOG, "GUC %s flags: NO_SHOW_ALL and !NOT_IN_SAMPLE",
1517 : : gconf->name);
1518 : 0 : return false;
1519 : : }
1520 : :
531 michael@paquier.xyz 1521 :CBC 366461 : 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
579 tgl@sss.pgh.pa.us 1532 : 928 : 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 : 928 : pg_timezone_initialize();
1542 : :
1543 : : /*
1544 : : * Create GUCMemoryContext and build hash table of all GUC variables.
1545 : : */
1546 : 928 : build_guc_variables();
1547 : :
1548 : : /*
1549 : : * Load all variables with their compiled-in defaults, and initialize
1550 : : * status fields as needed.
1551 : : */
548 1552 : 928 : hash_seq_init(&status, guc_hashtab);
1553 [ + + ]: 357280 : while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
1554 : : {
1555 : : /* Check mapping between initial and default value */
531 michael@paquier.xyz 1556 [ - + ]: 356352 : Assert(check_GUC_init(hentry->gucvar));
1557 : :
548 tgl@sss.pgh.pa.us 1558 : 356352 : InitializeOneGUCOption(hentry->gucvar);
1559 : : }
1560 : :
579 1561 : 928 : reporting_enabled = false;
1562 : :
1563 : : /*
1564 : : * Prevent any attempt to override the transaction modes from
1565 : : * non-interactive sources.
1566 : : */
1567 : 928 : SetConfigOption("transaction_isolation", "read committed",
1568 : : PGC_POSTMASTER, PGC_S_OVERRIDE);
1569 : 928 : SetConfigOption("transaction_read_only", "no",
1570 : : PGC_POSTMASTER, PGC_S_OVERRIDE);
1571 : 928 : 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 : 928 : InitializeGUCOptionsFromEnvironment();
1579 : 928 : }
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 : 1734 : InitializeGUCOptionsFromEnvironment(void)
1592 : : {
1593 : : char *env;
1594 : : long stack_rlimit;
1595 : :
1596 : 1734 : env = getenv("PGPORT");
1597 [ + + ]: 1734 : if (env != NULL)
1598 : 1609 : SetConfigOption("port", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
1599 : :
1600 : 1734 : env = getenv("PGDATESTYLE");
1601 [ + + ]: 1734 : if (env != NULL)
1602 : 100 : SetConfigOption("datestyle", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
1603 : :
1604 : 1734 : env = getenv("PGCLIENTENCODING");
1605 [ + + ]: 1734 : if (env != NULL)
1606 : 15 : 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 : 1734 : stack_rlimit = get_stack_depth_rlimit();
1616 [ + - ]: 1734 : if (stack_rlimit > 0)
1617 : : {
1618 : 1734 : long new_limit = (stack_rlimit - STACK_DEPTH_SLOP) / 1024L;
1619 : :
1620 [ + - ]: 1734 : if (new_limit > 100)
1621 : : {
1622 : : GucSource source;
1623 : : char limbuf[16];
1624 : :
1625 [ - + ]: 1734 : if (new_limit < 2048)
579 tgl@sss.pgh.pa.us 1626 :UBC 0 : source = PGC_S_ENV_VAR;
1627 : : else
1628 : : {
579 tgl@sss.pgh.pa.us 1629 :CBC 1734 : new_limit = 2048;
1630 : 1734 : source = PGC_S_DYNAMIC_DEFAULT;
1631 : : }
1632 : 1734 : snprintf(limbuf, sizeof(limbuf), "%ld", new_limit);
1633 : 1734 : SetConfigOption("max_stack_depth", limbuf,
1634 : : PGC_POSTMASTER, source);
1635 : : }
1636 : : }
1637 : 1734 : }
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 : 399481 : InitializeOneGUCOption(struct config_generic *gconf)
1647 : : {
1648 : 399481 : gconf->status = 0;
1649 : 399481 : gconf->source = PGC_S_DEFAULT;
1650 : 399481 : gconf->reset_source = PGC_S_DEFAULT;
1651 : 399481 : gconf->scontext = PGC_INTERNAL;
1652 : 399481 : gconf->reset_scontext = PGC_INTERNAL;
1653 : 399481 : gconf->srole = BOOTSTRAP_SUPERUSERID;
1654 : 399481 : gconf->reset_srole = BOOTSTRAP_SUPERUSERID;
1655 : 399481 : gconf->stack = NULL;
1656 : 399481 : gconf->extra = NULL;
1657 : 399481 : gconf->last_reported = NULL;
1658 : 399481 : gconf->sourcefile = NULL;
1659 : 399481 : gconf->sourceline = 0;
1660 : :
1661 [ + + + + : 399481 : switch (gconf->vartype)
+ - ]
1662 : : {
1663 : 115037 : case PGC_BOOL:
1664 : : {
1665 : 115037 : struct config_bool *conf = (struct config_bool *) gconf;
1666 : 115037 : bool newval = conf->boot_val;
1667 : 115037 : void *extra = NULL;
1668 : :
1669 [ - + ]: 115037 : if (!call_bool_check_hook(conf, &newval, &extra,
1670 : : PGC_S_DEFAULT, LOG))
579 tgl@sss.pgh.pa.us 1671 [ # # ]:UBC 0 : elog(FATAL, "failed to initialize %s to %d",
1672 : : conf->gen.name, (int) newval);
579 tgl@sss.pgh.pa.us 1673 [ - + ]:CBC 115037 : if (conf->assign_hook)
579 tgl@sss.pgh.pa.us 1674 :UBC 0 : conf->assign_hook(newval, extra);
579 tgl@sss.pgh.pa.us 1675 :CBC 115037 : *conf->variable = conf->reset_val = newval;
1676 : 115037 : conf->gen.extra = conf->reset_extra = extra;
1677 : 115037 : break;
1678 : : }
1679 : 135208 : case PGC_INT:
1680 : : {
1681 : 135208 : struct config_int *conf = (struct config_int *) gconf;
1682 : 135208 : int newval = conf->boot_val;
1683 : 135208 : void *extra = NULL;
1684 : :
1685 [ - + ]: 135208 : Assert(newval >= conf->min);
1686 [ - + ]: 135208 : Assert(newval <= conf->max);
1687 [ - + ]: 135208 : if (!call_int_check_hook(conf, &newval, &extra,
1688 : : PGC_S_DEFAULT, LOG))
579 tgl@sss.pgh.pa.us 1689 [ # # ]:UBC 0 : elog(FATAL, "failed to initialize %s to %d",
1690 : : conf->gen.name, newval);
579 tgl@sss.pgh.pa.us 1691 [ + + ]:CBC 135208 : if (conf->assign_hook)
1692 : 10068 : conf->assign_hook(newval, extra);
1693 : 135208 : *conf->variable = conf->reset_val = newval;
1694 : 135208 : conf->gen.extra = conf->reset_extra = extra;
1695 : 135208 : break;
1696 : : }
1697 : 23221 : case PGC_REAL:
1698 : : {
1699 : 23221 : struct config_real *conf = (struct config_real *) gconf;
1700 : 23221 : double newval = conf->boot_val;
1701 : 23221 : void *extra = NULL;
1702 : :
1703 [ - + ]: 23221 : Assert(newval >= conf->min);
1704 [ - + ]: 23221 : Assert(newval <= conf->max);
1705 [ - + ]: 23221 : if (!call_real_check_hook(conf, &newval, &extra,
1706 : : PGC_S_DEFAULT, LOG))
579 tgl@sss.pgh.pa.us 1707 [ # # ]:UBC 0 : elog(FATAL, "failed to initialize %s to %g",
1708 : : conf->gen.name, newval);
579 tgl@sss.pgh.pa.us 1709 [ + + ]:CBC 23221 : if (conf->assign_hook)
1710 : 1856 : conf->assign_hook(newval, extra);
1711 : 23221 : *conf->variable = conf->reset_val = newval;
1712 : 23221 : conf->gen.extra = conf->reset_extra = extra;
1713 : 23221 : break;
1714 : : }
1715 : 84837 : case PGC_STRING:
1716 : : {
1717 : 84837 : struct config_string *conf = (struct config_string *) gconf;
1718 : : char *newval;
1719 : 84837 : void *extra = NULL;
1720 : :
1721 : : /* non-NULL boot_val must always get strdup'd */
1722 [ + + ]: 84837 : if (conf->boot_val != NULL)
1723 : 75592 : newval = guc_strdup(FATAL, conf->boot_val);
1724 : : else
1725 : 9245 : newval = NULL;
1726 : :
1727 [ - + ]: 84837 : if (!call_string_check_hook(conf, &newval, &extra,
1728 : : PGC_S_DEFAULT, LOG))
579 tgl@sss.pgh.pa.us 1729 [ # # # # ]:UBC 0 : elog(FATAL, "failed to initialize %s to \"%s\"",
1730 : : conf->gen.name, newval ? newval : "");
579 tgl@sss.pgh.pa.us 1731 [ + + ]:CBC 84837 : if (conf->assign_hook)
1732 : 45352 : conf->assign_hook(newval, extra);
1733 : 84837 : *conf->variable = conf->reset_val = newval;
1734 : 84837 : conf->gen.extra = conf->reset_extra = extra;
1735 : 84837 : break;
1736 : : }
1737 : 41178 : case PGC_ENUM:
1738 : : {
1739 : 41178 : struct config_enum *conf = (struct config_enum *) gconf;
1740 : 41178 : int newval = conf->boot_val;
1741 : 41178 : void *extra = NULL;
1742 : :
1743 [ - + ]: 41178 : if (!call_enum_check_hook(conf, &newval, &extra,
1744 : : PGC_S_DEFAULT, LOG))
579 tgl@sss.pgh.pa.us 1745 [ # # ]:UBC 0 : elog(FATAL, "failed to initialize %s to %d",
1746 : : conf->gen.name, newval);
579 tgl@sss.pgh.pa.us 1747 [ + + ]:CBC 41178 : if (conf->assign_hook)
1748 : 5568 : conf->assign_hook(newval, extra);
1749 : 41178 : *conf->variable = conf->reset_val = newval;
1750 : 41178 : conf->gen.extra = conf->reset_extra = extra;
1751 : 41178 : break;
1752 : : }
1753 : : }
1754 : 399481 : }
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
548 1763 : 33071 : RemoveGUCFromLists(struct config_generic *gconf)
1764 : : {
1765 [ + - ]: 33071 : if (gconf->source != PGC_S_DEFAULT)
1766 : 33071 : dlist_delete(&gconf->nondef_link);
1767 [ - + ]: 33071 : if (gconf->stack != NULL)
548 tgl@sss.pgh.pa.us 1768 :UBC 0 : slist_delete(&guc_stack_list, &gconf->stack_link);
548 tgl@sss.pgh.pa.us 1769 [ + + ]:CBC 33071 : if (gconf->status & GUC_NEEDS_REPORT)
1770 : 5288 : slist_delete(&guc_report_list, &gconf->report_link);
1771 : 33071 : }
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
579 1786 : 904 : 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 [ + + ]: 904 : if (userDoption)
1796 : 747 : configdir = make_absolute_path(userDoption);
1797 : : else
1798 : 157 : configdir = make_absolute_path(getenv("PGDATA"));
1799 : :
1800 [ + - - + ]: 904 : if (configdir && stat(configdir, &stat_buf) != 0)
1801 : : {
33 michael@paquier.xyz 1802 :UNC 0 : write_stderr("%s: could not access directory \"%s\": %m\n",
1803 : : progname,
1804 : : configdir);
579 tgl@sss.pgh.pa.us 1805 [ # # ]:UBC 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 : : */
579 tgl@sss.pgh.pa.us 1816 [ + + ]:CBC 904 : if (ConfigFileName)
1817 : : {
1818 : 10 : fname = make_absolute_path(ConfigFileName);
548 1819 : 10 : fname_is_malloced = true;
1820 : : }
579 1821 [ + - ]: 894 : else if (configdir)
1822 : : {
1823 : 894 : fname = guc_malloc(FATAL,
1824 : 894 : strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
1825 : 894 : sprintf(fname, "%s/%s", configdir, CONFIG_FILENAME);
548 1826 : 894 : fname_is_malloced = false;
1827 : : }
1828 : : else
1829 : : {
579 tgl@sss.pgh.pa.us 1830 :UBC 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 : : */
579 tgl@sss.pgh.pa.us 1841 :CBC 904 : SetConfigOption("config_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1842 : :
548 1843 [ + + ]: 904 : if (fname_is_malloced)
1844 : 10 : free(fname);
1845 : : else
1846 : 894 : guc_free(fname);
1847 : :
1848 : : /*
1849 : : * Now read the config file for the first time.
1850 : : */
579 1851 [ - + ]: 904 : if (stat(ConfigFileName, &stat_buf) != 0)
1852 : : {
33 michael@paquier.xyz 1853 :UNC 0 : write_stderr("%s: could not access the server configuration file \"%s\": %m\n",
1854 : : progname, ConfigFileName);
579 tgl@sss.pgh.pa.us 1855 :UBC 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 : : */
579 tgl@sss.pgh.pa.us 1864 :CBC 904 : 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 : 904 : find_option("data_directory", false, false, PANIC);
1875 [ - + ]: 904 : if (*data_directory_rec->variable)
579 tgl@sss.pgh.pa.us 1876 :UBC 0 : SetDataDir(*data_directory_rec->variable);
579 tgl@sss.pgh.pa.us 1877 [ + - ]:CBC 904 : else if (configdir)
1878 : 904 : SetDataDir(configdir);
1879 : : else
1880 : : {
579 tgl@sss.pgh.pa.us 1881 :UBC 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 : : */
579 tgl@sss.pgh.pa.us 1897 :CBC 904 : 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 : 904 : 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 : 902 : pg_timezone_abbrev_initialize();
1915 : :
1916 : : /*
1917 : : * Figure out where pg_hba.conf is, and make sure the path is absolute.
1918 : : */
1919 [ + + ]: 902 : if (HbaFileName)
1920 : : {
1921 : 1 : fname = make_absolute_path(HbaFileName);
548 1922 : 1 : fname_is_malloced = true;
1923 : : }
579 1924 [ + - ]: 901 : else if (configdir)
1925 : : {
1926 : 901 : fname = guc_malloc(FATAL,
1927 : 901 : strlen(configdir) + strlen(HBA_FILENAME) + 2);
1928 : 901 : sprintf(fname, "%s/%s", configdir, HBA_FILENAME);
548 1929 : 901 : fname_is_malloced = false;
1930 : : }
1931 : : else
1932 : : {
579 tgl@sss.pgh.pa.us 1933 :UBC 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 : : }
579 tgl@sss.pgh.pa.us 1940 :CBC 902 : SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1941 : :
548 1942 [ + + ]: 902 : if (fname_is_malloced)
1943 : 1 : free(fname);
1944 : : else
1945 : 901 : guc_free(fname);
1946 : :
1947 : : /*
1948 : : * Likewise for pg_ident.conf.
1949 : : */
579 1950 [ + + ]: 902 : if (IdentFileName)
1951 : : {
1952 : 1 : fname = make_absolute_path(IdentFileName);
548 1953 : 1 : fname_is_malloced = true;
1954 : : }
579 1955 [ + - ]: 901 : else if (configdir)
1956 : : {
1957 : 901 : fname = guc_malloc(FATAL,
1958 : 901 : strlen(configdir) + strlen(IDENT_FILENAME) + 2);
1959 : 901 : sprintf(fname, "%s/%s", configdir, IDENT_FILENAME);
548 1960 : 901 : fname_is_malloced = false;
1961 : : }
1962 : : else
1963 : : {
579 tgl@sss.pgh.pa.us 1964 :UBC 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 : : }
579 tgl@sss.pgh.pa.us 1971 :CBC 902 : SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1972 : :
548 1973 [ + + ]: 902 : if (fname_is_malloced)
1974 : 1 : free(fname);
1975 : : else
1976 : 901 : guc_free(fname);
1977 : :
579 1978 : 902 : free(configdir);
1979 : :
1980 : 902 : 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 : 1708 : pg_timezone_abbrev_initialize(void)
1995 : : {
1996 : 1708 : SetConfigOption("timezone_abbreviations", "Default",
1997 : : PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT);
1998 : 1708 : }
1999 : :
2000 : :
2001 : : /*
2002 : : * Reset all options to their saved default values (implements RESET ALL)
2003 : : */
2004 : : void
2005 : 3 : ResetAllOptions(void)
2006 : : {
2007 : : dlist_mutable_iter iter;
2008 : :
2009 : : /* We need only consider GUCs not already at PGC_S_DEFAULT */
548 2010 [ + - + + ]: 166 : dlist_foreach_modify(iter, &guc_nondef_list)
2011 : : {
2012 : 163 : struct config_generic *gconf = dlist_container(struct config_generic,
2013 : : nondef_link, iter.cur);
2014 : :
2015 : : /* Don't reset non-SET-able values */
579 2016 [ + + ]: 163 : if (gconf->context != PGC_SUSET &&
2017 [ + + ]: 150 : gconf->context != PGC_USERSET)
2018 : 98 : continue;
2019 : : /* Don't reset if special exclusion from RESET ALL */
2020 [ + + ]: 65 : if (gconf->flags & GUC_NO_RESET_ALL)
2021 : 12 : continue;
2022 : : /* No need to reset if wasn't SET */
2023 [ + + ]: 53 : if (gconf->source <= PGC_S_OVERRIDE)
2024 : 47 : continue;
2025 : :
2026 : : /* Save old value to support transaction abort */
2027 : 6 : push_old_value(gconf, GUC_ACTION_SET);
2028 : :
2029 [ - - + + : 6 : switch (gconf->vartype)
- - ]
2030 : : {
579 tgl@sss.pgh.pa.us 2031 :UBC 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 : : }
579 tgl@sss.pgh.pa.us 2055 :CBC 3 : case PGC_REAL:
2056 : : {
2057 : 3 : struct config_real *conf = (struct config_real *) gconf;
2058 : :
2059 [ - + ]: 3 : if (conf->assign_hook)
579 tgl@sss.pgh.pa.us 2060 :UBC 0 : conf->assign_hook(conf->reset_val,
2061 : : conf->reset_extra);
579 tgl@sss.pgh.pa.us 2062 :CBC 3 : *conf->variable = conf->reset_val;
2063 : 3 : set_extra_field(&conf->gen, &conf->gen.extra,
2064 : : conf->reset_extra);
2065 : 3 : break;
2066 : : }
2067 : 3 : case PGC_STRING:
2068 : : {
2069 : 3 : struct config_string *conf = (struct config_string *) gconf;
2070 : :
2071 [ - + ]: 3 : if (conf->assign_hook)
579 tgl@sss.pgh.pa.us 2072 :UBC 0 : conf->assign_hook(conf->reset_val,
2073 : : conf->reset_extra);
579 tgl@sss.pgh.pa.us 2074 :CBC 3 : set_string_field(conf, conf->variable, conf->reset_val);
2075 : 3 : set_extra_field(&conf->gen, &conf->gen.extra,
2076 : : conf->reset_extra);
2077 : 3 : break;
2078 : : }
579 tgl@sss.pgh.pa.us 2079 :UBC 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 : :
548 tgl@sss.pgh.pa.us 2093 :CBC 6 : set_guc_source(gconf, gconf->reset_source);
579 2094 : 6 : gconf->scontext = gconf->reset_scontext;
2095 : 6 : gconf->srole = gconf->reset_srole;
2096 : :
548 2097 [ - + - - ]: 6 : if ((gconf->flags & GUC_REPORT) && !(gconf->status & GUC_NEEDS_REPORT))
2098 : : {
579 tgl@sss.pgh.pa.us 2099 :UBC 0 : gconf->status |= GUC_NEEDS_REPORT;
548 2100 : 0 : slist_push_head(&guc_report_list, &gconf->report_link);
2101 : : }
2102 : : }
579 tgl@sss.pgh.pa.us 2103 :CBC 3 : }
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
548 2113 : 554238 : set_guc_source(struct config_generic *gconf, GucSource newsource)
2114 : : {
2115 : : /* Adjust nondef list membership if appropriate for change */
2116 [ + + ]: 554238 : if (gconf->source == PGC_S_DEFAULT)
2117 : : {
2118 [ + + ]: 223420 : if (newsource != PGC_S_DEFAULT)
2119 : 223341 : dlist_push_tail(&guc_nondef_list, &gconf->nondef_link);
2120 : : }
2121 : : else
2122 : : {
2123 [ + + ]: 330818 : if (newsource == PGC_S_DEFAULT)
2124 : 39884 : dlist_delete(&gconf->nondef_link);
2125 : : }
2126 : : /* Now update the source field */
2127 : 554238 : gconf->source = newsource;
2128 : 554238 : }
2129 : :
2130 : :
2131 : : /*
2132 : : * push_old_value
2133 : : * Push previous state during transactional assignment to a GUC variable.
2134 : : */
2135 : : static void
579 2136 : 178404 : 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 [ - + ]: 178404 : if (GUCNestLevel == 0)
579 tgl@sss.pgh.pa.us 2142 :UBC 0 : return;
2143 : :
2144 : : /* Do we already have a stack entry of the current nest level? */
579 tgl@sss.pgh.pa.us 2145 :CBC 178404 : stack = gconf->stack;
2146 [ + + + + ]: 178404 : if (stack && stack->nest_level >= GUCNestLevel)
2147 : : {
2148 : : /* Yes, so adjust its state if necessary */
2149 [ - + ]: 5580 : Assert(stack->nest_level == GUCNestLevel);
2150 [ + + - - ]: 5580 : switch (action)
2151 : : {
2152 : 5515 : case GUC_ACTION_SET:
2153 : : /* SET overrides any prior action at same nest level */
2154 [ - + ]: 5515 : if (stack->state == GUC_SET_LOCAL)
2155 : : {
2156 : : /* must discard old masked value */
579 tgl@sss.pgh.pa.us 2157 :UBC 0 : discard_stack_value(gconf, &stack->masked);
2158 : : }
579 tgl@sss.pgh.pa.us 2159 :CBC 5515 : stack->state = GUC_SET;
2160 : 5515 : break;
2161 : 65 : case GUC_ACTION_LOCAL:
2162 [ + + ]: 65 : if (stack->state == GUC_SET)
2163 : : {
2164 : : /* SET followed by SET LOCAL, remember SET's value */
2165 : 6 : stack->masked_scontext = gconf->scontext;
2166 : 6 : stack->masked_srole = gconf->srole;
2167 : 6 : set_stack_value(gconf, &stack->masked);
2168 : 6 : stack->state = GUC_SET_LOCAL;
2169 : : }
2170 : : /* in all other cases, no change to stack entry */
2171 : 65 : break;
579 tgl@sss.pgh.pa.us 2172 :UBC 0 : case GUC_ACTION_SAVE:
2173 : : /* Could only have a prior SAVE of same variable */
2174 [ # # ]: 0 : Assert(stack->state == GUC_SAVE);
2175 : 0 : break;
2176 : : }
579 tgl@sss.pgh.pa.us 2177 :CBC 5580 : return;
2178 : : }
2179 : :
2180 : : /*
2181 : : * Push a new stack entry
2182 : : *
2183 : : * We keep all the stack entries in TopTransactionContext for simplicity.
2184 : : */
2185 : 172824 : stack = (GucStack *) MemoryContextAllocZero(TopTransactionContext,
2186 : : sizeof(GucStack));
2187 : :
2188 : 172824 : stack->prev = gconf->stack;
2189 : 172824 : stack->nest_level = GUCNestLevel;
2190 [ + + + - ]: 172824 : switch (action)
2191 : : {
2192 : 23488 : case GUC_ACTION_SET:
2193 : 23488 : stack->state = GUC_SET;
2194 : 23488 : break;
2195 : 4074 : case GUC_ACTION_LOCAL:
2196 : 4074 : stack->state = GUC_LOCAL;
2197 : 4074 : break;
2198 : 145262 : case GUC_ACTION_SAVE:
2199 : 145262 : stack->state = GUC_SAVE;
2200 : 145262 : break;
2201 : : }
2202 : 172824 : stack->source = gconf->source;
2203 : 172824 : stack->scontext = gconf->scontext;
2204 : 172824 : stack->srole = gconf->srole;
2205 : 172824 : set_stack_value(gconf, &stack->prior);
2206 : :
548 2207 [ + + ]: 172824 : if (gconf->stack == NULL)
2208 : 167781 : slist_push_head(&guc_stack_list, &gconf->stack_link);
579 2209 : 172824 : gconf->stack = stack;
2210 : : }
2211 : :
2212 : :
2213 : : /*
2214 : : * Do GUC processing at main transaction start.
2215 : : */
2216 : : void
2217 : 433233 : 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 [ - + ]: 433233 : if (GUCNestLevel != 0)
579 tgl@sss.pgh.pa.us 2225 [ # # ]:UBC 0 : elog(WARNING, "GUC nest level = %d at transaction start",
2226 : : GUCNestLevel);
579 tgl@sss.pgh.pa.us 2227 :CBC 433233 : GUCNestLevel = 1;
2228 : 433233 : }
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 : 184511 : NewGUCNestLevel(void)
2238 : : {
2239 : 184511 : 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
41 jdavis@postgresql.or 2248 :GNC 137212 : RestrictSearchPath(void)
2249 : : {
2250 [ + + ]: 137212 : if (!IsBootstrapProcessingMode())
2251 : 126136 : set_config_option("search_path", GUC_SAFE_SEARCH_PATH, PGC_USERSET,
2252 : : PGC_S_SESSION, GUC_ACTION_SAVE, true, 0, false);
2253 : 137212 : }
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
579 tgl@sss.pgh.pa.us 2264 :CBC 617029 : 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 [ + - - + : 617029 : Assert(nestLevel > 0 &&
- - - - ]
2274 : : (nestLevel <= GUCNestLevel ||
2275 : : (nestLevel == GUCNestLevel + 1 && !isCommit)));
2276 : :
2277 : : /* We need only process GUCs having nonempty stacks */
548 2278 [ + + + + : 794707 : slist_foreach_modify(iter, &guc_stack_list)
+ + ]
2279 : : {
2280 : 177684 : 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 : : */
579 2291 [ + + ]: 350524 : while ((stack = gconf->stack) != NULL &&
2292 [ + + ]: 182739 : stack->nest_level >= nestLevel)
2293 : : {
2294 : 172846 : GucStack *prev = stack->prev;
2295 : 172846 : bool restorePrior = false;
2296 : 172846 : 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 [ + + ]: 172846 : if (!isCommit) /* if abort, always restore prior value */
2306 : 128396 : restorePrior = true;
2307 [ + + ]: 44450 : else if (stack->state == GUC_SAVE)
2308 : 18672 : restorePrior = true;
2309 [ + + ]: 25778 : else if (stack->nest_level == 1)
2310 : : {
2311 : : /* transaction commit */
2312 [ + + ]: 25757 : if (stack->state == GUC_SET_LOCAL)
2313 : 6 : restoreMasked = true;
2314 [ + + ]: 25751 : else if (stack->state == GUC_SET)
2315 : : {
2316 : : /* we keep the current active value */
2317 : 22517 : discard_stack_value(gconf, &stack->prior);
2318 : : }
2319 : : else /* must be GUC_LOCAL */
2320 : 3234 : restorePrior = true;
2321 : : }
2322 [ + + ]: 21 : else if (prev == NULL ||
2323 [ + + ]: 6 : prev->nest_level < stack->nest_level - 1)
2324 : : {
2325 : : /* decrement entry's level and do not pop it */
2326 : 18 : stack->nest_level--;
2327 : 18 : 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 [ - + - - : 3 : switch (stack->state)
- ]
2336 : : {
579 tgl@sss.pgh.pa.us 2337 :UBC 0 : case GUC_SAVE:
2338 : 0 : Assert(false); /* can't get here */
2339 : : break;
2340 : :
579 tgl@sss.pgh.pa.us 2341 :CBC 3 : case GUC_SET:
2342 : : /* next level always becomes SET */
2343 : 3 : discard_stack_value(gconf, &stack->prior);
2344 [ - + ]: 3 : if (prev->state == GUC_SET_LOCAL)
579 tgl@sss.pgh.pa.us 2345 :UBC 0 : discard_stack_value(gconf, &prev->masked);
579 tgl@sss.pgh.pa.us 2346 :CBC 3 : prev->state = GUC_SET;
2347 : 3 : break;
2348 : :
579 tgl@sss.pgh.pa.us 2349 :UBC 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 : : }
2378 : :
579 tgl@sss.pgh.pa.us 2379 :CBC 172828 : changed = false;
2380 : :
2381 [ + + + + ]: 172828 : 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 [ + + ]: 150308 : if (restoreMasked)
2390 : : {
2391 : 6 : newvalue = stack->masked;
2392 : 6 : newsource = PGC_S_SESSION;
2393 : 6 : newscontext = stack->masked_scontext;
2394 : 6 : newsrole = stack->masked_srole;
2395 : : }
2396 : : else
2397 : : {
2398 : 150302 : newvalue = stack->prior;
2399 : 150302 : newsource = stack->source;
2400 : 150302 : newscontext = stack->scontext;
2401 : 150302 : newsrole = stack->srole;
2402 : : }
2403 : :
2404 [ + + + + : 150308 : switch (gconf->vartype)
+ - ]
2405 : : {
2406 : 1527 : case PGC_BOOL:
2407 : : {
2408 : 1527 : struct config_bool *conf = (struct config_bool *) gconf;
2409 : 1527 : bool newval = newvalue.val.boolval;
2410 : 1527 : void *newextra = newvalue.extra;
2411 : :
2412 [ + + ]: 1527 : if (*conf->variable != newval ||
2413 [ - + ]: 215 : conf->gen.extra != newextra)
2414 : : {
2415 [ - + ]: 1312 : if (conf->assign_hook)
579 tgl@sss.pgh.pa.us 2416 :UBC 0 : conf->assign_hook(newval, newextra);
579 tgl@sss.pgh.pa.us 2417 :CBC 1312 : *conf->variable = newval;
2418 : 1312 : set_extra_field(&conf->gen, &conf->gen.extra,
2419 : : newextra);
2420 : 1312 : changed = true;
2421 : : }
2422 : 1527 : break;
2423 : : }
2424 : 4772 : case PGC_INT:
2425 : : {
2426 : 4772 : struct config_int *conf = (struct config_int *) gconf;
2427 : 4772 : int newval = newvalue.val.intval;
2428 : 4772 : void *newextra = newvalue.extra;
2429 : :
2430 [ + + ]: 4772 : if (*conf->variable != newval ||
2431 [ - + ]: 98 : conf->gen.extra != newextra)
2432 : : {
2433 [ - + ]: 4674 : if (conf->assign_hook)
579 tgl@sss.pgh.pa.us 2434 :UBC 0 : conf->assign_hook(newval, newextra);
579 tgl@sss.pgh.pa.us 2435 :CBC 4674 : *conf->variable = newval;
2436 : 4674 : set_extra_field(&conf->gen, &conf->gen.extra,
2437 : : newextra);
2438 : 4674 : changed = true;
2439 : : }
2440 : 4772 : break;
2441 : : }
2442 : 704 : case PGC_REAL:
2443 : : {
2444 : 704 : struct config_real *conf = (struct config_real *) gconf;
2445 : 704 : double newval = newvalue.val.realval;
2446 : 704 : void *newextra = newvalue.extra;
2447 : :
2448 [ + + ]: 704 : if (*conf->variable != newval ||
2449 [ - + ]: 12 : conf->gen.extra != newextra)
2450 : : {
2451 [ - + ]: 692 : if (conf->assign_hook)
579 tgl@sss.pgh.pa.us 2452 :UBC 0 : conf->assign_hook(newval, newextra);
579 tgl@sss.pgh.pa.us 2453 :CBC 692 : *conf->variable = newval;
2454 : 692 : set_extra_field(&conf->gen, &conf->gen.extra,
2455 : : newextra);
2456 : 692 : changed = true;
2457 : : }
2458 : 704 : break;
2459 : : }
2460 : 135502 : case PGC_STRING:
2461 : : {
2462 : 135502 : struct config_string *conf = (struct config_string *) gconf;
2463 : 135502 : char *newval = newvalue.val.stringval;
2464 : 135502 : void *newextra = newvalue.extra;
2465 : :
2466 [ + + ]: 135502 : if (*conf->variable != newval ||
2467 [ - + ]: 7 : conf->gen.extra != newextra)
2468 : : {
2469 [ + + ]: 135495 : if (conf->assign_hook)
2470 : 135226 : conf->assign_hook(newval, newextra);
2471 : 135495 : set_string_field(conf, conf->variable, newval);
2472 : 135495 : set_extra_field(&conf->gen, &conf->gen.extra,
2473 : : newextra);
2474 : 135495 : 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 : 135502 : set_string_field(conf, &stack->prior.val.stringval, NULL);
2484 : 135502 : set_string_field(conf, &stack->masked.val.stringval, NULL);
2485 : 135502 : break;
2486 : : }
2487 : 7803 : case PGC_ENUM:
2488 : : {
2489 : 7803 : struct config_enum *conf = (struct config_enum *) gconf;
2490 : 7803 : int newval = newvalue.val.enumval;
2491 : 7803 : void *newextra = newvalue.extra;
2492 : :
2493 [ + + ]: 7803 : if (*conf->variable != newval ||
2494 [ - + ]: 445 : conf->gen.extra != newextra)
2495 : : {
2496 [ + + ]: 7358 : if (conf->assign_hook)
2497 : 15 : conf->assign_hook(newval, newextra);
2498 : 7358 : *conf->variable = newval;
2499 : 7358 : set_extra_field(&conf->gen, &conf->gen.extra,
2500 : : newextra);
2501 : 7358 : changed = true;
2502 : : }
2503 : 7803 : break;
2504 : : }
2505 : : }
2506 : :
2507 : : /*
2508 : : * Release stacked extra values if not used anymore.
2509 : : */
2510 : 150308 : set_extra_field(gconf, &(stack->prior.extra), NULL);
2511 : 150308 : set_extra_field(gconf, &(stack->masked.extra), NULL);
2512 : :
2513 : : /* And restore source information */
548 2514 : 150308 : set_guc_source(gconf, newsource);
579 2515 : 150308 : gconf->scontext = newscontext;
2516 : 150308 : 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 : 172828 : gconf->stack = prev;
548 2524 [ + + ]: 172828 : if (prev == NULL)
2525 : 167783 : slist_delete_current(&iter);
579 2526 : 172828 : pfree(stack);
2527 : :
2528 : : /* Report new value if we changed it */
548 2529 [ + + + + ]: 172822 : if (changed && (gconf->flags & GUC_REPORT) &&
2530 [ + + ]: 8131 : !(gconf->status & GUC_NEEDS_REPORT))
2531 : : {
579 2532 : 107 : gconf->status |= GUC_NEEDS_REPORT;
548 2533 : 107 : slist_push_head(&guc_report_list, &gconf->report_link);
2534 : : }
2535 : : } /* end of stack-popping loop */
2536 : : }
2537 : :
2538 : : /* Update nesting level */
579 2539 : 617023 : GUCNestLevel = nestLevel - 1;
3770 ishii@postgresql.org 2540 : 617023 : }
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
579 tgl@sss.pgh.pa.us 2548 : 11164 : 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 [ + + ]: 11164 : if (whereToSendOutput != DestRemote)
2557 : 46 : return;
2558 : :
2559 : 11118 : 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 [ + + ]: 11118 : if (RecoveryInProgress())
2570 : 504 : SetConfigOption("in_hot_standby", "true",
2571 : : PGC_INTERNAL, PGC_S_OVERRIDE);
2572 : :
2573 : : /* Transmit initial values of interesting variables */
548 2574 : 11118 : hash_seq_init(&status, guc_hashtab);
2575 [ + + ]: 4293308 : while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
2576 : : {
2577 : 4271072 : struct config_generic *conf = hentry->gucvar;
2578 : :
579 2579 [ + + ]: 4271072 : if (conf->flags & GUC_REPORT)
2580 : 155652 : 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 : 311863 : ReportChangedGUCOptions(void)
2599 : : {
2600 : : slist_mutable_iter iter;
2601 : :
2602 : : /* Quick exit if not (yet) enabled */
2603 [ + + ]: 311863 : if (!reporting_enabled)
2604 : 26205 : 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 [ + + + + ]: 285658 : if (in_hot_standby_guc && !RecoveryInProgress())
2613 : 5 : SetConfigOption("in_hot_standby", "false",
2614 : : PGC_INTERNAL, PGC_S_OVERRIDE);
2615 : :
2616 : : /* Transmit new values of interesting variables */
548 2617 [ + + + + : 372969 : slist_foreach_modify(iter, &guc_report_list)
+ + ]
2618 : : {
2619 : 87311 : struct config_generic *conf = slist_container(struct config_generic,
2620 : : report_link, iter.cur);
2621 : :
2622 [ + - - + ]: 87311 : Assert((conf->flags & GUC_REPORT) && (conf->status & GUC_NEEDS_REPORT));
2623 : 87311 : ReportGUCOption(conf);
2624 : 87311 : conf->status &= ~GUC_NEEDS_REPORT;
2625 : 87311 : 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
579 2636 : 242963 : ReportGUCOption(struct config_generic *record)
2637 : : {
2638 : 242963 : char *val = ShowGUCOption(record, false);
2639 : :
2640 [ + + ]: 242963 : if (record->last_reported == NULL ||
2641 [ + + ]: 87311 : strcmp(val, record->last_reported) != 0)
2642 : : {
2643 : : StringInfoData msgbuf;
2644 : :
236 nathan@postgresql.or 2645 :GNC 159790 : pq_beginmessage(&msgbuf, PqMsg_ParameterStatus);
579 tgl@sss.pgh.pa.us 2646 :CBC 159790 : pq_sendstring(&msgbuf, record->name);
2647 : 159790 : pq_sendstring(&msgbuf, val);
2648 : 159790 : 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 : : */
548 2655 : 159790 : guc_free(record->last_reported);
2656 : 159790 : record->last_reported = guc_strdup(LOG, val);
2657 : : }
2658 : :
579 2659 : 242963 : pfree(val);
2660 : 242963 : }
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 : 6959 : 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 : 6959 : unitlen = 0;
2683 [ + + + - : 20823 : while (*unit != '\0' && !isspace((unsigned char) *unit) &&
+ - ]
2684 : : unitlen < MAX_UNIT_LEN)
2685 : 13864 : unitstr[unitlen++] = *(unit++);
2686 : 6959 : unitstr[unitlen] = '\0';
2687 : : /* allow whitespace after unit */
2688 [ - + ]: 6959 : while (isspace((unsigned char) *unit))
579 tgl@sss.pgh.pa.us 2689 :UBC 0 : unit++;
579 tgl@sss.pgh.pa.us 2690 [ - + ]:CBC 6959 : if (*unit != '\0')
579 tgl@sss.pgh.pa.us 2691 :UBC 0 : return false; /* unit too long, or garbage after it */
2692 : :
2693 : : /* now search the appropriate table */
579 tgl@sss.pgh.pa.us 2694 [ + + ]:CBC 6959 : if (base_unit & GUC_UNIT_MEMORY)
2695 : 5350 : table = memory_unit_conversion_table;
2696 : : else
2697 : 1609 : table = time_unit_conversion_table;
2698 : :
2699 [ + - ]: 83623 : for (i = 0; *table[i].unit; i++)
2700 : : {
2701 [ + + ]: 83623 : if (base_unit == table[i].base_unit &&
2702 [ + + ]: 23336 : strcmp(unitstr, table[i].unit) == 0)
2703 : : {
2704 : 6959 : 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 [ + - ]: 6959 : if (*table[i + 1].unit &&
2712 [ + + ]: 6959 : base_unit == table[i + 1].base_unit)
2713 : 6956 : cvalue = rint(cvalue / table[i + 1].multiplier) *
2714 : 6956 : table[i + 1].multiplier;
2715 : :
2716 : 6959 : *base_value = cvalue;
2717 : 6959 : return true;
2718 : : }
2719 : : }
579 tgl@sss.pgh.pa.us 2720 :UBC 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
579 tgl@sss.pgh.pa.us 2731 :CBC 342 : 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 : 342 : *unit = NULL;
2738 : :
2739 [ + + ]: 342 : if (base_unit & GUC_UNIT_MEMORY)
2740 : 308 : table = memory_unit_conversion_table;
2741 : : else
2742 : 34 : table = time_unit_conversion_table;
2743 : :
2744 [ + - ]: 2394 : for (i = 0; *table[i].unit; i++)
2745 : : {
2746 [ + + ]: 2394 : 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 [ + + ]: 1081 : if (table[i].multiplier <= 1.0 ||
2754 [ + + ]: 1026 : base_value % (int64) table[i].multiplier == 0)
2755 : : {
2756 : 342 : *value = (int64) rint(base_value / table[i].multiplier);
2757 : 342 : *unit = table[i].unit;
2758 : 342 : break;
2759 : : }
2760 : : }
2761 : : }
2762 : :
2763 [ - + ]: 342 : Assert(*unit != NULL);
2764 : 342 : }
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 : 134 : 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 : 134 : *unit = NULL;
2780 : :
2781 [ - + ]: 134 : if (base_unit & GUC_UNIT_MEMORY)
579 tgl@sss.pgh.pa.us 2782 :UBC 0 : table = memory_unit_conversion_table;
2783 : : else
579 tgl@sss.pgh.pa.us 2784 :CBC 134 : table = time_unit_conversion_table;
2785 : :
2786 [ + - ]: 682 : for (i = 0; *table[i].unit; i++)
2787 : : {
2788 [ + - ]: 682 : 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 : 682 : *value = base_value / table[i].multiplier;
2801 : 682 : *unit = table[i].unit;
2802 [ + - ]: 682 : if (*value > 0 &&
2803 [ + + ]: 682 : fabs((rint(*value) / *value) - 1.0) <= 1e-8)
2804 : 134 : break;
2805 : : }
2806 : : }
2807 : :
2808 [ - + ]: 134 : Assert(*unit != NULL);
2809 : 134 : }
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 : 724464 : get_config_unit_name(int flags)
2817 : : {
304 msawada@postgresql.o 2818 [ + + + + : 724464 : switch (flags & GUC_UNIT)
+ + + + +
- ]
2819 : : {
579 tgl@sss.pgh.pa.us 2820 : 580669 : case 0:
2821 : 580669 : return NULL; /* GUC has no units */
2822 : 9460 : case GUC_UNIT_BYTE:
2823 : 9460 : return "B";
2824 : 22704 : case GUC_UNIT_KB:
2825 : 22704 : return "kB";
2826 : 11352 : case GUC_UNIT_MB:
2827 : 11352 : return "MB";
2828 : 32164 : case GUC_UNIT_BLOCKS:
2829 : : {
2830 : : static char bbuf[8];
2831 : :
2832 : : /* initialize if first time through */
2833 [ + + ]: 32164 : if (bbuf[0] == '\0')
2834 : 35 : snprintf(bbuf, sizeof(bbuf), "%dkB", BLCKSZ / 1024);
2835 : 32164 : return bbuf;
2836 : : }
2837 : 3784 : case GUC_UNIT_XBLOCKS:
2838 : : {
2839 : : static char xbuf[8];
2840 : :
2841 : : /* initialize if first time through */
2842 [ + + ]: 3784 : if (xbuf[0] == '\0')
2843 : 35 : snprintf(xbuf, sizeof(xbuf), "%dkB", XLOG_BLCKSZ / 1024);
2844 : 3784 : return xbuf;
2845 : : }
2846 : 41627 : case GUC_UNIT_MS:
2847 : 41627 : return "ms";
2848 : 18920 : case GUC_UNIT_S:
2849 : 18920 : return "s";
2850 : 3784 : case GUC_UNIT_MIN:
2851 : 3784 : return "min";
579 tgl@sss.pgh.pa.us 2852 :UBC 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
579 tgl@sss.pgh.pa.us 2873 :CBC 53135 : 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 [ + - ]: 53135 : if (result)
2884 : 53135 : *result = 0;
2885 [ + + ]: 53135 : if (hintmsg)
2886 : 49279 : *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 : 53135 : errno = 0;
2896 : 53135 : val = strtol(value, &endptr, 0);
2897 [ + + + - : 53135 : if (*endptr == '.' || *endptr == 'e' || *endptr == 'E' ||
+ - ]
2898 [ - + ]: 53129 : errno == ERANGE)
2899 : : {
2900 : 6 : errno = 0;
2901 : 6 : val = strtod(value, &endptr);
2902 : : }
2903 : :
2904 [ + + - + ]: 53135 : if (endptr == value || errno == ERANGE)
2905 : 11 : return false; /* no HINT for these cases */
2906 : :
2907 : : /* reject NaN (infinities will fail range check below) */
2908 [ - + ]: 53124 : if (isnan(val))
579 tgl@sss.pgh.pa.us 2909 :UBC 0 : return false; /* treat same as syntax error; no HINT */
2910 : :
2911 : : /* allow whitespace between number and unit */
579 tgl@sss.pgh.pa.us 2912 [ + + ]:CBC 53142 : while (isspace((unsigned char) *endptr))
2913 : 18 : endptr++;
2914 : :
2915 : : /* Handle possible unit */
2916 [ + + ]: 53124 : if (*endptr != '\0')
2917 : : {
2918 [ + + ]: 6955 : if ((flags & GUC_UNIT) == 0)
2919 : 2 : return false; /* this setting does not accept a unit */
2920 : :
2921 [ - + ]: 6953 : 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. */
579 tgl@sss.pgh.pa.us 2926 [ # # ]:UBC 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 */
579 tgl@sss.pgh.pa.us 2938 :CBC 53122 : val = rint(val);
2939 : :
2940 [ + + - + ]: 53122 : if (val > INT_MAX || val < INT_MIN)
2941 : : {
2942 [ + - ]: 3 : if (hintmsg)
2943 : 3 : *hintmsg = gettext_noop("Value exceeds integer range.");
2944 : 3 : return false;
2945 : : }
2946 : :
2947 [ + - ]: 53119 : if (result)
2948 : 53119 : *result = (int) val;
2949 : 53119 : 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 : 4219 : 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 [ + - ]: 4219 : if (result)
2970 : 4219 : *result = 0;
2971 [ + + ]: 4219 : if (hintmsg)
2972 : 3976 : *hintmsg = NULL;
2973 : :
2974 : 4219 : errno = 0;
2975 : 4219 : val = strtod(value, &endptr);
2976 : :
2977 [ + + - + ]: 4219 : if (endptr == value || errno == ERANGE)
2978 : 8 : return false; /* no HINT for these cases */
2979 : :
2980 : : /* reject NaN (infinities will fail range checks later) */
2981 [ + + ]: 4211 : if (isnan(val))
2982 : 3 : return false; /* treat same as syntax error; no HINT */
2983 : :
2984 : : /* allow whitespace between number and unit */
2985 [ - + ]: 4208 : while (isspace((unsigned char) *endptr))
579 tgl@sss.pgh.pa.us 2986 :UBC 0 : endptr++;
2987 : :
2988 : : /* Handle possible unit */
579 tgl@sss.pgh.pa.us 2989 [ + + ]:CBC 4208 : if (*endptr != '\0')
2990 : : {
2991 [ + + ]: 8 : if ((flags & GUC_UNIT) == 0)
2992 : 2 : return false; /* this setting does not accept a unit */
2993 : :
2994 [ - + ]: 6 : 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. */
579 tgl@sss.pgh.pa.us 2999 [ # # ]:UBC 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 : :
579 tgl@sss.pgh.pa.us 3010 [ + - ]:CBC 4206 : if (result)
3011 : 4206 : *result = val;
3012 : 4206 : 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 : 240908 : config_enum_lookup_by_value(struct config_enum *record, int val)
3026 : : {
3027 : : const struct config_enum_entry *entry;
3028 : :
3029 [ + - + - ]: 613819 : for (entry = record->options; entry && entry->name; entry++)
3030 : : {
3031 [ + + ]: 613819 : if (entry->val == val)
3032 : 240908 : return entry->name;
3033 : : }
3034 : :
579 tgl@sss.pgh.pa.us 3035 [ # # ]:UBC 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
579 tgl@sss.pgh.pa.us 3048 :CBC 33949 : 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 [ + - + + ]: 74787 : for (entry = record->options; entry && entry->name; entry++)
3054 : : {
3055 [ + + ]: 74772 : if (pg_strcasecmp(value, entry->name) == 0)
3056 : : {
3057 : 33934 : *retval = entry->val;
3058 : 33934 : return true;
3059 : : }
3060 : : }
3061 : :
3062 : 15 : *retval = 0;
3063 : 15 : 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 : 73768 : 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 : 73768 : initStringInfo(&retstr);
3082 : 73768 : appendStringInfoString(&retstr, prefix);
3083 : :
3084 : 73768 : seplen = strlen(separator);
3085 [ + - + + ]: 489960 : for (entry = record->options; entry && entry->name; entry++)
3086 : : {
3087 [ + + ]: 416192 : if (!entry->hidden)
3088 : : {
3089 : 298870 : appendStringInfoString(&retstr, entry->name);
3090 : 298870 : 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 [ + - ]: 73768 : if (retstr.len >= seplen)
3102 : : {
3103 : : /* Replace final separator */
3104 : 73768 : retstr.data[retstr.len - seplen] = '\0';
3105 : 73768 : retstr.len -= seplen;
3106 : : }
3107 : :
3108 : 73768 : appendStringInfoString(&retstr, suffix);
3109 : :
3110 : 73768 : 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 : 411468 : 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 [ + + + + : 411468 : switch (record->vartype)
+ - ]
3138 : : {
3139 : 65973 : case PGC_BOOL:
3140 : : {
3141 : 65973 : struct config_bool *conf = (struct config_bool *) record;
3142 : :
3143 [ - + ]: 65973 : if (!parse_bool(value, &newval->boolval))
3144 : : {
579 tgl@sss.pgh.pa.us 3145 [ # # ]:UBC 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 : :
579 tgl@sss.pgh.pa.us 3152 [ - + ]:CBC 65973 : if (!call_bool_check_hook(conf, &newval->boolval, newextra,
3153 : : source, elevel))
579 tgl@sss.pgh.pa.us 3154 :UBC 0 : return false;
3155 : : }
579 tgl@sss.pgh.pa.us 3156 :CBC 65961 : break;
3157 : 49252 : case PGC_INT:
3158 : : {
3159 : 49252 : struct config_int *conf = (struct config_int *) record;
3160 : : const char *hintmsg;
3161 : :
3162 [ - + ]: 49252 : if (!parse_int(value, &newval->intval,
3163 : : conf->gen.flags, &hintmsg))
3164 : : {
579 tgl@sss.pgh.pa.us 3165 [ # # # # ]:UBC 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 : :
579 tgl@sss.pgh.pa.us 3173 [ + - - + ]:CBC 49252 : if (newval->intval < conf->min || newval->intval > conf->max)
3174 : : {
579 tgl@sss.pgh.pa.us 3175 :UBC 0 : const char *unit = get_config_unit_name(conf->gen.flags);
3176 : :
3177 [ # # # # : 0 : ereport(elevel,
# # ]
3178 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3179 : : errmsg("%d%s%s is outside the valid range for parameter \"%s\" (%d .. %d)",
3180 : : newval->intval,
3181 : : unit ? " " : "",
3182 : : unit ? unit : "",
3183 : : name,
3184 : : conf->min, conf->max)));
3185 : 0 : return false;
3186 : : }
3187 : :
579 tgl@sss.pgh.pa.us 3188 [ - + ]:CBC 49252 : if (!call_int_check_hook(conf, &newval->intval, newextra,
3189 : : source, elevel))
579 tgl@sss.pgh.pa.us 3190 :UBC 0 : return false;
3191 : : }
579 tgl@sss.pgh.pa.us 3192 :CBC 49252 : break;
3193 : 3976 : case PGC_REAL:
3194 : : {
3195 : 3976 : struct config_real *conf = (struct config_real *) record;
3196 : : const char *hintmsg;
3197 : :
3198 [ + + ]: 3976 : if (!parse_real(value, &newval->realval,
3199 : : conf->gen.flags, &hintmsg))
3200 : : {
3201 [ + - - + ]: 3 : ereport(elevel,
3202 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3203 : : errmsg("invalid value for parameter \"%s\": \"%s\"",
3204 : : name, value),
3205 : : hintmsg ? errhint("%s", _(hintmsg)) : 0));
579 tgl@sss.pgh.pa.us 3206 :UBC 0 : return false;
3207 : : }
3208 : :
579 tgl@sss.pgh.pa.us 3209 [ + - + + ]:CBC 3973 : if (newval->realval < conf->min || newval->realval > conf->max)
3210 : : {
3211 : 3 : const char *unit = get_config_unit_name(conf->gen.flags);
3212 : :
3213 [ + - + - : 3 : ereport(elevel,
+ - ]
3214 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3215 : : errmsg("%g%s%s is outside the valid range for parameter \"%s\" (%g .. %g)",
3216 : : newval->realval,
3217 : : unit ? " " : "",
3218 : : unit ? unit : "",
3219 : : name,
3220 : : conf->min, conf->max)));
579 tgl@sss.pgh.pa.us 3221 :UBC 0 : return false;
3222 : : }
3223 : :
579 tgl@sss.pgh.pa.us 3224 [ - + ]:CBC 3970 : if (!call_real_check_hook(conf, &newval->realval, newextra,
3225 : : source, elevel))
579 tgl@sss.pgh.pa.us 3226 :UBC 0 : return false;
3227 : : }
579 tgl@sss.pgh.pa.us 3228 :CBC 3970 : break;
3229 : 258318 : case PGC_STRING:
3230 : : {
3231 : 258318 : struct config_string *conf = (struct config_string *) record;
3232 : :
3233 : : /*
3234 : : * The value passed by the caller could be transient, so we
3235 : : * always strdup it.
3236 : : */
3237 : 258318 : newval->stringval = guc_strdup(elevel, value);
3238 [ - + ]: 258318 : if (newval->stringval == NULL)
579 tgl@sss.pgh.pa.us 3239 :UBC 0 : return false;
3240 : :
3241 : : /*
3242 : : * The only built-in "parsing" check we have is to apply
3243 : : * truncation if GUC_IS_NAME.
3244 : : */
579 tgl@sss.pgh.pa.us 3245 [ + + ]:CBC 258318 : if (conf->gen.flags & GUC_IS_NAME)
3246 : 59214 : truncate_identifier(newval->stringval,
3247 : 59214 : strlen(newval->stringval),
3248 : : true);
3249 : :
3250 [ - + ]: 258318 : if (!call_string_check_hook(conf, &newval->stringval, newextra,
3251 : : source, elevel))
3252 : : {
548 tgl@sss.pgh.pa.us 3253 :UBC 0 : guc_free(newval->stringval);
579 3254 : 0 : newval->stringval = NULL;
3255 : 0 : return false;
3256 : : }
3257 : : }
579 tgl@sss.pgh.pa.us 3258 :CBC 258297 : break;
3259 : 33949 : case PGC_ENUM:
3260 : : {
3261 : 33949 : struct config_enum *conf = (struct config_enum *) record;
3262 : :
3263 [ + + ]: 33949 : if (!config_enum_lookup_by_name(conf, value, &newval->enumval))
3264 : : {
3265 : : char *hintmsg;
3266 : :
3267 : 15 : hintmsg = config_enum_get_options(conf,
3268 : : "Available values: ",
3269 : : ".", ", ");
3270 : :
3271 [ + - + - ]: 15 : ereport(elevel,
3272 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3273 : : errmsg("invalid value for parameter \"%s\": \"%s\"",
3274 : : name, value),
3275 : : hintmsg ? errhint("%s", _(hintmsg)) : 0));
3276 : :
579 tgl@sss.pgh.pa.us 3277 [ # # ]:UBC 0 : if (hintmsg)
3278 : 0 : pfree(hintmsg);
3279 : 0 : return false;
3280 : : }
3281 : :
579 tgl@sss.pgh.pa.us 3282 [ - + ]:CBC 33934 : if (!call_enum_check_hook(conf, &newval->enumval, newextra,
3283 : : source, elevel))
579 tgl@sss.pgh.pa.us 3284 :UBC 0 : return false;
3285 : : }
579 tgl@sss.pgh.pa.us 3286 :CBC 33933 : break;
3287 : : }
3288 : :
3289 : 411413 : return true;
3290 : : }
3291 : :
3292 : :
3293 : : /*
3294 : : * set_config_option: sets option `name' to given value.
3295 : : *
3296 : : * The value should be a string, which will be parsed and converted to
3297 : : * the appropriate data type. The context and source parameters indicate
3298 : : * in which context this function is being called, so that it can apply the
3299 : : * access restrictions properly.
3300 : : *
3301 : : * If value is NULL, set the option to its default value (normally the
3302 : : * reset_val, but if source == PGC_S_DEFAULT we instead use the boot_val).
3303 : : *
3304 : : * action indicates whether to set the value globally in the session, locally
3305 : : * to the current top transaction, or just for the duration of a function call.
3306 : : *
3307 : : * If changeVal is false then don't really set the option but do all
3308 : : * the checks to see if it would work.
3309 : : *
3310 : : * elevel should normally be passed as zero, allowing this function to make
3311 : : * its standard choice of ereport level. However some callers need to be
3312 : : * able to override that choice; they should pass the ereport level to use.
3313 : : *
3314 : : * is_reload should be true only when called from read_nondefault_variables()
3315 : : * or RestoreGUCState(), where we are trying to load some other process's
3316 : : * GUC settings into a new process.
3317 : : *
3318 : : * Return value:
3319 : : * +1: the value is valid and was successfully applied.
3320 : : * 0: the name or value is invalid (but see below).
3321 : : * -1: the value was not applied because of context, priority, or changeVal.
3322 : : *
3323 : : * If there is an error (non-existing option, invalid value) then an
3324 : : * ereport(ERROR) is thrown *unless* this is called for a source for which
3325 : : * we don't want an ERROR (currently, those are defaults, the config file,
3326 : : * and per-database or per-user settings, as well as callers who specify
3327 : : * a less-than-ERROR elevel). In those cases we write a suitable error
3328 : : * message via ereport() and return 0.
3329 : : *
3330 : : * See also SetConfigOption for an external interface.
3331 : : */
3332 : : int
3333 : 368019 : set_config_option(const char *name, const char *value,
3334 : : GucContext context, GucSource source,
3335 : : GucAction action, bool changeVal, int elevel,
3336 : : bool is_reload)
3337 : : {
3338 : : Oid srole;
3339 : :
3340 : : /*
3341 : : * Non-interactive sources should be treated as having all privileges,
3342 : : * except for PGC_S_CLIENT. Note in particular that this is true for
3343 : : * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3344 : : * privilege check was done when the pg_db_role_setting entry was made.
3345 : : */
3346 [ + + + + ]: 368019 : if (source >= PGC_S_INTERACTIVE || source == PGC_S_CLIENT)
3347 : 188655 : srole = GetUserId();
3348 : : else
3349 : 179364 : srole = BOOTSTRAP_SUPERUSERID;
3350 : :
128 jdavis@postgresql.or 3351 :GNC 368019 : return set_config_with_handle(name, NULL, value,
3352 : : context, source, srole,
3353 : : action, changeVal, elevel,
3354 : : is_reload);
3355 : : }
3356 : :
3357 : : /*
3358 : : * set_config_option_ext: sets option `name' to given value.
3359 : : *
3360 : : * This API adds the ability to explicitly specify which role OID
3361 : : * is considered to be setting the value. Most external callers can use
3362 : : * set_config_option() and let it determine that based on the GucSource,
3363 : : * but there are a few that are supplying a value that was determined
3364 : : * in some special way and need to override the decision. Also, when
3365 : : * restoring a previously-assigned value, it's important to supply the
3366 : : * same role OID that set the value originally; so all guc.c callers
3367 : : * that are doing that type of thing need to call this directly.
3368 : : *
3369 : : * Generally, srole should be GetUserId() when the source is a SQL operation,
3370 : : * or BOOTSTRAP_SUPERUSERID if the source is a config file or similar.
3371 : : */
3372 : : int
579 tgl@sss.pgh.pa.us 3373 :CBC 45726 : set_config_option_ext(const char *name, const char *value,
3374 : : GucContext context, GucSource source, Oid srole,
3375 : : GucAction action, bool changeVal, int elevel,
3376 : : bool is_reload)
3377 : : {
128 jdavis@postgresql.or 3378 :GNC 45726 : return set_config_with_handle(name, NULL, value,
3379 : : context, source, srole,
3380 : : action, changeVal, elevel,
3381 : : is_reload);
3382 : : }
3383 : :
3384 : :
3385 : : /*
3386 : : * set_config_with_handle: takes an optional 'handle' argument, which can be
3387 : : * obtained by the caller from get_config_handle().
3388 : : *
3389 : : * This should be used by callers which repeatedly set the same config
3390 : : * option(s), and want to avoid the overhead of a hash lookup each time.
3391 : : */
3392 : : int
3393 : 413794 : set_config_with_handle(const char *name, config_handle *handle,
3394 : : const char *value,
3395 : : GucContext context, GucSource source, Oid srole,
3396 : : GucAction action, bool changeVal, int elevel,
3397 : : bool is_reload)
3398 : : {
3399 : : struct config_generic *record;
3400 : : union config_var_val newval_union;
579 tgl@sss.pgh.pa.us 3401 :CBC 413794 : void *newextra = NULL;
3402 : 413794 : bool prohibitValueChange = false;
3403 : : bool makeDefault;
3404 : :
3405 [ + + ]: 413794 : if (elevel == 0)
3406 : : {
3407 [ + + + + ]: 368070 : if (source == PGC_S_DEFAULT || source == PGC_S_FILE)
3408 : : {
3409 : : /*
3410 : : * To avoid cluttering the log, only the postmaster bleats loudly
3411 : : * about problems with the config file.
3412 : : */
3413 [ + + ]: 43444 : elevel = IsUnderPostmaster ? DEBUG3 : LOG;
3414 : : }
3415 [ + - + + ]: 324626 : else if (source == PGC_S_GLOBAL ||
3416 [ + - ]: 306024 : source == PGC_S_DATABASE ||
3417 [ - + ]: 306024 : source == PGC_S_USER ||
3418 : : source == PGC_S_DATABASE_USER)
3419 : 18602 : elevel = WARNING;
3420 : : else
3421 : 306024 : elevel = ERROR;
3422 : : }
3423 : :
3424 : : /*
3425 : : * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
3426 : : * because the current worker will also pop the change. We're probably
3427 : : * dealing with a function having a proconfig entry. Only the function's
3428 : : * body should observe the change, and peer workers do not share in the
3429 : : * execution of a function call started by this worker.
3430 : : *
3431 : : * Other changes might need to affect other workers, so forbid them.
3432 : : */
3433 [ - + - - : 413794 : if (IsInParallelMode() && changeVal && action != GUC_ACTION_SAVE)
- - ]
3434 : : {
579 tgl@sss.pgh.pa.us 3435 [ # # ]:UBC 0 : ereport(elevel,
3436 : : (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3437 : : errmsg("cannot set parameters during a parallel operation")));
110 3438 : 0 : return -1;
3439 : : }
3440 : :
3441 : : /* if handle is specified, no need to look up option */
128 jdavis@postgresql.or 3442 [ + + ]:GNC 413794 : if (!handle)
3443 : : {
3444 : 413753 : record = find_option(name, true, false, elevel);
3445 [ - + ]: 413717 : if (record == NULL)
128 jdavis@postgresql.or 3446 :UNC 0 : return 0;
3447 : : }
3448 : : else
128 jdavis@postgresql.or 3449 :GNC 41 : record = handle;
3450 : :
3451 : : /*
3452 : : * Check if the option can be set at this time. See guc.h for the precise
3453 : : * rules.
3454 : : */
579 tgl@sss.pgh.pa.us 3455 [ + + + + :CBC 413758 : switch (record->context)
+ + + - ]
3456 : : {
3457 : 50236 : case PGC_INTERNAL:
3458 [ + + ]: 50236 : if (context != PGC_INTERNAL)
3459 : : {
3460 [ + - ]: 2 : ereport(elevel,
3461 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3462 : : errmsg("parameter \"%s\" cannot be changed",
3463 : : name)));
579 tgl@sss.pgh.pa.us 3464 :UBC 0 : return 0;
3465 : : }
579 tgl@sss.pgh.pa.us 3466 :CBC 50234 : break;
3467 : 25070 : case PGC_POSTMASTER:
3468 [ + + ]: 25070 : if (context == PGC_SIGHUP)
3469 : : {
3470 : : /*
3471 : : * We are re-reading a PGC_POSTMASTER variable from
3472 : : * postgresql.conf. We can't change the setting, so we should
3473 : : * give a warning if the DBA tries to change it. However,
3474 : : * because of variant formats, canonicalization by check
3475 : : * hooks, etc, we can't just compare the given string directly
3476 : : * to what's stored. Set a flag to check below after we have
3477 : : * the final storable value.
3478 : : */
3479 : 7777 : prohibitValueChange = true;
3480 : : }
3481 [ + + ]: 17293 : else if (context != PGC_POSTMASTER)
3482 : : {
3483 [ + - ]: 4 : ereport(elevel,
3484 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3485 : : errmsg("parameter \"%s\" cannot be changed without restarting the server",
3486 : : name)));
579 tgl@sss.pgh.pa.us 3487 :UBC 0 : return 0;
3488 : : }
579 tgl@sss.pgh.pa.us 3489 :CBC 25066 : break;
3490 : 23156 : case PGC_SIGHUP:
3491 [ + + + + ]: 23156 : if (context != PGC_SIGHUP && context != PGC_POSTMASTER)
3492 : : {
3493 [ + - ]: 3 : ereport(elevel,
3494 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3495 : : errmsg("parameter \"%s\" cannot be changed now",
3496 : : name)));
579 tgl@sss.pgh.pa.us 3497 :UBC 0 : return 0;
3498 : : }
3499 : :
3500 : : /*
3501 : : * Hmm, the idea of the SIGHUP context is "ought to be global, but
3502 : : * can be changed after postmaster start". But there's nothing
3503 : : * that prevents a crafty administrator from sending SIGHUP
3504 : : * signals to individual backends only.
3505 : : */
579 tgl@sss.pgh.pa.us 3506 :CBC 23153 : break;
3507 : 354 : case PGC_SU_BACKEND:
3508 [ - + ]: 354 : if (context == PGC_BACKEND)
3509 : : {
3510 : : /*
3511 : : * Check whether the requesting user has been granted
3512 : : * privilege to set this GUC.
3513 : : */
3514 : : AclResult aclresult;
3515 : :
579 tgl@sss.pgh.pa.us 3516 :UBC 0 : aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3517 [ # # ]: 0 : if (aclresult != ACLCHECK_OK)
3518 : : {
3519 : : /* No granted privilege */
3520 [ # # ]: 0 : ereport(elevel,
3521 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3522 : : errmsg("permission denied to set parameter \"%s\"",
3523 : : name)));
3524 : 0 : return 0;
3525 : : }
3526 : : }
3527 : : /* fall through to process the same as PGC_BACKEND */
3528 : : /* FALLTHROUGH */
3529 : : case PGC_BACKEND:
579 tgl@sss.pgh.pa.us 3530 [ + + ]:CBC 356 : if (context == PGC_SIGHUP)
3531 : : {
3532 : : /*
3533 : : * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
3534 : : * the config file, we want to accept the new value in the
3535 : : * postmaster (whence it will propagate to
3536 : : * subsequently-started backends), but ignore it in existing
3537 : : * backends. This is a tad klugy, but necessary because we
3538 : : * don't re-read the config file during backend start.
3539 : : *
3540 : : * However, if changeVal is false then plow ahead anyway since
3541 : : * we are trying to find out if the value is potentially good,
3542 : : * not actually use it.
3543 : : *
3544 : : * In EXEC_BACKEND builds, this works differently: we load all
3545 : : * non-default settings from the CONFIG_EXEC_PARAMS file
3546 : : * during backend start. In that case we must accept
3547 : : * PGC_SIGHUP settings, so as to have the same value as if
3548 : : * we'd forked from the postmaster. This can also happen when
3549 : : * using RestoreGUCState() within a background worker that
3550 : : * needs to have the same settings as the user backend that
3551 : : * started it. is_reload will be true when either situation
3552 : : * applies.
3553 : : */
110 3554 [ + + + - : 286 : if (IsUnderPostmaster && changeVal && !is_reload)
+ + ]
579 3555 : 235 : return -1;
3556 : : }
3557 [ + + + - ]: 70 : else if (context != PGC_POSTMASTER &&
3558 [ + - ]: 4 : context != PGC_BACKEND &&
3559 [ + - ]: 4 : context != PGC_SU_BACKEND &&
3560 : : source != PGC_S_CLIENT)
3561 : : {
3562 [ + - ]: 4 : ereport(elevel,
3563 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3564 : : errmsg("parameter \"%s\" cannot be set after connection start",
3565 : : name)));
579 tgl@sss.pgh.pa.us 3566 :UBC 0 : return 0;
3567 : : }
579 tgl@sss.pgh.pa.us 3568 :CBC 117 : break;
3569 : 19275 : case PGC_SUSET:
3570 [ + + + + ]: 19275 : if (context == PGC_USERSET || context == PGC_BACKEND)
3571 : : {
3572 : : /*
3573 : : * Check whether the requesting user has been granted
3574 : : * privilege to set this GUC.
3575 : : */
3576 : : AclResult aclresult;
3577 : :
3578 : 15 : aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3579 [ + + ]: 15 : if (aclresult != ACLCHECK_OK)
3580 : : {
3581 : : /* No granted privilege */
3582 [ + - ]: 8 : ereport(elevel,
3583 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3584 : : errmsg("permission denied to set parameter \"%s\"",
3585 : : name)));
3586 : 2 : return 0;
3587 : : }
3588 : : }
3589 : 19267 : break;
3590 : 295665 : case PGC_USERSET:
3591 : : /* always okay */
3592 : 295665 : break;
3593 : : }
3594 : :
3595 : : /*
3596 : : * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
3597 : : * security restriction context. We can reject this regardless of the GUC
3598 : : * context or source, mainly because sources that it might be reasonable
3599 : : * to override for won't be seen while inside a function.
3600 : : *
3601 : : * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
3602 : : * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
3603 : : * An exception might be made if the reset value is assumed to be "safe".
3604 : : *
3605 : : * Note: this flag is currently used for "session_authorization" and
3606 : : * "role". We need to prohibit changing these inside a local userid
3607 : : * context because when we exit it, GUC won't be notified, leaving things
3608 : : * out of sync. (This could be fixed by forcing a new GUC nesting level,
3609 : : * but that would change behavior in possibly-undesirable ways.) Also, we
3610 : : * prohibit changing these in a security-restricted operation because
3611 : : * otherwise RESET could be used to regain the session user's privileges.
3612 : : */
3613 [ + + ]: 413502 : if (record->flags & GUC_NOT_WHILE_SEC_REST)
3614 : : {
3615 [ - + ]: 16548 : if (InLocalUserIdChange())
3616 : : {
3617 : : /*
3618 : : * Phrasing of this error message is historical, but it's the most
3619 : : * common case.
3620 : : */
579 tgl@sss.pgh.pa.us 3621 [ # # ]:UBC 0 : ereport(elevel,
3622 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3623 : : errmsg("cannot set parameter \"%s\" within security-definer function",
3624 : : name)));
3625 : 0 : return 0;
3626 : : }
579 tgl@sss.pgh.pa.us 3627 [ - + ]:CBC 16548 : if (InSecurityRestrictedOperation())
3628 : : {
579 tgl@sss.pgh.pa.us 3629 [ # # ]:UBC 0 : ereport(elevel,
3630 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3631 : : errmsg("cannot set parameter \"%s\" within security-restricted operation",
3632 : : name)));
3633 : 0 : return 0;
3634 : : }
3635 : : }
3636 : :
3637 : : /* Disallow resetting and saving GUC_NO_RESET values */
565 tgl@sss.pgh.pa.us 3638 [ + + ]:CBC 413502 : if (record->flags & GUC_NO_RESET)
3639 : : {
3640 [ + + ]: 10799 : if (value == NULL)
3641 : : {
3642 [ + - ]: 9 : ereport(elevel,
3643 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3644 : : errmsg("parameter \"%s\" cannot be reset", name)));
565 tgl@sss.pgh.pa.us 3645 :UBC 0 : return 0;
3646 : : }
565 tgl@sss.pgh.pa.us 3647 [ + + ]:CBC 10790 : if (action == GUC_ACTION_SAVE)
3648 : : {
3649 [ + - ]: 3 : ereport(elevel,
3650 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3651 : : errmsg("parameter \"%s\" cannot be set locally in functions",
3652 : : name)));
565 tgl@sss.pgh.pa.us 3653 :UBC 0 : return 0;
3654 : : }
3655 : : }
3656 : :
3657 : : /*
3658 : : * Should we set reset/stacked values? (If so, the behavior is not
3659 : : * transactional.) This is done either when we get a default value from
3660 : : * the database's/user's/client's default settings or when we reset a
3661 : : * value to its default.
3662 : : */
579 tgl@sss.pgh.pa.us 3663 [ + + + + :CBC 413498 : makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
+ + ]
3664 [ + - ]: 8 : ((value != NULL) || source == PGC_S_DEFAULT);
3665 : :
3666 : : /*
3667 : : * Ignore attempted set if overridden by previously processed setting.
3668 : : * However, if changeVal is false then plow ahead anyway since we are
3669 : : * trying to find out if the value is potentially good, not actually use
3670 : : * it. Also keep going if makeDefault is true, since we may want to set
3671 : : * the reset/stacked values even if we can't set the variable itself.
3672 : : */
3673 [ + + ]: 413490 : if (record->source > source)
3674 : : {
3675 [ + + - + ]: 1085 : if (changeVal && !makeDefault)
3676 : : {
579 tgl@sss.pgh.pa.us 3677 [ # # ]:UBC 0 : elog(DEBUG3, "\"%s\": setting ignored because previous source is higher priority",
3678 : : name);
3679 : 0 : return -1;
3680 : : }
579 tgl@sss.pgh.pa.us 3681 :CBC 1085 : changeVal = false;
3682 : : }
3683 : :
3684 : : /*
3685 : : * Evaluate value and set variable.
3686 : : */
3687 [ + + + + : 413490 : switch (record->vartype)
+ - ]
3688 : : {
3689 : 66628 : case PGC_BOOL:
3690 : : {
3691 : 66628 : struct config_bool *conf = (struct config_bool *) record;
3692 : :
3693 : : #define newval (newval_union.boolval)
3694 : :
3695 [ + + ]: 66628 : if (value)
3696 : : {
3697 [ - + ]: 65962 : if (!parse_and_validate_value(record, name, value,
3698 : : source, elevel,
3699 : : &newval_union, &newextra))
579 tgl@sss.pgh.pa.us 3700 :UBC 0 : return 0;
3701 : : }
579 tgl@sss.pgh.pa.us 3702 [ - + ]:CBC 666 : else if (source == PGC_S_DEFAULT)
3703 : : {
579 tgl@sss.pgh.pa.us 3704 :UBC 0 : newval = conf->boot_val;
3705 [ # # ]: 0 : if (!call_bool_check_hook(conf, &newval, &newextra,
3706 : : source, elevel))
3707 : 0 : return 0;
3708 : : }
3709 : : else
3710 : : {
579 tgl@sss.pgh.pa.us 3711 :CBC 666 : newval = conf->reset_val;
3712 : 666 : newextra = conf->reset_extra;
3713 : 666 : source = conf->gen.reset_source;
3714 : 666 : context = conf->gen.reset_scontext;
3715 : 666 : srole = conf->gen.reset_srole;
3716 : : }
3717 : :
3718 [ + + ]: 66616 : if (prohibitValueChange)
3719 : : {
3720 : : /* Release newextra, unless it's reset_extra */
3721 [ - + - - ]: 806 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 tgl@sss.pgh.pa.us 3722 :UBC 0 : guc_free(newextra);
3723 : :
579 tgl@sss.pgh.pa.us 3724 [ - + ]:CBC 806 : if (*conf->variable != newval)
3725 : : {
579 tgl@sss.pgh.pa.us 3726 :UBC 0 : record->status |= GUC_PENDING_RESTART;
3727 [ # # ]: 0 : ereport(elevel,
3728 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3729 : : errmsg("parameter \"%s\" cannot be changed without restarting the server",
3730 : : name)));
3731 : 0 : return 0;
3732 : : }
579 tgl@sss.pgh.pa.us 3733 :CBC 806 : record->status &= ~GUC_PENDING_RESTART;
3734 : 806 : return -1;
3735 : : }
3736 : :
3737 [ + + ]: 65810 : if (changeVal)
3738 : : {
3739 : : /* Save old value to support transaction abort */
3740 [ + + ]: 65775 : if (!makeDefault)
3741 : 13573 : push_old_value(&conf->gen, action);
3742 : :
3743 [ - + ]: 65775 : if (conf->assign_hook)
579 tgl@sss.pgh.pa.us 3744 :UBC 0 : conf->assign_hook(newval, newextra);
579 tgl@sss.pgh.pa.us 3745 :CBC 65775 : *conf->variable = newval;
3746 : 65775 : set_extra_field(&conf->gen, &conf->gen.extra,
3747 : : newextra);
548 3748 : 65775 : set_guc_source(&conf->gen, source);
579 3749 : 65775 : conf->gen.scontext = context;
3750 : 65775 : conf->gen.srole = srole;
3751 : : }
3752 [ + + ]: 65810 : if (makeDefault)
3753 : : {
3754 : : GucStack *stack;
3755 : :
3756 [ + + ]: 52225 : if (conf->gen.reset_source <= source)
3757 : : {
3758 : 52202 : conf->reset_val = newval;
3759 : 52202 : set_extra_field(&conf->gen, &conf->reset_extra,
3760 : : newextra);
3761 : 52202 : conf->gen.reset_source = source;
3762 : 52202 : conf->gen.reset_scontext = context;
3763 : 52202 : conf->gen.reset_srole = srole;
3764 : : }
3765 [ - + ]: 52225 : for (stack = conf->gen.stack; stack; stack = stack->prev)
3766 : : {
579 tgl@sss.pgh.pa.us 3767 [ # # ]:UBC 0 : if (stack->source <= source)
3768 : : {
3769 : 0 : stack->prior.val.boolval = newval;
3770 : 0 : set_extra_field(&conf->gen, &stack->prior.extra,
3771 : : newextra);
3772 : 0 : stack->source = source;
3773 : 0 : stack->scontext = context;
3774 : 0 : stack->srole = srole;
3775 : : }
3776 : : }
3777 : : }
3778 : :
3779 : : /* Perhaps we didn't install newextra anywhere */
579 tgl@sss.pgh.pa.us 3780 [ - + - - ]:CBC 65810 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 tgl@sss.pgh.pa.us 3781 :UBC 0 : guc_free(newextra);
579 tgl@sss.pgh.pa.us 3782 :CBC 65810 : break;
3783 : :
3784 : : #undef newval
3785 : : }
3786 : :
7567 bruce@momjian.us 3787 : 49386 : case PGC_INT:
3788 : : {
579 tgl@sss.pgh.pa.us 3789 : 49386 : struct config_int *conf = (struct config_int *) record;
3790 : :
3791 : : #define newval (newval_union.intval)
3792 : :
3793 [ + + ]: 49386 : if (value)
3794 : : {
3795 [ - + ]: 49241 : if (!parse_and_validate_value(record, name, value,
3796 : : source, elevel,
3797 : : &newval_union, &newextra))
579 tgl@sss.pgh.pa.us 3798 :UBC 0 : return 0;
3799 : : }
579 tgl@sss.pgh.pa.us 3800 [ - + ]:CBC 145 : else if (source == PGC_S_DEFAULT)
3801 : : {
579 tgl@sss.pgh.pa.us 3802 :UBC 0 : newval = conf->boot_val;
3803 [ # # ]: 0 : if (!call_int_check_hook(conf, &newval, &newextra,
3804 : : source, elevel))
3805 : 0 : return 0;
3806 : : }
3807 : : else
3808 : : {
579 tgl@sss.pgh.pa.us 3809 :CBC 145 : newval = conf->reset_val;
3810 : 145 : newextra = conf->reset_extra;
3811 : 145 : source = conf->gen.reset_source;
3812 : 145 : context = conf->gen.reset_scontext;
3813 : 145 : srole = conf->gen.reset_srole;
3814 : : }
3815 : :
3816 [ + + ]: 49386 : if (prohibitValueChange)
3817 : : {
3818 : : /* Release newextra, unless it's reset_extra */
3819 [ - + - - ]: 3672 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 tgl@sss.pgh.pa.us 3820 :UBC 0 : guc_free(newextra);
3821 : :
579 tgl@sss.pgh.pa.us 3822 [ - + ]:CBC 3672 : if (*conf->variable != newval)
3823 : : {
579 tgl@sss.pgh.pa.us 3824 :UBC 0 : record->status |= GUC_PENDING_RESTART;
3825 [ # # ]: 0 : ereport(elevel,
3826 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3827 : : errmsg("parameter \"%s\" cannot be changed without restarting the server",
3828 : : name)));
3829 : 0 : return 0;
3830 : : }
579 tgl@sss.pgh.pa.us 3831 :CBC 3672 : record->status &= ~GUC_PENDING_RESTART;
3832 : 3672 : return -1;
3833 : : }
3834 : :
3835 [ + + ]: 45714 : if (changeVal)
3836 : : {
3837 : : /* Save old value to support transaction abort */
3838 [ + + ]: 44843 : if (!makeDefault)
3839 : 9919 : push_old_value(&conf->gen, action);
3840 : :
3841 [ + + ]: 44843 : if (conf->assign_hook)
3842 : 8909 : conf->assign_hook(newval, newextra);
3843 : 44843 : *conf->variable = newval;
3844 : 44843 : set_extra_field(&conf->gen, &conf->gen.extra,
3845 : : newextra);
548 3846 : 44843 : set_guc_source(&conf->gen, source);
579 3847 : 44843 : conf->gen.scontext = context;
3848 : 44843 : conf->gen.srole = srole;
3849 : : }
3850 [ + + ]: 45714 : if (makeDefault)
3851 : : {
3852 : : GucStack *stack;
3853 : :
3854 [ + + ]: 35755 : if (conf->gen.reset_source <= source)
3855 : : {
3856 : 34924 : conf->reset_val = newval;
3857 : 34924 : set_extra_field(&conf->gen, &conf->reset_extra,
3858 : : newextra);
3859 : 34924 : conf->gen.reset_source = source;
3860 : 34924 : conf->gen.reset_scontext = context;
3861 : 34924 : conf->gen.reset_srole = srole;
3862 : : }
3863 [ - + ]: 35755 : for (stack = conf->gen.stack; stack; stack = stack->prev)
3864 : : {
579 tgl@sss.pgh.pa.us 3865 [ # # ]:UBC 0 : if (stack->source <= source)
3866 : : {
3867 : 0 : stack->prior.val.intval = newval;
3868 : 0 : set_extra_field(&conf->gen, &stack->prior.extra,
3869 : : newextra);
3870 : 0 : stack->source = source;
3871 : 0 : stack->scontext = context;
3872 : 0 : stack->srole = srole;
3873 : : }
3874 : : }
3875 : : }
3876 : :
3877 : : /* Perhaps we didn't install newextra anywhere */
579 tgl@sss.pgh.pa.us 3878 [ - + - - ]:CBC 45714 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 tgl@sss.pgh.pa.us 3879 :UBC 0 : guc_free(newextra);
579 tgl@sss.pgh.pa.us 3880 :CBC 45714 : break;
3881 : :
3882 : : #undef newval
3883 : : }
3884 : :
3885 : 4047 : case PGC_REAL:
3886 : : {
3887 : 4047 : struct config_real *conf = (struct config_real *) record;
3888 : :
3889 : : #define newval (newval_union.realval)
3890 : :
3891 [ + + ]: 4047 : if (value)
3892 : : {
3893 [ - + ]: 3976 : if (!parse_and_validate_value(record, name, value,
3894 : : source, elevel,
3895 : : &newval_union, &newextra))
579 tgl@sss.pgh.pa.us 3896 :UBC 0 : return 0;
3897 : : }
579 tgl@sss.pgh.pa.us 3898 [ - + ]:CBC 71 : else if (source == PGC_S_DEFAULT)
3899 : : {
579 tgl@sss.pgh.pa.us 3900 :UBC 0 : newval = conf->boot_val;
3901 [ # # ]: 0 : if (!call_real_check_hook(conf, &newval, &newextra,
3902 : : source, elevel))
3903 : 0 : return 0;
3904 : : }
3905 : : else
3906 : : {
579 tgl@sss.pgh.pa.us 3907 :CBC 71 : newval = conf->reset_val;
3908 : 71 : newextra = conf->reset_extra;
3909 : 71 : source = conf->gen.reset_source;
3910 : 71 : context = conf->gen.reset_scontext;
3911 : 71 : srole = conf->gen.reset_srole;
3912 : : }
3913 : :
3914 [ - + ]: 4041 : if (prohibitValueChange)
3915 : : {
3916 : : /* Release newextra, unless it's reset_extra */
579 tgl@sss.pgh.pa.us 3917 [ # # # # ]:UBC 0 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 3918 : 0 : guc_free(newextra);
3919 : :
579 3920 [ # # ]: 0 : if (*conf->variable != newval)
3921 : : {
3922 : 0 : record->status |= GUC_PENDING_RESTART;
3923 [ # # ]: 0 : ereport(elevel,
3924 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3925 : : errmsg("parameter \"%s\" cannot be changed without restarting the server",
3926 : : name)));
3927 : 0 : return 0;
3928 : : }
3929 : 0 : record->status &= ~GUC_PENDING_RESTART;
3930 : 0 : return -1;
3931 : : }
3932 : :
579 tgl@sss.pgh.pa.us 3933 [ + - ]:CBC 4041 : if (changeVal)
3934 : : {
3935 : : /* Save old value to support transaction abort */
3936 [ + - ]: 4041 : if (!makeDefault)
3937 : 4041 : push_old_value(&conf->gen, action);
3938 : :
3939 [ - + ]: 4041 : if (conf->assign_hook)
579 tgl@sss.pgh.pa.us 3940 :UBC 0 : conf->assign_hook(newval, newextra);
579 tgl@sss.pgh.pa.us 3941 :CBC 4041 : *conf->variable = newval;
3942 : 4041 : set_extra_field(&conf->gen, &conf->gen.extra,
3943 : : newextra);
548 3944 : 4041 : set_guc_source(&conf->gen, source);
579 3945 : 4041 : conf->gen.scontext = context;
3946 : 4041 : conf->gen.srole = srole;
3947 : : }
3948 [ - + ]: 4041 : if (makeDefault)
3949 : : {
3950 : : GucStack *stack;
3951 : :
579 tgl@sss.pgh.pa.us 3952 [ # # ]:UBC 0 : if (conf->gen.reset_source <= source)
3953 : : {
3954 : 0 : conf->reset_val = newval;
3955 : 0 : set_extra_field(&conf->gen, &conf->reset_extra,
3956 : : newextra);
3957 : 0 : conf->gen.reset_source = source;
3958 : 0 : conf->gen.reset_scontext = context;
3959 : 0 : conf->gen.reset_srole = srole;
3960 : : }
3961 [ # # ]: 0 : for (stack = conf->gen.stack; stack; stack = stack->prev)
3962 : : {
3963 [ # # ]: 0 : if (stack->source <= source)
3964 : : {
3965 : 0 : stack->prior.val.realval = newval;
3966 : 0 : set_extra_field(&conf->gen, &stack->prior.extra,
3967 : : newextra);
3968 : 0 : stack->source = source;
3969 : 0 : stack->scontext = context;
3970 : 0 : stack->srole = srole;
3971 : : }
3972 : : }
3973 : : }
3974 : :
3975 : : /* Perhaps we didn't install newextra anywhere */
579 tgl@sss.pgh.pa.us 3976 [ - + - - ]:CBC 4041 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 tgl@sss.pgh.pa.us 3977 :UBC 0 : guc_free(newextra);
579 tgl@sss.pgh.pa.us 3978 :CBC 4041 : break;
3979 : :
3980 : : #undef newval
3981 : : }
3982 : :
3983 : 259271 : case PGC_STRING:
3984 : : {
3985 : 259271 : struct config_string *conf = (struct config_string *) record;
3986 : :
3987 : : #define newval (newval_union.stringval)
3988 : :
3989 [ + + ]: 259271 : if (value)
3990 : : {
3991 [ - + ]: 258303 : if (!parse_and_validate_value(record, name, value,
3992 : : source, elevel,
3993 : : &newval_union, &newextra))
579 tgl@sss.pgh.pa.us 3994 :UBC 0 : return 0;
3995 : : }
579 tgl@sss.pgh.pa.us 3996 [ + + ]:CBC 968 : else if (source == PGC_S_DEFAULT)
3997 : : {
3998 : : /* non-NULL boot_val must always get strdup'd */
3999 [ + - ]: 8 : if (conf->boot_val != NULL)
4000 : : {
4001 : 8 : newval = guc_strdup(elevel, conf->boot_val);
4002 [ - + ]: 8 : if (newval == NULL)
579 tgl@sss.pgh.pa.us 4003 :UBC 0 : return 0;
4004 : : }
4005 : : else
4006 : 0 : newval = NULL;
4007 : :
579 tgl@sss.pgh.pa.us 4008 [ + + ]:CBC 8 : if (!call_string_check_hook(conf, &newval, &newextra,
4009 : : source, elevel))
4010 : : {
548 tgl@sss.pgh.pa.us 4011 :GBC 6 : guc_free(newval);
579 tgl@sss.pgh.pa.us 4012 :UBC 0 : return 0;
4013 : : }
4014 : : }
4015 : : else
4016 : : {
4017 : : /*
4018 : : * strdup not needed, since reset_val is already under
4019 : : * guc.c's control
4020 : : */
579 tgl@sss.pgh.pa.us 4021 :CBC 960 : newval = conf->reset_val;
4022 : 960 : newextra = conf->reset_extra;
4023 : 960 : source = conf->gen.reset_source;
4024 : 960 : context = conf->gen.reset_scontext;
4025 : 960 : srole = conf->gen.reset_srole;
4026 : : }
4027 : :
4028 [ + + ]: 259244 : if (prohibitValueChange)
4029 : : {
4030 : : bool newval_different;
4031 : :
4032 : : /* newval shouldn't be NULL, so we're a bit sloppy here */
4033 : 4863 : newval_different = (*conf->variable == NULL ||
4034 [ + - + - ]: 3242 : newval == NULL ||
4035 [ - + ]: 1621 : strcmp(*conf->variable, newval) != 0);
4036 : :
4037 : : /* Release newval, unless it's reset_val */
4038 [ + - + - ]: 1621 : if (newval && !string_field_used(conf, newval))
548 4039 : 1621 : guc_free(newval);
4040 : : /* Release newextra, unless it's reset_extra */
579 4041 [ - + - - ]: 1621 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 tgl@sss.pgh.pa.us 4042 :UBC 0 : guc_free(newextra);
4043 : :
579 tgl@sss.pgh.pa.us 4044 [ - + ]:CBC 1621 : if (newval_different)
4045 : : {
579 tgl@sss.pgh.pa.us 4046 :UBC 0 : record->status |= GUC_PENDING_RESTART;
4047 [ # # ]: 0 : ereport(elevel,
4048 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4049 : : errmsg("parameter \"%s\" cannot be changed without restarting the server",
4050 : : name)));
4051 : 0 : return 0;
4052 : : }
579 tgl@sss.pgh.pa.us 4053 :CBC 1621 : record->status &= ~GUC_PENDING_RESTART;
4054 : 1621 : return -1;
4055 : : }
4056 : :
4057 [ + + ]: 257623 : if (changeVal)
4058 : : {
4059 : : /* Save old value to support transaction abort */
4060 [ + + ]: 256909 : if (!makeDefault)
4061 : 141583 : push_old_value(&conf->gen, action);
4062 : :
4063 [ + + ]: 256909 : if (conf->assign_hook)
4064 : 233749 : conf->assign_hook(newval, newextra);
4065 : 256908 : set_string_field(conf, conf->variable, newval);
4066 : 256908 : set_extra_field(&conf->gen, &conf->gen.extra,
4067 : : newextra);
548 4068 : 256908 : set_guc_source(&conf->gen, source);
579 4069 : 256908 : conf->gen.scontext = context;
4070 : 256908 : conf->gen.srole = srole;
4071 : : }
4072 : :
4073 [ + + ]: 257622 : if (makeDefault)
4074 : : {
4075 : : GucStack *stack;
4076 : :
4077 [ + + ]: 115519 : if (conf->gen.reset_source <= source)
4078 : : {
4079 : 115325 : set_string_field(conf, &conf->reset_val, newval);
4080 : 115325 : set_extra_field(&conf->gen, &conf->reset_extra,
4081 : : newextra);
4082 : 115325 : conf->gen.reset_source = source;
4083 : 115325 : conf->gen.reset_scontext = context;
4084 : 115325 : conf->gen.reset_srole = srole;
4085 : : }
4086 [ - + ]: 115519 : for (stack = conf->gen.stack; stack; stack = stack->prev)
4087 : : {
579 tgl@sss.pgh.pa.us 4088 [ # # ]:UBC 0 : if (stack->source <= source)
4089 : : {
4090 : 0 : set_string_field(conf, &stack->prior.val.stringval,
4091 : : newval);
4092 : 0 : set_extra_field(&conf->gen, &stack->prior.extra,
4093 : : newextra);
4094 : 0 : stack->source = source;
4095 : 0 : stack->scontext = context;
4096 : 0 : stack->srole = srole;
4097 : : }
4098 : : }
4099 : : }
4100 : :
4101 : : /* Perhaps we didn't install newval anywhere */
579 tgl@sss.pgh.pa.us 4102 [ + + + + ]:CBC 257622 : if (newval && !string_field_used(conf, newval))
548 4103 : 704 : guc_free(newval);
4104 : : /* Perhaps we didn't install newextra anywhere */
579 4105 [ + + + + ]: 257622 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 4106 : 228 : guc_free(newextra);
579 4107 : 257622 : break;
4108 : :
4109 : : #undef newval
4110 : : }
4111 : :
4112 : 34158 : case PGC_ENUM:
4113 : : {
4114 : 34158 : struct config_enum *conf = (struct config_enum *) record;
4115 : :
4116 : : #define newval (newval_union.enumval)
4117 : :
4118 [ + + ]: 34158 : if (value)
4119 : : {
4120 [ - + ]: 33947 : if (!parse_and_validate_value(record, name, value,
4121 : : source, elevel,
4122 : : &newval_union, &newextra))
579 tgl@sss.pgh.pa.us 4123 :UBC 0 : return 0;
4124 : : }
579 tgl@sss.pgh.pa.us 4125 [ - + ]:CBC 211 : else if (source == PGC_S_DEFAULT)
4126 : : {
579 tgl@sss.pgh.pa.us 4127 :UBC 0 : newval = conf->boot_val;
4128 [ # # ]: 0 : if (!call_enum_check_hook(conf, &newval, &newextra,
4129 : : source, elevel))
4130 : 0 : return 0;
4131 : : }
4132 : : else
4133 : : {
579 tgl@sss.pgh.pa.us 4134 :CBC 211 : newval = conf->reset_val;
4135 : 211 : newextra = conf->reset_extra;
4136 : 211 : source = conf->gen.reset_source;
4137 : 211 : context = conf->gen.reset_scontext;
4138 : 211 : srole = conf->gen.reset_srole;
4139 : : }
4140 : :
4141 [ + + ]: 34142 : if (prohibitValueChange)
4142 : : {
4143 : : /* Release newextra, unless it's reset_extra */
4144 [ - + - - ]: 1678 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 tgl@sss.pgh.pa.us 4145 :UBC 0 : guc_free(newextra);
4146 : :
579 tgl@sss.pgh.pa.us 4147 [ - + ]:CBC 1678 : if (*conf->variable != newval)
4148 : : {
579 tgl@sss.pgh.pa.us 4149 :UBC 0 : record->status |= GUC_PENDING_RESTART;
4150 [ # # ]: 0 : ereport(elevel,
4151 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4152 : : errmsg("parameter \"%s\" cannot be changed without restarting the server",
4153 : : name)));
4154 : 0 : return 0;
4155 : : }
579 tgl@sss.pgh.pa.us 4156 :CBC 1678 : record->status &= ~GUC_PENDING_RESTART;
4157 : 1678 : return -1;
4158 : : }
4159 : :
4160 [ + + ]: 32464 : if (changeVal)
4161 : : {
4162 : : /* Save old value to support transaction abort */
4163 [ + + ]: 32366 : if (!makeDefault)
4164 : 9288 : push_old_value(&conf->gen, action);
4165 : :
4166 [ + + ]: 32366 : if (conf->assign_hook)
4167 : 4607 : conf->assign_hook(newval, newextra);
4168 : 32366 : *conf->variable = newval;
4169 : 32366 : set_extra_field(&conf->gen, &conf->gen.extra,
4170 : : newextra);
548 4171 : 32366 : set_guc_source(&conf->gen, source);
579 4172 : 32366 : conf->gen.scontext = context;
4173 : 32366 : conf->gen.srole = srole;
4174 : : }
4175 [ + + ]: 32464 : if (makeDefault)
4176 : : {
4177 : : GucStack *stack;
4178 : :
4179 [ + - ]: 23078 : if (conf->gen.reset_source <= source)
4180 : : {
4181 : 23078 : conf->reset_val = newval;
4182 : 23078 : set_extra_field(&conf->gen, &conf->reset_extra,
4183 : : newextra);
4184 : 23078 : conf->gen.reset_source = source;
4185 : 23078 : conf->gen.reset_scontext = context;
4186 : 23078 : conf->gen.reset_srole = srole;
4187 : : }
4188 [ - + ]: 23078 : for (stack = conf->gen.stack; stack; stack = stack->prev)
4189 : : {
579 tgl@sss.pgh.pa.us 4190 [ # # ]:UBC 0 : if (stack->source <= source)
4191 : : {
4192 : 0 : stack->prior.val.enumval = newval;
4193 : 0 : set_extra_field(&conf->gen, &stack->prior.extra,
4194 : : newextra);
4195 : 0 : stack->source = source;
4196 : 0 : stack->scontext = context;
4197 : 0 : stack->srole = srole;
4198 : : }
4199 : : }
4200 : : }
4201 : :
4202 : : /* Perhaps we didn't install newextra anywhere */
579 tgl@sss.pgh.pa.us 4203 [ - + - - ]:CBC 32464 : if (newextra && !extra_field_used(&conf->gen, newextra))
548 tgl@sss.pgh.pa.us 4204 :UBC 0 : guc_free(newextra);
579 tgl@sss.pgh.pa.us 4205 :CBC 32464 : break;
4206 : :
4207 : : #undef newval
4208 : : }
4209 : : }
4210 : :
548 4211 [ + + + + ]: 405651 : if (changeVal && (record->flags & GUC_REPORT) &&
4212 [ + + ]: 114546 : !(record->status & GUC_NEEDS_REPORT))
4213 : : {
579 4214 : 83953 : record->status |= GUC_NEEDS_REPORT;
548 4215 : 83953 : slist_push_head(&guc_report_list, &record->report_link);
4216 : : }
4217 : :
579 4218 [ + + ]: 405649 : return changeVal ? 1 : -1;
4219 : : }
4220 : :
4221 : :
4222 : : /*
4223 : : * Retrieve a config_handle for the given name, suitable for calling
4224 : : * set_config_with_handle(). Only return handle to permanent GUC.
4225 : : */
4226 : : config_handle *
128 jdavis@postgresql.or 4227 :GNC 25 : get_config_handle(const char *name)
4228 : : {
4229 : 25 : struct config_generic *gen = find_option(name, false, false, 0);
4230 : :
4231 [ + - + - ]: 25 : if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
4232 : 25 : return gen;
4233 : :
128 jdavis@postgresql.or 4234 :UNC 0 : return NULL;
4235 : : }
4236 : :
4237 : :
4238 : : /*
4239 : : * Set the fields for source file and line number the setting came from.
4240 : : */
4241 : : static void
579 tgl@sss.pgh.pa.us 4242 :CBC 65393 : set_config_sourcefile(const char *name, char *sourcefile, int sourceline)
4243 : : {
4244 : : struct config_generic *record;
4245 : : int elevel;
4246 : :
4247 : : /*
4248 : : * To avoid cluttering the log, only the postmaster bleats loudly about
4249 : : * problems with the config file.
4250 : : */
4251 [ + + ]: 65393 : elevel = IsUnderPostmaster ? DEBUG3 : LOG;
4252 : :
4253 : 65393 : record = find_option(name, true, false, elevel);
4254 : : /* should not happen */
4255 [ - + ]: 65393 : if (record == NULL)
579 tgl@sss.pgh.pa.us 4256 :UBC 0 : return;
4257 : :
579 tgl@sss.pgh.pa.us 4258 :CBC 65393 : sourcefile = guc_strdup(elevel, sourcefile);
548 4259 : 65393 : guc_free(record->sourcefile);
579 4260 : 65393 : record->sourcefile = sourcefile;
4261 : 65393 : record->sourceline = sourceline;
4262 : : }
4263 : :
4264 : : /*
4265 : : * Set a config option to the given value.
4266 : : *
4267 : : * See also set_config_option; this is just the wrapper to be called from
4268 : : * outside GUC. (This function should be used when possible, because its API
4269 : : * is more stable than set_config_option's.)
4270 : : *
4271 : : * Note: there is no support here for setting source file/line, as it
4272 : : * is currently not needed.
4273 : : */
4274 : : void
4275 : 136982 : SetConfigOption(const char *name, const char *value,
4276 : : GucContext context, GucSource source)
4277 : : {
4278 : 136982 : (void) set_config_option(name, value, context, source,
4279 : : GUC_ACTION_SET, true, 0, false);
4280 : 136958 : }
4281 : :
4282 : :
4283 : :
4284 : : /*
4285 : : * Fetch the current value of the option `name', as a string.
4286 : : *
4287 : : * If the option doesn't exist, return NULL if missing_ok is true,
4288 : : * otherwise throw an ereport and don't return.
4289 : : *
4290 : : * If restrict_privileged is true, we also enforce that only superusers and
4291 : : * members of the pg_read_all_settings role can see GUC_SUPERUSER_ONLY
4292 : : * variables. This should only be passed as true in user-driven calls.
4293 : : *
4294 : : * The string is *not* allocated for modification and is really only
4295 : : * valid until the next call to configuration related functions.
4296 : : */
4297 : : const char *
4298 : 6867 : GetConfigOption(const char *name, bool missing_ok, bool restrict_privileged)
4299 : : {
4300 : : struct config_generic *record;
4301 : : static char buffer[256];
4302 : :
4303 : 6867 : record = find_option(name, false, missing_ok, ERROR);
4304 [ + + ]: 6867 : if (record == NULL)
579 tgl@sss.pgh.pa.us 4305 :GBC 1 : return NULL;
579 tgl@sss.pgh.pa.us 4306 [ - + ]:CBC 6866 : if (restrict_privileged &&
443 tgl@sss.pgh.pa.us 4307 [ # # ]:UBC 0 : !ConfigOptionIsVisible(record))
579 4308 [ # # ]: 0 : ereport(ERROR,
4309 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4310 : : errmsg("permission denied to examine \"%s\"", name),
4311 : : errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4312 : : "pg_read_all_settings")));
4313 : :
8003 tgl@sss.pgh.pa.us 4314 [ + + - + :CBC 6866 : switch (record->vartype)
+ - ]
4315 : : {
4316 : 1123 : case PGC_BOOL:
579 4317 [ + + ]: 1123 : return *((struct config_bool *) record)->variable ? "on" : "off";
4318 : :
8003 4319 : 1426 : case PGC_INT:
579 4320 : 1426 : snprintf(buffer, sizeof(buffer), "%d",
4321 : 1426 : *((struct config_int *) record)->variable);
4322 : 1426 : return buffer;
4323 : :
8003 tgl@sss.pgh.pa.us 4324 :UBC 0 : case PGC_REAL:
579 4325 : 0 : snprintf(buffer, sizeof(buffer), "%g",
4326 : 0 : *((struct config_real *) record)->variable);
4327 : 0 : return buffer;
4328 : :
8003 tgl@sss.pgh.pa.us 4329 :CBC 2795 : case PGC_STRING:
164 tgl@sss.pgh.pa.us 4330 :GNC 2795 : return *((struct config_string *) record)->variable ?
4331 [ + - ]: 2795 : *((struct config_string *) record)->variable : "";
4332 : :
5879 magnus@hagander.net 4333 :CBC 1522 : case PGC_ENUM:
579 tgl@sss.pgh.pa.us 4334 : 1522 : return config_enum_lookup_by_value((struct config_enum *) record,
4335 : 1522 : *((struct config_enum *) record)->variable);
4336 : : }
579 tgl@sss.pgh.pa.us 4337 :UBC 0 : return NULL;
4338 : : }
4339 : :
4340 : : /*
4341 : : * Get the RESET value associated with the given option.
4342 : : *
4343 : : * Note: this is not re-entrant, due to use of static result buffer;
4344 : : * not to mention that a string variable could have its reset_val changed.
4345 : : * Beware of assuming the result value is good for very long.
4346 : : */
4347 : : const char *
4348 : 0 : GetConfigOptionResetString(const char *name)
4349 : : {
4350 : : struct config_generic *record;
4351 : : static char buffer[256];
4352 : :
4353 : 0 : record = find_option(name, false, false, ERROR);
4354 [ # # ]: 0 : Assert(record != NULL);
443 4355 [ # # ]: 0 : if (!ConfigOptionIsVisible(record))
579 4356 [ # # ]: 0 : ereport(ERROR,
4357 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4358 : : errmsg("permission denied to examine \"%s\"", name),
4359 : : errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4360 : : "pg_read_all_settings")));
4361 : :
4362 [ # # # # : 0 : switch (record->vartype)
# # ]
4363 : : {
5581 4364 : 0 : case PGC_BOOL:
579 4365 [ # # ]: 0 : return ((struct config_bool *) record)->reset_val ? "on" : "off";
4366 : :
5581 4367 : 0 : case PGC_INT:
579 4368 : 0 : snprintf(buffer, sizeof(buffer), "%d",
4369 : : ((struct config_int *) record)->reset_val);
4370 : 0 : return buffer;
4371 : :
4372 : 0 : case PGC_REAL:
4373 : 0 : snprintf(buffer, sizeof(buffer), "%g",
4374 : : ((struct config_real *) record)->reset_val);
4375 : 0 : return buffer;
4376 : :
5581 4377 : 0 : case PGC_STRING:
164 tgl@sss.pgh.pa.us 4378 :UNC 0 : return ((struct config_string *) record)->reset_val ?
4379 [ # # ]: 0 : ((struct config_string *) record)->reset_val : "";
4380 : :
5581 tgl@sss.pgh.pa.us 4381 :UBC 0 : case PGC_ENUM:
579 4382 : 0 : return config_enum_lookup_by_value((struct config_enum *) record,
4383 : : ((struct config_enum *) record)->reset_val);
4384 : : }
4385 : 0 : return NULL;
4386 : : }
4387 : :
4388 : : /*
4389 : : * Get the GUC flags associated with the given option.
4390 : : *
4391 : : * If the option doesn't exist, return 0 if missing_ok is true,
4392 : : * otherwise throw an ereport and don't return.
4393 : : */
4394 : : int
579 tgl@sss.pgh.pa.us 4395 :CBC 17 : GetConfigOptionFlags(const char *name, bool missing_ok)
4396 : : {
4397 : : struct config_generic *record;
4398 : :
4399 : 17 : record = find_option(name, false, missing_ok, ERROR);
4400 [ - + ]: 17 : if (record == NULL)
579 tgl@sss.pgh.pa.us 4401 :UBC 0 : return 0;
579 tgl@sss.pgh.pa.us 4402 :CBC 17 : return record->flags;
4403 : : }
4404 : :
4405 : :
4406 : : /*
4407 : : * Write updated configuration parameter values into a temporary file.
4408 : : * This function traverses the list of parameters and quotes the string
4409 : : * values before writing them.
4410 : : */
4411 : : static void
4412 : 59 : write_auto_conf_file(int fd, const char *filename, ConfigVariable *head)
4413 : : {
4414 : : StringInfoData buf;
4415 : : ConfigVariable *item;
4416 : :
4417 : 59 : initStringInfo(&buf);
4418 : :
4419 : : /* Emit file header containing warning comment */
4420 : 59 : appendStringInfoString(&buf, "# Do not edit this file manually!\n");
4421 : 59 : appendStringInfoString(&buf, "# It will be overwritten by the ALTER SYSTEM command.\n");
4422 : :
4423 : 59 : errno = 0;
4424 [ - + ]: 59 : if (write(fd, buf.data, buf.len) != buf.len)
4425 : : {
4426 : : /* if write didn't set errno, assume problem is no disk space */
579 tgl@sss.pgh.pa.us 4427 [ # # ]:UBC 0 : if (errno == 0)
4428 : 0 : errno = ENOSPC;
4429 [ # # ]: 0 : ereport(ERROR,
4430 : : (errcode_for_file_access(),
4431 : : errmsg("could not write to file \"%s\": %m", filename)));
4432 : : }
4433 : :
4434 : : /* Emit each parameter, properly quoting the value */
579 tgl@sss.pgh.pa.us 4435 [ + + ]:CBC 128 : for (item = head; item != NULL; item = item->next)
4436 : : {
4437 : : char *escaped;
4438 : :
4439 : 69 : resetStringInfo(&buf);
4440 : :
4441 : 69 : appendStringInfoString(&buf, item->name);
4442 : 69 : appendStringInfoString(&buf, " = '");
4443 : :
4444 : 69 : escaped = escape_single_quotes_ascii(item->value);
4445 [ - + ]: 69 : if (!escaped)
579 tgl@sss.pgh.pa.us 4446 [ # # ]:UBC 0 : ereport(ERROR,
4447 : : (errcode(ERRCODE_OUT_OF_MEMORY),
4448 : : errmsg("out of memory")));
579 tgl@sss.pgh.pa.us 4449 :CBC 69 : appendStringInfoString(&buf, escaped);
4450 : 69 : free(escaped);
4451 : :
4452 : 69 : appendStringInfoString(&buf, "'\n");
4453 : :
4454 : 69 : errno = 0;
4455 [ - + ]: 69 : if (write(fd, buf.data, buf.len) != buf.len)
4456 : : {
4457 : : /* if write didn't set errno, assume problem is no disk space */
579 tgl@sss.pgh.pa.us 4458 [ # # ]:UBC 0 : if (errno == 0)
4459 : 0 : errno = ENOSPC;
4460 [ # # ]: 0 : ereport(ERROR,
4461 : : (errcode_for_file_access(),
4462 : : errmsg("could not write to file \"%s\": %m", filename)));
4463 : : }
4464 : : }
4465 : :
4466 : : /* fsync before considering the write to be successful */
579 tgl@sss.pgh.pa.us 4467 [ - + ]:CBC 59 : if (pg_fsync(fd) != 0)
579 tgl@sss.pgh.pa.us 4468 [ # # ]:UBC 0 : ereport(ERROR,
4469 : : (errcode_for_file_access(),
4470 : : errmsg("could not fsync file \"%s\": %m", filename)));
4471 : :
579 tgl@sss.pgh.pa.us 4472 :CBC 59 : pfree(buf.data);
7653 bruce@momjian.us 4473 : 59 : }
4474 : :
4475 : : /*
4476 : : * Update the given list of configuration parameters, adding, replacing
4477 : : * or deleting the entry for item "name" (delete if "value" == NULL).
4478 : : */
4479 : : static void
579 tgl@sss.pgh.pa.us 4480 : 59 : replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p,
4481 : : const char *name, const char *value)
4482 : : {
4483 : : ConfigVariable *item,
4484 : : *next,
4485 : 59 : *prev = NULL;
4486 : :
4487 : : /*
4488 : : * Remove any existing match(es) for "name". Normally there'd be at most
4489 : : * one, but if external tools have modified the config file, there could
4490 : : * be more.
4491 : : */
4492 [ + + ]: 114 : for (item = *head_p; item != NULL; item = next)
4493 : : {
4494 : 55 : next = item->next;
4495 [ + + ]: 55 : if (guc_name_compare(item->name, name) == 0)
4496 : : {
4497 : : /* found a match, delete it */
4498 [ + + ]: 28 : if (prev)
4499 : 5 : prev->next = next;
4500 : : else
4501 : 23 : *head_p = next;
4502 [ + + ]: 28 : if (next == NULL)
4503 : 27 : *tail_p = prev;
4504 : :
4505 : 28 : pfree(item->name);
4506 : 28 : pfree(item->value);
4507 : 28 : pfree(item->filename);
4508 : 28 : pfree(item);
4509 : : }
4510 : : else
4511 : 27 : prev = item;
4512 : : }
4513 : :
4514 : : /* Done if we're trying to delete it */
4515 [ + + ]: 59 : if (value == NULL)
4516 : 17 : return;
4517 : :
4518 : : /* OK, append a new entry */
4519 : 42 : item = palloc(sizeof *item);
4520 : 42 : item->name = pstrdup(name);
4521 : 42 : item->value = pstrdup(value);
4522 : 42 : item->errmsg = NULL;
4523 : 42 : item->filename = pstrdup(""); /* new item has no location */
4524 : 42 : item->sourceline = 0;
4525 : 42 : item->ignore = false;
4526 : 42 : item->applied = false;
4527 : 42 : item->next = NULL;
4528 : :
4529 [ + + ]: 42 : if (*head_p == NULL)
4530 : 31 : *head_p = item;
4531 : : else
4532 : 11 : (*tail_p)->next = item;
4533 : 42 : *tail_p = item;
4534 : : }
4535 : :
4536 : :
4537 : : /*
4538 : : * Execute ALTER SYSTEM statement.
4539 : : *
4540 : : * Read the old PG_AUTOCONF_FILENAME file, merge in the new variable value,
4541 : : * and write out an updated file. If the command is ALTER SYSTEM RESET ALL,
4542 : : * we can skip reading the old file and just write an empty file.
4543 : : *
4544 : : * An LWLock is used to serialize updates of the configuration file.
4545 : : *
4546 : : * In case of an error, we leave the original automatic
4547 : : * configuration file (PG_AUTOCONF_FILENAME) intact.
4548 : : */
4549 : : void
4550 : 79 : AlterSystemSetConfigFile(AlterSystemStmt *altersysstmt)
4551 : : {
4552 : : char *name;
4553 : : char *value;
4554 : 79 : bool resetall = false;
4555 : 79 : ConfigVariable *head = NULL;
4556 : 79 : ConfigVariable *tail = NULL;
4557 : : volatile int Tmpfd;
4558 : : char AutoConfFileName[MAXPGPATH];
4559 : : char AutoConfTmpFileName[MAXPGPATH];
4560 : :
4561 : : /*
4562 : : * Extract statement arguments
4563 : : */
4564 : 79 : name = altersysstmt->setstmt->name;
4565 : :
16 rhaas@postgresql.org 4566 [ - + ]:GNC 79 : if (!AllowAlterSystem)
16 rhaas@postgresql.org 4567 [ # # ]:UNC 0 : ereport(ERROR,
4568 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4569 : : errmsg("ALTER SYSTEM is not allowed in this environment")));
4570 : :
579 tgl@sss.pgh.pa.us 4571 [ + + + - ]:CBC 79 : switch (altersysstmt->setstmt->kind)
4572 : : {
4573 : 55 : case VAR_SET_VALUE:
4574 : 55 : value = ExtractSetVariableArgs(altersysstmt->setstmt);
4575 : 55 : break;
4576 : :
4577 : 23 : case VAR_SET_DEFAULT:
4578 : : case VAR_RESET:
4579 : 23 : value = NULL;
4580 : 23 : break;
4581 : :
4582 : 1 : case VAR_RESET_ALL:
4583 : 1 : value = NULL;
4584 : 1 : resetall = true;
4585 : 1 : break;
4586 : :
579 tgl@sss.pgh.pa.us 4587 :UBC 0 : default:
4588 [ # # ]: 0 : elog(ERROR, "unrecognized alter system stmt type: %d",
4589 : : altersysstmt->setstmt->kind);
4590 : : break;
4591 : : }
4592 : :
4593 : : /*
4594 : : * Check permission to run ALTER SYSTEM on the target variable
4595 : : */
579 tgl@sss.pgh.pa.us 4596 [ + + ]:CBC 79 : if (!superuser())
4597 : : {
4598 [ + + ]: 23 : if (resetall)
4599 [ + - ]: 1 : ereport(ERROR,
4600 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4601 : : errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4602 : : else
4603 : : {
4604 : : AclResult aclresult;
4605 : :
4606 : 22 : aclresult = pg_parameter_aclcheck(name, GetUserId(),
4607 : : ACL_ALTER_SYSTEM);
4608 [ + + ]: 22 : if (aclresult != ACLCHECK_OK)
4609 [ + - ]: 13 : ereport(ERROR,
4610 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4611 : : errmsg("permission denied to set parameter \"%s\"",
4612 : : name)));
4613 : : }
4614 : : }
4615 : :
4616 : : /*
4617 : : * Unless it's RESET_ALL, validate the target variable and value
4618 : : */
4619 [ + - ]: 65 : if (!resetall)
4620 : : {
4621 : : struct config_generic *record;
4622 : :
4623 : : /* We don't want to create a placeholder if there's not one already */
176 tgl@sss.pgh.pa.us 4624 :GNC 65 : record = find_option(name, false, true, DEBUG5);
4625 [ + + ]: 65 : if (record != NULL)
4626 : : {
4627 : : /*
4628 : : * Don't allow parameters that can't be set in configuration files
4629 : : * to be set in PG_AUTOCONF_FILENAME file.
4630 : : */
4631 [ + + ]: 64 : if ((record->context == PGC_INTERNAL) ||
4632 [ + + ]: 62 : (record->flags & GUC_DISALLOW_IN_FILE) ||
4633 [ - + ]: 58 : (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
579 tgl@sss.pgh.pa.us 4634 [ + - ]:GBC 6 : ereport(ERROR,
4635 : : (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4636 : : errmsg("parameter \"%s\" cannot be changed",
4637 : : name)));
4638 : :
4639 : : /*
4640 : : * If a value is specified, verify that it's sane.
4641 : : */
176 tgl@sss.pgh.pa.us 4642 [ + + ]:GNC 58 : if (value)
4643 : : {
4644 : : union config_var_val newval;
4645 : 41 : void *newextra = NULL;
4646 : :
4647 [ - + ]: 41 : if (!parse_and_validate_value(record, name, value,
4648 : : PGC_S_FILE, ERROR,
4649 : : &newval, &newextra))
176 tgl@sss.pgh.pa.us 4650 [ # # ]:UNC 0 : ereport(ERROR,
4651 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4652 : : errmsg("invalid value for parameter \"%s\": \"%s\"",
4653 : : name, value)));
4654 : :
176 tgl@sss.pgh.pa.us 4655 [ + + + - ]:GNC 41 : if (record->vartype == PGC_STRING && newval.stringval != NULL)
4656 : 15 : guc_free(newval.stringval);
4657 : 41 : guc_free(newextra);
4658 : : }
4659 : : }
4660 : : else
4661 : : {
4662 : : /*
4663 : : * Variable not known; check we'd be allowed to create it. (We
4664 : : * cannot validate the value, but that's fine. A non-core GUC in
4665 : : * the config file cannot cause postmaster start to fail, so we
4666 : : * don't have to be too tense about possibly installing a bad
4667 : : * value.)
4668 : : */
4669 : 1 : (void) assignable_custom_variable_name(name, false, ERROR);
4670 : : }
4671 : :
4672 : : /*
4673 : : * We must also reject values containing newlines, because the grammar
4674 : : * for config files doesn't support embedded newlines in string
4675 : : * literals.
4676 : : */
4677 [ + + - + ]: 59 : if (value && strchr(value, '\n'))
176 tgl@sss.pgh.pa.us 4678 [ # # ]:UNC 0 : ereport(ERROR,
4679 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4680 : : errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4681 : : }
4682 : :
4683 : : /*
4684 : : * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4685 : : * the data directory, so we can reference them by simple relative paths.
4686 : : */
579 tgl@sss.pgh.pa.us 4687 :CBC 59 : snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4688 : : PG_AUTOCONF_FILENAME);
4689 : 59 : snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4690 : : AutoConfFileName,
4691 : : "tmp");
4692 : :
4693 : : /*
4694 : : * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4695 : : * time. Use AutoFileLock to ensure that. We must hold the lock while
4696 : : * reading the old file contents.
4697 : : */
4698 : 59 : LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4699 : :
4700 : : /*
4701 : : * If we're going to reset everything, then no need to open or parse the
4702 : : * old file. We'll just write out an empty list.
4703 : : */
4704 [ + - ]: 59 : if (!resetall)
4705 : : {
4706 : : struct stat st;
4707 : :
4708 [ + - ]: 59 : if (stat(AutoConfFileName, &st) == 0)
4709 : : {
4710 : : /* open old file PG_AUTOCONF_FILENAME */
4711 : : FILE *infile;
4712 : :
4713 : 59 : infile = AllocateFile(AutoConfFileName, "r");
4714 [ - + ]: 59 : if (infile == NULL)
579 tgl@sss.pgh.pa.us 4715 [ # # ]:UBC 0 : ereport(ERROR,
4716 : : (errcode_for_file_access(),
4717 : : errmsg("could not open file \"%s\": %m",
4718 : : AutoConfFileName)));
4719 : :
4720 : : /* parse it */
506 michael@paquier.xyz 4721 [ - + ]:CBC 59 : if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4722 : : LOG, &head, &tail))
579 tgl@sss.pgh.pa.us 4723 [ # # ]:UBC 0 : ereport(ERROR,
4724 : : (errcode(ERRCODE_CONFIG_FILE_ERROR),
4725 : : errmsg("could not parse contents of file \"%s\"",
4726 : : AutoConfFileName)));
4727 : :
579 tgl@sss.pgh.pa.us 4728 :CBC 59 : FreeFile(infile);
4729 : : }
4730 : :
4731 : : /*
4732 : : * Now, replace any existing entry with the new value, or add it if
4733 : : * not present.
4734 : : */
4735 : 59 : replace_auto_config_value(&head, &tail, name, value);
4736 : : }
4737 : :
4738 : : /*
4739 : : * Invoke the post-alter hook for setting this GUC variable. GUCs
4740 : : * typically do not have corresponding entries in pg_parameter_acl, so we
4741 : : * call the hook using the name rather than a potentially-non-existent
4742 : : * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4743 : : * context can be distinguished from others. (Note that "name" will be
4744 : : * NULL in the RESET ALL case.)
4745 : : *
4746 : : * We do this here rather than at the end, because ALTER SYSTEM is not
4747 : : * transactional. If the hook aborts our transaction, it will be cleaner
4748 : : * to do so before we touch any files.
4749 : : */
4750 [ + + ]: 59 : InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4751 : : ACL_ALTER_SYSTEM,
4752 : : altersysstmt->setstmt->kind,
4753 : : false);
4754 : :
4755 : : /*
4756 : : * To ensure crash safety, first write the new file data to a temp file,
4757 : : * then atomically rename it into place.
4758 : : *
4759 : : * If there is a temp file left over due to a previous crash, it's okay to
4760 : : * truncate and reuse it.
4761 : : */
4762 : 59 : Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4763 : : O_CREAT | O_RDWR | O_TRUNC);
4764 [ - + ]: 59 : if (Tmpfd < 0)
579 tgl@sss.pgh.pa.us 4765 [ # # ]:UBC 0 : ereport(ERROR,
4766 : : (errcode_for_file_access(),
4767 : : errmsg("could not open file \"%s\": %m",
4768 : : AutoConfTmpFileName)));
4769 : :
4770 : : /*
4771 : : * Use a TRY block to clean up the file if we fail. Since we need a TRY
4772 : : * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4773 : : */
579 tgl@sss.pgh.pa.us 4774 [ + - ]:CBC 59 : PG_TRY();
4775 : : {
4776 : : /* Write and sync the new contents to the temporary file */
4777 : 59 : write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4778 : :
4779 : : /* Close before renaming; may be required on some platforms */
4780 : 59 : close(Tmpfd);
4781 : 59 : Tmpfd = -1;
4782 : :
4783 : : /*
4784 : : * As the rename is atomic operation, if any problem occurs after this
4785 : : * at worst it can lose the parameters set by last ALTER SYSTEM
4786 : : * command.
4787 : : */
4788 : 59 : durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4789 : : }
579 tgl@sss.pgh.pa.us 4790 :UBC 0 : PG_CATCH();
4791 : : {
4792 : : /* Close file first, else unlink might fail on some platforms */
4793 [ # # ]: 0 : if (Tmpfd >= 0)
4794 : 0 : close(Tmpfd);
4795 : :
4796 : : /* Unlink, but ignore any error */
4797 : 0 : (void) unlink(AutoConfTmpFileName);
4798 : :
4799 : 0 : PG_RE_THROW();
4800 : : }
579 tgl@sss.pgh.pa.us 4801 [ - + ]:CBC 59 : PG_END_TRY();
4802 : :
4803 : 59 : FreeConfigVariables(head);
4804 : :
4805 : 59 : LWLockRelease(AutoFileLock);
3429 rhaas@postgresql.org 4806 : 59 : }
4807 : :
4808 : :
4809 : : /*
4810 : : * Common code for DefineCustomXXXVariable subroutines: allocate the
4811 : : * new variable's config struct and fill in generic fields.
4812 : : */
4813 : : static struct config_generic *
579 tgl@sss.pgh.pa.us 4814 : 10109 : init_custom_variable(const char *name,
4815 : : const char *short_desc,
4816 : : const char *long_desc,
4817 : : GucContext context,
4818 : : int flags,
4819 : : enum config_type type,
4820 : : size_t sz)
4821 : : {
4822 : : struct config_generic *gen;
4823 : :
4824 : : /*
4825 : : * Only allow custom PGC_POSTMASTER variables to be created during shared
4826 : : * library preload; any later than that, we can't ensure that the value
4827 : : * doesn't change after startup. This is a fatal elog if it happens; just
4828 : : * erroring out isn't safe because we don't know what the calling loadable
4829 : : * module might already have hooked into.
4830 : : */
4831 [ + + ]: 10109 : if (context == PGC_POSTMASTER &&
4832 [ - + ]: 9 : !process_shared_preload_libraries_in_progress)
579 tgl@sss.pgh.pa.us 4833 [ # # ]:UBC 0 : elog(FATAL, "cannot create PGC_POSTMASTER variables after startup");
4834 : :
4835 : : /*
4836 : : * We can't support custom GUC_LIST_QUOTE variables, because the wrong
4837 : : * things would happen if such a variable were set or pg_dump'd when the
4838 : : * defining extension isn't loaded. Again, treat this as fatal because
4839 : : * the loadable module may be partly initialized already.
4840 : : */
579 tgl@sss.pgh.pa.us 4841 [ - + ]:CBC 10109 : if (flags & GUC_LIST_QUOTE)
579 tgl@sss.pgh.pa.us 4842 [ # # ]:UBC 0 : elog(FATAL, "extensions cannot define GUC_LIST_QUOTE variables");
4843 : :
4844 : : /*
4845 : : * Before pljava commit 398f3b876ed402bdaec8bc804f29e2be95c75139
4846 : : * (2015-12-15), two of that module's PGC_USERSET variables facilitated
4847 : : * trivial escalation to superuser privileges. Restrict the variables to
4848 : : * protect sites that have yet to upgrade pljava.
4849 : : */
579 tgl@sss.pgh.pa.us 4850 [ + + ]:CBC 10109 : if (context == PGC_USERSET &&
4851 [ + - ]: 7848 : (strcmp(name, "pljava.classpath") == 0 ||
4852 [ - + ]: 7848 : strcmp(name, "pljava.vmoptions") == 0))
579 tgl@sss.pgh.pa.us 4853 :UBC 0 : context = PGC_SUSET;
4854 : :
579 tgl@sss.pgh.pa.us 4855 :CBC 10109 : gen = (struct config_generic *) guc_malloc(ERROR, sz);
4856 : 10109 : memset(gen, 0, sz);
4857 : :
4858 : 10109 : gen->name = guc_strdup(ERROR, name);
4859 : 10109 : gen->context = context;
4860 : 10109 : gen->group = CUSTOM_OPTIONS;
4861 : 10109 : gen->short_desc = short_desc;
4862 : 10109 : gen->long_desc = long_desc;
4863 : 10109 : gen->flags = flags;
4864 : 10109 : gen->vartype = type;
4865 : :
4866 : 10109 : return gen;
4867 : : }
4868 : :
4869 : : /*
4870 : : * Common code for DefineCustomXXXVariable subroutines: insert the new
4871 : : * variable into the GUC variable hash, replacing any placeholder.
4872 : : */
4873 : : static void
4874 : 10109 : define_custom_variable(struct config_generic *variable)
4875 : : {
4876 : 10109 : const char *name = variable->name;
4877 : : GUCHashEntry *hentry;
4878 : : struct config_string *pHolder;
4879 : :
4880 : : /* Check mapping between initial and default value */
531 michael@paquier.xyz 4881 [ - + ]: 10109 : Assert(check_GUC_init(variable));
4882 : :
4883 : : /*
4884 : : * See if there's a placeholder by the same name.
4885 : : */
548 tgl@sss.pgh.pa.us 4886 : 10109 : hentry = (GUCHashEntry *) hash_search(guc_hashtab,
4887 : : &name,
4888 : : HASH_FIND,
4889 : : NULL);
4890 [ + + ]: 10109 : if (hentry == NULL)
4891 : : {
4892 : : /*
4893 : : * No placeholder to replace, so we can just add it ... but first,
4894 : : * make sure it's initialized to its default value.
4895 : : */
579 4896 : 10061 : InitializeOneGUCOption(variable);
4897 : 10061 : add_guc_variable(variable, ERROR);
4898 : 10061 : return;
4899 : : }
4900 : :
4901 : : /*
4902 : : * This better be a placeholder
4903 : : */
548 4904 [ - + ]: 48 : if ((hentry->gucvar->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
579 tgl@sss.pgh.pa.us 4905 [ # # ]:UBC 0 : ereport(ERROR,
4906 : : (errcode(ERRCODE_INTERNAL_ERROR),
4907 : : errmsg("attempt to redefine parameter \"%s\"", name)));
4908 : :
548 tgl@sss.pgh.pa.us 4909 [ - + ]:CBC 48 : Assert(hentry->gucvar->vartype == PGC_STRING);
4910 : 48 : pHolder = (struct config_string *) hentry->gucvar;
4911 : :
4912 : : /*
4913 : : * First, set the variable to its default value. We must do this even
4914 : : * though we intend to immediately apply a new value, since it's possible
4915 : : * that the new value is invalid.
4916 : : */
579 4917 : 48 : InitializeOneGUCOption(variable);
4918 : :
4919 : : /*
4920 : : * Replace the placeholder in the hash table. We aren't changing the name
4921 : : * (at least up to case-folding), so the hash value is unchanged.
4922 : : */
548 4923 : 48 : hentry->gucname = name;
4924 : 48 : hentry->gucvar = variable;
4925 : :
4926 : : /*
4927 : : * Remove the placeholder from any lists it's in, too.
4928 : : */
4929 : 48 : RemoveGUCFromLists(&pHolder->gen);
4930 : :
4931 : : /*
4932 : : * Assign the string value(s) stored in the placeholder to the real
4933 : : * variable. Essentially, we need to duplicate all the active and stacked
4934 : : * values, but with appropriate validation and datatype adjustment.
4935 : : *
4936 : : * If an assignment fails, we report a WARNING and keep going. We don't
4937 : : * want to throw ERROR for bad values, because it'd bollix the add-on
4938 : : * module that's presumably halfway through getting loaded. In such cases
4939 : : * the default or previous state will become active instead.
4940 : : */
4941 : :
4942 : : /* First, apply the reset value if any */
579 4943 [ + + ]: 48 : if (pHolder->reset_val)
4944 : 45 : (void) set_config_option_ext(name, pHolder->reset_val,
4945 : : pHolder->gen.reset_scontext,
4946 : : pHolder->gen.reset_source,
4947 : : pHolder->gen.reset_srole,
4948 : : GUC_ACTION_SET, true, WARNING, false);
4949 : : /* That should not have resulted in stacking anything */
4950 [ - + ]: 48 : Assert(variable->stack == NULL);
4951 : :
4952 : : /* Now, apply current and stacked values, in the order they were stacked */
4953 : 48 : reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
4954 : 48 : *(pHolder->variable),
4955 : : pHolder->gen.scontext, pHolder->gen.source,
4956 : : pHolder->gen.srole);
4957 : :
4958 : : /* Also copy over any saved source-location information */
4959 [ + + ]: 48 : if (pHolder->gen.sourcefile)
4960 : 37 : set_config_sourcefile(name, pHolder->gen.sourcefile,
4961 : : pHolder->gen.sourceline);
4962 : :
4963 : : /*
4964 : : * Free up as much as we conveniently can of the placeholder structure.
4965 : : * (This neglects any stack items, so it's possible for some memory to be
4966 : : * leaked. Since this can only happen once per session per variable, it
4967 : : * doesn't seem worth spending much code on.)
4968 : : */
4969 : 48 : set_string_field(pHolder, pHolder->variable, NULL);
4970 : 48 : set_string_field(pHolder, &pHolder->reset_val, NULL);
4971 : :
548 4972 : 48 : guc_free(pHolder);
4973 : : }
4974 : :
4975 : : /*
4976 : : * Recursive subroutine for define_custom_variable: reapply non-reset values
4977 : : *
4978 : : * We recurse so that the values are applied in the same order as originally.
4979 : : * At each recursion level, apply the upper-level value (passed in) in the
4980 : : * fashion implied by the stack entry.
4981 : : */
4982 : : static void
579 4983 : 48 : reapply_stacked_values(struct config_generic *variable,
4984 : : struct config_string *pHolder,
4985 : : GucStack *stack,
4986 : : const char *curvalue,
4987 : : GucContext curscontext, GucSource cursource,
4988 : : Oid cursrole)
4989 : : {
4990 : 48 : const char *name = variable->name;
4991 : 48 : GucStack *oldvarstack = variable->stack;
4992 : :
4993 [ - + ]: 48 : if (stack != NULL)
4994 : : {
4995 : : /* First, recurse, so that stack items are processed bottom to top */
579 tgl@sss.pgh.pa.us 4996 :UBC 0 : reapply_stacked_values(variable, pHolder, stack->prev,
4997 : 0 : stack->prior.val.stringval,
4998 : : stack->scontext, stack->source, stack->srole);
4999 : :
5000 : : /* See how to apply the passed-in value */
5001 [ # # # # : 0 : switch (stack->state)
# ]
5002 : : {
5003 : 0 : case GUC_SAVE:
5004 : 0 : (void) set_config_option_ext(name, curvalue,
5005 : : curscontext, cursource, cursrole,
5006 : : GUC_ACTION_SAVE, true,
5007 : : WARNING, false);
5008 : 0 : break;
5009 : :
5010 : 0 : case GUC_SET:
5011 : 0 : (void) set_config_option_ext(name, curvalue,
5012 : : curscontext, cursource, cursrole,
5013 : : GUC_ACTION_SET, true,
5014 : : WARNING, false);
5015 : 0 : break;
5016 : :
5017 : 0 : case GUC_LOCAL:
5018 : 0 : (void) set_config_option_ext(name, curvalue,
5019 : : curscontext, cursource, cursrole,
5020 : : GUC_ACTION_LOCAL, true,
5021 : : WARNING, false);
5022 : 0 : break;
5023 : :
5024 : 0 : case GUC_SET_LOCAL:
5025 : : /* first, apply the masked value as SET */
5026 : 0 : (void) set_config_option_ext(name, stack->masked.val.stringval,
5027 : : stack->masked_scontext,
5028 : : PGC_S_SESSION,
5029 : : stack->masked_srole,
5030 : : GUC_ACTION_SET, true,
5031 : : WARNING, false);
5032 : : /* then apply the current value as LOCAL */
5033 : 0 : (void) set_config_option_ext(name, curvalue,
5034 : : curscontext, cursource, cursrole,
5035 : : GUC_ACTION_LOCAL, true,
5036 : : WARNING, false);
5037 : 0 : break;
5038 : : }
5039 : :
5040 : : /* If we successfully made a stack entry, adjust its nest level */
5041 [ # # ]: 0 : if (variable->stack != oldvarstack)
5042 : 0 : variable->stack->nest_level = stack->nest_level;
5043 : : }
5044 : : else
5045 : : {
5046 : : /*
5047 : : * We are at the end of the stack. If the active/previous value is
5048 : : * different from the reset value, it must represent a previously
5049 : : * committed session value. Apply it, and then drop the stack entry
5050 : : * that set_config_option will have created under the impression that
5051 : : * this is to be just a transactional assignment. (We leak the stack
5052 : : * entry.)
5053 : : */
579 tgl@sss.pgh.pa.us 5054 [ + + ]:CBC 48 : if (curvalue != pHolder->reset_val ||
5055 [ + - ]: 45 : curscontext != pHolder->gen.reset_scontext ||
5056 [ + - ]: 45 : cursource != pHolder->gen.reset_source ||
5057 [ - + ]: 45 : cursrole != pHolder->gen.reset_srole)
5058 : : {
5059 : 3 : (void) set_config_option_ext(name, curvalue,
5060 : : curscontext, cursource, cursrole,
5061 : : GUC_ACTION_SET, true, WARNING, false);
548 5062 [ + + ]: 3 : if (variable->stack != NULL)
5063 : : {
5064 : 2 : slist_delete(&guc_stack_list, &variable->stack_link);
5065 : 2 : variable->stack = NULL;
5066 : : }
5067 : : }
5068 : : }
3429 rhaas@postgresql.org 5069 : 48 : }
5070 : :
5071 : : /*
5072 : : * Functions for extensions to call to define their custom GUC variables.
5073 : : */
5074 : : void
579 tgl@sss.pgh.pa.us 5075 : 4055 : DefineCustomBoolVariable(const char *name,
5076 : : const char *short_desc,
5077 : : const char *long_desc,
5078 : : bool *valueAddr,
5079 : : bool bootValue,
5080 : : GucContext context,
5081 : : int flags,
5082 : : GucBoolCheckHook check_hook,
5083 : : GucBoolAssignHook assign_hook,
5084 : : GucShowHook show_hook)
5085 : : {
5086 : : struct config_bool *var;
5087 : :
5088 : : var = (struct config_bool *)
5089 : 4055 : init_custom_variable(name, short_desc, long_desc, context, flags,
5090 : : PGC_BOOL, sizeof(struct config_bool));
5091 : 4055 : var->variable = valueAddr;
5092 : 4055 : var->boot_val = bootValue;
5093 : 4055 : var->reset_val = bootValue;
5094 : 4055 : var->check_hook = check_hook;
5095 : 4055 : var->assign_hook = assign_hook;
5096 : 4055 : var->show_hook = show_hook;
5097 : 4055 : define_custom_variable(&var->gen);
3429 rhaas@postgresql.org 5098 : 4055 : }
5099 : :
5100 : : void
579 tgl@sss.pgh.pa.us 5101 : 43 : DefineCustomIntVariable(const char *name,
5102 : : const char *short_desc,
5103 : : const char *long_desc,
5104 : : int *valueAddr,
5105 : : int bootValue,
5106 : : int minValue,
5107 : : int maxValue,
5108 : : GucContext context,
5109 : : int flags,
5110 : : GucIntCheckHook check_hook,
5111 : : GucIntAssignHook assign_hook,
5112 : : GucShowHook show_hook)
5113 : : {
5114 : : struct config_int *var;
5115 : :
5116 : : var = (struct config_int *)
5117 : 43 : init_custom_variable(name, short_desc, long_desc, context, flags,
5118 : : PGC_INT, sizeof(struct config_int));
5119 : 43 : var->variable = valueAddr;
5120 : 43 : var->boot_val = bootValue;
5121 : 43 : var->reset_val = bootValue;
5122 : 43 : var->min = minValue;
5123 : 43 : var->max = maxValue;
5124 : 43 : var->check_hook = check_hook;
5125 : 43 : var->assign_hook = assign_hook;
5126 : 43 : var->show_hook = show_hook;
5127 : 43 : define_custom_variable(&var->gen);
5128 : 43 : }
5129 : :
5130 : : void
5131 : 21 : DefineCustomRealVariable(const char *name,
5132 : : const char *short_desc,
5133 : : const char *long_desc,
5134 : : double *valueAddr,
5135 : : double bootValue,
5136 : : double minValue,
5137 : : double maxValue,
5138 : : GucContext context,
5139 : : int flags,
5140 : : GucRealCheckHook check_hook,
5141 : : GucRealAssignHook assign_hook,
5142 : : GucShowHook show_hook)
5143 : : {
5144 : : struct config_real *var;
5145 : :
5146 : : var = (struct config_real *)
5147 : 21 : init_custom_variable(name, short_desc, long_desc, context, flags,
5148 : : PGC_REAL, sizeof(struct config_real));
5149 : 21 : var->variable = valueAddr;
5150 : 21 : var->boot_val = bootValue;
5151 : 21 : var->reset_val = bootValue;
5152 : 21 : var->min = minValue;
5153 : 21 : var->max = maxValue;
5154 : 21 : var->check_hook = check_hook;
5155 : 21 : var->assign_hook = assign_hook;
5156 : 21 : var->show_hook = show_hook;
5157 : 21 : define_custom_variable(&var->gen);
5158 : 21 : }
5159 : :
5160 : : void
5161 : 4011 : DefineCustomStringVariable(const char *name,
5162 : : const char *short_desc,
5163 : : const char *long_desc,
5164 : : char **valueAddr,
5165 : : const char *bootValue,
5166 : : GucContext context,
5167 : : int flags,
5168 : : GucStringCheckHook check_hook,
5169 : : GucStringAssignHook assign_hook,
5170 : : GucShowHook show_hook)
5171 : : {
5172 : : struct config_string *var;
5173 : :
5174 : : var = (struct config_string *)
5175 : 4011 : init_custom_variable(name, short_desc, long_desc, context, flags,
5176 : : PGC_STRING, sizeof(struct config_string));
5177 : 4011 : var->variable = valueAddr;
5178 : 4011 : var->boot_val = bootValue;
5179 : 4011 : var->check_hook = check_hook;
5180 : 4011 : var->assign_hook = assign_hook;
5181 : 4011 : var->show_hook = show_hook;
5182 : 4011 : define_custom_variable(&var->gen);
3429 rhaas@postgresql.org 5183 : 4011 : }
5184 : :
5185 : : void
579 tgl@sss.pgh.pa.us 5186 : 1979 : DefineCustomEnumVariable(const char *name,
5187 : : const char *short_desc,
5188 : : const char *long_desc,
5189 : : int *valueAddr,
5190 : : int bootValue,
5191 : : const struct config_enum_entry *options,
5192 : : GucContext context,
5193 : : int flags,
5194 : : GucEnumCheckHook check_hook,
5195 : : GucEnumAssignHook assign_hook,
5196 : : GucShowHook show_hook)
5197 : : {
5198 : : struct config_enum *var;
5199 : :
5200 : : var = (struct config_enum *)
5201 : 1979 : init_custom_variable(name, short_desc, long_desc, context, flags,
5202 : : PGC_ENUM, sizeof(struct config_enum));
5203 : 1979 : var->variable = valueAddr;
5204 : 1979 : var->boot_val = bootValue;
5205 : 1979 : var->reset_val = bootValue;
5206 : 1979 : var->options = options;
5207 : 1979 : var->check_hook = check_hook;
5208 : 1979 : var->assign_hook = assign_hook;
5209 : 1979 : var->show_hook = show_hook;
5210 : 1979 : define_custom_variable(&var->gen);
3429 rhaas@postgresql.org 5211 : 1979 : }
5212 : :
5213 : : /*
5214 : : * Mark the given GUC prefix as "reserved".
5215 : : *
5216 : : * This deletes any existing placeholders matching the prefix,
5217 : : * and then prevents new ones from being created.
5218 : : * Extensions should call this after they've defined all of their custom
5219 : : * GUCs, to help catch misspelled config-file entries.
5220 : : */
5221 : : void
579 tgl@sss.pgh.pa.us 5222 : 2037 : MarkGUCPrefixReserved(const char *className)
5223 : : {
5224 : 2037 : int classLen = strlen(className);
5225 : : HASH_SEQ_STATUS status;
5226 : : GUCHashEntry *hentry;
5227 : : MemoryContext oldcontext;
5228 : :
5229 : : /*
5230 : : * Check for existing placeholders. We must actually remove invalid
5231 : : * placeholders, else future parallel worker startups will fail. (We
5232 : : * don't bother trying to free associated memory, since this shouldn't
5233 : : * happen often.)
5234 : : */
548 5235 : 2037 : hash_seq_init(&status, guc_hashtab);
5236 [ + + ]: 796683 : while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5237 : : {
5238 : 794646 : struct config_generic *var = hentry->gucvar;
5239 : :
579 5240 [ + + ]: 794646 : if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5241 [ + + ]: 12 : strncmp(className, var->name, classLen) == 0 &&
5242 [ + - ]: 3 : var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5243 : : {
5244 [ + - ]: 3 : ereport(WARNING,
5245 : : (errcode(ERRCODE_INVALID_NAME),
5246 : : errmsg("invalid configuration parameter name \"%s\", removing it",
5247 : : var->name),
5248 : : errdetail("\"%s\" is now a reserved prefix.",
5249 : : className)));
5250 : : /* Remove it from the hash table */
548 5251 : 3 : hash_search(guc_hashtab,
5252 : 3 : &var->name,
5253 : : HASH_REMOVE,
5254 : : NULL);
5255 : : /* Remove it from any lists it's in, too */
5256 : 3 : RemoveGUCFromLists(var);
5257 : : }
5258 : : }
5259 : :
5260 : : /* And remember the name so we can prevent future mistakes. */
5261 : 2037 : oldcontext = MemoryContextSwitchTo(GUCMemoryContext);
579 5262 : 2037 : reserved_class_prefix = lappend(reserved_class_prefix, pstrdup(className));
5263 : 2037 : MemoryContextSwitchTo(oldcontext);
1641 tmunro@postgresql.or 5264 : 2037 : }
5265 : :
5266 : :
5267 : : /*
5268 : : * Return an array of modified GUC options to show in EXPLAIN.
5269 : : *
5270 : : * We only report options related to query planning (marked with GUC_EXPLAIN),
5271 : : * with values different from their built-in defaults.
5272 : : */
5273 : : struct config_generic **
579 tgl@sss.pgh.pa.us 5274 : 6 : get_explain_guc_options(int *num)
5275 : : {
5276 : : struct config_generic **result;
5277 : : dlist_iter iter;
5278 : :
5279 : 6 : *num = 0;
5280 : :
5281 : : /*
5282 : : * While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
5283 : : * it doesn't seem worth dynamically resizing this array.
5284 : : */
548 5285 : 6 : result = palloc(sizeof(struct config_generic *) * hash_get_num_entries(guc_hashtab));
5286 : :
5287 : : /* We need only consider GUCs with source not PGC_S_DEFAULT */
5288 [ + - + + ]: 338 : dlist_foreach(iter, &guc_nondef_list)
5289 : : {
5290 : 332 : struct config_generic *conf = dlist_container(struct config_generic,
5291 : : nondef_link, iter.cur);
5292 : : bool modified;
5293 : :
5294 : : /* return only parameters marked for inclusion in explain */
579 5295 [ + + ]: 332 : if (!(conf->flags & GUC_EXPLAIN))
1122 5296 : 320 : continue;
5297 : :
5298 : : /* return only options visible to the current user */
443 5299 [ - + ]: 12 : if (!ConfigOptionIsVisible(conf))
579 tgl@sss.pgh.pa.us 5300 :UBC 0 : continue;
5301 : :
5302 : : /* return only options that are different from their boot values */
579 tgl@sss.pgh.pa.us 5303 :CBC 12 : modified = false;
5304 : :
5305 [ + - - - : 12 : switch (conf->vartype)
+ - ]
5306 : : {
1122 5307 : 6 : case PGC_BOOL:
5308 : : {
579 5309 : 6 : struct config_bool *lconf = (struct config_bool *) conf;
5310 : :
5311 : 6 : modified = (lconf->boot_val != *(lconf->variable));
5312 : : }
5313 : 6 : break;
5314 : :
1122 tgl@sss.pgh.pa.us 5315 :UBC 0 : case PGC_INT:
5316 : : {
579 5317 : 0 : struct config_int *lconf = (struct config_int *) conf;
5318 : :
5319 : 0 : modified = (lconf->boot_val != *(lconf->variable));
5320 : : }
5321 : 0 : break;
5322 : :
1122 5323 : 0 : case PGC_REAL:
5324 : : {
579 5325 : 0 : struct config_real *lconf = (struct config_real *) conf;
5326 : :
5327 : 0 : modified = (lconf->boot_val != *(lconf->variable));
5328 : : }
5329 : 0 : break;
5330 : :
1122 5331 : 0 : case PGC_STRING:
5332 : : {
579 5333 : 0 : struct config_string *lconf = (struct config_string *) conf;
5334 : :
164 5335 [ # # ]: 0 : if (lconf->boot_val == NULL &&
5336 [ # # ]: 0 : *lconf->variable == NULL)
5337 : 0 : modified = false;
5338 [ # # ]: 0 : else if (lconf->boot_val == NULL ||
5339 [ # # ]: 0 : *lconf->variable == NULL)
5340 : 0 : modified = true;
5341 : : else
5342 : 0 : modified = (strcmp(lconf->boot_val, *(lconf->variable)) != 0);
5343 : : }
579 5344 : 0 : break;
5345 : :
1122 tgl@sss.pgh.pa.us 5346 :CBC 6 : case PGC_ENUM:
5347 : : {
579 5348 : 6 : struct config_enum *lconf = (struct config_enum *) conf;
5349 : :
5350 : 6 : modified = (lconf->boot_val != *(lconf->variable));
5351 : : }
5352 : 6 : break;
5353 : :
579 tgl@sss.pgh.pa.us 5354 :UBC 0 : default:
5355 [ # # ]: 0 : elog(ERROR, "unexpected GUC type: %d", conf->vartype);
5356 : : }
5357 : :
579 tgl@sss.pgh.pa.us 5358 [ - + ]:CBC 12 : if (!modified)
579 tgl@sss.pgh.pa.us 5359 :UBC 0 : continue;
5360 : :
5361 : : /* OK, report it */
579 tgl@sss.pgh.pa.us 5362 :CBC 12 : result[*num] = conf;
5363 : 12 : *num = *num + 1;
5364 : : }
5365 : :
5366 : 6 : return result;
5367 : : }
5368 : :
5369 : : /*
5370 : : * Return GUC variable value by name; optionally return canonical form of
5371 : : * name. If the GUC is unset, then throw an error unless missing_ok is true,
5372 : : * in which case return NULL. Return value is palloc'd (but *varname isn't).
5373 : : */
5374 : : char *
5375 : 4559 : GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
5376 : : {
5377 : : struct config_generic *record;
5378 : :
5379 : 4559 : record = find_option(name, false, missing_ok, ERROR);
5380 [ + + ]: 4540 : if (record == NULL)
5381 : : {
5382 [ - + ]: 3 : if (varname)
579 tgl@sss.pgh.pa.us 5383 :UBC 0 : *varname = NULL;
579 tgl@sss.pgh.pa.us 5384 :CBC 3 : return NULL;
5385 : : }
5386 : :
443 5387 [ + + ]: 4537 : if (!ConfigOptionIsVisible(record))
579 5388 [ + - ]: 1 : ereport(ERROR,
5389 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
5390 : : errmsg("permission denied to examine \"%s\"", name),
5391 : : errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
5392 : : "pg_read_all_settings")));
5393 : :
5394 [ + + ]: 4536 : if (varname)
5395 : 1302 : *varname = record->name;
5396 : :
5397 : 4536 : return ShowGUCOption(record, true);
5398 : : }
5399 : :
5400 : : /*
5401 : : * ShowGUCOption: get string value of variable
5402 : : *
5403 : : * We express a numeric value in appropriate units if it has units and
5404 : : * use_units is true; else you just get the raw number.
5405 : : * The result string is palloc'd.
5406 : : */
5407 : : char *
5408 : 972742 : ShowGUCOption(struct config_generic *record, bool use_units)
5409 : : {
5410 : : char buffer[256];
5411 : : const char *val;
5412 : :
5413 [ + + + + : 972742 : switch (record->vartype)
+ - ]
5414 : : {
5415 : 282437 : case PGC_BOOL:
5416 : : {
5417 : 282437 : struct config_bool *conf = (struct config_bool *) record;
5418 : :
5419 [ + + ]: 282437 : if (conf->show_hook)
5420 : 13522 : val = conf->show_hook();
5421 : : else
5422 [ + + ]: 268915 : val = *conf->variable ? "on" : "off";
5423 : : }
5424 : 282437 : break;
5425 : :
5426 : 273245 : case PGC_INT:
5427 : : {
5428 : 273245 : struct config_int *conf = (struct config_int *) record;
5429 : :
5430 [ + + ]: 273245 : if (conf->show_hook)
5431 : 13605 : val = conf->show_hook();
5432 : : else
5433 : : {
5434 : : /*
5435 : : * Use int64 arithmetic to avoid overflows in units
5436 : : * conversion.
5437 : : */
5438 : 259640 : int64 result = *conf->variable;
5439 : : const char *unit;
5440 : :
5441 [ + + + + : 259640 : if (use_units && result > 0 && (record->flags & GUC_UNIT))
+ + ]
5442 : 342 : convert_int_from_base_unit(result,
5443 : 342 : record->flags & GUC_UNIT,
5444 : : &result, &unit);
5445 : : else
5446 : 259298 : unit = "";
5447 : :
5448 : 259640 : snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
5449 : : result, unit);
5450 : 259640 : val = buffer;
5451 : : }
5452 : : }
5453 : 273245 : break;
5454 : :
5455 : 45594 : case PGC_REAL:
5456 : : {
5457 : 45594 : struct config_real *conf = (struct config_real *) record;
5458 : :
5459 [ - + ]: 45594 : if (conf->show_hook)
579 tgl@sss.pgh.pa.us 5460 :UBC 0 : val = conf->show_hook();
5461 : : else
5462 : : {
579 tgl@sss.pgh.pa.us 5463 :CBC 45594 : double result = *conf->variable;
5464 : : const char *unit;
5465 : :
5466 [ + + + + : 45594 : if (use_units && result > 0 && (record->flags & GUC_UNIT))
+ + ]
5467 : 134 : convert_real_from_base_unit(result,
5468 : 134 : record->flags & GUC_UNIT,
5469 : : &result, &unit);
5470 : : else
5471 : 45460 : unit = "";
5472 : :
5473 : 45594 : snprintf(buffer, sizeof(buffer), "%g%s",
5474 : : result, unit);
5475 : 45594 : val = buffer;
5476 : : }
5477 : : }
5478 : 45594 : break;
5479 : :
5480 : 283025 : case PGC_STRING:
5481 : : {
5482 : 283025 : struct config_string *conf = (struct config_string *) record;
5483 : :
5484 [ + + ]: 283025 : if (conf->show_hook)
5485 : 28216 : val = conf->show_hook();
5486 [ + + + + ]: 254809 : else if (*conf->variable && **conf->variable)
5487 : 194154 : val = *conf->variable;
5488 : : else
5489 : 60655 : val = "";
5490 : : }
5491 : 283025 : break;
5492 : :
5493 : 88441 : case PGC_ENUM:
5494 : : {
5495 : 88441 : struct config_enum *conf = (struct config_enum *) record;
5496 : :
5497 [ - + ]: 88441 : if (conf->show_hook)
579 tgl@sss.pgh.pa.us 5498 :UBC 0 : val = conf->show_hook();
5499 : : else
579 tgl@sss.pgh.pa.us 5500 :CBC 88441 : val = config_enum_lookup_by_value(conf, *conf->variable);
5501 : : }
5502 : 88441 : break;
5503 : :
579 tgl@sss.pgh.pa.us 5504 :UBC 0 : default:
5505 : : /* just to keep compiler quiet */
5506 : 0 : val = "???";
5507 : 0 : break;
5508 : : }
5509 : :
579 tgl@sss.pgh.pa.us 5510 :CBC 972742 : return pstrdup(val);
5511 : : }
5512 : :
5513 : :
5514 : : #ifdef EXEC_BACKEND
5515 : :
5516 : : /*
5517 : : * These routines dump out all non-default GUC options into a binary
5518 : : * file that is read by all exec'ed backends. The format is:
5519 : : *
5520 : : * variable name, string, null terminated
5521 : : * variable value, string, null terminated
5522 : : * variable sourcefile, string, null terminated (empty if none)
5523 : : * variable sourceline, integer
5524 : : * variable source, integer
5525 : : * variable scontext, integer
5526 : : * variable srole, OID
5527 : : */
5528 : : static void
5529 : : write_one_nondefault_variable(FILE *fp, struct config_generic *gconf)
5530 : : {
5531 : : Assert(gconf->source != PGC_S_DEFAULT);
5532 : :
5533 : : fprintf(fp, "%s", gconf->name);
5534 : : fputc(0, fp);
5535 : :
5536 : : switch (gconf->vartype)
5537 : : {
5538 : : case PGC_BOOL:
5539 : : {
5540 : : struct config_bool *conf = (struct config_bool *) gconf;
5541 : :
5542 : : if (*conf->variable)
5543 : : fprintf(fp, "true");
5544 : : else
5545 : : fprintf(fp, "false");
5546 : : }
5547 : : break;
5548 : :
5549 : : case PGC_INT:
5550 : : {
5551 : : struct config_int *conf = (struct config_int *) gconf;
5552 : :
5553 : : fprintf(fp, "%d", *conf->variable);
5554 : : }
5555 : : break;
5556 : :
5557 : : case PGC_REAL:
5558 : : {
5559 : : struct config_real *conf = (struct config_real *) gconf;
5560 : :
5561 : : fprintf(fp, "%.17g", *conf->variable);
5562 : : }
5563 : : break;
5564 : :
5565 : : case PGC_STRING:
5566 : : {
5567 : : struct config_string *conf = (struct config_string *) gconf;
5568 : :
5569 : : if (*conf->variable)
5570 : : fprintf(fp, "%s", *conf->variable);
5571 : : }
5572 : : break;
5573 : :
5574 : : case PGC_ENUM:
5575 : : {
5576 : : struct config_enum *conf = (struct config_enum *) gconf;
5577 : :
5578 : : fprintf(fp, "%s",
5579 : : config_enum_lookup_by_value(conf, *conf->variable));
5580 : : }
5581 : : break;
5582 : : }
5583 : :
5584 : : fputc(0, fp);
5585 : :
5586 : : if (gconf->sourcefile)
5587 : : fprintf(fp, "%s", gconf->sourcefile);
5588 : : fputc(0, fp);
5589 : :
5590 : : fwrite(&gconf->sourceline, 1, sizeof(gconf->sourceline), fp);
5591 : : fwrite(&gconf->source, 1, sizeof(gconf->source), fp);
5592 : : fwrite(&gconf->scontext, 1, sizeof(gconf->scontext), fp);
5593 : : fwrite(&gconf->srole, 1, sizeof(gconf->srole), fp);
5594 : : }
5595 : :
5596 : : void
5597 : : write_nondefault_variables(GucContext context)
5598 : : {
5599 : : int elevel;
5600 : : FILE *fp;
5601 : : dlist_iter iter;
5602 : :
5603 : : Assert(context == PGC_POSTMASTER || context == PGC_SIGHUP);
5604 : :
5605 : : elevel = (context == PGC_SIGHUP) ? LOG : ERROR;
5606 : :
5607 : : /*
5608 : : * Open file
5609 : : */
5610 : : fp = AllocateFile(CONFIG_EXEC_PARAMS_NEW, "w");
5611 : : if (!fp)
5612 : : {
5613 : : ereport(elevel,
5614 : : (errcode_for_file_access(),
5615 : : errmsg("could not write to file \"%s\": %m",
5616 : : CONFIG_EXEC_PARAMS_NEW)));
5617 : : return;
5618 : : }
5619 : :
5620 : : /* We need only consider GUCs with source not PGC_S_DEFAULT */
5621 : : dlist_foreach(iter, &guc_nondef_list)
5622 : : {
5623 : : struct config_generic *gconf = dlist_container(struct config_generic,
5624 : : nondef_link, iter.cur);
5625 : :
5626 : : write_one_nondefault_variable(fp, gconf);
5627 : : }
5628 : :
5629 : : if (FreeFile(fp))
5630 : : {
5631 : : ereport(elevel,
5632 : : (errcode_for_file_access(),
5633 : : errmsg("could not write to file \"%s\": %m",
5634 : : CONFIG_EXEC_PARAMS_NEW)));
5635 : : return;
5636 : : }
5637 : :
5638 : : /*
5639 : : * Put new file in place. This could delay on Win32, but we don't hold
5640 : : * any exclusive locks.
5641 : : */
5642 : : rename(CONFIG_EXEC_PARAMS_NEW, CONFIG_EXEC_PARAMS);
5643 : : }
5644 : :
5645 : :
5646 : : /*
5647 : : * Read string, including null byte from file
5648 : : *
5649 : : * Return NULL on EOF and nothing read
5650 : : */
5651 : : static char *
5652 : : read_string_with_null(FILE *fp)
5653 : : {
5654 : : int i = 0,
5655 : : ch,
5656 : : maxlen = 256;
5657 : : char *str = NULL;
5658 : :
5659 : : do
5660 : : {
5661 : : if ((ch = fgetc(fp)) == EOF)
5662 : : {
5663 : : if (i == 0)
5664 : : return NULL;
5665 : : else
5666 : : elog(FATAL, "invalid format of exec config params file");
5667 : : }
5668 : : if (i == 0)
5669 : : str = guc_malloc(FATAL, maxlen);
5670 : : else if (i == maxlen)
5671 : : str = guc_realloc(FATAL, str, maxlen *= 2);
5672 : : str[i++] = ch;
5673 : : } while (ch != 0);
5674 : :
5675 : : return str;
5676 : : }
5677 : :
5678 : :
5679 : : /*
5680 : : * This routine loads a previous postmaster dump of its non-default
5681 : : * settings.
5682 : : */
5683 : : void
5684 : : read_nondefault_variables(void)
5685 : : {
5686 : : FILE *fp;
5687 : : char *varname,
5688 : : *varvalue,
5689 : : *varsourcefile;
5690 : : int varsourceline;
5691 : : GucSource varsource;
5692 : : GucContext varscontext;
5693 : : Oid varsrole;
5694 : :
5695 : : /*
5696 : : * Open file
5697 : : */
5698 : : fp = AllocateFile(CONFIG_EXEC_PARAMS, "r");
5699 : : if (!fp)
5700 : : {
5701 : : /* File not found is fine */
5702 : : if (errno != ENOENT)
5703 : : ereport(FATAL,
5704 : : (errcode_for_file_access(),
5705 : : errmsg("could not read from file \"%s\": %m",
5706 : : CONFIG_EXEC_PARAMS)));
5707 : : return;
5708 : : }
5709 : :
5710 : : for (;;)
5711 : : {
5712 : : if ((varname = read_string_with_null(fp)) == NULL)
5713 : : break;
5714 : :
5715 : : if (find_option(varname, true, false, FATAL) == NULL)
5716 : : elog(FATAL, "failed to locate variable \"%s\" in exec config params file", varname);
5717 : :
5718 : : if ((varvalue = read_string_with_null(fp)) == NULL)
5719 : : elog(FATAL, "invalid format of exec config params file");
5720 : : if ((varsourcefile = read_string_with_null(fp)) == NULL)
5721 : : elog(FATAL, "invalid format of exec config params file");
5722 : : if (fread(&varsourceline, 1, sizeof(varsourceline), fp) != sizeof(varsourceline))
5723 : : elog(FATAL, "invalid format of exec config params file");
5724 : : if (fread(&varsource, 1, sizeof(varsource), fp) != sizeof(varsource))
5725 : : elog(FATAL, "invalid format of exec config params file");
5726 : : if (fread(&varscontext, 1, sizeof(varscontext), fp) != sizeof(varscontext))
5727 : : elog(FATAL, "invalid format of exec config params file");
5728 : : if (fread(&varsrole, 1, sizeof(varsrole), fp) != sizeof(varsrole))
5729 : : elog(FATAL, "invalid format of exec config params file");
5730 : :
5731 : : (void) set_config_option_ext(varname, varvalue,
5732 : : varscontext, varsource, varsrole,
5733 : : GUC_ACTION_SET, true, 0, true);
5734 : : if (varsourcefile[0])
5735 : : set_config_sourcefile(varname, varsourcefile, varsourceline);
5736 : :
5737 : : guc_free(varname);
5738 : : guc_free(varvalue);
5739 : : guc_free(varsourcefile);
5740 : : }
5741 : :
5742 : : FreeFile(fp);
5743 : : }
5744 : : #endif /* EXEC_BACKEND */
5745 : :
5746 : : /*
5747 : : * can_skip_gucvar:
5748 : : * Decide whether SerializeGUCState can skip sending this GUC variable,
5749 : : * or whether RestoreGUCState can skip resetting this GUC to default.
5750 : : *
5751 : : * It is somewhat magical and fragile that the same test works for both cases.
5752 : : * Realize in particular that we are very likely selecting different sets of
5753 : : * GUCs on the leader and worker sides! Be sure you've understood the
5754 : : * comments here and in RestoreGUCState thoroughly before changing this.
5755 : : */
5756 : : static bool
5757 : 114788 : can_skip_gucvar(struct config_generic *gconf)
5758 : : {
5759 : : /*
5760 : : * We can skip GUCs that are guaranteed to have the same values in leaders
5761 : : * and workers. (Note it is critical that the leader and worker have the
5762 : : * same idea of which GUCs fall into this category. It's okay to consider
5763 : : * context and name for this purpose, since those are unchanging
5764 : : * properties of a GUC.)
5765 : : *
5766 : : * PGC_POSTMASTER variables always have the same value in every child of a
5767 : : * particular postmaster, so the worker will certainly have the right
5768 : : * value already. Likewise, PGC_INTERNAL variables are set by special
5769 : : * mechanisms (if indeed they aren't compile-time constants). So we may
5770 : : * always skip these.
5771 : : *
5772 : : * Role must be handled specially because its current value can be an
5773 : : * invalid value (for instance, if someone dropped the role since we set
5774 : : * it). So if we tried to serialize it normally, we might get a failure.
5775 : : * We skip it here, and use another mechanism to ensure the worker has the
5776 : : * right value.
5777 : : *
5778 : : * For all other GUCs, we skip if the GUC has its compiled-in default
5779 : : * value (i.e., source == PGC_S_DEFAULT). On the leader side, this means
5780 : : * we don't send GUCs that have their default values, which typically
5781 : : * saves lots of work. On the worker side, this means we don't need to
5782 : : * reset the GUC to default because it already has that value. See
5783 : : * comments in RestoreGUCState for more info.
5784 : : */
5785 : 190354 : return gconf->context == PGC_POSTMASTER ||
5786 [ + + + + : 175304 : gconf->context == PGC_INTERNAL || gconf->source == PGC_S_DEFAULT ||
+ - ]
5787 [ + + ]: 60516 : strcmp(gconf->name, "role") == 0;
5788 : : }
5789 : :
5790 : : /*
5791 : : * estimate_variable_size:
5792 : : * Compute space needed for dumping the given GUC variable.
5793 : : *
5794 : : * It's OK to overestimate, but not to underestimate.
5795 : : */
5796 : : static Size
5797 : 24184 : estimate_variable_size(struct config_generic *gconf)
5798 : : {
5799 : : Size size;
5800 : 24184 : Size valsize = 0;
5801 : :
5802 : : /* Skippable GUCs consume zero space. */
5803 [ + + ]: 24184 : if (can_skip_gucvar(gconf))
5804 : 10439 : return 0;
5805 : :
5806 : : /* Name, plus trailing zero byte. */
5807 : 13745 : size = strlen(gconf->name) + 1;
5808 : :
5809 : : /* Get the maximum display length of the GUC value. */
5810 [ + + + + : 13745 : switch (gconf->vartype)
+ - ]
5811 : : {
5812 : 2910 : case PGC_BOOL:
5813 : : {
5814 : 2910 : valsize = 5; /* max(strlen('true'), strlen('false')) */
5815 : : }
5816 : 2910 : break;
5817 : :
5818 : 2821 : case PGC_INT:
5819 : : {
5820 : 2821 : struct config_int *conf = (struct config_int *) gconf;
5821 : :
5822 : : /*
5823 : : * Instead of getting the exact display length, use max
5824 : : * length. Also reduce the max length for typical ranges of
5825 : : * small values. Maximum value is 2147483647, i.e. 10 chars.
5826 : : * Include one byte for sign.
5827 : : */
555 peter@eisentraut.org 5828 [ + - + + ]: 2821 : if (abs(*conf->variable) < 1000)
579 tgl@sss.pgh.pa.us 5829 : 2225 : valsize = 3 + 1;
5830 : : else
5831 : 596 : valsize = 10 + 1;
5832 : : }
5833 : 2821 : break;
5834 : :
5835 : 823 : case PGC_REAL:
5836 : : {
5837 : : /*
5838 : : * We are going to print it with %e with REALTYPE_PRECISION
5839 : : * fractional digits. Account for sign, leading digit,
5840 : : * decimal point, and exponent with up to 3 digits. E.g.
5841 : : * -3.99329042340000021e+110
5842 : : */
5843 : 823 : valsize = 1 + 1 + 1 + REALTYPE_PRECISION + 5;
5844 : : }
5845 : 823 : break;
5846 : :
5847 : 5471 : case PGC_STRING:
5848 : : {
5849 : 5471 : struct config_string *conf = (struct config_string *) gconf;
5850 : :
5851 : : /*
5852 : : * If the value is NULL, we transmit it as an empty string.
5853 : : * Although this is not physically the same value, GUC
5854 : : * generally treats a NULL the same as empty string.
5855 : : */
5856 [ + - ]: 5471 : if (*conf->variable)
5857 : 5471 : valsize = strlen(*conf->variable);
5858 : : else
579 tgl@sss.pgh.pa.us 5859 :UBC 0 : valsize = 0;
5860 : : }
579 tgl@sss.pgh.pa.us 5861 :CBC 5471 : break;
5862 : :
5863 : 1720 : case PGC_ENUM:
5864 : : {
5865 : 1720 : struct config_enum *conf = (struct config_enum *) gconf;
5866 : :
5867 : 1720 : valsize = strlen(config_enum_lookup_by_value(conf, *conf->variable));
5868 : : }
5869 : 1720 : break;
5870 : : }
5871 : :
5872 : : /* Allow space for terminating zero-byte for value */
5873 : 13745 : size = add_size(size, valsize + 1);
5874 : :
5875 [ + + ]: 13745 : if (gconf->sourcefile)
5876 : 6878 : size = add_size(size, strlen(gconf->sourcefile));
5877 : :
5878 : : /* Allow space for terminating zero-byte for sourcefile */
5879 : 13745 : size = add_size(size, 1);
5880 : :
5881 : : /* Include line whenever file is nonempty. */
5882 [ + + + - ]: 13745 : if (gconf->sourcefile && gconf->sourcefile[0])
5883 : 6878 : size = add_size(size, sizeof(gconf->sourceline));
5884 : :
5885 : 13745 : size = add_size(size, sizeof(gconf->source));
5886 : 13745 : size = add_size(size, sizeof(gconf->scontext));
5887 : 13745 : size = add_size(size, sizeof(gconf->srole));
5888 : :
5889 : 13745 : return size;
5890 : : }
5891 : :
5892 : : /*
5893 : : * EstimateGUCStateSpace:
5894 : : * Returns the size needed to store the GUC state for the current process
5895 : : */
5896 : : Size
5897 : 414 : EstimateGUCStateSpace(void)
5898 : : {
5899 : : Size size;
5900 : : dlist_iter iter;
5901 : :
5902 : : /* Add space reqd for saving the data size of the guc state */
5903 : 414 : size = sizeof(Size);
5904 : :
5905 : : /*
5906 : : * Add up the space needed for each GUC variable.
5907 : : *
5908 : : * We need only process non-default GUCs.
5909 : : */
548 5910 [ + - + + ]: 24598 : dlist_foreach(iter, &guc_nondef_list)
5911 : : {
5912 : 24184 : struct config_generic *gconf = dlist_container(struct config_generic,
5913 : : nondef_link, iter.cur);
5914 : :
5915 : 24184 : size = add_size(size, estimate_variable_size(gconf));
5916 : : }
5917 : :
579 5918 : 414 : return size;
5919 : : }
5920 : :
5921 : : /*
5922 : : * do_serialize:
5923 : : * Copies the formatted string into the destination. Moves ahead the
5924 : : * destination pointer, and decrements the maxbytes by that many bytes. If
5925 : : * maxbytes is not sufficient to copy the string, error out.
5926 : : */
5927 : : static void
5928 : 41235 : do_serialize(char **destptr, Size *maxbytes, const char *fmt,...)
5929 : : {
5930 : : va_list vargs;
5931 : : int n;
5932 : :
5933 [ - + ]: 41235 : if (*maxbytes <= 0)
579 tgl@sss.pgh.pa.us 5934 [ # # ]:UBC 0 : elog(ERROR, "not enough space to serialize GUC state");
5935 : :
579 tgl@sss.pgh.pa.us 5936 :CBC 41235 : va_start(vargs, fmt);
5937 : 41235 : n = vsnprintf(*destptr, *maxbytes, fmt, vargs);
5938 : 41235 : va_end(vargs);
5939 : :
5940 [ - + ]: 41235 : if (n < 0)
5941 : : {
5942 : : /* Shouldn't happen. Better show errno description. */
579 tgl@sss.pgh.pa.us 5943 [ # # ]:UBC 0 : elog(ERROR, "vsnprintf failed: %m with format string \"%s\"", fmt);
5944 : : }
579 tgl@sss.pgh.pa.us 5945 [ - + ]:CBC 41235 : if (n >= *maxbytes)
5946 : : {
5947 : : /* This shouldn't happen either, really. */
579 tgl@sss.pgh.pa.us 5948 [ # # ]:UBC 0 : elog(ERROR, "not enough space to serialize GUC state");
5949 : : }
5950 : :
5951 : : /* Shift the destptr ahead of the null terminator */
579 tgl@sss.pgh.pa.us 5952 :CBC 41235 : *destptr += n + 1;
5953 : 41235 : *maxbytes -= n + 1;
4756 5954 : 41235 : }
5955 : :
5956 : : /* Binary copy version of do_serialize() */
5957 : : static void
579 5958 : 48113 : do_serialize_binary(char **destptr, Size *maxbytes, void *val, Size valsize)
5959 : : {
5960 [ - + ]: 48113 : if (valsize > *maxbytes)
579 tgl@sss.pgh.pa.us 5961 [ # # ]:UBC 0 : elog(ERROR, "not enough space to serialize GUC state");
5962 : :
579 tgl@sss.pgh.pa.us 5963 :CBC 48113 : memcpy(*destptr, val, valsize);
5964 : 48113 : *destptr += valsize;
5965 : 48113 : *maxbytes -= valsize;
4756 5966 : 48113 : }
5967 : :
5968 : : /*
5969 : : * serialize_variable:
5970 : : * Dumps name, value and other information of a GUC variable into destptr.
5971 : : */
5972 : : static void
579 5973 : 24184 : serialize_variable(char **destptr, Size *maxbytes,
5974 : : struct config_generic *gconf)
5975 : : {
5976 : : /* Ignore skippable GUCs. */
5977 [ + + ]: 24184 : if (can_skip_gucvar(gconf))
5978 : 10439 : return;
5979 : :
5980 : 13745 : do_serialize(destptr, maxbytes, "%s", gconf->name);
5981 : :
5982 [ + + + + : 13745 : switch (gconf->vartype)
+ - ]
5983 : : {
5984 : 2910 : case PGC_BOOL:
5985 : : {
5986 : 2910 : struct config_bool *conf = (struct config_bool *) gconf;
5987 : :
5988 : 2910 : do_serialize(destptr, maxbytes,
5989 [ + + ]: 2910 : (*conf->variable ? "true" : "false"));
5990 : : }
5991 : 2910 : break;
5992 : :
5993 : 2821 : case PGC_INT:
5994 : : {
5995 : 2821 : struct config_int *conf = (struct config_int *) gconf;
5996 : :
5997 : 2821 : do_serialize(destptr, maxbytes, "%d", *conf->variable);
5998 : : }
5999 : 2821 : break;
6000 : :
6001 : 823 : case PGC_REAL:
6002 : : {
6003 : 823 : struct config_real *conf = (struct config_real *) gconf;
6004 : :
6005 : 823 : do_serialize(destptr, maxbytes, "%.*e",
6006 : 823 : REALTYPE_PRECISION, *conf->variable);
6007 : : }
6008 : 823 : break;
6009 : :
6010 : 5471 : case PGC_STRING:
6011 : : {
6012 : 5471 : struct config_string *conf = (struct config_string *) gconf;
6013 : :
6014 : : /* NULL becomes empty string, see estimate_variable_size() */
579 tgl@sss.pgh.pa.us 6015 :UBC 0 : do_serialize(destptr, maxbytes, "%s",
579 tgl@sss.pgh.pa.us 6016 [ + - ]:CBC 5471 : *conf->variable ? *conf->variable : "");
6017 : : }
6018 : 5471 : break;
6019 : :
6020 : 1720 : case PGC_ENUM:
6021 : : {
6022 : 1720 : struct config_enum *conf = (struct config_enum *) gconf;
6023 : :
6024 : 1720 : do_serialize(destptr, maxbytes, "%s",
6025 : 1720 : config_enum_lookup_by_value(conf, *conf->variable));
6026 : : }
6027 : 1720 : break;
6028 : : }
6029 : :
6030 : 13745 : do_serialize(destptr, maxbytes, "%s",
6031 [ + + ]: 13745 : (gconf->sourcefile ? gconf->sourcefile : ""));
6032 : :
6033 [ + + + - ]: 13745 : if (gconf->sourcefile && gconf->sourcefile[0])
6034 : 6878 : do_serialize_binary(destptr, maxbytes, &gconf->sourceline,
6035 : : sizeof(gconf->sourceline));
6036 : :
6037 : 13745 : do_serialize_binary(destptr, maxbytes, &gconf->source,
6038 : : sizeof(gconf->source));
6039 : 13745 : do_serialize_binary(destptr, maxbytes, &gconf->scontext,
6040 : : sizeof(gconf->scontext));
6041 : 13745 : do_serialize_binary(destptr, maxbytes, &gconf->srole,
6042 : : sizeof(gconf->srole));
6043 : : }
6044 : :
6045 : : /*
6046 : : * SerializeGUCState:
6047 : : * Dumps the complete GUC state onto the memory location at start_address.
6048 : : */
6049 : : void
6050 : 414 : SerializeGUCState(Size maxsize, char *start_address)
6051 : : {
6052 : : char *curptr;
6053 : : Size actual_size;
6054 : : Size bytes_left;
6055 : : dlist_iter iter;
6056 : :
6057 : : /* Reserve space for saving the actual size of the guc state */
6058 [ - + ]: 414 : Assert(maxsize > sizeof(actual_size));
6059 : 414 : curptr = start_address + sizeof(actual_size);
6060 : 414 : bytes_left = maxsize - sizeof(actual_size);
6061 : :
6062 : : /* We need only consider GUCs with source not PGC_S_DEFAULT */
548 6063 [ + - + + ]: 24598 : dlist_foreach(iter, &guc_nondef_list)
6064 : : {
6065 : 24184 : struct config_generic *gconf = dlist_container(struct config_generic,
6066 : : nondef_link, iter.cur);
6067 : :
6068 : 24184 : serialize_variable(&curptr, &bytes_left, gconf);
6069 : : }
6070 : :
6071 : : /* Store actual size without assuming alignment of start_address. */
579 6072 : 414 : actual_size = maxsize - bytes_left - sizeof(actual_size);
6073 : 414 : memcpy(start_address, &actual_size, sizeof(actual_size));
2622 rhaas@postgresql.org 6074 : 414 : }
6075 : :
6076 : : /*
6077 : : * read_gucstate:
6078 : : * Actually it does not read anything, just returns the srcptr. But it does
6079 : : * move the srcptr past the terminating zero byte, so that the caller is ready
6080 : : * to read the next string.
6081 : : */
6082 : : static char *
579 tgl@sss.pgh.pa.us 6083 : 137028 : read_gucstate(char **srcptr, char *srcend)
6084 : : {
6085 : 137028 : char *retptr = *srcptr;
6086 : : char *ptr;
6087 : :
6088 [ - + ]: 137028 : if (*srcptr >= srcend)
579 tgl@sss.pgh.pa.us 6089 [ # # ]:UBC 0 : elog(ERROR, "incomplete GUC state");
6090 : :
6091 : : /* The string variables are all null terminated */
579 tgl@sss.pgh.pa.us 6092 [ + - + + ]:CBC 4050126 : for (ptr = *srcptr; ptr < srcend && *ptr != '\0'; ptr++)
6093 : : ;
6094 : :
6095 [ - + ]: 137028 : if (ptr >= srcend)
579 tgl@sss.pgh.pa.us 6096 [ # # ]:UBC 0 : elog(ERROR, "could not find null terminator in GUC state");
6097 : :
6098 : : /* Set the new position to the byte following the terminating NUL */
579 tgl@sss.pgh.pa.us 6099 :CBC 137028 : *srcptr = ptr + 1;
6100 : :
6101 : 137028 : return retptr;
6102 : : }
6103 : :
6104 : : /* Binary read version of read_gucstate(). Copies into dest */
6105 : : static void
6106 : 159025 : read_gucstate_binary(char **srcptr, char *srcend, void *dest, Size size)
6107 : : {
6108 [ - + ]: 159025 : if (*srcptr + size > srcend)
579 tgl@sss.pgh.pa.us 6109 [ # # ]:UBC 0 : elog(ERROR, "incomplete GUC state");
6110 : :
579 tgl@sss.pgh.pa.us 6111 :CBC 159025 : memcpy(dest, *srcptr, size);
6112 : 159025 : *srcptr += size;
7660 6113 : 159025 : }
6114 : :
6115 : : /*
6116 : : * Callback used to add a context message when reporting errors that occur
6117 : : * while trying to restore GUCs in parallel workers.
6118 : : */
6119 : : static void
579 tgl@sss.pgh.pa.us 6120 :UBC 0 : guc_restore_error_context_callback(void *arg)
6121 : : {
6122 : 0 : char **error_context_name_and_value = (char **) arg;
6123 : :
6124 [ # # ]: 0 : if (error_context_name_and_value)
6125 : 0 : errcontext("while setting parameter \"%s\" to \"%s\"",
6126 : : error_context_name_and_value[0],
6127 : 0 : error_context_name_and_value[1]);
6236 JanWieck@Yahoo.com 6128 : 0 : }
6129 : :
6130 : : /*
6131 : : * RestoreGUCState:
6132 : : * Reads the GUC state at the specified address and sets this process's
6133 : : * GUCs to match.
6134 : : *
6135 : : * Note that this provides the worker with only a very shallow view of the
6136 : : * leader's GUC state: we'll know about the currently active values, but not
6137 : : * about stacked or reset values. That's fine since the worker is just
6138 : : * executing one part of a query, within which the active values won't change
6139 : : * and the stacked values are invisible.
6140 : : */
6141 : : void
579 tgl@sss.pgh.pa.us 6142 :CBC 1322 : RestoreGUCState(void *gucstate)
6143 : : {
6144 : : char *varname,
6145 : : *varvalue,
6146 : : *varsourcefile;
6147 : : int varsourceline;
6148 : : GucSource varsource;
6149 : : GucContext varscontext;
6150 : : Oid varsrole;
6151 : 1322 : char *srcptr = (char *) gucstate;
6152 : : char *srcend;
6153 : : Size len;
6154 : : dlist_mutable_iter iter;
6155 : : ErrorContextCallback error_context_callback;
6156 : :
6157 : : /*
6158 : : * First, ensure that all potentially-shippable GUCs are reset to their
6159 : : * default values. We must not touch those GUCs that the leader will
6160 : : * never ship, while there is no need to touch those that are shippable
6161 : : * but already have their default values. Thus, this ends up being the
6162 : : * same test that SerializeGUCState uses, even though the sets of
6163 : : * variables involved may well be different since the leader's set of
6164 : : * variables-not-at-default-values can differ from the set that are
6165 : : * not-default in this freshly started worker.
6166 : : *
6167 : : * Once we have set all the potentially-shippable GUCs to default values,
6168 : : * restoring the GUCs that the leader sent (because they had non-default
6169 : : * values over there) leads us to exactly the set of GUC values that the
6170 : : * leader has. This is true even though the worker may have initially
6171 : : * absorbed postgresql.conf settings that the leader hasn't yet seen, or
6172 : : * ALTER USER/DATABASE SET settings that were established after the leader
6173 : : * started.
6174 : : *
6175 : : * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
6176 : : * also ensures that set_config_option won't refuse to set them because of
6177 : : * source-priority comparisons.
6178 : : */
548 6179 [ + - + + ]: 67742 : dlist_foreach_modify(iter, &guc_nondef_list)
6180 : : {
6181 : 66420 : struct config_generic *gconf = dlist_container(struct config_generic,
6182 : : nondef_link, iter.cur);
6183 : :
6184 : : /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
579 6185 [ + + ]: 66420 : if (can_skip_gucvar(gconf))
6186 : 33400 : continue;
6187 : :
6188 : : /*
6189 : : * We can use InitializeOneGUCOption to reset the GUC to default, but
6190 : : * first we must free any existing subsidiary data to avoid leaking
6191 : : * memory. The stack must be empty, but we have to clean up all other
6192 : : * fields. Beware that there might be duplicate value or "extra"
6193 : : * pointers. We also have to be sure to take it out of any lists it's
6194 : : * in.
6195 : : */
6196 [ - + ]: 33020 : Assert(gconf->stack == NULL);
548 6197 : 33020 : guc_free(gconf->extra);
6198 : 33020 : guc_free(gconf->last_reported);
6199 : 33020 : guc_free(gconf->sourcefile);
579 6200 [ + + - + : 33020 : switch (gconf->vartype)
+ - ]
6201 : : {
6202 : 7046 : case PGC_BOOL:
6203 : : {
6204 : 7046 : struct config_bool *conf = (struct config_bool *) gconf;
6205 : :
6206 [ - + - - ]: 7046 : if (conf->reset_extra && conf->reset_extra != gconf->extra)
548 tgl@sss.pgh.pa.us 6207 :UBC 0 : guc_free(conf->reset_extra);
579 tgl@sss.pgh.pa.us 6208 :CBC 7046 : break;
6209 : : }
6210 : 6173 : case PGC_INT:
6211 : : {
6212 : 6173 : struct config_int *conf = (struct config_int *) gconf;
6213 : :
6214 [ - + - - ]: 6173 : if (conf->reset_extra && conf->reset_extra != gconf->extra)
548 tgl@sss.pgh.pa.us 6215 :UBC 0 : guc_free(conf->reset_extra);
579 tgl@sss.pgh.pa.us 6216 :CBC 6173 : break;
6217 : : }
579 tgl@sss.pgh.pa.us 6218 :UBC 0 : case PGC_REAL:
6219 : : {
6220 : 0 : struct config_real *conf = (struct config_real *) gconf;
6221 : :
6222 [ # # # # ]: 0 : if (conf->reset_extra && conf->reset_extra != gconf->extra)
548 6223 : 0 : guc_free(conf->reset_extra);
579 6224 : 0 : break;
6225 : : }
579 tgl@sss.pgh.pa.us 6226 :CBC 15866 : case PGC_STRING:
6227 : : {
6228 : 15866 : struct config_string *conf = (struct config_string *) gconf;
6229 : :
548 6230 : 15866 : guc_free(*conf->variable);
579 6231 [ + - - + ]: 15866 : if (conf->reset_val && conf->reset_val != *conf->variable)
548 tgl@sss.pgh.pa.us 6232 :UBC 0 : guc_free(conf->reset_val);
579 tgl@sss.pgh.pa.us 6233 [ + + - + ]:CBC 15866 : if (conf->reset_extra && conf->reset_extra != gconf->extra)
548 tgl@sss.pgh.pa.us 6234 :UBC 0 : guc_free(conf->reset_extra);
579 tgl@sss.pgh.pa.us 6235 :CBC 15866 : break;
6236 : : }
6237 : 3935 : case PGC_ENUM:
6238 : : {
6239 : 3935 : struct config_enum *conf = (struct config_enum *) gconf;
6240 : :
6241 [ - + - - ]: 3935 : if (conf->reset_extra && conf->reset_extra != gconf->extra)
548 tgl@sss.pgh.pa.us 6242 :UBC 0 : guc_free(conf->reset_extra);
579 tgl@sss.pgh.pa.us 6243 :CBC 3935 : break;
6244 : : }
6245 : : }
6246 : : /* Remove it from any lists it's in. */
548 6247 : 33020 : RemoveGUCFromLists(gconf);
6248 : : /* Now we can reset the struct to PGS_S_DEFAULT state. */
579 6249 : 33020 : InitializeOneGUCOption(gconf);
6250 : : }
6251 : :
6252 : : /* First item is the length of the subsequent data */
6253 : 1322 : memcpy(&len, gucstate, sizeof(len));
6254 : :
6255 : 1322 : srcptr += sizeof(len);
6256 : 1322 : srcend = srcptr + len;
6257 : :
6258 : : /* If the GUC value check fails, we want errors to show useful context. */
6259 : 1322 : error_context_callback.callback = guc_restore_error_context_callback;
6260 : 1322 : error_context_callback.previous = error_context_stack;
6261 : 1322 : error_context_callback.arg = NULL;
6262 : 1322 : error_context_stack = &error_context_callback;
6263 : :
6264 : : /* Restore all the listed GUCs. */
6265 [ + + ]: 46998 : while (srcptr < srcend)
6266 : : {
6267 : : int result;
6268 : : char *error_context_name_and_value[2];
6269 : :
6270 : 45676 : varname = read_gucstate(&srcptr, srcend);
6271 : 45676 : varvalue = read_gucstate(&srcptr, srcend);
6272 : 45676 : varsourcefile = read_gucstate(&srcptr, srcend);
6273 [ + + ]: 45676 : if (varsourcefile[0])
6274 : 21997 : read_gucstate_binary(&srcptr, srcend,
6275 : : &varsourceline, sizeof(varsourceline));
6276 : : else
6277 : 23679 : varsourceline = 0;
6278 : 45676 : read_gucstate_binary(&srcptr, srcend,
6279 : : &varsource, sizeof(varsource));
6280 : 45676 : read_gucstate_binary(&srcptr, srcend,
6281 : : &varscontext, sizeof(varscontext));
6282 : 45676 : read_gucstate_binary(&srcptr, srcend,
6283 : : &varsrole, sizeof(varsrole));
6284 : :
6285 : 45676 : error_context_name_and_value[0] = varname;
6286 : 45676 : error_context_name_and_value[1] = varvalue;
6287 : 45676 : error_context_callback.arg = &error_context_name_and_value[0];
6288 : 45676 : result = set_config_option_ext(varname, varvalue,
6289 : : varscontext, varsource, varsrole,
6290 : : GUC_ACTION_SET, true, ERROR, true);
6291 [ - + ]: 45676 : if (result <= 0)
579 tgl@sss.pgh.pa.us 6292 [ # # ]:UBC 0 : ereport(ERROR,
6293 : : (errcode(ERRCODE_INTERNAL_ERROR),
6294 : : errmsg("parameter \"%s\" could not be set", varname)));
579 tgl@sss.pgh.pa.us 6295 [ + + ]:CBC 45676 : if (varsourcefile[0])
6296 : 21997 : set_config_sourcefile(varname, varsourcefile, varsourceline);
6297 : 45676 : error_context_callback.arg = NULL;
6298 : : }
6299 : :
6300 : 1322 : error_context_stack = error_context_callback.previous;
6473 6301 : 1322 : }
6302 : :
6303 : : /*
6304 : : * A little "long argument" simulation, although not quite GNU
6305 : : * compliant. Takes a string of the form "some-option=some value" and
6306 : : * returns name = "some_option" and value = "some value" in palloc'ed
6307 : : * storage. Note that '-' is converted to '_' in the option name. If
6308 : : * there is no '=' in the input string then value will be NULL.
6309 : : */
6310 : : void
579 6311 : 24110 : ParseLongOption(const char *string, char **name, char **value)
6312 : : {
6313 : : size_t equal_pos;
6314 : : char *cp;
6315 : :
534 peter@eisentraut.org 6316 [ - + ]: 24110 : Assert(string);
6317 [ - + ]: 24110 : Assert(name);
6318 [ - + ]: 24110 : Assert(value);
6319 : :
579 tgl@sss.pgh.pa.us 6320 : 24110 : equal_pos = strcspn(string, "=");
6321 : :
6322 [ + - ]: 24110 : if (string[equal_pos] == '=')
6323 : : {
548 6324 : 24110 : *name = palloc(equal_pos + 1);
579 6325 : 24110 : strlcpy(*name, string, equal_pos + 1);
6326 : :
548 6327 : 24110 : *value = pstrdup(&string[equal_pos + 1]);
6328 : : }
6329 : : else
6330 : : {
6331 : : /* no equal sign in string */
548 tgl@sss.pgh.pa.us 6332 :UBC 0 : *name = pstrdup(string);
579 6333 : 0 : *value = NULL;
6334 : : }
6335 : :
579 tgl@sss.pgh.pa.us 6336 [ + + ]:CBC 331660 : for (cp = *name; *cp; cp++)
6337 [ + + ]: 307550 : if (*cp == '-')
6338 : 740 : *cp = '_';
6833 bruce@momjian.us 6339 : 24110 : }
6340 : :
6341 : :
6342 : : /*
6343 : : * Transform array of GUC settings into lists of names and values. The lists
6344 : : * are faster to process in cases where the settings must be applied
6345 : : * repeatedly (e.g. for each function invocation).
6346 : : */
6347 : : void
248 jdavis@postgresql.or 6348 :GNC 3152 : TransformGUCArray(ArrayType *array, List **names, List **values)
6349 : : {
6350 : : int i;
6351 : :
579 tgl@sss.pgh.pa.us 6352 [ - + ]:CBC 3152 : Assert(array != NULL);
6353 [ - + ]: 3152 : Assert(ARR_ELEMTYPE(array) == TEXTOID);
6354 [ - + ]: 3152 : Assert(ARR_NDIM(array) == 1);
6355 [ - + ]: 3152 : Assert(ARR_LBOUND(array)[0] == 1);
6356 : :
248 jdavis@postgresql.or 6357 :GNC 3152 : *names = NIL;
6358 : 3152 : *values = NIL;
579 tgl@sss.pgh.pa.us 6359 [ + + ]:CBC 21816 : for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6360 : : {
6361 : : Datum d;
6362 : : bool isnull;
6363 : : char *s;
6364 : : char *name;
6365 : : char *value;
6366 : :
6367 : 18664 : d = array_ref(array, 1, &i,
6368 : : -1 /* varlenarray */ ,
6369 : : -1 /* TEXT's typlen */ ,
6370 : : false /* TEXT's typbyval */ ,
6371 : : TYPALIGN_INT /* TEXT's typalign */ ,
6372 : : &isnull);
6373 : :
6374 [ - + ]: 18664 : if (isnull)
579 tgl@sss.pgh.pa.us 6375 :UBC 0 : continue;
6376 : :
579 tgl@sss.pgh.pa.us 6377 :CBC 18664 : s = TextDatumGetCString(d);
6378 : :
6379 : 18664 : ParseLongOption(s, &name, &value);
6380 [ - + ]: 18664 : if (!value)
6381 : : {
579 tgl@sss.pgh.pa.us 6382 [ # # ]:UBC 0 : ereport(WARNING,
6383 : : (errcode(ERRCODE_SYNTAX_ERROR),
6384 : : errmsg("could not parse setting for parameter \"%s\"",
6385 : : name)));
548 6386 : 0 : pfree(name);
579 6387 : 0 : continue;
6388 : : }
6389 : :
248 jdavis@postgresql.or 6390 :GNC 18664 : *names = lappend(*names, name);
6391 : 18664 : *values = lappend(*values, value);
6392 : :
6393 : 18664 : pfree(s);
6394 : : }
6395 : 3152 : }
6396 : :
6397 : :
6398 : : /*
6399 : : * Handle options fetched from pg_db_role_setting.setconfig,
6400 : : * pg_proc.proconfig, etc. Caller must specify proper context/source/action.
6401 : : *
6402 : : * The array parameter must be an array of TEXT (it must not be NULL).
6403 : : */
6404 : : void
6405 : 3127 : ProcessGUCArray(ArrayType *array,
6406 : : GucContext context, GucSource source, GucAction action)
6407 : : {
6408 : : List *gucNames;
6409 : : List *gucValues;
6410 : : ListCell *lc1;
6411 : : ListCell *lc2;
6412 : :
6413 : 3127 : TransformGUCArray(array, &gucNames, &gucValues);
6414 [ + - + + : 21760 : forboth(lc1, gucNames, lc2, gucValues)
+ - + + +
+ + - +
+ ]
6415 : : {
247 michael@paquier.xyz 6416 : 18639 : char *name = lfirst(lc1);
6417 : 18639 : char *value = lfirst(lc2);
6418 : :
333 akorotkov@postgresql 6419 :CBC 18639 : (void) set_config_option(name, value,
6420 : : context, source,
6421 : : action, true, 0, false);
6422 : :
548 tgl@sss.pgh.pa.us 6423 : 18633 : pfree(name);
6424 : 18633 : pfree(value);
6425 : : }
6426 : :
248 jdavis@postgresql.or 6427 :GNC 3121 : list_free(gucNames);
6428 : 3121 : list_free(gucValues);
1888 michael@paquier.xyz 6429 :CBC 3121 : }
6430 : :
6431 : :
6432 : : /*
6433 : : * Add an entry to an option array. The array parameter may be NULL
6434 : : * to indicate the current table entry is NULL.
6435 : : */
6436 : : ArrayType *
333 akorotkov@postgresql 6437 : 606 : GUCArrayAdd(ArrayType *array, const char *name, const char *value)
6438 : : {
6439 : : struct config_generic *record;
6440 : : Datum datum;
6441 : : char *newval;
6442 : : ArrayType *a;
6443 : :
579 tgl@sss.pgh.pa.us 6444 [ - + ]: 606 : Assert(name);
6445 [ - + ]: 606 : Assert(value);
6446 : :
6447 : : /* test if the option is valid and we're allowed to set it */
333 akorotkov@postgresql 6448 : 606 : (void) validate_option_array_item(name, value, false);
6449 : :
6450 : : /* normalize name (converts obsolete GUC names to modern spellings) */
579 tgl@sss.pgh.pa.us 6451 : 605 : record = find_option(name, false, true, WARNING);
6452 [ + - ]: 605 : if (record)
6453 : 605 : name = record->name;
6454 : :
6455 : : /* build new item for array */
6456 : 605 : newval = psprintf("%s=%s", name, value);
6457 : 605 : datum = CStringGetTextDatum(newval);
6458 : :
6459 [ + + ]: 605 : if (array)
6460 : : {
6461 : : int index;
6462 : : bool isnull;
6463 : : int i;
6464 : :
6465 [ - + ]: 470 : Assert(ARR_ELEMTYPE(array) == TEXTOID);
6466 [ - + ]: 470 : Assert(ARR_NDIM(array) == 1);
6467 [ - + ]: 470 : Assert(ARR_LBOUND(array)[0] == 1);
6468 : :
6469 : 470 : index = ARR_DIMS(array)[0] + 1; /* add after end */
6470 : :
6471 [ + + ]: 1847 : for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6472 : : {
6473 : : Datum d;
6474 : : char *current;
6475 : :
6476 : 1384 : d = array_ref(array, 1, &i,
6477 : : -1 /* varlenarray */ ,
6478 : : -1 /* TEXT's typlen */ ,
6479 : : false /* TEXT's typbyval */ ,
6480 : : TYPALIGN_INT /* TEXT's typalign */ ,
6481 : : &isnull);
6482 [ - + ]: 1384 : if (isnull)
579 tgl@sss.pgh.pa.us 6483 :UBC 0 : continue;
579 tgl@sss.pgh.pa.us 6484 :CBC 1384 : current = TextDatumGetCString(d);
6485 : :
6486 : : /* check for match up through and including '=' */
6487 [ + + ]: 1384 : if (strncmp(current, newval, strlen(name) + 1) == 0)
6488 : : {
6489 : 7 : index = i;
6490 : 7 : break;
6491 : : }
6492 : : }
6493 : :
6494 : 470 : a = array_set(array, 1, &index,
6495 : : datum,
6496 : : false,
6497 : : -1 /* varlena array */ ,
6498 : : -1 /* TEXT's typlen */ ,
6499 : : false /* TEXT's typbyval */ ,
6500 : : TYPALIGN_INT /* TEXT's typalign */ );
6501 : : }
6502 : : else
6503 : 135 : a = construct_array_builtin(&datum, 1, TEXTOID);
6504 : :
6505 : 605 : return a;
6506 : : }
6507 : :
6508 : :
6509 : : /*
6510 : : * Delete an entry from an option array. The array parameter may be NULL
6511 : : * to indicate the current table entry is NULL. Also, if the return value
6512 : : * is NULL then a null should be stored.
6513 : : */
6514 : : ArrayType *
333 akorotkov@postgresql 6515 : 11 : GUCArrayDelete(ArrayType *array, const char *name)
6516 : : {
6517 : : struct config_generic *record;
6518 : : ArrayType *newarray;
6519 : : int i;
6520 : : int index;
6521 : :
579 tgl@sss.pgh.pa.us 6522 [ - + ]: 11 : Assert(name);
6523 : :
6524 : : /* test if the option is valid and we're allowed to set it */
333 akorotkov@postgresql 6525 : 11 : (void) validate_option_array_item(name, NULL, false);
6526 : :
6527 : : /* normalize name (converts obsolete GUC names to modern spellings) */
579 tgl@sss.pgh.pa.us 6528 : 11 : record = find_option(name, false, true, WARNING);
6529 [ + - ]: 11 : if (record)
6530 : 11 : name = record->name;
6531 : :
6532 : : /* if array is currently null, then surely nothing to delete */
6533 [ - + ]: 11 : if (!array)
579 tgl@sss.pgh.pa.us 6534 :UBC 0 : return NULL;
6535 : :
579 tgl@sss.pgh.pa.us 6536 :CBC 11 : newarray = NULL;
6537 : 11 : index = 1;
6538 : :
6539 [ + + ]: 23 : for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6540 : : {
6541 : : Datum d;
6542 : : char *val;
6543 : : bool isnull;
6544 : :
6545 : 12 : d = array_ref(array, 1, &i,
6546 : : -1 /* varlenarray */ ,
6547 : : -1 /* TEXT's typlen */ ,
6548 : : false /* TEXT's typbyval */ ,
6549 : : TYPALIGN_INT /* TEXT's typalign */ ,
6550 : : &isnull);
6551 [ - + ]: 12 : if (isnull)
579 tgl@sss.pgh.pa.us 6552 :UBC 0 : continue;
579 tgl@sss.pgh.pa.us 6553 :CBC 12 : val = TextDatumGetCString(d);
6554 : :
6555 : : /* ignore entry if it's what we want to delete */
6556 [ + + ]: 12 : if (strncmp(val, name, strlen(name)) == 0
6557 [ + - ]: 11 : && val[strlen(name)] == '=')
6558 : 11 : continue;
6559 : :
6560 : : /* else add it to the output array */
6561 [ - + ]: 1 : if (newarray)
579 tgl@sss.pgh.pa.us 6562 :UBC 0 : newarray = array_set(newarray, 1, &index,
6563 : : d,
6564 : : false,
6565 : : -1 /* varlenarray */ ,
6566 : : -1 /* TEXT's typlen */ ,
6567 : : false /* TEXT's typbyval */ ,
6568 : : TYPALIGN_INT /* TEXT's typalign */ );
6569 : : else
579 tgl@sss.pgh.pa.us 6570 :CBC 1 : newarray = construct_array_builtin(&d, 1, TEXTOID);
6571 : :
6572 : 1 : index++;
6573 : : }
6574 : :
6575 : 11 : return newarray;
6576 : : }
6577 : :
6578 : :
6579 : : /*
6580 : : * Given a GUC array, delete all settings from it that our permission
6581 : : * level allows: if superuser, delete them all; if regular user, only
6582 : : * those that are PGC_USERSET or we have permission to set
6583 : : */
6584 : : ArrayType *
333 akorotkov@postgresql 6585 : 1 : GUCArrayReset(ArrayType *array)
6586 : : {
6587 : : ArrayType *newarray;
6588 : : int i;
6589 : : int index;
6590 : :
6591 : : /* if array is currently null, nothing to do */
579 tgl@sss.pgh.pa.us 6592 [ - + ]: 1 : if (!array)
579 tgl@sss.pgh.pa.us 6593 :UBC 0 : return NULL;
6594 : :
6595 : : /* if we're superuser, we can delete everything, so just do it */
579 tgl@sss.pgh.pa.us 6596 [ - + ]:CBC 1 : if (superuser())
579 tgl@sss.pgh.pa.us 6597 :UBC 0 : return NULL;
6598 : :
579 tgl@sss.pgh.pa.us 6599 :CBC 1 : newarray = NULL;
6600 : 1 : index = 1;
6601 : :
6602 [ + + ]: 3 : for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6603 : : {
6604 : : Datum d;
6605 : : char *val;
6606 : : char *eqsgn;
6607 : : bool isnull;
6608 : :
6609 : 2 : d = array_ref(array, 1, &i,
6610 : : -1 /* varlenarray */ ,
6611 : : -1 /* TEXT's typlen */ ,
6612 : : false /* TEXT's typbyval */ ,
6613 : : TYPALIGN_INT /* TEXT's typalign */ ,
6614 : : &isnull);
6615 [ - + ]: 2 : if (isnull)
579 tgl@sss.pgh.pa.us 6616 :UBC 0 : continue;
579 tgl@sss.pgh.pa.us 6617 :CBC 2 : val = TextDatumGetCString(d);
6618 : :
6619 : 2 : eqsgn = strchr(val, '=');
6620 : 2 : *eqsgn = '\0';
6621 : :
6622 : : /* skip if we have permission to delete it */
333 akorotkov@postgresql 6623 [ + + ]: 2 : if (validate_option_array_item(val, NULL, true))
579 tgl@sss.pgh.pa.us 6624 : 1 : continue;
6625 : :
6626 : : /* else add it to the output array */
6627 [ - + ]: 1 : if (newarray)
579 tgl@sss.pgh.pa.us 6628 :UBC 0 : newarray = array_set(newarray, 1, &index,
6629 : : d,
6630 : : false,
6631 : : -1 /* varlenarray */ ,
6632 : : -1 /* TEXT's typlen */ ,
6633 : : false /* TEXT's typbyval */ ,
6634 : : TYPALIGN_INT /* TEXT's typalign */ );
6635 : : else
579 tgl@sss.pgh.pa.us 6636 :CBC 1 : newarray = construct_array_builtin(&d, 1, TEXTOID);
6637 : :
6638 : 1 : index++;
6639 : 1 : pfree(val);
6640 : : }
6641 : :
6642 : 1 : return newarray;
6643 : : }
6644 : :
6645 : : /*
6646 : : * Validate a proposed option setting for GUCArrayAdd/Delete/Reset.
6647 : : *
6648 : : * name is the option name. value is the proposed value for the Add case,
6649 : : * or NULL for the Delete/Reset cases. If skipIfNoPermissions is true, it's
6650 : : * not an error to have no permissions to set the option.
6651 : : *
6652 : : * Returns true if OK, false if skipIfNoPermissions is true and user does not
6653 : : * have permission to change this option (all other error cases result in an
6654 : : * error being thrown).
6655 : : */
6656 : : static bool
333 akorotkov@postgresql 6657 : 619 : validate_option_array_item(const char *name, const char *value,
6658 : : bool skipIfNoPermissions)
6659 : :
6660 : : {
6661 : : struct config_generic *gconf;
6662 : :
6663 : : /*
6664 : : * There are three cases to consider:
6665 : : *
6666 : : * name is a known GUC variable. Check the value normally, check
6667 : : * permissions normally (i.e., allow if variable is USERSET, or if it's
6668 : : * SUSET and user is superuser or holds ACL_SET permissions).
6669 : : *
6670 : : * name is not known, but exists or can be created as a placeholder (i.e.,
6671 : : * it has a valid custom name). We allow this case if you're a superuser,
6672 : : * otherwise not. Superusers are assumed to know what they're doing. We
6673 : : * can't allow it for other users, because when the placeholder is
6674 : : * resolved it might turn out to be a SUSET variable. (With currently
6675 : : * available infrastructure, we can actually handle such cases within the
6676 : : * current session --- but once an entry is made in pg_db_role_setting,
6677 : : * it's assumed to be fully validated.)
6678 : : *
6679 : : * name is not known and can't be created as a placeholder. Throw error,
6680 : : * unless skipIfNoPermissions is true, in which case return false.
6681 : : */
579 tgl@sss.pgh.pa.us 6682 : 619 : gconf = find_option(name, true, skipIfNoPermissions, ERROR);
6683 [ - + ]: 619 : if (!gconf)
6684 : : {
6685 : : /* not known, failed to make a placeholder */
579 tgl@sss.pgh.pa.us 6686 :UBC 0 : return false;
6687 : : }
6688 : :
579 tgl@sss.pgh.pa.us 6689 [ - + ]:CBC 619 : if (gconf->flags & GUC_CUSTOM_PLACEHOLDER)
6690 : : {
6691 : : /*
6692 : : * We cannot do any meaningful check on the value, so only permissions
6693 : : * are useful to check.
6694 : : */
579 tgl@sss.pgh.pa.us 6695 [ # # # # ]:UBC 0 : if (superuser() ||
6696 : 0 : pg_parameter_aclcheck(name, GetUserId(), ACL_SET) == ACLCHECK_OK)
6697 : 0 : return true;
6698 [ # # ]: 0 : if (skipIfNoPermissions)
1967 peter_e@gmx.net 6699 : 0 : return false;
579 tgl@sss.pgh.pa.us 6700 [ # # ]: 0 : ereport(ERROR,
6701 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
6702 : : errmsg("permission denied to set parameter \"%s\"", name)));
6703 : : }
6704 : :
6705 : : /* manual permissions check so we can avoid an error being thrown */
579 tgl@sss.pgh.pa.us 6706 [ + + ]:CBC 619 : if (gconf->context == PGC_USERSET)
6707 : : /* ok */ ;
6708 [ + - + + ]: 192 : else if (gconf->context == PGC_SUSET &&
6709 [ + + ]: 102 : (superuser() ||
6710 : 6 : pg_parameter_aclcheck(name, GetUserId(), ACL_SET) == ACLCHECK_OK))
6711 : : /* ok */ ;
6712 [ + + ]: 2 : else if (skipIfNoPermissions)
6713 : 1 : return false;
6714 : : /* if a permissions error should be thrown, let set_config_option do it */
6715 : :
6716 : : /* test for permissions and valid option value */
6717 [ + + ]: 618 : (void) set_config_option(name, value,
6718 : 618 : superuser() ? PGC_SUSET : PGC_USERSET,
6719 : : PGC_S_TEST, GUC_ACTION_SET, false, 0, false);
6720 : :
1967 peter_e@gmx.net 6721 : 617 : return true;
6722 : : }
6723 : :
6724 : :
6725 : : /*
6726 : : * Called by check_hooks that want to override the normal
6727 : : * ERRCODE_INVALID_PARAMETER_VALUE SQLSTATE for check hook failures.
6728 : : *
6729 : : * Note that GUC_check_errmsg() etc are just macros that result in a direct
6730 : : * assignment to the associated variables. That is ugly, but forced by the
6731 : : * limitations of C's macro mechanisms.
6732 : : */
6733 : : void
579 tgl@sss.pgh.pa.us 6734 : 19 : GUC_check_errcode(int sqlerrcode)
6735 : : {
6736 : 19 : GUC_check_errcode_value = sqlerrcode;
1967 peter_e@gmx.net 6737 : 19 : }
6738 : :
6739 : :
6740 : : /*
6741 : : * Convenience functions to manage calling a variable's check_hook.
6742 : : * These mostly take care of the protocol for letting check hooks supply
6743 : : * portions of the error report on failure.
6744 : : */
6745 : :
6746 : : static bool
579 tgl@sss.pgh.pa.us 6747 : 181012 : call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra,
6748 : : GucSource source, int elevel)
6749 : : {
6750 : : /* Quick success if no hook */
6751 [ + + ]: 181012 : if (!conf->check_hook)
6752 : 164741 : return true;
6753 : :
6754 : : /* Reset variables that might be set by hook */
6755 : 16271 : GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6756 : 16271 : GUC_check_errmsg_string = NULL;
6757 : 16271 : GUC_check_errdetail_string = NULL;
6758 : 16271 : GUC_check_errhint_string = NULL;
6759 : :
6760 [ + + ]: 16271 : if (!conf->check_hook(newval, extra, source))
6761 : : {
6762 [ + - + - : 12 : ereport(elevel,
- + - + ]
6763 : : (errcode(GUC_check_errcode_value),
6764 : : GUC_check_errmsg_string ?
6765 : : errmsg_internal("%s", GUC_check_errmsg_string) :
6766 : : errmsg("invalid value for parameter \"%s\": %d",
6767 : : conf->gen.name, (int) *newval),
6768 : : GUC_check_errdetail_string ?
6769 : : errdetail_internal("%s", GUC_check_errdetail_string) : 0,
6770 : : GUC_check_errhint_string ?
6771 : : errhint("%s", GUC_check_errhint_string) : 0));
6772 : : /* Flush any strings created in ErrorContext */
579 tgl@sss.pgh.pa.us 6773 :UBC 0 : FlushErrorState();
6774 : 0 : return false;
6775 : : }
6776 : :
1967 peter_e@gmx.net 6777 :CBC 16259 : return true;
6778 : : }
6779 : :
6780 : : static bool
579 tgl@sss.pgh.pa.us 6781 : 184460 : call_int_check_hook(struct config_int *conf, int *newval, void **extra,
6782 : : GucSource source, int elevel)
6783 : : {
6784 : : /* Quick success if no hook */
6785 [ + + ]: 184460 : if (!conf->check_hook)
6786 : 151589 : return true;
6787 : :
6788 : : /* Reset variables that might be set by hook */
6789 : 32871 : GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6790 : 32871 : GUC_check_errmsg_string = NULL;
6791 : 32871 : GUC_check_errdetail_string = NULL;
6792 : 32871 : GUC_check_errhint_string = NULL;
6793 : :
6794 [ - + ]: 32871 : if (!conf->check_hook(newval, extra, source))
6795 : : {
579 tgl@sss.pgh.pa.us 6796 [ # # # # :UBC 0 : ereport(elevel,
# # # # ]
6797 : : (errcode(GUC_check_errcode_value),
6798 : : GUC_check_errmsg_string ?
6799 : : errmsg_internal("%s", GUC_check_errmsg_string) :
6800 : : errmsg("invalid value for parameter \"%s\": %d",
6801 : : conf->gen.name, *newval),
6802 : : GUC_check_errdetail_string ?
6803 : : errdetail_internal("%s", GUC_check_errdetail_string) : 0,
6804 : : GUC_check_errhint_string ?
6805 : : errhint("%s", GUC_check_errhint_string) : 0));
6806 : : /* Flush any strings created in ErrorContext */
6807 : 0 : FlushErrorState();
6808 : 0 : return false;
6809 : : }
6810 : :
1967 peter_e@gmx.net 6811 :CBC 32871 : return true;
6812 : : }
6813 : :
6814 : : static bool
579 tgl@sss.pgh.pa.us 6815 : 27191 : call_real_check_hook(struct config_real *conf, double *newval, void **extra,
6816 : : GucSource source, int elevel)
6817 : : {
6818 : : /* Quick success if no hook */
6819 [ + + ]: 27191 : if (!conf->check_hook)
6820 : 26263 : return true;
6821 : :
6822 : : /* Reset variables that might be set by hook */
6823 : 928 : GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6824 : 928 : GUC_check_errmsg_string = NULL;
6825 : 928 : GUC_check_errdetail_string = NULL;
6826 : 928 : GUC_check_errhint_string = NULL;
6827 : :
6828 [ - + ]: 928 : if (!conf->check_hook(newval, extra, source))
6829 : : {
579 tgl@sss.pgh.pa.us 6830 [ # # # # :UBC 0 : ereport(elevel,
# # # # ]
6831 : : (errcode(GUC_check_errcode_value),
6832 : : GUC_check_errmsg_string ?
6833 : : errmsg_internal("%s", GUC_check_errmsg_string) :
6834 : : errmsg("invalid value for parameter \"%s\": %g",
6835 : : conf->gen.name, *newval),
6836 : : GUC_check_errdetail_string ?
6837 : : errdetail_internal("%s", GUC_check_errdetail_string) : 0,
6838 : : GUC_check_errhint_string ?
6839 : : errhint("%s", GUC_check_errhint_string) : 0));
6840 : : /* Flush any strings created in ErrorContext */
6841 : 0 : FlushErrorState();
1967 peter_e@gmx.net 6842 : 0 : return false;
6843 : : }
6844 : :
1967 peter_e@gmx.net 6845 :CBC 928 : return true;
6846 : : }
6847 : :
6848 : : static bool
579 tgl@sss.pgh.pa.us 6849 : 343169 : call_string_check_hook(struct config_string *conf, char **newval, void **extra,
6850 : : GucSource source, int elevel)
6851 : : {
6852 : 343169 : volatile bool result = true;
6853 : :
6854 : : /* Quick success if no hook */
6855 [ + + ]: 343169 : if (!conf->check_hook)
6856 : 58558 : return true;
6857 : :
6858 : : /*
6859 : : * If elevel is ERROR, or if the check_hook itself throws an elog
6860 : : * (undesirable, but not always avoidable), make sure we don't leak the
6861 : : * already-malloc'd newval string.
6862 : : */
6863 [ + + ]: 284611 : PG_TRY();
6864 : : {
6865 : : /* Reset variables that might be set by hook */
6866 : 284611 : GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6867 : 284611 : GUC_check_errmsg_string = NULL;
6868 : 284611 : GUC_check_errdetail_string = NULL;
6869 : 284611 : GUC_check_errhint_string = NULL;
6870 : :
6871 [ + + ]: 284611 : if (!conf->check_hook(newval, extra, source))
6872 : : {
6873 [ + - + + : 18 : ereport(elevel,
+ - + + -
+ ]
6874 : : (errcode(GUC_check_errcode_value),
6875 : : GUC_check_errmsg_string ?
6876 : : errmsg_internal("%s", GUC_check_errmsg_string) :
6877 : : errmsg("invalid value for parameter \"%s\": \"%s\"",
6878 : : conf->gen.name, *newval ? *newval : ""),
6879 : : GUC_check_errdetail_string ?
6880 : : errdetail_internal("%s", GUC_check_errdetail_string) : 0,
6881 : : GUC_check_errhint_string ?
6882 : : errhint("%s", GUC_check_errhint_string) : 0));
6883 : : /* Flush any strings created in ErrorContext */
579 tgl@sss.pgh.pa.us 6884 :UBC 0 : FlushErrorState();
6885 : 0 : result = false;
6886 : : }
6887 : : }
579 tgl@sss.pgh.pa.us 6888 :CBC 21 : PG_CATCH();
6889 : : {
548 6890 : 21 : guc_free(*newval);
579 6891 : 21 : PG_RE_THROW();
6892 : : }
6893 [ - + ]: 284590 : PG_END_TRY();
6894 : :
6895 : 284590 : return result;
6896 : : }
6897 : :
6898 : : static bool
6899 : 75112 : call_enum_check_hook(struct config_enum *conf, int *newval, void **extra,
6900 : : GucSource source, int elevel)
6901 : : {
6902 : : /* Quick success if no hook */
6903 [ + + ]: 75112 : if (!conf->check_hook)
6904 : 66365 : return true;
6905 : :
6906 : : /* Reset variables that might be set by hook */
6907 : 8747 : GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
6908 : 8747 : GUC_check_errmsg_string = NULL;
6909 : 8747 : GUC_check_errdetail_string = NULL;
6910 : 8747 : GUC_check_errhint_string = NULL;
6911 : :
6912 [ + + ]: 8747 : if (!conf->check_hook(newval, extra, source))
6913 : : {
6914 [ + - + - : 1 : ereport(elevel,
- + - + ]
6915 : : (errcode(GUC_check_errcode_value),
6916 : : GUC_check_errmsg_string ?
6917 : : errmsg_internal("%s", GUC_check_errmsg_string) :
6918 : : errmsg("invalid value for parameter \"%s\": \"%s\"",
6919 : : conf->gen.name,
6920 : : config_enum_lookup_by_value(conf, *newval)),
6921 : : GUC_check_errdetail_string ?
6922 : : errdetail_internal("%s", GUC_check_errdetail_string) : 0,
6923 : : GUC_check_errhint_string ?
6924 : : errhint("%s", GUC_check_errhint_string) : 0));
6925 : : /* Flush any strings created in ErrorContext */
579 tgl@sss.pgh.pa.us 6926 :UBC 0 : FlushErrorState();
1917 andres@anarazel.de 6927 : 0 : return false;
6928 : : }
6929 : :
1917 andres@anarazel.de 6930 :CBC 8746 : return true;
6931 : : }
|
