#include <signal.h>
#include "datatype/timestamp.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	INTERRUPTS_PENDING_CONDITION() (unlikely(InterruptPending))

#define	CHECK_FOR_INTERRUPTS()

#define	INTERRUPTS_CAN_BE_PROCESSED()

#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	MIN_BAS_VAC_RING_SIZE_KB 128

#define	MAX_BAS_VAC_RING_SIZE_KB (16 * 1024 * 1024)

#define	STACK_DEPTH_SLOP (512 * 1024)

#define	SECURITY_LOCAL_USERID_CHANGE 0x0001

#define	SECURITY_RESTRICTED_OPERATION 0x0002

#define	SECURITY_NOFORCE_RLS 0x0004

#define	BACKEND_NUM_TYPES (B_LOGGER + 1)

#define	AmRegularBackendProcess() (MyBackendType == B_BACKEND)

#define	AmAutoVacuumLauncherProcess() (MyBackendType == B_AUTOVAC_LAUNCHER)

#define	AmAutoVacuumWorkerProcess() (MyBackendType == B_AUTOVAC_WORKER)

#define	AmBackgroundWorkerProcess() (MyBackendType == B_BG_WORKER)

#define	AmWalSenderProcess() (MyBackendType == B_WAL_SENDER)

#define	AmLogicalSlotSyncWorkerProcess() (MyBackendType == B_SLOTSYNC_WORKER)

#define	AmArchiverProcess() (MyBackendType == B_ARCHIVER)

#define	AmBackgroundWriterProcess() (MyBackendType == B_BG_WRITER)

#define	AmCheckpointerProcess() (MyBackendType == B_CHECKPOINTER)

#define	AmStartupProcess() (MyBackendType == B_STARTUP)

#define	AmWalReceiverProcess() (MyBackendType == B_WAL_RECEIVER)

#define	AmWalSummarizerProcess() (MyBackendType == B_WAL_SUMMARIZER)

#define	AmWalWriterProcess() (MyBackendType == B_WAL_WRITER)

#define	AmIoWorkerProcess() (MyBackendType == B_IO_WORKER)

#define	AmSpecialWorkerProcess()

#define	IsExternalConnectionBackend(backend_type) (backend_type == B_BACKEND \|\| backend_type == B_WAL_SENDER)

#define	IsBootstrapProcessingMode() (Mode == BootstrapProcessing)

#define	IsInitProcessingMode() (Mode == InitProcessing)

#define	IsNormalProcessingMode() (Mode == NormalProcessing)

#define	GetProcessingMode() Mode

#define	SetProcessingMode(mode)

#define	INIT_PG_LOAD_SESSION_LIBS 0x0001

#define	INIT_PG_OVERRIDE_ALLOW_CONNS 0x0002

#define	INIT_PG_OVERRIDE_ROLE_LOGIN 0x0004

Typedefs
typedef char *	pg_stack_base_t

typedef enum BackendType	BackendType

typedef enum ProcessingMode	ProcessingMode

typedef void(*	shmem_request_hook_type) (void)

Enumerations
enum	BackendType { B_INVALID = 0 , B_BACKEND , B_DEAD_END_BACKEND , B_AUTOVAC_LAUNCHER , B_AUTOVAC_WORKER , B_BG_WORKER , B_WAL_SENDER , B_SLOTSYNC_WORKER , B_STANDALONE_BACKEND , B_ARCHIVER , B_BG_WRITER , B_CHECKPOINTER , B_IO_WORKER , B_STARTUP , B_WAL_RECEIVER , B_WAL_SUMMARIZER , B_WAL_WRITER , B_LOGGER }

enum	ProcessingMode { BootstrapProcessing , InitProcessing , NormalProcessing }

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)

ssize_t	get_stack_depth_rlimit (void)

void	PreventCommandIfReadOnly (const char *cmdname)

void	PreventCommandIfParallelMode (const char *cmdname)

void	PreventCommandDuringRecovery (const char *cmdname)

void	InitPostmasterChild (void)

void	InitStandaloneProcess (const char *argv0)

void	InitProcessLocalLatch (void)

void	SwitchToSharedLatch (void)

void	SwitchBackToLocalLatch (void)

const char *	GetBackendTypeDesc (BackendType backendType)

void	SetDatabasePath (const char *path)

void	checkDataDir (void)

void	SetDataDir (const char *dir)

void	ChangeToDataDir (void)

char *	GetUserNameFromId (Oid roleid, bool noerr)

Oid	GetUserId (void)

Oid	GetOuterUserId (void)

Oid	GetSessionUserId (void)

bool	GetSessionUserIsSuperuser (void)

Oid	GetAuthenticatedUserId (void)

void	SetAuthenticatedUserId (Oid userid)

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 roleid, bool bypass_login_check)

void	InitializeSessionUserIdStandalone (void)

void	SetSessionAuthorization (Oid userid, bool is_superuser)

Oid	GetCurrentRoleId (void)

void	SetCurrentRoleId (Oid roleid, bool is_superuser)

void	InitializeSystemUser (const char authn_id, const char auth_method)

const char *	GetSystemUser (void)

bool	superuser (void)

bool	superuser_arg (Oid roleid)

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

void	InitializeMaxBackends (void)

void	InitializeFastPathLocks (void)

