#include <signal.h>
#include "pgtime.h"

Include dependency graph for miscadmin.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	InvalidPid (-1)

#define	CHECK_FOR_INTERRUPTS()

#define	HOLD_INTERRUPTS() (InterruptHoldoffCount++)

#define	RESUME_INTERRUPTS()

#define	HOLD_CANCEL_INTERRUPTS() (QueryCancelHoldoffCount++)

#define	RESUME_CANCEL_INTERRUPTS()

#define	START_CRIT_SECTION() (CritSectionCount++)

#define	END_CRIT_SECTION()

#define	USE_POSTGRES_DATES 0

#define	USE_ISO_DATES 1

#define	USE_SQL_DATES 2

#define	USE_GERMAN_DATES 3

#define	USE_XSD_DATES 4

#define	DATEORDER_YMD 0

#define	DATEORDER_DMY 1

#define	DATEORDER_MDY 2

#define	INTSTYLE_POSTGRES 0

#define	INTSTYLE_POSTGRES_VERBOSE 1

#define	INTSTYLE_SQL_STANDARD 2

#define	INTSTYLE_ISO_8601 3

#define	MAXTZLEN 10 /* max TZ name len, not counting tr. null */

#define	SECURITY_LOCAL_USERID_CHANGE 0x0001

#define	SECURITY_RESTRICTED_OPERATION 0x0002

#define	SECURITY_NOFORCE_RLS 0x0004

#define	IsBootstrapProcessingMode() (Mode == BootstrapProcessing)

#define	IsInitProcessingMode() (Mode == InitProcessing)

#define	IsNormalProcessingMode() (Mode == NormalProcessing)

#define	GetProcessingMode() Mode

#define	SetProcessingMode(mode)

#define	AmBootstrapProcess() (MyAuxProcType == BootstrapProcess)

#define	AmStartupProcess() (MyAuxProcType == StartupProcess)

#define	AmBackgroundWriterProcess() (MyAuxProcType == BgWriterProcess)

#define	AmCheckpointerProcess() (MyAuxProcType == CheckpointerProcess)

#define	AmWalWriterProcess() (MyAuxProcType == WalWriterProcess)

#define	AmWalReceiverProcess() (MyAuxProcType == WalReceiverProcess)

Typedefs
typedef char *	pg_stack_base_t

typedef enum ProcessingMode	ProcessingMode

Enumerations
enum	ProcessingMode { BootstrapProcessing, InitProcessing, NormalProcessing }

enum	AuxProcType { NotAnAuxProcess = -1, CheckerProcess = 0, BootstrapProcess, StartupProcess, BgWriterProcess, CheckpointerProcess, WalWriterProcess, WalReceiverProcess, NUM_AUXPROCTYPES }

Functions
void	ProcessInterrupts (void)

pg_stack_base_t	set_stack_base (void)

void	restore_stack_base (pg_stack_base_t base)

void	check_stack_depth (void)

bool	stack_is_too_deep (void)

void	PostgresSigHupHandler (SIGNAL_ARGS)

void	PreventCommandIfReadOnly (const char *cmdname)

void	PreventCommandIfParallelMode (const char *cmdname)

void	PreventCommandDuringRecovery (const char *cmdname)

int	trace_recovery (int trace_level)

void	InitPostmasterChild (void)

void	InitStandaloneProcess (const char *argv0)

void	SetDatabasePath (const char *path)

char *	GetUserNameFromId (Oid roleid, bool noerr)

Oid	GetUserId (void)

Oid	GetOuterUserId (void)

Oid	GetSessionUserId (void)

Oid	GetAuthenticatedUserId (void)

void	GetUserIdAndSecContext (Oid userid, int sec_context)

void	SetUserIdAndSecContext (Oid userid, int sec_context)

bool	InLocalUserIdChange (void)

bool	InSecurityRestrictedOperation (void)

bool	InNoForceRLSOperation (void)

void	GetUserIdAndContext (Oid userid, bool sec_def_context)

void	SetUserIdAndContext (Oid userid, bool sec_def_context)

void	InitializeSessionUserId (const char *rolename, Oid useroid)

void	InitializeSessionUserIdStandalone (void)

void	SetSessionAuthorization (Oid userid, bool is_superuser)

Oid	GetCurrentRoleId (void)

void	SetCurrentRoleId (Oid roleid, bool is_superuser)

void	SetDataDir (const char *dir)

void	ChangeToDataDir (void)

void	SwitchToSharedLatch (void)

void	SwitchBackToLocalLatch (void)

bool	superuser (void)

bool	superuser_arg (Oid roleid)

void	pg_split_opts (char *argv, int argcp, const char *optstr)

void	InitializeMaxBackends (void)

void	InitPostgres (const char in_dbname, Oid dboid, const char username, Oid useroid, char *out_dbname)

void	BaseInit (void)

void	CreateDataDirLockFile (bool amPostmaster)

void	CreateSocketLockFile (const char socketfile, bool amPostmaster, const char socketDir)

void	TouchSocketLockFiles (void)

void	AddToDataDirLockFile (int target_line, const char *str)

bool	RecheckDataDirLockFile (void)

void	ValidatePgVersion (const char *path)

void	process_shared_preload_libraries (void)

void	process_session_preload_libraries (void)

void	pg_bindtextdomain (const char *domain)

bool	has_rolreplication (Oid roleid)

bool	BackupInProgress (void)

void	CancelBackup (void)

Variables
PGDLLIMPORT volatile bool	InterruptPending

PGDLLIMPORT volatile bool	QueryCancelPending

PGDLLIMPORT volatile bool	ProcDiePending

PGDLLIMPORT volatile bool	IdleInTransactionSessionTimeoutPending

PGDLLIMPORT volatile sig_atomic_t	ConfigReloadPending

volatile bool	ClientConnectionLost

PGDLLIMPORT volatile uint32	InterruptHoldoffCount

PGDLLIMPORT volatile uint32	QueryCancelHoldoffCount

PGDLLIMPORT volatile uint32	CritSectionCount

PGDLLIMPORT pid_t	PostmasterPid

PGDLLIMPORT bool	IsPostmasterEnvironment

PGDLLIMPORT bool	IsUnderPostmaster

PGDLLIMPORT bool	IsBackgroundWorker

PGDLLIMPORT bool	IsBinaryUpgrade

bool	ExitOnAnyError

PGDLLIMPORT char *	DataDir

PGDLLIMPORT int	NBuffers

int	MaxBackends

int	MaxConnections

int	max_worker_processes

int	max_parallel_workers

PGDLLIMPORT int	MyProcPid

PGDLLIMPORT pg_time_t	MyStartTime

PGDLLIMPORT struct Port *	MyProcPort

PGDLLIMPORT struct Latch *	MyLatch

int32	MyCancelKey

int	MyPMChildSlot

char	OutputFileName []

PGDLLIMPORT char	my_exec_path []

char	pkglib_path []

PGDLLIMPORT Oid	MyDatabaseId

PGDLLIMPORT Oid	MyDatabaseTableSpace

PGDLLIMPORT int	DateStyle

PGDLLIMPORT int	DateOrder

PGDLLIMPORT int	IntervalStyle

bool	enableFsync

bool	allowSystemTableMods

PGDLLIMPORT int	work_mem

PGDLLIMPORT int	maintenance_work_mem

PGDLLIMPORT int	replacement_sort_tuples

int	VacuumCostPageHit

int	VacuumCostPageMiss

int	VacuumCostPageDirty

int	VacuumCostLimit

int	VacuumCostDelay

int	VacuumPageHit

int	VacuumPageMiss

int	VacuumPageDirty

int	VacuumCostBalance

bool	VacuumCostActive

int	trace_recovery_messages

char *	DatabasePath

ProcessingMode	Mode

AuxProcType	MyAuxProcType

bool	IgnoreSystemIndexes

PGDLLIMPORT bool	process_shared_preload_libraries_in_progress

char *	session_preload_libraries_string

char *	shared_preload_libraries_string

char *	local_preload_libraries_string

Macro Definition Documentation

#define AmBackgroundWriterProcess ( ) (MyAuxProcType == BgWriterProcess)

Definition at line 407 of file miscadmin.h.

Referenced by ForwardFsyncRequest().

#define AmBootstrapProcess ( ) (MyAuxProcType == BootstrapProcess)

Definition at line 405 of file miscadmin.h.

#define AmCheckpointerProcess ( ) (MyAuxProcType == CheckpointerProcess)

Definition at line 408 of file miscadmin.h.

Referenced by AbsorbFsyncRequests(), CheckpointWriteDelay(), ForwardFsyncRequest(), and mdinit().

#define AmStartupProcess ( ) (MyAuxProcType == StartupProcess)

Definition at line 406 of file miscadmin.h.

Referenced by HotStandbyActiveInReplay(), and mdinit().

#define AmWalReceiverProcess ( ) (MyAuxProcType == WalReceiverProcess)

Definition at line 410 of file miscadmin.h.

Referenced by get_sync_bit().

#define AmWalWriterProcess ( ) (MyAuxProcType == WalWriterProcess)

Definition at line 409 of file miscadmin.h.

#define CHECK_FOR_INTERRUPTS ( )

Value:

do { \
    if (InterruptPending) \
		ProcessInterrupts(); \
} while(0)

Definition at line 98 of file miscadmin.h.

