PostgreSQL Source Code git master
guc_hooks.h File Reference
#include "utils/guc.h"
Include dependency graph for guc_hooks.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

bool check_application_name (char **newval, void **extra, GucSource source)
 
void assign_application_name (const char *newval, void *extra)
 
const char * show_archive_command (void)
 
bool check_autovacuum_work_mem (int *newval, void **extra, GucSource source)
 
bool check_vacuum_buffer_usage_limit (int *newval, void **extra, GucSource source)
 
bool check_backtrace_functions (char **newval, void **extra, GucSource source)
 
void assign_backtrace_functions (const char *newval, void *extra)
 
bool check_bonjour (bool *newval, void **extra, GucSource source)
 
bool check_canonical_path (char **newval, void **extra, GucSource source)
 
void assign_checkpoint_completion_target (double newval, void *extra)
 
bool check_client_connection_check_interval (int *newval, void **extra, GucSource source)
 
bool check_client_encoding (char **newval, void **extra, GucSource source)
 
void assign_client_encoding (const char *newval, void *extra)
 
bool check_cluster_name (char **newval, void **extra, GucSource source)
 
bool check_commit_ts_buffers (int *newval, void **extra, GucSource source)
 
const char * show_data_directory_mode (void)
 
bool check_datestyle (char **newval, void **extra, GucSource source)
 
void assign_datestyle (const char *newval, void *extra)
 
bool check_debug_io_direct (char **newval, void **extra, GucSource source)
 
void assign_debug_io_direct (const char *newval, void *extra)
 
bool check_log_connections (char **newval, void **extra, GucSource source)
 
void assign_log_connections (const char *newval, void *extra)
 
bool check_default_table_access_method (char **newval, void **extra, GucSource source)
 
bool check_default_tablespace (char **newval, void **extra, GucSource source)
 
bool check_default_text_search_config (char **newval, void **extra, GucSource source)
 
void assign_default_text_search_config (const char *newval, void *extra)
 
bool check_default_with_oids (bool *newval, void **extra, GucSource source)
 
bool check_effective_io_concurrency (int *newval, void **extra, GucSource source)
 
bool check_huge_page_size (int *newval, void **extra, GucSource source)
 
void assign_io_method (int newval, void *extra)
 
bool check_io_max_concurrency (int *newval, void **extra, GucSource source)
 
const char * show_in_hot_standby (void)
 
bool check_locale_messages (char **newval, void **extra, GucSource source)
 
void assign_locale_messages (const char *newval, void *extra)
 
bool check_locale_monetary (char **newval, void **extra, GucSource source)
 
void assign_locale_monetary (const char *newval, void *extra)
 
bool check_locale_numeric (char **newval, void **extra, GucSource source)
 
void assign_locale_numeric (const char *newval, void *extra)
 
bool check_locale_time (char **newval, void **extra, GucSource source)
 
void assign_locale_time (const char *newval, void *extra)
 
bool check_log_destination (char **newval, void **extra, GucSource source)
 
void assign_log_destination (const char *newval, void *extra)
 
const char * show_log_file_mode (void)
 
bool check_log_stats (bool *newval, void **extra, GucSource source)
 
bool check_log_timezone (char **newval, void **extra, GucSource source)
 
void assign_log_timezone (const char *newval, void *extra)
 
const char * show_log_timezone (void)
 
bool check_maintenance_io_concurrency (int *newval, void **extra, GucSource source)
 
void assign_maintenance_io_concurrency (int newval, void *extra)
 
void assign_io_max_combine_limit (int newval, void *extra)
 
void assign_io_combine_limit (int newval, void *extra)
 
bool check_max_slot_wal_keep_size (int *newval, void **extra, GucSource source)
 
void assign_max_wal_size (int newval, void *extra)
 
bool check_max_stack_depth (int *newval, void **extra, GucSource source)
 
void assign_max_stack_depth (int newval, void *extra)
 
bool check_multixact_member_buffers (int *newval, void **extra, GucSource source)
 
bool check_multixact_offset_buffers (int *newval, void **extra, GucSource source)
 
bool check_notify_buffers (int *newval, void **extra, GucSource source)
 
bool check_primary_slot_name (char **newval, void **extra, GucSource source)
 
bool check_random_seed (double *newval, void **extra, GucSource source)
 
void assign_random_seed (double newval, void *extra)
 
const char * show_random_seed (void)
 
bool check_recovery_prefetch (int *new_value, void **extra, GucSource source)
 
void assign_recovery_prefetch (int new_value, void *extra)
 
bool check_recovery_target (char **newval, void **extra, GucSource source)
 
void assign_recovery_target (const char *newval, void *extra)
 
bool check_recovery_target_lsn (char **newval, void **extra, GucSource source)
 
void assign_recovery_target_lsn (const char *newval, void *extra)
 
bool check_recovery_target_name (char **newval, void **extra, GucSource source)
 
void assign_recovery_target_name (const char *newval, void *extra)
 
bool check_recovery_target_time (char **newval, void **extra, GucSource source)
 
void assign_recovery_target_time (const char *newval, void *extra)
 
bool check_recovery_target_timeline (char **newval, void **extra, GucSource source)
 
void assign_recovery_target_timeline (const char *newval, void *extra)
 
bool check_recovery_target_xid (char **newval, void **extra, GucSource source)
 
void assign_recovery_target_xid (const char *newval, void *extra)
 
bool check_role (char **newval, void **extra, GucSource source)
 
void assign_role (const char *newval, void *extra)
 
const char * show_role (void)
 
bool check_restrict_nonsystem_relation_kind (char **newval, void **extra, GucSource source)
 
void assign_restrict_nonsystem_relation_kind (const char *newval, void *extra)
 
bool check_search_path (char **newval, void **extra, GucSource source)
 
void assign_search_path (const char *newval, void *extra)
 
bool check_serial_buffers (int *newval, void **extra, GucSource source)
 
bool check_session_authorization (char **newval, void **extra, GucSource source)
 
void assign_session_authorization (const char *newval, void *extra)
 
void assign_session_replication_role (int newval, void *extra)
 
void assign_stats_fetch_consistency (int newval, void *extra)
 
bool check_ssl (bool *newval, void **extra, GucSource source)
 
bool check_stage_log_stats (bool *newval, void **extra, GucSource source)
 
bool check_subtrans_buffers (int *newval, void **extra, GucSource source)
 
bool check_synchronous_standby_names (char **newval, void **extra, GucSource source)
 
void assign_synchronous_standby_names (const char *newval, void *extra)
 
void assign_synchronous_commit (int newval, void *extra)
 
void assign_syslog_facility (int newval, void *extra)
 
void assign_syslog_ident (const char *newval, void *extra)
 
void assign_tcp_keepalives_count (int newval, void *extra)
 
const char * show_tcp_keepalives_count (void)
 
void assign_tcp_keepalives_idle (int newval, void *extra)
 
const char * show_tcp_keepalives_idle (void)
 
void assign_tcp_keepalives_interval (int newval, void *extra)
 
const char * show_tcp_keepalives_interval (void)
 
void assign_tcp_user_timeout (int newval, void *extra)
 
const char * show_tcp_user_timeout (void)
 
bool check_temp_buffers (int *newval, void **extra, GucSource source)
 
bool check_temp_tablespaces (char **newval, void **extra, GucSource source)
 
void assign_temp_tablespaces (const char *newval, void *extra)
 
bool check_timezone (char **newval, void **extra, GucSource source)
 
void assign_timezone (const char *newval, void *extra)
 
const char * show_timezone (void)
 
bool check_timezone_abbreviations (char **newval, void **extra, GucSource source)
 
void assign_timezone_abbreviations (const char *newval, void *extra)
 
bool check_transaction_buffers (int *newval, void **extra, GucSource source)
 
bool check_transaction_deferrable (bool *newval, void **extra, GucSource source)
 
bool check_transaction_isolation (int *newval, void **extra, GucSource source)
 
bool check_transaction_read_only (bool *newval, void **extra, GucSource source)
 
void assign_transaction_timeout (int newval, void *extra)
 
const char * show_unix_socket_permissions (void)
 
bool check_wal_buffers (int *newval, void **extra, GucSource source)
 
bool check_wal_consistency_checking (char **newval, void **extra, GucSource source)
 
void assign_wal_consistency_checking (const char *newval, void *extra)
 
bool check_wal_segment_size (int *newval, void **extra, GucSource source)
 
void assign_wal_sync_method (int new_wal_sync_method, void *extra)
 
bool check_synchronized_standby_slots (char **newval, void **extra, GucSource source)
 
void assign_synchronized_standby_slots (const char *newval, void *extra)
 
bool check_idle_replication_slot_timeout (int *newval, void **extra, GucSource source)
 

Function Documentation

◆ assign_application_name()

void assign_application_name ( const char *  newval,
void *  extra 
)

Definition at line 1108 of file variable.c.

1109{
1110 /* Update the pg_stat_activity view */
1112}
void pgstat_report_appname(const char *appname)
#define newval

References newval, and pgstat_report_appname().

◆ assign_backtrace_functions()

void assign_backtrace_functions ( const char *  newval,
void *  extra 
)

Definition at line 2226 of file elog.c.

2227{
2228 backtrace_function_list = (char *) extra;
2229}
static char * backtrace_function_list
Definition: elog.c:116

References backtrace_function_list.

◆ assign_checkpoint_completion_target()

void assign_checkpoint_completion_target ( double  newval,
void *  extra 
)

Definition at line 2198 of file xlog.c.

2199{
2202}
double CheckPointCompletionTarget
Definition: checkpointer.c:143
static void CalculateCheckpointSegments(void)
Definition: xlog.c:2162

References CalculateCheckpointSegments(), CheckPointCompletionTarget, and newval.

◆ assign_client_encoding()

void assign_client_encoding ( const char *  newval,
void *  extra 
)

Definition at line 786 of file variable.c.

787{
788 int encoding = *((int *) extra);
789
790 /*
791 * In a parallel worker, we never override the client encoding that was
792 * set by ParallelWorkerMain().
793 */
794 if (IsParallelWorker())
795 return;
796
797 /* We do not expect an error if PrepareClientEncoding succeeded */
799 elog(LOG, "SetClientEncoding(%d) failed", encoding);
800}
#define LOG
Definition: elog.h:31
#define elog(elevel,...)
Definition: elog.h:225
#define IsParallelWorker()
Definition: parallel.h:60
int SetClientEncoding(int encoding)
Definition: mbutils.c:208
int32 encoding
Definition: pg_database.h:41

References elog, encoding, IsParallelWorker, LOG, and SetClientEncoding().

◆ assign_datestyle()

void assign_datestyle ( const char *  newval,
void *  extra 
)

Definition at line 244 of file variable.c.

245{
246 int *myextra = (int *) extra;
247
248 DateStyle = myextra[0];
249 DateOrder = myextra[1];
250}
int DateStyle
Definition: globals.c:124
int DateOrder
Definition: globals.c:125

References DateOrder, and DateStyle.

◆ assign_debug_io_direct()

void assign_debug_io_direct ( const char *  newval,
void *  extra 
)

Definition at line 4050 of file fd.c.

4051{
4052 int *flags = (int *) extra;
4053
4054 io_direct_flags = *flags;
4055}
int io_direct_flags
Definition: fd.c:167

References io_direct_flags.

◆ assign_default_text_search_config()

void assign_default_text_search_config ( const char *  newval,
void *  extra 
)

Definition at line 670 of file ts_cache.c.

671{
672 /* Just reset the cache to force a lookup on first use */
674}
#define InvalidOid
Definition: postgres_ext.h:37
static Oid TSCurrentConfigCache
Definition: ts_cache.c:78

References InvalidOid, and TSCurrentConfigCache.

◆ assign_io_combine_limit()

void assign_io_combine_limit ( int  newval,
void *  extra 
)

Definition at line 1172 of file variable.c.

1173{
1176}
int io_max_combine_limit
Definition: bufmgr.c:168
int io_combine_limit_guc
Definition: bufmgr.c:167
int io_combine_limit
Definition: bufmgr.c:166
#define Min(x, y)
Definition: c.h:975

References io_combine_limit, io_combine_limit_guc, io_max_combine_limit, Min, and newval.

◆ assign_io_max_combine_limit()

void assign_io_max_combine_limit ( int  newval,
void *  extra 
)

◆ assign_io_method()

void assign_io_method ( int  newval,
void *  extra 
)

Definition at line 1156 of file aio.c.

1157{
1160
1162}
const IoMethodOps * pgaio_method_ops
Definition: aio.c:88
static const IoMethodOps *const pgaio_method_ops_table[]
Definition: aio.c:82
const struct config_enum_entry io_method_options[]
Definition: aio.c:65
#define lengthof(array)
Definition: c.h:759
Assert(PointerIsAligned(start, uint64))

References Assert(), io_method_options, lengthof, newval, pgaio_method_ops, and pgaio_method_ops_table.

◆ assign_locale_messages()

void assign_locale_messages ( const char *  newval,
void *  extra 
)

Definition at line 448 of file pg_locale.c.

449{
450 /*
451 * LC_MESSAGES category does not exist everywhere, but accept it anyway.
452 * We ignore failure, as per comment above.
453 */
454#ifdef LC_MESSAGES
455 (void) pg_perm_setlocale(LC_MESSAGES, newval);
456#endif
457}
char * pg_perm_setlocale(int category, const char *locale)
Definition: pg_locale.c:211

References newval, and pg_perm_setlocale().

◆ assign_locale_monetary()

void assign_locale_monetary ( const char *  newval,
void *  extra 
)

Definition at line 385 of file pg_locale.c.

386{
388}
static bool CurrentLocaleConvValid
Definition: pg_locale.c:154

References CurrentLocaleConvValid.

◆ assign_locale_numeric()

void assign_locale_numeric ( const char *  newval,
void *  extra 
)

Definition at line 397 of file pg_locale.c.

398{
400}

References CurrentLocaleConvValid.

◆ assign_locale_time()

void assign_locale_time ( const char *  newval,
void *  extra 
)

Definition at line 409 of file pg_locale.c.

410{
411 CurrentLCTimeValid = false;
412}
static bool CurrentLCTimeValid
Definition: pg_locale.c:155

References CurrentLCTimeValid.

◆ assign_log_connections()

void assign_log_connections ( const char *  newval,
void *  extra 
)

Definition at line 1091 of file backend_startup.c.

1092{
1093 log_connections = *((int *) extra);
1094}
uint32 log_connections

References log_connections.

◆ assign_log_destination()

void assign_log_destination ( const char *  newval,
void *  extra 
)

Definition at line 2297 of file elog.c.

2298{
2299 Log_destination = *((int *) extra);
2300}
int Log_destination
Definition: elog.c:110

References Log_destination.

◆ assign_log_timezone()

void assign_log_timezone ( const char *  newval,
void *  extra 
)

Definition at line 456 of file variable.c.

457{
458 log_timezone = *((pg_tz **) extra);
459}
PGDLLIMPORT pg_tz * log_timezone
Definition: pgtz.c:31
Definition: pgtz.h:66

References log_timezone.

◆ assign_maintenance_io_concurrency()

void assign_maintenance_io_concurrency ( int  newval,
void *  extra 
)

Definition at line 1146 of file variable.c.

1147{
1148#ifdef USE_PREFETCH
1149 /*
1150 * Reconfigure recovery prefetching, because a setting it depends on
1151 * changed.
1152 */
1154 if (AmStartupProcess())
1156#endif
1157}
int maintenance_io_concurrency
Definition: bufmgr.c:158
#define AmStartupProcess()
Definition: miscadmin.h:389
void XLogPrefetchReconfigure(void)

References AmStartupProcess, maintenance_io_concurrency, newval, and XLogPrefetchReconfigure().

◆ assign_max_stack_depth()

void assign_max_stack_depth ( int  newval,
void *  extra 
)

Definition at line 159 of file stack_depth.c.