void	InitPostgres (const char in_dbname, Oid dboid, const char username, Oid useroid, bits32 flags, 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	process_shmem_requests (void)

void	pg_bindtextdomain (const char *domain)

bool	has_rolreplication (Oid roleid)

Size	EstimateClientConnectionInfoSpace (void)

void	SerializeClientConnectionInfo (Size maxsize, char *start_address)

void	RestoreClientConnectionInfo (char *conninfo)

size_t	get_hash_memory_limit (void)

Variables
PGDLLIMPORT volatile sig_atomic_t	InterruptPending

PGDLLIMPORT volatile sig_atomic_t	QueryCancelPending

PGDLLIMPORT volatile sig_atomic_t	ProcDiePending

PGDLLIMPORT volatile sig_atomic_t	IdleInTransactionSessionTimeoutPending

PGDLLIMPORT volatile sig_atomic_t	TransactionTimeoutPending

PGDLLIMPORT volatile sig_atomic_t	IdleSessionTimeoutPending

PGDLLIMPORT volatile sig_atomic_t	ProcSignalBarrierPending

PGDLLIMPORT volatile sig_atomic_t	LogMemoryContextPending

PGDLLIMPORT volatile sig_atomic_t	IdleStatsUpdateTimeoutPending

PGDLLIMPORT volatile sig_atomic_t	PublishMemoryContextPending

PGDLLIMPORT volatile sig_atomic_t	CheckClientConnectionPending

PGDLLIMPORT volatile sig_atomic_t	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	IsBinaryUpgrade

PGDLLIMPORT bool	ExitOnAnyError

PGDLLIMPORT char *	DataDir

PGDLLIMPORT int	data_directory_mode

PGDLLIMPORT int	NBuffers

PGDLLIMPORT int	MaxBackends

PGDLLIMPORT int	MaxConnections

PGDLLIMPORT int	max_worker_processes

PGDLLIMPORT int	max_parallel_workers

PGDLLIMPORT int	commit_timestamp_buffers

PGDLLIMPORT int	multixact_member_buffers

PGDLLIMPORT int	multixact_offset_buffers

PGDLLIMPORT int	notify_buffers

PGDLLIMPORT int	serializable_buffers

PGDLLIMPORT int	subtransaction_buffers

PGDLLIMPORT int	transaction_buffers

PGDLLIMPORT int	MyProcPid

PGDLLIMPORT pg_time_t	MyStartTime

PGDLLIMPORT TimestampTz	MyStartTimestamp

PGDLLIMPORT struct Port *	MyProcPort

PGDLLIMPORT struct Latch *	MyLatch

PGDLLIMPORT char	MyCancelKey []

PGDLLIMPORT int	MyCancelKeyLength

PGDLLIMPORT int	MyPMChildSlot

PGDLLIMPORT char	OutputFileName []

PGDLLIMPORT char	my_exec_path []

PGDLLIMPORT char	pkglib_path []

PGDLLIMPORT Oid	MyDatabaseId

PGDLLIMPORT Oid	MyDatabaseTableSpace

PGDLLIMPORT bool	MyDatabaseHasLoginEventTriggers

PGDLLIMPORT int	DateStyle

PGDLLIMPORT int	DateOrder

PGDLLIMPORT int	IntervalStyle

PGDLLIMPORT bool	enableFsync

PGDLLIMPORT bool	allowSystemTableMods

PGDLLIMPORT int	work_mem

PGDLLIMPORT double	hash_mem_multiplier

PGDLLIMPORT int	maintenance_work_mem

PGDLLIMPORT int	max_parallel_maintenance_workers

PGDLLIMPORT int	VacuumBufferUsageLimit

PGDLLIMPORT int	VacuumCostPageHit

PGDLLIMPORT int	VacuumCostPageMiss

PGDLLIMPORT int	VacuumCostPageDirty

PGDLLIMPORT int	VacuumCostLimit

PGDLLIMPORT double	VacuumCostDelay

PGDLLIMPORT int	VacuumCostBalance

PGDLLIMPORT bool	VacuumCostActive

PGDLLIMPORT int	max_stack_depth

PGDLLIMPORT char *	DatabasePath

PGDLLIMPORT BackendType	MyBackendType

PGDLLIMPORT ProcessingMode	Mode

PGDLLIMPORT bool	IgnoreSystemIndexes

PGDLLIMPORT bool	process_shared_preload_libraries_in_progress

PGDLLIMPORT bool	process_shared_preload_libraries_done

PGDLLIMPORT bool	process_shmem_requests_in_progress

PGDLLIMPORT char *	session_preload_libraries_string

PGDLLIMPORT char *	shared_preload_libraries_string

PGDLLIMPORT char *	local_preload_libraries_string

PGDLLIMPORT shmem_request_hook_type	shmem_request_hook

Macro Definition Documentation

◆ AmArchiverProcess

#define AmArchiverProcess ( ) (MyBackendType == B_ARCHIVER)

Definition at line 387 of file miscadmin.h.

◆ AmAutoVacuumLauncherProcess

#define AmAutoVacuumLauncherProcess ( ) (MyBackendType == B_AUTOVAC_LAUNCHER)

Definition at line 382 of file miscadmin.h.

◆ AmAutoVacuumWorkerProcess

#define AmAutoVacuumWorkerProcess ( ) (MyBackendType == B_AUTOVAC_WORKER)

Definition at line 383 of file miscadmin.h.

◆ AmBackgroundWorkerProcess

#define AmBackgroundWorkerProcess ( ) (MyBackendType == B_BG_WORKER)

Definition at line 384 of file miscadmin.h.

◆ AmBackgroundWriterProcess

#define AmBackgroundWriterProcess ( ) (MyBackendType == B_BG_WRITER)

Definition at line 388 of file miscadmin.h.

◆ AmCheckpointerProcess

#define AmCheckpointerProcess ( ) (MyBackendType == B_CHECKPOINTER)

Definition at line 389 of file miscadmin.h.

◆ AmIoWorkerProcess

#define AmIoWorkerProcess ( ) (MyBackendType == B_IO_WORKER)

Definition at line 394 of file miscadmin.h.

◆ AmLogicalSlotSyncWorkerProcess

#define AmLogicalSlotSyncWorkerProcess ( ) (MyBackendType == B_SLOTSYNC_WORKER)

Definition at line 386 of file miscadmin.h.

◆ AmRegularBackendProcess

#define AmRegularBackendProcess ( ) (MyBackendType == B_BACKEND)

Definition at line 381 of file miscadmin.h.

◆ AmSpecialWorkerProcess

#define AmSpecialWorkerProcess ( )

Value:

(AmAutoVacuumLauncherProcess() || \

AmLogicalSlotSyncWorkerProcess())

AmAutoVacuumLauncherProcess

#define AmAutoVacuumLauncherProcess()

Definition: miscadmin.h:382

Definition at line 396 of file miscadmin.h.

◆ AmStartupProcess

#define AmStartupProcess ( ) (MyBackendType == B_STARTUP)

Definition at line 390 of file miscadmin.h.

◆ AmWalReceiverProcess

#define AmWalReceiverProcess ( ) (MyBackendType == B_WAL_RECEIVER)

Definition at line 391 of file miscadmin.h.

◆ AmWalSenderProcess

#define AmWalSenderProcess ( ) (MyBackendType == B_WAL_SENDER)

Definition at line 385 of file miscadmin.h.

◆ AmWalSummarizerProcess

#define AmWalSummarizerProcess ( ) (MyBackendType == B_WAL_SUMMARIZER)

Definition at line 392 of file miscadmin.h.

◆ AmWalWriterProcess

#define AmWalWriterProcess ( ) (MyBackendType == B_WAL_WRITER)

Definition at line 393 of file miscadmin.h.

◆ BACKEND_NUM_TYPES

#define BACKEND_NUM_TYPES (B_LOGGER + 1)

Definition at line 377 of file miscadmin.h.

◆ CHECK_FOR_INTERRUPTS

#define CHECK_FOR_INTERRUPTS ( )

Value:

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

Definition at line 123 of file miscadmin.h.

◆ DATEORDER_DMY

#define DATEORDER_DMY 1

Definition at line 244 of file miscadmin.h.

◆ DATEORDER_MDY

#define DATEORDER_MDY 2

Definition at line 245 of file miscadmin.h.

◆ DATEORDER_YMD

#define DATEORDER_YMD 0

Definition at line 243 of file miscadmin.h.

◆ END_CRIT_SECTION

#define END_CRIT_SECTION ( )

Value:

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

Definition at line 152 of file miscadmin.h.

◆ GetProcessingMode

#define GetProcessingMode ( ) Mode

Definition at line 481 of file miscadmin.h.

◆ HOLD_CANCEL_INTERRUPTS

#define HOLD_CANCEL_INTERRUPTS ( ) (QueryCancelHoldoffCount++)

Definition at line 142 of file miscadmin.h.

◆ HOLD_INTERRUPTS

#define HOLD_INTERRUPTS ( ) (InterruptHoldoffCount++)

Definition at line 134 of file miscadmin.h.

◆ INIT_PG_LOAD_SESSION_LIBS

#define INIT_PG_LOAD_SESSION_LIBS 0x0001

Definition at line 499 of file miscadmin.h.

◆ INIT_PG_OVERRIDE_ALLOW_CONNS

#define INIT_PG_OVERRIDE_ALLOW_CONNS 0x0002

Definition at line 500 of file miscadmin.h.

◆ INIT_PG_OVERRIDE_ROLE_LOGIN

#define INIT_PG_OVERRIDE_ROLE_LOGIN 0x0004

Definition at line 501 of file miscadmin.h.

◆ INTERRUPTS_CAN_BE_PROCESSED

#define INTERRUPTS_CAN_BE_PROCESSED ( )

Value:

(InterruptHoldoffCount == 0 && CritSectionCount == 0 && \

QueryCancelHoldoffCount == 0)

InterruptHoldoffCount

PGDLLIMPORT volatile uint32 InterruptHoldoffCount

Definition: globals.c:44

Definition at line 130 of file miscadmin.h.

◆ INTERRUPTS_PENDING_CONDITION

#define INTERRUPTS_PENDING_CONDITION ( ) (unlikely(InterruptPending))

Definition at line 114 of file miscadmin.h.

◆ INTSTYLE_ISO_8601

#define INTSTYLE_ISO_8601 3

Definition at line 260 of file miscadmin.h.

◆ INTSTYLE_POSTGRES

#define INTSTYLE_POSTGRES 0

Definition at line 257 of file miscadmin.h.

◆ INTSTYLE_POSTGRES_VERBOSE

#define INTSTYLE_POSTGRES_VERBOSE 1

Definition at line 258 of file miscadmin.h.

◆ INTSTYLE_SQL_STANDARD

#define INTSTYLE_SQL_STANDARD 2

Definition at line 259 of file miscadmin.h.

◆ InvalidPid

#define InvalidPid (-1)

Definition at line 32 of file miscadmin.h.

◆ IsBootstrapProcessingMode

#define IsBootstrapProcessingMode ( ) (Mode == BootstrapProcessing)

Definition at line 477 of file miscadmin.h.

◆ IsExternalConnectionBackend

#define IsExternalConnectionBackend ( backend_type ) (backend_type == B_BACKEND || backend_type == B_WAL_SENDER)

Definition at line 405 of file miscadmin.h.

◆ IsInitProcessingMode

#define IsInitProcessingMode ( ) (Mode == InitProcessing)

Definition at line 478 of file miscadmin.h.

◆ IsNormalProcessingMode

#define IsNormalProcessingMode ( ) (Mode == NormalProcessing)

Definition at line 479 of file miscadmin.h.

◆ MAX_BAS_VAC_RING_SIZE_KB

#define MAX_BAS_VAC_RING_SIZE_KB (16 * 1024 * 1024)

Definition at line 279 of file miscadmin.h.

◆ MAXTZLEN

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

Definition at line 264 of file miscadmin.h.

◆ MIN_BAS_VAC_RING_SIZE_KB

#define MIN_BAS_VAC_RING_SIZE_KB 128

Definition at line 278 of file miscadmin.h.

◆ RESUME_CANCEL_INTERRUPTS

#define RESUME_CANCEL_INTERRUPTS ( )

Value:

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

Definition at line 144 of file miscadmin.h.

◆ RESUME_INTERRUPTS

#define RESUME_INTERRUPTS ( )

Value:

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

Definition at line 136 of file miscadmin.h.

◆ SECURITY_LOCAL_USERID_CHANGE

#define SECURITY_LOCAL_USERID_CHANGE 0x0001

Definition at line 318 of file miscadmin.h.

◆ SECURITY_NOFORCE_RLS

#define SECURITY_NOFORCE_RLS 0x0004

Definition at line 320 of file miscadmin.h.

◆ SECURITY_RESTRICTED_OPERATION

#define SECURITY_RESTRICTED_OPERATION 0x0002

Definition at line 319 of file miscadmin.h.

◆ SetProcessingMode

#define SetProcessingMode ( mode )

Value:

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

Definition at line 483 of file miscadmin.h.

◆ STACK_DEPTH_SLOP

#define STACK_DEPTH_SLOP (512 * 1024)

Definition at line 297 of file miscadmin.h.

◆ START_CRIT_SECTION

#define START_CRIT_SECTION ( ) (CritSectionCount++)

Definition at line 150 of file miscadmin.h.

◆ USE_GERMAN_DATES

#define USE_GERMAN_DATES 3

Definition at line 239 of file miscadmin.h.

◆ USE_ISO_DATES

#define USE_ISO_DATES 1

Definition at line 237 of file miscadmin.h.

◆ USE_POSTGRES_DATES

#define USE_POSTGRES_DATES 0

Definition at line 236 of file miscadmin.h.

◆ USE_SQL_DATES

#define USE_SQL_DATES 2

Definition at line 238 of file miscadmin.h.

◆ USE_XSD_DATES

#define USE_XSD_DATES 4

Definition at line 240 of file miscadmin.h.

Typedef Documentation

◆ BackendType

typedef enum BackendType BackendType

◆ pg_stack_base_t

typedef char* pg_stack_base_t

Definition at line 299 of file miscadmin.h.

◆ ProcessingMode

typedef enum ProcessingMode ProcessingMode

◆ shmem_request_hook_type

typedef void(* shmem_request_hook_type) (void)

Definition at line 533 of file miscadmin.h.

Enumeration Type Documentation

◆ BackendType

enum BackendType

Enumerator
B_INVALID
B_BACKEND
B_DEAD_END_BACKEND
B_AUTOVAC_LAUNCHER
B_AUTOVAC_WORKER
B_BG_WORKER
B_WAL_SENDER
B_SLOTSYNC_WORKER
B_STANDALONE_BACKEND
B_ARCHIVER
B_BG_WRITER
B_CHECKPOINTER
B_IO_WORKER
B_STARTUP
B_WAL_RECEIVER
B_WAL_SUMMARIZER
B_WAL_WRITER
B_LOGGER

Definition at line 337 of file miscadmin.h.

{
    B_INVALID = 0,
 
    /* Backends and other backend-like processes */
    B_BACKEND,
    B_DEAD_END_BACKEND,
    B_AUTOVAC_LAUNCHER,
    B_AUTOVAC_WORKER,
    B_BG_WORKER,
    B_WAL_SENDER,
    B_SLOTSYNC_WORKER,
 
    B_STANDALONE_BACKEND,
 
    /*
     * Auxiliary processes. These have PGPROC entries, but they are not
     * attached to any particular database, and cannot run transactions or
     * even take heavyweight locks. There can be only one of each of these
     * running at a time.
     *
     * If you modify these, make sure to update NUM_AUXILIARY_PROCS and the
     * glossary in the docs.
     */
    B_ARCHIVER,
    B_BG_WRITER,
    B_CHECKPOINTER,
    B_IO_WORKER,
    B_STARTUP,
    B_WAL_RECEIVER,
    B_WAL_SUMMARIZER,
    B_WAL_WRITER,
 
    /*
     * Logger is not connected to shared memory and does not have a PGPROC
     * entry.
     */
    B_LOGGER,
} BackendType;

◆ ProcessingMode

enum ProcessingMode

Enumerator
BootstrapProcessing
InitProcessing
NormalProcessing

Definition at line 468 of file miscadmin.h.

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

Function Documentation

◆ AddToDataDirLockFile()

void AddToDataDirLockFile	(	int	target_line,
		const char *	str
	)

Definition at line 1570 of file miscinit.c.

{
    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 (pg_pwrite(fd, destbuffer, len, 0) != 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)));
    }
}

References close, DIRECTORY_LOCK_FILE, ereport, errcode_for_file_access(), errmsg(), fd(), len, LOG, PG_BINARY, pg_fsync(), pg_pwrite, pgstat_report_wait_end(), pgstat_report_wait_start(), read, snprintf, and str.