Referenced by _bt_buildadd(), _bt_readnextpage(), _bt_walk_left(), _crypt_blowfish_rn(), _hash_init(), _hash_readnext(), _hash_readprev(), add_partial_path(), add_path(), agg_retrieve_hash_table(), analyze_rel(), ApplyLauncherMain(), ATRewriteTable(), backend_read_statsfile(), BipartiteMatch(), BitmapHeapNext(), blgetbitmap(), bloomBuildCallback(), brin_evacuate_page(), brin_getinsertbuffer(), brin_vacuum_scan(), bringetbitmap(), brinGetTupleForHeapBlock(), brininsert(), brinsummarize(), bt_check_level_from_leftmost(), bt_right_page_check_scankey(), bt_target_page_check(), btree_xlog_delete_get_latestRemovedXid(), calculate_database_size(), calculate_relation_size(), calculate_tablespace_size(), ClientAuthentication(), cluster_rel(), collect_corrupt_items(), collect_visibility_data(), ConditionVariableSleep(), copy_file(), copy_heap_data(), copy_messages(), copy_read_data(), copy_relation_data(), copydir(), CopyFrom(), CopyTo(), count_nondeletable_pages(), CountOtherDBBackends(), db_dir_size(), DecodingContextFindStartpoint(), do_autovacuum(), do_des(), do_pg_stop_backup(), dofindsubquery(), errfinish(), exec_execute_message(), exec_parse_message(), exec_replication_command(), exec_simple_query(), exec_stmt(), exec_stmts(), ExecAgg(), ExecAppend(), ExecCustomScan(), ExecGather(), ExecGatherMerge(), ExecGroup(), ExecHashIncreaseNumBatches(), ExecHashIncreaseNumBuckets(), ExecHashJoin(), ExecHashJoinGetSavedTuple(), ExecHashRemoveNextSkewBucket(), ExecLimit(), ExecLockRows(), ExecMakeTableFunctionResult(), ExecMaterial(), ExecMergeAppend(), ExecMergeJoin(), ExecModifyTable(), ExecNestLoop(), ExecProjectSet(), ExecRecursiveUnion(), ExecResult(), ExecScan(), ExecScanHashTableForUnmatched(), ExecSetOp(), ExecSort(), ExecSubPlan(), ExecUnique(), ExecWindowAgg(), fetch_input_tuple(), findPartialMatch(), fsm_vacuum_page(), gather_getnext(), gather_merge_init(), gather_readnext(), get_query_def(), get_rule_expr(), get_setop_query(), GetMultiXactIdMembers(), GetNewOidWithIndex(), GetNewRelFileNode(), getNextNearest(), ginbuild(), ginBuildCallback(), gingetbitmap(), gistgetbitmap(), gistgettuple(), gistProcessItup(), gm_readnext_tuple(), HandleFunctionRequest(), hash_xlog_vacuum_get_latestRemovedXid(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heapgetpage(), hypothetical_dense_rank_final(), hypothetical_rank_common(), ident_inet(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), interactive_getc(), lazy_truncate_heap(), libpqrcv_connect(), libpqrcv_PQexec(), libpqrcv_processTuples(), logicalrep_worker_stop(), LogicalRepApplyLoop(), lseg_inside_poly(), make_bounded_heap(), mode_final(), mq_putmessage(), MultiExecBitmapIndexScan(), MultiExecProcNode(), numeric_fac(), OpenTableList(), pg_logical_slot_get_changes_guts(), pg_prewarm(), pg_sleep(), pg_visibility_map_summary(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PGSemaphoreLock(), pgstat_collect_oids(), pgstat_get_backend_current_activity(), pgstat_heap(), pgstat_index(), pgstat_read_current_status(), pgstat_vacuum_stat(), pgstathashindex(), pgstatindex_impl(), plperl_spi_prepare(), PortalRunMulti(), postgresAcquireSampleRowsFunc(), PostgresMain(), predicate_implied_by_simple_clause(), predicate_refuted_by_simple_clause(), process_ordered_aggregate_multi(), ProcessClientReadInterrupt(), ProcessClientWriteInterrupt(), ProcessWalRcvInterrupts(), ProcSleep(), ProcWaitForSignal(), puttuple_common(), random_relative_prime(), RE_compile_and_cache(), RE_wchar_execute(), read_local_xlog_page(), refresh_matview_datafill(), regexp_fixed_prefix(), replace_text(), replace_text_regexp(), replorigin_create(), RequestCheckpoint(), revmap_extend_and_get_blkno(), sendAuthRequest(), sendDir(), set_rtable_names(), setop_retrieve_hash_table(), shm_mq_receive_bytes(), shm_mq_send_bytes(), shm_mq_wait_internal(), spgdoinsert(), spgWalk(), statapprox_heap(), storeQueryResult(), summarize_range(), tablesample_getnext(), test_shm_mq_pipelined(), text_to_array_internal(), tfuncLoadRows(), throttle(), TidNext(), toast_save_datum(), tuplesort_heap_insert(), tuplesort_heap_replace_top(), tuplesort_skiptuples(), tuplestore_skiptuples(), vacuum_delay_point(), vacuum_rel(), validate_index_heapscan(), wait_for_relation_state_change(), wait_for_worker_state_change(), wait_for_workers_to_become_ready(), wait_pid(), WaitExceedsMaxStandbyDelay(), WaitForBackgroundWorkerShutdown(), WaitForBackgroundWorkerStartup(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), walkdir(), WalSndLoop(), WalSndWaitForWal(), WalSndWriteData(), and window_gettupleslot().

#define DATEORDER_DMY 1

Definition at line 218 of file miscadmin.h.

Referenced by check_datestyle(), DecodeNumber(), EncodeDateOnly(), EncodeDateTime(), locale_date_order(), and setup_config().

#define DATEORDER_MDY 2

Definition at line 219 of file miscadmin.h.

Referenced by check_datestyle(), locale_date_order(), and setup_config().

#define DATEORDER_YMD 0

Definition at line 217 of file miscadmin.h.

Referenced by check_datestyle(), DecodeNumber(), locale_date_order(), and setup_config().

#define END_CRIT_SECTION ( )

Value:

do { \
	Assert(CritSectionCount > 0); \
	CritSectionCount--; \
} while(0)

Definition at line 133 of file miscadmin.h.

Referenced by _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_newroot(), _bt_split(), _bt_unlink_halfdead_page(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_freeovflpage(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), AbsorbFsyncRequests(), addLeafTuple(), brin_doinsert(), brin_doupdate(), brin_initialize_empty_new_buffer(), brinbuildempty(), brinRevmapDesummarizeRange(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), createPostingTree(), CreateSlotOnDisk(), do_setval(), doPickSplit(), EndPrepare(), fill_seq_with_data(), FreeSpaceMapTruncateRel(), GenericXLogFinish(), ginbuild(), ginbuildempty(), ginbulkdelete(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginUpdateStats(), ginVacuumPostingTreeLeaf(), gistbuild(), gistbuildempty(), gistbulkdelete(), gistplacetopage(), gistvacuumpage(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_finish_speculative(), heap_inplace_update(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_page_prune(), heap_update(), lazy_scan_heap(), lazy_vacuum_page(), moveLeafs(), MultiXactIdCreateFromMembers(), nextval_internal(), PostPrepare_Locks(), RecordTransactionAbort(), RecordTransactionAbortPrepared(), RecordTransactionCommit(), RecordTransactionCommitPrepared(), ReplicationSlotDropPtr(), RestoreSlotFromDisk(), revmap_physical_extend(), SaveSlotToPath(), shiftList(), SlruPhysicalWritePage(), spgAddNodeAction(), spgbuild(), spgSplitNodeAction(), TruncateMultiXact(), UpdateFullPageWrites(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), visibilitymap_set(), visibilitymap_truncate(), write_relmap_file(), writeListPage(), XLogBackgroundFlush(), XLogFlush(), and XLogInsertRecord().

#define GetProcessingMode ( ) Mode

Definition at line 372 of file miscadmin.h.

#define HOLD_CANCEL_INTERRUPTS ( ) (QueryCancelHoldoffCount++)

Definition at line 123 of file miscadmin.h.

Referenced by CopyGetData(), and SocketBackend().

#define HOLD_INTERRUPTS ( ) (InterruptHoldoffCount++)

#define INTSTYLE_ISO_8601 3

Definition at line 234 of file miscadmin.h.

Referenced by EncodeInterval().

#define INTSTYLE_POSTGRES 0

Definition at line 231 of file miscadmin.h.

Referenced by EncodeInterval(), and set_transmission_modes().

#define INTSTYLE_POSTGRES_VERBOSE 1

Definition at line 232 of file miscadmin.h.

Referenced by DecodeInterval(), EncodeInterval(), and PGTYPESinterval_to_asc().

#define INTSTYLE_SQL_STANDARD 2

Definition at line 233 of file miscadmin.h.

Referenced by DecodeInterval(), and EncodeInterval().

#define InvalidPid (-1)

Definition at line 31 of file miscadmin.h.

Referenced by asyncQueueAdvanceTail(), asyncQueueFillWarning(), asyncQueueUnregister(), AsyncShmemInit(), BackgroundWorkerShmemInit(), GetBackgroundWorkerPid(), GetSafeSnapshot(), GetSerializableTransactionSnapshot(), RegisterDynamicBackgroundWorker(), RestoreTransactionSnapshot(), and SignalBackends().

#define IsBootstrapProcessingMode ( ) (Mode == BootstrapProcessing)

Definition at line 368 of file miscadmin.h.

Referenced by AtEOXact_cleanup(), BootstrapModeMain(), CacheInvalidateHeapTuple(), create_toast_table(), DefineIndex(), ExecUpdate(), format_operator_internal(), format_procedure_internal(), formrdesc(), get_type_io_data(), get_user_default_acl(), GetNewOid(), GetNewTransactionId(), heap_create_with_catalog(), heap_inplace_update(), index_constraint_create(), index_create(), index_update_stats(), IndexBuildHeapRangeScan(), initialize_acl(), InitializeSearchPath(), InitializeSessionUserId(), InitPostgres(), InitXLOGAccess(), mdcreate(), mdopen(), RangeVarGetAndCheckCreationNamespace(), recordMultipleDependencies(), recordSharedDependencyOn(), regclassin(), regclassout(), regconfigin(), regdictionaryin(), regnamespacein(), regoperatorin(), regoperin(), regoperout(), regprocedurein(), regprocin(), regprocout(), regrolein(), regtypein(), regtypeout(), RelationCacheInitializePhase2(), RelationCacheInitializePhase3(), RelationDecrementReferenceCount(), RelationIncrementReferenceCount(), RelationMapFinishBootstrap(), RelationMapInitializePhase2(), RelationMapInitializePhase3(), RelationMapUpdateMap(), SearchCatCache(), TypeCreate(), TypeShellMake(), XLogInsert(), and XLOGShmemInit().

#define IsInitProcessingMode ( ) (Mode == InitProcessing)

Definition at line 369 of file miscadmin.h.

Referenced by BackgroundWorkerInitializeConnection(), and BackgroundWorkerInitializeConnectionByOid().

#define IsNormalProcessingMode ( ) (Mode == NormalProcessing)

Definition at line 370 of file miscadmin.h.

Referenced by heap_create(), heap_create_with_catalog(), index_constraint_create(), and index_create().

#define MAXTZLEN 10 /* max TZ name len, not counting tr. null */

Definition at line 238 of file miscadmin.h.

Referenced by abstime2tm(), and EncodeDateTime().

#define RESUME_CANCEL_INTERRUPTS ( )

Value:

do { \
	Assert(QueryCancelHoldoffCount > 0); \
	QueryCancelHoldoffCount--; \
} while(0)

Definition at line 125 of file miscadmin.h.

Referenced by CopyGetData(), and SocketBackend().

#define RESUME_INTERRUPTS ( )

Value:

do { \
	Assert(InterruptHoldoffCount > 0); \
	InterruptHoldoffCount--; \
} while(0)

Definition at line 117 of file miscadmin.h.

Referenced by AbortSubTransaction(), AbortTransaction(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), CommitTransaction(), DestroyParallelContext(), do_autovacuum(), handle_sig_alarm(), HandleParallelMessages(), LockErrorCleanup(), LWLockAcquireOrWait(), LWLockConditionalAcquire(), LWLockRelease(), LWLockWaitForVar(), perform_work_item(), PostgresMain(), PrepareTransaction(), and WalWriterMain().

#define SECURITY_LOCAL_USERID_CHANGE 0x0001

Definition at line 294 of file miscadmin.h.

Referenced by CreateSchemaCommand(), ExecRefreshMatView(), fmgr_security_definer(), InLocalUserIdChange(), refresh_by_match_merge(), ri_PerformCheck(), ri_PlanCheck(), and SetUserIdAndContext().

#define SECURITY_NOFORCE_RLS 0x0004

Definition at line 296 of file miscadmin.h.

Referenced by InNoForceRLSOperation(), ri_PerformCheck(), and ri_PlanCheck().

#define SECURITY_RESTRICTED_OPERATION 0x0002

Definition at line 295 of file miscadmin.h.

Referenced by do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), index_build(), InSecurityRestrictedOperation(), refresh_by_match_merge(), vacuum_rel(), and validate_index().

#define SetProcessingMode ( mode )

Value:

do { \
		AssertArg((mode) == BootstrapProcessing || \
                  (mode) == InitProcessing || \
                  (mode) == NormalProcessing); \
		Mode = (mode); \
    } while(0)

Definition at line 374 of file miscadmin.h.

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), AuxiliaryProcessMain(), BackgroundWorkerInitializeConnection(), BackgroundWorkerInitializeConnectionByOid(), PostgresMain(), and StartBackgroundWorker().

#define START_CRIT_SECTION ( ) (CritSectionCount++)

Definition at line 131 of file miscadmin.h.

Referenced by _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_newroot(), _bt_split(), _bt_unlink_halfdead_page(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_freeovflpage(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), AbsorbFsyncRequests(), addLeafTuple(), brin_doinsert(), brin_doupdate(), brin_initialize_empty_new_buffer(), brinbuildempty(), brinRevmapDesummarizeRange(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), createPostingTree(), CreateSlotOnDisk(), do_setval(), doPickSplit(), EndPrepare(), fill_seq_with_data(), FreeSpaceMapTruncateRel(), GenericXLogFinish(), GetNewMultiXactId(), ginbuild(), ginbuildempty(), ginbulkdelete(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginUpdateStats(), ginVacuumPostingTreeLeaf(), gistbuild(), gistbuildempty(), gistbulkdelete(), gistplacetopage(), gistvacuumpage(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_finish_speculative(), heap_inplace_update(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_page_prune(), heap_update(), lazy_scan_heap(), lazy_vacuum_page(), moveLeafs(), nextval_internal(), PostPrepare_Locks(), RecordTransactionAbort(), RecordTransactionAbortPrepared(), RecordTransactionCommit(), RecordTransactionCommitPrepared(), ReplicationSlotDropPtr(), RestoreSlotFromDisk(), revmap_physical_extend(), SaveSlotToPath(), shiftList(), SlruPhysicalWritePage(), spgAddNodeAction(), spgbuild(), spgSplitNodeAction(), TruncateMultiXact(), UpdateFullPageWrites(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), visibilitymap_set(), visibilitymap_truncate(), write_relmap_file(), writeListPage(), XLogBackgroundFlush(), XLogFlush(), and XLogInsertRecord().

#define USE_GERMAN_DATES 3

Definition at line 213 of file miscadmin.h.

Referenced by check_datestyle(), EncodeDateOnly(), and EncodeDateTime().

#define USE_ISO_DATES 1

Definition at line 211 of file miscadmin.h.

Referenced by check_datestyle(), EncodeDateOnly(), EncodeDateTime(), set_transmission_modes(), and timestamptz_to_str().

#define USE_POSTGRES_DATES 0

Definition at line 210 of file miscadmin.h.

Referenced by check_datestyle(), EncodeDateOnly(), and EncodeDateTime().

#define USE_SQL_DATES 2

Definition at line 212 of file miscadmin.h.

Referenced by check_datestyle(), EncodeDateOnly(), and EncodeDateTime().

#define USE_XSD_DATES 4

Definition at line 214 of file miscadmin.h.

Referenced by datum_to_json(), datum_to_jsonb(), EncodeDateOnly(), EncodeDateTime(), EncodeTimezone(), and map_sql_value_to_xml_value().

Typedef Documentation

typedef char* pg_stack_base_t

Definition at line 269 of file miscadmin.h.

typedef enum ProcessingMode ProcessingMode

Enumeration Type Documentation

enum AuxProcType

Enumerator
NotAnAuxProcess
CheckerProcess
BootstrapProcess
StartupProcess
BgWriterProcess
CheckpointerProcess
WalWriterProcess
WalReceiverProcess
NUM_AUXPROCTYPES

Definition at line 389 of file miscadmin.h.

 {
     NotAnAuxProcess = -1,
     CheckerProcess = 0,
     BootstrapProcess,
     StartupProcess,
     BgWriterProcess,
     CheckpointerProcess,
     WalWriterProcess,
     WalReceiverProcess,
 
     NUM_AUXPROCTYPES            /* Must be last! */
 } AuxProcType;

enum ProcessingMode

Enumerator
BootstrapProcessing
InitProcessing
NormalProcessing

Definition at line 359 of file miscadmin.h.

 {
     BootstrapProcessing,        /* bootstrap creation of template database */
     InitProcessing,             /* initializing system */
     NormalProcessing            /* normal processing */
 } ProcessingMode;

Function Documentation

void AddToDataDirLockFile	(	int	target_line,
		const char *	str
	)

Definition at line 1158 of file miscinit.c.

References close, DIRECTORY_LOCK_FILE, ereport, errcode_for_file_access(), errmsg(), fd(), LOG, NULL, PG_BINARY, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), read, snprintf(), WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE, and write.

Referenced by InternalIpcMemoryCreate(), pmdie(), PostmasterMain(), reaper(), and sigusr1_handler().

 {
     int         fd;
     int         len;
     int         lineno;
     char       *srcptr;
     char       *destptr;
     char        srcbuffer[BLCKSZ];
     char        destbuffer[BLCKSZ];
 
     fd = open(DIRECTORY_LOCK_FILE, O_RDWR | PG_BINARY, 0);
     if (fd < 0)
     {
         ereport(LOG,
                 (errcode_for_file_access(),
                  errmsg("could not open file \"%s\": %m",
                         DIRECTORY_LOCK_FILE)));
         return;
     }
     pgstat_report_wait_start(WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ);
     len = read(fd, srcbuffer, sizeof(srcbuffer) - 1);
     pgstat_report_wait_end();
     if (len < 0)
     {
         ereport(LOG,
                 (errcode_for_file_access(),
                  errmsg("could not read from file \"%s\": %m",
                         DIRECTORY_LOCK_FILE)));
         close(fd);
         return;
     }
     srcbuffer[len] = '\0';
 
     /*
      * Advance over lines we are not supposed to rewrite, then copy them to
      * destbuffer.
      */
     srcptr = srcbuffer;
     for (lineno = 1; lineno < target_line; lineno++)
     {
         char       *eol = strchr(srcptr, '\n');
 
         if (eol == NULL)
             break;              /* not enough lines in file yet */
         srcptr = eol + 1;
     }
     memcpy(destbuffer, srcbuffer, srcptr - srcbuffer);
     destptr = destbuffer + (srcptr - srcbuffer);
 
     /*
      * Fill in any missing lines before the target line, in case lines are
      * added to the file out of order.
      */
     for (; lineno < target_line; lineno++)
     {
         if (destptr < destbuffer + sizeof(destbuffer))
             *destptr++ = '\n';
     }
 
     /*
      * Write or rewrite the target line.
      */
     snprintf(destptr, destbuffer + sizeof(destbuffer) - destptr, "%s\n", str);
     destptr += strlen(destptr);
 
     /*
      * If there are more lines in the old file, append them to destbuffer.
      */
     if ((srcptr = strchr(srcptr, '\n')) != NULL)
     {
         srcptr++;
         snprintf(destptr, destbuffer + sizeof(destbuffer) - destptr, "%s",
                  srcptr);
     }
 
     /*
      * And rewrite the data.  Since we write in a single kernel call, this
      * update should appear atomic to onlookers.
      */
     len = strlen(destbuffer);
     errno = 0;
     pgstat_report_wait_start(WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE);
     if (lseek(fd, (off_t) 0, SEEK_SET) != 0 ||
         (int) write(fd, destbuffer, len) != len)
     {
         pgstat_report_wait_end();
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         ereport(LOG,
                 (errcode_for_file_access(),
                  errmsg("could not write to file \"%s\": %m",
                         DIRECTORY_LOCK_FILE)));
         close(fd);
         return;
     }
     pgstat_report_wait_end();
     pgstat_report_wait_start(WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC);
     if (pg_fsync(fd) != 0)
     {
         ereport(LOG,
                 (errcode_for_file_access(),
                  errmsg("could not write to file \"%s\": %m",
                         DIRECTORY_LOCK_FILE)));
     }
     pgstat_report_wait_end();
     if (close(fd) != 0)
     {
         ereport(LOG,
                 (errcode_for_file_access(),
                  errmsg("could not write to file \"%s\": %m",
                         DIRECTORY_LOCK_FILE)));
     }
 }

bool BackupInProgress ( void )

Definition at line 11354 of file xlog.c.

References BACKUP_LABEL_FILE.

Referenced by pg_is_in_backup(), and PostmasterStateMachine().

 {
     struct stat stat_buf;
 
     return (stat(BACKUP_LABEL_FILE, &stat_buf) == 0);
 }

void BaseInit ( void )

Definition at line 517 of file postinit.c.

References DebugFileOpen(), InitBufferPoolAccess(), InitCommunication(), InitFileAccess(), and smgrinit().

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), AuxiliaryProcessMain(), PostgresMain(), and StartBackgroundWorker().

 {
     /*
      * Attach to shared memory and semaphores, and initialize our
      * input/output/debugging file descriptors.
      */
     InitCommunication();
     DebugFileOpen();
 
     /* Do local initialization of file, storage and buffer managers */
     InitFileAccess();
     smgrinit();
     InitBufferPoolAccess();
 }

void CancelBackup ( void )

Definition at line 11374 of file xlog.c.

References BACKUP_LABEL_FILE, BACKUP_LABEL_OLD, DEBUG1, durable_rename(), ereport, errcode_for_file_access(), errdetail(), errmsg(), LOG, TABLESPACE_MAP, TABLESPACE_MAP_OLD, unlink(), and WARNING.

Referenced by PostmasterStateMachine().

 {
     struct stat stat_buf;
 
     /* if the backup_label file is not there, return */
     if (stat(BACKUP_LABEL_FILE, &stat_buf) < 0)
         return;
 
     /* remove leftover file from previously canceled backup if it exists */
     unlink(BACKUP_LABEL_OLD);
 
     if (durable_rename(BACKUP_LABEL_FILE, BACKUP_LABEL_OLD, DEBUG1) != 0)
     {
         ereport(WARNING,
                 (errcode_for_file_access(),
                  errmsg("online backup mode was not canceled"),
                  errdetail("File \"%s\" could not be renamed to \"%s\": %m.",
                            BACKUP_LABEL_FILE, BACKUP_LABEL_OLD)));
         return;
     }
 
     /* if the tablespace_map file is not there, return */
     if (stat(TABLESPACE_MAP, &stat_buf) < 0)
     {
         ereport(LOG,
                 (errmsg("online backup mode canceled"),
                  errdetail("File \"%s\" was renamed to \"%s\".",
                            BACKUP_LABEL_FILE, BACKUP_LABEL_OLD)));
         return;
     }
 
     /* remove leftover file from previously canceled backup if it exists */
     unlink(TABLESPACE_MAP_OLD);
 
     if (durable_rename(TABLESPACE_MAP, TABLESPACE_MAP_OLD, DEBUG1) == 0)
     {
         ereport(LOG,
                 (errmsg("online backup mode canceled"),
                  errdetail("Files \"%s\" and \"%s\" were renamed to "
                            "\"%s\" and \"%s\", respectively.",
                            BACKUP_LABEL_FILE, TABLESPACE_MAP,
                            BACKUP_LABEL_OLD, TABLESPACE_MAP_OLD)));
     }
     else
     {
         ereport(WARNING,
                 (errcode_for_file_access(),
                  errmsg("online backup mode canceled"),
                  errdetail("File \"%s\" was renamed to \"%s\", but "
                            "file \"%s\" could not be renamed to \"%s\": %m.",
                            BACKUP_LABEL_FILE, BACKUP_LABEL_OLD,
                            TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
     }
 }

void ChangeToDataDir ( void )

Definition at line 116 of file miscinit.c.

References AssertState, DataDir, ereport, errcode_for_file_access(), errmsg(), and FATAL.

Referenced by AuxiliaryProcessMain(), PostgresMain(), and PostmasterMain().

 {
     AssertState(DataDir);
 
     if (chdir(DataDir) < 0)
         ereport(FATAL,
                 (errcode_for_file_access(),
                  errmsg("could not change directory to \"%s\": %m",
                         DataDir)));
 }

void check_stack_depth ( void )

Definition at line 3117 of file postgres.c.

References ereport, errcode(), errhint(), errmsg(), ERROR, max_stack_depth, and stack_is_too_deep().

Referenced by BuildTupleRemapInfo(), clean_NOT_intree(), clean_stopword_intree(), cntsize(), contains_required_value(), convertJsonbValue(), copyObjectImpl(), Cover(), datum_to_json(), datum_to_jsonb(), dofindsubquery(), EventTriggerInvoke(), ExecEndNode(), ExecEvalAlternativeSubPlan(), ExecEvalSubPlan(), ExecInitExprRec(), ExecInitNode(), ExecMakeFunctionResultSet(), ExecProcNodeFirst(), ExecShutdownNode(), execute(), expression_tree_mutator(), expression_tree_walker(), fillQT(), find_composite_type_dependencies(), findoprnd(), findoprnd_recurse(), flatten_grouping_sets(), FreePageManagerDumpBtree(), freetree(), generate_partition_qual(), get_query_def(), get_rels_with_domain(), get_rule_expr(), get_setop_query(), gistSplit(), hash_range(), hk_depth_search(), infix(), inline_set_returning_function(), int_query_opr_selec(), JsonbDeepContains(), JumbleExpr(), ltree_execute(), makepol(), maketree(), MatchText(), MultiExecProcNode(), parse_array(), parse_object(), plainnode(), plperl_hash_from_tuple(), plperl_sv_to_datum(), populate_array_dim_jsonb(), populate_record_field(), QT2QTN(), QTNBinary(), QTNClearFlags(), QTNCopy(), QTNFree(), QTNodeCompare(), QTNSort(), QTNTernary(), range_cmp(), range_in(), range_out(), range_recv(), range_send(), raw_expression_tree_walker(), record_cmp(), record_eq(), record_in(), record_out(), record_recv(), record_send(), setPath(), split_array(), TQExamine(), TQRemap(), transformExprRecurse(), transformSetOperationTree(), traverse_lacons(), TS_execute(), TS_execute_ternary(), TS_phrase_execute(), tsquery_opr_selec(), and tsquery_requires_match().

 {
     if (stack_is_too_deep())
     {
         ereport(ERROR,
                 (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
                  errmsg("stack depth limit exceeded"),
                  errhint("Increase the configuration parameter \"max_stack_depth\" (currently %dkB), "
                          "after ensuring the platform's stack depth limit is adequate.",
                          max_stack_depth)));
     }
 }

void CreateDataDirLockFile ( bool amPostmaster )

Definition at line 1081 of file miscinit.c.

References CreateLockFile(), DataDir, and DIRECTORY_LOCK_FILE.

Referenced by AuxiliaryProcessMain(), PostgresMain(), and PostmasterMain().

 {
     CreateLockFile(DIRECTORY_LOCK_FILE, amPostmaster, "", true, DataDir);
 }

void CreateSocketLockFile	(	const char *	socketfile,
		bool	amPostmaster,
		const char *	socketDir
	)

Definition at line 1090 of file miscinit.c.

References CreateLockFile(), MAXPGPATH, and snprintf().

 {
     char        lockfile[MAXPGPATH];
 
     snprintf(lockfile, sizeof(lockfile), "%s.lock", socketfile);
     CreateLockFile(lockfile, amPostmaster, socketDir, false, socketfile);
 }

Oid GetAuthenticatedUserId ( void )

Definition at line 343 of file miscinit.c.

References AssertState, AuthenticatedUserId, and OidIsValid.

Referenced by InitializeParallelDSM().

 {
     AssertState(OidIsValid(AuthenticatedUserId));
     return AuthenticatedUserId;
 }

Oid GetCurrentRoleId ( void )

Definition at line 636 of file miscinit.c.

References InvalidOid, OuterUserId, and SetRoleIsActive.

Referenced by show_role().

 {
     if (SetRoleIsActive)
         return OuterUserId;
     else
         return InvalidOid;
 }

Oid GetOuterUserId ( void )

Definition at line 295 of file miscinit.c.

References AssertState, OidIsValid, and OuterUserId.

Referenced by DropRole(), and RenameRole().

 {
     AssertState(OidIsValid(OuterUserId));
     return OuterUserId;
 }

Oid GetSessionUserId ( void )

Definition at line 318 of file miscinit.c.

References AssertState, OidIsValid, and SessionUserId.

Referenced by check_role(), DropRole(), get_rolespec_oid(), get_rolespec_tuple(), InitPostgres(), is_admin_of_role(), pgstat_bestart(), RenameRole(), and session_user().

 {
     AssertState(OidIsValid(SessionUserId));
     return SessionUserId;
 }

Oid GetUserId ( void )

Definition at line 284 of file miscinit.c.

References AssertState, CurrentUserId, and OidIsValid.

 {
     AssertState(OidIsValid(CurrentUserId));
     return CurrentUserId;
 }

void GetUserIdAndContext	(	Oid *	userid,
		bool *	sec_def_context
	)

Definition at line 438 of file miscinit.c.

References CurrentUserId, and InLocalUserIdChange().

 {
     *userid = CurrentUserId;
     *sec_def_context = InLocalUserIdChange();
 }

void GetUserIdAndSecContext	(	Oid *	userid,
		int *	sec_context
	)

Definition at line 389 of file miscinit.c.

References CurrentUserId, and SecurityRestrictionContext.

Referenced by CreateSchemaCommand(), do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), fmgr_security_definer(), index_build(), InitializeParallelDSM(), PushTransaction(), ri_PerformCheck(), ri_PlanCheck(), StartTransaction(), vacuum_rel(), and validate_index().

 {
     *userid = CurrentUserId;
     *sec_context = SecurityRestrictionContext;
 }

char* GetUserNameFromId	(	Oid	roleid,
		bool	noerr
	)

Definition at line 692 of file miscinit.c.

References AUTHOID, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, NameStr, NULL, ObjectIdGetDatum, pstrdup(), ReleaseSysCache(), result, and SearchSysCache1.

Referenced by check_is_member_of_role(), current_user(), getObjectDescription(), getObjectIdentityParts(), insert_username(), regroleout(), RemoveRoleFromObjectPolicy(), session_user(), and timetravel().

 {
     HeapTuple   tuple;
     char       *result;
 
     tuple = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
     if (!HeapTupleIsValid(tuple))
     {
         if (!noerr)
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("invalid role OID: %u", roleid)));
         result = NULL;
     }
     else
     {
         result = pstrdup(NameStr(((Form_pg_authid) GETSTRUCT(tuple))->rolname));
         ReleaseSysCache(tuple);
     }
     return result;
 }

bool has_rolreplication ( Oid roleid )

Definition at line 465 of file miscinit.c.

References AUTHOID, GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum, ReleaseSysCache(), result, and SearchSysCache1.

Referenced by check_permissions(), and InitPostgres().

 {
     bool        result = false;
     HeapTuple   utup;
 
     utup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
     if (HeapTupleIsValid(utup))
     {
         result = ((Form_pg_authid) GETSTRUCT(utup))->rolreplication;
         ReleaseSysCache(utup);
     }
     return result;
 }

void InitializeMaxBackends ( void )

Definition at line 495 of file postinit.c.

References Assert, autovacuum_max_workers, elog, ERROR, MAX_BACKENDS, max_worker_processes, MaxBackends, and MaxConnections.

Referenced by AuxiliaryProcessMain(), PostgresMain(), and PostmasterMain().

 {
     Assert(MaxBackends == 0);
 
     /* the extra unit accounts for the autovacuum launcher */
     MaxBackends = MaxConnections + autovacuum_max_workers + 1 +
         max_worker_processes;
 
     /* internal error because the values were all checked previously */
     if (MaxBackends > MAX_BACKENDS)
         elog(ERROR, "too many backends configured");
 }

void InitializeSessionUserId	(	const char *	rolename,
		Oid	useroid
	)

Definition at line 483 of file miscinit.c.

References AssertState, AuthenticatedUserId, AuthenticatedUserIsSuperuser, AUTHNAME, AUTHOID, CountUserBackends(), ereport, errcode(), errmsg(), FATAL, GETSTRUCT, HeapTupleGetOid, HeapTupleIsValid, IsBootstrapProcessingMode, IsUnderPostmaster, MyProc, NameStr, NULL, ObjectIdGetDatum, OidIsValid, PGC_BACKEND, PGC_INTERNAL, PGC_S_OVERRIDE, PointerGetDatum, ReleaseSysCache(), PGPROC::roleId, SearchSysCache1, SetConfigOption(), and SetSessionUserId().

Referenced by InitPostgres().

 {
     HeapTuple   roleTup;
     Form_pg_authid rform;
     char       *rname;
 
     /*
      * Don't do scans if we're bootstrapping, none of the system catalogs
      * exist yet, and they should be owned by postgres anyway.
      */
     AssertState(!IsBootstrapProcessingMode());
 
     /* call only once */
     AssertState(!OidIsValid(AuthenticatedUserId));
 
     if (rolename != NULL)
     {
         roleTup = SearchSysCache1(AUTHNAME, PointerGetDatum(rolename));
         if (!HeapTupleIsValid(roleTup))
             ereport(FATAL,
                     (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
                      errmsg("role \"%s\" does not exist", rolename)));
     }
     else
     {
         roleTup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
         if (!HeapTupleIsValid(roleTup))
             ereport(FATAL,
                     (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
                      errmsg("role with OID %u does not exist", roleid)));
     }
 
     rform = (Form_pg_authid) GETSTRUCT(roleTup);
     roleid = HeapTupleGetOid(roleTup);
     rname = NameStr(rform->rolname);
 
     AuthenticatedUserId = roleid;
     AuthenticatedUserIsSuperuser = rform->rolsuper;
 
     /* This sets OuterUserId/CurrentUserId too */
     SetSessionUserId(roleid, AuthenticatedUserIsSuperuser);
 
     /* Also mark our PGPROC entry with the authenticated user id */
     /* (We assume this is an atomic store so no lock is needed) */
     MyProc->roleId = roleid;
 
     /*
      * These next checks are not enforced when in standalone mode, so that
      * there is a way to recover from sillinesses like "UPDATE pg_authid SET
      * rolcanlogin = false;".
      */
     if (IsUnderPostmaster)
     {
         /*
          * Is role allowed to login at all?
          */
         if (!rform->rolcanlogin)
             ereport(FATAL,
                     (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
                      errmsg("role \"%s\" is not permitted to log in",
                             rname)));
 
         /*
          * Check connection limit for this role.
          *
          * There is a race condition here --- we create our PGPROC before
          * checking for other PGPROCs.  If two backends did this at about the
          * same time, they might both think they were over the limit, while
          * ideally one should succeed and one fail.  Getting that to work
          * exactly seems more trouble than it is worth, however; instead we
          * just document that the connection limit is approximate.
          */
         if (rform->rolconnlimit >= 0 &&
             !AuthenticatedUserIsSuperuser &&
             CountUserBackends(roleid) > rform->rolconnlimit)
             ereport(FATAL,
                     (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
                      errmsg("too many connections for role \"%s\"",
                             rname)));
     }
 
     /* Record username and superuser status as GUC settings too */
     SetConfigOption("session_authorization", rname,
                     PGC_BACKEND, PGC_S_OVERRIDE);
     SetConfigOption("is_superuser",
                     AuthenticatedUserIsSuperuser ? "on" : "off",
                     PGC_INTERNAL, PGC_S_OVERRIDE);
 
     ReleaseSysCache(roleTup);
 }

void InitializeSessionUserIdStandalone ( void )

Definition at line 579 of file miscinit.c.

References AssertState, AuthenticatedUserId, AuthenticatedUserIsSuperuser, BOOTSTRAP_SUPERUSERID, IsAutoVacuumWorkerProcess(), IsBackgroundWorker, IsUnderPostmaster, OidIsValid, and SetSessionUserId().

Referenced by InitPostgres().

 {
     /*
      * This function should only be called in single-user mode, in autovacuum
      * workers, and in background workers.
      */
     AssertState(!IsUnderPostmaster || IsAutoVacuumWorkerProcess() || IsBackgroundWorker);
 
     /* call only once */
     AssertState(!OidIsValid(AuthenticatedUserId));
 
     AuthenticatedUserId = BOOTSTRAP_SUPERUSERID;
     AuthenticatedUserIsSuperuser = true;
 
     SetSessionUserId(BOOTSTRAP_SUPERUSERID, true);
 }

void InitPostgres	(	const char *	in_dbname,
		Oid	dboid,
		const char *	username,
		Oid	useroid,
		char *	out_dbname
	)

Definition at line 558 of file postinit.c.

References am_db_walsender, am_walsender, Assert, before_shmem_exit(), CAC_WAITBACKUP, Port::canAcceptConnections, CheckDeadLockAlert(), CheckMyDatabase(), CommitTransactionCommand(), PGPROC::databaseId, DatabaseRelationId, dbname, DEADLOCK_TIMEOUT, DEBUG3, DEFAULTTABLESPACE_OID, elog, EnablePortalManager(), ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), FATAL, GetDatabasePath(), GetDatabaseTuple(), GetDatabaseTupleByOid(), GetSessionUserId(), GETSTRUCT, GetTransactionSnapshot(), GetUserId(), has_rolreplication(), HaveNFreeProcs(), HeapTupleGetOid, HeapTupleIsValid, IDLE_IN_TRANSACTION_SESSION_TIMEOUT, IdleInTransactionSessionTimeoutHandler(), InitBufferPoolBackend(), InitCatalogCache(), initialize_acl(), InitializeClientEncoding(), InitializeSearchPath(), InitializeSessionUserId(), InitializeSessionUserIdStandalone(), InitPlanCache(), InitProcessPhase2(), InvalidateCatalogSnapshot(), InvalidBackendId, IsAutoVacuumLauncherProcess(), IsAutoVacuumWorkerProcess(), IsBackgroundWorker, IsBinaryUpgrade, IsBootstrapProcessingMode, IsUnderPostmaster, LOCK_TIMEOUT, LockSharedObject(), LockTimeoutHandler(), MaxBackends, MyBackendId, MyDatabaseId, MyDatabaseTableSpace, MyProc, MyProcPort, NAMEDATALEN, NameStr, NULL, OidIsValid, on_shmem_exit(), PerformAuthentication(), pg_usleep(), pgstat_bestart(), pgstat_initialize(), PostAuthDelay, process_settings(), process_startup_options(), ProcSignalInit(), RecoveryInProgress(), RegisterTimeout(), RelationCacheInitialize(), RelationCacheInitializePhase2(), RelationCacheInitializePhase3(), ReservedBackends, RowExclusiveLock, SetCurrentStatementStartTimestamp(), SetDatabasePath(), SharedInvalBackendInit(), ShutdownPostgres(), ShutdownXLOG(), StartTransactionCommand(), StartupXLOG(), STATEMENT_TIMEOUT, StatementTimeoutHandler(), strlcpy(), superuser(), TemplateDbOid, ThereIsAtLeastOneRole(), ValidatePgVersion(), WARNING, XACT_READ_COMMITTED, and XactIsoLevel.

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), BackgroundWorkerInitializeConnection(), BackgroundWorkerInitializeConnectionByOid(), BootstrapModeMain(), and PostgresMain().

 {
     bool        bootstrap = IsBootstrapProcessingMode();
     bool        am_superuser;
     char       *fullpath;
     char        dbname[NAMEDATALEN];
 
     elog(DEBUG3, "InitPostgres");
 
     /*
      * Add my PGPROC struct to the ProcArray.
      *
      * Once I have done this, I am visible to other backends!
      */
     InitProcessPhase2();
 
     /*
      * Initialize my entry in the shared-invalidation manager's array of
      * per-backend data.
      *
      * Sets up MyBackendId, a unique backend identifier.
      */
     MyBackendId = InvalidBackendId;
 
     SharedInvalBackendInit(false);
 
     if (MyBackendId > MaxBackends || MyBackendId <= 0)
         elog(FATAL, "bad backend ID: %d", MyBackendId);
 
     /* Now that we have a BackendId, we can participate in ProcSignal */
     ProcSignalInit(MyBackendId);
 
     /*
      * Also set up timeout handlers needed for backend operation.  We need
      * these in every case except bootstrap.
      */
     if (!bootstrap)
     {
         RegisterTimeout(DEADLOCK_TIMEOUT, CheckDeadLockAlert);
         RegisterTimeout(STATEMENT_TIMEOUT, StatementTimeoutHandler);
         RegisterTimeout(LOCK_TIMEOUT, LockTimeoutHandler);
         RegisterTimeout(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
                         IdleInTransactionSessionTimeoutHandler);
     }
 
     /*
      * bufmgr needs another initialization call too
      */
     InitBufferPoolBackend();
 
     /*
      * Initialize local process's access to XLOG.
      */
     if (IsUnderPostmaster)
     {
         /*
          * The postmaster already started the XLOG machinery, but we need to
          * call InitXLOGAccess(), if the system isn't in hot-standby mode.
          * This is handled by calling RecoveryInProgress and ignoring the
          * result.
          */
         (void) RecoveryInProgress();
     }
     else
     {
         /*
          * We are either a bootstrap process or a standalone backend. Either
          * way, start up the XLOG machinery, and register to have it closed
          * down at exit.
          */
         StartupXLOG();
         on_shmem_exit(ShutdownXLOG, 0);
     }
 
     /*
      * Initialize the relation cache and the system catalog caches.  Note that
      * no catalog access happens here; we only set up the hashtable structure.
      * We must do this before starting a transaction because transaction abort
      * would try to touch these hashtables.
      */
     RelationCacheInitialize();
     InitCatalogCache();
     InitPlanCache();
 
     /* Initialize portal manager */
     EnablePortalManager();
 
     /* Initialize stats collection --- must happen before first xact */
     if (!bootstrap)
         pgstat_initialize();
 
     /*
      * Load relcache entries for the shared system catalogs.  This must create
      * at least entries for pg_database and catalogs used for authentication.
      */
     RelationCacheInitializePhase2();
 
     /*
      * Set up process-exit callback to do pre-shutdown cleanup.  This is the
      * first before_shmem_exit callback we register; thus, this will be the
      * last thing we do before low-level modules like the buffer manager begin
      * to close down.  We need to have this in place before we begin our first
      * transaction --- if we fail during the initialization transaction, as is
      * entirely possible, we need the AbortTransaction call to clean up.
      */
     before_shmem_exit(ShutdownPostgres, 0);
 
     /* The autovacuum launcher is done here */
     if (IsAutoVacuumLauncherProcess())
     {
         /* report this backend in the PgBackendStatus array */
         pgstat_bestart();
 
         return;
     }
 
     /*
      * Start a new transaction here before first access to db, and get a
      * snapshot.  We don't have a use for the snapshot itself, but we're
      * interested in the secondary effect that it sets RecentGlobalXmin. (This
      * is critical for anything that reads heap pages, because HOT may decide
      * to prune them even if the process doesn't attempt to modify any
      * tuples.)
      */
     if (!bootstrap)
     {
         /* statement_timestamp must be set for timeouts to work correctly */
         SetCurrentStatementStartTimestamp();
         StartTransactionCommand();
 
         /*
          * transaction_isolation will have been set to the default by the
          * above.  If the default is "serializable", and we are in hot
          * standby, we will fail if we don't change it to something lower.
          * Fortunately, "read committed" is plenty good enough.
          */
         XactIsoLevel = XACT_READ_COMMITTED;
 
         (void) GetTransactionSnapshot();
     }
 
     /*
      * Perform client authentication if necessary, then figure out our
      * postgres user ID, and see if we are a superuser.
      *
      * In standalone mode and in autovacuum worker processes, we use a fixed
      * ID, otherwise we figure it out from the authenticated user name.
      */
     if (bootstrap || IsAutoVacuumWorkerProcess())
     {
         InitializeSessionUserIdStandalone();
         am_superuser = true;
     }
     else if (!IsUnderPostmaster)
     {
         InitializeSessionUserIdStandalone();
         am_superuser = true;
         if (!ThereIsAtLeastOneRole())
             ereport(WARNING,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("no roles are defined in this database system"),
                      errhint("You should immediately run CREATE USER \"%s\" SUPERUSER;.",
                              username != NULL ? username : "postgres")));
     }
     else if (IsBackgroundWorker)
     {
         if (username == NULL && !OidIsValid(useroid))
         {
             InitializeSessionUserIdStandalone();
             am_superuser = true;
         }
         else
         {
             InitializeSessionUserId(username, useroid);
             am_superuser = superuser();
         }
     }
     else
     {
         /* normal multiuser case */
         Assert(MyProcPort != NULL);
         PerformAuthentication(MyProcPort);
         InitializeSessionUserId(username, useroid);
         am_superuser = superuser();
     }
 
     /*
      * If we're trying to shut down, only superusers can connect, and new
      * replication connections are not allowed.
      */
     if ((!am_superuser || am_walsender) &&
         MyProcPort != NULL &&
         MyProcPort->canAcceptConnections == CAC_WAITBACKUP)
     {
         if (am_walsender)
             ereport(FATAL,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("new replication connections are not allowed during database shutdown")));
         else
             ereport(FATAL,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("must be superuser to connect during database shutdown")));
     }
 
     /*
      * Binary upgrades only allowed super-user connections
      */
     if (IsBinaryUpgrade && !am_superuser)
     {
         ereport(FATAL,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser to connect in binary upgrade mode")));
     }
 
     /*
      * The last few connections slots are reserved for superusers. Although
      * replication connections currently require superuser privileges, we
      * don't allow them to consume the reserved slots, which are intended for
      * interactive use.
      */
     if ((!am_superuser || am_walsender) &&
         ReservedBackends > 0 &&
         !HaveNFreeProcs(ReservedBackends))
         ereport(FATAL,
                 (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
                  errmsg("remaining connection slots are reserved for non-replication superuser connections")));
 
     /* Check replication permissions needed for walsender processes. */
     if (am_walsender)
     {
         Assert(!bootstrap);
 
         if (!superuser() && !has_rolreplication(GetUserId()))
             ereport(FATAL,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("must be superuser or replication role to start walsender")));
     }
 
     /*
      * If this is a plain walsender only supporting physical replication, we
      * don't want to connect to any particular database. Just finish the
      * backend startup by processing any options from the startup packet, and
      * we're done.
      */
     if (am_walsender && !am_db_walsender)
     {
         /* process any options passed in the startup packet */
         if (MyProcPort != NULL)
             process_startup_options(MyProcPort, am_superuser);
 
         /* Apply PostAuthDelay as soon as we've read all options */
         if (PostAuthDelay > 0)
             pg_usleep(PostAuthDelay * 1000000L);
 
         /* initialize client encoding */
         InitializeClientEncoding();
 
         /* report this backend in the PgBackendStatus array */
         pgstat_bestart();
 
         /* close the transaction we started above */
         CommitTransactionCommand();
 
         return;
     }
 
     /*
      * Set up the global variables holding database id and default tablespace.
      * But note we won't actually try to touch the database just yet.
      *
      * We take a shortcut in the bootstrap case, otherwise we have to look up
      * the db's entry in pg_database.
      */
     if (bootstrap)
     {
         MyDatabaseId = TemplateDbOid;
         MyDatabaseTableSpace = DEFAULTTABLESPACE_OID;
     }
     else if (in_dbname != NULL)
     {
         HeapTuple   tuple;
         Form_pg_database dbform;
 
         tuple = GetDatabaseTuple(in_dbname);
         if (!HeapTupleIsValid(tuple))
             ereport(FATAL,
                     (errcode(ERRCODE_UNDEFINED_DATABASE),
                      errmsg("database \"%s\" does not exist", in_dbname)));
         dbform = (Form_pg_database) GETSTRUCT(tuple);
         MyDatabaseId = HeapTupleGetOid(tuple);
         MyDatabaseTableSpace = dbform->dattablespace;
         /* take database name from the caller, just for paranoia */
         strlcpy(dbname, in_dbname, sizeof(dbname));
     }
     else if (OidIsValid(dboid))
     {
         /* caller specified database by OID */
         HeapTuple   tuple;
         Form_pg_database dbform;
 
         tuple = GetDatabaseTupleByOid(dboid);
         if (!HeapTupleIsValid(tuple))
             ereport(FATAL,
                     (errcode(ERRCODE_UNDEFINED_DATABASE),
                      errmsg("database %u does not exist", dboid)));
         dbform = (Form_pg_database) GETSTRUCT(tuple);
         MyDatabaseId = HeapTupleGetOid(tuple);
         MyDatabaseTableSpace = dbform->dattablespace;
         Assert(MyDatabaseId == dboid);
         strlcpy(dbname, NameStr(dbform->datname), sizeof(dbname));
         /* pass the database name back to the caller */
         if (out_dbname)
             strcpy(out_dbname, dbname);
     }
     else
     {
         /*
          * If this is a background worker not bound to any particular
          * database, we're done now.  Everything that follows only makes sense
          * if we are bound to a specific database.  We do need to close the
          * transaction we started before returning.
          */
         if (!bootstrap)
         {
             pgstat_bestart();
             CommitTransactionCommand();
         }
         return;
     }
 
     /*
      * Now, take a writer's lock on the database we are trying to connect to.
      * If there is a concurrently running DROP DATABASE on that database, this
      * will block us until it finishes (and has committed its update of
      * pg_database).
      *
      * Note that the lock is not held long, only until the end of this startup
      * transaction.  This is OK since we will advertise our use of the
      * database in the ProcArray before dropping the lock (in fact, that's the
      * next thing to do).  Anyone trying a DROP DATABASE after this point will
      * see us in the array once they have the lock.  Ordering is important for
      * this because we don't want to advertise ourselves as being in this
      * database until we have the lock; otherwise we create what amounts to a
      * deadlock with CountOtherDBBackends().
      *
      * Note: use of RowExclusiveLock here is reasonable because we envision
      * our session as being a concurrent writer of the database.  If we had a
      * way of declaring a session as being guaranteed-read-only, we could use
      * AccessShareLock for such sessions and thereby not conflict against
      * CREATE DATABASE.
      */
     if (!bootstrap)
         LockSharedObject(DatabaseRelationId, MyDatabaseId, 0,
                          RowExclusiveLock);
 
     /*
      * Now we can mark our PGPROC entry with the database ID.
      *
      * We assume this is an atomic store so no lock is needed; though actually
      * things would work fine even if it weren't atomic.  Anyone searching the
      * ProcArray for this database's ID should hold the database lock, so they
      * would not be executing concurrently with this store.  A process looking
      * for another database's ID could in theory see a chance match if it read
      * a partially-updated databaseId value; but as long as all such searches
      * wait and retry, as in CountOtherDBBackends(), they will certainly see
      * the correct value on their next try.
      */
     MyProc->databaseId = MyDatabaseId;
 
     /*
      * We established a catalog snapshot while reading pg_authid and/or
      * pg_database; but until we have set up MyDatabaseId, we won't react to
      * incoming sinval messages for unshared catalogs, so we won't realize it
      * if the snapshot has been invalidated.  Assume it's no good anymore.
      */
     InvalidateCatalogSnapshot();
 
     /*
      * Recheck pg_database to make sure the target database hasn't gone away.
      * If there was a concurrent DROP DATABASE, this ensures we will die
      * cleanly without creating a mess.
      */
     if (!bootstrap)
     {
         HeapTuple   tuple;
 
         tuple = GetDatabaseTuple(dbname);
         if (!HeapTupleIsValid(tuple) ||
             MyDatabaseId != HeapTupleGetOid(tuple) ||
             MyDatabaseTableSpace != ((Form_pg_database) GETSTRUCT(tuple))->dattablespace)
             ereport(FATAL,
                     (errcode(ERRCODE_UNDEFINED_DATABASE),
                      errmsg("database \"%s\" does not exist", dbname),
                      errdetail("It seems to have just been dropped or renamed.")));
     }
 
     /*
      * Now we should be able to access the database directory safely. Verify
      * it's there and looks reasonable.
      */
     fullpath = GetDatabasePath(MyDatabaseId, MyDatabaseTableSpace);
 
     if (!bootstrap)
     {
         if (access(fullpath, F_OK) == -1)
         {
             if (errno == ENOENT)
                 ereport(FATAL,
                         (errcode(ERRCODE_UNDEFINED_DATABASE),
                          errmsg("database \"%s\" does not exist",
                                 dbname),
                          errdetail("The database subdirectory \"%s\" is missing.",
                                    fullpath)));
             else
                 ereport(FATAL,
                         (errcode_for_file_access(),
                          errmsg("could not access directory \"%s\": %m",
                                 fullpath)));
         }
 
         ValidatePgVersion(fullpath);
     }
 
     SetDatabasePath(fullpath);
 
     /*
      * It's now possible to do real access to the system catalogs.
      *
      * Load relcache entries for the system catalogs.  This must create at
      * least the minimum set of "nailed-in" cache entries.
      */
     RelationCacheInitializePhase3();
 
     /* set up ACL framework (so CheckMyDatabase can check permissions) */
     initialize_acl();
 
     /*
      * Re-read the pg_database row for our database, check permissions and set
      * up database-specific GUC settings.  We can't do this until all the
      * database-access infrastructure is up.  (Also, it wants to know if the
      * user is a superuser, so the above stuff has to happen first.)
      */
     if (!bootstrap)
         CheckMyDatabase(dbname, am_superuser);
 
     /*
      * Now process any command-line switches and any additional GUC variable
      * settings passed in the startup packet.   We couldn't do this before
      * because we didn't know if client is a superuser.
      */
     if (MyProcPort != NULL)
         process_startup_options(MyProcPort, am_superuser);
 
     /* Process pg_db_role_setting options */
     process_settings(MyDatabaseId, GetSessionUserId());
 
     /* Apply PostAuthDelay as soon as we've read all options */
     if (PostAuthDelay > 0)
         pg_usleep(PostAuthDelay * 1000000L);
 
     /*
      * Initialize various default states that can't be set up until we've
      * selected the active user and gotten the right GUC settings.
      */
 
     /* set default namespace search path */
     InitializeSearchPath();
 
     /* initialize client encoding */
     InitializeClientEncoding();
 
     /* report this backend in the PgBackendStatus array */
     if (!bootstrap)
         pgstat_bestart();
 
     /* close the transaction we started above */
     if (!bootstrap)
         CommitTransactionCommand();
 }

void InitPostmasterChild ( void )

Definition at line 176 of file miscinit.c.

References elog, FATAL, InitializeLatchSupport(), InitLatch(), IsUnderPostmaster, LocalLatchData, MyLatch, MyProcPid, MyStartTime, NULL, and on_exit_reset().

Referenced by BackendStartup(), do_start_bgworker(), pgarch_start(), pgstat_start(), StartAutoVacLauncher(), StartAutoVacWorker(), StartChildProcess(), and SysLogger_Start().

 {
     IsUnderPostmaster = true;   /* we are a postmaster subprocess now */
 
     MyProcPid = getpid();       /* reset MyProcPid */
 
     MyStartTime = time(NULL);   /* set our start time in case we call elog */
 
     /*
      * make sure stderr is in binary mode before anything can possibly be
      * written to it, in case it's actually the syslogger pipe, so the pipe
      * chunking protocol isn't disturbed. Non-logpipe data gets translated on
      * redirection (e.g. via pg_ctl -l) anyway.
      */
 #ifdef WIN32
     _setmode(fileno(stderr), _O_BINARY);
 #endif
 
     /* We don't want the postmaster's proc_exit() handlers */
     on_exit_reset();
 
     /* Initialize process-local latch support */
     InitializeLatchSupport();
     MyLatch = &LocalLatchData;
     InitLatch(MyLatch);
 
     /*
      * If possible, make this process a group leader, so that the postmaster
      * can signal any child processes too. Not all processes will have
      * children, but for consistency we make all postmaster child processes do
      * this.
      */
 #ifdef HAVE_SETSID
     if (setsid() < 0)
         elog(FATAL, "setsid() failed: %m");
 #endif
 }

void InitStandaloneProcess ( const char * argv0 )

Definition at line 220 of file miscinit.c.

References Assert, elog, FATAL, find_my_exec(), get_pkglib_path(), InitializeLatchSupport(), InitLatch(), IsPostmasterEnvironment, LocalLatchData, my_exec_path, MyLatch, MyProcPid, MyStartTime, NULL, and pkglib_path.

Referenced by AuxiliaryProcessMain(), and PostgresMain().

 {
     Assert(!IsPostmasterEnvironment);
 
     MyProcPid = getpid();       /* reset MyProcPid */
 
     MyStartTime = time(NULL);   /* set our start time in case we call elog */
 
     /* Initialize process-local latch support */
     InitializeLatchSupport();
     MyLatch = &LocalLatchData;
     InitLatch(MyLatch);
 
     /* Compute paths, no postmaster to inherit from */
     if (my_exec_path[0] == '\0')
     {
         if (find_my_exec(argv0, my_exec_path) < 0)
             elog(FATAL, "%s: could not locate my own executable path",
                  argv0);
     }
 
     if (pkglib_path[0] == '\0')
         get_pkglib_path(my_exec_path, pkglib_path);
 }

bool InLocalUserIdChange ( void )

Definition at line 407 of file miscinit.c.

References SECURITY_LOCAL_USERID_CHANGE, and SecurityRestrictionContext.

Referenced by GetUserIdAndContext(), is_admin_of_role(), and set_config_option().

 {
     return (SecurityRestrictionContext & SECURITY_LOCAL_USERID_CHANGE) != 0;
 }

bool InNoForceRLSOperation ( void )

Definition at line 425 of file miscinit.c.

References SECURITY_NOFORCE_RLS, and SecurityRestrictionContext.

Referenced by check_enable_rls().

 {
     return (SecurityRestrictionContext & SECURITY_NOFORCE_RLS) != 0;
 }

bool InSecurityRestrictedOperation ( void )

Definition at line 416 of file miscinit.c.

References SECURITY_RESTRICTED_OPERATION, and SecurityRestrictionContext.

Referenced by CheckRestrictedOperation(), DefineRelation(), is_admin_of_role(), set_config_option(), and SetUserIdAndContext().

 {
     return (SecurityRestrictionContext & SECURITY_RESTRICTED_OPERATION) != 0;
 }

void pg_bindtextdomain ( const char * domain )

Definition at line 1511 of file miscinit.c.

References get_locale_path(), MAXPGPATH, and my_exec_path.

Referenced by _PG_init().

 {
 #ifdef ENABLE_NLS
     if (my_exec_path[0] != '\0')
     {
         char        locale_path[MAXPGPATH];
 
         get_locale_path(my_exec_path, locale_path);
         bindtextdomain(domain, locale_path);
         pg_bind_textdomain_codeset(domain);
     }
 #endif
 }

void pg_split_opts	(	char **	argv,
		int *	argcp,
		const char *	optstr
	)

Definition at line 436 of file postinit.c.

References appendStringInfoChar(), StringInfoData::data, initStringInfo(), pfree(), pstrdup(), and resetStringInfo().

Referenced by BackendRun(), and process_startup_options().

 {
     StringInfoData s;
 
     initStringInfo(&s);
 
     while (*optstr)
     {
         bool        last_was_escape = false;
 
         resetStringInfo(&s);
 
         /* skip over leading space */
         while (isspace((unsigned char) *optstr))
             optstr++;
 
         if (*optstr == '\0')
             break;
 
         /*
          * Parse a single option, stopping at the first space, unless it's
          * escaped.
          */
         while (*optstr)
         {
             if (isspace((unsigned char) *optstr) && !last_was_escape)
                 break;
 
             if (!last_was_escape && *optstr == '\\')
                 last_was_escape = true;
             else
             {
                 last_was_escape = false;
                 appendStringInfoChar(&s, *optstr);
             }
 
             optstr++;
         }
 
         /* now store the option in the next argv[] position */
         argv[(*argcp)++] = pstrdup(s.data);
     }
 
     pfree(s.data);
 }

void PostgresSigHupHandler ( SIGNAL_ARGS )

Definition at line 2688 of file postgres.c.

References ConfigReloadPending, MyLatch, and SetLatch().

Referenced by PostgresMain(), and WalSndSignals().

 {
     int         save_errno = errno;
 
     ConfigReloadPending = true;
     SetLatch(MyLatch);
 
     errno = save_errno;
 }

void PreventCommandDuringRecovery ( const char * cmdname )

Definition at line 273 of file utility.c.

References ereport, errcode(), errmsg(), ERROR, and RecoveryInProgress().

Referenced by LockTableCommand(), pg_notify(), standard_ProcessUtility(), and txid_current().

 {
     if (RecoveryInProgress())
         ereport(ERROR,
                 (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
         /* translator: %s is name of a SQL command, eg CREATE */
                  errmsg("cannot execute %s during recovery",
                         cmdname)));
 }

void PreventCommandIfParallelMode ( const char * cmdname )

Definition at line 254 of file utility.c.

References ereport, errcode(), errmsg(), ERROR, and IsInParallelMode().

Referenced by _SPI_execute_plan(), check_xact_readonly(), do_setval(), DoCopy(), ExecCheckXactReadOnly(), init_execution_state(), nextval_internal(), and SPI_cursor_open_internal().

 {
     if (IsInParallelMode())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
         /* translator: %s is name of a SQL command, eg CREATE */
                  errmsg("cannot execute %s during a parallel operation",
                         cmdname)));
 }