160{
161 ssize_t newval_bytes = newval * (ssize_t) 1024;
162
163 max_stack_depth_bytes = newval_bytes;
164}
static ssize_t max_stack_depth_bytes
Definition: stack_depth.c:29

References max_stack_depth_bytes, and newval.

◆ assign_max_wal_size()

void assign_max_wal_size ( int  newval,
void *  extra 
)

Definition at line 2191 of file xlog.c.

2192{
2195}
int max_wal_size_mb
Definition: xlog.c:114

References CalculateCheckpointSegments(), max_wal_size_mb, and newval.

◆ assign_random_seed()

void assign_random_seed ( double  newval,
void *  extra 
)

Definition at line 668 of file variable.c.

669{
670 /* We'll do this at most once for any setting of the GUC variable */
671 if (*((int *) extra))
673 *((int *) extra) = 0;
674}
Datum Float8GetDatum(float8 X)
Definition: fmgr.c:1816
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:641
Datum setseed(PG_FUNCTION_ARGS)

References DirectFunctionCall1, Float8GetDatum(), newval, and setseed().

◆ assign_recovery_prefetch()

void assign_recovery_prefetch ( int  new_value,
void *  extra 
)

Definition at line 1095 of file xlogprefetcher.c.

1096{
1097 /* Reconfigure prefetching, because a setting it depends on changed. */
1098 recovery_prefetch = new_value;
1099 if (AmStartupProcess())
1101}
int recovery_prefetch

References AmStartupProcess, recovery_prefetch, and XLogPrefetchReconfigure().

◆ assign_recovery_target()

void assign_recovery_target ( const char *  newval,
void *  extra 
)

Definition at line 4808 of file xlogrecovery.c.

4809{
4813
4814 if (newval && strcmp(newval, "") != 0)
4816 else
4818}
RecoveryTargetType recoveryTarget
Definition: xlogrecovery.c:86
static pg_noreturn void error_multiple_recovery_targets(void)
@ RECOVERY_TARGET_IMMEDIATE
Definition: xlogrecovery.h:30
@ RECOVERY_TARGET_UNSET
Definition: xlogrecovery.h:25

References error_multiple_recovery_targets(), newval, RECOVERY_TARGET_IMMEDIATE, RECOVERY_TARGET_UNSET, and recoveryTarget.

◆ assign_recovery_target_lsn()

void assign_recovery_target_lsn ( const char *  newval,
void *  extra 
)

Definition at line 4847 of file xlogrecovery.c.

4848{
4852
4853 if (newval && strcmp(newval, "") != 0)
4854 {
4856 recoveryTargetLSN = *((XLogRecPtr *) extra);
4857 }
4858 else
4860}
uint64 XLogRecPtr
Definition: xlogdefs.h:21
XLogRecPtr recoveryTargetLSN
Definition: xlogrecovery.c:93
@ RECOVERY_TARGET_LSN
Definition: xlogrecovery.h:29

References error_multiple_recovery_targets(), newval, RECOVERY_TARGET_LSN, RECOVERY_TARGET_UNSET, recoveryTarget, and recoveryTargetLSN.

◆ assign_recovery_target_name()

void assign_recovery_target_name ( const char *  newval,
void *  extra 
)

Definition at line 4882 of file xlogrecovery.c.

4883{
4887
4888 if (newval && strcmp(newval, "") != 0)
4889 {
4892 }
4893 else
4895}
const char * recoveryTargetName
Definition: xlogrecovery.c:92
@ RECOVERY_TARGET_NAME
Definition: xlogrecovery.h:28

References error_multiple_recovery_targets(), newval, RECOVERY_TARGET_NAME, RECOVERY_TARGET_UNSET, recoveryTarget, and recoveryTargetName.

◆ assign_recovery_target_time()

void assign_recovery_target_time ( const char *  newval,
void *  extra 
)

◆ assign_recovery_target_timeline()

void assign_recovery_target_timeline ( const char *  newval,
void *  extra 
)

Definition at line 5011 of file xlogrecovery.c.

5012{
5015 recoveryTargetTLIRequested = (TimeLineID) strtoul(newval, NULL, 0);
5016 else
5018}
uint32 TimeLineID
Definition: xlogdefs.h:59
RecoveryTargetTimeLineGoal recoveryTargetTimeLineGoal
Definition: xlogrecovery.c:121
TimeLineID recoveryTargetTLIRequested
Definition: xlogrecovery.c:122
RecoveryTargetTimeLineGoal
Definition: xlogrecovery.h:37
@ RECOVERY_TARGET_TIMELINE_NUMERIC
Definition: xlogrecovery.h:40

References newval, RECOVERY_TARGET_TIMELINE_NUMERIC, recoveryTargetTimeLineGoal, and recoveryTargetTLIRequested.

◆ assign_recovery_target_xid()

void assign_recovery_target_xid ( const char *  newval,
void *  extra 
)

Definition at line 5047 of file xlogrecovery.c.

5048{
5052
5053 if (newval && strcmp(newval, "") != 0)
5054 {
5056 recoveryTargetXid = *((TransactionId *) extra);
5057 }
5058 else
5060}
uint32 TransactionId
Definition: c.h:623
TransactionId recoveryTargetXid
Definition: xlogrecovery.c:89
@ RECOVERY_TARGET_XID
Definition: xlogrecovery.h:26

References error_multiple_recovery_targets(), newval, RECOVERY_TARGET_UNSET, RECOVERY_TARGET_XID, recoveryTarget, and recoveryTargetXid.

◆ assign_restrict_nonsystem_relation_kind()

void assign_restrict_nonsystem_relation_kind ( const char *  newval,
void *  extra 
)

Definition at line 3637 of file postgres.c.

3638{
3639 int *flags = (int *) extra;
3640
3642}
int restrict_nonsystem_relation_kind
Definition: postgres.c:105

References restrict_nonsystem_relation_kind.

◆ assign_role()

void assign_role ( const char *  newval,
void *  extra 
)

Definition at line 1026 of file variable.c.

1027{
1028 role_auth_extra *myextra = (role_auth_extra *) extra;
1029
1030 SetCurrentRoleId(myextra->roleid, myextra->is_superuser);
1031}
void SetCurrentRoleId(Oid roleid, bool is_superuser)
Definition: miscinit.c:1007
bool is_superuser
Definition: variable.c:811

References role_auth_extra::is_superuser, role_auth_extra::roleid, and SetCurrentRoleId().

◆ assign_search_path()

void assign_search_path ( const char *  newval,
void *  extra 
)

Definition at line 4713 of file namespace.c.

4714{
4715 /* don't access search_path during bootstrap */
4717
4718 /*
4719 * We mark the path as needing recomputation, but don't do anything until
4720 * it's needed. This avoids trying to do database access during GUC
4721 * initialization, or outside a transaction.
4722 *
4723 * This does not invalidate the search path cache, so if this value had
4724 * been previously set and no syscache invalidations happened,
4725 * recomputation may not be necessary.
4726 */
4727 baseSearchPathValid = false;
4728}
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:476
static bool baseSearchPathValid
Definition: namespace.c:158

References Assert(), baseSearchPathValid, and IsBootstrapProcessingMode.

◆ assign_session_authorization()

void assign_session_authorization ( const char *  newval,
void *  extra 
)

Definition at line 912 of file variable.c.

913{
914 role_auth_extra *myextra = (role_auth_extra *) extra;
915
916 /* Do nothing for the boot_val default of NULL */
917 if (!myextra)
918 return;
919
920 SetSessionAuthorization(myextra->roleid, myextra->is_superuser);
921}
void SetSessionAuthorization(Oid userid, bool is_superuser)
Definition: miscinit.c:971

References role_auth_extra::is_superuser, role_auth_extra::roleid, and SetSessionAuthorization().

◆ assign_session_replication_role()

void assign_session_replication_role ( int  newval,
void *  extra 
)

Definition at line 6630 of file trigger.c.

6631{
6632 /*
6633 * Must flush the plan cache when changing replication role; but don't
6634 * flush unnecessarily.
6635 */
6638}
void ResetPlanCache(void)
Definition: plancache.c:2332
int SessionReplicationRole
Definition: trigger.c:64

References newval, ResetPlanCache(), and SessionReplicationRole.

◆ assign_stats_fetch_consistency()

void assign_stats_fetch_consistency ( int  newval,
void *  extra 
)

Definition at line 2064 of file pgstat.c.

2066{
2067 /*
2068 * Changing this value in a transaction may cause snapshot state
2069 * inconsistencies, so force a clear of the current snapshot on the next
2070 * snapshot build attempt.
2071 */
int pgstat_fetch_consistency
Definition: pgstat.c:204
static bool force_stats_snapshot_clear
Definition: pgstat.c:250

References force_stats_snapshot_clear, newval, and pgstat_fetch_consistency.

◆ assign_synchronized_standby_slots()

void assign_synchronized_standby_slots ( const char *  newval,
void *  extra 
)

Definition at line 2755 of file slot.c.

2756{
2757 /*
2758 * The standby slots may have changed, so we must recompute the oldest
2759 * LSN.
2760 */
2762
2764}
static XLogRecPtr ss_oldest_flush_lsn
Definition: slot.c:172
static SyncStandbySlotsConfigData * synchronized_standby_slots_config
Definition: slot.c:166
#define InvalidXLogRecPtr
Definition: xlogdefs.h:28

References InvalidXLogRecPtr, ss_oldest_flush_lsn, and synchronized_standby_slots_config.

◆ assign_synchronous_commit()

void assign_synchronous_commit ( int  newval,
void *  extra 
)

Definition at line 1056 of file syncrep.c.

1057{
1058 switch (newval)
1059 {
1062 break;
1065 break;
1068 break;
1069 default:
1071 break;
1072 }
1073}
static int SyncRepWaitMode
Definition: syncrep.c:98
#define SYNC_REP_NO_WAIT
Definition: syncrep.h:22
#define SYNC_REP_WAIT_WRITE
Definition: syncrep.h:23
#define SYNC_REP_WAIT_FLUSH
Definition: syncrep.h:24
#define SYNC_REP_WAIT_APPLY
Definition: syncrep.h:25
@ SYNCHRONOUS_COMMIT_REMOTE_WRITE
Definition: xact.h:72
@ SYNCHRONOUS_COMMIT_REMOTE_APPLY
Definition: xact.h:75
@ SYNCHRONOUS_COMMIT_REMOTE_FLUSH
Definition: xact.h:74

References newval, SYNC_REP_NO_WAIT, SYNC_REP_WAIT_APPLY, SYNC_REP_WAIT_FLUSH, SYNC_REP_WAIT_WRITE, SYNCHRONOUS_COMMIT_REMOTE_APPLY, SYNCHRONOUS_COMMIT_REMOTE_FLUSH, SYNCHRONOUS_COMMIT_REMOTE_WRITE, and SyncRepWaitMode.

◆ assign_synchronous_standby_names()

void assign_synchronous_standby_names ( const char *  newval,
void *  extra 
)

Definition at line 1050 of file syncrep.c.

1051{
1052 SyncRepConfig = (SyncRepConfigData *) extra;
1053}
SyncRepConfigData * SyncRepConfig
Definition: syncrep.c:97

References SyncRepConfig.

◆ assign_syslog_facility()

void assign_syslog_facility ( int  newval,
void *  extra 
)

Definition at line 2338 of file elog.c.

2339{
2340#ifdef HAVE_SYSLOG
2341 /*
2342 * As above, don't thrash the syslog connection unnecessarily.
2343 */
2344 if (syslog_facility != newval)
2345 {
2346 if (openlog_done)
2347 {
2348 closelog();
2349 openlog_done = false;
2350 }
2352 }
2353#endif
2354 /* Without syslog support, just ignore it */
2355}
static int syslog_facility
Definition: guc_tables.c:591

References newval, and syslog_facility.

◆ assign_syslog_ident()

void assign_syslog_ident ( const char *  newval,
void *  extra 
)

Definition at line 2306 of file elog.c.

2307{
2308#ifdef HAVE_SYSLOG
2309 /*
2310 * guc.c is likely to call us repeatedly with same parameters, so don't
2311 * thrash the syslog connection unnecessarily. Also, we do not re-open
2312 * the connection until needed, since this routine will get called whether
2313 * or not Log_destination actually mentions syslog.
2314 *
2315 * Note that we make our own copy of the ident string rather than relying
2316 * on guc.c's. This may be overly paranoid, but it ensures that we cannot
2317 * accidentally free a string that syslog is still using.
2318 */
2319 if (syslog_ident == NULL || strcmp(syslog_ident, newval) != 0)
2320 {
2321 if (openlog_done)
2322 {
2323 closelog();
2324 openlog_done = false;
2325 }
2326 free(syslog_ident);
2327 syslog_ident = strdup(newval);
2328 /* if the strdup fails, we will cope in write_syslog() */
2329 }
2330#endif
2331 /* Without syslog support, just ignore it */
2332}
#define free(a)
Definition: header.h:65

References free, and newval.

◆ assign_tcp_keepalives_count()

void assign_tcp_keepalives_count ( int  newval,
void *  extra 
)

Definition at line 2011 of file pqcomm.c.

2012{
2013 /* See comments in assign_tcp_keepalives_idle */
2015}
struct Port * MyProcPort
Definition: globals.c:50
int pq_setkeepalivescount(int count, Port *port)
Definition: pqcomm.c:1832

References MyProcPort, newval, and pq_setkeepalivescount().

◆ assign_tcp_keepalives_idle()

void assign_tcp_keepalives_idle ( int  newval,
void *  extra 
)

Definition at line 1955 of file pqcomm.c.

1956{
1957 /*
1958 * The kernel API provides no way to test a value without setting it; and
1959 * once we set it we might fail to unset it. So there seems little point
1960 * in fully implementing the check-then-assign GUC API for these
1961 * variables. Instead we just do the assignment on demand.
1962 * pq_setkeepalivesidle reports any problems via ereport(LOG).
1963 *
1964 * This approach means that the GUC value might have little to do with the
1965 * actual kernel value, so we use a show_hook that retrieves the kernel
1966 * value rather than trusting GUC's copy.
1967 */
1969}
int pq_setkeepalivesidle(int idle, Port *port)
Definition: pqcomm.c:1668

References MyProcPort, newval, and pq_setkeepalivesidle().

◆ assign_tcp_keepalives_interval()

void assign_tcp_keepalives_interval ( int  newval,
void *  extra 
)

Definition at line 1988 of file pqcomm.c.

1989{
1990 /* See comments in assign_tcp_keepalives_idle */
1992}
int pq_setkeepalivesinterval(int interval, Port *port)
Definition: pqcomm.c:1753

References MyProcPort, newval, and pq_setkeepalivesinterval().

◆ assign_tcp_user_timeout()

void assign_tcp_user_timeout ( int  newval,
void *  extra 
)

Definition at line 2034 of file pqcomm.c.

2035{
2036 /* See comments in assign_tcp_keepalives_idle */
2038}
int pq_settcpusertimeout(int timeout, Port *port)
Definition: pqcomm.c:1907

References MyProcPort, newval, and pq_settcpusertimeout().

◆ assign_temp_tablespaces()

void assign_temp_tablespaces ( const char *  newval,
void *  extra 
)

Definition at line 1306 of file tablespace.c.

1307{
1309
1310 /*
1311 * If check_temp_tablespaces was executed inside a transaction, then pass
1312 * the list it made to fd.c. Otherwise, clear fd.c's list; we must be
1313 * still outside a transaction, or else restoring during transaction exit,
1314 * and in either case we can just let the next PrepareTempTablespaces call
1315 * make things sane.
1316 */
1317 if (myextra)
1318 SetTempTablespaces(myextra->tblSpcs, myextra->numSpcs);
1319 else
1320 SetTempTablespaces(NULL, 0);
1321}
void SetTempTablespaces(Oid *tableSpaces, int numSpaces)
Definition: fd.c:3071
Oid tblSpcs[FLEXIBLE_ARRAY_MEMBER]
Definition: tablespace.c:1193

References temp_tablespaces_extra::numSpcs, SetTempTablespaces(), and temp_tablespaces_extra::tblSpcs.

◆ assign_timezone()

void assign_timezone ( const char *  newval,
void *  extra 
)

Definition at line 381 of file variable.c.

382{
383 session_timezone = *((pg_tz **) extra);
384 /* datetime.c's cache of timezone abbrevs may now be obsolete */
386}
void ClearTimeZoneAbbrevCache(void)
Definition: datetime.c:3221
PGDLLIMPORT pg_tz * session_timezone
Definition: pgtz.c:28

References ClearTimeZoneAbbrevCache(), and session_timezone.

◆ assign_timezone_abbreviations()

void assign_timezone_abbreviations ( const char *  newval,
void *  extra 
)

Definition at line 519 of file variable.c.

520{
521 /* Do nothing for the boot_val default of NULL */
522 if (!extra)
523 return;
524
526}
void InstallTimeZoneAbbrevs(TimeZoneAbbrevTable *tbl)
Definition: datetime.c:5073

References InstallTimeZoneAbbrevs().

◆ assign_transaction_timeout()

void assign_transaction_timeout ( int  newval,
void *  extra 
)

Definition at line 3568 of file postgres.c.

3569{
3570 if (IsTransactionState())
3571 {
3572 /*
3573 * If transaction_timeout GUC has changed within the transaction block
3574 * enable or disable the timer correspondingly.
3575 */
3580 }
3581}
void enable_timeout_after(TimeoutId id, int delay_ms)
Definition: timeout.c:560
bool get_timeout_active(TimeoutId id)
Definition: timeout.c:780
void disable_timeout(TimeoutId id, bool keep_indicator)
Definition: timeout.c:685
@ TRANSACTION_TIMEOUT
Definition: timeout.h:34
bool IsTransactionState(void)
Definition: xact.c:387

References disable_timeout(), enable_timeout_after(), get_timeout_active(), IsTransactionState(), newval, and TRANSACTION_TIMEOUT.

◆ assign_wal_consistency_checking()

void assign_wal_consistency_checking ( const char *  newval,
void *  extra 
)

Definition at line 4803 of file xlog.c.

4804{
4805 /*
4806 * If some checks were deferred, it's possible that the checks will fail
4807 * later during InitializeWalConsistencyChecking(). But in that case, the
4808 * postmaster will exit anyway, so it's safe to proceed with the
4809 * assignment.
4810 *
4811 * Any built-in resource managers specified are assigned immediately,
4812 * which affects WAL created before shared_preload_libraries are
4813 * processed. Any custom resource managers specified won't be assigned
4814 * until after shared_preload_libraries are processed, but that's OK
4815 * because WAL for a custom resource manager can't be written before the
4816 * module is loaded anyway.
4817 */
4819}
bool * wal_consistency_checking
Definition: xlog.c:126

References wal_consistency_checking.

◆ assign_wal_sync_method()

void assign_wal_sync_method ( int  new_wal_sync_method,
void *  extra 
)

Definition at line 8687 of file xlog.c.

8688{
8689 if (wal_sync_method != new_wal_sync_method)
8690 {
8691 /*
8692 * To ensure that no blocks escape unsynced, force an fsync on the
8693 * currently open log segment (if any). Also, if the open flag is
8694 * changing, close the log file so it will be reopened (with new flag
8695 * bit) at next use.
8696 */
8697 if (openLogFile >= 0)
8698 {
8699 pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN);
8700 if (pg_fsync(openLogFile) != 0)
8701 {
8702 char xlogfname[MAXFNAMELEN];
8703 int save_errno;
8704
8705 save_errno = errno;
8708 errno = save_errno;
8709 ereport(PANIC,
8711 errmsg("could not fsync file \"%s\": %m", xlogfname)));
8712 }
8713
8715 if (get_sync_bit(wal_sync_method) != get_sync_bit(new_wal_sync_method))
8716 XLogFileClose();
8717 }
8718 }
8719}
int errcode_for_file_access(void)
Definition: elog.c:876
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define PANIC
Definition: elog.h:42
#define ereport(elevel,...)
Definition: elog.h:149
int pg_fsync(int fd)
Definition: fd.c:385
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:85
static void pgstat_report_wait_end(void)
Definition: wait_event.h:101
static int openLogFile
Definition: xlog.c:635
int wal_segment_size
Definition: xlog.c:143
static int get_sync_bit(int method)
Definition: xlog.c:8639
int wal_sync_method
Definition: xlog.c:130
static TimeLineID openLogTLI
Definition: xlog.c:637
static void XLogFileClose(void)
Definition: xlog.c:3645
static XLogSegNo openLogSegNo
Definition: xlog.c:636
#define MAXFNAMELEN
static void XLogFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)

