LCOV - code coverage report
Current view: top level - src/backend/utils/misc - guc.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 1856 2303 80.6 %
Date: 2024-05-19 08:10:29 Functions: 95 98 96.9 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14