void PreventCommandIfReadOnly ( const char * cmdname )

Definition at line 236 of file utility.c.

References ereport, errcode(), errmsg(), ERROR, and XactReadOnly.

Referenced by check_xact_readonly(), do_setval(), DoCopy(), ExecCheckXactReadOnly(), and nextval_internal().

 {
     if (XactReadOnly)
         ereport(ERROR,
                 (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
         /* translator: %s is name of a SQL command, eg CREATE */
                  errmsg("cannot execute %s in a read-only transaction",
                         cmdname)));
 }

void process_session_preload_libraries ( void )

Definition at line 1500 of file miscinit.c.

References load_libraries(), local_preload_libraries_string, and session_preload_libraries_string.

Referenced by PostgresMain().

 {
     load_libraries(session_preload_libraries_string,
                    "session_preload_libraries",
                    false);
     load_libraries(local_preload_libraries_string,
                    "local_preload_libraries",
                    true);
 }

void process_shared_preload_libraries ( void )

Definition at line 1487 of file miscinit.c.

References load_libraries(), process_shared_preload_libraries_in_progress, and shared_preload_libraries_string.

Referenced by PostmasterMain().

 {
     process_shared_preload_libraries_in_progress = true;
     load_libraries(shared_preload_libraries_string,
                    "shared_preload_libraries",
                    false);
     process_shared_preload_libraries_in_progress = false;
 }