Referenced by InternalIpcMemoryCreate(), PostmasterMain(), process_pm_child_exit(), process_pm_pmsignal(), and process_pm_shutdown_request().

◆ BaseInit()

void BaseInit ( void )

Definition at line 616 of file postinit.c.

{
    Assert(MyProc != NULL);
 
    /*
     * Initialize our input/output/debugging file descriptors.
     */
    DebugFileOpen();
 
    /*
     * Initialize file access. Done early so other subsystems can access
     * files.
     */
    InitFileAccess();
 
    /*
     * Initialize statistics reporting. This needs to happen early to ensure
     * that pgstat's shutdown callback runs after the shutdown callbacks of
     * all subsystems that can produce stats (like e.g. transaction commits
     * can).
     */
    pgstat_initialize();
 
    /*
     * Initialize AIO before infrastructure that might need to actually
     * execute AIO.
     */
    pgaio_init_backend();
 
    /* Do local initialization of storage and buffer managers */
    InitSync();
    smgrinit();
    InitBufferManagerAccess();
 
    /*
     * Initialize temporary file access after pgstat, so that the temporary
     * file shutdown hook can report temporary file statistics.
     */
    InitTemporaryFileAccess();
 
    /*
     * Initialize local buffers for WAL record construction, in case we ever
     * try to insert XLOG.
     */
    InitXLogInsert();
 
    /* Initialize lock manager's local structs */
    InitLockManagerAccess();
 
    /*
     * Initialize replication slots after pgstat. The exit hook might need to
     * drop ephemeral slots, which in turn triggers stats reporting.
     */
    ReplicationSlotInitialize();
 
    /*
     * The before shmem exit callback frees the DSA memory occupied by the
     * latest memory context statistics that could be published by this proc
     * if requested.
     */
    before_shmem_exit(AtProcExit_memstats_cleanup, 0);
}

References Assert(), AtProcExit_memstats_cleanup(), before_shmem_exit(), DebugFileOpen(), InitBufferManagerAccess(), InitFileAccess(), InitLockManagerAccess(), InitSync(), InitTemporaryFileAccess(), InitXLogInsert(), MyProc, pgaio_init_backend(), pgstat_initialize(), ReplicationSlotInitialize(), and smgrinit().

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), AuxiliaryProcessMainCommon(), BackgroundWorkerMain(), BootstrapModeMain(), PostgresMain(), and ReplSlotSyncWorkerMain().

◆ ChangeToDataDir()

void ChangeToDataDir ( void )

Definition at line 460 of file miscinit.c.

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

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

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ check_stack_depth()

void check_stack_depth ( void )

Definition at line 95 of file stack_depth.c.

{
    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)));
    }
}

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

Referenced by _jumbleNode(), AlterTypeRecurse(), apply_scanjoin_target_to_paths(), ATAddCheckNNConstraint(), ATExecAddColumn(), ATExecAlterConstrDeferrability(), ATExecAlterConstrEnforceability(), ATExecDropColumn(), ATExecSetNotNull(), CheckAttributeType(), checkCond(), clean_NOT_intree(), clean_stopword_intree(), cntsize(), contains_required_value(), convertJsonbValue(), copyObjectImpl(), Cover(), create_plan_recurse(), datum_to_json_internal(), datum_to_jsonb_internal(), dofindsubquery(), dropconstraint_internal(), emit_jsp_gin_entries(), equal(), eval_const_expressions_mutator(), EventTriggerInvoke(), ExecEndNode(), ExecEvalSubPlan(), ExecInitExprRec(), ExecInitNode(), ExecMakeFunctionResultSet(), ExecProcNodeFirst(), ExecShutdownNode_walker(), execute(), executeAnyItem(), executeBoolItem(), executeItemOptUnwrapTarget(), expand_partitioned_rtentry(), expression_tree_mutator_impl(), expression_tree_walker_impl(), extract_jsp_bool_expr(), fillQT(), find_composite_type_dependencies(), find_matching_subplans_recurse(), findDependentObjects(), findoprnd(), findoprnd_recurse(), flatten_grouping_sets(), flattenJsonPathParseItem(), FreePageManagerDumpBtree(), freetree(), generate_partition_qual(), generate_partitionwise_join_paths(), get_query_def(), get_rels_with_domain(), get_rule_expr(), get_setop_query(), get_steps_using_prefix_recurse(), gistSplit(), hash_range(), hash_range_extended(), hash_record(), hash_record_extended(), hk_depth_search(), infix(), inline_set_returning_function(), int_query_opr_selec(), is_simple_union_all_recurse(), JsonbDeepContains(), lseg_inside_poly(), ltree_execute(), makepol(), maketree(), MatchText(), MultiExecProcNode(), outNode(), p_ishost(), p_isURLPath(), parse_array(), parse_object(), parseNodeString(), plainnode(), planstate_tree_walker_impl(), plperl_hash_from_tuple(), plperl_sv_to_datum(), PLy_input_setup_func(), PLy_output_setup_func(), populate_array_dim_jsonb(), populate_record_field(), printJsonPathItem(), pull_up_sublinks_jointree_recurse(), pull_up_subqueries_recurse(), QT2QTN(), QTNBinary(), QTNClearFlags(), QTNCopy(), QTNFree(), QTNodeCompare(), QTNSort(), QTNTernary(), range_cmp(), range_in(), range_out(), range_recv(), range_send(), raw_expression_tree_walker_impl(), record_cmp(), record_eq(), record_in(), record_out(), record_recv(), record_send(), recurse_set_operations(), regex_selectivity_sub(), relation_is_updatable(), resolve_special_varno(), set_append_rel_size(), setPath(), split_array(), SplitToVariants(), standard_ProcessUtility(), transformExprRecurse(), transformFromClauseItem(), transformSetOperationTree(), traverse_lacons(), try_partitionwise_join(), TS_execute_locations_recurse(), TS_execute_recurse(), TS_phrase_execute(), tsquery_opr_selec(), and tsquery_requires_match().

◆ checkDataDir()

void checkDataDir ( void )

Definition at line 347 of file miscinit.c.

{
    struct stat stat_buf;
 
    Assert(DataDir);
 
    if (stat(DataDir, &stat_buf) != 0)
    {
        if (errno == ENOENT)
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("data directory \"%s\" does not exist",
                            DataDir)));
        else
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not read permissions of directory \"%s\": %m",
                            DataDir)));
    }
 
    /* eventual chdir would fail anyway, but let's test ... */
    if (!S_ISDIR(stat_buf.st_mode))
        ereport(FATAL,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("specified data directory \"%s\" is not a directory",
                        DataDir)));
 
    /*
     * Check that the directory belongs to my userid; if not, reject.
     *
     * This check is an essential part of the interlock that prevents two
     * postmasters from starting in the same directory (see CreateLockFile()).
     * Do not remove or weaken it.
     *
     * XXX can we safely enable this check on Windows?
     */
#if !defined(WIN32) && !defined(__CYGWIN__)
    if (stat_buf.st_uid != geteuid())
        ereport(FATAL,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("data directory \"%s\" has wrong ownership",
                        DataDir),
                 errhint("The server must be started by the user that owns the data directory.")));
#endif
 
    /*
     * Check if the directory has correct permissions.  If not, reject.
     *
     * Only two possible modes are allowed, 0700 and 0750.  The latter mode
     * indicates that group read/execute should be allowed on all newly
     * created files and directories.
     *
     * XXX temporarily suppress check when on Windows, because there may not
     * be proper support for Unix-y file permissions.  Need to think of a
     * reasonable check to apply on Windows.
     */
#if !defined(WIN32) && !defined(__CYGWIN__)
    if (stat_buf.st_mode & PG_MODE_MASK_GROUP)
        ereport(FATAL,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("data directory \"%s\" has invalid permissions",
                        DataDir),
                 errdetail("Permissions should be u=rwx (0700) or u=rwx,g=rx (0750).")));
#endif
 
    /*
     * Reset creation modes and mask based on the mode of the data directory.
     *
     * The mask was set earlier in startup to disallow group permissions on
     * newly created files and directories.  However, if group read/execute
     * are present on the data directory then modify the create modes and mask
     * to allow group read/execute on newly created files and directories and
     * set the data_directory_mode GUC.
     *
     * Suppress when on Windows, because there may not be proper support for
     * Unix-y file permissions.
     */
#if !defined(WIN32) && !defined(__CYGWIN__)
    SetDataDirectoryCreatePerm(stat_buf.st_mode);
 
    umask(pg_mode_mask);
    data_directory_mode = pg_dir_create_mode;
#endif
 
    /* Check for PG_VERSION */
    ValidatePgVersion(DataDir);
}

References Assert(), data_directory_mode, DataDir, ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), FATAL, pg_dir_create_mode, pg_mode_mask, PG_MODE_MASK_GROUP, S_ISDIR, SetDataDirectoryCreatePerm(), stat::st_mode, stat::st_uid, stat, and ValidatePgVersion().

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ CreateDataDirLockFile()

void CreateDataDirLockFile ( bool amPostmaster )

Definition at line 1514 of file miscinit.c.

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

References CreateLockFile(), DataDir, and DIRECTORY_LOCK_FILE.

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ CreateSocketLockFile()

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

Definition at line 1523 of file miscinit.c.

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

References CreateLockFile(), MAXPGPATH, and snprintf.

Referenced by Lock_AF_UNIX().

◆ EstimateClientConnectionInfoSpace()

Size EstimateClientConnectionInfoSpace ( void )

Definition at line 1086 of file miscinit.c.

{
    Size        size = 0;
 
    size = add_size(size, sizeof(SerializedClientConnectionInfo));
 
    if (MyClientConnectionInfo.authn_id)
        size = add_size(size, strlen(MyClientConnectionInfo.authn_id) + 1);
 
    return size;
}

References add_size(), ClientConnectionInfo::authn_id, and MyClientConnectionInfo.

Referenced by InitializeParallelDSM().

◆ get_hash_memory_limit()

size_t get_hash_memory_limit ( void )

Definition at line 3616 of file nodeHash.c.

{
    double      mem_limit;
 
    /* Do initial calculation in double arithmetic */
    mem_limit = (double) work_mem * hash_mem_multiplier * 1024.0;
 
    /* Clamp in case it doesn't fit in size_t */
    mem_limit = Min(mem_limit, (double) SIZE_MAX);
 
    return (size_t) mem_limit;
}

References hash_mem_multiplier, Min, and work_mem.

Referenced by BuildTupleHashTable(), consider_groupingsets_paths(), cost_memoize_rescan(), create_setop_path(), create_unique_path(), ExecChooseHashTableSize(), ExecInitMemoize(), ExecParallelHashIncreaseNumBatches(), final_cost_hashjoin(), hash_agg_set_limits(), hash_choose_num_partitions(), subpath_is_hashable(), and subplan_is_hashable().

◆ get_stack_depth_rlimit()

ssize_t get_stack_depth_rlimit ( void )

