#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	SECURITY_LOCAL_USERID_CHANGE 0x0001

#define	SECURITY_RESTRICTED_OPERATION 0x0002

#define	SECURITY_NOFORCE_RLS 0x0004

#define	BACKEND_NUM_TYPES (B_LOGGER + 1)

#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	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_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_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)

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)

Oid	GetAuthenticatedUserId (void)

void	GetUserIdAndSecContext (Oid userid, int sec_context)

void	SetUserIdAndSecContext (Oid userid, int sec_context)

bool	InLocalUserIdChange (void)

bool	InSecurityRestrictedOperation (void)

bool	InNoForceRLSOperation (void)

void	GetUserIdAndContext (Oid userid, bool sec_def_context)

void	SetUserIdAndContext (Oid userid, bool sec_def_context)

void	InitializeSessionUserId (const char *rolename, Oid 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	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 bool	MyCancelKeyValid

PGDLLIMPORT int32	MyCancelKey

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 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 376 of file miscadmin.h.

◆ AmAutoVacuumLauncherProcess

#define AmAutoVacuumLauncherProcess ( ) (MyBackendType == B_AUTOVAC_LAUNCHER)

Definition at line 371 of file miscadmin.h.

◆ AmAutoVacuumWorkerProcess

#define AmAutoVacuumWorkerProcess ( ) (MyBackendType == B_AUTOVAC_WORKER)

Definition at line 372 of file miscadmin.h.

◆ AmBackgroundWorkerProcess

#define AmBackgroundWorkerProcess ( ) (MyBackendType == B_BG_WORKER)

Definition at line 373 of file miscadmin.h.

◆ AmBackgroundWriterProcess

#define AmBackgroundWriterProcess ( ) (MyBackendType == B_BG_WRITER)

Definition at line 377 of file miscadmin.h.

◆ AmCheckpointerProcess

#define AmCheckpointerProcess ( ) (MyBackendType == B_CHECKPOINTER)

Definition at line 378 of file miscadmin.h.

◆ AmLogicalSlotSyncWorkerProcess

#define AmLogicalSlotSyncWorkerProcess ( ) (MyBackendType == B_SLOTSYNC_WORKER)

Definition at line 375 of file miscadmin.h.

◆ AmStartupProcess

#define AmStartupProcess ( ) (MyBackendType == B_STARTUP)

Definition at line 379 of file miscadmin.h.

◆ AmWalReceiverProcess

#define AmWalReceiverProcess ( ) (MyBackendType == B_WAL_RECEIVER)

Definition at line 380 of file miscadmin.h.

◆ AmWalSenderProcess

#define AmWalSenderProcess ( ) (MyBackendType == B_WAL_SENDER)

Definition at line 374 of file miscadmin.h.

◆ AmWalSummarizerProcess

#define AmWalSummarizerProcess ( ) (MyBackendType == B_WAL_SUMMARIZER)

Definition at line 381 of file miscadmin.h.

◆ AmWalWriterProcess

#define AmWalWriterProcess ( ) (MyBackendType == B_WAL_WRITER)

Definition at line 382 of file miscadmin.h.

◆ BACKEND_NUM_TYPES

#define BACKEND_NUM_TYPES (B_LOGGER + 1)

Definition at line 367 of file miscadmin.h.

◆ CHECK_FOR_INTERRUPTS

#define CHECK_FOR_INTERRUPTS ( )

Value:

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

Definition at line 122 of file miscadmin.h.

◆ DATEORDER_DMY

#define DATEORDER_DMY 1

Definition at line 243 of file miscadmin.h.

◆ DATEORDER_MDY

#define DATEORDER_MDY 2

Definition at line 244 of file miscadmin.h.

◆ DATEORDER_YMD

#define DATEORDER_YMD 0

Definition at line 242 of file miscadmin.h.

◆ END_CRIT_SECTION

#define END_CRIT_SECTION ( )

Value:

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

Definition at line 151 of file miscadmin.h.

◆ GetProcessingMode

#define GetProcessingMode ( ) Mode

Definition at line 455 of file miscadmin.h.

◆ HOLD_CANCEL_INTERRUPTS

#define HOLD_CANCEL_INTERRUPTS ( ) (QueryCancelHoldoffCount++)

Definition at line 141 of file miscadmin.h.

◆ HOLD_INTERRUPTS

#define HOLD_INTERRUPTS ( ) (InterruptHoldoffCount++)

Definition at line 133 of file miscadmin.h.

◆ INIT_PG_LOAD_SESSION_LIBS

#define INIT_PG_LOAD_SESSION_LIBS 0x0001

Definition at line 473 of file miscadmin.h.

◆ INIT_PG_OVERRIDE_ALLOW_CONNS

#define INIT_PG_OVERRIDE_ALLOW_CONNS 0x0002

Definition at line 474 of file miscadmin.h.

◆ INIT_PG_OVERRIDE_ROLE_LOGIN

#define INIT_PG_OVERRIDE_ROLE_LOGIN 0x0004

Definition at line 475 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:42

Definition at line 129 of file miscadmin.h.

◆ INTERRUPTS_PENDING_CONDITION

#define INTERRUPTS_PENDING_CONDITION ( ) (unlikely(InterruptPending))

Definition at line 113 of file miscadmin.h.

◆ INTSTYLE_ISO_8601

#define INTSTYLE_ISO_8601 3

Definition at line 259 of file miscadmin.h.

◆ INTSTYLE_POSTGRES

#define INTSTYLE_POSTGRES 0

Definition at line 256 of file miscadmin.h.

◆ INTSTYLE_POSTGRES_VERBOSE

#define INTSTYLE_POSTGRES_VERBOSE 1

Definition at line 257 of file miscadmin.h.

◆ INTSTYLE_SQL_STANDARD

#define INTSTYLE_SQL_STANDARD 2

Definition at line 258 of file miscadmin.h.

◆ InvalidPid

#define InvalidPid (-1)

Definition at line 32 of file miscadmin.h.

◆ IsBootstrapProcessingMode

#define IsBootstrapProcessingMode ( ) (Mode == BootstrapProcessing)

Definition at line 451 of file miscadmin.h.

◆ IsInitProcessingMode

#define IsInitProcessingMode ( ) (Mode == InitProcessing)

Definition at line 452 of file miscadmin.h.

◆ IsNormalProcessingMode

#define IsNormalProcessingMode ( ) (Mode == NormalProcessing)

Definition at line 453 of file miscadmin.h.

◆ MAX_BAS_VAC_RING_SIZE_KB

#define MAX_BAS_VAC_RING_SIZE_KB (16 * 1024 * 1024)

Definition at line 278 of file miscadmin.h.

◆ MAXTZLEN

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

Definition at line 263 of file miscadmin.h.

◆ MIN_BAS_VAC_RING_SIZE_KB

#define MIN_BAS_VAC_RING_SIZE_KB 128

Definition at line 277 of file miscadmin.h.

◆ RESUME_CANCEL_INTERRUPTS

#define RESUME_CANCEL_INTERRUPTS ( )

Value:

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

Definition at line 143 of file miscadmin.h.

◆ RESUME_INTERRUPTS

#define RESUME_INTERRUPTS ( )

Value:

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

Definition at line 135 of file miscadmin.h.

◆ SECURITY_LOCAL_USERID_CHANGE

#define SECURITY_LOCAL_USERID_CHANGE 0x0001

Definition at line 311 of file miscadmin.h.

◆ SECURITY_NOFORCE_RLS

#define SECURITY_NOFORCE_RLS 0x0004

Definition at line 313 of file miscadmin.h.

◆ SECURITY_RESTRICTED_OPERATION

#define SECURITY_RESTRICTED_OPERATION 0x0002

Definition at line 312 of file miscadmin.h.

◆ SetProcessingMode

#define SetProcessingMode ( mode )

Value:

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

Definition at line 457 of file miscadmin.h.

◆ START_CRIT_SECTION

#define START_CRIT_SECTION ( ) (CritSectionCount++)

Definition at line 149 of file miscadmin.h.

◆ USE_GERMAN_DATES

#define USE_GERMAN_DATES 3

Definition at line 238 of file miscadmin.h.

◆ USE_ISO_DATES

#define USE_ISO_DATES 1

Definition at line 236 of file miscadmin.h.

◆ USE_POSTGRES_DATES

#define USE_POSTGRES_DATES 0

Definition at line 235 of file miscadmin.h.

◆ USE_SQL_DATES

#define USE_SQL_DATES 2

Definition at line 237 of file miscadmin.h.

◆ USE_XSD_DATES

#define USE_XSD_DATES 4

Definition at line 239 of file miscadmin.h.

Typedef Documentation

◆ BackendType

typedef enum BackendType BackendType

◆ pg_stack_base_t

typedef char* pg_stack_base_t

Definition at line 293 of file miscadmin.h.

◆ ProcessingMode

typedef enum ProcessingMode ProcessingMode

◆ shmem_request_hook_type

typedef void(* shmem_request_hook_type) (void)

Definition at line 507 of file miscadmin.h.

Enumeration Type Documentation

◆ BackendType

enum BackendType

Enumerator
B_INVALID
B_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_STARTUP
B_WAL_RECEIVER
B_WAL_SUMMARIZER
B_WAL_WRITER
B_LOGGER

Definition at line 330 of file miscadmin.h.

 {
     B_INVALID = 0,
  
     /* Backends and other backend-like processes */
     B_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. 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_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 442 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 1511 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 603 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();
  
     /* 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();
 }

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

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

◆ ChangeToDataDir()

void ChangeToDataDir ( void )

Definition at line 454 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 3564 of file postgres.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(), ATExecAddColumn(), ATExecAlterConstrRecurse(), ATExecDropColumn(), 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(), 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 341 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 1455 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 1464 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 1027 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, MyClientConnectionInfo, and size.

Referenced by InitializeParallelDSM().

◆ get_hash_memory_limit()

size_t get_hash_memory_limit ( void )

Definition at line 3488 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 BuildTupleHashTableExt(), choose_hashed_setop(), consider_groupingsets_paths(), cost_memoize_rescan(), create_unique_path(), ExecChooseHashTableSize(), ExecInitMemoize(), ExecParallelHashIncreaseNumBatches(), final_cost_hashjoin(), hash_agg_set_limits(), hash_choose_num_partitions(), subpath_is_hashable(), and subplan_is_hashable().

◆ GetAuthenticatedUserId()

Oid GetAuthenticatedUserId ( void )

Definition at line 583 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 = "unknown process type";
  
     switch (backendType)
     {
         case B_INVALID:
             backendDesc = "not initialized";
             break;
         case B_ARCHIVER:
             backendDesc = "archiver";
             break;
         case B_AUTOVAC_LAUNCHER:
             backendDesc = "autovacuum launcher";
             break;
         case B_AUTOVAC_WORKER:
             backendDesc = "autovacuum worker";
             break;
         case B_BACKEND:
             backendDesc = "client backend";
             break;
         case B_BG_WORKER:
             backendDesc = "background worker";
             break;
         case B_BG_WRITER:
             backendDesc = "background writer";
             break;
         case B_CHECKPOINTER:
             backendDesc = "checkpointer";
             break;
         case B_LOGGER:
             backendDesc = "logger";
             break;
         case B_SLOTSYNC_WORKER:
             backendDesc = "slotsync worker";
             break;
         case B_STANDALONE_BACKEND:
             backendDesc = "standalone backend";
             break;
         case B_STARTUP:
             backendDesc = "startup";
             break;
         case B_WAL_RECEIVER:
             backendDesc = "walreceiver";
             break;
         case B_WAL_SENDER:
             backendDesc = "walsender";
             break;
         case B_WAL_SUMMARIZER:
             backendDesc = "walsummarizer";
             break;
         case B_WAL_WRITER:
             backendDesc = "walwriter";
             break;
     }
  
     return backendDesc;
 }

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

Referenced by BackendInitialize(), get_backend_type_for_log(), init_ps_display(), pg_stat_get_activity(), and pg_stat_get_io().

◆ GetCurrentRoleId()

Oid GetCurrentRoleId ( void )

Definition at line 924 of file miscinit.c.

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

References InvalidOid, OuterUserId, and SetRoleIsActive.

Referenced by InitializeParallelDSM(), and show_role().

◆ GetOuterUserId()

Oid GetOuterUserId ( void )

Definition at line 525 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 548 of file miscinit.c.

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

References Assert, OidIsValid, and SessionUserId.

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

◆ GetSystemUser()

const char* GetSystemUser ( void )

Definition at line 574 of file miscinit.c.

 {
     return SystemUser;
 }

References SystemUser.

Referenced by system_user().

◆ GetUserId()

Oid GetUserId ( void )

Definition at line 514 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 684 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 635 of file miscinit.c.

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

References CurrentUserId, and SecurityRestrictionContext.

Referenced by brin_summarize_range(), bt_index_check_internal(), 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 980 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 711 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 574 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 (FastPathLockGroupsPerBackend * FP_LOCK_SLOTS_PER_GROUP >= max_locks_per_xact)
             break;
  
         FastPathLockGroupsPerBackend *= 2;
     }
  
     Assert(FastPathLockGroupsPerBackend <= FP_LOCK_GROUPS_PER_BACKEND_MAX);
 }

References Assert, FastPathLockGroupsPerBackend, FP_LOCK_GROUPS_PER_BACKEND_MAX, FP_LOCK_SLOTS_PER_GROUP, and max_locks_per_xact.

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

◆ InitializeMaxBackends()

void InitializeMaxBackends ( void )

Definition at line 542 of file postinit.c.

 {
     Assert(MaxBackends == 0);
  
     /* the extra unit accounts for the autovacuum launcher */
     MaxBackends = MaxConnections + autovacuum_max_workers + 1 +
         max_worker_processes + max_wal_senders;
  
     if (MaxBackends > MAX_BACKENDS)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("too many server processes configured"),
                  errdetail("\"max_connections\" (%d) plus \"autovacuum_max_workers\" (%d) plus \"max_worker_processes\" (%d) plus \"max_wal_senders\" (%d) must be less than %d.",
                            MaxConnections, autovacuum_max_workers,
                            max_worker_processes, max_wal_senders,
                            MAX_BACKENDS)));
 }

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

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