void ProcessInterrupts ( void )

Definition at line 2825 of file postgres.c.

References Assert, ClientAuthInProgress, ClientConnectionLost, CritSectionCount, DEBUG1, DestNone, DestRemote, DoingCommandRead, ereport, errcode(), errdetail_recovery_conflict(), errhint(), errmsg(), ERROR, FATAL, get_timeout_finish_time(), get_timeout_indicator(), HandleParallelMessages(), IdleInTransactionSessionTimeout, IdleInTransactionSessionTimeoutPending, InterruptHoldoffCount, InterruptPending, IsAutoVacuumWorkerProcess(), IsLogicalLauncher(), IsLogicalWorker(), LOCK_TIMEOUT, LockErrorCleanup(), ParallelMessagePending, pgstat_report_recovery_conflict(), proc_exit(), ProcDiePending, PROCSIG_RECOVERY_CONFLICT_DATABASE, QueryCancelHoldoffCount, QueryCancelPending, RecoveryConflictPending, RecoveryConflictReason, RecoveryConflictRetryable, STATEMENT_TIMEOUT, and whereToSendOutput.

Referenced by die().

 {
     /* OK to accept any interrupts now? */
     if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
         return;
     InterruptPending = false;
 
     if (ProcDiePending)
     {
         ProcDiePending = false;
         QueryCancelPending = false; /* ProcDie trumps QueryCancel */
         LockErrorCleanup();
         /* As in quickdie, don't risk sending to client during auth */
         if (ClientAuthInProgress && whereToSendOutput == DestRemote)
             whereToSendOutput = DestNone;
         if (ClientAuthInProgress)
             ereport(FATAL,
                     (errcode(ERRCODE_QUERY_CANCELED),
                      errmsg("canceling authentication due to timeout")));
         else if (IsAutoVacuumWorkerProcess())
             ereport(FATAL,
                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
                      errmsg("terminating autovacuum process due to administrator command")));
         else if (IsLogicalWorker())
             ereport(FATAL,
                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
                      errmsg("terminating logical replication worker due to administrator command")));
         else if (IsLogicalLauncher())
         {
             ereport(DEBUG1,
                     (errmsg("logical replication launcher shutting down")));
 
             /*
              * The logical replication launcher can be stopped at any time.
              * Use exit status 1 so the background worker is restarted.
              */
             proc_exit(1);
         }
         else if (RecoveryConflictPending && RecoveryConflictRetryable)
         {
             pgstat_report_recovery_conflict(RecoveryConflictReason);
             ereport(FATAL,
                     (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                      errmsg("terminating connection due to conflict with recovery"),
                      errdetail_recovery_conflict()));
         }
         else if (RecoveryConflictPending)
         {
             /* Currently there is only one non-retryable recovery conflict */
             Assert(RecoveryConflictReason == PROCSIG_RECOVERY_CONFLICT_DATABASE);
             pgstat_report_recovery_conflict(RecoveryConflictReason);
             ereport(FATAL,
                     (errcode(ERRCODE_DATABASE_DROPPED),
                      errmsg("terminating connection due to conflict with recovery"),
                      errdetail_recovery_conflict()));
         }
         else
             ereport(FATAL,
                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
                      errmsg("terminating connection due to administrator command")));
     }
     if (ClientConnectionLost)
     {
         QueryCancelPending = false; /* lost connection trumps QueryCancel */
         LockErrorCleanup();
         /* don't send to client, we already know the connection to be dead. */
         whereToSendOutput = DestNone;
         ereport(FATAL,
                 (errcode(ERRCODE_CONNECTION_FAILURE),
                  errmsg("connection to client lost")));
     }
 
     /*
      * If a recovery conflict happens while we are waiting for input from the
      * client, the client is presumably just sitting idle in a transaction,
      * preventing recovery from making progress.  Terminate the connection to
      * dislodge it.
      */
     if (RecoveryConflictPending && DoingCommandRead)
     {
         QueryCancelPending = false; /* this trumps QueryCancel */
         RecoveryConflictPending = false;
         LockErrorCleanup();
         pgstat_report_recovery_conflict(RecoveryConflictReason);
         ereport(FATAL,
                 (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                  errmsg("terminating connection due to conflict with recovery"),
                  errdetail_recovery_conflict(),
                  errhint("In a moment you should be able to reconnect to the"
                          " database and repeat your command.")));
     }
 
     if (QueryCancelPending)
     {
         bool        lock_timeout_occurred;
         bool        stmt_timeout_occurred;
 
         /*
          * Don't allow query cancel interrupts while reading input from the
          * client, because we might lose sync in the FE/BE protocol.  (Die
          * interrupts are OK, because we won't read any further messages from
          * the client in that case.)
          */
         if (QueryCancelHoldoffCount != 0)
         {
             /*
              * Re-arm InterruptPending so that we process the cancel request
              * as soon as we're done reading the message.
              */
             InterruptPending = true;
             return;
         }
 
         QueryCancelPending = false;
 
         /*
          * If LOCK_TIMEOUT and STATEMENT_TIMEOUT indicators are both set, we
          * need to clear both, so always fetch both.
          */
         lock_timeout_occurred = get_timeout_indicator(LOCK_TIMEOUT, true);
         stmt_timeout_occurred = get_timeout_indicator(STATEMENT_TIMEOUT, true);
 
         /*
          * If both were set, we want to report whichever timeout completed
          * earlier; this ensures consistent behavior if the machine is slow
          * enough that the second timeout triggers before we get here.  A tie
          * is arbitrarily broken in favor of reporting a lock timeout.
          */
         if (lock_timeout_occurred && stmt_timeout_occurred &&
             get_timeout_finish_time(STATEMENT_TIMEOUT) < get_timeout_finish_time(LOCK_TIMEOUT))
             lock_timeout_occurred = false;  /* report stmt timeout */
 
         if (lock_timeout_occurred)
         {
             LockErrorCleanup();
             ereport(ERROR,
                     (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                      errmsg("canceling statement due to lock timeout")));
         }
         if (stmt_timeout_occurred)
         {
             LockErrorCleanup();
             ereport(ERROR,
                     (errcode(ERRCODE_QUERY_CANCELED),
                      errmsg("canceling statement due to statement timeout")));
         }
         if (IsAutoVacuumWorkerProcess())
         {
             LockErrorCleanup();
             ereport(ERROR,
                     (errcode(ERRCODE_QUERY_CANCELED),
                      errmsg("canceling autovacuum task")));
         }
         if (RecoveryConflictPending)
         {
             RecoveryConflictPending = false;
             LockErrorCleanup();
             pgstat_report_recovery_conflict(RecoveryConflictReason);
             ereport(ERROR,
                     (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                      errmsg("canceling statement due to conflict with recovery"),
                      errdetail_recovery_conflict()));
         }
 
         /*
          * If we are reading a command from the client, just ignore the cancel
          * request --- sending an extra error message won't accomplish
          * anything.  Otherwise, go ahead and throw the error.
          */
         if (!DoingCommandRead)
         {
             LockErrorCleanup();
             ereport(ERROR,
                     (errcode(ERRCODE_QUERY_CANCELED),
                      errmsg("canceling statement due to user request")));
         }
     }
 
     if (IdleInTransactionSessionTimeoutPending)
     {
         /* Has the timeout setting changed since last we looked? */
         if (IdleInTransactionSessionTimeout > 0)
             ereport(FATAL,
                     (errcode(ERRCODE_IDLE_IN_TRANSACTION_SESSION_TIMEOUT),
                      errmsg("terminating connection due to idle-in-transaction timeout")));
         else
             IdleInTransactionSessionTimeoutPending = false;
 
     }
 
     if (ParallelMessagePending)
         HandleParallelMessages();
 }

