PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
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_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)
 
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 2250 of file elog.c.

2251{
2252 backtrace_function_list = (char *) extra;
2253}
static char * backtrace_function_list
Definition: elog.c:117

References backtrace_function_list.

◆ assign_checkpoint_completion_target()

void assign_checkpoint_completion_target ( double  newval,
void *  extra 
)

Definition at line 2331 of file xlog.c.

2332{
2335}
double CheckPointCompletionTarget
Definition: checkpointer.c:143
static void CalculateCheckpointSegments(void)
Definition: xlog.c:2295

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:226
#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:126
int DateOrder
Definition: globals.c:127

References DateOrder, and DateStyle.

◆ assign_debug_io_direct()

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

Definition at line 4094 of file fd.c.

4095{
4096 int *flags = (int *) extra;
4097
4098 io_direct_flags = *flags;
4099}
int io_direct_flags
Definition: fd.c:168

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:35
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 1170 of file variable.c.

1171{
1174}
int io_max_combine_limit
Definition: bufmgr.c:172
int io_combine_limit_guc
Definition: bufmgr.c:171
int io_combine_limit
Definition: bufmgr.c:170
#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 1201 of file aio.c.

1202{
1205
1207}
const IoMethodOps * pgaio_method_ops
Definition: aio.c:96
static const IoMethodOps *const pgaio_method_ops_table[]
Definition: aio.c:87
const struct config_enum_entry io_method_options[]
Definition: aio.c:67
#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 427 of file pg_locale.c.

428{
429 /*
430 * LC_MESSAGES category does not exist everywhere, but accept it anyway.
431 * We ignore failure, as per comment above.
432 */
433#ifdef LC_MESSAGES
434 (void) pg_perm_setlocale(LC_MESSAGES, newval);
435#endif
436}
char * pg_perm_setlocale(int category, const char *locale)
Definition: pg_locale.c:190

References newval, and pg_perm_setlocale().

◆ assign_locale_monetary()

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

Definition at line 364 of file pg_locale.c.

365{
367}
static bool CurrentLocaleConvValid
Definition: pg_locale.c:133

References CurrentLocaleConvValid.

◆ assign_locale_numeric()

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

Definition at line 376 of file pg_locale.c.

377{
379}

References CurrentLocaleConvValid.

◆ assign_locale_time()

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

Definition at line 388 of file pg_locale.c.

389{
390 CurrentLCTimeValid = false;
391}
static bool CurrentLCTimeValid
Definition: pg_locale.c:134

References CurrentLCTimeValid.

◆ assign_log_connections()

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

Definition at line 1112 of file backend_startup.c.

1113{
1114 log_connections = *((int *) extra);
1115}
uint32 log_connections

References log_connections.

◆ assign_log_destination()

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

Definition at line 2323 of file elog.c.

2324{
2325 Log_destination = *((int *) extra);
2326}
int Log_destination
Definition: elog.c:111

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 /*
1149 * Reconfigure recovery prefetching, because a setting it depends on
1150 * changed.
1151 */
1153 if (AmStartupProcess())
1155}
int maintenance_io_concurrency
Definition: bufmgr.c:162
#define AmStartupProcess()
Definition: miscadmin.h:390
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 2324 of file xlog.c.

2325{
2328}
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:682
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 4814 of file xlogrecovery.c.

4815{
4819
4820 if (newval && strcmp(newval, "") != 0)
4822 else
4824}
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 4855 of file xlogrecovery.c.

4856{
4860
4861 if (newval && strcmp(newval, "") != 0)
4862 {
4864 recoveryTargetLSN = *((XLogRecPtr *) extra);
4865 }
4866 else
4868}
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 4890 of file xlogrecovery.c.

4891{
4895
4896 if (newval && strcmp(newval, "") != 0)
4897 {
4900 }
4901 else
4903}
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 5021 of file xlogrecovery.c.

5022{
5025 recoveryTargetTLIRequested = (TimeLineID) strtoul(newval, NULL, 0);
5026 else
5028}
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 5059 of file xlogrecovery.c.

5060{
5064
5065 if (newval && strcmp(newval, "") != 0)
5066 {
5068 recoveryTargetXid = *((TransactionId *) extra);
5069 }
5070 else
5072}
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 3670 of file postgres.c.

3671{
3672 int *flags = (int *) extra;
3673
3675}
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:477
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:2447
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 2757 of file slot.c.

2758{
2759 /*
2760 * The standby slots may have changed, so we must recompute the oldest
2761 * LSN.
2762 */
2764
2766}
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 1123 of file syncrep.c.

1124{
1125 switch (newval)
1126 {
1129 break;
1132 break;
1135 break;
1136 default:
1138 break;
1139 }
1140}
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 1117 of file syncrep.c.