References ereport, errcode_for_file_access(), errmsg(), get_sync_bit(), MAXFNAMELEN, openLogFile, openLogSegNo, openLogTLI, PANIC, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), wal_segment_size, wal_sync_method, XLogFileClose(), and XLogFileName().

◆ check_application_name()

bool check_application_name ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 1080 of file variable.c.

1081{
1082 char *clean;
1083 char *ret;
1084
1085 /* Only allow clean ASCII chars in the application name */
1087 if (!clean)
1088 return false;
1089
1090 ret = guc_strdup(WARNING, clean);
1091 if (!ret)
1092 {
1093 pfree(clean);
1094 return false;
1095 }
1096
1097 guc_free(*newval);
1098
1099 pfree(clean);
1100 *newval = ret;
1101 return true;
1102}
#define WARNING
Definition: elog.h:36
#define MCXT_ALLOC_NO_OOM
Definition: fe_memutils.h:29
void guc_free(void *ptr)
Definition: guc.c:689
char * guc_strdup(int elevel, const char *src)
Definition: guc.c:677
void pfree(void *pointer)
Definition: mcxt.c:1524
char * pg_clean_ascii(const char *str, int alloc_flags)
Definition: string.c:85

References guc_free(), guc_strdup(), MCXT_ALLOC_NO_OOM, newval, pfree(), pg_clean_ascii(), and WARNING.

◆ check_autovacuum_work_mem()

bool check_autovacuum_work_mem ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 3383 of file autovacuum.c.

3384{
3385 /*
3386 * -1 indicates fallback.
3387 *
3388 * If we haven't yet changed the boot_val default of -1, just let it be.
3389 * Autovacuum will look to maintenance_work_mem instead.
3390 */
3391 if (*newval == -1)
3392 return true;
3393
3394 /*
3395 * We clamp manually-set values to at least 64kB. Since
3396 * maintenance_work_mem is always set to at least this value, do the same
3397 * here.
3398 */
3399 if (*newval < 64)
3400 *newval = 64;
3401
3402 return true;
3403}

References newval.

◆ check_backtrace_functions()

bool check_backtrace_functions ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 2167 of file elog.c.

2168{
2169 int newvallen = strlen(*newval);
2170 char *someval;
2171 int validlen;
2172 int i;
2173 int j;
2174
2175 /*
2176 * Allow characters that can be C identifiers and commas as separators, as
2177 * well as some whitespace for readability.
2178 */
2179 validlen = strspn(*newval,
2180 "0123456789_"
2181 "abcdefghijklmnopqrstuvwxyz"
2182 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
2183 ", \n\t");
2184 if (validlen != newvallen)
2185 {
2186 GUC_check_errdetail("Invalid character.");
2187 return false;
2188 }
2189
2190 if (*newval[0] == '\0')
2191 {
2192 *extra = NULL;
2193 return true;
2194 }
2195
2196 /*
2197 * Allocate space for the output and create the copy. We could discount
2198 * whitespace chars to save some memory, but it doesn't seem worth the
2199 * trouble.
2200 */
2201 someval = guc_malloc(ERROR, newvallen + 1 + 1);
2202 for (i = 0, j = 0; i < newvallen; i++)
2203 {
2204 if ((*newval)[i] == ',')
2205 someval[j++] = '\0'; /* next item */
2206 else if ((*newval)[i] == ' ' ||
2207 (*newval)[i] == '\n' ||
2208 (*newval)[i] == '\t')
2209 ; /* ignore these */
2210 else
2211 someval[j++] = (*newval)[i]; /* copy anything else */
2212 }
2213
2214 /* two \0s end the setting */
2215 someval[j] = '\0';
2216 someval[j + 1] = '\0';
2217
2218 *extra = someval;
2219 return true;
2220}
#define ERROR
Definition: elog.h:39
void * guc_malloc(int elevel, size_t size)
Definition: guc.c:638
#define GUC_check_errdetail
Definition: guc.h:481
int j
Definition: isn.c:75
int i
Definition: isn.c:74

References ERROR, GUC_check_errdetail, guc_malloc(), i, j, and newval.

◆ check_bonjour()

bool check_bonjour ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1225 of file variable.c.

1226{
1227#ifndef USE_BONJOUR
1228 if (*newval)
1229 {
1230 GUC_check_errmsg("Bonjour is not supported by this build");
1231 return false;
1232 }
1233#endif
1234 return true;
1235}
#define GUC_check_errmsg
Definition: guc.h:477

References GUC_check_errmsg, and newval.

◆ check_canonical_path()

bool check_canonical_path ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 1059 of file variable.c.

1060{
1061 /*
1062 * Since canonicalize_path never enlarges the string, we can just modify
1063 * newval in-place. But watch out for NULL, which is the default value
1064 * for external_pid_file.
1065 */
1066 if (*newval)
1068 return true;
1069}
void canonicalize_path(char *path)
Definition: path.c:337

References canonicalize_path(), and newval.

◆ check_client_connection_check_interval()

bool check_client_connection_check_interval ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 3518 of file postgres.c.

3519{
3520 if (!WaitEventSetCanReportClosed() && *newval != 0)
3521 {
3522 GUC_check_errdetail("\"client_connection_check_interval\" must be set to 0 on this platform.");
3523 return false;
3524 }
3525 return true;
3526}
bool WaitEventSetCanReportClosed(void)

References GUC_check_errdetail, newval, and WaitEventSetCanReportClosed().

◆ check_client_encoding()

bool check_client_encoding ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 688 of file variable.c.