Definition at line 176 of file stack_depth.c.

{
#if defined(HAVE_GETRLIMIT)
    static ssize_t val = 0;
 
    /* This won't change after process launch, so check just once */
    if (val == 0)
    {
        struct rlimit rlim;
 
        if (getrlimit(RLIMIT_STACK, &rlim) < 0)
            val = -1;
        else if (rlim.rlim_cur == RLIM_INFINITY)
            val = SSIZE_MAX;
        /* rlim_cur is probably of an unsigned type, so check for overflow */
        else if (rlim.rlim_cur >= SSIZE_MAX)
            val = SSIZE_MAX;
        else
            val = rlim.rlim_cur;
    }
    return val;
#else
    /* On Windows we set the backend stack size in src/backend/Makefile */
    return WIN32_STACK_RLIMIT;
#endif
}

References val.

Referenced by check_max_stack_depth(), and InitializeGUCOptionsFromEnvironment().

◆ GetAuthenticatedUserId()

Oid GetAuthenticatedUserId ( void )

Definition at line 596 of file miscinit.c.

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

References Assert(), AuthenticatedUserId, and OidIsValid.

Referenced by check_session_authorization(), and InitializeParallelDSM().

◆ GetBackendTypeDesc()

const char * GetBackendTypeDesc ( BackendType backendType )

Definition at line 263 of file miscinit.c.

{
    const char *backendDesc = gettext_noop("unknown process type");
 
    switch (backendType)
    {
        case B_INVALID:
            backendDesc = gettext_noop("not initialized");
            break;
        case B_ARCHIVER:
            backendDesc = gettext_noop("archiver");
            break;
        case B_AUTOVAC_LAUNCHER:
            backendDesc = gettext_noop("autovacuum launcher");
            break;
        case B_AUTOVAC_WORKER:
            backendDesc = gettext_noop("autovacuum worker");
            break;
        case B_BACKEND:
            backendDesc = gettext_noop("client backend");
            break;
        case B_DEAD_END_BACKEND:
            backendDesc = gettext_noop("dead-end client backend");
            break;
        case B_BG_WORKER:
            backendDesc = gettext_noop("background worker");
            break;
        case B_BG_WRITER:
            backendDesc = gettext_noop("background writer");
            break;
        case B_CHECKPOINTER:
            backendDesc = gettext_noop("checkpointer");
            break;
        case B_IO_WORKER:
            backendDesc = gettext_noop("io worker");
            break;
        case B_LOGGER:
            backendDesc = gettext_noop("logger");
            break;
        case B_SLOTSYNC_WORKER:
            backendDesc = gettext_noop("slotsync worker");
            break;
        case B_STANDALONE_BACKEND:
            backendDesc = gettext_noop("standalone backend");
            break;
        case B_STARTUP:
            backendDesc = gettext_noop("startup");
            break;
        case B_WAL_RECEIVER:
            backendDesc = gettext_noop("walreceiver");
            break;
        case B_WAL_SENDER:
            backendDesc = gettext_noop("walsender");
            break;
        case B_WAL_SUMMARIZER:
            backendDesc = gettext_noop("walsummarizer");
            break;
        case B_WAL_WRITER:
            backendDesc = gettext_noop("walwriter");
            break;
    }
 
    return backendDesc;
}

References B_ARCHIVER, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_DEAD_END_BACKEND, B_INVALID, B_IO_WORKER, B_LOGGER, B_SLOTSYNC_WORKER, B_STANDALONE_BACKEND, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, B_WAL_SUMMARIZER, B_WAL_WRITER, and gettext_noop.

Referenced by BackendInitialize(), BackendStartup(), CleanupBackend(), CountChildren(), get_backend_type_for_log(), init_ps_display(), pg_stat_get_activity(), pg_stat_io_build_tuples(), and signal_child().

◆ GetCurrentRoleId()

Oid GetCurrentRoleId ( void )

Definition at line 986 of file miscinit.c.

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

References InvalidOid, OuterUserId, and SetRoleIsActive.

Referenced by check_role(), InitializeParallelDSM(), and show_role().

◆ GetOuterUserId()

Oid GetOuterUserId ( void )

Definition at line 531 of file miscinit.c.

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

References Assert(), OidIsValid, and OuterUserId.

Referenced by DropRole(), and RenameRole().

◆ GetSessionUserId()

Oid GetSessionUserId ( void )

Definition at line 559 of file miscinit.c.

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

References Assert(), OidIsValid, and SessionUserId.

Referenced by check_role(), check_session_authorization(), DropRole(), get_rolespec_oid(), get_rolespec_tuple(), InitializeParallelDSM(), InitPostgres(), pgstat_bestart_final(), RenameRole(), and session_user().

◆ GetSessionUserIsSuperuser()

bool GetSessionUserIsSuperuser ( void )

Definition at line 566 of file miscinit.c.

{
    Assert(OidIsValid(SessionUserId));
    return SessionUserIsSuperuser;
}

References Assert(), OidIsValid, SessionUserId, and SessionUserIsSuperuser.

Referenced by check_session_authorization(), and InitializeParallelDSM().

◆ GetSystemUser()

const char * GetSystemUser ( void )

Definition at line 586 of file miscinit.c.

{
    return SystemUser;
}

References SystemUser.

Referenced by system_user().

◆ GetUserId()

Oid GetUserId ( void )

Definition at line 520 of file miscinit.c.

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

References Assert(), CurrentUserId, and OidIsValid.

◆ GetUserIdAndContext()

void GetUserIdAndContext	(	Oid *	userid,
		bool *	sec_def_context
	)

Definition at line 712 of file miscinit.c.

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

References CurrentUserId, and InLocalUserIdChange().

◆ GetUserIdAndSecContext()

void GetUserIdAndSecContext	(	Oid *	userid,
		int *	sec_context
	)

Definition at line 663 of file miscinit.c.

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

References CurrentUserId, and SecurityRestrictionContext.

Referenced by AfterTriggerExecute(), amcheck_lock_relation_and_check(), brin_summarize_range(), cluster_rel(), ComputeIndexAttrs(), CreateSchemaCommand(), DefineIndex(), do_analyze_rel(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), InitializeParallelDSM(), PushTransaction(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), ri_PerformCheck(), ri_PlanCheck(), StartTransaction(), SwitchToUntrustedUser(), vacuum_rel(), and validate_index().

◆ GetUserNameFromId()

char * GetUserNameFromId	(	Oid	roleid,
		bool	noerr
	)

Definition at line 1039 of file miscinit.c.

{
    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;
}

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

Referenced by AddRoleMems(), check_can_set_role(), check_object_ownership(), check_role_grantor(), check_role_membership_authorization(), current_user(), DelRoleMems(), DropOwnedObjects(), execute_extension_script(), getObjectDescription(), getObjectIdentityParts(), insert_username(), LogicalRepSyncTableStart(), ReassignOwnedObjects(), regroleout(), session_user(), SwitchToUntrustedUser(), and TargetPrivilegesCheck().

◆ has_rolreplication()

bool has_rolreplication ( Oid roleid )

Definition at line 739 of file miscinit.c.

{
    bool        result = false;
    HeapTuple   utup;
 
    /* Superusers bypass all permission checking. */
    if (superuser_arg(roleid))
        return true;
 
    utup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
    if (HeapTupleIsValid(utup))
    {
        result = ((Form_pg_authid) GETSTRUCT(utup))->rolreplication;
        ReleaseSysCache(utup);
    }
    return result;
}

References GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), rolreplication, SearchSysCache1(), and superuser_arg().

Referenced by AlterRole(), binary_upgrade_logical_slot_has_caught_up(), CheckSlotPermissions(), CreateRole(), and InitPostgres().

◆ InitializeFastPathLocks()

void InitializeFastPathLocks ( void )

Definition at line 587 of file postinit.c.

{
    /* Should be initialized only once. */
    Assert(FastPathLockGroupsPerBackend == 0);
 
    /* we need at least one group */
    FastPathLockGroupsPerBackend = 1;
 
    while (FastPathLockGroupsPerBackend < FP_LOCK_GROUPS_PER_BACKEND_MAX)
    {
        /* stop once we exceed max_locks_per_xact */
        if (FastPathLockSlotsPerBackend() >= max_locks_per_xact)
            break;
 
        FastPathLockGroupsPerBackend *= 2;
    }
 
    Assert(FastPathLockGroupsPerBackend <= FP_LOCK_GROUPS_PER_BACKEND_MAX);
}

References Assert(), FastPathLockGroupsPerBackend, FastPathLockSlotsPerBackend, FP_LOCK_GROUPS_PER_BACKEND_MAX, and max_locks_per_xact.

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ InitializeMaxBackends()

void InitializeMaxBackends ( void )

Definition at line 555 of file postinit.c.

{
    Assert(MaxBackends == 0);
 
    /* Note that this does not include "auxiliary" processes */
    MaxBackends = MaxConnections + autovacuum_worker_slots +
        max_worker_processes + max_wal_senders + NUM_SPECIAL_WORKER_PROCS;
 
    if (MaxBackends > MAX_BACKENDS)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("too many server processes configured"),
                 errdetail("\"max_connections\" (%d) plus \"autovacuum_worker_slots\" (%d) plus \"max_worker_processes\" (%d) plus \"max_wal_senders\" (%d) must be less than %d.",
                           MaxConnections, autovacuum_worker_slots,
                           max_worker_processes, max_wal_senders,
                           MAX_BACKENDS - (NUM_SPECIAL_WORKER_PROCS - 1))));
}

References Assert(), autovacuum_worker_slots, ereport, errcode(), errdetail(), errmsg(), ERROR, MAX_BACKENDS, max_wal_senders, max_worker_processes, MaxBackends, MaxConnections, and NUM_SPECIAL_WORKER_PROCS.

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ InitializeSessionUserId()

void InitializeSessionUserId	(	const char *	rolename,
		Oid	roleid,
		bool	bypass_login_check
	)

Definition at line 761 of file miscinit.c.