1118{
1119 SyncRepConfig = (SyncRepConfigData *) extra;
1120}
SyncRepConfigData * SyncRepConfig
Definition: syncrep.c:97

References SyncRepConfig.

◆ assign_syslog_facility()

void assign_syslog_facility ( int  newval,
void *  extra 
)

Definition at line 2364 of file elog.c.

2365{
2366#ifdef HAVE_SYSLOG
2367 /*
2368 * As above, don't thrash the syslog connection unnecessarily.
2369 */
2370 if (syslog_facility != newval)
2371 {
2372 if (openlog_done)
2373 {
2374 closelog();
2375 openlog_done = false;
2376 }
2378 }
2379#endif
2380 /* Without syslog support, just ignore it */
2381}
static int syslog_facility
Definition: guc_tables.c:603

References newval, and syslog_facility.

◆ assign_syslog_ident()

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

Definition at line 2332 of file elog.c.

2333{
2334#ifdef HAVE_SYSLOG
2335 /*
2336 * guc.c is likely to call us repeatedly with same parameters, so don't
2337 * thrash the syslog connection unnecessarily. Also, we do not re-open
2338 * the connection until needed, since this routine will get called whether
2339 * or not Log_destination actually mentions syslog.
2340 *
2341 * Note that we make our own copy of the ident string rather than relying
2342 * on guc.c's. This may be overly paranoid, but it ensures that we cannot
2343 * accidentally free a string that syslog is still using.
2344 */
2345 if (syslog_ident == NULL || strcmp(syslog_ident, newval) != 0)
2346 {
2347 if (openlog_done)
2348 {
2349 closelog();
2350 openlog_done = false;
2351 }
2352 free(syslog_ident);
2353 syslog_ident = strdup(newval);
2354 /* if the strdup fails, we will cope in write_syslog() */
2355 }
2356#endif
2357 /* Without syslog support, just ignore it */
2358}
#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:52
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:3113
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 3599 of file postgres.c.

3600{
3601 if (IsTransactionState())
3602 {
3603 /*
3604 * If transaction_timeout GUC has changed within the transaction block
3605 * enable or disable the timer correspondingly.
3606 */
3611 }
3612}
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 4938 of file xlog.c.

4939{
4940 /*
4941 * If some checks were deferred, it's possible that the checks will fail
4942 * later during InitializeWalConsistencyChecking(). But in that case, the
4943 * postmaster will exit anyway, so it's safe to proceed with the
4944 * assignment.
4945 *
4946 * Any built-in resource managers specified are assigned immediately,
4947 * which affects WAL created before shared_preload_libraries are
4948 * processed. Any custom resource managers specified won't be assigned
4949 * until after shared_preload_libraries are processed, but that's OK
4950 * because WAL for a custom resource manager can't be written before the
4951 * module is loaded anyway.
4952 */
4954}
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 8829 of file xlog.c.

8830{
8831 if (wal_sync_method != new_wal_sync_method)
8832 {
8833 /*
8834 * To ensure that no blocks escape unsynced, force an fsync on the
8835 * currently open log segment (if any). Also, if the open flag is
8836 * changing, close the log file so it will be reopened (with new flag
8837 * bit) at next use.
8838 */
8839 if (openLogFile >= 0)
8840 {
8841 pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN);
8842 if (pg_fsync(openLogFile) != 0)
8843 {
8844 char xlogfname[MAXFNAMELEN];
8845 int save_errno;
8846
8847 save_errno = errno;
8850 errno = save_errno;
8851 ereport(PANIC,
8853 errmsg("could not fsync file \"%s\": %m", xlogfname)));
8854 }
8855
8857 if (get_sync_bit(wal_sync_method) != get_sync_bit(new_wal_sync_method))
8858 XLogFileClose();
8859 }
8860 }
8861}
int errcode_for_file_access(void)
Definition: elog.c:877
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define PANIC
Definition: elog.h:42
#define ereport(elevel,...)
Definition: elog.h:149
int pg_fsync(int fd)
Definition: fd.c:386
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:646
int wal_segment_size
Definition: xlog.c:143
static int get_sync_bit(int method)
Definition: xlog.c:8781
int wal_sync_method
Definition: xlog.c:130
static TimeLineID openLogTLI
Definition: xlog.c:648
static void XLogFileClose(void)
Definition: xlog.c:3778
static XLogSegNo openLogSegNo
Definition: xlog.c:647
#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(LOG, 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 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:2146
char * pg_clean_ascii(const char *str, int alloc_flags)
Definition: string.c:85

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

◆ check_autovacuum_work_mem()

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

Definition at line 3387 of file autovacuum.c.

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

References newval.

◆ check_backtrace_functions()

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

Definition at line 2189 of file elog.c.

