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