bool RecheckDataDirLockFile ( void )

Definition at line 1286 of file miscinit.c.

References buffer, close, DIRECTORY_LOCK_FILE, ereport, errcode_for_file_access(), errmsg(), fd(), LOG, PG_BINARY, pgstat_report_wait_end(), pgstat_report_wait_start(), read, and WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ.

Referenced by ServerLoop().

 {
     int         fd;
     int         len;
     long        file_pid;
     char        buffer[BLCKSZ];
 
     fd = open(DIRECTORY_LOCK_FILE, O_RDWR | PG_BINARY, 0);
     if (fd < 0)
     {
         /*
          * There are many foreseeable false-positive error conditions.  For
          * safety, fail only on enumerated clearly-something-is-wrong
          * conditions.
          */
         switch (errno)
         {
             case ENOENT:
             case ENOTDIR:
                 /* disaster */
                 ereport(LOG,
                         (errcode_for_file_access(),
                          errmsg("could not open file \"%s\": %m",
                                 DIRECTORY_LOCK_FILE)));
                 return false;
             default:
                 /* non-fatal, at least for now */
                 ereport(LOG,
                         (errcode_for_file_access(),
                          errmsg("could not open file \"%s\": %m; continuing anyway",
                                 DIRECTORY_LOCK_FILE)));
                 return true;
         }
     }
     pgstat_report_wait_start(WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ);
     len = read(fd, buffer, sizeof(buffer) - 1);
     pgstat_report_wait_end();
     if (len < 0)
     {
         ereport(LOG,
                 (errcode_for_file_access(),
                  errmsg("could not read from file \"%s\": %m",
                         DIRECTORY_LOCK_FILE)));
         close(fd);
         return true;            /* treat read failure as nonfatal */
     }
     buffer[len] = '\0';
     close(fd);
     file_pid = atol(buffer);
     if (file_pid == getpid())
         return true;            /* all is well */
 
     /* Trouble: someone's overwritten the lock file */
     ereport(LOG,
             (errmsg("lock file \"%s\" contains wrong PID: %ld instead of %ld",
                     DIRECTORY_LOCK_FILE, file_pid, (long) getpid())));
     return false;
 }

