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

#define	SECURITY_RESTRICTED_OPERATION 0x0002

#define	SECURITY_NOFORCE_RLS 0x0004

#define	BACKEND_NUM_TYPES (B_WAL_WRITER + 1)

#define	IsBootstrapProcessingMode() (Mode == BootstrapProcessing)

#define	IsInitProcessingMode() (Mode == InitProcessing)

#define	IsNormalProcessingMode() (Mode == NormalProcessing)

#define	GetProcessingMode() Mode

#define	SetProcessingMode(mode)

#define	AmStartupProcess() (MyAuxProcType == StartupProcess)

#define	AmBackgroundWriterProcess() (MyAuxProcType == BgWriterProcess)

#define	AmArchiverProcess() (MyAuxProcType == ArchiverProcess)

#define	AmCheckpointerProcess() (MyAuxProcType == CheckpointerProcess)

#define	AmWalWriterProcess() (MyAuxProcType == WalWriterProcess)

#define	AmWalReceiverProcess() (MyAuxProcType == WalReceiverProcess)

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_ARCHIVER , B_AUTOVAC_LAUNCHER , B_AUTOVAC_WORKER , B_BACKEND , B_BG_WORKER , B_BG_WRITER , B_CHECKPOINTER , B_LOGGER , B_STANDALONE_BACKEND , B_STARTUP , B_WAL_RECEIVER , B_WAL_SENDER , B_WAL_WRITER }

enum	ProcessingMode { BootstrapProcessing , InitProcessing , NormalProcessing }

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

Functions
void	ProcessInterrupts (void)

pg_stack_base_t	set_stack_base (void)

void	restore_stack_base (pg_stack_base_t base)

void	check_stack_depth (void)

bool	stack_is_too_deep (void)

void	PreventCommandIfReadOnly (const char *cmdname)

void	PreventCommandIfParallelMode (const char *cmdname)

void	PreventCommandDuringRecovery (const char *cmdname)

int	trace_recovery (int trace_level)

void	InitPostmasterChild (void)

void	InitStandaloneProcess (const char *argv0)