689{
690 int encoding;
691 const char *canonical_name;
692
693 /* Look up the encoding by name */
695 if (encoding < 0)
696 return false;
697
698 /* Get the canonical name (no aliases, uniform case) */
699 canonical_name = pg_encoding_to_char(encoding);
700
701 /*
702 * Parallel workers send data to the leader, not the client. They always
703 * send data using the database encoding; therefore, we should never
704 * actually change the client encoding in a parallel worker. However,
705 * during parallel worker startup, we want to accept the leader's
706 * client_encoding setting so that anyone who looks at the value in the
707 * worker sees the same value that they would see in the leader. A change
708 * other than during startup, for example due to a SET clause attached to
709 * a function definition, should be rejected, as there is nothing we can
710 * do inside the worker to make it take effect.
711 */
713 {
714 GUC_check_errcode(ERRCODE_INVALID_TRANSACTION_STATE);
715 GUC_check_errdetail("Cannot change \"client_encoding\" during a parallel operation.");
716 return false;
717 }
718
719 /*
720 * If we are not within a transaction then PrepareClientEncoding will not
721 * be able to look up the necessary conversion procs. If we are still
722 * starting up, it will return "OK" anyway, and InitializeClientEncoding
723 * will fix things once initialization is far enough along. After
724 * startup, we'll fail. This would only happen if someone tries to change
725 * client_encoding in postgresql.conf and then SIGHUP existing sessions.
726 * It seems like a bad idea for client_encoding to change that way anyhow,
727 * so we don't go out of our way to support it.
728 *
729 * In a parallel worker, we might as well skip PrepareClientEncoding since
730 * we're not going to use its results.
731 *
732 * Note: in the postmaster, or any other process that never calls
733 * InitializeClientEncoding, PrepareClientEncoding will always succeed,
734 * and so will SetClientEncoding; but they won't do anything, which is OK.
735 */
736 if (!IsParallelWorker() &&
738 {
739 if (IsTransactionState())
740 {
741 /* Must be a genuine no-such-conversion problem */
742 GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
743 GUC_check_errdetail("Conversion between %s and %s is not supported.",
744 canonical_name,
746 }
747 else
748 {
749 /* Provide a useful complaint */
750 GUC_check_errdetail("Cannot change \"client_encoding\" now.");
751 }
752 return false;
753 }
754
755 /*
756 * Replace the user-supplied string with the encoding's canonical name.
757 * This gets rid of aliases and case-folding variations.
758 *
759 * XXX Although canonicalizing seems like a good idea in the abstract, it
760 * breaks pre-9.1 JDBC drivers, which expect that if they send "UNICODE"
761 * as the client_encoding setting then it will read back the same way. As
762 * a workaround, don't replace the string if it's "UNICODE". Remove that
763 * hack when pre-9.1 JDBC drivers are no longer in use.
764 */
765 if (strcmp(*newval, canonical_name) != 0 &&
766 strcmp(*newval, "UNICODE") != 0)
767 {
769 *newval = guc_strdup(LOG, canonical_name);
770 if (!*newval)
771 return false;
772 }
773
774 /*
775 * Save the encoding's ID in *extra, for use by assign_client_encoding.
776 */
777 *extra = guc_malloc(LOG, sizeof(int));
778 if (!*extra)
779 return false;
780 *((int *) *extra) = encoding;
781
782 return true;
783}
bool InitializingParallelWorker
Definition: parallel.c:121
int pg_valid_client_encoding(const char *name)
Definition: encnames.c:485
void GUC_check_errcode(int sqlerrcode)
Definition: guc.c:6785
const char * GetDatabaseEncodingName(void)
Definition: mbutils.c:1267
int PrepareClientEncoding(int encoding)
Definition: mbutils.c:110
#define pg_encoding_to_char
Definition: pg_wchar.h:630

References encoding, GetDatabaseEncodingName(), GUC_check_errcode(), GUC_check_errdetail, guc_free(), guc_malloc(), guc_strdup(), InitializingParallelWorker, IsParallelWorker, IsTransactionState(), LOG, newval, pg_encoding_to_char, pg_valid_client_encoding(), and PrepareClientEncoding().

◆ check_cluster_name()

bool check_cluster_name ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 1118 of file variable.c.

1119{
1120 char *clean;
1121 char *ret;
1122
1123 /* Only allow clean ASCII chars in the cluster name */
1125 if (!clean)
1126 return false;
1127
1128 ret = guc_strdup(WARNING, clean);
1129 if (!ret)
1130 {
1131 pfree(clean);
1132 return false;
1133 }
1134
1135 guc_free(*newval);
1136
1137 pfree(clean);
1138 *newval = ret;
1139 return true;
1140}

References guc_free(), guc_strdup(), MCXT_ALLOC_NO_OOM, newval, pfree(), pg_clean_ascii(), and WARNING.

◆ check_commit_ts_buffers()

bool check_commit_ts_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 584 of file commit_ts.c.

585{
586 return check_slru_buffers("commit_timestamp_buffers", newval);
587}
bool check_slru_buffers(const char *name, int *newval)
Definition: slru.c:355

References check_slru_buffers(), and newval.

◆ check_datestyle()

bool check_datestyle ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 52 of file variable.c.

53{
54 int newDateStyle = DateStyle;
55 int newDateOrder = DateOrder;
56 bool have_style = false;
57 bool have_order = false;
58 bool ok = true;
59 char *rawstring;
60 int *myextra;
61 char *result;
62 List *elemlist;
63 ListCell *l;
64
65 /* Need a modifiable copy of string */
66 rawstring = pstrdup(*newval);
67
68 /* Parse string into list of identifiers */
69 if (!SplitIdentifierString(rawstring, ',', &elemlist))
70 {
71 /* syntax error in list */
72 GUC_check_errdetail("List syntax is invalid.");
73 pfree(rawstring);
74 list_free(elemlist);
75 return false;
76 }
77
78 foreach(l, elemlist)
79 {
80 char *tok = (char *) lfirst(l);
81
82 /* Ugh. Somebody ought to write a table driven version -- mjl */
83
84 if (pg_strcasecmp(tok, "ISO") == 0)
85 {
86 if (have_style && newDateStyle != USE_ISO_DATES)
87 ok = false; /* conflicting styles */
88 newDateStyle = USE_ISO_DATES;
89 have_style = true;
90 }
91 else if (pg_strcasecmp(tok, "SQL") == 0)
92 {
93 if (have_style && newDateStyle != USE_SQL_DATES)
94 ok = false; /* conflicting styles */
95 newDateStyle = USE_SQL_DATES;
96 have_style = true;
97 }
98 else if (pg_strncasecmp(tok, "POSTGRES", 8) == 0)
99 {
100 if (have_style && newDateStyle != USE_POSTGRES_DATES)
101 ok = false; /* conflicting styles */
102 newDateStyle = USE_POSTGRES_DATES;
103 have_style = true;
104 }
105 else if (pg_strcasecmp(tok, "GERMAN") == 0)
106 {
107 if (have_style && newDateStyle != USE_GERMAN_DATES)
108 ok = false; /* conflicting styles */
109 newDateStyle = USE_GERMAN_DATES;
110 have_style = true;
111 /* GERMAN also sets DMY, unless explicitly overridden */
112 if (!have_order)
113 newDateOrder = DATEORDER_DMY;
114 }
115 else if (pg_strcasecmp(tok, "YMD") == 0)
116 {
117 if (have_order && newDateOrder != DATEORDER_YMD)
118 ok = false; /* conflicting orders */
119 newDateOrder = DATEORDER_YMD;
120 have_order = true;
121 }
122 else if (pg_strcasecmp(tok, "DMY") == 0 ||
123 pg_strncasecmp(tok, "EURO", 4) == 0)
124 {
125 if (have_order && newDateOrder != DATEORDER_DMY)
126 ok = false; /* conflicting orders */
127 newDateOrder = DATEORDER_DMY;
128 have_order = true;
129 }
130 else if (pg_strcasecmp(tok, "MDY") == 0 ||
131 pg_strcasecmp(tok, "US") == 0 ||
132 pg_strncasecmp(tok, "NONEURO", 7) == 0)
133 {
134 if (have_order && newDateOrder != DATEORDER_MDY)
135 ok = false; /* conflicting orders */
136 newDateOrder = DATEORDER_MDY;
137 have_order = true;
138 }
139 else if (pg_strcasecmp(tok, "DEFAULT") == 0)
140 {
141 /*
142 * Easiest way to get the current DEFAULT state is to fetch the
143 * DEFAULT string from guc.c and recursively parse it.
144 *
145 * We can't simply "return check_datestyle(...)" because we need
146 * to handle constructs like "DEFAULT, ISO".
147 */
148 char *subval;
149 void *subextra = NULL;
150
151 subval = guc_strdup(LOG, GetConfigOptionResetString("datestyle"));
152 if (!subval)
153 {
154 ok = false;
155 break;
156 }
157 if (!check_datestyle(&subval, &subextra, source))
158 {
159 guc_free(subval);
160 ok = false;
161 break;
162 }
163 myextra = (int *) subextra;
164 if (!have_style)
165 newDateStyle = myextra[0];
166 if (!have_order)
167 newDateOrder = myextra[1];
168 guc_free(subval);
169 guc_free(subextra);
170 }
171 else
172 {
173 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
174 pfree(rawstring);
175 list_free(elemlist);
176 return false;
177 }
178 }
179
180 pfree(rawstring);
181 list_free(elemlist);
182
183 if (!ok)
184 {
185 GUC_check_errdetail("Conflicting \"DateStyle\" specifications.");
186 return false;
187 }
188
189 /*
190 * Prepare the canonical string to return. GUC wants it guc_malloc'd.
191 */
192 result = (char *) guc_malloc(LOG, 32);
193 if (!result)
194 return false;
195
196 switch (newDateStyle)
197 {
198 case USE_ISO_DATES:
199 strcpy(result, "ISO");
200 break;
201 case USE_SQL_DATES:
202 strcpy(result, "SQL");
203 break;
204 case USE_GERMAN_DATES:
205 strcpy(result, "German");
206 break;
207 default:
208 strcpy(result, "Postgres");
209 break;
210 }
211 switch (newDateOrder)
212 {
213 case DATEORDER_YMD:
214 strcat(result, ", YMD");
215 break;
216 case DATEORDER_DMY:
217 strcat(result, ", DMY");
218 break;
219 default:
220 strcat(result, ", MDY");
221 break;
222 }
223
225 *newval = result;
226
227 /*
228 * Set up the "extra" struct actually used by assign_datestyle.
229 */
230 myextra = (int *) guc_malloc(LOG, 2 * sizeof(int));
231 if (!myextra)
232 return false;
233 myextra[0] = newDateStyle;
234 myextra[1] = newDateOrder;
235 *extra = myextra;
236
237 return true;
238}
bool check_datestyle(char **newval, void **extra, GucSource source)
Definition: variable.c:52
const char * GetConfigOptionResetString(const char *name)
Definition: guc.c:4405
void list_free(List *list)
Definition: list.c:1546
char * pstrdup(const char *in)
Definition: mcxt.c:1699
#define USE_SQL_DATES
Definition: miscadmin.h:237
#define USE_POSTGRES_DATES
Definition: miscadmin.h:235
#define USE_ISO_DATES
Definition: miscadmin.h:236
#define DATEORDER_DMY
Definition: miscadmin.h:243
#define DATEORDER_MDY
Definition: miscadmin.h:244
#define DATEORDER_YMD
Definition: miscadmin.h:242
#define USE_GERMAN_DATES
Definition: miscadmin.h:238
#define lfirst(lc)
Definition: pg_list.h:172
static rewind_source * source
Definition: pg_rewind.c:89
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
Definition: pgstrcasecmp.c:69
Definition: pg_list.h:54
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
Definition: varlena.c:3525

References check_datestyle(), DateOrder, DATEORDER_DMY, DATEORDER_MDY, DATEORDER_YMD, DateStyle, GetConfigOptionResetString(), GUC_check_errdetail, guc_free(), guc_malloc(), guc_strdup(), lfirst, list_free(), LOG, newval, pfree(), pg_strcasecmp(), pg_strncasecmp(), pstrdup(), source, SplitIdentifierString(), USE_GERMAN_DATES, USE_ISO_DATES, USE_POSTGRES_DATES, and USE_SQL_DATES.

Referenced by check_datestyle().

◆ check_debug_io_direct()

bool check_debug_io_direct ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 3965 of file fd.c.

3966{
3967 bool result = true;
3968 int flags;
3969
3970#if PG_O_DIRECT == 0
3971 if (strcmp(*newval, "") != 0)
3972 {
3973 GUC_check_errdetail("\"%s\" is not supported on this platform.",
3974 "debug_io_direct");
3975 result = false;
3976 }
3977 flags = 0;
3978#else
3979 List *elemlist;
3980 ListCell *l;
3981 char *rawstring;
3982
3983 /* Need a modifiable copy of string */
3984 rawstring = pstrdup(*newval);
3985
3986 if (!SplitGUCList(rawstring, ',', &elemlist))
3987 {
3988 GUC_check_errdetail("Invalid list syntax in parameter \"%s\".",
3989 "debug_io_direct");
3990 pfree(rawstring);
3991 list_free(elemlist);
3992 return false;
3993 }
3994
3995 flags = 0;
3996 foreach(l, elemlist)
3997 {
3998 char *item = (char *) lfirst(l);
3999
4000 if (pg_strcasecmp(item, "data") == 0)
4001 flags |= IO_DIRECT_DATA;
4002 else if (pg_strcasecmp(item, "wal") == 0)
4003 flags |= IO_DIRECT_WAL;
4004 else if (pg_strcasecmp(item, "wal_init") == 0)
4005 flags |= IO_DIRECT_WAL_INIT;
4006 else
4007 {
4008 GUC_check_errdetail("Invalid option \"%s\".", item);
4009 result = false;
4010 break;
4011 }
4012 }
4013
4014 /*
4015 * It's possible to configure block sizes smaller than our assumed I/O
4016 * alignment size, which could result in invalid I/O requests.
4017 */
4018#if XLOG_BLCKSZ < PG_IO_ALIGN_SIZE
4019 if (result && (flags & (IO_DIRECT_WAL | IO_DIRECT_WAL_INIT)))
4020 {
4021 GUC_check_errdetail("\"%s\" is not supported for WAL because %s is too small.",
4022 "debug_io_direct", "XLOG_BLCKSZ");
4023 result = false;
4024 }
4025#endif
4026#if BLCKSZ < PG_IO_ALIGN_SIZE
4027 if (result && (flags & IO_DIRECT_DATA))
4028 {
4029 GUC_check_errdetail("\"%s\" is not supported for data because %s is too small.",
4030 "debug_io_direct", "BLCKSZ");
4031 result = false;
4032 }
4033#endif
4034
4035 pfree(rawstring);
4036 list_free(elemlist);
4037#endif
4038
4039 if (!result)
4040 return result;
4041
4042 /* Save the flags in *extra, for use by assign_debug_io_direct */
4043 *extra = guc_malloc(ERROR, sizeof(int));
4044 *((int *) *extra) = flags;
4045
4046 return result;
4047}
#define IO_DIRECT_WAL
Definition: fd.h:55
#define IO_DIRECT_DATA
Definition: fd.h:54
#define IO_DIRECT_WAL_INIT
Definition: fd.h:56
bool SplitGUCList(char *rawstring, char separator, List **namelist)
Definition: varlena.c:3773

References ERROR, GUC_check_errdetail, guc_malloc(), IO_DIRECT_DATA, IO_DIRECT_WAL, IO_DIRECT_WAL_INIT, lfirst, list_free(), newval, pfree(), pg_strcasecmp(), pstrdup(), and SplitGUCList().

◆ check_default_table_access_method()

bool check_default_table_access_method ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 102 of file tableamapi.c.

103{
104 if (**newval == '\0')
105 {
106 GUC_check_errdetail("\"%s\" cannot be empty.",
107 "default_table_access_method");
108 return false;
109 }
110
111 if (strlen(*newval) >= NAMEDATALEN)
112 {
113 GUC_check_errdetail("\"%s\" is too long (maximum %d characters).",
114 "default_table_access_method", NAMEDATALEN - 1);
115 return false;
116 }
117
118 /*
119 * If we aren't inside a transaction, or not connected to a database, we
120 * cannot do the catalog access necessary to verify the method. Must
121 * accept the value on faith.
122 */
124 {
125 if (!OidIsValid(get_table_am_oid(*newval, true)))
126 {
127 /*
128 * When source == PGC_S_TEST, don't throw a hard error for a
129 * nonexistent table access method, only a NOTICE. See comments in
130 * guc.h.
131 */
132 if (source == PGC_S_TEST)
133 {
135 (errcode(ERRCODE_UNDEFINED_OBJECT),
136 errmsg("table access method \"%s\" does not exist",
137 *newval)));
138 }
139 else
140 {
141 GUC_check_errdetail("Table access method \"%s\" does not exist.",
142 *newval);
143 return false;
144 }
145 }
146 }
147
148 return true;
149}
Oid get_table_am_oid(const char *amname, bool missing_ok)
Definition: amcmds.c:173
#define OidIsValid(objectId)
Definition: c.h:746
int errcode(int sqlerrcode)
Definition: elog.c:853
#define NOTICE
Definition: elog.h:35
Oid MyDatabaseId
Definition: globals.c:93
@ PGC_S_TEST
Definition: guc.h:125
#define NAMEDATALEN

References ereport, errcode(), errmsg(), get_table_am_oid(), GUC_check_errdetail, InvalidOid, IsTransactionState(), MyDatabaseId, NAMEDATALEN, newval, NOTICE, OidIsValid, PGC_S_TEST, and source.

◆ check_default_tablespace()

bool check_default_tablespace ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 1091 of file tablespace.c.

1092{
1093 /*
1094 * If we aren't inside a transaction, or connected to a database, we
1095 * cannot do the catalog accesses necessary to verify the name. Must
1096 * accept the value on faith.
1097 */
1099 {
1100 if (**newval != '\0' &&
1102 {
1103 /*
1104 * When source == PGC_S_TEST, don't throw a hard error for a
1105 * nonexistent tablespace, only a NOTICE. See comments in guc.h.
1106 */
1107 if (source == PGC_S_TEST)
1108 {
1110 (errcode(ERRCODE_UNDEFINED_OBJECT),
1111 errmsg("tablespace \"%s\" does not exist",
1112 *newval)));
1113 }
1114 else
1115 {
1116 GUC_check_errdetail("Tablespace \"%s\" does not exist.",
1117 *newval);
1118 return false;
1119 }
1120 }
1121 }
1122
1123 return true;
1124}
Oid get_tablespace_oid(const char *tablespacename, bool missing_ok)
Definition: tablespace.c:1426

References ereport, errcode(), errmsg(), get_tablespace_oid(), GUC_check_errdetail, InvalidOid, IsTransactionState(), MyDatabaseId, newval, NOTICE, OidIsValid, PGC_S_TEST, and source.

◆ check_default_text_search_config()

bool check_default_text_search_config ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 602 of file ts_cache.c.

603{
604 /*
605 * If we aren't inside a transaction, or connected to a database, we
606 * cannot do the catalog accesses necessary to verify the config name.
607 * Must accept it on faith.
608 */
610 {
611 ErrorSaveContext escontext = {T_ErrorSaveContext};
612 List *namelist;
613 Oid cfgId;
614 HeapTuple tuple;
616 char *buf;
617
619 (Node *) &escontext);
620 if (namelist != NIL)
621 cfgId = get_ts_config_oid(namelist, true);
622 else
623 cfgId = InvalidOid; /* bad name list syntax */
624
625 /*
626 * When source == PGC_S_TEST, don't throw a hard error for a
627 * nonexistent configuration, only a NOTICE. See comments in guc.h.
628 */
629 if (!OidIsValid(cfgId))
630 {
631 if (source == PGC_S_TEST)
632 {
634 (errcode(ERRCODE_UNDEFINED_OBJECT),
635 errmsg("text search configuration \"%s\" does not exist", *newval)));
636 return true;
637 }
638 else
639 return false;
640 }
641
642 /*
643 * Modify the actually stored value to be fully qualified, to ensure
644 * later changes of search_path don't affect it.
645 */
646 tuple = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgId));
647 if (!HeapTupleIsValid(tuple))
648 elog(ERROR, "cache lookup failed for text search configuration %u",
649 cfgId);
650 cfg = (Form_pg_ts_config) GETSTRUCT(tuple);
651
653 NameStr(cfg->cfgname));
654
655 ReleaseSysCache(tuple);
656
657 /* GUC wants it guc_malloc'd not palloc'd */
660 pfree(buf);
661 if (!*newval)
662 return false;
663 }
664
665 return true;
666}
#define NameStr(name)
Definition: c.h:717
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3449
Oid get_ts_config_oid(List *names, bool missing_ok)
Definition: namespace.c:3152
#define NIL
Definition: pg_list.h:68
static char * buf
Definition: pg_test_fsync.c:72
FormData_pg_ts_config * Form_pg_ts_config
Definition: pg_ts_config.h:48
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:257
unsigned int Oid
Definition: postgres_ext.h:32
List * stringToQualifiedNameList(const char *string, Node *escontext)
Definition: regproc.c:1797
char * quote_qualified_identifier(const char *qualifier, const char *ident)
Definition: ruleutils.c:13103
Definition: nodes.h:131
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:269
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:221

References buf, elog, ereport, errcode(), errmsg(), ERROR, get_namespace_name(), get_ts_config_oid(), GETSTRUCT(), guc_free(), guc_strdup(), HeapTupleIsValid, InvalidOid, IsTransactionState(), LOG, MyDatabaseId, NameStr, newval, NIL, NOTICE, ObjectIdGetDatum(), OidIsValid, pfree(), PGC_S_TEST, quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), source, and stringToQualifiedNameList().