void restore_stack_base ( pg_stack_base_t base )

Definition at line 3095 of file postgres.c.

References stack_base_ptr.

 {
 #if defined(__ia64__) || defined(__ia64)
     stack_base_ptr = base.stack_base_ptr;
     register_stack_base_ptr = base.register_stack_base_ptr;
 #else
     stack_base_ptr = base;
 #endif
 }

pg_stack_base_t set_stack_base ( void )

Definition at line 3064 of file postgres.c.

References stack_base_ptr.

Referenced by PostmasterMain().

 {
     char        stack_base;
     pg_stack_base_t old;
 
 #if defined(__ia64__) || defined(__ia64)
     old.stack_base_ptr = stack_base_ptr;
     old.register_stack_base_ptr = register_stack_base_ptr;
 #else
     old = stack_base_ptr;
 #endif
 
     /* Set up reference point for stack depth checking */
     stack_base_ptr = &stack_base;
 #if defined(__ia64__) || defined(__ia64)
     register_stack_base_ptr = ia64_get_bsp();
 #endif
 
     return old;
 }

void SetCurrentRoleId	(	Oid	roleid,
		bool	is_superuser
	)

Definition at line 657 of file miscinit.c.

References OidIsValid, PGC_INTERNAL, PGC_S_OVERRIDE, SessionUserId, SessionUserIsSuperuser, SetConfigOption(), SetOuterUserId(), and SetRoleIsActive.