void	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)

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	InitPostgres (const char in_dbname, Oid dboid, const char username, Oid useroid, bool load_session_libraries, bool override_allow_connections, 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	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	IsBackgroundWorker

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	MyProcPid

PGDLLIMPORT pg_time_t	MyStartTime

PGDLLIMPORT TimestampTz	MyStartTimestamp

PGDLLIMPORT struct Port *	MyProcPort

PGDLLIMPORT struct Latch *	MyLatch

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 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	VacuumCostPageHit

PGDLLIMPORT int	VacuumCostPageMiss

PGDLLIMPORT int	VacuumCostPageDirty

PGDLLIMPORT int	VacuumCostLimit

PGDLLIMPORT double	VacuumCostDelay

PGDLLIMPORT int64	VacuumPageHit

PGDLLIMPORT int64	VacuumPageMiss

PGDLLIMPORT int64	VacuumPageDirty

PGDLLIMPORT int	VacuumCostBalance

PGDLLIMPORT bool	VacuumCostActive

PGDLLIMPORT int	trace_recovery_messages

PGDLLIMPORT char *	DatabasePath

PGDLLIMPORT BackendType	MyBackendType

PGDLLIMPORT ProcessingMode	Mode

PGDLLIMPORT AuxProcType	MyAuxProcType

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 ( ) (MyAuxProcType == ArchiverProcess)

Definition at line 445 of file miscadmin.h.

◆ AmBackgroundWriterProcess

#define AmBackgroundWriterProcess ( ) (MyAuxProcType == BgWriterProcess)

Definition at line 444 of file miscadmin.h.

◆ AmCheckpointerProcess

#define AmCheckpointerProcess ( ) (MyAuxProcType == CheckpointerProcess)

Definition at line 446 of file miscadmin.h.

◆ AmStartupProcess

#define AmStartupProcess ( ) (MyAuxProcType == StartupProcess)

Definition at line 443 of file miscadmin.h.

◆ AmWalReceiverProcess

#define AmWalReceiverProcess ( ) (MyAuxProcType == WalReceiverProcess)

Definition at line 448 of file miscadmin.h.

◆ AmWalWriterProcess

#define AmWalWriterProcess ( ) (MyAuxProcType == WalWriterProcess)

Definition at line 447 of file miscadmin.h.

◆ BACKEND_NUM_TYPES

#define BACKEND_NUM_TYPES (B_WAL_WRITER + 1)

Definition at line 335 of file miscadmin.h.

◆ CHECK_FOR_INTERRUPTS

#define CHECK_FOR_INTERRUPTS ( )

Value:

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

Definition at line 121 of file miscadmin.h.

◆ DATEORDER_DMY

#define DATEORDER_DMY 1

Definition at line 237 of file miscadmin.h.

◆ DATEORDER_MDY

#define DATEORDER_MDY 2

Definition at line 238 of file miscadmin.h.

◆ DATEORDER_YMD

#define DATEORDER_YMD 0

Definition at line 236 of file miscadmin.h.

◆ END_CRIT_SECTION

#define END_CRIT_SECTION ( )

Value:

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

Definition at line 150 of file miscadmin.h.

◆ GetProcessingMode

#define GetProcessingMode ( ) Mode

Definition at line 409 of file miscadmin.h.

◆ HOLD_CANCEL_INTERRUPTS

#define HOLD_CANCEL_INTERRUPTS ( ) (QueryCancelHoldoffCount++)

Definition at line 140 of file miscadmin.h.

◆ HOLD_INTERRUPTS

#define HOLD_INTERRUPTS ( ) (InterruptHoldoffCount++)

Definition at line 132 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:40

Definition at line 128 of file miscadmin.h.

◆ INTERRUPTS_PENDING_CONDITION

#define INTERRUPTS_PENDING_CONDITION ( ) (unlikely(InterruptPending))

Definition at line 112 of file miscadmin.h.

◆ INTSTYLE_ISO_8601

#define INTSTYLE_ISO_8601 3

Definition at line 253 of file miscadmin.h.

◆ INTSTYLE_POSTGRES

#define INTSTYLE_POSTGRES 0

Definition at line 250 of file miscadmin.h.

◆ INTSTYLE_POSTGRES_VERBOSE

#define INTSTYLE_POSTGRES_VERBOSE 1

Definition at line 251 of file miscadmin.h.

◆ INTSTYLE_SQL_STANDARD

#define INTSTYLE_SQL_STANDARD 2

Definition at line 252 of file miscadmin.h.

◆ InvalidPid

#define InvalidPid (-1)

Definition at line 32 of file miscadmin.h.

◆ IsBootstrapProcessingMode

#define IsBootstrapProcessingMode ( ) (Mode == BootstrapProcessing)

Definition at line 405 of file miscadmin.h.

◆ IsInitProcessingMode

#define IsInitProcessingMode ( ) (Mode == InitProcessing)

Definition at line 406 of file miscadmin.h.

◆ IsNormalProcessingMode

#define IsNormalProcessingMode ( ) (Mode == NormalProcessing)

Definition at line 407 of file miscadmin.h.

◆ MAXTZLEN

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

Definition at line 257 of file miscadmin.h.

◆ RESUME_CANCEL_INTERRUPTS

#define RESUME_CANCEL_INTERRUPTS ( )

Value:

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

Definition at line 142 of file miscadmin.h.

◆ RESUME_INTERRUPTS

#define RESUME_INTERRUPTS ( )

Value:

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

Definition at line 134 of file miscadmin.h.

◆ SECURITY_LOCAL_USERID_CHANGE

#define SECURITY_LOCAL_USERID_CHANGE 0x0001

Definition at line 304 of file miscadmin.h.

◆ SECURITY_NOFORCE_RLS

#define SECURITY_NOFORCE_RLS 0x0004

Definition at line 306 of file miscadmin.h.

◆ SECURITY_RESTRICTED_OPERATION

#define SECURITY_RESTRICTED_OPERATION 0x0002

Definition at line 305 of file miscadmin.h.

◆ SetProcessingMode

#define SetProcessingMode ( mode )

Value:

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

Definition at line 411 of file miscadmin.h.

◆ START_CRIT_SECTION

#define START_CRIT_SECTION ( ) (CritSectionCount++)

Definition at line 148 of file miscadmin.h.

◆ USE_GERMAN_DATES

#define USE_GERMAN_DATES 3

Definition at line 232 of file miscadmin.h.

◆ USE_ISO_DATES

#define USE_ISO_DATES 1

Definition at line 230 of file miscadmin.h.

◆ USE_POSTGRES_DATES

#define USE_POSTGRES_DATES 0

Definition at line 229 of file miscadmin.h.

◆ USE_SQL_DATES

#define USE_SQL_DATES 2

Definition at line 231 of file miscadmin.h.

◆ USE_XSD_DATES

#define USE_XSD_DATES 4

Definition at line 233 of file miscadmin.h.

Typedef Documentation

◆ BackendType

typedef enum BackendType BackendType

◆ pg_stack_base_t

typedef char* pg_stack_base_t

Definition at line 282 of file miscadmin.h.

◆ ProcessingMode

typedef enum ProcessingMode ProcessingMode

◆ shmem_request_hook_type

typedef void(* shmem_request_hook_type) (void)

Definition at line 488 of file miscadmin.h.

Enumeration Type Documentation

◆ AuxProcType

enum AuxProcType

Enumerator
NotAnAuxProcess
StartupProcess
BgWriterProcess
ArchiverProcess
CheckpointerProcess
WalWriterProcess
WalReceiverProcess
NUM_AUXPROCTYPES

Definition at line 428 of file miscadmin.h.

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

◆ BackendType

enum BackendType

Enumerator
B_INVALID
B_ARCHIVER
B_AUTOVAC_LAUNCHER
B_AUTOVAC_WORKER
B_BACKEND
B_BG_WORKER
B_BG_WRITER
B_CHECKPOINTER
B_LOGGER
B_STANDALONE_BACKEND
B_STARTUP
B_WAL_RECEIVER
B_WAL_SENDER
B_WAL_WRITER

Definition at line 317 of file miscadmin.h.

 {
     B_INVALID = 0,
     B_ARCHIVER,
     B_AUTOVAC_LAUNCHER,
     B_AUTOVAC_WORKER,
     B_BACKEND,
     B_BG_WORKER,
     B_BG_WRITER,
     B_CHECKPOINTER,
     B_LOGGER,
     B_STANDALONE_BACKEND,
     B_STARTUP,
     B_WAL_RECEIVER,
     B_WAL_SENDER,
     B_WAL_WRITER,
 } BackendType;

◆ ProcessingMode

enum ProcessingMode

Enumerator
BootstrapProcessing
InitProcessing
NormalProcessing

Definition at line 396 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 1515 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, generate_unaccent_rules::str, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC, and WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE.

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

◆ BaseInit()

void BaseInit ( void )

Definition at line 636 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();
     InitBufferPoolAccess();
  
     /*
      * 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 replication slots after pgstat. The exit hook might need to
      * drop ephemeral slots, which in turn triggers stats reporting.
      */
     ReplicationSlotInitialize();
 }

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

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