◆ InitializeSessionUserId()

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

Definition at line 733 of file miscinit.c.

 {
     HeapTuple   roleTup;
     Form_pg_authid rform;
     char       *rname;
     bool        is_superuser;
  
     /*
      * 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());
  
     /* call only once */
     Assert(!OidIsValid(AuthenticatedUserId));
  
     /*
      * 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();
  
     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);
  
     AuthenticatedUserId = roleid;
     is_superuser = rform->rolsuper;
  
     /* This sets OuterUserId/CurrentUserId too */
     SetSessionUserId(roleid, is_superuser);
  
     /* Also mark our PGPROC entry with the authenticated user id */
     /* (We assume this is an atomic store so no lock is needed) */
     MyProc->roleId = roleid;
  
     /*
      * These next checks are not enforced when in standalone mode, so that
      * there is a way to recover from sillinesses like "UPDATE pg_authid SET
      * rolcanlogin = false;".
      */
     if (IsUnderPostmaster)
     {
         /*
          * Is role allowed to login at all?
          */
         if (!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.
          *
          * 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 &&
             !is_superuser &&
             CountUserBackends(roleid) > rform->rolconnlimit)
             ereport(FATAL,
                     (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
                      errmsg("too many connections for role \"%s\"",
                             rname)));
     }
  
     /* Record username and superuser status as GUC settings too */
     SetConfigOption("session_authorization", rname,
                     PGC_BACKEND, PGC_S_OVERRIDE);
     SetConfigOption("is_superuser",
                     is_superuser ? "on" : "off",
                     PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
  
     ReleaseSysCache(roleTup);
 }

References AcceptInvalidationMessages(), Assert, AuthenticatedUserId, CountUserBackends(), ereport, errcode(), errmsg(), FATAL, GETSTRUCT, HeapTupleIsValid, is_superuser(), IsBootstrapProcessingMode, IsUnderPostmaster, MyProc, NameStr, ObjectIdGetDatum(), OidIsValid, PGC_BACKEND, PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, PointerGetDatum(), ReleaseSysCache(), PGPROC::roleId, SearchSysCache1(), SetConfigOption(), and SetSessionUserId().

Referenced by InitPostgres().

◆ InitializeSessionUserIdStandalone()

void InitializeSessionUserIdStandalone ( void )

Definition at line 837 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;
     SetSessionUserId(BOOTSTRAP_SUPERUSERID, true);
  
     /*
      * XXX This should set SetConfigOption("session_authorization"), too.
      * Since we don't, C code will get NULL, and current_setting() will get an
      * empty string.
      */
     SetConfigOption("is_superuser", "on",
                     PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
 }

References AmAutoVacuumWorkerProcess, AmBackgroundWorkerProcess, AmLogicalSlotSyncWorkerProcess, Assert, AuthenticatedUserId, IsUnderPostmaster, OidIsValid, PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT, SetConfigOption(), and SetSessionUserId().

Referenced by InitPostgres().

◆ InitializeSystemUser()

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

Definition at line 867 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, 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 697 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 my entry in the shared-invalidation manager's array of
      * per-backend data.
      */
     SharedInvalBackendInit(false);
  
     ProcSignalInit(MyCancelKeyValid, MyCancelKey);
  
     /*
      * 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();
  
     /* Initialize status reporting */
     pgstat_beinit();
  
     /*
      * 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())
     {
         /* report this backend in the PgBackendStatus array */
         pgstat_bestart();
  
         return;
     }
  
     /*
      * Start a new transaction here before first access to db, and get a
      * snapshot.  We don't have a use for the snapshot itself, but we're
      * interested in the secondary effect that it sets RecentGlobalXmin. (This
      * is critical for anything that reads heap pages, because HOT may decide
      * to prune them even if the process doesn't attempt to modify any
      * tuples.)
      *
      * FIXME: This comment is inaccurate / the code buggy. A snapshot that is
      * not pushed/active does not reliably prevent HOT pruning (->xmin could
      * e.g. be cleared when cache invalidations are processed).
      */
     if (!bootstrap)
     {
         /* statement_timestamp must be set for timeouts to work correctly */
         SetCurrentStatementStartTimestamp();
         StartTransactionCommand();
  
         /*
          * transaction_isolation will have been set to the default by the
          * above.  If the default is "serializable", and we are in hot
          * standby, we will fail if we don't change it to something lower.
          * Fortunately, "read committed" is plenty good enough.
          */
         XactIsoLevel = XACT_READ_COMMITTED;
  
         (void) GetTransactionSnapshot();
     }
  
     /*
      * Perform client authentication if necessary, then figure out our
      * postgres user ID, and see if we are a superuser.
      *
      * In standalone mode, 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();
     }
  
     /*
      * 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 connection slots are reserved for superusers and roles
      * with privileges of pg_use_reserved_connections.  Replication
      * connections are drawn from slots reserved with max_wal_senders and are
      * not limited by max_connections, superuser_reserved_connections, or
      * reserved_connections.
      *
      * 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 (!am_superuser && !am_walsender &&
         (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();
  
         /* report this backend in the PgBackendStatus array */
         pgstat_bestart();
  
         /* close the transaction we started above */
         CommitTransactionCommand();
  
         return;
     }
  
     /*
      * Set up the global variables holding database id and default tablespace.
      * But note we won't actually try to touch the database just yet.
      *
      * We take a shortcut in the bootstrap case, otherwise we have to look up
      * the db's entry in pg_database.
      */
     if (bootstrap)
     {
         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();
             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();
  
     /* report this backend in the PgBackendStatus array */
     if (!bootstrap)
         pgstat_bestart();
  
     /* close the transaction we started above */
     if (!bootstrap)
         CommitTransactionCommand();
 }