2190{
2191 int newvallen = strlen(*newval);
2192 char *someval;
2193 int validlen;
2194 int i;
2195 int j;
2196
2197 /*
2198 * Allow characters that can be C identifiers and commas as separators, as
2199 * well as some whitespace for readability.
2200 */
2201 validlen = strspn(*newval,
2202 "0123456789_"
2203 "abcdefghijklmnopqrstuvwxyz"
2204 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
2205 ", \n\t");
2206 if (validlen != newvallen)
2207 {
2208 GUC_check_errdetail("Invalid character.");
2209 return false;
2210 }
2211
2212 if (*newval[0] == '\0')
2213 {
2214 *extra = NULL;
2215 return true;
2216 }
2217
2218 /*
2219 * Allocate space for the output and create the copy. We could discount
2220 * whitespace chars to save some memory, but it doesn't seem worth the
2221 * trouble.
2222 */
2223 someval = guc_malloc(LOG, newvallen + 1 + 1);
2224 if (!someval)
2225 return false;
2226 for (i = 0, j = 0; i < newvallen; i++)
2227 {
2228 if ((*newval)[i] == ',')
2229 someval[j++] = '\0'; /* next item */
2230 else if ((*newval)[i] == ' ' ||
2231 (*newval)[i] == '\n' ||
2232 (*newval)[i] == '\t')
2233 ; /* ignore these */
2234 else
2235 someval[j++] = (*newval)[i]; /* copy anything else */
2236 }
2237
2238 /* two \0s end the setting */
2239 someval[j] = '\0';
2240 someval[j + 1] = '\0';
2241
2242 *extra = someval;
2243 return true;
2244}
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:78
int i
Definition: isn.c:77

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

◆ check_bonjour()

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

Definition at line 1223 of file variable.c.

1224{
1225#ifndef USE_BONJOUR
1226 if (*newval)
1227 {
1228 GUC_check_errmsg("Bonjour is not supported by this build");
1229 return false;
1230 }
1231#endif
1232 return true;
1233}
#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 3549 of file postgres.c.