◆ ChangeToDataDir()

void ChangeToDataDir ( void )

Definition at line 449 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 3461 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(), checkCond(), clean_NOT_intree(), clean_stopword_intree(), cntsize(), contains_required_value(), convertJsonbValue(), copyObjectImpl(), Cover(), create_plan_recurse(), datum_to_json(), datum_to_jsonb(), dofindsubquery(), emit_jsp_gin_entries(), equal(), EventTriggerInvoke(), ExecEndNode(), ExecEvalSubPlan(), ExecInitExprRec(), ExecInitNode(), ExecMakeFunctionResultSet(), ExecProcNodeFirst(), ExecShutdownNode_walker(), execute(), executeAnyItem(), 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(), 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(), 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 336 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 1459 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 1468 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 1031 of file miscinit.c.

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

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

Referenced by InitializeParallelDSM().

◆ get_hash_memory_limit()

size_t get_hash_memory_limit ( void )

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

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

References Assert(), AuthenticatedUserId, and OidIsValid.

Referenced by InitializeParallelDSM().

◆ GetBackendTypeDesc()

const char* GetBackendTypeDesc ( BackendType backendType )

Definition at line 264 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_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_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_STANDALONE_BACKEND, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, 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 928 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 521 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 544 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 570 of file miscinit.c.

 {
     return SystemUser;
 }