{
    HeapTuple   roleTup;
    Form_pg_authid rform;
    char       *rname;
    bool        is_superuser;
 
    /*
     * In a parallel worker, we don't have to do anything here.
     * ParallelWorkerMain already set our output variables, and we aren't
     * going to enforce either rolcanlogin or rolconnlimit.  Furthermore, we
     * don't really want to perform a catalog lookup for the role: we don't
     * want to fail if it's been dropped.
     */
    if (InitializingParallelWorker)
    {
        Assert(bypass_login_check);
        return;
    }
 
    /*
     * Don't do scans if we're bootstrapping, none of the system catalogs
     * exist yet, and they should be owned by postgres anyway.
     */
    Assert(!IsBootstrapProcessingMode());
 
    /*
     * Make sure syscache entries are flushed for recent catalog changes. This
     * allows us to find roles that were created on-the-fly during
     * authentication.
     */
    AcceptInvalidationMessages();
 
    /*
     * Look up the role, either by name if that's given or by OID if not.
     */
    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 = rform->oid;
    rname = NameStr(rform->rolname);
    is_superuser = rform->rolsuper;
 
    SetAuthenticatedUserId(roleid);
 
    /*
     * Set SessionUserId and related variables, including "role", via the GUC
     * mechanisms.
     *
     * Note: ideally we would use PGC_S_DYNAMIC_DEFAULT here, so that
     * session_authorization could subsequently be changed from
     * pg_db_role_setting entries.  Instead, session_authorization in
     * pg_db_role_setting has no effect.  Changing that would require solving
     * two problems:
     *
     * 1. If pg_db_role_setting has values for both session_authorization and
     * role, we could not be sure which order those would be applied in, and
     * it would matter.
     *
     * 2. Sites may have years-old session_authorization entries.  There's not
     * been any particular reason to remove them.  Ending the dormancy of
     * those entries could seriously change application behavior, so only a
     * major release should do that.
     */
    SetConfigOption("session_authorization", rname,
                    PGC_BACKEND, PGC_S_OVERRIDE);
 
    /*
     * 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?  (But background workers can
         * override this by setting bypass_login_check.)
         */
        if (!bypass_login_check && !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.  We enforce the limit only
         * for regular backends, since other process types have their own
         * PGPROC pools.
         *
         * 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 &&
            AmRegularBackendProcess() &&
            !is_superuser &&
            CountUserBackends(roleid) > rform->rolconnlimit)
            ereport(FATAL,
                    (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
                     errmsg("too many connections for role \"%s\"",
                            rname)));
    }
 
    ReleaseSysCache(roleTup);
}

References AcceptInvalidationMessages(), AmRegularBackendProcess, Assert(), CountUserBackends(), ereport, errcode(), errmsg(), FATAL, GETSTRUCT(), HeapTupleIsValid, InitializingParallelWorker, is_superuser(), IsBootstrapProcessingMode, IsUnderPostmaster, NameStr, ObjectIdGetDatum(), PGC_BACKEND, PGC_S_OVERRIDE, PointerGetDatum(), ReleaseSysCache(), SearchSysCache1(), SetAuthenticatedUserId(), and SetConfigOption().

Referenced by InitPostgres().

◆ InitializeSessionUserIdStandalone()

void InitializeSessionUserIdStandalone ( void )

Definition at line 891 of file miscinit.c.

{
    /*
     * This function should only be called in single-user mode, in autovacuum
     * workers, in slot sync worker and in background workers.
     */
    Assert(!IsUnderPostmaster || AmAutoVacuumWorkerProcess() ||
           AmLogicalSlotSyncWorkerProcess() || AmBackgroundWorkerProcess());
 
    /* call only once */
    Assert(!OidIsValid(AuthenticatedUserId));
 
    AuthenticatedUserId = BOOTSTRAP_SUPERUSERID;
 
    /*
     * XXX Ideally we'd do this via SetConfigOption("session_authorization"),
     * but we lack the role name needed to do that, and we can't fetch it
     * because one reason for this special case is to be able to start up even
     * if something's happened to the BOOTSTRAP_SUPERUSERID's pg_authid row.
     * Since we don't set the GUC itself, C code will see the value as NULL,
     * and current_setting() will report an empty string within this session.
     */
    SetSessionAuthorization(BOOTSTRAP_SUPERUSERID, true);
 
    /* We could do SetConfigOption("role"), but let's be consistent */
    SetCurrentRoleId(InvalidOid, false);
}

References AmAutoVacuumWorkerProcess, AmBackgroundWorkerProcess, AmLogicalSlotSyncWorkerProcess, Assert(), AuthenticatedUserId, InvalidOid, IsUnderPostmaster, OidIsValid, SetCurrentRoleId(), and SetSessionAuthorization().

Referenced by InitPostgres().

◆ InitializeSystemUser()

void InitializeSystemUser	(	const char *	authn_id,
		const char *	auth_method
	)

Definition at line 925 of file miscinit.c.

{
    char       *system_user;
 
    /* call only once */
    Assert(SystemUser == NULL);
 
    /*
     * InitializeSystemUser should be called only when authn_id is not NULL,
     * meaning that auth_method is valid.
     */
    Assert(authn_id != NULL);
 
    system_user = psprintf("%s:%s", auth_method, authn_id);
 
    /* Store SystemUser in long-lived storage */
    SystemUser = MemoryContextStrdup(TopMemoryContext, system_user);
    pfree(system_user);
}

References Assert(), authn_id, MemoryContextStrdup(), pfree(), psprintf(), system_user(), SystemUser, and TopMemoryContext.

Referenced by InitPostgres(), and ParallelWorkerMain().

◆ InitPostgres()

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

Definition at line 723 of file postinit.c.

{
    bool        bootstrap = IsBootstrapProcessingMode();
    bool        am_superuser;
    char       *fullpath;
    char        dbname[NAMEDATALEN];
    int         nfree = 0;
 
    elog(DEBUG3, "InitPostgres");
 
    /*
     * Add my PGPROC struct to the ProcArray.
     *
     * Once I have done this, I am visible to other backends!
     */
    InitProcessPhase2();
 
    /* Initialize status reporting */
    pgstat_beinit();
 
    /*
     * And initialize an entry in the PgBackendStatus array.  That way, if
     * LWLocks or third-party authentication should happen to hang, it is
     * possible to retrieve some information about what is going on.
     */
    if (!bootstrap)
    {
        pgstat_bestart_initial();
        INJECTION_POINT("init-pre-auth");
    }
 
    /*
     * Initialize my entry in the shared-invalidation manager's array of
     * per-backend data.
     */
    SharedInvalBackendInit(false);
 
    ProcSignalInit(MyCancelKey, MyCancelKeyLength);
 
    /*
     * 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);
        RegisterTimeout(TRANSACTION_TIMEOUT, TransactionTimeoutHandler);
        RegisterTimeout(IDLE_SESSION_TIMEOUT, IdleSessionTimeoutHandler);
        RegisterTimeout(CLIENT_CONNECTION_CHECK_TIMEOUT, ClientCheckTimeoutHandler);
        RegisterTimeout(IDLE_STATS_UPDATE_TIMEOUT,
                        IdleStatsUpdateTimeoutHandler);
    }
 
    /*
     * If this is either a bootstrap process or a standalone backend, start up
     * the XLOG machinery, and register to have it closed down at exit. In
     * other cases, the startup process is responsible for starting up the
     * XLOG machinery, and the checkpointer for closing it down.
     */
    if (!IsUnderPostmaster)
    {
        /*
         * We don't yet have an aux-process resource owner, but StartupXLOG
         * and ShutdownXLOG will need one.  Hence, create said resource owner
         * (and register a callback to clean it up after ShutdownXLOG runs).
         */
        CreateAuxProcessResourceOwner();
 
        StartupXLOG();
        /* Release (and warn about) any buffer pins leaked in StartupXLOG */
        ReleaseAuxProcessResources(true);
        /* Reset CurrentResourceOwner to nothing for the moment */
        CurrentResourceOwner = NULL;
 
        /*
         * Use before_shmem_exit() so that ShutdownXLOG() can rely on DSM
         * segments etc to work (which in turn is required for pgstats).
         */
        before_shmem_exit(pgstat_before_server_shutdown, 0);
        before_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();
 
    /*
     * 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
     * one of the first before_shmem_exit callbacks we register; thus, this
     * will be one the last things 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 (AmAutoVacuumLauncherProcess())
    {
        /* fill in the remainder of this entry in the PgBackendStatus array */
        pgstat_bestart_final();
 
        return;
    }
 
    /*
     * Start a new transaction here before first access to db.
     */
    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;
    }
 
    /*
     * Perform client authentication if necessary, then figure out our
     * postgres user ID, and see if we are a superuser.
     *
     * In standalone mode, autovacuum worker processes and slot sync worker
     * process, we use a fixed ID, otherwise we figure it out from the
     * authenticated user name.
     */
    if (bootstrap || AmAutoVacuumWorkerProcess() || AmLogicalSlotSyncWorkerProcess())
    {
        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 (AmBackgroundWorkerProcess())
    {
        if (username == NULL && !OidIsValid(useroid))
        {
            InitializeSessionUserIdStandalone();
            am_superuser = true;
        }
        else
        {
            InitializeSessionUserId(username, useroid,
                                    (flags & INIT_PG_OVERRIDE_ROLE_LOGIN) != 0);
            am_superuser = superuser();
        }
    }
    else
    {
        /* normal multiuser case */
        Assert(MyProcPort != NULL);
        PerformAuthentication(MyProcPort);
        InitializeSessionUserId(username, useroid, false);
        /* ensure that auth_method is actually valid, aka authn_id is not NULL */
        if (MyClientConnectionInfo.authn_id)
            InitializeSystemUser(MyClientConnectionInfo.authn_id,
                                 hba_authname(MyClientConnectionInfo.auth_method));
        am_superuser = superuser();
    }
 
    /* Report any SSL/GSS details for the session. */
    if (MyProcPort != NULL)
    {
        Assert(!bootstrap);
 
        pgstat_bestart_security();
    }
 
    /*
     * 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 regular connection slots are reserved for superusers and
     * roles with privileges of pg_use_reserved_connections.  We do not apply
     * these limits to background processes, since they all have their own
     * pools of PGPROC slots.
     *
     * Note: At this point, the new backend has already claimed a proc struct,
     * so we must check whether the number of free slots is strictly less than
     * the reserved connection limits.
     */
    if (AmRegularBackendProcess() && !am_superuser &&
        (SuperuserReservedConnections + ReservedConnections) > 0 &&
        !HaveNFreeProcs(SuperuserReservedConnections + ReservedConnections, &nfree))
    {
        if (nfree < SuperuserReservedConnections)
            ereport(FATAL,
                    (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
                     errmsg("remaining connection slots are reserved for roles with the %s attribute",
                            "SUPERUSER")));
 
        if (!has_privs_of_role(GetUserId(), ROLE_PG_USE_RESERVED_CONNECTIONS))
            ereport(FATAL,
                    (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
                     errmsg("remaining connection slots are reserved for roles with privileges of the \"%s\" role",
                            "pg_use_reserved_connections")));
    }
 
    /* Check replication permissions needed for walsender processes. */
    if (am_walsender)
    {
        Assert(!bootstrap);
 
        if (!has_rolreplication(GetUserId()))
            ereport(FATAL,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("permission denied to start WAL sender"),
                     errdetail("Only roles with the %s attribute may start a WAL sender process.",
                               "REPLICATION")));
    }
 
    /*
     * 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();
 
        /* fill in the remainder of this entry in the PgBackendStatus array */
        pgstat_bestart_final();
 
        /* 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)
    {
        dboid = Template1DbOid;
        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);
        dboid = dbform->oid;
    }
    else if (!OidIsValid(dboid))
    {
        /*
         * 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_final();
            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, dboid, 0, RowExclusiveLock);
 
    /*
     * 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;
        Form_pg_database datform;
 
        tuple = GetDatabaseTupleByOid(dboid);
        if (HeapTupleIsValid(tuple))
            datform = (Form_pg_database) GETSTRUCT(tuple);
 
        if (!HeapTupleIsValid(tuple) ||
            (in_dbname && namestrcmp(&datform->datname, in_dbname)))
        {
            if (in_dbname)
                ereport(FATAL,
                        (errcode(ERRCODE_UNDEFINED_DATABASE),
                         errmsg("database \"%s\" does not exist", in_dbname),
                         errdetail("It seems to have just been dropped or renamed.")));
            else
                ereport(FATAL,
                        (errcode(ERRCODE_UNDEFINED_DATABASE),
                         errmsg("database %u does not exist", dboid)));
        }
 
        strlcpy(dbname, NameStr(datform->datname), sizeof(dbname));
 
        if (database_is_invalid_form(datform))
        {
            ereport(FATAL,
                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                    errmsg("cannot connect to invalid database \"%s\"", dbname),
                    errhint("Use DROP DATABASE to drop invalid databases."));
        }
 
        MyDatabaseTableSpace = datform->dattablespace;
        MyDatabaseHasLoginEventTriggers = datform->dathasloginevt;
        /* pass the database name back to the caller */
        if (out_dbname)
            strcpy(out_dbname, dbname);
    }
 
    /*
     * Now that we rechecked, we are certain to be connected to a database and
     * thus can set MyDatabaseId.
     *
     * It is important that MyDatabaseId only be set once we are sure that the
     * target database can no longer be concurrently dropped or renamed.  For
     * example, without this guarantee, pgstat_update_dbstats() could create
     * entries for databases that were just dropped in the pgstat shutdown
     * callback, which could confuse other code paths like the autovacuum
     * scheduler.
     */
    MyDatabaseId = dboid;
 
    /*
     * 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();
 
    /*
     * 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);
    pfree(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,
                        (flags & INIT_PG_OVERRIDE_ALLOW_CONNS) != 0);
 
    /*
     * 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();
 
    /* Initialize this backend's session state. */
    InitializeSession();
 
    /*
     * If this is an interactive session, load any libraries that should be
     * preloaded at backend start.  Since those are determined by GUCs, this
     * can't happen until GUC settings are complete, but we want it to happen
     * during the initial transaction in case anything that requires database
     * access needs to be done.
     */
    if ((flags & INIT_PG_LOAD_SESSION_LIBS) != 0)
        process_session_preload_libraries();
 
    /* fill in the remainder of this entry in the PgBackendStatus array */
    if (!bootstrap)
        pgstat_bestart_final();
 
    /* close the transaction we started above */
    if (!bootstrap)
        CommitTransactionCommand();
}