◆ check_default_with_oids()

bool check_default_with_oids ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1238 of file variable.c.

1239{
1240 if (*newval)
1241 {
1242 /* check the GUC's definition for an explanation */
1243 GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
1244 GUC_check_errmsg("tables declared WITH OIDS are not supported");
1245
1246 return false;
1247 }
1248
1249 return true;
1250}

References GUC_check_errcode(), GUC_check_errmsg, and newval.

◆ check_effective_io_concurrency()

bool check_effective_io_concurrency ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1253 of file variable.c.

1254{
1255#ifndef USE_PREFETCH
1256 if (*newval != 0)
1257 {
1258 GUC_check_errdetail("\"%s\" must be set to 0 on platforms that lack support for issuing read-ahead advice.",
1259 "effective_io_concurrency");
1260 return false;
1261 }
1262#endif /* USE_PREFETCH */
1263 return true;
1264}

References GUC_check_errdetail, and newval.

◆ check_huge_page_size()

bool check_huge_page_size ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 578 of file sysv_shmem.c.

579{
580#if !(defined(MAP_HUGE_MASK) && defined(MAP_HUGE_SHIFT))
581 /* Recent enough Linux only, for now. See GetHugePageSize(). */
582 if (*newval != 0)
583 {
584 GUC_check_errdetail("\"huge_page_size\" must be 0 on this platform.");
585 return false;
586 }
587#endif
588 return true;
589}

References GUC_check_errdetail, and newval.

◆ check_idle_replication_slot_timeout()

bool check_idle_replication_slot_timeout ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 3002 of file slot.c.

3003{
3004 if (IsBinaryUpgrade && *newval != 0)
3005 {
3006 GUC_check_errdetail("\"%s\" must be set to 0 during binary upgrade mode.",
3007 "idle_replication_slot_timeout");
3008 return false;
3009 }
3010
3011 return true;
3012}
bool IsBinaryUpgrade
Definition: globals.c:120

References GUC_check_errdetail, IsBinaryUpgrade, and newval.

◆ check_io_max_concurrency()

bool check_io_max_concurrency ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1165 of file aio.c.

1166{
1167 if (*newval == -1)
1168 {
1169 /*
1170 * Auto-tuning will be applied later during startup, as auto-tuning
1171 * depends on the value of various GUCs.
1172 */
1173 return true;
1174 }
1175 else if (*newval == 0)
1176 {
1177 GUC_check_errdetail("Only -1 or values bigger than 0 are valid.");
1178 return false;
1179 }
1180
1181 return true;
1182}

References GUC_check_errdetail, and newval.

◆ check_locale_messages()

bool check_locale_messages ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 425 of file pg_locale.c.

426{
427 if (**newval == '\0')
428 {
429 if (source == PGC_S_DEFAULT)
430 return true;
431 else
432 return false;
433 }
434
435 /*
436 * LC_MESSAGES category does not exist everywhere, but accept it anyway
437 *
438 * On Windows, we can't even check the value, so accept blindly
439 */
440#if defined(LC_MESSAGES) && !defined(WIN32)
441 return check_locale(LC_MESSAGES, *newval, NULL);
442#else
443 return true;
444#endif
445}
@ PGC_S_DEFAULT
Definition: guc.h:113
bool check_locale(int category, const char *locale, char **canonname)
Definition: pg_locale.c:314

References check_locale(), newval, PGC_S_DEFAULT, and source.

◆ check_locale_monetary()

bool check_locale_monetary ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 379 of file pg_locale.c.

380{
381 return check_locale(LC_MONETARY, *newval, NULL);
382}

References check_locale(), and newval.

◆ check_locale_numeric()

bool check_locale_numeric ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 391 of file pg_locale.c.

392{
393 return check_locale(LC_NUMERIC, *newval, NULL);
394}

References check_locale(), and newval.

◆ check_locale_time()

bool check_locale_time ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 403 of file pg_locale.c.

404{
405 return check_locale(LC_TIME, *newval, NULL);
406}

References check_locale(), and newval.

◆ check_log_connections()

bool check_log_connections ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 1049 of file backend_startup.c.

1050{
1051 uint32 flags;
1052 char *rawstring;
1053 List *elemlist;
1054 bool success;
1055
1056 /* Need a modifiable copy of string */
1057 rawstring = pstrdup(*newval);
1058
1059 if (!SplitIdentifierString(rawstring, ',', &elemlist))
1060 {
1061 GUC_check_errdetail("Invalid list syntax in parameter \"log_connections\".");
1062 pfree(rawstring);
1063 list_free(elemlist);
1064 return false;
1065 }
1066
1067 /* Validation logic is all in the helper */
1068 success = validate_log_connections_options(elemlist, &flags);
1069
1070 /* Time for cleanup */
1071 pfree(rawstring);
1072 list_free(elemlist);
1073
1074 if (!success)
1075 return false;
1076
1077 /*
1078 * We succeeded, so allocate `extra` and save the flags there for use by
1079 * assign_log_connections().
1080 */
1081 *extra = guc_malloc(ERROR, sizeof(int));
1082 *((int *) *extra) = flags;
1083
1084 return true;
1085}
static bool validate_log_connections_options(List *elemlist, uint32 *flags)
uint32_t uint32
Definition: c.h:502
static bool success
Definition: initdb.c:186

References ERROR, GUC_check_errdetail, guc_malloc(), list_free(), newval, pfree(), pstrdup(), SplitIdentifierString(), success, and validate_log_connections_options().

◆ check_log_destination()

bool check_log_destination ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 2235 of file elog.c.

2236{
2237 char *rawstring;
2238 List *elemlist;
2239 ListCell *l;
2240 int newlogdest = 0;
2241 int *myextra;
2242
2243 /* Need a modifiable copy of string */
2244 rawstring = pstrdup(*newval);
2245
2246 /* Parse string into list of identifiers */
2247 if (!SplitIdentifierString(rawstring, ',', &elemlist))
2248 {
2249 /* syntax error in list */
2250 GUC_check_errdetail("List syntax is invalid.");
2251 pfree(rawstring);
2252 list_free(elemlist);
2253 return false;
2254 }
2255
2256 foreach(l, elemlist)
2257 {
2258 char *tok = (char *) lfirst(l);
2259
2260 if (pg_strcasecmp(tok, "stderr") == 0)
2261 newlogdest |= LOG_DESTINATION_STDERR;
2262 else if (pg_strcasecmp(tok, "csvlog") == 0)
2263 newlogdest |= LOG_DESTINATION_CSVLOG;
2264 else if (pg_strcasecmp(tok, "jsonlog") == 0)
2265 newlogdest |= LOG_DESTINATION_JSONLOG;
2266#ifdef HAVE_SYSLOG
2267 else if (pg_strcasecmp(tok, "syslog") == 0)
2268 newlogdest |= LOG_DESTINATION_SYSLOG;
2269#endif
2270#ifdef WIN32
2271 else if (pg_strcasecmp(tok, "eventlog") == 0)
2272 newlogdest |= LOG_DESTINATION_EVENTLOG;
2273#endif
2274 else
2275 {
2276 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
2277 pfree(rawstring);
2278 list_free(elemlist);
2279 return false;
2280 }
2281 }
2282
2283 pfree(rawstring);
2284 list_free(elemlist);
2285
2286 myextra = (int *) guc_malloc(ERROR, sizeof(int));
2287 *myextra = newlogdest;
2288 *extra = myextra;
2289
2290 return true;
2291}
#define LOG_DESTINATION_JSONLOG
Definition: elog.h:488
#define LOG_DESTINATION_SYSLOG
Definition: elog.h:485
#define LOG_DESTINATION_STDERR
Definition: elog.h:484
#define LOG_DESTINATION_EVENTLOG
Definition: elog.h:486
#define LOG_DESTINATION_CSVLOG
Definition: elog.h:487

References ERROR, GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG_DESTINATION_CSVLOG, LOG_DESTINATION_EVENTLOG, LOG_DESTINATION_JSONLOG, LOG_DESTINATION_STDERR, LOG_DESTINATION_SYSLOG, newval, pfree(), pg_strcasecmp(), pstrdup(), and SplitIdentifierString().

◆ check_log_stats()

bool check_log_stats ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 3553 of file postgres.c.