References SystemUser.

Referenced by system_user().

◆ GetUserId()

Oid GetUserId ( void )

Definition at line 510 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 680 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 631 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(), ExecCreateTableAs(), ExecRefreshMatView(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), InitializeParallelDSM(), PushTransaction(), reindex_index(), ReindexRelationConcurrently(), ri_PerformCheck(), ri_PlanCheck(), StartTransaction(), vacuum_rel(), and validate_index().

◆ GetUserNameFromId()

char* GetUserNameFromId	(	Oid	roleid,
		bool	noerr
	)

Definition at line 984 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 AUTHOID, 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(), and TargetPrivilegesCheck().

◆ has_rolreplication()

bool has_rolreplication ( Oid roleid )

Definition at line 707 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 AUTHOID, GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), rolreplication, SearchSysCache1(), and superuser_arg().

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

◆ InitializeMaxBackends()

void InitializeMaxBackends ( void )

Definition at line 566 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;
  
     /* internal error because the values were all checked previously */
     if (MaxBackends > MAX_BACKENDS)
         elog(ERROR, "too many backends configured");
 }

References Assert(), autovacuum_max_workers, elog(), 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
	)

Definition at line 729 of file miscinit.c.

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

References AcceptInvalidationMessages(), Assert(), AuthenticatedUserId, AuthenticatedUserIsSuperuser, AUTHNAME, AUTHOID, CountUserBackends(), ereport, errcode(), errmsg(), FATAL, GETSTRUCT, HeapTupleIsValid, 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 832 of file miscinit.c.

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

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

Referenced by InitPostgres().

◆ InitializeSystemUser()

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

Definition at line 855 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,
		bool	load_session_libraries,
		bool	override_allow_connections,
		char *	out_dbname
	)