References am_db_walsender, am_walsender, AmAutoVacuumLauncherProcess, AmAutoVacuumWorkerProcess, AmBackgroundWorkerProcess, AmLogicalSlotSyncWorkerProcess, AmRegularBackendProcess, Assert(), ClientConnectionInfo::auth_method, ClientConnectionInfo::authn_id, before_shmem_exit(), CheckDeadLockAlert(), CheckMyDatabase(), CLIENT_CONNECTION_CHECK_TIMEOUT, ClientCheckTimeoutHandler(), CommitTransactionCommand(), CreateAuxProcessResourceOwner(), CurrentResourceOwner, database_is_invalid_form(), PGPROC::databaseId, dbname, DEADLOCK_TIMEOUT, DEBUG3, elog, EnablePortalManager(), ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), FATAL, GetDatabasePath(), GetDatabaseTuple(), GetDatabaseTupleByOid(), GetSessionUserId(), GETSTRUCT(), GetUserId(), has_privs_of_role(), has_rolreplication(), HaveNFreeProcs(), hba_authname(), HeapTupleIsValid, IDLE_IN_TRANSACTION_SESSION_TIMEOUT, IDLE_SESSION_TIMEOUT, IDLE_STATS_UPDATE_TIMEOUT, IdleInTransactionSessionTimeoutHandler(), IdleSessionTimeoutHandler(), IdleStatsUpdateTimeoutHandler(), INIT_PG_LOAD_SESSION_LIBS, INIT_PG_OVERRIDE_ALLOW_CONNS, INIT_PG_OVERRIDE_ROLE_LOGIN, InitCatalogCache(), initialize_acl(), InitializeClientEncoding(), InitializeSearchPath(), InitializeSession(), InitializeSessionUserId(), InitializeSessionUserIdStandalone(), InitializeSystemUser(), InitPlanCache(), InitProcessPhase2(), INJECTION_POINT, InvalidateCatalogSnapshot(), IsBinaryUpgrade, IsBootstrapProcessingMode, IsUnderPostmaster, LOCK_TIMEOUT, LockSharedObject(), LockTimeoutHandler(), MyCancelKey, MyCancelKeyLength, MyClientConnectionInfo, MyDatabaseHasLoginEventTriggers, MyDatabaseId, MyDatabaseTableSpace, MyProc, MyProcPort, NAMEDATALEN, NameStr, namestrcmp(), OidIsValid, PerformAuthentication(), pfree(), pg_usleep(), pgstat_before_server_shutdown(), pgstat_beinit(), pgstat_bestart_final(), pgstat_bestart_initial(), pgstat_bestart_security(), PostAuthDelay, process_session_preload_libraries(), process_settings(), process_startup_options(), ProcSignalInit(), RegisterTimeout(), RelationCacheInitialize(), RelationCacheInitializePhase2(), RelationCacheInitializePhase3(), ReleaseAuxProcessResources(), ReservedConnections, RowExclusiveLock, SetCurrentStatementStartTimestamp(), SetDatabasePath(), SharedInvalBackendInit(), ShutdownPostgres(), ShutdownXLOG(), StartTransactionCommand(), StartupXLOG(), STATEMENT_TIMEOUT, StatementTimeoutHandler(), strlcpy(), superuser(), SuperuserReservedConnections, ThereIsAtLeastOneRole(), TRANSACTION_TIMEOUT, TransactionTimeoutHandler(), username, ValidatePgVersion(), WARNING, XACT_READ_COMMITTED, and XactIsoLevel.

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

◆ InitPostmasterChild()

void InitPostmasterChild ( void )

Definition at line 96 of file miscinit.c.

{
    IsUnderPostmaster = true;   /* we are a postmaster subprocess now */
 
    /*
     * Start our win32 signal implementation. This has to be done after we
     * read the backend variables, because we need to pick up the signal pipe
     * from the parent process.
     */
#ifdef WIN32
    pgwin32_signal_initialize();
#endif
 
    InitProcessGlobals();
 
    /*
     * 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();
 
    /* In EXEC_BACKEND case we will not have inherited BlockSig etc values */
#ifdef EXEC_BACKEND
    pqinitmask();
#endif
 
    /* Initialize process-local latch support */
    InitializeWaitEventSupport();
    InitProcessLocalLatch();
    InitializeLatchWaitSet();
 
    /*
     * 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
 
    /*
     * Every postmaster child process is expected to respond promptly to
     * SIGQUIT at all times.  Therefore we centrally remove SIGQUIT from
     * BlockSig and install a suitable signal handler.  (Client-facing
     * processes may choose to replace this default choice of handler with
     * quickdie().)  All other blockable signals remain blocked for now.
     */
    pqsignal(SIGQUIT, SignalHandlerForCrashExit);
 
    sigdelset(&BlockSig, SIGQUIT);
    sigprocmask(SIG_SETMASK, &BlockSig, NULL);
 
    /* Request a signal if the postmaster dies, if possible. */
    PostmasterDeathSignalInit();
 
    /* Don't give the pipe to subprograms that we execute. */
#ifndef WIN32
    if (fcntl(postmaster_alive_fds[POSTMASTER_FD_WATCH], F_SETFD, FD_CLOEXEC) < 0)
        ereport(FATAL,
                (errcode_for_socket_access(),
                 errmsg_internal("could not set postmaster death monitoring pipe to FD_CLOEXEC mode: %m")));
#endif
}

References BlockSig, elog, ereport, errcode_for_socket_access(), errmsg_internal(), FATAL, InitializeLatchWaitSet(), InitializeWaitEventSupport(), InitProcessGlobals(), InitProcessLocalLatch(), IsUnderPostmaster, on_exit_reset(), pgwin32_signal_initialize(), postmaster_alive_fds, POSTMASTER_FD_WATCH, PostmasterDeathSignalInit(), pqinitmask(), pqsignal, SignalHandlerForCrashExit(), and SIGQUIT.

Referenced by postmaster_child_launch().

◆ InitProcessLocalLatch()

void InitProcessLocalLatch ( void )

Definition at line 235 of file miscinit.c.

{
    MyLatch = &LocalLatchData;
    InitLatch(MyLatch);
}

References InitLatch(), LocalLatchData, and MyLatch.

Referenced by InitPostmasterChild(), InitStandaloneProcess(), and PostmasterMain().

◆ InitStandaloneProcess()

void InitStandaloneProcess ( const char * argv0 )

Definition at line 175 of file miscinit.c.