3554{
3555 if (*newval &&
3557 {
3558 GUC_check_errdetail("Cannot enable \"log_statement_stats\" when "
3559 "\"log_parser_stats\", \"log_planner_stats\", "
3560 "or \"log_executor_stats\" is true.");
3561 return false;
3562 }
3563 return true;
3564}
bool log_parser_stats
Definition: guc_tables.c:507
bool log_planner_stats
Definition: guc_tables.c:508
bool log_executor_stats
Definition: guc_tables.c:509

References GUC_check_errdetail, log_executor_stats, log_parser_stats, log_planner_stats, and newval.

◆ check_log_timezone()

bool check_log_timezone ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 418 of file variable.c.

419{
420 pg_tz *new_tz;
421
422 /*
423 * Assume it is a timezone name, and try to load it.
424 */
425 new_tz = pg_tzset(*newval);
426
427 if (!new_tz)
428 {
429 /* Doesn't seem to be any great value in errdetail here */
430 return false;
431 }
432
433 if (!pg_tz_acceptable(new_tz))
434 {
435 GUC_check_errmsg("time zone \"%s\" appears to use leap seconds",
436 *newval);
437 GUC_check_errdetail("PostgreSQL does not support leap seconds.");
438 return false;
439 }
440
441 /*
442 * Pass back data for assign_log_timezone to use
443 */
444 *extra = guc_malloc(LOG, sizeof(pg_tz *));
445 if (!*extra)
446 return false;
447 *((pg_tz **) *extra) = new_tz;
448
449 return true;
450}
bool pg_tz_acceptable(pg_tz *tz)
Definition: localtime.c:2004
pg_tz * pg_tzset(const char *tzname)
Definition: pgtz.c:234

References GUC_check_errdetail, GUC_check_errmsg, guc_malloc(), LOG, newval, pg_tz_acceptable(), and pg_tzset().

◆ check_maintenance_io_concurrency()

bool check_maintenance_io_concurrency ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1267 of file variable.c.

1268{
1269#ifndef USE_PREFETCH
1270 if (*newval != 0)
1271 {
1272 GUC_check_errdetail("\"%s\" must be set to 0 on platforms that lack support for issuing read-ahead advice.",
1273 "maintenance_io_concurrency");
1274 return false;
1275 }
1276#endif /* USE_PREFETCH */
1277 return true;
1278}

References GUC_check_errdetail, and newval.

◆ check_max_slot_wal_keep_size()

bool check_max_slot_wal_keep_size ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 2223 of file xlog.c.

2224{
2225 if (IsBinaryUpgrade && *newval != -1)
2226 {
2227 GUC_check_errdetail("\"%s\" must be set to -1 during binary upgrade mode.",
2228 "max_slot_wal_keep_size");
2229 return false;
2230 }
2231
2232 return true;
2233}

References GUC_check_errdetail, IsBinaryUpgrade, and newval.

◆ check_max_stack_depth()

bool check_max_stack_depth ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 142 of file stack_depth.c.

143{
144 ssize_t newval_bytes = *newval * (ssize_t) 1024;
145 ssize_t stack_rlimit = get_stack_depth_rlimit();
146
147 if (stack_rlimit > 0 && newval_bytes > stack_rlimit - STACK_DEPTH_SLOP)
148 {
149 GUC_check_errdetail("\"max_stack_depth\" must not exceed %zdkB.",
150 (stack_rlimit - STACK_DEPTH_SLOP) / 1024);
151 GUC_check_errhint("Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent.");
152 return false;
153 }
154 return true;
155}
#define GUC_check_errhint
Definition: guc.h:485
#define STACK_DEPTH_SLOP
Definition: miscadmin.h:296
ssize_t get_stack_depth_rlimit(void)
Definition: stack_depth.c:176

References get_stack_depth_rlimit(), GUC_check_errdetail, GUC_check_errhint, newval, and STACK_DEPTH_SLOP.

◆ check_multixact_member_buffers()

bool check_multixact_member_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 2023 of file multixact.c.

2024{
2025 return check_slru_buffers("multixact_member_buffers", newval);
2026}

References check_slru_buffers(), and newval.

◆ check_multixact_offset_buffers()

bool check_multixact_offset_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 2014 of file multixact.c.

2015{
2016 return check_slru_buffers("multixact_offset_buffers", newval);
2017}

References check_slru_buffers(), and newval.

◆ check_notify_buffers()

bool check_notify_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 2394 of file async.c.

2395{
2396 return check_slru_buffers("notify_buffers", newval);
2397}

References check_slru_buffers(), and newval.

◆ check_primary_slot_name()

bool check_primary_slot_name ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 4754 of file xlogrecovery.c.

4755{
4756 if (*newval && strcmp(*newval, "") != 0 &&
4758 return false;
4759
4760 return true;
4761}
bool ReplicationSlotValidateName(const char *name, int elevel)
Definition: slot.c:267

References newval, ReplicationSlotValidateName(), and WARNING.

◆ check_random_seed()

bool check_random_seed ( double *  newval,
void **  extra,
GucSource  source 
)

Definition at line 656 of file variable.c.

657{
658 *extra = guc_malloc(LOG, sizeof(int));
659 if (!*extra)
660 return false;
661 /* Arm the assign only if source of value is an interactive SET */
662 *((int *) *extra) = (source >= PGC_S_INTERACTIVE);
663
664 return true;
665}
@ PGC_S_INTERACTIVE
Definition: guc.h:124

References guc_malloc(), LOG, PGC_S_INTERACTIVE, and source.

◆ check_recovery_prefetch()

bool check_recovery_prefetch ( int *  new_value,
void **  extra,
GucSource  source 
)

Definition at line 1081 of file xlogprefetcher.c.

1082{
1083#ifndef USE_PREFETCH
1084 if (*new_value == RECOVERY_PREFETCH_ON)
1085 {
1086 GUC_check_errdetail("\"recovery_prefetch\" is not supported on platforms that lack support for issuing read-ahead advice.");
1087 return false;
1088 }
1089#endif
1090
1091 return true;
1092}
@ RECOVERY_PREFETCH_ON

References GUC_check_errdetail, and RECOVERY_PREFETCH_ON.

◆ check_recovery_target()

bool check_recovery_target ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 4794 of file xlogrecovery.c.

4795{
4796 if (strcmp(*newval, "immediate") != 0 && strcmp(*newval, "") != 0)
4797 {
4798 GUC_check_errdetail("The only allowed value is \"immediate\".");
4799 return false;
4800 }
4801 return true;
4802}

References GUC_check_errdetail, and newval.

◆ check_recovery_target_lsn()

bool check_recovery_target_lsn ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 4824 of file xlogrecovery.c.

4825{
4826 if (strcmp(*newval, "") != 0)
4827 {
4828 XLogRecPtr lsn;
4829 XLogRecPtr *myextra;
4830 bool have_error = false;
4831
4832 lsn = pg_lsn_in_internal(*newval, &have_error);
4833 if (have_error)
4834 return false;
4835
4836 myextra = (XLogRecPtr *) guc_malloc(ERROR, sizeof(XLogRecPtr));
4837 *myextra = lsn;
4838 *extra = myextra;
4839 }
4840 return true;
4841}
XLogRecPtr pg_lsn_in_internal(const char *str, bool *have_error)
Definition: pg_lsn.c:29

References ERROR, guc_malloc(), newval, and pg_lsn_in_internal().

◆ check_recovery_target_name()

bool check_recovery_target_name ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 4866 of file xlogrecovery.c.

4867{
4868 /* Use the value of newval directly */
4869 if (strlen(*newval) >= MAXFNAMELEN)
4870 {
4871 GUC_check_errdetail("\"%s\" is too long (maximum %d characters).",
4872 "recovery_target_name", MAXFNAMELEN - 1);
4873 return false;
4874 }
4875 return true;
4876}

References GUC_check_errdetail, MAXFNAMELEN, and newval.

◆ check_recovery_target_time()

bool check_recovery_target_time ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 4907 of file xlogrecovery.c.

4908{
4909 if (strcmp(*newval, "") != 0)
4910 {
4911 /* reject some special values */
4912 if (strcmp(*newval, "now") == 0 ||
4913 strcmp(*newval, "today") == 0 ||
4914 strcmp(*newval, "tomorrow") == 0 ||
4915 strcmp(*newval, "yesterday") == 0)
4916 {
4917 return false;
4918 }
4919
4920 /*
4921 * parse timestamp value (see also timestamptz_in())
4922 */
4923 {
4924 char *str = *newval;
4925 fsec_t fsec;
4926 struct pg_tm tt,
4927 *tm = &tt;
4928 int tz;
4929 int dtype;
4930 int nf;
4931 int dterr;
4932 char *field[MAXDATEFIELDS];
4933 int ftype[MAXDATEFIELDS];
4934 char workbuf[MAXDATELEN + MAXDATEFIELDS];
4935 DateTimeErrorExtra dtextra;
4937
4938 dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
4939 field, ftype, MAXDATEFIELDS, &nf);
4940 if (dterr == 0)
4941 dterr = DecodeDateTime(field, ftype, nf,
4942 &dtype, tm, &fsec, &tz, &dtextra);
4943 if (dterr != 0)
4944 return false;
4945 if (dtype != DTK_DATE)
4946 return false;
4947
4948 if (tm2timestamp(tm, fsec, &tz, &timestamp) != 0)
4949 {
4950 GUC_check_errdetail("Timestamp out of range: \"%s\".", str);
4951 return false;
4952 }
4953 }
4954 }
4955 return true;
4956}
int ParseDateTime(const char *timestr, char *workbuf, size_t buflen, char **field, int *ftype, int maxfields, int *numfields)
Definition: datetime.c:764
int DecodeDateTime(char **field, int *ftype, int nf, int *dtype, struct pg_tm *tm, fsec_t *fsec, int *tzp, DateTimeErrorExtra *extra)
Definition: datetime.c:988
int tm2timestamp(struct pg_tm *tm, fsec_t fsec, int *tzp, Timestamp *result)
Definition: timestamp.c:2005
int64 TimestampTz
Definition: timestamp.h:39
int32 fsec_t
Definition: timestamp.h:41
const char * str
#define MAXDATEFIELDS
Definition: datetime.h:202
#define DTK_DATE
Definition: datetime.h:144
#define MAXDATELEN
Definition: datetime.h:200
static struct pg_tm tm
Definition: localtime.c:104
int64 timestamp
Definition: pgtime.h:35

References DecodeDateTime(), DTK_DATE, GUC_check_errdetail, MAXDATEFIELDS, MAXDATELEN, newval, ParseDateTime(), str, tm, and tm2timestamp().

◆ check_recovery_target_timeline()

bool check_recovery_target_timeline ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 4978 of file xlogrecovery.c.

4979{
4982
4983 if (strcmp(*newval, "current") == 0)
4985 else if (strcmp(*newval, "latest") == 0)
4987 else
4988 {
4990
4991 errno = 0;
4992 strtoul(*newval, NULL, 0);
4993 if (errno == EINVAL || errno == ERANGE)
4994 {
4995 GUC_check_errdetail("\"recovery_target_timeline\" is not a valid number.");
4996 return false;
4997 }
4998 }
4999
5001 *myextra = rttg;
5002 *extra = myextra;
5003
5004 return true;
5005}
@ RECOVERY_TARGET_TIMELINE_CONTROLFILE
Definition: xlogrecovery.h:38
@ RECOVERY_TARGET_TIMELINE_LATEST
Definition: xlogrecovery.h:39

References ERROR, GUC_check_errdetail, guc_malloc(), newval, RECOVERY_TARGET_TIMELINE_CONTROLFILE, RECOVERY_TARGET_TIMELINE_LATEST, and RECOVERY_TARGET_TIMELINE_NUMERIC.

◆ check_recovery_target_xid()

bool check_recovery_target_xid ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 5024 of file xlogrecovery.c.

5025{
5026 if (strcmp(*newval, "") != 0)
5027 {
5028 TransactionId xid;
5029 TransactionId *myextra;
5030
5031 errno = 0;
5032 xid = (TransactionId) strtou64(*newval, NULL, 0);
5033 if (errno == EINVAL || errno == ERANGE)
5034 return false;
5035
5036 myextra = (TransactionId *) guc_malloc(ERROR, sizeof(TransactionId));
5037 *myextra = xid;
5038 *extra = myextra;
5039 }
5040 return true;
5041}

References ERROR, guc_malloc(), and newval.

◆ check_restrict_nonsystem_relation_kind()

bool check_restrict_nonsystem_relation_kind ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 3587 of file postgres.c.

3588{
3589 char *rawstring;
3590 List *elemlist;
3591 ListCell *l;
3592 int flags = 0;
3593
3594 /* Need a modifiable copy of string */
3595 rawstring = pstrdup(*newval);
3596
3597 if (!SplitIdentifierString(rawstring, ',', &elemlist))
3598 {
3599 /* syntax error in list */
3600 GUC_check_errdetail("List syntax is invalid.");
3601 pfree(rawstring);
3602 list_free(elemlist);
3603 return false;
3604 }
3605
3606 foreach(l, elemlist)
3607 {
3608 char *tok = (char *) lfirst(l);
3609
3610 if (pg_strcasecmp(tok, "view") == 0)
3611 flags |= RESTRICT_RELKIND_VIEW;
3612 else if (pg_strcasecmp(tok, "foreign-table") == 0)
3614 else
3615 {
3616 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
3617 pfree(rawstring);
3618 list_free(elemlist);
3619 return false;
3620 }
3621 }
3622
3623 pfree(rawstring);
3624 list_free(elemlist);
3625
3626 /* Save the flags in *extra, for use by the assign function */
3627 *extra = guc_malloc(ERROR, sizeof(int));
3628 *((int *) *extra) = flags;
3629
3630 return true;
3631}
#define RESTRICT_RELKIND_FOREIGN_TABLE
Definition: tcopprot.h:44
#define RESTRICT_RELKIND_VIEW
Definition: tcopprot.h:43

References ERROR, GUC_check_errdetail, guc_malloc(), lfirst, list_free(), newval, pfree(), pg_strcasecmp(), pstrdup(), RESTRICT_RELKIND_FOREIGN_TABLE, RESTRICT_RELKIND_VIEW, and SplitIdentifierString().

◆ check_role()

bool check_role ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 933 of file variable.c.

934{
935 HeapTuple roleTup;
936 Oid roleid;
937 bool is_superuser;
938 role_auth_extra *myextra;
939 Form_pg_authid roleform;
940
941 if (strcmp(*newval, "none") == 0)
942 {
943 /* hardwired translation */
944 roleid = InvalidOid;
945 is_superuser = false;
946 }
948 {
949 /*
950 * In parallel worker initialization, we want to copy the leader's
951 * state even if it no longer matches the catalogs. ParallelWorkerMain
952 * already installed the correct role OID and superuser state.
953 */
954 roleid = GetCurrentRoleId();
956 }
957 else
958 {
959 if (!IsTransactionState())
960 {
961 /*
962 * Can't do catalog lookups, so fail. The result of this is that
963 * role cannot be set in postgresql.conf, which seems like a good
964 * thing anyway, so we don't work hard to avoid it.
965 */
966 return false;
967 }
968
969 /*
970 * When source == PGC_S_TEST, we don't throw a hard error for a
971 * nonexistent user name or insufficient privileges, only a NOTICE.
972 * See comments in guc.h.
973 */
974
975 /* Look up the username */
976 roleTup = SearchSysCache1(AUTHNAME, PointerGetDatum(*newval));
977 if (!HeapTupleIsValid(roleTup))
978 {
979 if (source == PGC_S_TEST)
980 {
982 (errcode(ERRCODE_UNDEFINED_OBJECT),
983 errmsg("role \"%s\" does not exist", *newval)));
984 return true;
985 }
986 GUC_check_errmsg("role \"%s\" does not exist", *newval);
987 return false;
988 }
989
990 roleform = (Form_pg_authid) GETSTRUCT(roleTup);
991 roleid = roleform->oid;
992 is_superuser = roleform->rolsuper;
993
994 ReleaseSysCache(roleTup);
995
996 /* Verify that session user is allowed to become this role */
998 {
999 if (source == PGC_S_TEST)
1000 {
1002 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1003 errmsg("permission will be denied to set role \"%s\"",
1004 *newval)));
1005 return true;
1006 }
1007 GUC_check_errcode(ERRCODE_INSUFFICIENT_PRIVILEGE);
1008 GUC_check_errmsg("permission denied to set role \"%s\"",
1009 *newval);
1010 return false;
1011 }
1012 }
1013
1014 /* Set up "extra" struct for assign_role to use */
1015 myextra = (role_auth_extra *) guc_malloc(LOG, sizeof(role_auth_extra));
1016 if (!myextra)
1017 return false;
1018 myextra->roleid = roleid;
1019 myextra->is_superuser = is_superuser;
1020 *extra = myextra;
1021
1022 return true;
1023}
bool member_can_set_role(Oid member, Oid role)
Definition: acl.c:5302
bool current_role_is_superuser
Definition: guc_tables.c:524
Oid GetSessionUserId(void)
Definition: miscinit.c:559
Oid GetCurrentRoleId(void)
Definition: miscinit.c:986
FormData_pg_authid * Form_pg_authid
Definition: pg_authid.h:56
static bool is_superuser(Archive *fout)
Definition: pg_dump.c:4846
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:327

References current_role_is_superuser, ereport, errcode(), errmsg(), GetCurrentRoleId(), GetSessionUserId(), GETSTRUCT(), GUC_check_errcode(), GUC_check_errmsg, guc_malloc(), HeapTupleIsValid, InitializingParallelWorker, InvalidOid, role_auth_extra::is_superuser, is_superuser(), IsTransactionState(), LOG, member_can_set_role(), newval, NOTICE, PGC_S_TEST, PointerGetDatum(), ReleaseSysCache(), role_auth_extra::roleid, SearchSysCache1(), and source.

◆ check_search_path()

bool check_search_path ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 4657 of file namespace.c.

4658{
4659 Oid roleid = InvalidOid;
4660 const char *searchPath = *newval;
4661 char *rawname;
4662 List *namelist;
4663 bool use_cache = (SearchPathCacheContext != NULL);
4664
4665 /*
4666 * We used to try to check that the named schemas exist, but there are
4667 * many valid use-cases for having search_path settings that include
4668 * schemas that don't exist; and often, we are not inside a transaction
4669 * here and so can't consult the system catalogs anyway. So now, the only
4670 * requirement is syntactic validity of the identifier list.
4671 *
4672 * Checking only the syntactic validity also allows us to use the search
4673 * path cache (if available) to avoid calling SplitIdentifierString() on
4674 * the same string repeatedly.
4675 */
4676 if (use_cache)
4677 {
4678 spcache_init();
4679
4680 roleid = GetUserId();
4681
4682 if (spcache_lookup(searchPath, roleid) != NULL)
4683 return true;
4684 }
4685
4686 /*
4687 * Ensure validity check succeeds before creating cache entry.
4688 */
4689
4690 rawname = pstrdup(searchPath); /* need a modifiable copy */
4691
4692 /* Parse string into list of identifiers */
4693 if (!SplitIdentifierString(rawname, ',', &namelist))
4694 {
4695 /* syntax error in name list */
4696 GUC_check_errdetail("List syntax is invalid.");
4697 pfree(rawname);
4698 list_free(namelist);
4699 return false;
4700 }
4701 pfree(rawname);
4702 list_free(namelist);
4703
4704 /* OK to create empty cache entry */
4705 if (use_cache)
4706 (void) spcache_insert(searchPath, roleid);
4707
4708 return true;
4709}
Oid GetUserId(void)
Definition: miscinit.c:520
static SearchPathCacheEntry * spcache_lookup(const char *searchPath, Oid roleid)
Definition: namespace.c:344
static MemoryContext SearchPathCacheContext
Definition: namespace.c:165
static SearchPathCacheEntry * spcache_insert(const char *searchPath, Oid roleid)
Definition: namespace.c:374
static void spcache_init(void)
Definition: namespace.c:306

References GetUserId(), GUC_check_errdetail, InvalidOid, list_free(), newval, pfree(), pstrdup(), SearchPathCacheContext, spcache_init(), spcache_insert(), spcache_lookup(), and SplitIdentifierString().

◆ check_serial_buffers()

bool check_serial_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 847 of file predicate.c.

848{
849 return check_slru_buffers("serializable_buffers", newval);
850}

References check_slru_buffers(), and newval.

◆ check_session_authorization()

bool check_session_authorization ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 815 of file variable.c.

816{
817 HeapTuple roleTup;
818 Form_pg_authid roleform;
819 Oid roleid;
820 bool is_superuser;
821 role_auth_extra *myextra;
822
823 /* Do nothing for the boot_val default of NULL */
824 if (*newval == NULL)
825 return true;
826
828 {
829 /*
830 * In parallel worker initialization, we want to copy the leader's
831 * state even if it no longer matches the catalogs. ParallelWorkerMain
832 * already installed the correct role OID and superuser state.
833 */
834 roleid = GetSessionUserId();
836 }
837 else
838 {
839 if (!IsTransactionState())
840 {
841 /*
842 * Can't do catalog lookups, so fail. The result of this is that
843 * session_authorization cannot be set in postgresql.conf, which
844 * seems like a good thing anyway, so we don't work hard to avoid
845 * it.
846 */
847 return false;
848 }
849
850 /*
851 * When source == PGC_S_TEST, we don't throw a hard error for a
852 * nonexistent user name or insufficient privileges, only a NOTICE.
853 * See comments in guc.h.
854 */
855
856 /* Look up the username */
857 roleTup = SearchSysCache1(AUTHNAME, PointerGetDatum(*newval));
858 if (!HeapTupleIsValid(roleTup))
859 {
860 if (source == PGC_S_TEST)
861 {
863 (errcode(ERRCODE_UNDEFINED_OBJECT),
864 errmsg("role \"%s\" does not exist", *newval)));
865 return true;
866 }
867 GUC_check_errmsg("role \"%s\" does not exist", *newval);
868 return false;
869 }
870
871 roleform = (Form_pg_authid) GETSTRUCT(roleTup);
872 roleid = roleform->oid;
873 is_superuser = roleform->rolsuper;
874
875 ReleaseSysCache(roleTup);
876
877 /*
878 * Only superusers may SET SESSION AUTHORIZATION a role other than
879 * itself. Note that in case of multiple SETs in a single session, the
880 * original authenticated user's superuserness is what matters.
881 */
882 if (roleid != GetAuthenticatedUserId() &&
884 {
885 if (source == PGC_S_TEST)
886 {
888 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
889 errmsg("permission will be denied to set session authorization \"%s\"",
890 *newval)));
891 return true;
892 }
893 GUC_check_errcode(ERRCODE_INSUFFICIENT_PRIVILEGE);
894 GUC_check_errmsg("permission denied to set session authorization \"%s\"",
895 *newval);
896 return false;
897 }
898 }
899
900 /* Set up "extra" struct for assign_session_authorization to use */
901 myextra = (role_auth_extra *) guc_malloc(LOG, sizeof(role_auth_extra));
902 if (!myextra)
903 return false;
904 myextra->roleid = roleid;
905 myextra->is_superuser = is_superuser;
906 *extra = myextra;
907
908 return true;
909}
bool GetSessionUserIsSuperuser(void)
Definition: miscinit.c:566
Oid GetAuthenticatedUserId(void)
Definition: miscinit.c:596
bool superuser_arg(Oid roleid)
Definition: superuser.c:56

