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