{
    Assert(!IsPostmasterEnvironment);
 
    MyBackendType = B_STANDALONE_BACKEND;
 
    /*
     * Start our win32 signal implementation
     */
#ifdef WIN32
    pgwin32_signal_initialize();
#endif
 
    InitProcessGlobals();
 
    /* Initialize process-local latch support */
    InitializeWaitEventSupport();
    InitProcessLocalLatch();
    InitializeLatchWaitSet();
 
    /*
     * For consistency with InitPostmasterChild, initialize signal mask here.
     * But we don't unblock SIGQUIT or provide a default handler for it.
     */
    pqinitmask();
    sigprocmask(SIG_SETMASK, &BlockSig, NULL);
 
    /* 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);
}

References argv0, Assert(), B_STANDALONE_BACKEND, BlockSig, elog, FATAL, find_my_exec(), get_pkglib_path(), InitializeLatchWaitSet(), InitializeWaitEventSupport(), InitProcessGlobals(), InitProcessLocalLatch(), IsPostmasterEnvironment, my_exec_path, MyBackendType, pgwin32_signal_initialize(), pkglib_path, and pqinitmask().

Referenced by BootstrapModeMain(), and PostgresSingleUserMain().

◆ InLocalUserIdChange()

bool InLocalUserIdChange ( void )

Definition at line 681 of file miscinit.c.

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

References SECURITY_LOCAL_USERID_CHANGE, and SecurityRestrictionContext.

Referenced by GetUserIdAndContext(), and set_config_with_handle().

◆ InNoForceRLSOperation()

bool InNoForceRLSOperation ( void )

Definition at line 699 of file miscinit.c.

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

References SECURITY_NOFORCE_RLS, and SecurityRestrictionContext.

Referenced by check_enable_rls().

◆ InSecurityRestrictedOperation()

bool InSecurityRestrictedOperation ( void )

Definition at line 690 of file miscinit.c.

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

References SECURITY_RESTRICTED_OPERATION, and SecurityRestrictionContext.

Referenced by afterTriggerMarkEvents(), CheckRestrictedOperation(), DefineRelation(), PerformCursorOpen(), set_config_with_handle(), and SetUserIdAndContext().

◆ pg_bindtextdomain()

void pg_bindtextdomain ( const char * domain )

Definition at line 1939 of file miscinit.c.

{
#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
}

References get_locale_path(), MAXPGPATH, and my_exec_path.

Referenced by _PG_init().

◆ pg_split_opts()

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

Definition at line 497 of file postinit.c.

{
    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);
}

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

Referenced by process_startup_options().

◆ PreventCommandDuringRecovery()

void PreventCommandDuringRecovery ( const char * cmdname )

Definition at line 441 of file utility.c.

{
    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)));
}

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

Referenced by pg_current_xact_id(), pg_notify(), and standard_ProcessUtility().

◆ PreventCommandIfParallelMode()

void PreventCommandIfParallelMode ( const char * cmdname )

Definition at line 422 of file utility.c.

{
    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)));
}

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

Referenced by do_setval(), ExecCheckXactReadOnly(), nextval_internal(), and standard_ProcessUtility().

◆ PreventCommandIfReadOnly()

void PreventCommandIfReadOnly ( const char * cmdname )

Definition at line 404 of file utility.c.

{
    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)));
}

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

Referenced by be_lo_creat(), be_lo_create(), be_lo_from_bytea(), be_lo_open(), be_lo_put(), be_lo_truncate(), be_lo_truncate64(), be_lo_unlink(), be_lowrite(), do_setval(), DoCopy(), ExecCheckXactReadOnly(), lo_import_internal(), nextval_internal(), and standard_ProcessUtility().

◆ process_session_preload_libraries()

void process_session_preload_libraries ( void )

Definition at line 1916 of file miscinit.c.

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

References load_libraries(), local_preload_libraries_string, and session_preload_libraries_string.

Referenced by InitPostgres().

◆ process_shared_preload_libraries()

void process_shared_preload_libraries ( void )

Definition at line 1902 of file miscinit.c.

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

References load_libraries(), process_shared_preload_libraries_done, process_shared_preload_libraries_in_progress, and shared_preload_libraries_string.

Referenced by PostgresSingleUserMain(), and PostmasterMain().

◆ process_shmem_requests()

void process_shmem_requests ( void )

Definition at line 1930 of file miscinit.c.

{
    process_shmem_requests_in_progress = true;
    if (shmem_request_hook)
        shmem_request_hook();
    process_shmem_requests_in_progress = false;
}

References process_shmem_requests_in_progress, and shmem_request_hook.

Referenced by PostgresSingleUserMain(), and PostmasterMain().

◆ ProcessInterrupts()

void ProcessInterrupts ( void )

Definition at line 3300 of file postgres.c.

{
    /* 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 (AmAutoVacuumWorkerProcess())
            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_internal("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 (AmWalReceiverProcess())
            ereport(FATAL,
                    (errcode(ERRCODE_ADMIN_SHUTDOWN),
                     errmsg("terminating walreceiver process due to administrator command")));
        else if (AmBackgroundWorkerProcess())
            ereport(FATAL,
                    (errcode(ERRCODE_ADMIN_SHUTDOWN),
                     errmsg("terminating background worker \"%s\" due to administrator command",
                            MyBgworkerEntry->bgw_type)));
        else if (AmIoWorkerProcess())
        {
            ereport(DEBUG1,
                    (errmsg_internal("io worker shutting down due to administrator command")));
 
            proc_exit(0);
        }
        else
            ereport(FATAL,
                    (errcode(ERRCODE_ADMIN_SHUTDOWN),
                     errmsg("terminating connection due to administrator command")));
    }
 
    if (CheckClientConnectionPending)
    {
        CheckClientConnectionPending = false;
 
        /*
         * Check for lost connection and re-arm, if still configured, but not
         * if we've arrived back at DoingCommandRead state.  We don't want to
         * wake up idle sessions, and they already know how to detect lost
         * connections.
         */
        if (!DoingCommandRead && client_connection_check_interval > 0)
        {
            if (!pq_check_connection())
                ClientConnectionLost = true;
            else
                enable_timeout_after(CLIENT_CONNECTION_CHECK_TIMEOUT,
                                     client_connection_check_interval);
        }
    }
 
    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")));
    }
 
    /*
     * 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.)
     *
     * See similar logic in ProcessRecoveryConflictInterrupts().
     */
    if (QueryCancelPending && QueryCancelHoldoffCount != 0)
    {
        /*
         * Re-arm InterruptPending so that we process the cancel request as
         * soon as we're done reading the message.  (XXX this is seriously
         * ugly: it complicates INTERRUPTS_CAN_BE_PROCESSED(), and it means we
         * can't use that macro directly as the initial test in this function,
         * meaning that this code also creates opportunities for other bugs to
         * appear.)
         */
        InterruptPending = true;
    }
    else if (QueryCancelPending)
    {
        bool        lock_timeout_occurred;
        bool        stmt_timeout_occurred;
 
        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 (AmAutoVacuumWorkerProcess())
        {
            LockErrorCleanup();
            ereport(ERROR,
                    (errcode(ERRCODE_QUERY_CANCELED),
                     errmsg("canceling autovacuum task")));
        }
 
        /*
         * 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 (RecoveryConflictPending)
        ProcessRecoveryConflictInterrupts();
 
    if (IdleInTransactionSessionTimeoutPending)
    {
        /*
         * If the GUC has been reset to zero, ignore the signal.  This is
         * important because the GUC update itself won't disable any pending
         * interrupt.  We need to unset the flag before the injection point,
         * otherwise we could loop in interrupts checking.
         */
        IdleInTransactionSessionTimeoutPending = false;
        if (IdleInTransactionSessionTimeout > 0)
        {
            INJECTION_POINT("idle-in-transaction-session-timeout");
            ereport(FATAL,
                    (errcode(ERRCODE_IDLE_IN_TRANSACTION_SESSION_TIMEOUT),
                     errmsg("terminating connection due to idle-in-transaction timeout")));
        }
    }
 
    if (TransactionTimeoutPending)
    {
        /* As above, ignore the signal if the GUC has been reset to zero. */
        TransactionTimeoutPending = false;
        if (TransactionTimeout > 0)
        {
            INJECTION_POINT("transaction-timeout");
            ereport(FATAL,
                    (errcode(ERRCODE_TRANSACTION_TIMEOUT),
                     errmsg("terminating connection due to transaction timeout")));
        }
    }
 
    if (IdleSessionTimeoutPending)
    {
        /* As above, ignore the signal if the GUC has been reset to zero. */
        IdleSessionTimeoutPending = false;
        if (IdleSessionTimeout > 0)
        {
            INJECTION_POINT("idle-session-timeout");
            ereport(FATAL,
                    (errcode(ERRCODE_IDLE_SESSION_TIMEOUT),
                     errmsg("terminating connection due to idle-session timeout")));
        }
    }
 
    /*
     * If there are pending stats updates and we currently are truly idle
     * (matching the conditions in PostgresMain(), report stats now.
     */
    if (IdleStatsUpdateTimeoutPending &&
        DoingCommandRead && !IsTransactionOrTransactionBlock())
    {
        IdleStatsUpdateTimeoutPending = false;
        pgstat_report_stat(true);
    }
 
    if (ProcSignalBarrierPending)
        ProcessProcSignalBarrier();
 
    if (ParallelMessagePending)
        ProcessParallelMessages();
 
    if (LogMemoryContextPending)
        ProcessLogMemoryContextInterrupt();
 
    if (PublishMemoryContextPending)
        ProcessGetMemoryContextInterrupt();
 
    if (ParallelApplyMessagePending)
        ProcessParallelApplyMessages();
}

References AmAutoVacuumWorkerProcess, AmBackgroundWorkerProcess, AmIoWorkerProcess, AmWalReceiverProcess, BackgroundWorker::bgw_type, CheckClientConnectionPending, client_connection_check_interval, CLIENT_CONNECTION_CHECK_TIMEOUT, ClientAuthInProgress, ClientConnectionLost, CritSectionCount, DEBUG1, DestNone, DestRemote, DoingCommandRead, enable_timeout_after(), ereport, errcode(), errmsg(), errmsg_internal(), ERROR, FATAL, get_timeout_finish_time(), get_timeout_indicator(), IdleInTransactionSessionTimeout, IdleInTransactionSessionTimeoutPending, IdleSessionTimeout, IdleSessionTimeoutPending, IdleStatsUpdateTimeoutPending, INJECTION_POINT, InterruptHoldoffCount, InterruptPending, IsLogicalLauncher(), IsLogicalWorker(), IsTransactionOrTransactionBlock(), LOCK_TIMEOUT, LockErrorCleanup(), LogMemoryContextPending, MyBgworkerEntry, ParallelApplyMessagePending, ParallelMessagePending, pgstat_report_stat(), pq_check_connection(), proc_exit(), ProcDiePending, ProcessGetMemoryContextInterrupt(), ProcessLogMemoryContextInterrupt(), ProcessParallelApplyMessages(), ProcessParallelMessages(), ProcessProcSignalBarrier(), ProcessRecoveryConflictInterrupts(), ProcSignalBarrierPending, PublishMemoryContextPending, QueryCancelHoldoffCount, QueryCancelPending, RecoveryConflictPending, STATEMENT_TIMEOUT, TransactionTimeout, TransactionTimeoutPending, and whereToSendOutput.

Referenced by die().

◆ RecheckDataDirLockFile()

bool RecheckDataDirLockFile ( void )

Definition at line 1697 of file miscinit.c.

{
    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;
}

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

Referenced by ServerLoop().

◆ restore_stack_base()

void restore_stack_base ( pg_stack_base_t base )

Definition at line 77 of file stack_depth.c.

{
    stack_base_ptr = base;
}

References stack_base_ptr.

◆ RestoreClientConnectionInfo()

void RestoreClientConnectionInfo ( char * conninfo )

Definition at line 1134 of file miscinit.c.

{
    SerializedClientConnectionInfo serialized;
 
    memcpy(&serialized, conninfo, sizeof(serialized));
 
    /* Copy the fields back into place */
    MyClientConnectionInfo.authn_id = NULL;
    MyClientConnectionInfo.auth_method = serialized.auth_method;
 
    if (serialized.authn_id_len >= 0)
    {
        char       *authn_id;
 
        authn_id = conninfo + sizeof(serialized);
        MyClientConnectionInfo.authn_id = MemoryContextStrdup(TopMemoryContext,
                                                              authn_id);
    }
}

References SerializedClientConnectionInfo::auth_method, ClientConnectionInfo::auth_method, ClientConnectionInfo::authn_id, authn_id, SerializedClientConnectionInfo::authn_id_len, MemoryContextStrdup(), MyClientConnectionInfo, and TopMemoryContext.

Referenced by ParallelWorkerMain().

◆ SerializeClientConnectionInfo()

void SerializeClientConnectionInfo	(	Size	maxsize,
		char *	start_address
	)

Definition at line 1102 of file miscinit.c.