References ereport, errcode(), errmsg(), GetAuthenticatedUserId(), GetSessionUserId(), GetSessionUserIsSuperuser(), GETSTRUCT(), GUC_check_errcode(), GUC_check_errmsg, guc_malloc(), HeapTupleIsValid, InitializingParallelWorker, role_auth_extra::is_superuser, is_superuser(), IsTransactionState(), LOG, newval, NOTICE, PGC_S_TEST, PointerGetDatum(), ReleaseSysCache(), role_auth_extra::roleid, SearchSysCache1(), source, and superuser_arg().

◆ check_ssl()

bool check_ssl ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 1281 of file variable.c.

1282{
1283#ifndef USE_SSL
1284 if (*newval)
1285 {
1286 GUC_check_errmsg("SSL is not supported by this build");
1287 return false;
1288 }
1289#endif
1290 return true;
1291}

References GUC_check_errmsg, and newval.

◆ check_stage_log_stats()

bool check_stage_log_stats ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 3539 of file postgres.c.

3540{
3542 {
3543 GUC_check_errdetail("Cannot enable parameter when \"log_statement_stats\" is true.");
3544 return false;
3545 }
3546 return true;
3547}
bool log_statement_stats
Definition: guc_tables.c:510

References GUC_check_errdetail, log_statement_stats, and newval.

◆ check_subtrans_buffers()

bool check_subtrans_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 254 of file subtrans.c.

255{
256 return check_slru_buffers("subtransaction_buffers", newval);
257}

References check_slru_buffers(), and newval.

◆ check_synchronized_standby_slots()

bool check_synchronized_standby_slots ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 2701 of file slot.c.

2702{
2703 char *rawname;
2704 char *ptr;
2705 List *elemlist;
2706 int size;
2707 bool ok;
2709
2710 if ((*newval)[0] == '\0')
2711 return true;
2712
2713 /* Need a modifiable copy of the GUC string */
2714 rawname = pstrdup(*newval);
2715
2716 /* Now verify if the specified slots exist and have correct type */
2717 ok = validate_sync_standby_slots(rawname, &elemlist);
2718
2719 if (!ok || elemlist == NIL)
2720 {
2721 pfree(rawname);
2722 list_free(elemlist);
2723 return ok;
2724 }
2725
2726 /* Compute the size required for the SyncStandbySlotsConfigData struct */
2727 size = offsetof(SyncStandbySlotsConfigData, slot_names);
2728 foreach_ptr(char, slot_name, elemlist)
2729 size += strlen(slot_name) + 1;
2730
2731 /* GUC extra value must be guc_malloc'd, not palloc'd */
2732 config = (SyncStandbySlotsConfigData *) guc_malloc(LOG, size);
2733
2734 /* Transform the data into SyncStandbySlotsConfigData */
2735 config->nslotnames = list_length(elemlist);
2736
2737 ptr = config->slot_names;
2738 foreach_ptr(char, slot_name, elemlist)
2739 {
2740 strcpy(ptr, slot_name);
2741 ptr += strlen(slot_name) + 1;
2742 }
2743
2744 *extra = config;
2745
2746 pfree(rawname);
2747 list_free(elemlist);
2748 return true;
2749}
static int list_length(const List *l)
Definition: pg_list.h:152
#define foreach_ptr(type, var, lst)
Definition: pg_list.h:469
static bool validate_sync_standby_slots(char *rawname, List **elemlist)
Definition: slot.c:2646
char slot_names[FLEXIBLE_ARRAY_MEMBER]
Definition: slot.c:100

References foreach_ptr, guc_malloc(), list_free(), list_length(), LOG, newval, NIL, SyncStandbySlotsConfigData::nslotnames, pfree(), pstrdup(), SyncStandbySlotsConfigData::slot_names, and validate_sync_standby_slots().

◆ check_synchronous_standby_names()

bool check_synchronous_standby_names ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 991 of file syncrep.c.

992{
993 if (*newval != NULL && (*newval)[0] != '\0')
994 {
995 yyscan_t scanner;
996 int parse_rc;
997 SyncRepConfigData *pconf;
998
999 /* Result of parsing is returned in one of these two variables */
1000 SyncRepConfigData *syncrep_parse_result = NULL;
1001 char *syncrep_parse_error_msg = NULL;
1002
1003 /* Parse the synchronous_standby_names string */
1004 syncrep_scanner_init(*newval, &scanner);
1005 parse_rc = syncrep_yyparse(&syncrep_parse_result, &syncrep_parse_error_msg, scanner);
1006 syncrep_scanner_finish(scanner);
1007
1008 if (parse_rc != 0 || syncrep_parse_result == NULL)
1009 {
1010 GUC_check_errcode(ERRCODE_SYNTAX_ERROR);
1011 if (syncrep_parse_error_msg)
1012 GUC_check_errdetail("%s", syncrep_parse_error_msg);
1013 else
1014 GUC_check_errdetail("\"%s\" parser failed.",
1015 "synchronous_standby_names");
1016 return false;
1017 }
1018
1019 if (syncrep_parse_result->num_sync <= 0)
1020 {
1021 GUC_check_errmsg("number of synchronous standbys (%d) must be greater than zero",
1022 syncrep_parse_result->num_sync);
1023 return false;
1024 }
1025
1026 /* GUC extra value must be guc_malloc'd, not palloc'd */
1027 pconf = (SyncRepConfigData *)
1028 guc_malloc(LOG, syncrep_parse_result->config_size);
1029 if (pconf == NULL)
1030 return false;
1031 memcpy(pconf, syncrep_parse_result, syncrep_parse_result->config_size);
1032
1033 *extra = pconf;
1034
1035 /*
1036 * We need not explicitly clean up syncrep_parse_result. It, and any
1037 * other cruft generated during parsing, will be freed when the
1038 * current memory context is deleted. (This code is generally run in
1039 * a short-lived context used for config file processing, so that will
1040 * not be very long.)
1041 */
1042 }
1043 else
1044 *extra = NULL;
1045
1046 return true;
1047}
void * yyscan_t
Definition: cubedata.h:67
int syncrep_yyparse(SyncRepConfigData **syncrep_parse_result_p, char **syncrep_parse_error_msg_p, yyscan_t yyscanner)
void syncrep_scanner_finish(yyscan_t yyscanner)
void syncrep_scanner_init(const char *str, yyscan_t *yyscannerp)

References SyncRepConfigData::config_size, GUC_check_errcode(), GUC_check_errdetail, GUC_check_errmsg, guc_malloc(), LOG, newval, SyncRepConfigData::num_sync, syncrep_scanner_finish(), syncrep_scanner_init(), and syncrep_yyparse().

◆ check_temp_buffers()

bool check_temp_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 785 of file localbuf.c.

786{
787 /*
788 * Once local buffers have been initialized, it's too late to change this.
789 * However, if this is only a test call, allow it.
790 */
792 {
793 GUC_check_errdetail("\"temp_buffers\" cannot be changed after any temporary tables have been accessed in the session.");
794 return false;
795 }
796 return true;
797}
int NLocBuffer
Definition: localbuf.c:42

References GUC_check_errdetail, newval, NLocBuffer, PGC_S_TEST, and source.

◆ check_temp_tablespaces()

bool check_temp_tablespaces ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 1198 of file tablespace.c.

1199{
1200 char *rawname;
1201 List *namelist;
1202
1203 /* Need a modifiable copy of string */
1204 rawname = pstrdup(*newval);
1205
1206 /* Parse string into list of identifiers */
1207 if (!SplitIdentifierString(rawname, ',', &namelist))
1208 {
1209 /* syntax error in name list */
1210 GUC_check_errdetail("List syntax is invalid.");
1211 pfree(rawname);
1212 list_free(namelist);
1213 return false;
1214 }
1215
1216 /*
1217 * If we aren't inside a transaction, or connected to a database, we
1218 * cannot do the catalog accesses necessary to verify the name. Must
1219 * accept the value on faith. Fortunately, there's then also no need to
1220 * pass the data to fd.c.
1221 */
1223 {
1224 temp_tablespaces_extra *myextra;
1225 Oid *tblSpcs;
1226 int numSpcs;
1227 ListCell *l;
1228
1229 /* temporary workspace until we are done verifying the list */
1230 tblSpcs = (Oid *) palloc(list_length(namelist) * sizeof(Oid));
1231 numSpcs = 0;
1232 foreach(l, namelist)
1233 {
1234 char *curname = (char *) lfirst(l);
1235 Oid curoid;
1236 AclResult aclresult;
1237
1238 /* Allow an empty string (signifying database default) */
1239 if (curname[0] == '\0')
1240 {
1241 /* InvalidOid signifies database's default tablespace */
1242 tblSpcs[numSpcs++] = InvalidOid;
1243 continue;
1244 }
1245
1246 /*
1247 * In an interactive SET command, we ereport for bad info. When
1248 * source == PGC_S_TEST, don't throw a hard error for a
1249 * nonexistent tablespace, only a NOTICE. See comments in guc.h.
1250 */
1251 curoid = get_tablespace_oid(curname, source <= PGC_S_TEST);
1252 if (curoid == InvalidOid)
1253 {
1254 if (source == PGC_S_TEST)
1256 (errcode(ERRCODE_UNDEFINED_OBJECT),
1257 errmsg("tablespace \"%s\" does not exist",
1258 curname)));
1259 continue;
1260 }
1261
1262 /*
1263 * Allow explicit specification of database's default tablespace
1264 * in temp_tablespaces without triggering permissions checks.
1265 */
1266 if (curoid == MyDatabaseTableSpace)
1267 {
1268 /* InvalidOid signifies database's default tablespace */
1269 tblSpcs[numSpcs++] = InvalidOid;
1270 continue;
1271 }
1272
1273 /* Check permissions, similarly complaining only if interactive */
1274 aclresult = object_aclcheck(TableSpaceRelationId, curoid, GetUserId(),
1275 ACL_CREATE);
1276 if (aclresult != ACLCHECK_OK)
1277 {
1279 aclcheck_error(aclresult, OBJECT_TABLESPACE, curname);
1280 continue;
1281 }
1282
1283 tblSpcs[numSpcs++] = curoid;
1284 }
1285
1286 /* Now prepare an "extra" struct for assign_temp_tablespaces */
1287 myextra = guc_malloc(LOG, offsetof(temp_tablespaces_extra, tblSpcs) +
1288 numSpcs * sizeof(Oid));
1289 if (!myextra)
1290 return false;
1291 myextra->numSpcs = numSpcs;
1292 memcpy(myextra->tblSpcs, tblSpcs, numSpcs * sizeof(Oid));
1293 *extra = myextra;
1294
1295 pfree(tblSpcs);
1296 }
1297
1298 pfree(rawname);
1299 list_free(namelist);
1300
1301 return true;
1302}
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:2622
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3804
Oid MyDatabaseTableSpace
Definition: globals.c:95
void * palloc(Size size)
Definition: mcxt.c:1317
@ OBJECT_TABLESPACE
Definition: parsenodes.h:2354
#define ACL_CREATE
Definition: parsenodes.h:85

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, ereport, errcode(), errmsg(), get_tablespace_oid(), GetUserId(), GUC_check_errdetail, guc_malloc(), InvalidOid, IsTransactionState(), lfirst, list_free(), list_length(), LOG, MyDatabaseId, MyDatabaseTableSpace, newval, NOTICE, temp_tablespaces_extra::numSpcs, object_aclcheck(), OBJECT_TABLESPACE, palloc(), pfree(), PGC_S_INTERACTIVE, PGC_S_TEST, pstrdup(), source, SplitIdentifierString(), and temp_tablespaces_extra::tblSpcs.

◆ check_timezone()

bool check_timezone ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 261 of file variable.c.

262{
263 pg_tz *new_tz;
264 long gmtoffset;
265 char *endptr;
266 double hours;
267
268 if (pg_strncasecmp(*newval, "interval", 8) == 0)
269 {
270 /*
271 * Support INTERVAL 'foo'. This is for SQL spec compliance, not
272 * because it has any actual real-world usefulness.
273 */
274 const char *valueptr = *newval;
275 char *val;
277
278 valueptr += 8;
279 while (isspace((unsigned char) *valueptr))
280 valueptr++;
281 if (*valueptr++ != '\'')
282 return false;
283 val = pstrdup(valueptr);
284 /* Check and remove trailing quote */
285 endptr = strchr(val, '\'');
286 if (!endptr || endptr[1] != '\0')
287 {
288 pfree(val);
289 return false;
290 }
291 *endptr = '\0';
292
293 /*
294 * Try to parse it. XXX an invalid interval format will result in
295 * ereport(ERROR), which is not desirable for GUC. We did what we
296 * could to guard against this in flatten_set_variable_args, but a
297 * string coming in from postgresql.conf might contain anything.
298 */
302 Int32GetDatum(-1)));
303
304 pfree(val);
305 if (interval->month != 0)
306 {
307 GUC_check_errdetail("Cannot specify months in time zone interval.");
309 return false;
310 }
311 if (interval->day != 0)
312 {
313 GUC_check_errdetail("Cannot specify days in time zone interval.");
315 return false;
316 }
317
318 /* Here we change from SQL to Unix sign convention */
319 gmtoffset = -(interval->time / USECS_PER_SEC);
320 new_tz = pg_tzset_offset(gmtoffset);
321
323 }
324 else
325 {
326 /*
327 * Try it as a numeric number of hours (possibly fractional).
328 */
329 hours = strtod(*newval, &endptr);
330 if (endptr != *newval && *endptr == '\0')
331 {
332 /* Here we change from SQL to Unix sign convention */
333 gmtoffset = -hours * SECS_PER_HOUR;
334 new_tz = pg_tzset_offset(gmtoffset);
335 }
336 else
337 {
338 /*
339 * Otherwise assume it is a timezone name, and try to load it.
340 */
341 new_tz = pg_tzset(*newval);
342
343 if (!new_tz)
344 {
345 /* Doesn't seem to be any great value in errdetail here */
346 return false;
347 }
348
349 if (!pg_tz_acceptable(new_tz))
350 {
351 GUC_check_errmsg("time zone \"%s\" appears to use leap seconds",
352 *newval);
353 GUC_check_errdetail("PostgreSQL does not support leap seconds.");
354 return false;
355 }
356 }
357 }
358
359 /* Test for failure in pg_tzset_offset, which we assume is out-of-range */
360 if (!new_tz)
361 {
362 GUC_check_errdetail("UTC timezone offset is out of range.");
363 return false;
364 }
365
366 /*
367 * Pass back data for assign_timezone to use
368 */
369 *extra = guc_malloc(LOG, sizeof(pg_tz *));
370 if (!*extra)
371 return false;
372 *((pg_tz **) *extra) = new_tz;
373
374 return true;
375}
Datum interval_in(PG_FUNCTION_ARGS)
Definition: timestamp.c:890
#define SECS_PER_HOUR
Definition: timestamp.h:127
#define USECS_PER_SEC
Definition: timestamp.h:134
#define DirectFunctionCall3(func, arg1, arg2, arg3)
Definition: fmgr.h:645
long val
Definition: informix.c:689
pg_tz * pg_tzset_offset(long gmtoffset)
Definition: pgtz.c:320
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:355
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:217
static Interval * DatumGetIntervalP(Datum X)
Definition: timestamp.h:40

References CStringGetDatum(), DatumGetIntervalP(), DirectFunctionCall3, GUC_check_errdetail, GUC_check_errmsg, guc_malloc(), Int32GetDatum(), interval_in(), InvalidOid, LOG, interval::month, newval, ObjectIdGetDatum(), pfree(), pg_strncasecmp(), pg_tz_acceptable(), pg_tzset(), pg_tzset_offset(), pstrdup(), SECS_PER_HOUR, interval::time, USECS_PER_SEC, and val.

◆ check_timezone_abbreviations()

bool check_timezone_abbreviations ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 487 of file variable.c.