Referenced by assign_role().

 {
     /*
      * Get correct info if it's SET ROLE NONE
      *
      * If SessionUserId hasn't been set yet, just do nothing --- the eventual
      * SetSessionUserId call will fix everything.  This is needed since we
      * will get called during GUC initialization.
      */
     if (!OidIsValid(roleid))
     {
         if (!OidIsValid(SessionUserId))
             return;
 
         roleid = SessionUserId;
         is_superuser = SessionUserIsSuperuser;
 
         SetRoleIsActive = false;
     }
     else
         SetRoleIsActive = true;
 
     SetOuterUserId(roleid);
 
     SetConfigOption("is_superuser",
                     is_superuser ? "on" : "off",
                     PGC_INTERNAL, PGC_S_OVERRIDE);
 }

void SetDatabasePath ( const char * path )

Definition at line 83 of file miscinit.c.

References Assert, DatabasePath, MemoryContextStrdup(), and TopMemoryContext.

Referenced by InitPostgres().

 {
     /* This should happen only once per process */
     Assert(!DatabasePath);
     DatabasePath = MemoryContextStrdup(TopMemoryContext, path);
 }

void SetDataDir ( const char * dir )

Definition at line 95 of file miscinit.c.

References AssertArg, DataDir, free, and make_absolute_path().

Referenced by SelectConfigFiles().

 {
     char       *new;
 
     AssertArg(dir);
 
     /* If presented path is relative, convert to absolute */
     new = make_absolute_path(dir);
 
     if (DataDir)
         free(DataDir);
     DataDir = new;
 }

void SetSessionAuthorization	(	Oid	userid,
		bool	is_superuser
	)

Definition at line 611 of file miscinit.c.

References AssertState, AuthenticatedUserId, AuthenticatedUserIsSuperuser, ereport, errcode(), errmsg(), ERROR, OidIsValid, PGC_INTERNAL, PGC_S_OVERRIDE, SetConfigOption(), and SetSessionUserId().

Referenced by assign_session_authorization().

 {
     /* Must have authenticated already, else can't make permission check */
     AssertState(OidIsValid(AuthenticatedUserId));
 
     if (userid != AuthenticatedUserId &&
         !AuthenticatedUserIsSuperuser)
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("permission denied to set session authorization")));
 
     SetSessionUserId(userid, is_superuser);
 
     SetConfigOption("is_superuser",
                     is_superuser ? "on" : "off",
                     PGC_INTERNAL, PGC_S_OVERRIDE);
 }

void SetUserIdAndContext	(	Oid	userid,
		bool	sec_def_context
	)

Definition at line 445 of file miscinit.c.

References CurrentUserId, ereport, errcode(), errmsg(), ERROR, InSecurityRestrictedOperation(), SECURITY_LOCAL_USERID_CHANGE, and SecurityRestrictionContext.

 {
     /* We throw the same error SET ROLE would. */
     if (InSecurityRestrictedOperation())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("cannot set parameter \"%s\" within security-restricted operation",
                         "role")));
     CurrentUserId = userid;
     if (sec_def_context)
         SecurityRestrictionContext |= SECURITY_LOCAL_USERID_CHANGE;
     else
         SecurityRestrictionContext &= ~SECURITY_LOCAL_USERID_CHANGE;
 }

void SetUserIdAndSecContext	(	Oid	userid,
		int	sec_context
	)

Definition at line 396 of file miscinit.c.

References CurrentUserId, and SecurityRestrictionContext.

Referenced by AbortSubTransaction(), AbortTransaction(), CreateSchemaCommand(), do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), fmgr_security_definer(), index_build(), ParallelWorkerMain(), refresh_by_match_merge(), ri_PerformCheck(), ri_PlanCheck(), vacuum_rel(), and validate_index().

 {
     CurrentUserId = userid;
     SecurityRestrictionContext = sec_context;
 }

bool stack_is_too_deep ( void )

Definition at line 3131 of file postgres.c.