3550{
3551 if (!WaitEventSetCanReportClosed() && *newval != 0)
3552 {
3553 GUC_check_errdetail("\"client_connection_check_interval\" must be set to 0 on this platform.");
3554 return false;
3555 }
3556 return true;
3557}
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:6786
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(LOG, 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(), LOG, MCXT_ALLOC_NO_OOM, newval, pfree(), and pg_clean_ascii().

◆ 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:354

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:2321
#define USE_SQL_DATES
Definition: miscadmin.h:238
#define USE_POSTGRES_DATES
Definition: miscadmin.h:236
#define USE_ISO_DATES
Definition: miscadmin.h:237
#define DATEORDER_DMY
Definition: miscadmin.h:244
#define DATEORDER_MDY
Definition: miscadmin.h:245
#define DATEORDER_YMD
Definition: miscadmin.h:243
#define USE_GERMAN_DATES
Definition: miscadmin.h:239
#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 4007 of file fd.c.

4008{
4009 bool result = true;
4010 int flags;
4011
4012#if PG_O_DIRECT == 0
4013 if (strcmp(*newval, "") != 0)
4014 {
4015 GUC_check_errdetail("\"%s\" is not supported on this platform.",
4016 "debug_io_direct");
4017 result = false;
4018 }
4019 flags = 0;
4020#else
4021 List *elemlist;
4022 ListCell *l;
4023 char *rawstring;
4024
4025 /* Need a modifiable copy of string */
4026 rawstring = pstrdup(*newval);
4027
4028 if (!SplitGUCList(rawstring, ',', &elemlist))
4029 {
4030 GUC_check_errdetail("Invalid list syntax in parameter \"%s\".",
4031 "debug_io_direct");
4032 pfree(rawstring);
4033 list_free(elemlist);
4034 return false;
4035 }
4036
4037 flags = 0;
4038 foreach(l, elemlist)
4039 {
4040 char *item = (char *) lfirst(l);
4041
4042 if (pg_strcasecmp(item, "data") == 0)
4043 flags |= IO_DIRECT_DATA;
4044 else if (pg_strcasecmp(item, "wal") == 0)
4045 flags |= IO_DIRECT_WAL;
4046 else if (pg_strcasecmp(item, "wal_init") == 0)
4047 flags |= IO_DIRECT_WAL_INIT;
4048 else
4049 {
4050 GUC_check_errdetail("Invalid option \"%s\".", item);
4051 result = false;
4052 break;
4053 }
4054 }
4055
4056 /*
4057 * It's possible to configure block sizes smaller than our assumed I/O
4058 * alignment size, which could result in invalid I/O requests.
4059 */
4060#if XLOG_BLCKSZ < PG_IO_ALIGN_SIZE
4061 if (result && (flags & (IO_DIRECT_WAL | IO_DIRECT_WAL_INIT)))
4062 {
4063 GUC_check_errdetail("\"%s\" is not supported for WAL because %s is too small.",
4064 "debug_io_direct", "XLOG_BLCKSZ");
4065 result = false;
4066 }
4067#endif
4068#if BLCKSZ < PG_IO_ALIGN_SIZE
4069 if (result && (flags & IO_DIRECT_DATA))
4070 {
4071 GUC_check_errdetail("\"%s\" is not supported for data because %s is too small.",
4072 "debug_io_direct", "BLCKSZ");
4073 result = false;
4074 }
4075#endif
4076
4077 pfree(rawstring);
4078 list_free(elemlist);
4079#endif
4080
4081 if (!result)
4082 return result;
4083
4084 /* Save the flags in *extra, for use by assign_debug_io_direct */
4085 *extra = guc_malloc(LOG, sizeof(int));
4086 if (!*extra)
4087 return false;
4088 *((int *) *extra) = flags;
4089
4090 return result;
4091}
#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 GUC_check_errdetail, guc_malloc(), IO_DIRECT_DATA, IO_DIRECT_WAL, IO_DIRECT_WAL_INIT, lfirst, list_free(), LOG, 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:854
#define NOTICE
Definition: elog.h:35
Oid MyDatabaseId
Definition: globals.c:95
@ 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 ERROR
Definition: elog.h:39
#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:3506
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:30
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:135
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 1236 of file variable.c.

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

References GUC_check_errcode(), GUC_check_errmsg, 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 3004 of file slot.c.

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

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 1210 of file aio.c.

1211{
1212 if (*newval == -1)
1213 {
1214 /*
1215 * Auto-tuning will be applied later during startup, as auto-tuning
1216 * depends on the value of various GUCs.
1217 */
1218 return true;
1219 }
1220 else if (*newval == 0)
1221 {
1222 GUC_check_errdetail("Only -1 or values bigger than 0 are valid.");
1223 return false;
1224 }
1225
1226 return true;
1227}

References GUC_check_errdetail, and newval.

◆ check_locale_messages()

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

Definition at line 404 of file pg_locale.c.

405{
406 if (**newval == '\0')
407 {
408 if (source == PGC_S_DEFAULT)
409 return true;
410 else
411 return false;
412 }
413
414 /*
415 * LC_MESSAGES category does not exist everywhere, but accept it anyway
416 *
417 * On Windows, we can't even check the value, so accept blindly
418 */
419#if defined(LC_MESSAGES) && !defined(WIN32)
420 return check_locale(LC_MESSAGES, *newval, NULL);
421#else
422 return true;
423#endif
424}
@ PGC_S_DEFAULT
Definition: guc.h:113
bool check_locale(int category, const char *locale, char **canonname)
Definition: pg_locale.c:293

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 358 of file pg_locale.c.

359{
360 return check_locale(LC_MONETARY, *newval, NULL);
361}

References check_locale(), and newval.

◆ check_locale_numeric()

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

Definition at line 370 of file pg_locale.c.

371{
372 return check_locale(LC_NUMERIC, *newval, NULL);
373}

References check_locale(), and newval.

◆ check_locale_time()

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

Definition at line 382 of file pg_locale.c.

383{
384 return check_locale(LC_TIME, *newval, NULL);
385}

References check_locale(), and newval.

◆ check_log_connections()

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

Definition at line 1068 of file backend_startup.c.

1069{
1070 uint32 flags;
1071 char *rawstring;
1072 List *elemlist;
1073 bool success;
1074
1075 /* Need a modifiable copy of string */
1076 rawstring = pstrdup(*newval);
1077
1078 if (!SplitIdentifierString(rawstring, ',', &elemlist))
1079 {
1080 GUC_check_errdetail("Invalid list syntax in parameter \"log_connections\".");
1081 pfree(rawstring);
1082 list_free(elemlist);
1083 return false;
1084 }
1085
1086 /* Validation logic is all in the helper */
1087 success = validate_log_connections_options(elemlist, &flags);
1088
1089 /* Time for cleanup */
1090 pfree(rawstring);
1091 list_free(elemlist);
1092
1093 if (!success)
1094 return false;
1095
1096 /*
1097 * We succeeded, so allocate `extra` and save the flags there for use by
1098 * assign_log_connections().
1099 */
1100 *extra = guc_malloc(LOG, sizeof(int));
1101 if (!*extra)
1102 return false;
1103 *((int *) *extra) = flags;
1104
1105 return true;
1106}
static bool validate_log_connections_options(List *elemlist, uint32 *flags)
uint32_t uint32
Definition: c.h:502
static bool success
Definition: initdb.c:187

References GUC_check_errdetail, guc_malloc(), list_free(), LOG, 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 2259 of file elog.c.

2260{
2261 char *rawstring;
2262 List *elemlist;
2263 ListCell *l;
2264 int newlogdest = 0;
2265 int *myextra;
2266
2267 /* Need a modifiable copy of string */
2268 rawstring = pstrdup(*newval);
2269
2270 /* Parse string into list of identifiers */
2271 if (!SplitIdentifierString(rawstring, ',', &elemlist))
2272 {
2273 /* syntax error in list */
2274 GUC_check_errdetail("List syntax is invalid.");
2275 pfree(rawstring);
2276 list_free(elemlist);
2277 return false;
2278 }
2279
2280 foreach(l, elemlist)
2281 {
2282 char *tok = (char *) lfirst(l);
2283
2284 if (pg_strcasecmp(tok, "stderr") == 0)
2285 newlogdest |= LOG_DESTINATION_STDERR;
2286 else if (pg_strcasecmp(tok, "csvlog") == 0)
2287 newlogdest |= LOG_DESTINATION_CSVLOG;
2288 else if (pg_strcasecmp(tok, "jsonlog") == 0)
2289 newlogdest |= LOG_DESTINATION_JSONLOG;
2290#ifdef HAVE_SYSLOG
2291 else if (pg_strcasecmp(tok, "syslog") == 0)
2292 newlogdest |= LOG_DESTINATION_SYSLOG;
2293#endif
2294#ifdef WIN32
2295 else if (pg_strcasecmp(tok, "eventlog") == 0)
2296 newlogdest |= LOG_DESTINATION_EVENTLOG;
2297#endif
2298 else
2299 {
2300 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
2301 pfree(rawstring);
2302 list_free(elemlist);
2303 return false;
2304 }
2305 }
2306
2307 pfree(rawstring);
2308 list_free(elemlist);
2309
2310 myextra = (int *) guc_malloc(LOG, sizeof(int));
2311 if (!myextra)
2312 return false;
2313 *myextra = newlogdest;
2314 *extra = myextra;
2315
2316 return true;
2317}
#define LOG_DESTINATION_JSONLOG
Definition: elog.h:489
#define LOG_DESTINATION_SYSLOG
Definition: elog.h:486
#define LOG_DESTINATION_STDERR
Definition: elog.h:485
#define LOG_DESTINATION_EVENTLOG
Definition: elog.h:487
#define LOG_DESTINATION_CSVLOG
Definition: elog.h:488

References GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG, 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 3584 of file postgres.c.

3585{
3586 if (*newval &&
3588 {
3589 GUC_check_errdetail("Cannot enable \"log_statement_stats\" when "
3590 "\"log_parser_stats\", \"log_planner_stats\", "
3591 "or \"log_executor_stats\" is true.");
3592 return false;
3593 }
3594 return true;
3595}
bool log_parser_stats
Definition: guc_tables.c:519
bool log_planner_stats
Definition: guc_tables.c:520
bool log_executor_stats
Definition: guc_tables.c:521

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_max_slot_wal_keep_size()

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

Definition at line 2356 of file xlog.c.

2357{
2358 if (IsBinaryUpgrade && *newval != -1)
2359 {
2360 GUC_check_errdetail("\"%s\" must be set to -1 during binary upgrade mode.",
2361 "max_slot_wal_keep_size");
2362 return false;
2363 }
2364
2365 return true;
2366}

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:297
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 4760 of file xlogrecovery.c.

4761{
4762 if (*newval && strcmp(*newval, "") != 0 &&
4764 return false;
4765
4766 return true;
4767}
#define WARNING
Definition: elog.h:36
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 4800 of file xlogrecovery.c.

4801{
4802 if (strcmp(*newval, "immediate") != 0 && strcmp(*newval, "") != 0)
4803 {
4804 GUC_check_errdetail("The only allowed value is \"immediate\".");
4805 return false;
4806 }
4807 return true;
4808}

References GUC_check_errdetail, and newval.

◆ check_recovery_target_lsn()

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

Definition at line 4830 of file xlogrecovery.c.

4831{
4832 if (strcmp(*newval, "") != 0)
4833 {
4834 XLogRecPtr lsn;
4835 XLogRecPtr *myextra;
4836 bool have_error = false;
4837
4838 lsn = pg_lsn_in_internal(*newval, &have_error);
4839 if (have_error)
4840 return false;
4841
4842 myextra = (XLogRecPtr *) guc_malloc(LOG, sizeof(XLogRecPtr));
4843 if (!myextra)
4844 return false;
4845 *myextra = lsn;
4846 *extra = myextra;
4847 }
4848 return true;
4849}
XLogRecPtr pg_lsn_in_internal(const char *str, bool *have_error)
Definition: pg_lsn.c:29

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

◆ check_recovery_target_name()

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

Definition at line 4874 of file xlogrecovery.c.

4875{
4876 /* Use the value of newval directly */
4877 if (strlen(*newval) >= MAXFNAMELEN)
4878 {
4879 GUC_check_errdetail("\"%s\" is too long (maximum %d characters).",
4880 "recovery_target_name", MAXFNAMELEN - 1);
4881 return false;
4882 }
4883 return true;
4884}

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 4915 of file xlogrecovery.c.

4916{
4917 if (strcmp(*newval, "") != 0)
4918 {
4919 /* reject some special values */
4920 if (strcmp(*newval, "now") == 0 ||
4921 strcmp(*newval, "today") == 0 ||
4922 strcmp(*newval, "tomorrow") == 0 ||
4923 strcmp(*newval, "yesterday") == 0)
4924 {
4925 return false;
4926 }
4927
4928 /*
4929 * parse timestamp value (see also timestamptz_in())
4930 */
4931 {
4932 char *str = *newval;
4933 fsec_t fsec;
4934 struct pg_tm tt,
4935 *tm = &tt;
4936 int tz;
4937 int dtype;
4938 int nf;
4939 int dterr;
4940 char *field[MAXDATEFIELDS];
4941 int ftype[MAXDATEFIELDS];
4942 char workbuf[MAXDATELEN + MAXDATEFIELDS];
4943 DateTimeErrorExtra dtextra;
4945
4946 dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
4947 field, ftype, MAXDATEFIELDS, &nf);
4948 if (dterr == 0)
4949 dterr = DecodeDateTime(field, ftype, nf,
4950 &dtype, tm, &fsec, &tz, &dtextra);
4951 if (dterr != 0)
4952 return false;
4953 if (dtype != DTK_DATE)
4954 return false;
4955
4956 if (tm2timestamp(tm, fsec, &tz, &timestamp) != 0)
4957 {
4958 GUC_check_errdetail("Timestamp out of range: \"%s\".", str);
4959 return false;
4960 }
4961 }
4962 }
4963 return true;
4964}
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:2006
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 4986 of file xlogrecovery.c.

4987{
4990
4991 if (strcmp(*newval, "current") == 0)
4993 else if (strcmp(*newval, "latest") == 0)
4995 else
4996 {
4998
4999 errno = 0;
5000 strtoul(*newval, NULL, 0);
5001 if (errno == EINVAL || errno == ERANGE)
5002 {
5003 GUC_check_errdetail("\"recovery_target_timeline\" is not a valid number.");
5004 return false;
5005 }
5006 }
5007
5009 if (!myextra)
5010 return false;
5011 *myextra = rttg;
5012 *extra = myextra;
5013
5014 return true;
5015}
@ RECOVERY_TARGET_TIMELINE_CONTROLFILE
Definition: xlogrecovery.h:38
@ RECOVERY_TARGET_TIMELINE_LATEST
Definition: xlogrecovery.h:39

References GUC_check_errdetail, guc_malloc(), LOG, 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 5034 of file xlogrecovery.c.

5035{
5036 if (strcmp(*newval, "") != 0)
5037 {
5038 TransactionId xid;
5039 TransactionId *myextra;
5040
5041 errno = 0;
5042 xid = (TransactionId) strtou64(*newval, NULL, 0);
5043 if (errno == EINVAL || errno == ERANGE)
5044 return false;
5045
5046 myextra = (TransactionId *) guc_malloc(LOG, sizeof(TransactionId));
5047 if (!myextra)
5048 return false;
5049 *myextra = xid;
5050 *extra = myextra;
5051 }
5052 return true;
5053}

References guc_malloc(), LOG, and newval.

◆ check_restrict_nonsystem_relation_kind()

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

Definition at line 3618 of file postgres.c.

3619{
3620 char *rawstring;
3621 List *elemlist;
3622 ListCell *l;
3623 int flags = 0;
3624
3625 /* Need a modifiable copy of string */
3626 rawstring = pstrdup(*newval);
3627
3628 if (!SplitIdentifierString(rawstring, ',', &elemlist))
3629 {
3630 /* syntax error in list */
3631 GUC_check_errdetail("List syntax is invalid.");
3632 pfree(rawstring);
3633 list_free(elemlist);
3634 return false;
3635 }
3636
3637 foreach(l, elemlist)
3638 {
3639 char *tok = (char *) lfirst(l);
3640
3641 if (pg_strcasecmp(tok, "view") == 0)
3642 flags |= RESTRICT_RELKIND_VIEW;
3643 else if (pg_strcasecmp(tok, "foreign-table") == 0)
3645 else
3646 {
3647 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
3648 pfree(rawstring);
3649 list_free(elemlist);
3650 return false;
3651 }
3652 }
3653
3654 pfree(rawstring);
3655 list_free(elemlist);
3656
3657 /* Save the flags in *extra, for use by the assign function */
3658 *extra = guc_malloc(LOG, sizeof(int));
3659 if (!*extra)
3660 return false;
3661 *((int *) *extra) = flags;
3662
3663 return true;
3664}
#define RESTRICT_RELKIND_FOREIGN_TABLE
Definition: tcopprot.h:44
#define RESTRICT_RELKIND_VIEW
Definition: tcopprot.h:43

References GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG, 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:536
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:4899
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 1251 of file variable.c.

1252{
1253#ifndef USE_SSL
1254 if (*newval)
1255 {
1256 GUC_check_errmsg("SSL is not supported by this build");
1257 return false;
1258 }
1259#endif
1260 return true;
1261}

References GUC_check_errmsg, and newval.

◆ check_stage_log_stats()

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

Definition at line 3570 of file postgres.c.

3571{
3573 {
3574 GUC_check_errdetail("Cannot enable parameter when \"log_statement_stats\" is true.");
3575 return false;
3576 }
3577 return true;
3578}
bool log_statement_stats
Definition: guc_tables.c:522

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 if (!config)
2734 return false;
2735
2736 /* Transform the data into SyncStandbySlotsConfigData */
2737 config->nslotnames = list_length(elemlist);
2738
2739 ptr = config->slot_names;
2740 foreach_ptr(char, slot_name, elemlist)
2741 {
2742 strcpy(ptr, slot_name);
2743 ptr += strlen(slot_name) + 1;
2744 }
2745
2746 *extra = config;
2747
2748 pfree(rawname);
2749 list_free(elemlist);
2750 return true;
2751}
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 1058 of file syncrep.c.

1059{
1060 if (*newval != NULL && (*newval)[0] != '\0')
1061 {
1062 yyscan_t scanner;
1063 int parse_rc;
1064 SyncRepConfigData *pconf;
1065
1066 /* Result of parsing is returned in one of these two variables */
1067 SyncRepConfigData *syncrep_parse_result = NULL;
1068 char *syncrep_parse_error_msg = NULL;
1069
1070 /* Parse the synchronous_standby_names string */
1071 syncrep_scanner_init(*newval, &scanner);
1072 parse_rc = syncrep_yyparse(&syncrep_parse_result, &syncrep_parse_error_msg, scanner);
1073 syncrep_scanner_finish(scanner);
1074
1075 if (parse_rc != 0 || syncrep_parse_result == NULL)
1076 {
1077 GUC_check_errcode(ERRCODE_SYNTAX_ERROR);
1078 if (syncrep_parse_error_msg)
1079 GUC_check_errdetail("%s", syncrep_parse_error_msg);
1080 else
1081 GUC_check_errdetail("\"%s\" parser failed.",
1082 "synchronous_standby_names");
1083 return false;
1084 }
1085
1086 if (syncrep_parse_result->num_sync <= 0)
1087 {
1088 GUC_check_errmsg("number of synchronous standbys (%d) must be greater than zero",
1089 syncrep_parse_result->num_sync);
1090 return false;
1091 }
1092
1093 /* GUC extra value must be guc_malloc'd, not palloc'd */
1094 pconf = (SyncRepConfigData *)
1095 guc_malloc(LOG, syncrep_parse_result->config_size);
1096 if (pconf == NULL)
1097 return false;
1098 memcpy(pconf, syncrep_parse_result, syncrep_parse_result->config_size);
1099
1100 *extra = pconf;
1101
1102 /*
1103 * We need not explicitly clean up syncrep_parse_result. It, and any
1104 * other cruft generated during parsing, will be freed when the
1105 * current memory context is deleted. (This code is generally run in
1106 * a short-lived context used for config file processing, so that will
1107 * not be very long.)
1108 */
1109 }
1110 else
1111 *extra = NULL;
1112
1113 return true;
1114}
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 868 of file localbuf.c.

869{
870 /*
871 * Once local buffers have been initialized, it's too late to change this.
872 * However, if this is only a test call, allow it.
873 */
875 {
876 GUC_check_errdetail("\"temp_buffers\" cannot be changed after any temporary tables have been accessed in the session.");
877 return false;
878 }
879 return true;
880}
int NLocBuffer
Definition: localbuf.c:44

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:2639
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3821
Oid MyDatabaseTableSpace
Definition: globals.c:97
void * palloc(Size size)
Definition: mcxt.c:1939
@ OBJECT_TABLESPACE
Definition: parsenodes.h:2359
#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:891
#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:686
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:6522

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:278
#define MAX_BAS_VAC_RING_SIZE_KB
Definition: miscadmin.h:279

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 4816 of file xlog.c.

4817{
4818 /*
4819 * -1 indicates a request for auto-tune.
4820 */
4821 if (*newval == -1)
4822 {
4823 /*
4824 * If we haven't yet changed the boot_val default of -1, just let it
4825 * be. We'll fix it when XLOGShmemSize is called.
4826 */
4827 if (XLOGbuffers == -1)
4828 return true;
4829
4830 /* Otherwise, substitute the auto-tune value */
4832 }
4833
4834 /*
4835 * We clamp manually-set values to at least 4 blocks. Prior to PostgreSQL
4836 * 9.1, a minimum of 4 was enforced by guc.c, but since that is no longer
4837 * the case, we just silently treat such values as a request for the
4838 * minimum. (We could throw an error instead, but that doesn't seem very
4839 * helpful.)
4840 */
4841 if (*newval < 4)
4842 *newval = 4;
4843
4844 return true;
4845}
static int XLOGChooseNumBuffers(void)
Definition: xlog.c:4800
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 4851 of file xlog.c.

4852{
4853 char *rawstring;
4854 List *elemlist;
4855 ListCell *l;
4856 bool newwalconsistency[RM_MAX_ID + 1];
4857
4858 /* Initialize the array */
4859 MemSet(newwalconsistency, 0, (RM_MAX_ID + 1) * sizeof(bool));
4860
4861 /* Need a modifiable copy of string */
4862 rawstring = pstrdup(*newval);
4863
4864 /* Parse string into list of identifiers */
4865 if (!SplitIdentifierString(rawstring, ',', &elemlist))
4866 {
4867 /* syntax error in list */
4868 GUC_check_errdetail("List syntax is invalid.");
4869 pfree(rawstring);
4870 list_free(elemlist);
4871 return false;
4872 }
4873
4874 foreach(l, elemlist)
4875 {
4876 char *tok = (char *) lfirst(l);
4877 int rmid;
4878
4879 /* Check for 'all'. */
4880 if (pg_strcasecmp(tok, "all") == 0)
4881 {
4882 for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
4883 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL)
4884 newwalconsistency[rmid] = true;
4885 }
4886 else
4887 {
4888 /* Check if the token matches any known resource manager. */
4889 bool found = false;
4890
4891 for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
4892 {
4893 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL &&
4894 pg_strcasecmp(tok, GetRmgr(rmid).rm_name) == 0)
4895 {
4896 newwalconsistency[rmid] = true;
4897 found = true;
4898 break;
4899 }
4900 }
4901 if (!found)
4902 {
4903 /*
4904 * During startup, it might be a not-yet-loaded custom
4905 * resource manager. Defer checking until
4906 * InitializeWalConsistencyChecking().
4907 */
4909 {
4911 }
4912 else
4913 {
4914 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
4915 pfree(rawstring);
4916 list_free(elemlist);
4917 return false;
4918 }
4919 }
4920 }
4921 }
4922
4923 pfree(rawstring);
4924 list_free(elemlist);
4925
4926 /* assign new value */
4927 *extra = guc_malloc(LOG, (RM_MAX_ID + 1) * sizeof(bool));
4928 if (!*extra)
4929 return false;
4930 memcpy(*extra, newwalconsistency, (RM_MAX_ID + 1) * sizeof(bool));
4931 return true;
4932}
#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, GetRmgr(), GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG, 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 2338 of file xlog.c.