488{
489 /*
490 * The boot_val for timezone_abbreviations is NULL. When we see that we
491 * just do nothing. If the value isn't overridden from the config file
492 * then pg_timezone_abbrev_initialize() will eventually replace it with
493 * "Default". This hack has two purposes: to avoid wasting cycles loading
494 * values that might soon be overridden from the config file, and to avoid
495 * trying to read the timezone abbrev files during InitializeGUCOptions().
496 * The latter doesn't work in an EXEC_BACKEND subprocess because
497 * my_exec_path hasn't been set yet and so we can't locate PGSHAREDIR.
498 */
499 if (*newval == NULL)
500 {
502 return true;
503 }
504
505 /* OK, load the file and produce a guc_malloc'd TimeZoneAbbrevTable */
506 *extra = load_tzoffsets(*newval);
507
508 /* tzparser.c returns NULL on failure, reporting via GUC_check_errmsg */
509 if (!*extra)
510 return false;
511
512 return true;
513}
TimeZoneAbbrevTable * load_tzoffsets(const char *filename)
Definition: tzparser.c:449

References Assert(), load_tzoffsets(), newval, PGC_S_DEFAULT, and source.

◆ check_transaction_buffers()

bool check_transaction_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 821 of file clog.c.

822{
823 return check_slru_buffers("transaction_buffers", newval);
824}

References check_slru_buffers(), and newval.

◆ check_transaction_deferrable()

bool check_transaction_deferrable ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 624 of file variable.c.

625{
626 /* Just accept the value when restoring state in a parallel worker */
628 return true;
629
630 if (IsSubTransaction())
631 {
632 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
633 GUC_check_errmsg("SET TRANSACTION [NOT] DEFERRABLE cannot be called within a subtransaction");
634 return false;
635 }
637 {
638 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
639 GUC_check_errmsg("SET TRANSACTION [NOT] DEFERRABLE must be called before any query");
640 return false;
641 }
642
643 return true;
644}
bool FirstSnapshotSet
Definition: snapmgr.c:192
bool IsSubTransaction(void)
Definition: xact.c:5044

References FirstSnapshotSet, GUC_check_errcode(), GUC_check_errmsg, InitializingParallelWorker, and IsSubTransaction().

◆ check_transaction_isolation()

bool check_transaction_isolation ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 586 of file variable.c.

587{
588 int newXactIsoLevel = *newval;
589
590 if (newXactIsoLevel != XactIsoLevel &&
592 {
594 {
595 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
596 GUC_check_errmsg("SET TRANSACTION ISOLATION LEVEL must be called before any query");
597 return false;
598 }
599 /* We ignore a subtransaction setting it to the existing value. */
600 if (IsSubTransaction())
601 {
602 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
603 GUC_check_errmsg("SET TRANSACTION ISOLATION LEVEL must not be called in a subtransaction");
604 return false;
605 }
606 /* Can't go to serializable mode while recovery is still active */
607 if (newXactIsoLevel == XACT_SERIALIZABLE && RecoveryInProgress())
608 {
609 GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
610 GUC_check_errmsg("cannot use serializable mode in a hot standby");
611 GUC_check_errhint("You can use REPEATABLE READ instead.");
612 return false;
613 }
614 }
615
616 return true;
617}
int XactIsoLevel
Definition: xact.c:79
#define XACT_SERIALIZABLE
Definition: xact.h:39
bool RecoveryInProgress(void)
Definition: xlog.c:6380

References FirstSnapshotSet, GUC_check_errcode(), GUC_check_errhint, GUC_check_errmsg, InitializingParallelWorker, IsSubTransaction(), IsTransactionState(), newval, RecoveryInProgress(), XACT_SERIALIZABLE, and XactIsoLevel.

◆ check_transaction_read_only()

bool check_transaction_read_only ( bool *  newval,
void **  extra,
GucSource  source 
)

Definition at line 546 of file variable.c.

547{
549 {
550 /* Can't go to r/w mode inside a r/o transaction */
551 if (IsSubTransaction())
552 {
553 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
554 GUC_check_errmsg("cannot set transaction read-write mode inside a read-only transaction");
555 return false;
556 }
557 /* Top level transaction can't change to r/w after first snapshot. */
559 {
560 GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
561 GUC_check_errmsg("transaction read-write mode must be set before any query");
562 return false;
563 }
564 /* Can't go to r/w mode while recovery is still active */
565 if (RecoveryInProgress())
566 {
567 GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
568 GUC_check_errmsg("cannot set transaction read-write mode during recovery");
569 return false;
570 }
571 }
572
573 return true;
574}
bool XactReadOnly
Definition: xact.c:82

References FirstSnapshotSet, GUC_check_errcode(), GUC_check_errmsg, InitializingParallelWorker, IsSubTransaction(), IsTransactionState(), newval, RecoveryInProgress(), and XactReadOnly.

◆ check_vacuum_buffer_usage_limit()

bool check_vacuum_buffer_usage_limit ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 137 of file vacuum.c.

139{
140 /* Value upper and lower hard limits are inclusive */
141 if (*newval == 0 || (*newval >= MIN_BAS_VAC_RING_SIZE_KB &&
143 return true;
144
145 /* Value does not fall within any allowable range */
146 GUC_check_errdetail("\"%s\" must be 0 or between %d kB and %d kB.",
147 "vacuum_buffer_usage_limit",
149
150 return false;
151}
#define MIN_BAS_VAC_RING_SIZE_KB
Definition: miscadmin.h:277
#define MAX_BAS_VAC_RING_SIZE_KB
Definition: miscadmin.h:278

References GUC_check_errdetail, MAX_BAS_VAC_RING_SIZE_KB, MIN_BAS_VAC_RING_SIZE_KB, and newval.

◆ check_wal_buffers()

bool check_wal_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 4683 of file xlog.c.

4684{
4685 /*
4686 * -1 indicates a request for auto-tune.
4687 */
4688 if (*newval == -1)
4689 {
4690 /*
4691 * If we haven't yet changed the boot_val default of -1, just let it
4692 * be. We'll fix it when XLOGShmemSize is called.
4693 */
4694 if (XLOGbuffers == -1)
4695 return true;
4696
4697 /* Otherwise, substitute the auto-tune value */
4699 }
4700
4701 /*
4702 * We clamp manually-set values to at least 4 blocks. Prior to PostgreSQL
4703 * 9.1, a minimum of 4 was enforced by guc.c, but since that is no longer
4704 * the case, we just silently treat such values as a request for the
4705 * minimum. (We could throw an error instead, but that doesn't seem very
4706 * helpful.)
4707 */
4708 if (*newval < 4)
4709 *newval = 4;
4710
4711 return true;
4712}
static int XLOGChooseNumBuffers(void)
Definition: xlog.c:4667
int XLOGbuffers
Definition: xlog.c:117

References newval, XLOGbuffers, and XLOGChooseNumBuffers().

◆ check_wal_consistency_checking()

bool check_wal_consistency_checking ( char **  newval,
void **  extra,
GucSource  source 
)

Definition at line 4718 of file xlog.c.

4719{
4720 char *rawstring;
4721 List *elemlist;
4722 ListCell *l;
4723 bool newwalconsistency[RM_MAX_ID + 1];
4724
4725 /* Initialize the array */
4726 MemSet(newwalconsistency, 0, (RM_MAX_ID + 1) * sizeof(bool));
4727
4728 /* Need a modifiable copy of string */
4729 rawstring = pstrdup(*newval);
4730
4731 /* Parse string into list of identifiers */
4732 if (!SplitIdentifierString(rawstring, ',', &elemlist))
4733 {
4734 /* syntax error in list */
4735 GUC_check_errdetail("List syntax is invalid.");
4736 pfree(rawstring);
4737 list_free(elemlist);
4738 return false;
4739 }
4740
4741 foreach(l, elemlist)
4742 {
4743 char *tok = (char *) lfirst(l);
4744 int rmid;
4745
4746 /* Check for 'all'. */
4747 if (pg_strcasecmp(tok, "all") == 0)
4748 {
4749 for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
4750 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL)
4751 newwalconsistency[rmid] = true;
4752 }
4753 else
4754 {
4755 /* Check if the token matches any known resource manager. */
4756 bool found = false;
4757
4758 for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
4759 {
4760 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL &&
4761 pg_strcasecmp(tok, GetRmgr(rmid).rm_name) == 0)
4762 {
4763 newwalconsistency[rmid] = true;
4764 found = true;
4765 break;
4766 }
4767 }
4768 if (!found)
4769 {
4770 /*
4771 * During startup, it might be a not-yet-loaded custom
4772 * resource manager. Defer checking until
4773 * InitializeWalConsistencyChecking().
4774 */
4776 {
4778 }
4779 else
4780 {
4781 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
4782 pfree(rawstring);
4783 list_free(elemlist);
4784 return false;
4785 }
4786 }
4787 }
4788 }
4789
4790 pfree(rawstring);
4791 list_free(elemlist);
4792
4793 /* assign new value */
4794 *extra = guc_malloc(ERROR, (RM_MAX_ID + 1) * sizeof(bool));
4795 memcpy(*extra, newwalconsistency, (RM_MAX_ID + 1) * sizeof(bool));
4796 return true;
4797}
#define MemSet(start, val, len)
Definition: c.h:991
bool process_shared_preload_libraries_done
Definition: miscinit.c:1838
#define RM_MAX_ID
Definition: rmgr.h:33
void(* rm_mask)(char *pagedata, BlockNumber blkno)
static bool check_wal_consistency_checking_deferred
Definition: xlog.c:166
static RmgrData GetRmgr(RmgrId rmid)
static bool RmgrIdExists(RmgrId rmid)

References check_wal_consistency_checking_deferred, ERROR, GetRmgr(), GUC_check_errdetail, guc_malloc(), lfirst, list_free(), MemSet, newval, pfree(), pg_strcasecmp(), process_shared_preload_libraries_done, pstrdup(), RmgrData::rm_mask, RM_MAX_ID, RmgrIdExists(), and SplitIdentifierString().

◆ check_wal_segment_size()

bool check_wal_segment_size ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 2205 of file xlog.c.

2206{
2208 {
2209 GUC_check_errdetail("The WAL segment size must be a power of two between 1 MB and 1 GB.");
2210 return false;
2211 }
2212
2213 return true;
2214}
#define IsValidWalSegSize(size)
Definition: xlog_internal.h:96

References GUC_check_errdetail, IsValidWalSegSize, and newval.

◆ show_archive_command()

const char * show_archive_command ( void  )

Definition at line 4856 of file xlog.c.

4857{
4858 if (XLogArchivingActive())
4859 return XLogArchiveCommand;
4860 else
4861 return "(disabled)";
4862}
char * XLogArchiveCommand
Definition: xlog.c:120
#define XLogArchivingActive()
Definition: xlog.h:99

References XLogArchiveCommand, and XLogArchivingActive.

◆ show_data_directory_mode()

const char * show_data_directory_mode ( void  )

Definition at line 1186 of file variable.c.

1187{
1188 static char buf[12];
1189
1190 snprintf(buf, sizeof(buf), "%04o", data_directory_mode);
1191 return buf;
1192}
int data_directory_mode
Definition: globals.c:76
#define snprintf
Definition: port.h:239

References buf, data_directory_mode, and snprintf.

◆ show_in_hot_standby()

const char * show_in_hot_standby ( void  )

Definition at line 4868 of file xlog.c.

4869{
4870 /*
4871 * We display the actual state based on shared memory, so that this GUC
4872 * reports up-to-date state if examined intra-query. The underlying
4873 * variable (in_hot_standby_guc) changes only when we transmit a new value
4874 * to the client.
4875 */
4876 return RecoveryInProgress() ? "on" : "off";
4877}

References RecoveryInProgress().

◆ show_log_file_mode()

const char * show_log_file_mode ( void  )

Definition at line 1198 of file variable.c.

1199{
1200 static char buf[12];
1201
1202 snprintf(buf, sizeof(buf), "%04o", Log_file_mode);
1203 return buf;
1204}
int Log_file_mode
Definition: syslogger.c:76

References buf, Log_file_mode, and snprintf.

◆ show_log_timezone()

const char * show_log_timezone ( void  )

Definition at line 465 of file variable.c.

466{
467 const char *tzn;
468
469 /* Always show the zone's canonical name */
471
472 if (tzn != NULL)
473 return tzn;
474
475 return "unknown";
476}
const char * pg_get_timezone_name(pg_tz *tz)
Definition: localtime.c:1989

References log_timezone, and pg_get_timezone_name().

◆ show_random_seed()

const char * show_random_seed ( void  )

Definition at line 677 of file variable.c.

678{
679 return "unavailable";
680}

◆ show_role()

const char * show_role ( void  )

Definition at line 1034 of file variable.c.

1035{
1036 /*
1037 * Check whether SET ROLE is active; if not return "none". This is a
1038 * kluge to deal with the fact that SET SESSION AUTHORIZATION logically
1039 * resets SET ROLE to NONE, but we cannot set the GUC role variable from
1040 * assign_session_authorization (because we haven't got enough info to
1041 * call set_config_option).
1042 */
1044 return "none";
1045
1046 /* Otherwise we can just use the GUC string */
1047 return role_string ? role_string : "none";
1048}
char * role_string
Definition: guc_tables.c:624

References GetCurrentRoleId(), OidIsValid, and role_string.

◆ show_tcp_keepalives_count()

const char * show_tcp_keepalives_count ( void  )

Definition at line 2021 of file pqcomm.c.

2022{
2023 /* See comments in assign_tcp_keepalives_idle */
2024 static char nbuf[16];
2025
2026 snprintf(nbuf, sizeof(nbuf), "%d", pq_getkeepalivescount(MyProcPort));
2027 return nbuf;
2028}
int pq_getkeepalivescount(Port *port)
Definition: pqcomm.c:1802

References MyProcPort, pq_getkeepalivescount(), and snprintf.

◆ show_tcp_keepalives_idle()

const char * show_tcp_keepalives_idle ( void  )

Definition at line 1975 of file pqcomm.c.

1976{
1977 /* See comments in assign_tcp_keepalives_idle */
1978 static char nbuf[16];
1979
1980 snprintf(nbuf, sizeof(nbuf), "%d", pq_getkeepalivesidle(MyProcPort));
1981 return nbuf;
1982}
int pq_getkeepalivesidle(Port *port)
Definition: pqcomm.c:1633

References MyProcPort, pq_getkeepalivesidle(), and snprintf.

◆ show_tcp_keepalives_interval()

const char * show_tcp_keepalives_interval ( void  )

Definition at line 1998 of file pqcomm.c.

1999{
2000 /* See comments in assign_tcp_keepalives_idle */
2001 static char nbuf[16];
2002
2003 snprintf(nbuf, sizeof(nbuf), "%d", pq_getkeepalivesinterval(MyProcPort));
2004 return nbuf;
2005}
int pq_getkeepalivesinterval(Port *port)
Definition: pqcomm.c:1718

References MyProcPort, pq_getkeepalivesinterval(), and snprintf.

◆ show_tcp_user_timeout()

const char * show_tcp_user_timeout ( void  )

Definition at line 2044 of file pqcomm.c.

2045{
2046 /* See comments in assign_tcp_keepalives_idle */
2047 static char nbuf[16];
2048
2049 snprintf(nbuf, sizeof(nbuf), "%d", pq_gettcpusertimeout(MyProcPort));
2050 return nbuf;
2051}
int pq_gettcpusertimeout(Port *port)
Definition: pqcomm.c:1877

References MyProcPort, pq_gettcpusertimeout(), and snprintf.

◆ show_timezone()

const char * show_timezone ( void  )

Definition at line 392 of file variable.c.

393{
394 const char *tzn;
395
396 /* Always show the zone's canonical name */
398
399 if (tzn != NULL)
400 return tzn;
401
402 return "unknown";
403}

References pg_get_timezone_name(), and session_timezone.

◆ show_unix_socket_permissions()

const char * show_unix_socket_permissions ( void  )

Definition at line 1210 of file variable.c.

1211{
1212 static char buf[12];
1213
1214 snprintf(buf, sizeof(buf), "%04o", Unix_socket_permissions);
1215 return buf;
1216}
int Unix_socket_permissions
Definition: pqcomm.c:106

References buf, snprintf, and Unix_socket_permissions.