Definition at line 725 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.
      *
      * Sets up MyBackendId, a unique backend identifier.
      */
     MyBackendId = InvalidBackendId;
  
     SharedInvalBackendInit(false);
  
     if (MyBackendId > MaxBackends || MyBackendId <= 0)
         elog(FATAL, "bad backend ID: %d", MyBackendId);
  
     /* Now that we have a BackendId, we can participate in ProcSignal */
     ProcSignalInit(MyBackendId);
  
     /*
      * Also set up timeout handlers needed for backend operation.  We need
      * these in every case except bootstrap.
      */
     if (!bootstrap)
     {
         RegisterTimeout(DEADLOCK_TIMEOUT, CheckDeadLockAlert);
         RegisterTimeout(STATEMENT_TIMEOUT, StatementTimeoutHandler);
         RegisterTimeout(LOCK_TIMEOUT, LockTimeoutHandler);
         RegisterTimeout(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
                         IdleInTransactionSessionTimeoutHandler);
         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 (IsAutoVacuumLauncherProcess())
     {
         /* report this backend in the PgBackendStatus array */
         pgstat_bestart();
  
         return;
     }
  
     /*
      * Start a new transaction here before first access to db, and get a
      * snapshot.  We don't have a use for the snapshot itself, but we're
      * interested in the secondary effect that it sets RecentGlobalXmin. (This
      * is critical for anything that reads heap pages, because HOT may decide
      * to prune them even if the process doesn't attempt to modify any
      * tuples.)
      *
      * 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 and in autovacuum worker processes, we use a fixed
      * ID, otherwise we figure it out from the authenticated user name.
      */
     if (bootstrap || IsAutoVacuumWorkerProcess())
     {
         InitializeSessionUserIdStandalone();
         am_superuser = true;
     }
     else if (!IsUnderPostmaster)
     {
         InitializeSessionUserIdStandalone();
         am_superuser = true;
         if (!ThereIsAtLeastOneRole())
             ereport(WARNING,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("no roles are defined in this database system"),
                      errhint("You should immediately run CREATE USER \"%s\" SUPERUSER;.",
                              username != NULL ? username : "postgres")));
     }
     else if (IsBackgroundWorker)
     {
         if (username == NULL && !OidIsValid(useroid))
         {
             InitializeSessionUserIdStandalone();
             am_superuser = true;
         }
         else
         {
             InitializeSessionUserId(username, useroid);
             am_superuser = superuser();
         }
     }
     else
     {
         /* normal multiuser case */
         Assert(MyProcPort != NULL);
         PerformAuthentication(MyProcPort);
         InitializeSessionUserId(username, useroid);
         /* 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 %s",
                             "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)
     {
         MyDatabaseId = 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);
         MyDatabaseId = dbform->oid;
         MyDatabaseTableSpace = dbform->dattablespace;
         /* take database name from the caller, just for paranoia */
         strlcpy(dbname, in_dbname, sizeof(dbname));
     }
     else if (OidIsValid(dboid))
     {
         /* caller specified database by OID */
         HeapTuple   tuple;
         Form_pg_database dbform;
  
         tuple = GetDatabaseTupleByOid(dboid);
         if (!HeapTupleIsValid(tuple))
             ereport(FATAL,
                     (errcode(ERRCODE_UNDEFINED_DATABASE),
                      errmsg("database %u does not exist", dboid)));
         dbform = (Form_pg_database) GETSTRUCT(tuple);
         MyDatabaseId = dbform->oid;
         MyDatabaseTableSpace = dbform->dattablespace;
         Assert(MyDatabaseId == dboid);
         strlcpy(dbname, NameStr(dbform->datname), sizeof(dbname));
         /* pass the database name back to the caller */
         if (out_dbname)
             strcpy(out_dbname, dbname);
     }
     else
     {
         /*
          * If this is a background worker not bound to any particular
          * database, we're done now.  Everything that follows only makes sense
          * if we are bound to a specific database.  We do need to close the
          * transaction we started before returning.
          */
         if (!bootstrap)
         {
             pgstat_bestart();
             CommitTransactionCommand();
         }
         return;
     }
  
     /*
      * Now, take a writer's lock on the database we are trying to connect to.
      * If there is a concurrently running DROP DATABASE on that database, this
      * will block us until it finishes (and has committed its update of
      * pg_database).
      *
      * Note that the lock is not held long, only until the end of this startup
      * transaction.  This is OK since we will advertise our use of the
      * database in the ProcArray before dropping the lock (in fact, that's the
      * next thing to do).  Anyone trying a DROP DATABASE after this point will
      * see us in the array once they have the lock.  Ordering is important for
      * this because we don't want to advertise ourselves as being in this
      * database until we have the lock; otherwise we create what amounts to a
      * deadlock with CountOtherDBBackends().
      *
      * Note: use of RowExclusiveLock here is reasonable because we envision
      * our session as being a concurrent writer of the database.  If we had a
      * way of declaring a session as being guaranteed-read-only, we could use
      * AccessShareLock for such sessions and thereby not conflict against
      * CREATE DATABASE.
      */
     if (!bootstrap)
         LockSharedObject(DatabaseRelationId, MyDatabaseId, 0,
                          RowExclusiveLock);
  
     /*
      * Now we can mark our PGPROC entry with the database ID.
      *
      * We assume this is an atomic store so no lock is needed; though actually
      * things would work fine even if it weren't atomic.  Anyone searching the
      * ProcArray for this database's ID should hold the database lock, so they
      * would not be executing concurrently with this store.  A process looking
      * for another database's ID could in theory see a chance match if it read
      * a partially-updated databaseId value; but as long as all such searches
      * wait and retry, as in CountOtherDBBackends(), they will certainly see
      * the correct value on their next try.
      */
     MyProc->databaseId = MyDatabaseId;
  
     /*
      * We established a catalog snapshot while reading pg_authid and/or
      * pg_database; but until we have set up MyDatabaseId, we won't react to
      * incoming sinval messages for unshared catalogs, so we won't realize it
      * if the snapshot has been invalidated.  Assume it's no good anymore.
      */
     InvalidateCatalogSnapshot();
  
     /*
      * Recheck pg_database to make sure the target database hasn't gone away.
      * If there was a concurrent DROP DATABASE, this ensures we will die
      * cleanly without creating a mess.
      */
     if (!bootstrap)
     {
         HeapTuple   tuple;
  
         tuple = GetDatabaseTuple(dbname);
         if (!HeapTupleIsValid(tuple) ||
             MyDatabaseId != ((Form_pg_database) GETSTRUCT(tuple))->oid ||
             MyDatabaseTableSpace != ((Form_pg_database) GETSTRUCT(tuple))->dattablespace)
             ereport(FATAL,
                     (errcode(ERRCODE_UNDEFINED_DATABASE),
                      errmsg("database \"%s\" does not exist", dbname),
                      errdetail("It seems to have just been dropped or renamed.")));
     }
  
     /*
      * Now we should be able to access the database directory safely. Verify
      * it's there and looks reasonable.
      */
     fullpath = GetDatabasePath(MyDatabaseId, MyDatabaseTableSpace);
  
     if (!bootstrap)
     {
         if (access(fullpath, F_OK) == -1)
         {
             if (errno == ENOENT)
                 ereport(FATAL,
                         (errcode(ERRCODE_UNDEFINED_DATABASE),
                          errmsg("database \"%s\" does not exist",
                                 dbname),
                          errdetail("The database subdirectory \"%s\" is missing.",
                                    fullpath)));
             else
                 ereport(FATAL,
                         (errcode_for_file_access(),
                          errmsg("could not access directory \"%s\": %m",
                                 fullpath)));
         }
  
         ValidatePgVersion(fullpath);
     }
  
     SetDatabasePath(fullpath);
     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, override_allow_connections);
  
     /*
      * 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 (load_session_libraries)
         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, Assert(), ClientConnectionInfo::auth_method, ClientConnectionInfo::authn_id, before_shmem_exit(), CheckDeadLockAlert(), CheckMyDatabase(), CLIENT_CONNECTION_CHECK_TIMEOUT, ClientCheckTimeoutHandler(), CommitTransactionCommand(), CreateAuxProcessResourceOwner(), CurrentResourceOwner, 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(), InitCatalogCache(), initialize_acl(), InitializeClientEncoding(), InitializeSearchPath(), InitializeSession(), InitializeSessionUserId(), InitializeSessionUserIdStandalone(), InitializeSystemUser(), InitPlanCache(), InitProcessPhase2(), InvalidateCatalogSnapshot(), InvalidBackendId, IsAutoVacuumLauncherProcess(), IsAutoVacuumWorkerProcess(), IsBackgroundWorker, IsBinaryUpgrade, IsBootstrapProcessingMode, IsUnderPostmaster, LOCK_TIMEOUT, LockSharedObject(), LockTimeoutHandler(), MaxBackends, MyBackendId, MyClientConnectionInfo, MyDatabaseId, MyDatabaseTableSpace, MyProc, MyProcPort, NAMEDATALEN, NameStr, 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(), username, ValidatePgVersion(), WARNING, XACT_READ_COMMITTED, and XactIsoLevel.

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

◆ 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 not because the postmaster
      * launches its children from signal handlers, so we might be running on
      * an alternative stack.
      */
     (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 BackendStartup(), do_start_bgworker(), StartAutoVacWorker(), StartChildProcess(), and SysLogger_Start().

◆ InitProcessLocalLatch()

void InitProcessLocalLatch ( void )

Definition at line 242 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 182 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 649 of file miscinit.c.

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

References SECURITY_LOCAL_USERID_CHANGE, and SecurityRestrictionContext.

Referenced by GetUserIdAndContext(), and set_config_option_ext().

◆ InNoForceRLSOperation()

bool InNoForceRLSOperation ( void )

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

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

References SECURITY_RESTRICTED_OPERATION, and SecurityRestrictionContext.

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

◆ pg_bindtextdomain()

void pg_bindtextdomain ( const char * domain )

Definition at line 1884 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 508 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 448 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 429 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 411 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 1861 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 1847 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 1875 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 3149 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 (IsAutoVacuumWorkerProcess())
             ereport(FATAL,
                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
                      errmsg("terminating autovacuum process due to administrator command")));
         else if (IsLogicalWorker())
             ereport(FATAL,
                     (errcode(ERRCODE_ADMIN_SHUTDOWN),
                      errmsg("terminating logical replication worker due to administrator command")));
         else if (IsLogicalLauncher())
         {
             ereport(DEBUG1,
                     (errmsg_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 (RecoveryConflictPending && RecoveryConflictRetryable)
         {
             pgstat_report_recovery_conflict(RecoveryConflictReason);
             ereport(FATAL,
                     (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                      errmsg("terminating connection due to conflict with recovery"),
                      errdetail_recovery_conflict()));
         }
         else if (RecoveryConflictPending)
         {
             /* Currently there is only one non-retryable recovery conflict */
             Assert(RecoveryConflictReason == PROCSIG_RECOVERY_CONFLICT_DATABASE);
             pgstat_report_recovery_conflict(RecoveryConflictReason);
             ereport(FATAL,
                     (errcode(ERRCODE_DATABASE_DROPPED),
                      errmsg("terminating connection due to conflict with recovery"),
                      errdetail_recovery_conflict()));
         }
         else if (IsBackgroundWorker)
             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")));
     }
  
     /*
      * If a recovery conflict happens while we are waiting for input from the
      * client, the client is presumably just sitting idle in a transaction,
      * preventing recovery from making progress.  Terminate the connection to
      * dislodge it.
      */
     if (RecoveryConflictPending && DoingCommandRead)
     {
         QueryCancelPending = false; /* this trumps QueryCancel */
         RecoveryConflictPending = false;
         LockErrorCleanup();
         pgstat_report_recovery_conflict(RecoveryConflictReason);
         ereport(FATAL,
                 (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                  errmsg("terminating connection due to conflict with recovery"),
                  errdetail_recovery_conflict(),
                  errhint("In a moment you should be able to reconnect to the"
                          " database and repeat your command.")));
     }
  
     /*
      * Don't allow query cancel interrupts while reading input from the
      * client, because we might lose sync in the FE/BE protocol.  (Die
      * interrupts are OK, because we won't read any further messages from the
      * client in that case.)
      */
     if (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 (IsAutoVacuumWorkerProcess())
         {
             LockErrorCleanup();
             ereport(ERROR,
                     (errcode(ERRCODE_QUERY_CANCELED),
                      errmsg("canceling autovacuum task")));
         }
         if (RecoveryConflictPending)
         {
             RecoveryConflictPending = false;
             LockErrorCleanup();
             pgstat_report_recovery_conflict(RecoveryConflictReason);
             ereport(ERROR,
                     (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                      errmsg("canceling statement due to conflict with recovery"),
                      errdetail_recovery_conflict()));
         }
  
         /*
          * If we are reading a command from the client, just ignore the cancel
          * request --- sending an extra error message won't accomplish
          * anything.  Otherwise, go ahead and throw the error.
          */
         if (!DoingCommandRead)
         {
             LockErrorCleanup();
             ereport(ERROR,
                     (errcode(ERRCODE_QUERY_CANCELED),
                      errmsg("canceling statement due to user request")));
         }
     }
  
     if (IdleInTransactionSessionTimeoutPending)
     {
         /*
          * 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.
          */
         if (IdleInTransactionSessionTimeout > 0)
             ereport(FATAL,
                     (errcode(ERRCODE_IDLE_IN_TRANSACTION_SESSION_TIMEOUT),
                      errmsg("terminating connection due to idle-in-transaction timeout")));
         else
             IdleInTransactionSessionTimeoutPending = false;
     }
  
     if (IdleSessionTimeoutPending)
     {
         /* As above, ignore the signal if the GUC has been reset to zero. */
         if (IdleSessionTimeout > 0)
             ereport(FATAL,
                     (errcode(ERRCODE_IDLE_SESSION_TIMEOUT),
                      errmsg("terminating connection due to idle-session timeout")));
         else
             IdleSessionTimeoutPending = false;
     }
  
     /*
      * 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 Assert(), BackgroundWorker::bgw_type, CheckClientConnectionPending, client_connection_check_interval, CLIENT_CONNECTION_CHECK_TIMEOUT, ClientAuthInProgress, ClientConnectionLost, CritSectionCount, DEBUG1, DestNone, DestRemote, DoingCommandRead, enable_timeout_after(), ereport, errcode(), ERRCODE_T_R_SERIALIZATION_FAILURE, errdetail_recovery_conflict(), errhint(), errmsg(), errmsg_internal(), ERROR, FATAL, get_timeout_finish_time(), get_timeout_indicator(), HandleParallelApplyMessages(), HandleParallelMessages(), IdleInTransactionSessionTimeout, IdleInTransactionSessionTimeoutPending, IdleSessionTimeout, IdleSessionTimeoutPending, IdleStatsUpdateTimeoutPending, InterruptHoldoffCount, InterruptPending, IsAutoVacuumWorkerProcess(), IsBackgroundWorker, IsLogicalLauncher(), IsLogicalWorker(), IsTransactionOrTransactionBlock(), LOCK_TIMEOUT, LockErrorCleanup(), LogMemoryContextPending, MyBgworkerEntry, ParallelApplyMessagePending, ParallelMessagePending, pgstat_report_recovery_conflict(), pgstat_report_stat(), pq_check_connection(), proc_exit(), ProcDiePending, ProcessLogMemoryContextInterrupt(), ProcessProcSignalBarrier(), PROCSIG_RECOVERY_CONFLICT_DATABASE, ProcSignalBarrierPending, QueryCancelHoldoffCount, QueryCancelPending, RecoveryConflictPending, RecoveryConflictReason, RecoveryConflictRetryable, STATEMENT_TIMEOUT, and whereToSendOutput.

Referenced by die().

◆ RecheckDataDirLockFile()

bool RecheckDataDirLockFile ( void )

Definition at line 1642 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(), read, and WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ.

Referenced by ServerLoop().

◆ restore_stack_base()

void restore_stack_base ( pg_stack_base_t base )

Definition at line 3444 of file postgres.c.

 {
     stack_base_ptr = base;
 }

References stack_base_ptr.

◆ RestoreClientConnectionInfo()

void RestoreClientConnectionInfo ( char * conninfo )

Definition at line 1079 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 1047 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 3411 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 949 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 323 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 429 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 903 of file miscinit.c.

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

References Assert(), AuthenticatedUserId, AuthenticatedUserIsSuperuser, ereport, errcode(), errmsg(), ERROR, is_superuser(), OidIsValid, 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 687 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 638 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(), ExecCreateTableAs(), ExecRefreshMatView(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), ParallelWorkerMain(), refresh_by_match_merge(), reindex_index(), ReindexRelationConcurrently(), ri_PerformCheck(), ri_PlanCheck(), vacuum_rel(), and validate_index().

◆ stack_is_too_deep()

bool stack_is_too_deep ( void )

Definition at line 3475 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(), and rstacktoodeep().

◆ 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(), 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_import_system_collations(), pg_logdir_ls(), pg_nextoid(), pg_read_file(), pg_relpages(), pg_relpagesbyid(), pg_rotate_logfile(), 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(), requireSuperuser(), 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 AUTHOID, 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(), AlterSubscriptionOwner_internal(), check_conn_params(), check_object_ownership(), check_role_grantor(), check_role_membership_authorization(), connect_pg_server(), CreateRole(), emit_audit_message(), 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(), object_ownercheck(), pg_class_aclmask_ext(), pg_largeobject_aclmask_snapshot(), pg_namespace_aclmask(), pg_parameter_acl_aclmask(), pg_parameter_aclmask(), pg_signal_backend(), pg_type_aclmask(), 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 249 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 222 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 1486 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().

◆ trace_recovery()

int trace_recovery ( int trace_level )

Definition at line 3749 of file elog.c.

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

References LOG, and trace_recovery_messages.

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

◆ ValidatePgVersion()

void ValidatePgVersion ( const char * path )

Definition at line 1714 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)));
 }