References max_stack_depth_bytes, NULL, and stack_base_ptr.

Referenced by check_stack_depth(), and rstacktoodeep().

 {
     char        stack_top_loc;
     long        stack_depth;
 
     /*
      * Compute distance from reference point to my local variables
      */
     stack_depth = (long) (stack_base_ptr - &stack_top_loc);
 
     /*
      * Take abs value, since stacks grow up on some machines, down on others
      */
     if (stack_depth < 0)
         stack_depth = -stack_depth;
 
     /*
      * Trouble?
      *
      * The test on stack_base_ptr prevents us from erroring out if called
      * during process setup or in a non-backend process.  Logically it should
      * be done first, but putting it here avoids wasting cycles during normal
      * cases.
      */
     if (stack_depth > max_stack_depth_bytes &&
         stack_base_ptr != NULL)
         return true;
 
     /*
      * On IA64 there is a separate "register" stack that requires its own
      * independent check.  For this, we have to measure the change in the
      * "BSP" pointer from PostgresMain to here.  Logic is just as above,
      * except that we know IA64's register stack grows up.
      *
      * Note we assume that the same max_stack_depth applies to both stacks.
      */
 #if defined(__ia64__) || defined(__ia64)
     stack_depth = (long) (ia64_get_bsp() - register_stack_base_ptr);
 
     if (stack_depth > max_stack_depth_bytes &&
         register_stack_base_ptr != NULL)
         return true;
 #endif                          /* IA64 */
 
     return false;
 }

bool superuser ( void )

Definition at line 47 of file superuser.c.

References GetUserId(), and superuser_arg().

Referenced by AddRoleMems(), AlterForeignDataWrapper(), AlterForeignDataWrapperOwner_internal(), AlterForeignServerOwner_internal(), AlterFunction(), AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), AlterOpFamily(), AlterPublicationOwner_internal(), AlterRole(), AlterRoleSet(), AlterSystemSetConfigFile(), AlterTypeOwner(), ATExecChangeOwner(), be_lo_export(), brin_metapage_info(), brin_page_items(), brin_page_type(), brin_revmap_data(), bt_metap(), bt_page_items(), bt_page_items_bytea(), bt_page_stats(), check_conn_params(), check_encoding_locale_matches(), check_permissions(), connect_pg_server(), CreateAccessMethod(), CreateCast(), CreateEventTrigger(), CreateForeignDataWrapper(), CreateFunction(), CreateProceduralLanguage(), CreatePublication(), CreateRole(), CreateSubscription(), CreateTableSpace(), dblink_connstr_check(), dblink_security_check(), DefineAggregate(), DefineOpClass(), DefineOpFamily(), DefineTSParser(), DefineTSTemplate(), DefineType(), DelRoleMems(), DoCopy(), DropRole(), dummy_object_relabel(), EnableDisableTrigger(), ExecSetVariableStmt(), execute_extension_script(), ExecuteDoStmt(), file_fdw_validator(), fmgr_security_definer(), fsm_page_contents(), get_raw_page_internal(), GetConfigOptionByNum(), gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), GUCArrayReset(), hash_bitmap_info(), hash_metapage_info(), hash_page_items(), hash_page_stats(), hash_page_type(), have_createdb_privilege(), heap_page_items(), InitPostgres(), lo_import_internal(), main(), page_checksum(), page_header(), pg_import_system_collations(), pg_logdir_ls(), pg_ls_dir(), pg_read_binary_file(), pg_read_file(), pg_relpages(), pg_relpagesbyid(), pg_signal_backend(), pg_stat_file(), pg_stat_get_wal_senders(), pgstat_get_backend_current_activity(), pgstatginindex(), pgstatindex(), pgstatindexbyid(), pgstattuple(), pgstattuple_approx(), pgstattuplebyid(), ProcedureCreate(), regress_putenv(), RemoveAccessMethodById(), RenameRole(), replorigin_check_prerequisites(), requireSuperuser(), sepgsql_restorecon(), set_config_by_name(), SetPGVariable(), ShowAllGUCConfig(), standard_ProcessUtility(), tuple_data_split(), validate_option_array_item(), and wait_pid().

 {
     return superuser_arg(GetUserId());
 }

bool superuser_arg ( Oid roleid )

Definition at line 57 of file superuser.c.

References AUTHOID, BOOTSTRAP_SUPERUSERID, CacheRegisterSyscacheCallback(), GETSTRUCT, HeapTupleIsValid, IsUnderPostmaster, last_roleid, last_roleid_is_super, ObjectIdGetDatum, OidIsValid, ReleaseSysCache(), result, roleid_callback_registered, RoleidCallback(), and SearchSysCache1.

Referenced by AddRoleMems(), AlterEventTriggerOwner_internal(), AlterForeignDataWrapperOwner_internal(), AlterPublicationOwner_internal(), AlterSubscriptionOwner_internal(), check_object_ownership(), DelRoleMems(), has_bypassrls_privilege(), has_createrole_privilege(), has_privs_of_role(), is_admin_of_role(), is_member_of_role(), LockGXact(), pg_class_aclmask(), pg_class_ownercheck(), pg_collation_ownercheck(), pg_conversion_ownercheck(), pg_database_aclmask(), pg_database_ownercheck(), pg_event_trigger_ownercheck(), pg_extension_ownercheck(), pg_foreign_data_wrapper_aclmask(), pg_foreign_data_wrapper_ownercheck(), pg_foreign_server_aclmask(), pg_foreign_server_ownercheck(), pg_language_aclmask(), pg_language_ownercheck(), pg_largeobject_aclmask_snapshot(), pg_largeobject_ownercheck(), pg_namespace_aclmask(), pg_namespace_ownercheck(), pg_opclass_ownercheck(), pg_oper_ownercheck(), pg_opfamily_ownercheck(), pg_proc_aclmask(), pg_proc_ownercheck(), pg_publication_ownercheck(), pg_signal_backend(), pg_statistics_object_ownercheck(), pg_subscription_ownercheck(), pg_tablespace_aclmask(), pg_tablespace_ownercheck(), pg_ts_config_ownercheck(), pg_ts_dict_ownercheck(), pg_type_aclmask(), pg_type_ownercheck(), select_best_grantor(), and superuser().

 {
     bool        result;
     HeapTuple   rtup;
 
     /* Quick out for cache hit */
     if (OidIsValid(last_roleid) && last_roleid == roleid)
         return last_roleid_is_super;
 
     /* Special escape path in case you deleted all your users. */
     if (!IsUnderPostmaster && roleid == BOOTSTRAP_SUPERUSERID)
         return true;
 
     /* OK, look up the information in pg_authid */
     rtup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
     if (HeapTupleIsValid(rtup))
     {
         result = ((Form_pg_authid) GETSTRUCT(rtup))->rolsuper;
         ReleaseSysCache(rtup);
     }
     else
     {
         /* Report "not superuser" for invalid roleids */
         result = false;
     }
 
     /* If first time through, set up callback for cache flushes */
     if (!roleid_callback_registered)
     {
         CacheRegisterSyscacheCallback(AUTHOID,
                                       RoleidCallback,
                                       (Datum) 0);
         roleid_callback_registered = true;
     }
 
     /* Cache the result for next time */
     last_roleid = roleid;
     last_roleid_is_super = result;
 
     return result;
 }

void SwitchBackToLocalLatch ( void )

Definition at line 265 of file miscinit.c.

References Assert, FeBeWaitSet, LocalLatchData, ModifyWaitEvent(), MyLatch, MyProc, NULL, PGPROC::procLatch, SetLatch(), and WL_LATCH_SET.

Referenced by AuxiliaryProcKill(), and ProcKill().

 {
     Assert(MyLatch != &LocalLatchData);
     Assert(MyProc != NULL && MyLatch == &MyProc->procLatch);
 
     MyLatch = &LocalLatchData;
 
     if (FeBeWaitSet)
         ModifyWaitEvent(FeBeWaitSet, 1, WL_LATCH_SET, MyLatch);
 
     SetLatch(MyLatch);
 }

void SwitchToSharedLatch ( void )

Definition at line 246 of file miscinit.c.

References Assert, FeBeWaitSet, ModifyWaitEvent(), MyLatch, MyProc, NULL, PGPROC::procLatch, SetLatch(), and WL_LATCH_SET.

Referenced by InitAuxiliaryProcess(), and InitProcess().

 {
     Assert(MyLatch == &LocalLatchData);
     Assert(MyProc != NULL);
 
     MyLatch = &MyProc->procLatch;
 
     if (FeBeWaitSet)
         ModifyWaitEvent(FeBeWaitSet, 1, WL_LATCH_SET, MyLatch);
 
     /*
      * Set the shared latch as the local one might have been set. This
      * shouldn't normally be necessary as code is supposed to check the
      * condition before waiting for the latch, but a bit care can't hurt.
      */
     SetLatch(MyLatch);
 }

void TouchSocketLockFiles ( void )

Definition at line 1108 of file miscinit.c.

References buffer, close, DIRECTORY_LOCK_FILE, fd(), lfirst, NULL, PG_BINARY, and read.

Referenced by ServerLoop().

 {
     ListCell   *l;
 
     foreach(l, lock_files)
     {
         char       *socketLockFile = (char *) lfirst(l);
 
         /* No need to touch the data directory lock file, we trust */
         if (strcmp(socketLockFile, DIRECTORY_LOCK_FILE) == 0)
             continue;
 
         /*
          * utime() is POSIX standard, utimes() is a common alternative; if we
          * have neither, fall back to actually reading the file (which only
          * sets the access time not mod time, but that should be enough in
          * most cases).  In all paths, we ignore errors.
          */
 #ifdef HAVE_UTIME
         utime(socketLockFile, NULL);
 #else                           /* !HAVE_UTIME */
 #ifdef HAVE_UTIMES
         utimes(socketLockFile, NULL);
 #else                           /* !HAVE_UTIMES */
         int         fd;
         char        buffer[1];
 
         fd = open(socketLockFile, O_RDONLY | PG_BINARY, 0);
         if (fd >= 0)
         {
             read(fd, buffer, sizeof(buffer));
             close(fd);
         }
 #endif                          /* HAVE_UTIMES */
 #endif                          /* HAVE_UTIME */
     }
 }

int trace_recovery ( int trace_level )

Definition at line 3753 of file elog.c.

References LOG, and trace_recovery_messages.

Referenced by KnownAssignedXidsRemove(), KnownAssignedXidsRemovePreceding(), LogCurrentRunningXacts(), ProcArrayApplyRecoveryInfo(), ProcessCommittedInvalidationMessages(), RecordKnownAssignedTransactionIds(), RecoveryRestartPoint(), StandbyAcquireAccessExclusiveLock(), StandbyReleaseAllLocks(), StandbyReleaseLocks(), and StandbyReleaseOldLocks().

 {
     if (trace_level < LOG &&
         trace_level >= trace_recovery_messages)
         return LOG;
 
     return trace_level;
 }

void ValidatePgVersion ( const char * path )

Definition at line 1358 of file miscinit.c.

References AllocateFile(), ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), FATAL, FreeFile(), MAXPGPATH, and snprintf().

Referenced by AuxiliaryProcessMain(), checkDataDir(), InitPostgres(), and PostgresMain().

 {
     char        full_path[MAXPGPATH];
     FILE       *file;
     int         ret;
     long        file_major;
     long        my_major;
     char       *endptr;
     char        file_version_string[64];
     const char *my_version_string = PG_VERSION;
 
     my_major = strtol(my_version_string, &endptr, 10);
 
     snprintf(full_path, sizeof(full_path), "%s/PG_VERSION", path);
 
     file = AllocateFile(full_path, "r");
     if (!file)
     {
         if (errno == ENOENT)
             ereport(FATAL,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("\"%s\" is not a valid data directory",
                             path),
                      errdetail("File \"%s\" is missing.", full_path)));
         else
             ereport(FATAL,
                     (errcode_for_file_access(),
                      errmsg("could not open file \"%s\": %m", full_path)));
     }
 
     file_version_string[0] = '\0';
     ret = fscanf(file, "%63s", file_version_string);
     file_major = strtol(file_version_string, &endptr, 10);
 
     if (ret != 1 || endptr == file_version_string)
         ereport(FATAL,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("\"%s\" is not a valid data directory",
                         path),
                  errdetail("File \"%s\" does not contain valid data.",
                            full_path),
                  errhint("You might need to initdb.")));
 
     FreeFile(file);
 
     if (my_major != file_major)
         ereport(FATAL,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("database files are incompatible with server"),
                  errdetail("The data directory was initialized by PostgreSQL version %s, "
                            "which is not compatible with this version %s.",
                            file_version_string, my_version_string)));
 }