References am_db_walsender, am_walsender, AmAutoVacuumLauncherProcess, AmAutoVacuumWorkerProcess, AmBackgroundWorkerProcess, AmLogicalSlotSyncWorkerProcess, 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, GetTransactionSnapshot(), 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(), InvalidateCatalogSnapshot(), IsBinaryUpgrade, IsBootstrapProcessingMode, IsUnderPostmaster, LOCK_TIMEOUT, LockSharedObject(), LockTimeoutHandler(), MyCancelKey, MyCancelKeyValid, MyClientConnectionInfo, MyDatabaseHasLoginEventTriggers, MyDatabaseId, MyDatabaseTableSpace, MyProc, MyProcPort, NAMEDATALEN, NameStr, namestrcmp(), OidIsValid, PerformAuthentication(), pfree(), pg_usleep(), pgstat_before_server_shutdown(), pgstat_beinit(), pgstat_bestart(), 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 AutoVacWorkerMain(), BackgroundWorkerInitializeConnection(), BackgroundWorkerInitializeConnectionByOid(), BootstrapModeMain(), PostgresMain(), and ReplSlotSyncWorkerMain().

◆ InitPostmasterChild()

void InitPostmasterChild ( void )

Definition at line 95 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
  
     /*
      * Set reference point for stack-depth checking.  This might seem
      * redundant in !EXEC_BACKEND builds, but it's better to keep the depth
      * logic the same with and without that build option.
      */
     (void) set_stack_base();
  
     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 */
     InitializeLatchSupport();
     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, InitializeLatchSupport(), InitializeLatchWaitSet(), InitProcessGlobals(), InitProcessLocalLatch(), IsUnderPostmaster, on_exit_reset(), pgwin32_signal_initialize(), postmaster_alive_fds, POSTMASTER_FD_WATCH, PostmasterDeathSignalInit(), pqinitmask(), pqsignal(), set_stack_base(), SignalHandlerForCrashExit(), and SIGQUIT.