2339{
2341 {
2342 GUC_check_errdetail("The WAL segment size must be a power of two between 1 MB and 1 GB.");
2343 return false;
2344 }
2345
2346 return true;
2347}
#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 4991 of file xlog.c.

4992{
4993 if (XLogArchivingActive())
4994 return XLogArchiveCommand;
4995 else
4996 return "(disabled)";
4997}
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 1184 of file variable.c.

1185{
1186 static char buf[12];
1187
1188 snprintf(buf, sizeof(buf), "%04o", data_directory_mode);
1189 return buf;
1190}
int data_directory_mode
Definition: globals.c:78
#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 5003 of file xlog.c.

5004{
5005 /*
5006 * We display the actual state based on shared memory, so that this GUC
5007 * reports up-to-date state if examined intra-query. The underlying
5008 * variable (in_hot_standby_guc) changes only when we transmit a new value
5009 * to the client.
5010 */
5011 return RecoveryInProgress() ? "on" : "off";
5012}

References RecoveryInProgress().

◆ show_log_file_mode()

const char * show_log_file_mode ( void  )

Definition at line 1196 of file variable.c.

1197{
1198 static char buf[12];
1199
1200 snprintf(buf, sizeof(buf), "%04o", Log_file_mode);
1201 return buf;
1202}
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:636

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 1208 of file variable.c.

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

References buf, snprintf, and Unix_socket_permissions.