{
    SerializedClientConnectionInfo serialized = {0};
 
    serialized.authn_id_len = -1;
    serialized.auth_method = MyClientConnectionInfo.auth_method;
 
    if (MyClientConnectionInfo.authn_id)
        serialized.authn_id_len = strlen(MyClientConnectionInfo.authn_id);
 
    /* Copy serialized representation to buffer */
    Assert(maxsize >= sizeof(serialized));
    memcpy(start_address, &serialized, sizeof(serialized));
 
    maxsize -= sizeof(serialized);
    start_address += sizeof(serialized);
 
    /* Copy authn_id into the space after the struct */
    if (serialized.authn_id_len >= 0)
    {
        Assert(maxsize >= (serialized.authn_id_len + 1));
        memcpy(start_address,
               MyClientConnectionInfo.authn_id,
        /* include the NULL terminator to ease deserialization */
               serialized.authn_id_len + 1);
    }
}

References Assert(), SerializedClientConnectionInfo::auth_method, ClientConnectionInfo::auth_method, ClientConnectionInfo::authn_id, SerializedClientConnectionInfo::authn_id_len, and MyClientConnectionInfo.

Referenced by InitializeParallelDSM().

◆ set_stack_base()

pg_stack_base_t set_stack_base ( void )

Definition at line 44 of file stack_depth.c.

{
#ifndef HAVE__BUILTIN_FRAME_ADDRESS
    char        stack_base;
#endif
    pg_stack_base_t old;
 
    old = stack_base_ptr;
 
    /*
     * Set up reference point for stack depth checking.  On recent gcc we use
     * __builtin_frame_address() to avoid a warning about storing a local
     * variable's address in a long-lived variable.
     */
#ifdef HAVE__BUILTIN_FRAME_ADDRESS
    stack_base_ptr = __builtin_frame_address(0);
#else
    stack_base_ptr = &stack_base;
#endif
 
    return old;
}

References stack_base_ptr.

Referenced by main().

◆ SetAuthenticatedUserId()

void SetAuthenticatedUserId ( Oid userid )

Definition at line 603 of file miscinit.c.

{
    Assert(OidIsValid(userid));
 
    /* call only once */
    Assert(!OidIsValid(AuthenticatedUserId));
 
    AuthenticatedUserId = userid;
 
    /* Also mark our PGPROC entry with the authenticated user id */
    /* (We assume this is an atomic store so no lock is needed) */
    MyProc->roleId = userid;
}

References Assert(), AuthenticatedUserId, MyProc, OidIsValid, and PGPROC::roleId.

Referenced by InitializeSessionUserId(), and ParallelWorkerMain().

◆ SetCurrentRoleId()

void SetCurrentRoleId	(	Oid	roleid,
		bool	is_superuser
	)

Definition at line 1007 of file miscinit.c.

{
    /*
     * Get correct info if it's SET ROLE NONE
     *
     * If SessionUserId hasn't been set yet, do nothing beyond updating
     * SetRoleIsActive --- the eventual SetSessionAuthorization call will
     * update the derived state.  This is needed since we will get called
     * during GUC initialization.
     */
    if (!OidIsValid(roleid))
    {
        SetRoleIsActive = false;
 
        if (!OidIsValid(SessionUserId))
            return;
 
        roleid = SessionUserId;
        is_superuser = SessionUserIsSuperuser;
    }
    else
        SetRoleIsActive = true;
 
    SetOuterUserId(roleid, is_superuser);
}

References is_superuser(), OidIsValid, SessionUserId, SessionUserIsSuperuser, SetOuterUserId(), and SetRoleIsActive.

Referenced by assign_role(), InitializeSessionUserIdStandalone(), and ParallelWorkerMain().

◆ SetDatabasePath()

void SetDatabasePath ( const char * path )

Definition at line 334 of file miscinit.c.

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

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

Referenced by InitPostgres().

◆ SetDataDir()

void SetDataDir ( const char * dir )

Definition at line 440 of file miscinit.c.

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

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

Referenced by SelectConfigFiles().

◆ SetSessionAuthorization()

void SetSessionAuthorization	(	Oid	userid,
		bool	is_superuser
	)

Definition at line 971 of file miscinit.c.

{
    SetSessionUserId(userid, is_superuser);
 
    if (!SetRoleIsActive)
        SetOuterUserId(userid, is_superuser);
}

References is_superuser(), SetOuterUserId(), SetRoleIsActive, and SetSessionUserId().

Referenced by assign_session_authorization(), InitializeSessionUserIdStandalone(), and ParallelWorkerMain().

◆ SetUserIdAndContext()

void SetUserIdAndContext	(	Oid	userid,
		bool	sec_def_context
	)

Definition at line 719 of file miscinit.c.

{
    /* 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;
}

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

◆ SetUserIdAndSecContext()

void SetUserIdAndSecContext	(	Oid	userid,
		int	sec_context
	)

Definition at line 670 of file miscinit.c.

{
    CurrentUserId = userid;
    SecurityRestrictionContext = sec_context;
}

References CurrentUserId, and SecurityRestrictionContext.

Referenced by AbortSubTransaction(), AbortTransaction(), AfterTriggerExecute(), amcheck_lock_relation_and_check(), brin_summarize_range(), cluster_rel(), ComputeIndexAttrs(), CreateSchemaCommand(), DefineIndex(), do_analyze_rel(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), ParallelWorkerMain(), refresh_by_match_merge(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), RestoreUserContext(), ri_PerformCheck(), ri_PlanCheck(), SwitchToUntrustedUser(), vacuum_rel(), and validate_index().

◆ stack_is_too_deep()

bool stack_is_too_deep ( void )

Definition at line 109 of file stack_depth.c.

{
    char        stack_top_loc;
    ssize_t     stack_depth;
 
    /*
     * Compute distance from reference point to my local variables
     */
    stack_depth = (ssize_t) (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
     * before that's been set.  Logically it should be done first, but putting
     * it last avoids wasting cycles during normal cases.
     */
    if (stack_depth > max_stack_depth_bytes &&
        stack_base_ptr != NULL)
        return true;
 
    return false;
}

References max_stack_depth_bytes, and stack_base_ptr.

Referenced by check_stack_depth(), MemoryContextStatsInternal(), rstacktoodeep(), and ShowTransactionStateRec().

◆ superuser()

bool superuser ( void )

Definition at line 46 of file superuser.c.

{
    return superuser_arg(GetUserId());
}

References GetUserId(), and superuser_arg().

Referenced by AlterForeignDataWrapper(), AlterForeignDataWrapperOwner_internal(), AlterForeignServerOwner_internal(), AlterFunction(), AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), AlterOpFamily(), AlterPublicationOwner_internal(), AlterRole(), AlterRoleSet(), AlterSubscription(), AlterSubscriptionOwner_internal(), AlterSystemSetConfigFile(), AlterType(), AlterTypeOwner(), ATExecChangeOwner(), brin_metapage_info(), brin_page_items(), brin_page_type(), brin_revmap_data(), bt_metap(), bt_multi_page_stats(), bt_page_items_bytea(), bt_page_items_internal(), bt_page_stats_internal(), check_encoding_locale_matches(), CheckAlterPublication(), CreateAccessMethod(), CreateCast(), CreateEventTrigger(), CreateForeignDataWrapper(), CreateFunction(), CreateProceduralLanguage(), CreatePublication(), CreateRole(), CreateSubscription(), CreateTableSpace(), dblink_connstr_check(), dblink_security_check(), DefineAggregate(), DefineOpClass(), DefineOpFamily(), DefineTSParser(), DefineTSTemplate(), DefineType(), DropRole(), dummy_object_relabel(), EnableDisableTrigger(), ExecSetVariableStmt(), execute_extension_script(), ExecuteDoStmt(), fmgr_security_definer(), fsm_page_contents(), get_raw_page_internal(), gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), gist_page_items(), gist_page_items_bytea(), gist_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(), heap_tuple_infomask_flags(), InitPostgres(), interpret_func_support(), main(), page_checksum_internal(), page_header(), pg_buffercache_superuser_check(), pg_import_system_collations(), pg_nextoid(), pg_relpages(), pg_relpagesbyid(), pg_signal_backend(), pg_stop_making_pinned_objects(), pgstat_get_backend_current_activity(), pgstatginindex(), pgstatindex(), pgstatindexbyid(), pgstattuple(), pgstattuple_approx(), pgstattuplebyid(), postgres_fdw_validator(), ProcedureCreate(), regress_setenv(), RenameRole(), sepgsql_restorecon(), set_config_by_name(), SetPGVariable(), standard_ProcessUtility(), TerminateOtherDBBackends(), tuple_data_split(), validate_option_array_item(), and wait_pid().

◆ superuser_arg()

bool superuser_arg ( Oid roleid )

Definition at line 56 of file superuser.c.

{
    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;
}

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

Referenced by AlterEventTriggerOwner_internal(), AlterForeignDataWrapperOwner_internal(), AlterPublicationOwner_internal(), check_conn_params(), check_object_ownership(), check_role_grantor(), check_role_membership_authorization(), check_session_authorization(), CreateRole(), CreateSubscription(), DropSubscription(), emit_audit_message(), GetSubscription(), has_bypassrls_privilege(), has_createrole_privilege(), has_privs_of_role(), has_rolreplication(), is_admin_of_role(), is_member_of_role(), LockGXact(), member_can_set_role(), object_aclmask_ext(), object_ownercheck(), pg_class_aclmask_ext(), pg_largeobject_aclmask_snapshot(), pg_namespace_aclmask_ext(), pg_parameter_acl_aclmask(), pg_parameter_aclmask(), pg_signal_backend(), pg_type_aclmask_ext(), pgfdw_security_check(), REGRESS_exec_check_perms(), REGRESS_object_access_hook(), REGRESS_object_access_hook_str(), REGRESS_utility_command(), select_best_grantor(), superuser(), and TerminateOtherDBBackends().

◆ SwitchBackToLocalLatch()

void SwitchBackToLocalLatch ( void )

Definition at line 242 of file miscinit.c.

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

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

Referenced by AuxiliaryProcKill(), and ProcKill().

◆ SwitchToSharedLatch()

void SwitchToSharedLatch ( void )

Definition at line 215 of file miscinit.c.

{
    Assert(MyLatch == &LocalLatchData);
    Assert(MyProc != NULL);
 
    MyLatch = &MyProc->procLatch;
 
    if (FeBeWaitSet)
        ModifyWaitEvent(FeBeWaitSet, FeBeWaitSetLatchPos, 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);
}

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

Referenced by InitAuxiliaryProcess(), and InitProcess().

◆ TouchSocketLockFiles()

void TouchSocketLockFiles ( void )

Definition at line 1541 of file miscinit.c.

{
    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;
 
        /* we just ignore any error here */
        (void) utime(socketLockFile, NULL);
    }
}

References DIRECTORY_LOCK_FILE, lfirst, and lock_files.

Referenced by ServerLoop().

◆ ValidatePgVersion()

void ValidatePgVersion ( const char * path )

Definition at line 1769 of file miscinit.c.

{
    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)));
}