Referenced by postmaster_child_launch().

◆ InitProcessLocalLatch()

void InitProcessLocalLatch ( void )

Definition at line 241 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 181 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 */
     InitializeLatchSupport();
     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(), InitializeLatchSupport(), InitializeLatchWaitSet(), 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 653 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 671 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 662 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 1880 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 484 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 1857 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 1843 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 1871 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 3277 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 (AmBackgroundWorkerProcess())
             ereport(FATAL,
                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
                      errmsg("terminating background worker \"%s\" due to administrator command",
                             MyBgworkerEntry->bgw_type)));
         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)
         HandleParallelMessages();
  
     if (LogMemoryContextPending)
         ProcessLogMemoryContextInterrupt();
  
     if (ParallelApplyMessagePending)
         HandleParallelApplyMessages();
 }

References AmAutoVacuumWorkerProcess, AmBackgroundWorkerProcess, 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(), HandleParallelApplyMessages(), HandleParallelMessages(), 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, ProcessLogMemoryContextInterrupt(), ProcessProcSignalBarrier(), ProcessRecoveryConflictInterrupts(), ProcSignalBarrierPending, QueryCancelHoldoffCount, QueryCancelPending, RecoveryConflictPending, STATEMENT_TIMEOUT, TransactionTimeout, TransactionTimeoutPending, and whereToSendOutput.

