| blob | 99854be4394fb502b64936e3577e7bf65ddbb32c |
1 /*--------------------------------------------------------------------
2 * guc.c
3 *
4 * Support for grand unified configuration scheme, including SET
5 * command, configuration file, and command line options.
6 *
7 * This file contains the generic option processing infrastructure.
8 * guc_funcs.c contains SQL-level functionality, including SET/SHOW
9 * commands and various system-administration SQL functions.
10 * guc_tables.c contains the arrays that define all the built-in
11 * GUC variables. Code that implements variable-specific behavior
12 * is scattered around the system in check, assign, and show hooks.
13 *
14 * See src/backend/utils/misc/README for more information.
15 *
16 *
17 * Copyright (c) 2000-2024, PostgreSQL Global Development Group
18 * Written by Peter Eisentraut <peter_e@gmx.net>.
19 *
20 * IDENTIFICATION
21 * src/backend/utils/misc/guc.c
22 *
23 *--------------------------------------------------------------------
24 */
27 #include <limits.h>
28 #include <math.h>
29 #include <sys/stat.h>
30 #include <unistd.h>
59 #ifdef EXEC_BACKEND
62 #endif
64 /*
65 * Precision with which REAL type guc values are to be printed for GUC
66 * serialization.
67 */
68 #define REALTYPE_PRECISION 17
70 /*
71 * Safe search path when executing code as the table owner, such as during
72 * maintenance operations.
73 */
80 /* global variables for check hook support */
85 /* Kluge: for speed, we examine this GUC variable's value directly */
89 /*
90 * Unit conversion tables.
91 *
92 * There are two tables, one for memory units, and another for time units.
93 * For each supported conversion from one unit to another, we have an entry
94 * in the table.
95 *
96 * To keep things simple, and to avoid possible roundoff error,
97 * conversions are never chained. There needs to be a direct conversion
98 * between all units (of the same type).
99 *
100 * The conversions for each base unit must be kept in order from greatest to
101 * smallest human-friendly unit; convert_xxx_from_base_unit() rely on that.
102 * (The order of the base-unit groups does not matter.)
103 */
107 {
109 * "min" */
114 /* Ensure that the constants in the tables don't overflow or underflow */
115 #if BLCKSZ < 1024 || BLCKSZ > (1024*1024)
116 #error BLCKSZ must be between 1KB and 1MB
117 #endif
118 #if XLOG_BLCKSZ < 1024 || XLOG_BLCKSZ > (1024*1024)
119 #error XLOG_BLCKSZ must be between 1KB and 1MB
120 #endif
122 static const char *const memory_units_hint = gettext_noop("Valid units for this parameter are \"B\", \"kB\", \"MB\", \"GB\", and \"TB\".");
125 {
157 };
159 static const char *const time_units_hint = gettext_noop("Valid units for this parameter are \"us\", \"ms\", \"s\", \"min\", \"h\", and \"d\".");
162 {
185 };
187 /*
188 * To allow continued support of obsolete names for GUC variables, we apply
189 * the following mappings to any unrecognized name. Note that an old name
190 * should be mapped to a new one only if the new variable has very similar
191 * semantics to the old.
192 */
196 NULL
197 };
200 /* Memory context holding all GUC-related data */
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 */
209 {
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 */
225 * different from PGC_S_DEFAULT */
227 * stack */
229 * GUC_NEEDS_REPORT bit set in status */
253 Oid cursrole);
276 /*
277 * This function handles both actual config file (re)loads and execution of
278 * show_all_file_settings() (i.e., the pg_file_settings view). In the latter
279 * case we don't apply any of the settings, but we make all the usual validity
280 * checks, and we return the ConfigVariable list so that it can be printed out
281 * by show_all_file_settings().
282 */
283 ConfigVariable *
285 {
292 HASH_SEQ_STATUS status;
295 /* Parse the main config file into a list of option names and values */
302 {
303 /* Syntax error(s) detected in the file, so bail out */
306 }
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 */
315 {
319 {
320 /* Syntax error(s) detected in the file, so 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 */
338 /*
339 * Prune all items except the last "data_directory" from the list.
340 */
342 {
346 }
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 */
361 }
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 */
370 {
374 }
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 */
390 {
393 /* Ignore anything already marked as ignorable */
397 /*
398 * Try to find the variable; but do not create a custom placeholder if
399 * it's not there already.
400 */
404 {
405 /* If it's already marked, then this is a duplicate entry */
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 */
416 {
420 }
421 }
422 /* Now mark it as present in file */
424 }
426 {
427 /* Invalid non-custom variable, so complain */
436 }
437 }
439 /*
440 * If we've detected any errors so far, we don't want to risk applying any
441 * changes.
442 */
446 /* Otherwise, set flag that we're beginning to apply changes */
449 /*
450 * Check for variables having been removed from the config file, and
451 * revert their reset values (and perhaps also effective values) to the
452 * boot-time defaults. If such a variable can't be changed after startup,
453 * report that and continue.
454 */
457 {
465 {
466 /* The removal can't be effective without a restart */
472 record_config_file_error(psprintf("parameter \"%s\" cannot be changed without restarting the server",
478 }
480 /* No more to do if we're just doing show_all_file_settings() */
484 /*
485 * Reset any "file" sources to "default", else set_config_option will
486 * not override those settings.
487 */
493 {
496 }
498 /* Now we can re-apply the wired-in default (i.e., the boot_val) */
502 {
503 /* Log the change if appropriate */
508 }
509 }
511 /*
512 * Restore any variables determined by environment variables or
513 * dynamically-computed defaults. This is a no-op except in the case
514 * where one of these had been in the config file and is now removed.
515 *
516 * In particular, we *must not* do this during the postmaster's initial
517 * loading of the file, since the timezone functions in particular should
518 * be run only after initialization is complete.
519 *
520 * XXX this is an unmaintainable crock, because we have to know how to set
521 * (or at least what to call to set) every non-PGC_INTERNAL variable that
522 * could potentially have PGC_S_DYNAMIC_DEFAULT or PGC_S_ENV_VAR source.
523 */
525 {
528 /* this selects SQL_ASCII in processes not connected to a database */
531 }
533 /*
534 * Now apply the values from the config file.
535 */
537 {
541 /* Ignore anything marked as ignorable */
545 /* In SIGHUP cases in the postmaster, we want to report changes */
547 {
550 /* If option doesn't exist yet or is NULL, treat as empty string */
553 /* must dup, else might have dangling pointer below */
555 }
561 {
562 /* variable was updated, so log the change if appropriate */
564 {
573 }
575 }
577 {
581 }
582 else
583 {
584 /* no error, but variable's active value was not changed */
586 }
588 /*
589 * We should update source location unless there was an error, since
590 * even if the active value didn't change, the reset value might have.
591 * (In the postmaster, there won't be a difference, but it does matter
592 * in backends.)
593 */
600 }
602 /* Remember when we last successfully loaded the config file. */
606 bail_out:
608 {
609 /* During postmaster startup, any error is fatal */
614 ConfFileWithError)));
619 ConfFileWithError)));
620 else
624 ConfFileWithError)));
625 }
627 /* Successful or otherwise, return the collected data list */
629 }
632 /*
633 * Some infrastructure for GUC-related memory allocation
634 *
635 * These functions are generally modeled on libc's malloc/realloc/etc,
636 * but any OOM issue is reported at the specified elevel.
637 * (Thus, control returns only if that's less than ERROR.)
638 */
641 {
645 MCXT_ALLOC_NO_OOM);
651 }
655 {
659 {
660 /* This is to help catch old code that malloc's GUC data. */
663 MCXT_ALLOC_NO_OOM);
664 }
665 else
666 {
667 /* Like realloc(3), but not like repalloc(), we allow old == NULL. */
669 MCXT_ALLOC_NO_OOM);
670 }
676 }
680 {
688 }
690 void
692 {
693 /*
694 * Historically, GUC-related code has relied heavily on the ability to do
695 * free(NULL), so we allow that here even though pfree() doesn't.
696 */
698 {
699 /* This is to help catch old code that malloc's GUC data. */
702 }
703 }
706 /*
707 * Detect whether strval is referenced anywhere in a GUC string item
708 */
709 static bool
711 {
719 {
723 }
725 }
727 /*
728 * Support for assigning to a field of a string GUC item. Free the prior
729 * value if it's not referenced anywhere else in the item (including stacked
730 * states).
731 */
732 static void
734 {
737 /* Do the assignment */
740 /* Free old value if it's not NULL and isn't referenced anymore */
743 }
745 /*
746 * Detect whether an "extra" struct is referenced anywhere in a GUC item
747 */
748 static bool
750 {
756 {
777 }
779 {
783 }
786 }
788 /*
789 * Support for assigning to an "extra" field of a GUC item. Free the prior
790 * value if it's not referenced anywhere else in the item (including stacked
791 * states).
792 */
793 static void
795 {
798 /* Do the assignment */
801 /* Free old value if it's not NULL and isn't referenced anymore */
804 }
806 /*
807 * Support for copying a variable's active value into a stack entry.
808 * The "extra" field associated with the active value is copied, too.
809 *
810 * NB: be sure stringval and extra fields of a new stack entry are
811 * initialized to NULL before this is used, else we'll try to guc_free() them.
812 */
813 static void
815 {
817 {
839 }
841 }
843 /*
844 * Support for discarding a no-longer-needed value in a stack entry.
845 * The "extra" field associated with the stack entry is cleared, too.
846 */
847 static void
849 {
851 {
856 /* no need to do anything */
861 NULL);
863 }
865 }
868 /*
869 * Fetch a palloc'd, sorted array of GUC struct pointers
870 *
871 * The array length is returned into *num_vars.
872 */
875 {
877 HASH_SEQ_STATUS status;
884 /* Extract pointers from the hash table */
891 /* Sort by name */
896 }
899 /*
900 * Build the GUC hash table. This is split out so that help_config.c can
901 * extract all the variables without running all of InitializeGUCOptions.
902 * It's not meant for use anyplace else.
903 */
904 void
906 {
909 HASHCTL hash_ctl;
914 /*
915 * Create the memory context that will hold all GUC-related data.
916 */
920 ALLOCSET_DEFAULT_SIZES);
922 /*
923 * Count all the built-in variables, and set their vartypes correctly.
924 */
926 {
929 /* Rather than requiring vartype to be filled in by hand, do this: */
931 num_vars++;
932 }
935 {
939 num_vars++;
940 }
943 {
947 num_vars++;
948 }
951 {
955 num_vars++;
956 }
959 {
963 num_vars++;
964 }
966 /*
967 * Create hash table with 20% slack
968 */
977 size_vars,
982 {
987 HASH_ENTER,
991 }
994 {
999 HASH_ENTER,
1003 }
1006 {
1011 HASH_ENTER,
1015 }
1018 {
1023 HASH_ENTER,
1027 }
1030 {
1035 HASH_ENTER,
1039 }
1042 }
1044 /*
1045 * Add a new GUC variable to the hash of known variables. The
1046 * hash is expanded if needed.
1047 */
1048 static bool
1050 {
1056 HASH_ENTER_NULL,
1059 {
1064 }
1068 }
1070 /*
1071 * Decide whether a proposed custom variable name is allowed.
1072 *
1073 * It must be two or more identifiers separated by dots, where the rules
1074 * for what is an identifier agree with scan.l. (If you change this rule,
1075 * adjust the errdetail in assignable_custom_variable_name().)
1076 */
1077 static bool
1079 {
1084 {
1086 {
1091 }
1095 {
1096 /* okay as first or non-first character */
1098 }
1101 else
1103 }
1106 /* OK if we found at least one separator */
1108 }
1110 /*
1111 * Decide whether an unrecognized variable name is allowed to be SET.
1112 *
1113 * It must pass the syntactic rules of valid_custom_variable_name(),
1114 * and it must not be in any namespace already reserved by an extension.
1115 * (We make this separate from valid_custom_variable_name() because we don't
1116 * apply the reserved-namespace test when reading configuration files.)
1117 *
1118 * If valid, return true. Otherwise, return false if skip_errors is true,
1119 * else throw a suitable error at the specified elevel (and return false
1120 * if that's less than ERROR).
1121 */
1122 static bool
1124 {
1125 /* If there's no separator, it can't be a custom variable */
1129 {
1133 /* The name must be syntactically acceptable ... */
1135 {
1140 name),
1141 errdetail("Custom parameter names must be two or more simple identifiers separated by dots.")));
1143 }
1144 /* ... and it must not match any previously-reserved prefix */
1146 {
1151 {
1156 name),
1158 rcprefix)));
1160 }
1161 }
1162 /* OK to create it */
1164 }
1166 /* Unrecognized single-part name */
1171 name)));
1173 }
1175 /*
1176 * Create and add a placeholder variable for a custom variable name.
1177 */
1180 {
1193 {
1196 }
1204 /*
1205 * The char* is allocated at the end of the struct since we have no
1206 * 'static' place to point to. Note that the current value, as well as
1207 * the boot and reset values, start out NULL.
1208 */
1212 {
1216 }
1219 }
1221 /*
1222 * Look up option "name". If it exists, return a pointer to its record.
1223 * Otherwise, if create_placeholders is true and name is a valid-looking
1224 * custom variable name, we'll create and return a placeholder record.
1225 * Otherwise, if skip_errors is true, then we silently return NULL for
1226 * an unrecognized or invalid name. Otherwise, the error is reported at
1227 * error level elevel (and we return NULL if that's less than ERROR).
1228 *
1229 * Note: internal errors, primarily out-of-memory, draw an elevel-level
1230 * report and NULL return regardless of skip_errors. Hence, callers must
1231 * handle a NULL return whenever elevel < ERROR, but they should not need
1232 * to emit any additional error message. (In practice, internal errors
1233 * can only happen when create_placeholders is true, so callers passing
1234 * false need not think terribly hard about this.)
1235 */
1239 {
1245 /* Look it up using the hash table. */
1248 HASH_FIND,
1249 NULL);
1253 /*
1254 * See if the name is an obsolete name for a variable. We assume that the
1255 * set of supported old names is short enough that a brute-force search is
1256 * the best way.
1257 */
1259 {
1263 }
1266 {
1267 /*
1268 * Check if the name is valid, and if so, add a placeholder.
1269 */
1272 else
1274 }
1276 /* Unknown name and we're not supposed to make a placeholder */
1281 name)));
1283 }
1286 /*
1287 * comparator for qsorting an array of GUC pointers
1288 */
1289 static int
1291 {
1296 }
1298 /*
1299 * the bare comparison function for GUC names
1300 */
1301 int
1303 {
1304 /*
1305 * The temptation to use strcasecmp() here must be resisted, because the
1306 * hash mapping has to remain stable across setlocale() calls. So, build
1307 * our own with a simple ASCII-only downcasing.
1308 */
1310 {
1320 }
1326 }
1328 /*
1329 * Hash function that's compatible with guc_name_compare
1330 */
1331 static uint32
1333 {
1338 {
1341 /* Case-fold in the same way as guc_name_compare */
1345 /* Merge into hash ... not very bright, but it needn't be */
1348 }
1350 }
1352 /*
1353 * Dynahash match function to use in guc_hashtab
1354 */
1355 static int
1357 {
1362 }
1365 /*
1366 * Convert a GUC name to the form that should be used in pg_parameter_acl.
1367 *
1368 * We need to canonicalize entries since, for example, case should not be
1369 * significant. In addition, we apply the map_old_guc_names[] mapping so that
1370 * any obsolete names will be converted when stored in a new PG version.
1371 * Note however that this function does not verify legality of the name.
1372 *
1373 * The result is a palloc'd string.
1374 */
1377 {
1380 /* Apply old-GUC-name mapping. */
1382 {
1384 {
1387 }
1388 }
1390 /* Apply case-folding that matches guc_name_compare(). */
1393 {
1397 {
1400 }
1401 }
1404 }
1406 /*
1407 * Check whether we should allow creation of a pg_parameter_acl entry
1408 * for the given name. (This can be applied either before or after
1409 * canonicalizing it.) Throws error if not.
1410 */
1411 void
1413 {
1414 /* OK if the GUC exists. */
1417 /* Otherwise, it'd better be a valid custom GUC name. */
1419 }
1421 /*
1422 * Routine in charge of checking various states of a GUC.
1423 *
1424 * This performs two sanity checks. First, it checks that the initial
1425 * value of a GUC is the same when declared and when loaded to prevent
1426 * anybody looking at the C declarations of these GUCs from being fooled by
1427 * mismatched values. Second, it checks for incorrect flag combinations.
1428 *
1429 * The following validation rules apply for the values:
1430 * bool - can be false, otherwise must be same as the boot_val
1431 * int - can be 0, otherwise must be same as the boot_val
1432 * real - can be 0.0, otherwise must be same as the boot_val
1433 * string - can be NULL, otherwise must be strcmp equal to the boot_val
1434 * enum - must be same as the boot_val
1435 */
1436 #ifdef USE_ASSERT_CHECKING
1437 static bool
1439 {
1440 /* Checks on values */
1442 {
1444 {
1448 {
1452 }
1454 }
1456 {
1460 {
1464 }
1466 }
1468 {
1472 {
1476 }
1478 }
1480 {
1486 {
1490 }
1492 }
1494 {
1498 {
1502 }
1504 }
1505 }
1507 /* Flag combinations */
1509 /*
1510 * GUC_NO_SHOW_ALL requires GUC_NOT_IN_SAMPLE, as a parameter not part of
1511 * SHOW ALL should not be hidden in postgresql.conf.sample.
1512 */
1515 {
1519 }
1522 }
1523 #endif
1525 /*
1526 * Initialize GUC options during program startup.
1527 *
1528 * Note that we cannot read the config file yet, since we have not yet
1529 * processed command-line switches.
1530 */
1531 void
1533 {
1534 HASH_SEQ_STATUS status;
1537 /*
1538 * Before log_line_prefix could possibly receive a nonempty setting, make
1539 * sure that timezone processing is minimally alive (see elog.c).
1540 */
1543 /*
1544 * Create GUCMemoryContext and build hash table of all GUC variables.
1545 */
1548 /*
1549 * Load all variables with their compiled-in defaults, and initialize
1550 * status fields as needed.
1551 */
1554 {
1555 /* Check mapping between initial and default value */
1559 }
1563 /*
1564 * Prevent any attempt to override the transaction modes from
1565 * non-interactive sources.
1566 */
1574 /*
1575 * For historical reasons, some GUC parameters can receive defaults from
1576 * environment variables. Process those settings.
1577 */
1579 }
1581 /*
1582 * Assign any GUC values that can come from the server's environment.
1583 *
1584 * This is called from InitializeGUCOptions, and also from ProcessConfigFile
1585 * to deal with the possibility that a setting has been removed from
1586 * postgresql.conf and should now get a value from the environment.
1587 * (The latter is a kludge that should probably go away someday; if so,
1588 * fold this back into InitializeGUCOptions.)
1589 */
1590 static void
1592 {
1608 /*
1609 * rlimit isn't exactly an "environment variable", but it behaves about
1610 * the same. If we can identify the platform stack depth rlimit, increase
1611 * default stack depth setting up to whatever is safe (but at most 2MB).
1612 * Report the value's source as PGC_S_DYNAMIC_DEFAULT if it's 2MB, or as
1613 * PGC_S_ENV_VAR if it's reflecting the rlimit limit.
1614 */
1617 {
1621 {
1622 GucSource source;
1627 else
1628 {
1631 }
1635 }
1636 }
1637 }
1639 /*
1640 * Initialize one GUC option variable to its compiled-in default.
1641 *
1642 * Note: the reason for calling check_hooks is not that we think the boot_val
1643 * might fail, but that the hooks might wish to compute an "extra" struct.
1644 */
1645 static void
1647 {
1662 {
1664 {
1678 }
1680 {
1696 }
1698 {
1714 }
1716 {
1721 /* non-NULL boot_val must always get strdup'd */
1724 else
1736 }
1738 {
1752 }
1753 }
1754 }
1756 /*
1757 * Summarily remove a GUC variable from any linked lists it's in.
1758 *
1759 * We use this in cases where the variable is about to be deleted or reset.
1760 * These aren't common operations, so it's okay if this is a bit slow.
1761 */
1762 static void
1764 {
1771 }
1774 /*
1775 * Select the configuration files and data directory to be used, and
1776 * do the initial read of postgresql.conf.
1777 *
1778 * This is called after processing command-line switches.
1779 * userDoption is the -D switch value if any (NULL if unspecified).
1780 * progname is just for use in error messages.
1781 *
1782 * Returns true on success; on failure, prints a suitable error message
1783 * to stderr and returns false.
1784 */
1785 bool
1787 {
1794 /* configdir is -D option, or $PGDATA if no -D */
1797 else
1801 {
1803 progname,
1804 configdir);
1808 }
1810 /*
1811 * Find the configuration file: if config_file was specified on the
1812 * command line, use it, else use configdir/postgresql.conf. In any case
1813 * ensure the result is an absolute path, so that it will be interpreted
1814 * the same way by future backends.
1815 */
1817 {
1820 }
1822 {
1827 }
1828 else
1829 {
1831 "You must specify the --config-file or -D invocation "
1833 progname);
1835 }
1837 /*
1838 * Set the ConfigFileName GUC variable to its final value, ensuring that
1839 * it can't be overridden later.
1840 */
1845 else
1848 /*
1849 * Now read the config file for the first time.
1850 */
1852 {
1857 }
1859 /*
1860 * Read the configuration file for the first time. This time only the
1861 * data_directory parameter is picked up to determine the data directory,
1862 * so that we can read the PG_AUTOCONF_FILENAME file next time.
1863 */
1866 /*
1867 * If the data_directory GUC variable has been set, use that as DataDir;
1868 * otherwise use configdir if set; else punt.
1869 *
1870 * Note: SetDataDir will copy and absolute-ize its argument, so we don't
1871 * have to.
1872 */
1879 else
1880 {
1883 "or by the -D invocation option, or by the "
1887 }
1889 /*
1890 * Reflect the final DataDir value back into the data_directory GUC var.
1891 * (If you are wondering why we don't just make them a single variable,
1892 * it's because the EXEC_BACKEND case needs DataDir to be transmitted to
1893 * child backends specially. XXX is that still true? Given that we now
1894 * chdir to DataDir, EXEC_BACKEND can read the config file without knowing
1895 * DataDir in advance.)
1896 */
1899 /*
1900 * Now read the config file a second time, allowing any settings in the
1901 * PG_AUTOCONF_FILENAME file to take effect. (This is pretty ugly, but
1902 * since we have to determine the DataDir before we can find the autoconf
1903 * file, the alternatives seem worse.)
1904 */
1907 /*
1908 * If timezone_abbreviations wasn't set in the configuration file, install
1909 * the default value. We do it this way because we can't safely install a
1910 * "real" value until my_exec_path is set, which may not have happened
1911 * when InitializeGUCOptions runs, so the bootstrap default value cannot
1912 * be the real desired default.
1913 */
1916 /*
1917 * Figure out where pg_hba.conf is, and make sure the path is absolute.
1918 */
1920 {
1923 }
1925 {
1930 }
1931 else
1932 {
1935 "or by the -D invocation option, or by the "
1939 }
1944 else
1947 /*
1948 * Likewise for pg_ident.conf.
1949 */
1951 {
1954 }
1956 {
1961 }
1962 else
1963 {
1966 "or by the -D invocation option, or by the "
1970 }
1975 else
1981 }
1983 /*
1984 * pg_timezone_abbrev_initialize --- set default value if not done already
1985 *
1986 * This is called after initial loading of postgresql.conf. If no
1987 * timezone_abbreviations setting was found therein, select default.
1988 * If a non-default value is already installed, nothing will happen.
1989 *
1990 * This can also be called from ProcessConfigFile to establish the default
1991 * value after a postgresql.conf entry for it is removed.
1992 */
1993 static void
1995 {
1998 }
2001 /*
2002 * Reset all options to their saved default values (implements RESET ALL)
2003 */
2004 void
2006 {
2007 dlist_mutable_iter iter;
2009 /* We need only consider GUCs not already at PGC_S_DEFAULT */
2011 {
2015 /* Don't reset non-SET-able values */
2019 /* Don't reset if special exclusion from RESET ALL */
2022 /* No need to reset if wasn't SET */
2026 /* Save old value to support transaction abort */
2030 {
2032 {
2042 }
2044 {
2054 }
2056 {
2066 }
2068 {
2078 }
2080 {
2090 }
2091 }
2098 {
2101 }
2102 }
2103 }
2106 /*
2107 * Apply a change to a GUC variable's "source" field.
2108 *
2109 * Use this rather than just assigning, to ensure that the variable's
2110 * membership in guc_nondef_list is updated correctly.
2111 */
2112 static void
2114 {
2115 /* Adjust nondef list membership if appropriate for change */
2117 {
2120 }
2121 else
2122 {
2125 }
2126 /* Now update the source field */
2128 }
2131 /*
2132 * push_old_value
2133 * Push previous state during transactional assignment to a GUC variable.
2134 */
2135 static void
2137 {
2140 /* If we're not inside a nest level, do nothing */
2144 /* Do we already have a stack entry of the current nest level? */
2147 {
2148 /* Yes, so adjust its state if necessary */
2151 {
2153 /* SET overrides any prior action at same nest level */
2155 {
2156 /* must discard old masked value */
2158 }
2163 {
2164 /* SET followed by SET LOCAL, remember SET's value */
2169 }
2170 /* in all other cases, no change to stack entry */
2173 /* Could only have a prior SAVE of same variable */
2176 }
2178 }
2180 /*
2181 * Push a new stack entry
2182 *
2183 * We keep all the stack entries in TopTransactionContext for simplicity.
2184 */
2191 {
2201 }
2210 }
2213 /*
2214 * Do GUC processing at main transaction start.
2215 */
2216 void
2218 {
2219 /*
2220 * The nest level should be 0 between transactions; if it isn't, somebody
2221 * didn't call AtEOXact_GUC, or called it with the wrong nestLevel. We
2222 * throw a warning but make no other effort to clean up.
2223 */
2226 GUCNestLevel);
2228 }
2230 /*
2231 * Enter a new nesting level for GUC values. This is called at subtransaction
2232 * start, and when entering a function that has proconfig settings, and in
2233 * some other places where we want to set GUC variables transiently.
2234 * NOTE we must not risk error here, else subtransaction start will be unhappy.
2235 */
2236 int
2238 {
2240 }
2242 /*
2243 * Set search_path to a fixed value for maintenance operations. No effect
2244 * during bootstrap, when the search_path is already set to a fixed value and
2245 * cannot be changed.
2246 */
2247 void
2249 {
2253 }
2255 /*
2256 * Do GUC processing at transaction or subtransaction commit or abort, or
2257 * when exiting a function that has proconfig settings, or when undoing a
2258 * transient assignment to some GUC variables. (The name is thus a bit of
2259 * a misnomer; perhaps it should be ExitGUCNestLevel or some such.)
2260 * During abort, we discard all GUC settings that were applied at nesting
2261 * levels >= nestLevel. nestLevel == 1 corresponds to the main transaction.
2262 */
2263 void
2265 {
2266 slist_mutable_iter iter;
2268 /*
2269 * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
2270 * abort, if there is a failure during transaction start before
2271 * AtStart_GUC is called.
2272 */
2277 /* We need only process GUCs having nonempty stacks */
2279 {
2284 /*
2285 * Process and pop each stack entry within the nest level. To simplify
2286 * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
2287 * we allow failure exit from code that uses a local nest level to be
2288 * recovered at the surrounding transaction or subtransaction abort;
2289 * so there could be more than one stack entry to pop.
2290 */
2293 {
2299 /*
2300 * In this next bit, if we don't set either restorePrior or
2301 * restoreMasked, we must "discard" any unwanted fields of the
2302 * stack entries to avoid leaking memory. If we do set one of
2303 * those flags, unused fields will be cleaned up after restoring.
2304 */
2310 {
2311 /* transaction commit */
2315 {
2316 /* we keep the current active value */
2318 }
2321 }
2324 {
2325 /* decrement entry's level and do not pop it */
2328 }
2329 else
2330 {
2331 /*
2332 * We have to merge this stack entry into prev. See README for
2333 * discussion of this bit.
2334 */
2336 {
2342 /* next level always becomes SET */
2351 {
2352 /* LOCAL migrates down */
2357 }
2358 else
2359 {
2360 /* else just forget this stack level */
2362 }
2366 /* prior state at this level no longer wanted */
2368 /* copy down the masked state */
2376 }
2377 }
2382 {
2383 /* Perform appropriate restoration of the stacked value */
2384 config_var_value newvalue;
2385 GucSource newsource;
2386 GucContext newscontext;
2387 Oid newsrole;
2390 {
2395 }
2396 else
2397 {
2402 }
2405 {
2407 {
2414 {
2419 newextra);
2421 }
2423 }
2425 {
2432 {
2437 newextra);
2439 }
2441 }
2443 {
2450 {
2455 newextra);
2457 }
2459 }
2461 {
2468 {
2473 newextra);
2475 }
2477 /*
2478 * Release stacked values if not used anymore. We
2479 * could use discard_stack_value() here, but since
2480 * we have type-specific code anyway, might as
2481 * well inline it.
2482 */
2486 }
2488 {
2495 {
2500 newextra);
2502 }
2504 }
2505 }
2507 /*
2508 * Release stacked extra values if not used anymore.
2509 */
2513 /* And restore source information */
2517 }
2519 /*
2520 * Pop the GUC's state stack; if it's now empty, remove the GUC
2521 * from guc_stack_list.
2522 */
2528 /* Report new value if we changed it */
2531 {
2534 }
2536 }
2538 /* Update nesting level */
2540 }
2543 /*
2544 * Start up automatic reporting of changes to variables marked GUC_REPORT.
2545 * This is executed at completion of backend startup.
2546 */
2547 void
2549 {
2550 HASH_SEQ_STATUS status;
2553 /*
2554 * Don't do anything unless talking to an interactive frontend.
2555 */
2561 /*
2562 * Hack for in_hot_standby: set the GUC value true if appropriate. This
2563 * is kind of an ugly place to do it, but there's few better options.
2564 *
2565 * (This could be out of date by the time we actually send it, in which
2566 * case the next ReportChangedGUCOptions call will send a duplicate
2567 * report.)
2568 */
2573 /* Transmit initial values of interesting variables */
2576 {
2581 }
2582 }
2584 /*
2585 * ReportChangedGUCOptions: report recently-changed GUC_REPORT variables
2586 *
2587 * This is called just before we wait for a new client query.
2588 *
2589 * By handling things this way, we ensure that a ParameterStatus message
2590 * is sent at most once per variable per query, even if the variable
2591 * changed multiple times within the query. That's quite possible when
2592 * using features such as function SET clauses. Function SET clauses
2593 * also tend to cause values to change intraquery but eventually revert
2594 * to their prevailing values; ReportGUCOption is responsible for avoiding
2595 * redundant reports in such cases.
2596 */
2597 void
2599 {
2600 slist_mutable_iter iter;
2602 /* Quick exit if not (yet) enabled */
2606 /*
2607 * Since in_hot_standby isn't actually changed by normal GUC actions, we
2608 * need a hack to check whether a new value needs to be reported to the
2609 * client. For speed, we rely on the assumption that it can never
2610 * transition from false to true.
2611 */
2616 /* Transmit new values of interesting variables */
2618 {
2626 }
2627 }
2629 /*
2630 * ReportGUCOption: if appropriate, transmit option value to frontend
2631 *
2632 * We need not transmit the value if it's the same as what we last
2633 * transmitted.
2634 */
2635 static void
2637 {
2642 {
2643 StringInfoData msgbuf;
2650 /*
2651 * We need a long-lifespan copy. If guc_strdup() fails due to OOM,
2652 * we'll set last_reported to NULL and thereby possibly make a
2653 * duplicate report later.
2654 */
2657 }
2660 }
2662 /*
2663 * Convert a value from one of the human-friendly units ("kB", "min" etc.)
2664 * to the given base unit. 'value' and 'unit' are the input value and unit
2665 * to convert from (there can be trailing spaces in the unit string).
2666 * The converted value is stored in *base_value.
2667 * It's caller's responsibility to round off the converted value as necessary
2668 * and check for out-of-range.
2669 *
2670 * Returns true on success, false if the input unit is not recognized.
2671 */
2672 static bool
2675 {
2681 /* extract unit string to compare to table entries */
2687 /* allow whitespace after unit */
2689 unit++;
2693 /* now search the appropriate table */
2696 else
2700 {
2703 {
2706 /*
2707 * If the user gave a fractional value such as "30.1GB", round it
2708 * off to the nearest multiple of the next smaller unit, if there
2709 * is one.
2710 */
2718 }
2719 }
2721 }
2723 /*
2724 * Convert an integer value in some base unit to a human-friendly unit.
2725 *
2726 * The output unit is chosen so that it's the greatest unit that can represent
2727 * the value without loss. For example, if the base unit is GUC_UNIT_KB, 1024
2728 * is converted to 1 MB, but 1025 is represented as 1025 kB.
2729 */
2730 static void
2733 {
2741 else
2745 {
2747 {
2748 /*
2749 * Accept the first conversion that divides the value evenly. We
2750 * assume that the conversions for each base unit are ordered from
2751 * greatest unit to the smallest!
2752 */
2755 {
2759 }
2760 }
2761 }
2764 }
2766 /*
2767 * Convert a floating-point value in some base unit to a human-friendly unit.
2768 *
2769 * Same as above, except we have to do the math a bit differently, and
2770 * there's a possibility that we don't find any exact divisor.
2771 */
2772 static void
2775 {
2783 else
2787 {
2789 {
2790 /*
2791 * Accept the first conversion that divides the value evenly; or
2792 * if there is none, use the smallest (last) target unit.
2793 *
2794 * What we actually care about here is whether snprintf with "%g"
2795 * will print the value as an integer, so the obvious test of
2796 * "*value == rint(*value)" is too strict; roundoff error might
2797 * make us choose an unreasonably small unit. As a compromise,
2798 * accept a divisor that is within 1e-8 of producing an integer.
2799 */
2805 }
2806 }
2809 }
2811 /*
2812 * Return the name of a GUC's base unit (e.g. "ms") given its flags.
2813 * Return NULL if the GUC is unitless.
2814 */
2817 {
2819 {
2829 {
2832 /* initialize if first time through */
2836 }
2838 {
2841 /* initialize if first time through */
2845 }
2856 }
2857 }
2860 /*
2861 * Try to parse value as an integer. The accepted formats are the
2862 * usual decimal, octal, or hexadecimal formats, as well as floating-point
2863 * formats (which will be rounded to integer after any units conversion).
2864 * Optionally, the value can be followed by a unit name if "flags" indicates
2865 * a unit is allowed.
2866 *
2867 * If the string parses okay, return true, else false.
2868 * If okay and result is not NULL, return the value in *result.
2869 * If not okay and hintmsg is not NULL, *hintmsg is set to a suitable
2870 * HINT message, or NULL if no hint provided.
2871 */
2872 bool
2874 {
2875 /*
2876 * We assume here that double is wide enough to represent any integer
2877 * value with adequate precision.
2878 */
2882 /* To suppress compiler warnings, always set output params */
2888 /*
2889 * Try to parse as an integer (allowing octal or hex input). If the
2890 * conversion stops at a decimal point or 'e', or overflows, re-parse as
2891 * float. This should work fine as long as we have no unit names starting
2892 * with 'e'. If we ever do, the test could be extended to check for a
2893 * sign or digit after 'e', but for now that's unnecessary.
2894 */
2899 {
2902 }
2907 /* reject NaN (infinities will fail range check below) */
2911 /* allow whitespace between number and unit */
2913 endptr++;
2915 /* Handle possible unit */
2917 {
2924 {
2925 /* invalid unit, or garbage after the unit; set hint and fail. */
2927 {
2930 else
2932 }
2934 }
2935 }
2937 /* Round to int, then check for overflow */
2941 {
2945 }
2950 }
2952 /*
2953 * Try to parse value as a floating point number in the usual format.
2954 * Optionally, the value can be followed by a unit name if "flags" indicates
2955 * a unit is allowed.
2956 *
2957 * If the string parses okay, return true, else false.
2958 * If okay and result is not NULL, return the value in *result.
2959 * If not okay and hintmsg is not NULL, *hintmsg is set to a suitable
2960 * HINT message, or NULL if no hint provided.
2961 */
2962 bool
2964 {
2968 /* To suppress compiler warnings, always set output params */
2980 /* reject NaN (infinities will fail range checks later) */
2984 /* allow whitespace between number and unit */
2986 endptr++;
2988 /* Handle possible unit */
2990 {
2997 {
2998 /* invalid unit, or garbage after the unit; set hint and fail. */
3000 {
3003 else
3005 }
3007 }
3008 }
3013 }
3016 /*
3017 * Lookup the name for an enum option with the selected value.
3018 * Should only ever be called with known-valid values, so throws
3019 * an elog(ERROR) if the enum option is not found.
3020 *
3021 * The returned string is a pointer to static data and not
3022 * allocated for modification.
3023 */
3026 {
3030 {
3033 }
3038 }
3041 /*
3042 * Lookup the value for an enum option with the selected name
3043 * (case-insensitive).
3044 * If the enum option is found, sets the retval value and returns
3045 * true. If it's not found, return false and retval is set to 0.
3046 */
3047 bool
3050 {
3054 {
3056 {
3059 }
3060 }
3064 }
3067 /*
3068 * Return a palloc'd string listing all the available options for an enum GUC
3069 * (excluding hidden ones), separated by the given separator.
3070 * If prefix is non-NULL, it is added before the first enum value.
3071 * If suffix is non-NULL, it is added to the end of the string.
3072 */
3076 {
3078 StringInfoData retstr;
3086 {
3088 {
3091 }
3092 }
3094 /*
3095 * All the entries may have been hidden, leaving the string empty if no
3096 * prefix was given. This indicates a broken GUC setup, since there is no
3097 * use for an enum without any values, so we just check to make sure we
3098 * don't write to invalid memory instead of actually trying to do
3099 * something smart with it.
3100 */
3102 {
3103 /* Replace final separator */
3106 }
3111 }
3113 /*
3114 * Parse and validate a proposed value for the specified configuration
3115 * parameter.
3116 *
3117 * This does built-in checks (such as range limits for an integer parameter)
3118 * and also calls any check hook the parameter may have.
3119 *
3120 * record: GUC variable's info record
3121 * name: variable name (should match the record of course)
3122 * value: proposed value, as a string
3123 * source: identifies source of value (check hooks may need this)
3124 * elevel: level to log any error reports at
3125 * newval: on success, converted parameter value is returned here
3126 * newextra: on success, receives any "extra" data returned by check hook
3127 * (caller must initialize *newextra to NULL)
3128 *
3129 * Returns true if OK, false if not (or throws error, if elevel >= ERROR)
3130 */
3131 static bool
3136 {
3138 {
3140 {
3144 {
3148 name)));
3150 }
3155 }
3158 {
3164 {
3171 }
3174 {
3180 else
3187 name,
3191 }
3196 }
3199 {
3205 {
3212 }
3215 {
3221 else
3228 name,
3232 }
3237 }
3240 {
3243 /*
3244 * The value passed by the caller could be transient, so we
3245 * always strdup it.
3246 */
3251 /*
3252 * The only built-in "parsing" check we have is to apply
3253 * truncation if GUC_IS_NAME.
3254 */
3262 {
3266 }
3267 }
3270 {
3274 {
3290 }
3295 }
3297 }
3300 }
3303 /*
3304 * set_config_option: sets option `name' to given value.
3305 *
3306 * The value should be a string, which will be parsed and converted to
3307 * the appropriate data type. The context and source parameters indicate
3308 * in which context this function is being called, so that it can apply the
3309 * access restrictions properly.
3310 *
3311 * If value is NULL, set the option to its default value (normally the
3312 * reset_val, but if source == PGC_S_DEFAULT we instead use the boot_val).
3313 *
3314 * action indicates whether to set the value globally in the session, locally
3315 * to the current top transaction, or just for the duration of a function call.
3316 *
3317 * If changeVal is false then don't really set the option but do all
3318 * the checks to see if it would work.
3319 *
3320 * elevel should normally be passed as zero, allowing this function to make
3321 * its standard choice of ereport level. However some callers need to be
3322 * able to override that choice; they should pass the ereport level to use.
3323 *
3324 * is_reload should be true only when called from read_nondefault_variables()
3325 * or RestoreGUCState(), where we are trying to load some other process's
3326 * GUC settings into a new process.
3327 *
3328 * Return value:
3329 * +1: the value is valid and was successfully applied.
3330 * 0: the name or value is invalid, or it's invalid to try to set
3331 * this GUC now; but elevel was less than ERROR (see below).
3332 * -1: no error detected, but the value was not applied, either
3333 * because changeVal is false or there is some overriding setting.
3334 *
3335 * If there is an error (non-existing option, invalid value, etc) then an
3336 * ereport(ERROR) is thrown *unless* this is called for a source for which
3337 * we don't want an ERROR (currently, those are defaults, the config file,
3338 * and per-database or per-user settings, as well as callers who specify
3339 * a less-than-ERROR elevel). In those cases we write a suitable error
3340 * message via ereport() and return 0.
3341 *
3342 * See also SetConfigOption for an external interface.
3343 */
3344 int
3349 {
3350 Oid srole;
3352 /*
3353 * Non-interactive sources should be treated as having all privileges,
3354 * except for PGC_S_CLIENT. Note in particular that this is true for
3355 * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3356 * privilege check was done when the pg_db_role_setting entry was made.
3357 */
3360 else
3366 is_reload);
3367 }
3369 /*
3370 * set_config_option_ext: sets option `name' to given value.
3371 *
3372 * This API adds the ability to explicitly specify which role OID
3373 * is considered to be setting the value. Most external callers can use
3374 * set_config_option() and let it determine that based on the GucSource,
3375 * but there are a few that are supplying a value that was determined
3376 * in some special way and need to override the decision. Also, when
3377 * restoring a previously-assigned value, it's important to supply the
3378 * same role OID that set the value originally; so all guc.c callers
3379 * that are doing that type of thing need to call this directly.
3380 *
3381 * Generally, srole should be GetUserId() when the source is a SQL operation,
3382 * or BOOTSTRAP_SUPERUSERID if the source is a config file or similar.
3383 */
3384 int
3389 {
3393 is_reload);
3394 }
3397 /*
3398 * set_config_with_handle: sets option `name' to given value.
3399 *
3400 * This API adds the ability to pass a 'handle' argument, which can be
3401 * obtained by the caller from get_config_handle(). NULL has no effect,
3402 * but a non-null value avoids the need to search the GUC tables.
3403 *
3404 * This should be used by callers which repeatedly set the same config
3405 * option(s), and want to avoid the overhead of a hash lookup each time.
3406 */
3407 int
3413 {
3421 {
3423 {
3424 /*
3425 * To avoid cluttering the log, only the postmaster bleats loudly
3426 * about problems with the config file.
3427 */
3429 }
3435 else
3437 }
3439 /* if handle is specified, no need to look up option */
3441 {
3445 }
3446 else
3449 /*
3450 * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
3451 * because the current worker will also pop the change. We're probably
3452 * dealing with a function having a proconfig entry. Only the function's
3453 * body should observe the change, and peer workers do not share in the
3454 * execution of a function call started by this worker.
3455 *
3456 * Also allow normal setting if the GUC is marked GUC_ALLOW_IN_PARALLEL.
3457 *
3458 * Other changes might need to affect other workers, so forbid them.
3459 */
3462 {
3466 name)));
3468 }
3470 /*
3471 * Check if the option can be set at this time. See guc.h for the precise
3472 * rules.
3473 */
3475 {
3478 {
3482 name)));
3484 }
3488 {
3489 /*
3490 * We are re-reading a PGC_POSTMASTER variable from
3491 * postgresql.conf. We can't change the setting, so we should
3492 * give a warning if the DBA tries to change it. However,
3493 * because of variant formats, canonicalization by check
3494 * hooks, etc, we can't just compare the given string directly
3495 * to what's stored. Set a flag to check below after we have
3496 * the final storable value.
3497 */
3499 }
3501 {
3505 name)));
3507 }
3511 {
3515 name)));
3517 }
3519 /*
3520 * Hmm, the idea of the SIGHUP context is "ought to be global, but
3521 * can be changed after postmaster start". But there's nothing
3522 * that prevents a crafty administrator from sending SIGHUP
3523 * signals to individual backends only.
3524 */
3528 {
3529 /*
3530 * Check whether the requesting user has been granted
3531 * privilege to set this GUC.
3532 */
3533 AclResult aclresult;
3537 {
3538 /* No granted privilege */
3542 name)));
3544 }
3545 }
3546 /* fall through to process the same as PGC_BACKEND */
3547 /* FALLTHROUGH */
3550 {
3551 /*
3552 * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
3553 * the config file, we want to accept the new value in the
3554 * postmaster (whence it will propagate to
3555 * subsequently-started backends), but ignore it in existing
3556 * backends. This is a tad klugy, but necessary because we
3557 * don't re-read the config file during backend start.
3558 *
3559 * However, if changeVal is false then plow ahead anyway since
3560 * we are trying to find out if the value is potentially good,
3561 * not actually use it.
3562 *
3563 * In EXEC_BACKEND builds, this works differently: we load all
3564 * non-default settings from the CONFIG_EXEC_PARAMS file
3565 * during backend start. In that case we must accept
3566 * PGC_SIGHUP settings, so as to have the same value as if
3567 * we'd forked from the postmaster. This can also happen when
3568 * using RestoreGUCState() within a background worker that
3569 * needs to have the same settings as the user backend that
3570 * started it. is_reload will be true when either situation
3571 * applies.
3572 */
3575 }
3580 {
3584 name)));
3586 }
3590 {
3591 /*
3592 * Check whether the requesting user has been granted
3593 * privilege to set this GUC.
3594 */
3595 AclResult aclresult;
3599 {
3600 /* No granted privilege */
3604 name)));
3606 }
3607 }
3610 /* always okay */
3612 }
3614 /*
3615 * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
3616 * security restriction context. We can reject this regardless of the GUC
3617 * context or source, mainly because sources that it might be reasonable
3618 * to override for won't be seen while inside a function.
3619 *
3620 * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
3621 * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
3622 * An exception might be made if the reset value is assumed to be "safe".
3623 *
3624 * Note: this flag is currently used for "session_authorization" and
3625 * "role". We need to prohibit changing these inside a local userid
3626 * context because when we exit it, GUC won't be notified, leaving things
3627 * out of sync. (This could be fixed by forcing a new GUC nesting level,
3628 * but that would change behavior in possibly-undesirable ways.) Also, we
3629 * prohibit changing these in a security-restricted operation because
3630 * otherwise RESET could be used to regain the session user's privileges.
3631 */
3633 {
3635 {
3636 /*
3637 * Phrasing of this error message is historical, but it's the most
3638 * common case.
3639 */
3643 name)));
3645 }
3647 {
3651 name)));
3653 }
3654 }
3656 /* Disallow resetting and saving GUC_NO_RESET values */
3658 {
3660 {
3665 }
3667 {
3671 name)));
3673 }
3674 }
3676 /*
3677 * Should we set reset/stacked values? (If so, the behavior is not
3678 * transactional.) This is done either when we get a default value from
3679 * the database's/user's/client's default settings or when we reset a
3680 * value to its default.
3681 */
3685 /*
3686 * Ignore attempted set if overridden by previously processed setting.
3687 * However, if changeVal is false then plow ahead anyway since we are
3688 * trying to find out if the value is potentially good, not actually use
3689 * it. Also keep going if makeDefault is true, since we may want to set
3690 * the reset/stacked values even if we can't set the variable itself.
3691 */
3693 {
3695 {
3697 name);
3699 }
3701 }
3703 /*
3704 * Evaluate value and set variable.
3705 */
3707 {
3709 {
3712 #define newval (newval_union.boolval)
3715 {
3720 }
3722 {
3727 }
3728 else
3729 {
3735 }
3738 {
3739 /* Release newextra, unless it's reset_extra */
3744 {
3749 name)));
3751 }
3754 }
3757 {
3758 /* Save old value to support transaction abort */
3766 newextra);
3770 }
3772 {
3776 {
3779 newextra);
3783 }
3785 {
3787 {
3790 newextra);
3794 }
3795 }
3796 }
3798 /* Perhaps we didn't install newextra anywhere */
3803 #undef newval
3804 }
3807 {
3810 #define newval (newval_union.intval)
3813 {
3818 }
3820 {
3825 }
3826 else
3827 {
3833 }
3836 {
3837 /* Release newextra, unless it's reset_extra */
3842 {
3847 name)));
3849 }
3852 }
3855 {
3856 /* Save old value to support transaction abort */
3864 newextra);
3868 }
3870 {
3874 {
3877 newextra);
3881 }
3883 {
3885 {
3888 newextra);
3892 }
3893 }
3894 }
3896 /* Perhaps we didn't install newextra anywhere */
3901 #undef newval
3902 }
3905 {
3908 #define newval (newval_union.realval)
3911 {
3916 }
3918 {
3923 }
3924 else
3925 {
3931 }
3934 {
3935 /* Release newextra, unless it's reset_extra */
3940 {
3945 name)));
3947 }
3950 }
3953 {
3954 /* Save old value to support transaction abort */
3962 newextra);
3966 }
3968 {
3972 {
3975 newextra);
3979 }
3981 {
3983 {
3986 newextra);
3990 }
3991 }
3992 }
3994 /* Perhaps we didn't install newextra anywhere */
3999 #undef newval
4000 }
4003 {
4006 #define newval (newval_union.stringval)
4009 {
4014 }
4016 {
4017 /* non-NULL boot_val must always get strdup'd */
4019 {
4023 }
4024 else
4029 {
4032 }
4033 }
4034 else
4035 {
4036 /*
4037 * strdup not needed, since reset_val is already under
4038 * guc.c's control
4039 */
4045 }
4048 {
4051 /* newval shouldn't be NULL, so we're a bit sloppy here */
4056 /* Release newval, unless it's reset_val */
4059 /* Release newextra, unless it's reset_extra */
4064 {
4069 name)));
4071 }
4074 }
4077 {
4078 /* Save old value to support transaction abort */
4086 newextra);
4090 }
4093 {
4097 {
4100 newextra);
4104 }
4106 {
4108 {
4110 newval);
4112 newextra);
4116 }
4117 }
4118 }
4120 /* Perhaps we didn't install newval anywhere */
4123 /* Perhaps we didn't install newextra anywhere */
4128 #undef newval
4129 }
4132 {
4135 #define newval (newval_union.enumval)
4138 {
4143 }
4145 {
4150 }
4151 else
4152 {
4158 }
4161 {
4162 /* Release newextra, unless it's reset_extra */
4167 {
4172 name)));
4174 }
4177 }
4180 {
4181 /* Save old value to support transaction abort */
4189 newextra);
4193 }
4195 {
4199 {
4202 newextra);
4206 }
4208 {
4210 {
4213 newextra);
4217 }
4218 }
4219 }
4221 /* Perhaps we didn't install newextra anywhere */
4226 #undef newval
4227 }
4228 }
4232 {
4235 }
4238 }
4241 /*
4242 * Retrieve a config_handle for the given name, suitable for calling
4243 * set_config_with_handle(). Only return handle to permanent GUC.
4244 */
4245 config_handle *
4247 {
4254 }
4257 /*
4258 * Set the fields for source file and line number the setting came from.
4259 */
4260 static void
4262 {
4266 /*
4267 * To avoid cluttering the log, only the postmaster bleats loudly about
4268 * problems with the config file.
4269 */
4273 /* should not happen */
4281 }
4283 /*
4284 * Set a config option to the given value.
4285 *
4286 * See also set_config_option; this is just the wrapper to be called from
4287 * outside GUC. (This function should be used when possible, because its API
4288 * is more stable than set_config_option's.)
4289 *
4290 * Note: there is no support here for setting source file/line, as it
4291 * is currently not needed.
4292 */
4293 void
4296 {
4299 }
4303 /*
4304 * Fetch the current value of the option `name', as a string.
4305 *
4306 * If the option doesn't exist, return NULL if missing_ok is true,
4307 * otherwise throw an ereport and don't return.
4308 *
4309 * If restrict_privileged is true, we also enforce that only superusers and
4310 * members of the pg_read_all_settings role can see GUC_SUPERUSER_ONLY
4311 * variables. This should only be passed as true in user-driven calls.
4312 *
4313 * The string is *not* allocated for modification and is really only
4314 * valid until the next call to configuration related functions.
4315 */
4318 {
4334 {
4355 }
4357 }
4359 /*
4360 * Get the RESET value associated with the given option.
4361 *
4362 * Note: this is not re-entrant, due to use of static result buffer;
4363 * not to mention that a string variable could have its reset_val changed.
4364 * Beware of assuming the result value is good for very long.
4365 */
4368 {
4382 {
4403 }
4405 }
4407 /*
4408 * Get the GUC flags associated with the given option.
4409 *
4410 * If the option doesn't exist, return 0 if missing_ok is true,
4411 * otherwise throw an ereport and don't return.
4412 */
4413 int
4415 {
4422 }
4425 /*
4426 * Write updated configuration parameter values into a temporary file.
4427 * This function traverses the list of parameters and quotes the string
4428 * values before writing them.
4429 */
4430 static void
4432 {
4433 StringInfoData buf;
4438 /* Emit file header containing warning comment */
4444 {
4445 /* if write didn't set errno, assume problem is no disk space */
4451 }
4453 /* Emit each parameter, properly quoting the value */
4455 {
4475 {
4476 /* if write didn't set errno, assume problem is no disk space */
4482 }
4483 }
4485 /* fsync before considering the write to be successful */
4492 }
4494 /*
4495 * Update the given list of configuration parameters, adding, replacing
4496 * or deleting the entry for item "name" (delete if "value" == NULL).
4497 */
4498 static void
4501 {
4506 /*
4507 * Remove any existing match(es) for "name". Normally there'd be at most
4508 * one, but if external tools have modified the config file, there could
4509 * be more.
4510 */
4512 {
4515 {
4516 /* found a match, delete it */
4519 else
4528 }
4529 else
4531 }
4533 /* Done if we're trying to delete it */
4537 /* OK, append a new entry */
4550 else
4553 }
4556 /*
4557 * Execute ALTER SYSTEM statement.
4558 *
4559 * Read the old PG_AUTOCONF_FILENAME file, merge in the new variable value,
4560 * and write out an updated file. If the command is ALTER SYSTEM RESET ALL,
4561 * we can skip reading the old file and just write an empty file.
4562 *
4563 * An LWLock is used to serialize updates of the configuration file.
4564 *
4565 * In case of an error, we leave the original automatic
4566 * configuration file (PG_AUTOCONF_FILENAME) intact.
4567 */
4568 void
4570 {
4580 /*
4581 * Extract statement arguments
4582 */
4591 {
4610 }
4612 /*
4613 * Check permission to run ALTER SYSTEM on the target variable
4614 */
4616 {
4621 else
4622 {
4623 AclResult aclresult;
4626 ACL_ALTER_SYSTEM);
4631 name)));
4632 }
4633 }
4635 /*
4636 * Unless it's RESET_ALL, validate the target variable and value
4637 */
4639 {
4642 /* We don't want to create a placeholder if there's not one already */
4645 {
4646 /*
4647 * Don't allow parameters that can't be set in configuration files
4648 * to be set in PG_AUTOCONF_FILENAME file.
4649 */
4656 name)));
4658 /*
4659 * If a value is specified, verify that it's sane.
4660 */
4662 {
4677 }
4678 }
4679 else
4680 {
4681 /*
4682 * Variable not known; check we'd be allowed to create it. (We
4683 * cannot validate the value, but that's fine. A non-core GUC in
4684 * the config file cannot cause postmaster start to fail, so we
4685 * don't have to be too tense about possibly installing a bad
4686 * value.)
4687 */
4689 }
4691 /*
4692 * We must also reject values containing newlines, because the grammar
4693 * for config files doesn't support embedded newlines in string
4694 * literals.
4695 */
4700 }
4702 /*
4703 * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4704 * the data directory, so we can reference them by simple relative paths.
4705 */
4707 PG_AUTOCONF_FILENAME);
4709 AutoConfFileName,
4712 /*
4713 * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4714 * time. Use AutoFileLock to ensure that. We must hold the lock while
4715 * reading the old file contents.
4716 */
4719 /*
4720 * If we're going to reset everything, then no need to open or parse the
4721 * old file. We'll just write out an empty list.
4722 */
4724 {
4728 {
4729 /* open old file PG_AUTOCONF_FILENAME */
4737 AutoConfFileName)));
4739 /* parse it */
4745 AutoConfFileName)));
4748 }
4750 /*
4751 * Now, replace any existing entry with the new value, or add it if
4752 * not present.
4753 */
4755 }
4757 /*
4758 * Invoke the post-alter hook for setting this GUC variable. GUCs
4759 * typically do not have corresponding entries in pg_parameter_acl, so we
4760 * call the hook using the name rather than a potentially-non-existent
4761 * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4762 * context can be distinguished from others. (Note that "name" will be
4763 * NULL in the RESET ALL case.)
4764 *
4765 * We do this here rather than at the end, because ALTER SYSTEM is not
4766 * transactional. If the hook aborts our transaction, it will be cleaner
4767 * to do so before we touch any files.
4768 */
4770 ACL_ALTER_SYSTEM,
4774 /*
4775 * To ensure crash safety, first write the new file data to a temp file,
4776 * then atomically rename it into place.
4777 *
4778 * If there is a temp file left over due to a previous crash, it's okay to
4779 * truncate and reuse it.
4780 */
4787 AutoConfTmpFileName)));
4789 /*
4790 * Use a TRY block to clean up the file if we fail. Since we need a TRY
4791 * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4792 */
4794 {
4795 /* Write and sync the new contents to the temporary file */
4798 /* Close before renaming; may be required on some platforms */
4802 /*
4803 * As the rename is atomic operation, if any problem occurs after this
4804 * at worst it can lose the parameters set by last ALTER SYSTEM
4805 * command.
4806 */
4808 }
4810 {
4811 /* Close file first, else unlink might fail on some platforms */
4815 /* Unlink, but ignore any error */
4819 }
4825 }
4828 /*
4829 * Common code for DefineCustomXXXVariable subroutines: allocate the
4830 * new variable's config struct and fill in generic fields.
4831 */
4836 GucContext context,
4840 {
4843 /*
4844 * Only allow custom PGC_POSTMASTER variables to be created during shared
4845 * library preload; any later than that, we can't ensure that the value
4846 * doesn't change after startup. This is a fatal elog if it happens; just
4847 * erroring out isn't safe because we don't know what the calling loadable
4848 * module might already have hooked into.
4849 */
4854 /*
4855 * We can't support custom GUC_LIST_QUOTE variables, because the wrong
4856 * things would happen if such a variable were set or pg_dump'd when the
4857 * defining extension isn't loaded. Again, treat this as fatal because
4858 * the loadable module may be partly initialized already.
4859 */
4863 /*
4864 * Before pljava commit 398f3b876ed402bdaec8bc804f29e2be95c75139
4865 * (2015-12-15), two of that module's PGC_USERSET variables facilitated
4866 * trivial escalation to superuser privileges. Restrict the variables to
4867 * protect sites that have yet to upgrade pljava.
4868 */
4886 }
4888 /*
4889 * Common code for DefineCustomXXXVariable subroutines: insert the new
4890 * variable into the GUC variable hash, replacing any placeholder.
4891 */
4892 static void
4894 {
4899 /* Check mapping between initial and default value */
4902 /*
4903 * See if there's a placeholder by the same name.
4904 */
4907 HASH_FIND,
4908 NULL);
4910 {
4911 /*
4912 * No placeholder to replace, so we can just add it ... but first,
4913 * make sure it's initialized to its default value.
4914 */
4918 }
4920 /*
4921 * This better be a placeholder
4922 */
4931 /*
4932 * First, set the variable to its default value. We must do this even
4933 * though we intend to immediately apply a new value, since it's possible
4934 * that the new value is invalid.
4935 */
4938 /*
4939 * Replace the placeholder in the hash table. We aren't changing the name
4940 * (at least up to case-folding), so the hash value is unchanged.
4941 */
4945 /*
4946 * Remove the placeholder from any lists it's in, too.
4947 */
4950 /*
4951 * Assign the string value(s) stored in the placeholder to the real
4952 * variable. Essentially, we need to duplicate all the active and stacked
4953 * values, but with appropriate validation and datatype adjustment.
4954 *
4955 * If an assignment fails, we report a WARNING and keep going. We don't
4956 * want to throw ERROR for bad values, because it'd bollix the add-on
4957 * module that's presumably halfway through getting loaded. In such cases
4958 * the default or previous state will become active instead.
4959 */
4961 /* First, apply the reset value if any */
4968 /* That should not have resulted in stacking anything */
4971 /* Now, apply current and stacked values, in the order they were stacked */
4977 /* Also copy over any saved source-location information */
4982 /*
4983 * Free up as much as we conveniently can of the placeholder structure.
4984 * (This neglects any stack items, so it's possible for some memory to be
4985 * leaked. Since this can only happen once per session per variable, it
4986 * doesn't seem worth spending much code on.)
4987 */
4992 }
4994 /*
4995 * Recursive subroutine for define_custom_variable: reapply non-reset values
4996 *
4997 * We recurse so that the values are applied in the same order as originally.
4998 * At each recursion level, apply the upper-level value (passed in) in the
4999 * fashion implied by the stack entry.
5000 */
5001 static void
5007 Oid cursrole)
5008 {
5013 {
5014 /* First, recurse, so that stack items are processed bottom to top */
5019 /* See how to apply the passed-in value */
5021 {
5044 /* first, apply the masked value as SET */
5047 PGC_S_SESSION,
5051 /* then apply the current value as LOCAL */
5057 }
5059 /* If we successfully made a stack entry, adjust its nest level */
5062 }
5063 else
5064 {
5065 /*
5066 * We are at the end of the stack. If the active/previous value is
5067 * different from the reset value, it must represent a previously
5068 * committed session value. Apply it, and then drop the stack entry
5069 * that set_config_option will have created under the impression that
5070 * this is to be just a transactional assignment. (We leak the stack
5071 * entry.)
5072 */
5077 {
5082 {
5085 }
5086 }
5087 }
5088 }
5090 /*
5091 * Functions for extensions to call to define their custom GUC variables.
5092 */
5093 void
5099 GucContext context,
5101 GucBoolCheckHook check_hook,
5102 GucBoolAssignHook assign_hook,
5103 GucShowHook show_hook)
5104 {
5117 }
5119 void
5127 GucContext context,
5129 GucIntCheckHook check_hook,
5130 GucIntAssignHook assign_hook,
5131 GucShowHook show_hook)
5132 {
5147 }
5149 void
5157 GucContext context,
5159 GucRealCheckHook check_hook,
5160 GucRealAssignHook assign_hook,
5161 GucShowHook show_hook)
5162 {
5177 }
5179 void
5185 GucContext context,
5187 GucStringCheckHook check_hook,
5188 GucStringAssignHook assign_hook,
5189 GucShowHook show_hook)
5190 {
5202 }
5204 void
5211 GucContext context,
5213 GucEnumCheckHook check_hook,
5214 GucEnumAssignHook assign_hook,
5215 GucShowHook show_hook)
5216 {
5230 }
5232 /*
5233 * Mark the given GUC prefix as "reserved".
5234 *
5235 * This deletes any existing placeholders matching the prefix,
5236 * and then prevents new ones from being created.
5237 * Extensions should call this after they've defined all of their custom
5238 * GUCs, to help catch misspelled config-file entries.
5239 */
5240 void
5242 {
5244 HASH_SEQ_STATUS status;
5246 MemoryContext oldcontext;
5248 /*
5249 * Check for existing placeholders. We must actually remove invalid
5250 * placeholders, else future parallel worker startups will fail. (We
5251 * don't bother trying to free associated memory, since this shouldn't
5252 * happen often.)
5253 */
5256 {
5262 {
5268 className)));
5269 /* Remove it from the hash table */
5272 HASH_REMOVE,
5273 NULL);
5274 /* Remove it from any lists it's in, too */
5276 }
5277 }
5279 /* And remember the name so we can prevent future mistakes. */
5283 }
5286 /*
5287 * Return an array of modified GUC options to show in EXPLAIN.
5288 *
5289 * We only report options related to query planning (marked with GUC_EXPLAIN),
5290 * with values different from their built-in defaults.
5291 */
5294 {
5296 dlist_iter iter;
5300 /*
5301 * While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
5302 * it doesn't seem worth dynamically resizing this array.
5303 */
5306 /* We need only consider GUCs with source not PGC_S_DEFAULT */
5308 {
5313 /* return only parameters marked for inclusion in explain */
5317 /* return only options visible to the current user */
5321 /* return only options that are different from their boot values */
5325 {
5327 {
5331 }
5335 {
5339 }
5343 {
5347 }
5351 {
5360 else
5362 }
5366 {
5370 }
5375 }
5380 /* OK, report it */
5383 }
5386 }
5388 /*
5389 * Return GUC variable value by name; optionally return canonical form of
5390 * name. If the GUC is unset, then throw an error unless missing_ok is true,
5391 * in which case return NULL. Return value is palloc'd (but *varname isn't).
5392 */
5395 {
5400 {
5404 }
5417 }
5419 /*
5420 * ShowGUCOption: get string value of variable
5421 *
5422 * We express a numeric value in appropriate units if it has units and
5423 * use_units is true; else you just get the raw number.
5424 * The result string is palloc'd.
5425 */
5428 {
5433 {
5435 {
5440 else
5442 }
5446 {
5451 else
5452 {
5453 /*
5454 * Use int64 arithmetic to avoid overflows in units
5455 * conversion.
5456 */
5464 else
5470 }
5471 }
5475 {
5480 else
5481 {
5489 else
5495 }
5496 }
5500 {
5507 else
5509 }
5513 {
5518 else
5520 }
5524 /* just to keep compiler quiet */
5527 }
5530 }
5533 #ifdef EXEC_BACKEND
5535 /*
5536 * These routines dump out all non-default GUC options into a binary
5537 * file that is read by all exec'ed backends. The format is:
5538 *
5539 * variable name, string, null terminated
5540 * variable value, string, null terminated
5541 * variable sourcefile, string, null terminated (empty if none)
5542 * variable sourceline, integer
5543 * variable source, integer
5544 * variable scontext, integer
5545 * variable srole, OID
5546 */
5547 static void
5549 {
5556 {
5558 {
5563 else
5565 }
5569 {
5573 }
5577 {
5581 }
5585 {
5590 }
5594 {
5599 }
5601 }
5613 }
5615 void
5617 {
5620 dlist_iter iter;
5626 /*
5627 * Open file
5628 */
5631 {
5635 CONFIG_EXEC_PARAMS_NEW)));
5637 }
5639 /* We need only consider GUCs with source not PGC_S_DEFAULT */
5641 {
5646 }
5649 {
5653 CONFIG_EXEC_PARAMS_NEW)));
5655 }
5657 /*
5658 * Put new file in place. This could delay on Win32, but we don't hold
5659 * any exclusive locks.
5660 */
5662 }
5665 /*
5666 * Read string, including null byte from file
5667 *
5668 * Return NULL on EOF and nothing read
5669 */
5672 {
5674 ch,
5678 do
5679 {
5681 {
5684 else
5686 }
5695 }
5698 /*
5699 * This routine loads a previous postmaster dump of its non-default
5700 * settings.
5701 */
5702 void
5704 {
5710 GucSource varsource;
5711 GucContext varscontext;
5712 Oid varsrole;
5714 /*
5715 * Open file
5716 */
5719 {
5720 /* File not found is fine */
5725 CONFIG_EXEC_PARAMS)));
5727 }
5730 {
5759 }
5762 }
5765 /*
5766 * can_skip_gucvar:
5767 * Decide whether SerializeGUCState can skip sending this GUC variable,
5768 * or whether RestoreGUCState can skip resetting this GUC to default.
5769 *
5770 * It is somewhat magical and fragile that the same test works for both cases.
5771 * Realize in particular that we are very likely selecting different sets of
5772 * GUCs on the leader and worker sides! Be sure you've understood the
5773 * comments here and in RestoreGUCState thoroughly before changing this.
5774 */
5775 static bool
5777 {
5778 /*
5779 * We can skip GUCs that are guaranteed to have the same values in leaders
5780 * and workers. (Note it is critical that the leader and worker have the
5781 * same idea of which GUCs fall into this category. It's okay to consider
5782 * context and name for this purpose, since those are unchanging
5783 * properties of a GUC.)
5784 *
5785 * PGC_POSTMASTER variables always have the same value in every child of a
5786 * particular postmaster, so the worker will certainly have the right
5787 * value already. Likewise, PGC_INTERNAL variables are set by special
5788 * mechanisms (if indeed they aren't compile-time constants). So we may
5789 * always skip these.
5790 *
5791 * Role must be handled specially because its current value can be an
5792 * invalid value (for instance, if someone dropped the role since we set
5793 * it). So if we tried to serialize it normally, we might get a failure.
5794 * We skip it here, and use another mechanism to ensure the worker has the
5795 * right value.
5796 *
5797 * For all other GUCs, we skip if the GUC has its compiled-in default
5798 * value (i.e., source == PGC_S_DEFAULT). On the leader side, this means
5799 * we don't send GUCs that have their default values, which typically
5800 * saves lots of work. On the worker side, this means we don't need to
5801 * reset the GUC to default because it already has that value. See
5802 * comments in RestoreGUCState for more info.
5803 */
5807 }
5809 /*
5810 * estimate_variable_size:
5811 * Compute space needed for dumping the given GUC variable.
5812 *
5813 * It's OK to overestimate, but not to underestimate.
5814 */
5815 static Size
5817 {
5818 Size size;
5821 /* Skippable GUCs consume zero space. */
5825 /* Name, plus trailing zero byte. */
5828 /* Get the maximum display length of the GUC value. */
5830 {
5832 {
5834 }
5838 {
5841 /*
5842 * Instead of getting the exact display length, use max
5843 * length. Also reduce the max length for typical ranges of
5844 * small values. Maximum value is 2147483647, i.e. 10 chars.
5845 * Include one byte for sign.
5846 */
5849 else
5851 }
5855 {
5856 /*
5857 * We are going to print it with %e with REALTYPE_PRECISION
5858 * fractional digits. Account for sign, leading digit,
5859 * decimal point, and exponent with up to 3 digits. E.g.
5860 * -3.99329042340000021e+110
5861 */
5863 }
5867 {
5870 /*
5871 * If the value is NULL, we transmit it as an empty string.
5872 * Although this is not physically the same value, GUC
5873 * generally treats a NULL the same as empty string.
5874 */
5877 else
5879 }
5883 {
5887 }
5889 }
5891 /* Allow space for terminating zero-byte for value */
5897 /* Allow space for terminating zero-byte for sourcefile */
5900 /* Include line whenever file is nonempty. */
5909 }
5911 /*
5912 * EstimateGUCStateSpace:
5913 * Returns the size needed to store the GUC state for the current process
5914 */
5915 Size
5917 {
5918 Size size;
5919 dlist_iter iter;
5921 /* Add space reqd for saving the data size of the guc state */
5924 /*
5925 * Add up the space needed for each GUC variable.
5926 *
5927 * We need only process non-default GUCs.
5928 */
5930 {
5935 }
5938 }
5940 /*
5941 * do_serialize:
5942 * Copies the formatted string into the destination. Moves ahead the
5943 * destination pointer, and decrements the maxbytes by that many bytes. If
5944 * maxbytes is not sufficient to copy the string, error out.
5945 */
5946 static void
5948 {
5960 {
5961 /* Shouldn't happen. Better show errno description. */
5963 }
5965 {
5966 /* This shouldn't happen either, really. */
5968 }
5970 /* Shift the destptr ahead of the null terminator */
5973 }
5975 /* Binary copy version of do_serialize() */
5976 static void
5978 {
5985 }
5987 /*
5988 * serialize_variable:
5989 * Dumps name, value and other information of a GUC variable into destptr.
5990 */
5991 static void
5994 {
5995 /* Ignore skippable GUCs. */
6002 {
6004 {
6009 }
6013 {
6017 }
6021 {
6026 }
6030 {
6033 /* NULL becomes empty string, see estimate_variable_size() */
6036 }
6040 {
6045 }
6047 }
6062 }
6064 /*
6065 * SerializeGUCState:
6066 * Dumps the complete GUC state onto the memory location at start_address.
6067 */
6068 void
6070 {
6072 Size actual_size;
6073 Size bytes_left;
6074 dlist_iter iter;
6076 /* Reserve space for saving the actual size of the guc state */
6081 /* We need only consider GUCs with source not PGC_S_DEFAULT */
6083 {
6088 }
6090 /* Store actual size without assuming alignment of start_address. */
6093 }
6095 /*
6096 * read_gucstate:
6097 * Actually it does not read anything, just returns the srcptr. But it does
6098 * move the srcptr past the terminating zero byte, so that the caller is ready
6099 * to read the next string.
6100 */
6103 {
6110 /* The string variables are all null terminated */
6112 ;
6117 /* Set the new position to the byte following the terminating NUL */
6121 }
6123 /* Binary read version of read_gucstate(). Copies into dest */
6124 static void
6126 {
6132 }
6134 /*
6135 * Callback used to add a context message when reporting errors that occur
6136 * while trying to restore GUCs in parallel workers.
6137 */
6138 static void
6140 {
6147 }
6149 /*
6150 * RestoreGUCState:
6151 * Reads the GUC state at the specified address and sets this process's
6152 * GUCs to match.
6153 *
6154 * Note that this provides the worker with only a very shallow view of the
6155 * leader's GUC state: we'll know about the currently active values, but not
6156 * about stacked or reset values. That's fine since the worker is just
6157 * executing one part of a query, within which the active values won't change
6158 * and the stacked values are invisible.
6159 */
6160 void
6162 {
6167 GucSource varsource;
6168 GucContext varscontext;
6169 Oid varsrole;
6172 Size len;
6173 dlist_mutable_iter iter;
6174 ErrorContextCallback error_context_callback;
6176 /*
6177 * First, ensure that all potentially-shippable GUCs are reset to their
6178 * default values. We must not touch those GUCs that the leader will
6179 * never ship, while there is no need to touch those that are shippable
6180 * but already have their default values. Thus, this ends up being the
6181 * same test that SerializeGUCState uses, even though the sets of
6182 * variables involved may well be different since the leader's set of
6183 * variables-not-at-default-values can differ from the set that are
6184 * not-default in this freshly started worker.
6185 *
6186 * Once we have set all the potentially-shippable GUCs to default values,
6187 * restoring the GUCs that the leader sent (because they had non-default
6188 * values over there) leads us to exactly the set of GUC values that the
6189 * leader has. This is true even though the worker may have initially
6190 * absorbed postgresql.conf settings that the leader hasn't yet seen, or
6191 * ALTER USER/DATABASE SET settings that were established after the leader
6192 * started.
6193 *
6194 * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
6195 * also ensures that set_config_option won't refuse to set them because of
6196 * source-priority comparisons.
6197 */
6199 {
6203 /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
6207 /*
6208 * We can use InitializeOneGUCOption to reset the GUC to default, but
6209 * first we must free any existing subsidiary data to avoid leaking
6210 * memory. The stack must be empty, but we have to clean up all other
6211 * fields. Beware that there might be duplicate value or "extra"
6212 * pointers. We also have to be sure to take it out of any lists it's
6213 * in.
6214 */
6220 {
6222 {
6228 }
6230 {
6236 }
6238 {
6244 }
6246 {
6255 }
6257 {
6263 }
6264 }
6265 /* Remove it from any lists it's in. */
6267 /* Now we can reset the struct to PGS_S_DEFAULT state. */
6269 }
6271 /* First item is the length of the subsequent data */
6277 /* If the GUC value check fails, we want errors to show useful context. */
6283 /* Restore all the listed GUCs. */
6285 {
6295 else
6317 }
6320 }
6322 /*
6323 * A little "long argument" simulation, although not quite GNU
6324 * compliant. Takes a string of the form "some-option=some value" and
6325 * returns name = "some_option" and value = "some value" in palloc'ed
6326 * storage. Note that '-' is converted to '_' in the option name. If
6327 * there is no '=' in the input string then value will be NULL.
6328 */
6329 void
6331 {
6342 {
6347 }
6348 else
6349 {
6350 /* no equal sign in string */
6353 }
6358 }
6361 /*
6362 * Transform array of GUC settings into lists of names and values. The lists
6363 * are faster to process in cases where the settings must be applied
6364 * repeatedly (e.g. for each function invocation).
6365 */
6366 void
6368 {
6379 {
6380 Datum d;
6400 {
6404 name)));
6407 }
6413 }
6414 }
6417 /*
6418 * Handle options fetched from pg_db_role_setting.setconfig,
6419 * pg_proc.proconfig, etc. Caller must specify proper context/source/action.
6420 *
6421 * The array parameter must be an array of TEXT (it must not be NULL).
6422 */
6423 void
6426 {
6434 {
6444 }
6448 }
6451 /*
6452 * Add an entry to an option array. The array parameter may be NULL
6453 * to indicate the current table entry is NULL.
6454 */
6455 ArrayType *
6457 {
6459 Datum datum;
6466 /* test if the option is valid and we're allowed to set it */
6469 /* normalize name (converts obsolete GUC names to modern spellings) */
6474 /* build new item for array */
6479 {
6491 {
6492 Datum d;
6505 /* check for match up through and including '=' */
6507 {
6510 }
6511 }
6514 datum,
6520 }
6521 else
6525 }
6528 /*
6529 * Delete an entry from an option array. The array parameter may be NULL
6530 * to indicate the current table entry is NULL. Also, if the return value
6531 * is NULL then a null should be stored.
6532 */
6533 ArrayType *
6535 {
6543 /* test if the option is valid and we're allowed to set it */
6546 /* normalize name (converts obsolete GUC names to modern spellings) */
6551 /* if array is currently null, then surely nothing to delete */
6559 {
6560 Datum d;
6574 /* ignore entry if it's what we want to delete */
6579 /* else add it to the output array */
6582 d,
6588 else
6591 index++;
6592 }
6595 }
6598 /*
6599 * Given a GUC array, delete all settings from it that our permission
6600 * level allows: if superuser, delete them all; if regular user, only
6601 * those that are PGC_USERSET or we have permission to set
6602 */
6603 ArrayType *
6605 {
6610 /* if array is currently null, nothing to do */
6614 /* if we're superuser, we can delete everything, so just do it */
6622 {
6623 Datum d;
6641 /* skip if we have permission to delete it */
6645 /* else add it to the output array */
6648 d,
6654 else
6657 index++;
6659 }
6662 }
6664 /*
6665 * Validate a proposed option setting for GUCArrayAdd/Delete/Reset.
6666 *
6667 * name is the option name. value is the proposed value for the Add case,
6668 * or NULL for the Delete/Reset cases. If skipIfNoPermissions is true, it's
6669 * not an error to have no permissions to set the option.
6670 *
6671 * Returns true if OK, false if skipIfNoPermissions is true and user does not
6672 * have permission to change this option (all other error cases result in an
6673 * error being thrown).
6674 */
6675 static bool
6679 {
6682 /*
6683 * There are three cases to consider:
6684 *
6685 * name is a known GUC variable. Check the value normally, check
6686 * permissions normally (i.e., allow if variable is USERSET, or if it's
6687 * SUSET and user is superuser or holds ACL_SET permissions).
6688 *
6689 * name is not known, but exists or can be created as a placeholder (i.e.,
6690 * it has a valid custom name). We allow this case if you're a superuser,
6691 * otherwise not. Superusers are assumed to know what they're doing. We
6692 * can't allow it for other users, because when the placeholder is
6693 * resolved it might turn out to be a SUSET variable. (With currently
6694 * available infrastructure, we can actually handle such cases within the
6695 * current session --- but once an entry is made in pg_db_role_setting,
6696 * it's assumed to be fully validated.)
6697 *
6698 * name is not known and can't be created as a placeholder. Throw error,
6699 * unless skipIfNoPermissions is true, in which case return false.
6700 */
6703 {
6704 /* not known, failed to make a placeholder */
6706 }
6709 {
6710 /*
6711 * We cannot do any meaningful check on the value, so only permissions
6712 * are useful to check.
6713 */
6722 }
6724 /* manual permissions check so we can avoid an error being thrown */
6733 /* if a permissions error should be thrown, let set_config_option do it */
6735 /* test for permissions and valid option value */
6741 }
6744 /*
6745 * Called by check_hooks that want to override the normal
6746 * ERRCODE_INVALID_PARAMETER_VALUE SQLSTATE for check hook failures.
6747 *
6748 * Note that GUC_check_errmsg() etc are just macros that result in a direct
6749 * assignment to the associated variables. That is ugly, but forced by the
6750 * limitations of C's macro mechanisms.
6751 */
6752 void
6754 {
6756 }
6759 /*
6760 * Convenience functions to manage calling a variable's check_hook.
6761 * These mostly take care of the protocol for letting check hooks supply
6762 * portions of the error report on failure.
6763 */
6765 static bool
6768 {
6769 /* Quick success if no hook */
6773 /* Reset variables that might be set by hook */
6780 {
6783 GUC_check_errmsg_string ?
6787 GUC_check_errdetail_string ?
6789 GUC_check_errhint_string ?
6791 /* Flush any strings created in ErrorContext */
6794 }
6797 }
6799 static bool
6802 {
6803 /* Quick success if no hook */
6807 /* Reset variables that might be set by hook */
6814 {
6817 GUC_check_errmsg_string ?
6821 GUC_check_errdetail_string ?
6823 GUC_check_errhint_string ?
6825 /* Flush any strings created in ErrorContext */
6828 }
6831 }
6833 static bool
6836 {
6837 /* Quick success if no hook */
6841 /* Reset variables that might be set by hook */
6848 {
6851 GUC_check_errmsg_string ?
6855 GUC_check_errdetail_string ?
6857 GUC_check_errhint_string ?
6859 /* Flush any strings created in ErrorContext */
6862 }
6865 }
6867 static bool
6870 {
6873 /* Quick success if no hook */
6877 /*
6878 * If elevel is ERROR, or if the check_hook itself throws an elog
6879 * (undesirable, but not always avoidable), make sure we don't leak the
6880 * already-malloc'd newval string.
6881 */
6883 {
6884 /* Reset variables that might be set by hook */
6891 {
6894 GUC_check_errmsg_string ?
6898 GUC_check_errdetail_string ?
6900 GUC_check_errhint_string ?
6902 /* Flush any strings created in ErrorContext */
6905 }
6906 }
6908 {
6911 }
6915 }
6917 static bool
6920 {
6921 /* Quick success if no hook */
6925 /* Reset variables that might be set by hook */
6932 {
6935 GUC_check_errmsg_string ?
6940 GUC_check_errdetail_string ?
6942 GUC_check_errhint_string ?
6944 /* Flush any strings created in ErrorContext */
6947 }
6950 }