Referenced by die().

◆ RecheckDataDirLockFile()

bool RecheckDataDirLockFile ( void )

Definition at line 1638 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 3547 of file postgres.c.

 {
     stack_base_ptr = base;
 }

References stack_base_ptr.

◆ RestoreClientConnectionInfo()

void RestoreClientConnectionInfo ( char * conninfo )

Definition at line 1075 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, SerializedClientConnectionInfo::authn_id_len, MemoryContextStrdup(), MyClientConnectionInfo, and TopMemoryContext.

Referenced by ParallelWorkerMain().

◆ SerializeClientConnectionInfo()

void SerializeClientConnectionInfo	(	Size	maxsize,
		char *	start_address
	)

Definition at line 1043 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 3514 of file postgres.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 InitPostmasterChild(), and PostmasterMain().

◆ SetCurrentRoleId()

void SetCurrentRoleId	(	Oid	roleid,
		bool	is_superuser
	)

Definition at line 945 of file miscinit.c.

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

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

Referenced by assign_role(), and ParallelWorkerMain().

◆ SetDatabasePath()

void SetDatabasePath ( const char * path )

Definition at line 328 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 434 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 908 of file miscinit.c.

 {
     SetSessionUserId(userid, is_superuser);
  
     SetConfigOption("is_superuser",
                     is_superuser ? "on" : "off",
                     PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
 }

References is_superuser(), PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT, SetConfigOption(), and SetSessionUserId().

Referenced by assign_session_authorization().

◆ SetUserIdAndContext()

void SetUserIdAndContext	(	Oid	userid,
		bool	sec_def_context
	)

Definition at line 691 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 642 of file miscinit.c.

 {
     CurrentUserId = userid;
     SecurityRestrictionContext = sec_context;
 }

References CurrentUserId, and SecurityRestrictionContext.

Referenced by AbortSubTransaction(), AbortTransaction(), brin_summarize_range(), bt_index_check_internal(), 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 3578 of file postgres.c.

 {
     char        stack_top_loc;
     long        stack_depth;
  
     /*
      * Compute distance from reference point to my local variables
      */
     stack_depth = (long) (stack_base_ptr - &stack_top_loc);
  
     /*
      * Take abs value, since stacks grow up on some machines, down on others
      */
     if (stack_depth < 0)
         stack_depth = -stack_depth;
  
     /*
      * Trouble?
      *
      * The test on stack_base_ptr prevents us from erroring out if called
      * during process setup or in a non-backend process.  Logically it should
      * be done first, but putting it here avoids wasting cycles during normal
      * cases.
      */
     if (stack_depth > max_stack_depth_bytes &&
         stack_base_ptr != NULL)
         return true;
  
     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_evict(), 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 248 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 221 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 1482 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 1710 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)));
 }