#include "datatype/timestamp.h"
#include "libpq/pqcomm.h"
#include "miscadmin.h"
#include "port/atomics.h"
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
#include "storage/proc.h"
#include "utils/hsearch.h"
#include "utils/relcache.h"

Include dependency graph for pgstat.h:

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

Go to the source code of this file.

Data Structures
struct	PgStat_TableCounts

struct	PgStat_TableStatus

struct	PgStat_TableXactStatus

struct	PgStat_MsgHdr

struct	PgStat_MsgDummy

struct	PgStat_MsgInquiry

struct	PgStat_TableEntry

struct	PgStat_MsgTabstat

struct	PgStat_MsgTabpurge

struct	PgStat_MsgDropdb

struct	PgStat_MsgResetcounter

struct	PgStat_MsgResetsharedcounter

struct	PgStat_MsgResetsinglecounter

struct	PgStat_MsgResetslrucounter

struct	PgStat_MsgAutovacStart

struct	PgStat_MsgVacuum

struct	PgStat_MsgAnalyze

struct	PgStat_MsgArchiver

struct	PgStat_MsgBgWriter

struct	PgStat_MsgSLRU

struct	PgStat_MsgRecoveryConflict

struct	PgStat_MsgTempFile

struct	PgStat_FunctionCounts

struct	PgStat_BackendFunctionEntry

struct	PgStat_FunctionEntry

struct	PgStat_MsgFuncstat

struct	PgStat_MsgFuncpurge

struct	PgStat_MsgDeadlock

struct	PgStat_MsgChecksumFailure

union	PgStat_Msg

struct	PgStat_StatDBEntry

struct	PgStat_StatTabEntry

struct	PgStat_StatFuncEntry

struct	PgStat_ArchiverStats

struct	PgStat_GlobalStats

struct	PgStat_SLRUStats

struct	PgBackendSSLStatus

struct	PgBackendGSSStatus

struct	PgBackendStatus

struct	LocalPgBackendStatus

struct	PgStat_FunctionCallUsage

Macros
#define	PGSTAT_STAT_PERMANENT_DIRECTORY "pg_stat"

#define	PGSTAT_STAT_PERMANENT_FILENAME "pg_stat/global.stat"

#define	PGSTAT_STAT_PERMANENT_TMPFILE "pg_stat/global.tmp"

#define	PG_STAT_TMP_DIR "pg_stat_tmp"

#define	PGSTAT_MAX_MSG_SIZE 1000

#define	PGSTAT_MSG_PAYLOAD (PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr))

#define	PGSTAT_NUM_TABENTRIES

#define	PGSTAT_NUM_TABPURGE

#define	PGSTAT_NUM_FUNCENTRIES

#define	PGSTAT_NUM_FUNCPURGE

#define	PGSTAT_FILE_FORMAT_ID 0x01A5BC9D

#define	PG_WAIT_LWLOCK 0x01000000U

#define	PG_WAIT_LOCK 0x03000000U

#define	PG_WAIT_BUFFER_PIN 0x04000000U

#define	PG_WAIT_ACTIVITY 0x05000000U

#define	PG_WAIT_CLIENT 0x06000000U

#define	PG_WAIT_EXTENSION 0x07000000U

#define	PG_WAIT_IPC 0x08000000U

#define	PG_WAIT_TIMEOUT 0x09000000U

#define	PG_WAIT_IO 0x0A000000U

#define	PGSTAT_NUM_PROGRESS_PARAM 20

#define	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)

#define	PGSTAT_END_WRITE_ACTIVITY(beentry)

#define	pgstat_begin_read_activity(beentry, before_changecount)

#define	pgstat_end_read_activity(beentry, after_changecount)

#define	pgstat_read_activity_complete(before_changecount, after_changecount)

#define	pgstat_count_heap_scan(rel)

#define	pgstat_count_heap_getnext(rel)

#define	pgstat_count_heap_fetch(rel)

#define	pgstat_count_index_scan(rel)

#define	pgstat_count_index_tuples(rel, n)

#define	pgstat_count_buffer_read(rel)

#define	pgstat_count_buffer_hit(rel)

#define	pgstat_count_buffer_read_time(n) (pgStatBlockReadTime += (n))

#define	pgstat_count_buffer_write_time(n) (pgStatBlockWriteTime += (n))

Typedefs
typedef enum TrackFunctionsLevel	TrackFunctionsLevel

typedef enum StatMsgType	StatMsgType

typedef int64	PgStat_Counter

typedef struct PgStat_TableCounts	PgStat_TableCounts

typedef enum PgStat_Shared_Reset_Target	PgStat_Shared_Reset_Target

typedef enum PgStat_Single_Reset_Type	PgStat_Single_Reset_Type

typedef struct PgStat_TableStatus	PgStat_TableStatus

typedef struct PgStat_TableXactStatus	PgStat_TableXactStatus

typedef struct PgStat_MsgHdr	PgStat_MsgHdr

typedef struct PgStat_MsgDummy	PgStat_MsgDummy

typedef struct PgStat_MsgInquiry	PgStat_MsgInquiry

typedef struct PgStat_TableEntry	PgStat_TableEntry

typedef struct PgStat_MsgTabstat	PgStat_MsgTabstat

typedef struct PgStat_MsgTabpurge	PgStat_MsgTabpurge

typedef struct PgStat_MsgDropdb	PgStat_MsgDropdb

typedef struct PgStat_MsgResetcounter	PgStat_MsgResetcounter

typedef struct PgStat_MsgResetsharedcounter	PgStat_MsgResetsharedcounter

typedef struct PgStat_MsgResetsinglecounter	PgStat_MsgResetsinglecounter

typedef struct PgStat_MsgResetslrucounter	PgStat_MsgResetslrucounter

typedef struct PgStat_MsgAutovacStart	PgStat_MsgAutovacStart

typedef struct PgStat_MsgVacuum	PgStat_MsgVacuum

typedef struct PgStat_MsgAnalyze	PgStat_MsgAnalyze

typedef struct PgStat_MsgArchiver	PgStat_MsgArchiver

typedef struct PgStat_MsgBgWriter	PgStat_MsgBgWriter

typedef struct PgStat_MsgSLRU	PgStat_MsgSLRU

typedef struct PgStat_MsgRecoveryConflict	PgStat_MsgRecoveryConflict

typedef struct PgStat_MsgTempFile	PgStat_MsgTempFile

typedef struct PgStat_FunctionCounts	PgStat_FunctionCounts

typedef struct PgStat_BackendFunctionEntry	PgStat_BackendFunctionEntry

typedef struct PgStat_FunctionEntry	PgStat_FunctionEntry

typedef struct PgStat_MsgFuncstat	PgStat_MsgFuncstat

typedef struct PgStat_MsgFuncpurge	PgStat_MsgFuncpurge

typedef struct PgStat_MsgDeadlock	PgStat_MsgDeadlock

typedef struct PgStat_MsgChecksumFailure	PgStat_MsgChecksumFailure

typedef union PgStat_Msg	PgStat_Msg

typedef struct PgStat_StatDBEntry	PgStat_StatDBEntry

typedef struct PgStat_StatTabEntry	PgStat_StatTabEntry

typedef struct PgStat_StatFuncEntry	PgStat_StatFuncEntry

typedef struct PgStat_ArchiverStats	PgStat_ArchiverStats

typedef struct PgStat_GlobalStats	PgStat_GlobalStats

typedef struct PgStat_SLRUStats	PgStat_SLRUStats

typedef enum BackendState	BackendState

typedef enum ProgressCommandType	ProgressCommandType

typedef struct PgBackendSSLStatus	PgBackendSSLStatus

typedef struct PgBackendGSSStatus	PgBackendGSSStatus

typedef struct PgBackendStatus	PgBackendStatus

typedef struct LocalPgBackendStatus	LocalPgBackendStatus

typedef struct PgStat_FunctionCallUsage	PgStat_FunctionCallUsage

Enumerations
enum	TrackFunctionsLevel { TRACK_FUNC_OFF, TRACK_FUNC_PL, TRACK_FUNC_ALL }

enum	StatMsgType { PGSTAT_MTYPE_DUMMY, PGSTAT_MTYPE_INQUIRY, PGSTAT_MTYPE_TABSTAT, PGSTAT_MTYPE_TABPURGE, PGSTAT_MTYPE_DROPDB, PGSTAT_MTYPE_RESETCOUNTER, PGSTAT_MTYPE_RESETSHAREDCOUNTER, PGSTAT_MTYPE_RESETSINGLECOUNTER, PGSTAT_MTYPE_RESETSLRUCOUNTER, PGSTAT_MTYPE_AUTOVAC_START, PGSTAT_MTYPE_VACUUM, PGSTAT_MTYPE_ANALYZE, PGSTAT_MTYPE_ARCHIVER, PGSTAT_MTYPE_BGWRITER, PGSTAT_MTYPE_SLRU, PGSTAT_MTYPE_FUNCSTAT, PGSTAT_MTYPE_FUNCPURGE, PGSTAT_MTYPE_RECOVERYCONFLICT, PGSTAT_MTYPE_TEMPFILE, PGSTAT_MTYPE_DEADLOCK, PGSTAT_MTYPE_CHECKSUMFAILURE }

enum	PgStat_Shared_Reset_Target { RESET_ARCHIVER, RESET_BGWRITER }

enum	PgStat_Single_Reset_Type { RESET_TABLE, RESET_FUNCTION }

enum	BackendState { STATE_UNDEFINED, STATE_IDLE, STATE_RUNNING, STATE_IDLEINTRANSACTION, STATE_FASTPATH, STATE_IDLEINTRANSACTION_ABORTED, STATE_DISABLED }

enum	WaitEventActivity { WAIT_EVENT_ARCHIVER_MAIN = PG_WAIT_ACTIVITY, WAIT_EVENT_AUTOVACUUM_MAIN, WAIT_EVENT_BGWRITER_HIBERNATE, WAIT_EVENT_BGWRITER_MAIN, WAIT_EVENT_CHECKPOINTER_MAIN, WAIT_EVENT_LOGICAL_APPLY_MAIN, WAIT_EVENT_LOGICAL_LAUNCHER_MAIN, WAIT_EVENT_PGSTAT_MAIN, WAIT_EVENT_RECOVERY_WAL_STREAM, WAIT_EVENT_SYSLOGGER_MAIN, WAIT_EVENT_WAL_RECEIVER_MAIN, WAIT_EVENT_WAL_SENDER_MAIN, WAIT_EVENT_WAL_WRITER_MAIN }

enum	WaitEventClient { WAIT_EVENT_CLIENT_READ = PG_WAIT_CLIENT, WAIT_EVENT_CLIENT_WRITE, WAIT_EVENT_GSS_OPEN_SERVER, WAIT_EVENT_LIBPQWALRECEIVER_CONNECT, WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE, WAIT_EVENT_SSL_OPEN_SERVER, WAIT_EVENT_WAL_RECEIVER_WAIT_START, WAIT_EVENT_WAL_SENDER_WAIT_WAL, WAIT_EVENT_WAL_SENDER_WRITE_DATA }

enum	WaitEventIPC { WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE = PG_WAIT_IPC, WAIT_EVENT_BGWORKER_SHUTDOWN, WAIT_EVENT_BGWORKER_STARTUP, WAIT_EVENT_BTREE_PAGE, WAIT_EVENT_CHECKPOINT_DONE, WAIT_EVENT_CHECKPOINT_START, WAIT_EVENT_EXECUTE_GATHER, WAIT_EVENT_HASH_BATCH_ALLOCATE, WAIT_EVENT_HASH_BATCH_ELECT, WAIT_EVENT_HASH_BATCH_LOAD, WAIT_EVENT_HASH_BUILD_ALLOCATE, WAIT_EVENT_HASH_BUILD_ELECT, WAIT_EVENT_HASH_BUILD_HASH_INNER, WAIT_EVENT_HASH_BUILD_HASH_OUTER, WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATE, WAIT_EVENT_HASH_GROW_BATCHES_DECIDE, WAIT_EVENT_HASH_GROW_BATCHES_ELECT, WAIT_EVENT_HASH_GROW_BATCHES_FINISH, WAIT_EVENT_HASH_GROW_BATCHES_REPARTITION, WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATE, WAIT_EVENT_HASH_GROW_BUCKETS_ELECT, WAIT_EVENT_HASH_GROW_BUCKETS_REINSERT, WAIT_EVENT_LOGICAL_SYNC_DATA, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE, WAIT_EVENT_MQ_INTERNAL, WAIT_EVENT_MQ_PUT_MESSAGE, WAIT_EVENT_MQ_RECEIVE, WAIT_EVENT_MQ_SEND, WAIT_EVENT_PARALLEL_BITMAP_SCAN, WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN, WAIT_EVENT_PARALLEL_FINISH, WAIT_EVENT_PROCARRAY_GROUP_UPDATE, WAIT_EVENT_PROC_SIGNAL_BARRIER, WAIT_EVENT_PROMOTE, WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT, WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE, WAIT_EVENT_RECOVERY_PAUSE, WAIT_EVENT_REPLICATION_ORIGIN_DROP, WAIT_EVENT_REPLICATION_SLOT_DROP, WAIT_EVENT_SAFE_SNAPSHOT, WAIT_EVENT_SYNC_REP, WAIT_EVENT_XACT_GROUP_UPDATE }

enum	WaitEventTimeout { WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT, WAIT_EVENT_PG_SLEEP, WAIT_EVENT_RECOVERY_APPLY_DELAY, WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL, WAIT_EVENT_VACUUM_DELAY }

enum	WaitEventIO { WAIT_EVENT_BASEBACKUP_READ = PG_WAIT_IO, WAIT_EVENT_BUFFILE_READ, WAIT_EVENT_BUFFILE_WRITE, WAIT_EVENT_BUFFILE_TRUNCATE, WAIT_EVENT_CONTROL_FILE_READ, WAIT_EVENT_CONTROL_FILE_SYNC, WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE, WAIT_EVENT_CONTROL_FILE_WRITE, WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE, WAIT_EVENT_COPY_FILE_READ, WAIT_EVENT_COPY_FILE_WRITE, WAIT_EVENT_DATA_FILE_EXTEND, WAIT_EVENT_DATA_FILE_FLUSH, WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC, WAIT_EVENT_DATA_FILE_PREFETCH, WAIT_EVENT_DATA_FILE_READ, WAIT_EVENT_DATA_FILE_SYNC, WAIT_EVENT_DATA_FILE_TRUNCATE, WAIT_EVENT_DATA_FILE_WRITE, WAIT_EVENT_DSM_FILL_ZERO_WRITE, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE, WAIT_EVENT_LOCK_FILE_CREATE_READ, WAIT_EVENT_LOCK_FILE_CREATE_SYNC, WAIT_EVENT_LOCK_FILE_CREATE_WRITE, WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ, WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC, WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC, WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE, WAIT_EVENT_LOGICAL_REWRITE_SYNC, WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE, WAIT_EVENT_LOGICAL_REWRITE_WRITE, WAIT_EVENT_RELATION_MAP_READ, WAIT_EVENT_RELATION_MAP_SYNC, WAIT_EVENT_RELATION_MAP_WRITE, WAIT_EVENT_REORDER_BUFFER_READ, WAIT_EVENT_REORDER_BUFFER_WRITE, WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ, WAIT_EVENT_REPLICATION_SLOT_READ, WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC, WAIT_EVENT_REPLICATION_SLOT_SYNC, WAIT_EVENT_REPLICATION_SLOT_WRITE, WAIT_EVENT_SLRU_FLUSH_SYNC, WAIT_EVENT_SLRU_READ, WAIT_EVENT_SLRU_SYNC, WAIT_EVENT_SLRU_WRITE, WAIT_EVENT_SNAPBUILD_READ, WAIT_EVENT_SNAPBUILD_SYNC, WAIT_EVENT_SNAPBUILD_WRITE, WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC, WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE, WAIT_EVENT_TIMELINE_HISTORY_READ, WAIT_EVENT_TIMELINE_HISTORY_SYNC, WAIT_EVENT_TIMELINE_HISTORY_WRITE, WAIT_EVENT_TWOPHASE_FILE_READ, WAIT_EVENT_TWOPHASE_FILE_SYNC, WAIT_EVENT_TWOPHASE_FILE_WRITE, WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ, WAIT_EVENT_WAL_BOOTSTRAP_SYNC, WAIT_EVENT_WAL_BOOTSTRAP_WRITE, WAIT_EVENT_WAL_COPY_READ, WAIT_EVENT_WAL_COPY_SYNC, WAIT_EVENT_WAL_COPY_WRITE, WAIT_EVENT_WAL_INIT_SYNC, WAIT_EVENT_WAL_INIT_WRITE, WAIT_EVENT_WAL_READ, WAIT_EVENT_WAL_SYNC, WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN, WAIT_EVENT_WAL_WRITE, WAIT_EVENT_LOGICAL_CHANGES_READ, WAIT_EVENT_LOGICAL_CHANGES_WRITE, WAIT_EVENT_LOGICAL_SUBXACT_READ, WAIT_EVENT_LOGICAL_SUBXACT_WRITE }

enum	ProgressCommandType { PROGRESS_COMMAND_INVALID, PROGRESS_COMMAND_VACUUM, PROGRESS_COMMAND_ANALYZE, PROGRESS_COMMAND_CLUSTER, PROGRESS_COMMAND_CREATE_INDEX, PROGRESS_COMMAND_BASEBACKUP }

Functions
Size	BackendStatusShmemSize (void)

void	CreateSharedBackendStatus (void)

void	pgstat_init (void)

int	pgstat_start (void)

void	pgstat_reset_all (void)

void	allow_immediate_pgstat_restart (void)

void	pgstat_ping (void)

void	pgstat_report_stat (bool force)

void	pgstat_vacuum_stat (void)

void	pgstat_drop_database (Oid databaseid)

void	pgstat_clear_snapshot (void)

void	pgstat_reset_counters (void)

void	pgstat_reset_shared_counters (const char *)

void	pgstat_reset_single_counter (Oid objectid, PgStat_Single_Reset_Type type)

void	pgstat_reset_slru_counter (const char *)

void	pgstat_report_autovac (Oid dboid)

void	pgstat_report_vacuum (Oid tableoid, bool shared, PgStat_Counter livetuples, PgStat_Counter deadtuples)

void	pgstat_report_analyze (Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, bool resetcounter)

void	pgstat_report_recovery_conflict (int reason)

void	pgstat_report_deadlock (void)

void	pgstat_report_checksum_failures_in_db (Oid dboid, int failurecount)

void	pgstat_report_checksum_failure (void)

void	pgstat_initialize (void)

void	pgstat_bestart (void)

void	pgstat_report_activity (BackendState state, const char *cmd_str)

void	pgstat_report_tempfile (size_t filesize)

void	pgstat_report_appname (const char *appname)

void	pgstat_report_xact_timestamp (TimestampTz tstamp)

const char *	pgstat_get_wait_event (uint32 wait_event_info)

const char *	pgstat_get_wait_event_type (uint32 wait_event_info)

const char *	pgstat_get_backend_current_activity (int pid, bool checkUser)

const char *	pgstat_get_crashed_backend_activity (int pid, char *buffer, int buflen)

void	pgstat_progress_start_command (ProgressCommandType cmdtype, Oid relid)

void	pgstat_progress_update_param (int index, int64 val)

void	pgstat_progress_update_multi_param (int nparam, const int index, const int64 val)

void	pgstat_progress_end_command (void)

PgStat_TableStatus *	find_tabstat_entry (Oid rel_id)

PgStat_BackendFunctionEntry *	find_funcstat_entry (Oid func_id)

void	pgstat_initstats (Relation rel)

char *	pgstat_clip_activity (const char *raw_activity)

static void	pgstat_report_wait_start (uint32 wait_event_info)

static void	pgstat_report_wait_end (void)

void	pgstat_count_heap_insert (Relation rel, PgStat_Counter n)

void	pgstat_count_heap_update (Relation rel, bool hot)

void	pgstat_count_heap_delete (Relation rel)

void	pgstat_count_truncate (Relation rel)

void	pgstat_update_heap_dead_tuples (Relation rel, int delta)

void	pgstat_init_function_usage (struct FunctionCallInfoBaseData fcinfo, PgStat_FunctionCallUsage fcu)

void	pgstat_end_function_usage (PgStat_FunctionCallUsage *fcu, bool finalize)

void	AtEOXact_PgStat (bool isCommit, bool parallel)

void	AtEOSubXact_PgStat (bool isCommit, int nestDepth)

void	AtPrepare_PgStat (void)

void	PostPrepare_PgStat (void)

void	pgstat_twophase_postcommit (TransactionId xid, uint16 info, void *recdata, uint32 len)

void	pgstat_twophase_postabort (TransactionId xid, uint16 info, void *recdata, uint32 len)

void	pgstat_send_archiver (const char *xlog, bool failed)

void	pgstat_send_bgwriter (void)

PgStat_StatDBEntry *	pgstat_fetch_stat_dbentry (Oid dbid)

PgStat_StatTabEntry *	pgstat_fetch_stat_tabentry (Oid relid)

PgBackendStatus *	pgstat_fetch_stat_beentry (int beid)

LocalPgBackendStatus *	pgstat_fetch_stat_local_beentry (int beid)

PgStat_StatFuncEntry *	pgstat_fetch_stat_funcentry (Oid funcid)

int	pgstat_fetch_stat_numbackends (void)

PgStat_ArchiverStats *	pgstat_fetch_stat_archiver (void)

PgStat_GlobalStats *	pgstat_fetch_global (void)

PgStat_SLRUStats *	pgstat_fetch_slru (void)

void	pgstat_count_slru_page_zeroed (int slru_idx)

void	pgstat_count_slru_page_hit (int slru_idx)

void	pgstat_count_slru_page_read (int slru_idx)

void	pgstat_count_slru_page_written (int slru_idx)

void	pgstat_count_slru_page_exists (int slru_idx)

void	pgstat_count_slru_flush (int slru_idx)

void	pgstat_count_slru_truncate (int slru_idx)

const char *	pgstat_slru_name (int slru_idx)

int	pgstat_slru_index (const char *name)

Macro Definition Documentation

◆ PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR "pg_stat_tmp"

Definition at line 34 of file pgstat.h.

◆ PG_WAIT_ACTIVITY

#define PG_WAIT_ACTIVITY 0x05000000U

Definition at line 787 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ PG_WAIT_BUFFER_PIN

#define PG_WAIT_BUFFER_PIN 0x04000000U

Definition at line 786 of file pgstat.h.

Referenced by LockBufferForCleanup(), pgstat_get_wait_event(), pgstat_get_wait_event_type(), and ResolveRecoveryConflictWithBufferPin().

◆ PG_WAIT_CLIENT

#define PG_WAIT_CLIENT 0x06000000U

Definition at line 788 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ PG_WAIT_EXTENSION

#define PG_WAIT_EXTENSION 0x07000000U

Definition at line 789 of file pgstat.h.

Referenced by autoprewarm_main(), initialize_worker_spi(), pgfdw_get_cleanup_result(), pgfdw_get_result(), pgstat_get_wait_event(), pgstat_get_wait_event_type(), test_shm_mq_pipelined(), and wait_for_workers_to_become_ready().

◆ PG_WAIT_IO

#define PG_WAIT_IO 0x0A000000U

Definition at line 792 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ PG_WAIT_IPC

#define PG_WAIT_IPC 0x08000000U

Definition at line 790 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ PG_WAIT_LOCK

#define PG_WAIT_LOCK 0x03000000U

Definition at line 785 of file pgstat.h.

Referenced by pgstat_get_wait_event(), pgstat_get_wait_event_type(), ProcSleep(), and ResolveRecoveryConflictWithLock().

◆ PG_WAIT_LWLOCK

#define PG_WAIT_LWLOCK 0x01000000U

Definition at line 784 of file pgstat.h.

Referenced by GetLWLockIdentifier(), LWLockReportWaitStart(), pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ PG_WAIT_TIMEOUT

#define PG_WAIT_TIMEOUT 0x09000000U

Definition at line 791 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ pgstat_begin_read_activity

#define pgstat_begin_read_activity	(	beentry,
		before_changecount
	)

Value:

do { \
        (before_changecount) = (beentry)->st_changecount; \
        pg_read_barrier(); \
    } while (0)

Definition at line 1189 of file pgstat.h.

Referenced by pgstat_get_backend_current_activity(), and pgstat_read_current_status().

◆ PGSTAT_BEGIN_WRITE_ACTIVITY

#define PGSTAT_BEGIN_WRITE_ACTIVITY ( beentry )

Value:

do { \
        START_CRIT_SECTION(); \
        (beentry)->st_changecount++; \
        pg_write_barrier(); \
    } while (0)

Definition at line 1174 of file pgstat.h.

Referenced by pgstat_beshutdown_hook(), pgstat_bestart(), pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_multi_param(), pgstat_progress_update_param(), pgstat_report_activity(), pgstat_report_appname(), and pgstat_report_xact_timestamp().

◆ pgstat_count_buffer_hit

#define pgstat_count_buffer_hit ( rel )

Value:

do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_blocks_hit++;            \
    } while (0)

Definition at line 1432 of file pgstat.h.

Referenced by ReadBufferExtended().

◆ pgstat_count_buffer_read

#define pgstat_count_buffer_read ( rel )

Value:

do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_blocks_fetched++;        \
    } while (0)

Definition at line 1427 of file pgstat.h.

Referenced by ReadBufferExtended().

◆ pgstat_count_buffer_read_time

#define pgstat_count_buffer_read_time ( n ) (pgStatBlockReadTime += (n))

Definition at line 1437 of file pgstat.h.

Referenced by ReadBuffer_common().

◆ pgstat_count_buffer_write_time

#define pgstat_count_buffer_write_time ( n ) (pgStatBlockWriteTime += (n))

Definition at line 1439 of file pgstat.h.

Referenced by FlushBuffer().

◆ pgstat_count_heap_fetch

#define pgstat_count_heap_fetch ( rel )

Value:

do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_tuples_fetched++;        \
    } while (0)

Definition at line 1412 of file pgstat.h.

Referenced by heapam_scan_bitmap_next_tuple(), and index_fetch_heap().

◆ pgstat_count_heap_getnext

#define pgstat_count_heap_getnext ( rel )

Value:

do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_tuples_returned++;       \
    } while (0)

Definition at line 1407 of file pgstat.h.

Referenced by heap_getnext(), heap_getnextslot(), and heapam_scan_sample_next_tuple().

◆ pgstat_count_heap_scan

#define pgstat_count_heap_scan ( rel )

Value:

do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_numscans++;              \
    } while (0)

Definition at line 1402 of file pgstat.h.

Referenced by initscan().

◆ pgstat_count_index_scan

#define pgstat_count_index_scan ( rel )

Value:

do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_numscans++;              \
    } while (0)

Definition at line 1417 of file pgstat.h.

Referenced by _bt_first(), _hash_first(), bringetbitmap(), gistgetbitmap(), and gistgettuple().

◆ pgstat_count_index_tuples

#define pgstat_count_index_tuples	(	rel,
		n
	)

Value:

do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_tuples_returned += (n);  \
    } while (0)

Definition at line 1422 of file pgstat.h.

Referenced by index_getbitmap(), and index_getnext_tid().

◆ pgstat_end_read_activity

#define pgstat_end_read_activity	(	beentry,
		after_changecount
	)

Value:

do { \
        pg_read_barrier(); \
        (after_changecount) = (beentry)->st_changecount; \
    } while (0)

Definition at line 1195 of file pgstat.h.

Referenced by pgstat_get_backend_current_activity(), and pgstat_read_current_status().

◆ PGSTAT_END_WRITE_ACTIVITY

#define PGSTAT_END_WRITE_ACTIVITY ( beentry )

Value:

do { \
        pg_write_barrier(); \
        (beentry)->st_changecount++; \
        Assert(((beentry)->st_changecount & 1) == 0); \
        END_CRIT_SECTION(); \
    } while (0)

Definition at line 1181 of file pgstat.h.

Referenced by pgstat_beshutdown_hook(), pgstat_bestart(), pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_multi_param(), pgstat_progress_update_param(), pgstat_report_activity(), pgstat_report_appname(), and pgstat_report_xact_timestamp().

◆ PGSTAT_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID 0x01A5BC9D

Definition at line 617 of file pgstat.h.

Referenced by pgstat_read_db_statsfile(), pgstat_read_db_statsfile_timestamp(), pgstat_read_statsfiles(), pgstat_write_db_statsfile(), and pgstat_write_statsfiles().

◆ PGSTAT_MAX_MSG_SIZE

#define PGSTAT_MAX_MSG_SIZE 1000

Definition at line 209 of file pgstat.h.

Referenced by pgstat_init().

◆ PGSTAT_MSG_PAYLOAD

#define PGSTAT_MSG_PAYLOAD (PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr))

Definition at line 210 of file pgstat.h.

◆ PGSTAT_NUM_FUNCENTRIES

#define PGSTAT_NUM_FUNCENTRIES

Value:

((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \

/ sizeof(PgStat_FunctionEntry))

Oid

unsigned int Oid

Definition: postgres_ext.h:31

PgStat_FunctionEntry

Definition: pgstat.h:511

PGSTAT_MSG_PAYLOAD

#define PGSTAT_MSG_PAYLOAD

Definition: pgstat.h:210

Definition at line 524 of file pgstat.h.

Referenced by pgstat_send_funcstats().

◆ PGSTAT_NUM_FUNCPURGE

#define PGSTAT_NUM_FUNCPURGE

Value:

((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \

/ sizeof(Oid))

Oid

unsigned int Oid

Definition: postgres_ext.h:31

PGSTAT_MSG_PAYLOAD

#define PGSTAT_MSG_PAYLOAD

Definition: pgstat.h:210

Definition at line 541 of file pgstat.h.

Referenced by pgstat_vacuum_stat().

◆ PGSTAT_NUM_PROGRESS_PARAM

#define PGSTAT_NUM_PROGRESS_PARAM 20

Definition at line 1006 of file pgstat.h.

Referenced by pg_stat_get_progress_info(), pgstat_progress_update_multi_param(), and pgstat_progress_update_param().

◆ PGSTAT_NUM_TABENTRIES

#define PGSTAT_NUM_TABENTRIES

Value:

((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - 3 * sizeof(int) - 2 * sizeof(PgStat_Counter)) \

/ sizeof(PgStat_TableEntry))

PgStat_Counter

int64 PgStat_Counter

Definition: pgstat.h:77

Oid

unsigned int Oid

Definition: postgres_ext.h:31

PgStat_TableEntry

struct PgStat_TableEntry PgStat_TableEntry

PGSTAT_MSG_PAYLOAD

#define PGSTAT_MSG_PAYLOAD

Definition: pgstat.h:210

Definition at line 266 of file pgstat.h.

Referenced by pgstat_report_stat().

◆ PGSTAT_NUM_TABPURGE

#define PGSTAT_NUM_TABPURGE

Value:

((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \

/ sizeof(Oid))

Oid

unsigned int Oid

Definition: postgres_ext.h:31

PGSTAT_MSG_PAYLOAD

#define PGSTAT_MSG_PAYLOAD

Definition: pgstat.h:210

Definition at line 288 of file pgstat.h.

Referenced by pgstat_vacuum_stat().

◆ pgstat_read_activity_complete

#define pgstat_read_activity_complete	(	before_changecount,
		after_changecount
	)

Value:

((before_changecount) == (after_changecount) && \

((before_changecount) & 1) == 0)

Definition at line 1201 of file pgstat.h.

Referenced by pgstat_get_backend_current_activity(), and pgstat_read_current_status().

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

#define PGSTAT_STAT_PERMANENT_DIRECTORY "pg_stat"

Definition at line 29 of file pgstat.h.

Referenced by get_dbstat_filename(), and pgstat_reset_all().

◆ PGSTAT_STAT_PERMANENT_FILENAME

#define PGSTAT_STAT_PERMANENT_FILENAME "pg_stat/global.stat"

Definition at line 30 of file pgstat.h.

Referenced by pgstat_read_db_statsfile_timestamp(), pgstat_read_statsfiles(), and pgstat_write_statsfiles().

◆ PGSTAT_STAT_PERMANENT_TMPFILE

#define PGSTAT_STAT_PERMANENT_TMPFILE "pg_stat/global.tmp"

Definition at line 31 of file pgstat.h.

Referenced by pgstat_write_statsfiles().

Typedef Documentation

◆ BackendState

typedef enum BackendState BackendState

◆ LocalPgBackendStatus

typedef struct LocalPgBackendStatus LocalPgBackendStatus

◆ PgBackendGSSStatus

typedef struct PgBackendGSSStatus PgBackendGSSStatus

◆ PgBackendSSLStatus

typedef struct PgBackendSSLStatus PgBackendSSLStatus

◆ PgBackendStatus

typedef struct PgBackendStatus PgBackendStatus

◆ PgStat_ArchiverStats

typedef struct PgStat_ArchiverStats PgStat_ArchiverStats

◆ PgStat_BackendFunctionEntry

typedef struct PgStat_BackendFunctionEntry PgStat_BackendFunctionEntry

◆ PgStat_Counter

typedef int64 PgStat_Counter

Definition at line 77 of file pgstat.h.

◆ PgStat_FunctionCallUsage

typedef struct PgStat_FunctionCallUsage PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

typedef struct PgStat_FunctionCounts PgStat_FunctionCounts

◆ PgStat_FunctionEntry

typedef struct PgStat_FunctionEntry PgStat_FunctionEntry

◆ PgStat_GlobalStats

typedef struct PgStat_GlobalStats PgStat_GlobalStats

◆ PgStat_Msg

typedef union PgStat_Msg PgStat_Msg

◆ PgStat_MsgAnalyze

typedef struct PgStat_MsgAnalyze PgStat_MsgAnalyze

◆ PgStat_MsgArchiver

typedef struct PgStat_MsgArchiver PgStat_MsgArchiver

◆ PgStat_MsgAutovacStart

typedef struct PgStat_MsgAutovacStart PgStat_MsgAutovacStart

◆ PgStat_MsgBgWriter

typedef struct PgStat_MsgBgWriter PgStat_MsgBgWriter

◆ PgStat_MsgChecksumFailure

typedef struct PgStat_MsgChecksumFailure PgStat_MsgChecksumFailure

◆ PgStat_MsgDeadlock

typedef struct PgStat_MsgDeadlock PgStat_MsgDeadlock

◆ PgStat_MsgDropdb

typedef struct PgStat_MsgDropdb PgStat_MsgDropdb

◆ PgStat_MsgDummy

typedef struct PgStat_MsgDummy PgStat_MsgDummy

◆ PgStat_MsgFuncpurge

typedef struct PgStat_MsgFuncpurge PgStat_MsgFuncpurge

◆ PgStat_MsgFuncstat

typedef struct PgStat_MsgFuncstat PgStat_MsgFuncstat

◆ PgStat_MsgHdr

typedef struct PgStat_MsgHdr PgStat_MsgHdr

◆ PgStat_MsgInquiry

typedef struct PgStat_MsgInquiry PgStat_MsgInquiry

◆ PgStat_MsgRecoveryConflict

typedef struct PgStat_MsgRecoveryConflict PgStat_MsgRecoveryConflict

◆ PgStat_MsgResetcounter

typedef struct PgStat_MsgResetcounter PgStat_MsgResetcounter

◆ PgStat_MsgResetsharedcounter

typedef struct PgStat_MsgResetsharedcounter PgStat_MsgResetsharedcounter

◆ PgStat_MsgResetsinglecounter

typedef struct PgStat_MsgResetsinglecounter PgStat_MsgResetsinglecounter

◆ PgStat_MsgResetslrucounter

typedef struct PgStat_MsgResetslrucounter PgStat_MsgResetslrucounter

◆ PgStat_MsgSLRU

typedef struct PgStat_MsgSLRU PgStat_MsgSLRU

◆ PgStat_MsgTabpurge

typedef struct PgStat_MsgTabpurge PgStat_MsgTabpurge

◆ PgStat_MsgTabstat

typedef struct PgStat_MsgTabstat PgStat_MsgTabstat

◆ PgStat_MsgTempFile

typedef struct PgStat_MsgTempFile PgStat_MsgTempFile

◆ PgStat_MsgVacuum

typedef struct PgStat_MsgVacuum PgStat_MsgVacuum

◆ PgStat_Shared_Reset_Target

typedef enum PgStat_Shared_Reset_Target PgStat_Shared_Reset_Target

◆ PgStat_Single_Reset_Type

typedef enum PgStat_Single_Reset_Type PgStat_Single_Reset_Type

◆ PgStat_SLRUStats

typedef struct PgStat_SLRUStats PgStat_SLRUStats

◆ PgStat_StatDBEntry

typedef struct PgStat_StatDBEntry PgStat_StatDBEntry

◆ PgStat_StatFuncEntry

typedef struct PgStat_StatFuncEntry PgStat_StatFuncEntry

◆ PgStat_StatTabEntry

typedef struct PgStat_StatTabEntry PgStat_StatTabEntry

◆ PgStat_TableCounts

typedef struct PgStat_TableCounts PgStat_TableCounts

◆ PgStat_TableEntry

typedef struct PgStat_TableEntry PgStat_TableEntry

◆ PgStat_TableStatus

typedef struct PgStat_TableStatus PgStat_TableStatus

◆ PgStat_TableXactStatus

typedef struct PgStat_TableXactStatus PgStat_TableXactStatus

◆ ProgressCommandType

typedef enum ProgressCommandType ProgressCommandType

◆ StatMsgType

typedef enum StatMsgType StatMsgType

◆ TrackFunctionsLevel

typedef enum TrackFunctionsLevel TrackFunctionsLevel

Enumeration Type Documentation

◆ BackendState

enum BackendState

Enumerator
STATE_UNDEFINED
STATE_IDLE
STATE_RUNNING
STATE_IDLEINTRANSACTION
STATE_FASTPATH
STATE_IDLEINTRANSACTION_ABORTED
STATE_DISABLED

Definition at line 768 of file pgstat.h.

 {
     STATE_UNDEFINED,
     STATE_IDLE,
     STATE_RUNNING,
     STATE_IDLEINTRANSACTION,
     STATE_FASTPATH,
     STATE_IDLEINTRANSACTION_ABORTED,
     STATE_DISABLED
 } BackendState;

◆ PgStat_Shared_Reset_Target

enum PgStat_Shared_Reset_Target

Enumerator
RESET_ARCHIVER
RESET_BGWRITER

Definition at line 122 of file pgstat.h.

 {
     RESET_ARCHIVER,
     RESET_BGWRITER
 } PgStat_Shared_Reset_Target;

◆ PgStat_Single_Reset_Type

enum PgStat_Single_Reset_Type

Enumerator
RESET_TABLE
RESET_FUNCTION

Definition at line 129 of file pgstat.h.

 {
     RESET_TABLE,
     RESET_FUNCTION
 } PgStat_Single_Reset_Type;

◆ ProgressCommandType

enum ProgressCommandType

Enumerator
PROGRESS_COMMAND_INVALID
PROGRESS_COMMAND_VACUUM
PROGRESS_COMMAND_ANALYZE
PROGRESS_COMMAND_CLUSTER
PROGRESS_COMMAND_CREATE_INDEX
PROGRESS_COMMAND_BASEBACKUP

Definition at line 996 of file pgstat.h.

 {
     PROGRESS_COMMAND_INVALID,
     PROGRESS_COMMAND_VACUUM,
     PROGRESS_COMMAND_ANALYZE,
     PROGRESS_COMMAND_CLUSTER,
     PROGRESS_COMMAND_CREATE_INDEX,
     PROGRESS_COMMAND_BASEBACKUP
 } ProgressCommandType;

◆ StatMsgType

enum StatMsgType

Enumerator
PGSTAT_MTYPE_DUMMY
PGSTAT_MTYPE_INQUIRY
PGSTAT_MTYPE_TABSTAT
PGSTAT_MTYPE_TABPURGE
PGSTAT_MTYPE_DROPDB
PGSTAT_MTYPE_RESETCOUNTER
PGSTAT_MTYPE_RESETSHAREDCOUNTER
PGSTAT_MTYPE_RESETSINGLECOUNTER
PGSTAT_MTYPE_RESETSLRUCOUNTER
PGSTAT_MTYPE_AUTOVAC_START
PGSTAT_MTYPE_VACUUM
PGSTAT_MTYPE_ANALYZE
PGSTAT_MTYPE_ARCHIVER
PGSTAT_MTYPE_BGWRITER
PGSTAT_MTYPE_SLRU
PGSTAT_MTYPE_FUNCSTAT
PGSTAT_MTYPE_FUNCPURGE
PGSTAT_MTYPE_RECOVERYCONFLICT
PGSTAT_MTYPE_TEMPFILE
PGSTAT_MTYPE_DEADLOCK
PGSTAT_MTYPE_CHECKSUMFAILURE

Definition at line 48 of file pgstat.h.

 {
     PGSTAT_MTYPE_DUMMY,
     PGSTAT_MTYPE_INQUIRY,
     PGSTAT_MTYPE_TABSTAT,
     PGSTAT_MTYPE_TABPURGE,
     PGSTAT_MTYPE_DROPDB,
     PGSTAT_MTYPE_RESETCOUNTER,
     PGSTAT_MTYPE_RESETSHAREDCOUNTER,
     PGSTAT_MTYPE_RESETSINGLECOUNTER,
     PGSTAT_MTYPE_RESETSLRUCOUNTER,
     PGSTAT_MTYPE_AUTOVAC_START,
     PGSTAT_MTYPE_VACUUM,
     PGSTAT_MTYPE_ANALYZE,
     PGSTAT_MTYPE_ARCHIVER,
     PGSTAT_MTYPE_BGWRITER,
     PGSTAT_MTYPE_SLRU,
     PGSTAT_MTYPE_FUNCSTAT,
     PGSTAT_MTYPE_FUNCPURGE,
     PGSTAT_MTYPE_RECOVERYCONFLICT,
     PGSTAT_MTYPE_TEMPFILE,
     PGSTAT_MTYPE_DEADLOCK,
     PGSTAT_MTYPE_CHECKSUMFAILURE
 } StatMsgType;

◆ TrackFunctionsLevel

enum TrackFunctionsLevel

Enumerator
TRACK_FUNC_OFF
TRACK_FUNC_PL
TRACK_FUNC_ALL

Definition at line 37 of file pgstat.h.

 {
     TRACK_FUNC_OFF,
     TRACK_FUNC_PL,
     TRACK_FUNC_ALL
 }           TrackFunctionsLevel;

◆ WaitEventActivity

enum WaitEventActivity

Enumerator
WAIT_EVENT_ARCHIVER_MAIN
WAIT_EVENT_AUTOVACUUM_MAIN
WAIT_EVENT_BGWRITER_HIBERNATE
WAIT_EVENT_BGWRITER_MAIN
WAIT_EVENT_CHECKPOINTER_MAIN
WAIT_EVENT_LOGICAL_APPLY_MAIN
WAIT_EVENT_LOGICAL_LAUNCHER_MAIN
WAIT_EVENT_PGSTAT_MAIN
WAIT_EVENT_RECOVERY_WAL_STREAM
WAIT_EVENT_SYSLOGGER_MAIN
WAIT_EVENT_WAL_RECEIVER_MAIN
WAIT_EVENT_WAL_SENDER_MAIN
WAIT_EVENT_WAL_WRITER_MAIN

Definition at line 802 of file pgstat.h.

 {
     WAIT_EVENT_ARCHIVER_MAIN = PG_WAIT_ACTIVITY,
     WAIT_EVENT_AUTOVACUUM_MAIN,
     WAIT_EVENT_BGWRITER_HIBERNATE,
     WAIT_EVENT_BGWRITER_MAIN,
     WAIT_EVENT_CHECKPOINTER_MAIN,
     WAIT_EVENT_LOGICAL_APPLY_MAIN,
     WAIT_EVENT_LOGICAL_LAUNCHER_MAIN,
     WAIT_EVENT_PGSTAT_MAIN,
     WAIT_EVENT_RECOVERY_WAL_STREAM,
     WAIT_EVENT_SYSLOGGER_MAIN,
     WAIT_EVENT_WAL_RECEIVER_MAIN,
     WAIT_EVENT_WAL_SENDER_MAIN,
     WAIT_EVENT_WAL_WRITER_MAIN
 } WaitEventActivity;

◆ WaitEventClient

enum WaitEventClient

Enumerator
WAIT_EVENT_CLIENT_READ
WAIT_EVENT_CLIENT_WRITE
WAIT_EVENT_GSS_OPEN_SERVER
WAIT_EVENT_LIBPQWALRECEIVER_CONNECT
WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE
WAIT_EVENT_SSL_OPEN_SERVER
WAIT_EVENT_WAL_RECEIVER_WAIT_START
WAIT_EVENT_WAL_SENDER_WAIT_WAL
WAIT_EVENT_WAL_SENDER_WRITE_DATA

Definition at line 827 of file pgstat.h.

 {
     WAIT_EVENT_CLIENT_READ = PG_WAIT_CLIENT,
     WAIT_EVENT_CLIENT_WRITE,
     WAIT_EVENT_GSS_OPEN_SERVER,
     WAIT_EVENT_LIBPQWALRECEIVER_CONNECT,
     WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE,
     WAIT_EVENT_SSL_OPEN_SERVER,
     WAIT_EVENT_WAL_RECEIVER_WAIT_START,
     WAIT_EVENT_WAL_SENDER_WAIT_WAL,
     WAIT_EVENT_WAL_SENDER_WRITE_DATA,
 } WaitEventClient;

◆ WaitEventIO

enum WaitEventIO

Enumerator
WAIT_EVENT_BASEBACKUP_READ
WAIT_EVENT_BUFFILE_READ
WAIT_EVENT_BUFFILE_WRITE
WAIT_EVENT_BUFFILE_TRUNCATE
WAIT_EVENT_CONTROL_FILE_READ
WAIT_EVENT_CONTROL_FILE_SYNC
WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE
WAIT_EVENT_CONTROL_FILE_WRITE
WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE
WAIT_EVENT_COPY_FILE_READ
WAIT_EVENT_COPY_FILE_WRITE
WAIT_EVENT_DATA_FILE_EXTEND
WAIT_EVENT_DATA_FILE_FLUSH
WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC
WAIT_EVENT_DATA_FILE_PREFETCH
WAIT_EVENT_DATA_FILE_READ
WAIT_EVENT_DATA_FILE_SYNC
WAIT_EVENT_DATA_FILE_TRUNCATE
WAIT_EVENT_DATA_FILE_WRITE
WAIT_EVENT_DSM_FILL_ZERO_WRITE
WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ
WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC
WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE
WAIT_EVENT_LOCK_FILE_CREATE_READ
WAIT_EVENT_LOCK_FILE_CREATE_SYNC
WAIT_EVENT_LOCK_FILE_CREATE_WRITE
WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ
WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC
WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC
WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE
WAIT_EVENT_LOGICAL_REWRITE_SYNC
WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE
WAIT_EVENT_LOGICAL_REWRITE_WRITE
WAIT_EVENT_RELATION_MAP_READ
WAIT_EVENT_RELATION_MAP_SYNC
WAIT_EVENT_RELATION_MAP_WRITE
WAIT_EVENT_REORDER_BUFFER_READ
WAIT_EVENT_REORDER_BUFFER_WRITE
WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ
WAIT_EVENT_REPLICATION_SLOT_READ
WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC
WAIT_EVENT_REPLICATION_SLOT_SYNC
WAIT_EVENT_REPLICATION_SLOT_WRITE
WAIT_EVENT_SLRU_FLUSH_SYNC
WAIT_EVENT_SLRU_READ
WAIT_EVENT_SLRU_SYNC
WAIT_EVENT_SLRU_WRITE
WAIT_EVENT_SNAPBUILD_READ
WAIT_EVENT_SNAPBUILD_SYNC
WAIT_EVENT_SNAPBUILD_WRITE
WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC
WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE
WAIT_EVENT_TIMELINE_HISTORY_READ
WAIT_EVENT_TIMELINE_HISTORY_SYNC
WAIT_EVENT_TIMELINE_HISTORY_WRITE
WAIT_EVENT_TWOPHASE_FILE_READ
WAIT_EVENT_TWOPHASE_FILE_SYNC
WAIT_EVENT_TWOPHASE_FILE_WRITE
WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ
WAIT_EVENT_WAL_BOOTSTRAP_SYNC
WAIT_EVENT_WAL_BOOTSTRAP_WRITE
WAIT_EVENT_WAL_COPY_READ
WAIT_EVENT_WAL_COPY_SYNC
WAIT_EVENT_WAL_COPY_WRITE
WAIT_EVENT_WAL_INIT_SYNC
WAIT_EVENT_WAL_INIT_WRITE
WAIT_EVENT_WAL_READ
WAIT_EVENT_WAL_SYNC
WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN
WAIT_EVENT_WAL_WRITE
WAIT_EVENT_LOGICAL_CHANGES_READ
WAIT_EVENT_LOGICAL_CHANGES_WRITE
WAIT_EVENT_LOGICAL_SUBXACT_READ
WAIT_EVENT_LOGICAL_SUBXACT_WRITE

Definition at line 914 of file pgstat.h.

 {
     WAIT_EVENT_BASEBACKUP_READ = PG_WAIT_IO,
     WAIT_EVENT_BUFFILE_READ,
     WAIT_EVENT_BUFFILE_WRITE,
     WAIT_EVENT_BUFFILE_TRUNCATE,
     WAIT_EVENT_CONTROL_FILE_READ,
     WAIT_EVENT_CONTROL_FILE_SYNC,
     WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE,
     WAIT_EVENT_CONTROL_FILE_WRITE,
     WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE,
     WAIT_EVENT_COPY_FILE_READ,
     WAIT_EVENT_COPY_FILE_WRITE,
     WAIT_EVENT_DATA_FILE_EXTEND,
     WAIT_EVENT_DATA_FILE_FLUSH,
     WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC,
     WAIT_EVENT_DATA_FILE_PREFETCH,
     WAIT_EVENT_DATA_FILE_READ,
     WAIT_EVENT_DATA_FILE_SYNC,
     WAIT_EVENT_DATA_FILE_TRUNCATE,
     WAIT_EVENT_DATA_FILE_WRITE,
     WAIT_EVENT_DSM_FILL_ZERO_WRITE,
     WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ,
     WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC,
     WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE,
     WAIT_EVENT_LOCK_FILE_CREATE_READ,
     WAIT_EVENT_LOCK_FILE_CREATE_SYNC,
     WAIT_EVENT_LOCK_FILE_CREATE_WRITE,
     WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ,
     WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC,
     WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC,
     WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE,
     WAIT_EVENT_LOGICAL_REWRITE_SYNC,
     WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE,
     WAIT_EVENT_LOGICAL_REWRITE_WRITE,
     WAIT_EVENT_RELATION_MAP_READ,
     WAIT_EVENT_RELATION_MAP_SYNC,
     WAIT_EVENT_RELATION_MAP_WRITE,
     WAIT_EVENT_REORDER_BUFFER_READ,
     WAIT_EVENT_REORDER_BUFFER_WRITE,
     WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ,
     WAIT_EVENT_REPLICATION_SLOT_READ,
     WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC,
     WAIT_EVENT_REPLICATION_SLOT_SYNC,
     WAIT_EVENT_REPLICATION_SLOT_WRITE,
     WAIT_EVENT_SLRU_FLUSH_SYNC,
     WAIT_EVENT_SLRU_READ,
     WAIT_EVENT_SLRU_SYNC,
     WAIT_EVENT_SLRU_WRITE,
     WAIT_EVENT_SNAPBUILD_READ,
     WAIT_EVENT_SNAPBUILD_SYNC,
     WAIT_EVENT_SNAPBUILD_WRITE,
     WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC,
     WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE,
     WAIT_EVENT_TIMELINE_HISTORY_READ,
     WAIT_EVENT_TIMELINE_HISTORY_SYNC,
     WAIT_EVENT_TIMELINE_HISTORY_WRITE,
     WAIT_EVENT_TWOPHASE_FILE_READ,
     WAIT_EVENT_TWOPHASE_FILE_SYNC,
     WAIT_EVENT_TWOPHASE_FILE_WRITE,
     WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ,
     WAIT_EVENT_WAL_BOOTSTRAP_SYNC,
     WAIT_EVENT_WAL_BOOTSTRAP_WRITE,
     WAIT_EVENT_WAL_COPY_READ,
     WAIT_EVENT_WAL_COPY_SYNC,
     WAIT_EVENT_WAL_COPY_WRITE,
     WAIT_EVENT_WAL_INIT_SYNC,
     WAIT_EVENT_WAL_INIT_WRITE,
     WAIT_EVENT_WAL_READ,
     WAIT_EVENT_WAL_SYNC,
     WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN,
     WAIT_EVENT_WAL_WRITE,
     WAIT_EVENT_LOGICAL_CHANGES_READ,
     WAIT_EVENT_LOGICAL_CHANGES_WRITE,
     WAIT_EVENT_LOGICAL_SUBXACT_READ,
     WAIT_EVENT_LOGICAL_SUBXACT_WRITE
 } WaitEventIO;

◆ WaitEventIPC

enum WaitEventIPC

Enumerator
WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE
WAIT_EVENT_BGWORKER_SHUTDOWN
WAIT_EVENT_BGWORKER_STARTUP
WAIT_EVENT_BTREE_PAGE
WAIT_EVENT_CHECKPOINT_DONE
WAIT_EVENT_CHECKPOINT_START
WAIT_EVENT_EXECUTE_GATHER
WAIT_EVENT_HASH_BATCH_ALLOCATE
WAIT_EVENT_HASH_BATCH_ELECT
WAIT_EVENT_HASH_BATCH_LOAD
WAIT_EVENT_HASH_BUILD_ALLOCATE
WAIT_EVENT_HASH_BUILD_ELECT
WAIT_EVENT_HASH_BUILD_HASH_INNER
WAIT_EVENT_HASH_BUILD_HASH_OUTER
WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATE
WAIT_EVENT_HASH_GROW_BATCHES_DECIDE
WAIT_EVENT_HASH_GROW_BATCHES_ELECT
WAIT_EVENT_HASH_GROW_BATCHES_FINISH
WAIT_EVENT_HASH_GROW_BATCHES_REPARTITION
WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATE
WAIT_EVENT_HASH_GROW_BUCKETS_ELECT
WAIT_EVENT_HASH_GROW_BUCKETS_REINSERT
WAIT_EVENT_LOGICAL_SYNC_DATA
WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE
WAIT_EVENT_MQ_INTERNAL
WAIT_EVENT_MQ_PUT_MESSAGE
WAIT_EVENT_MQ_RECEIVE
WAIT_EVENT_MQ_SEND
WAIT_EVENT_PARALLEL_BITMAP_SCAN
WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN
WAIT_EVENT_PARALLEL_FINISH
WAIT_EVENT_PROCARRAY_GROUP_UPDATE
WAIT_EVENT_PROC_SIGNAL_BARRIER
WAIT_EVENT_PROMOTE
WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT
WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE
WAIT_EVENT_RECOVERY_PAUSE
WAIT_EVENT_REPLICATION_ORIGIN_DROP
WAIT_EVENT_REPLICATION_SLOT_DROP
WAIT_EVENT_SAFE_SNAPSHOT
WAIT_EVENT_SYNC_REP
WAIT_EVENT_XACT_GROUP_UPDATE

Definition at line 847 of file pgstat.h.

 {
     WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE = PG_WAIT_IPC,
     WAIT_EVENT_BGWORKER_SHUTDOWN,
     WAIT_EVENT_BGWORKER_STARTUP,
     WAIT_EVENT_BTREE_PAGE,
     WAIT_EVENT_CHECKPOINT_DONE,
     WAIT_EVENT_CHECKPOINT_START,
     WAIT_EVENT_EXECUTE_GATHER,
     WAIT_EVENT_HASH_BATCH_ALLOCATE,
     WAIT_EVENT_HASH_BATCH_ELECT,
     WAIT_EVENT_HASH_BATCH_LOAD,
     WAIT_EVENT_HASH_BUILD_ALLOCATE,
     WAIT_EVENT_HASH_BUILD_ELECT,
     WAIT_EVENT_HASH_BUILD_HASH_INNER,
     WAIT_EVENT_HASH_BUILD_HASH_OUTER,
     WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATE,
     WAIT_EVENT_HASH_GROW_BATCHES_DECIDE,
     WAIT_EVENT_HASH_GROW_BATCHES_ELECT,
     WAIT_EVENT_HASH_GROW_BATCHES_FINISH,
     WAIT_EVENT_HASH_GROW_BATCHES_REPARTITION,
     WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATE,
     WAIT_EVENT_HASH_GROW_BUCKETS_ELECT,
     WAIT_EVENT_HASH_GROW_BUCKETS_REINSERT,
     WAIT_EVENT_LOGICAL_SYNC_DATA,
     WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE,
     WAIT_EVENT_MQ_INTERNAL,
     WAIT_EVENT_MQ_PUT_MESSAGE,
     WAIT_EVENT_MQ_RECEIVE,
     WAIT_EVENT_MQ_SEND,
     WAIT_EVENT_PARALLEL_BITMAP_SCAN,
     WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN,
     WAIT_EVENT_PARALLEL_FINISH,
     WAIT_EVENT_PROCARRAY_GROUP_UPDATE,
     WAIT_EVENT_PROC_SIGNAL_BARRIER,
     WAIT_EVENT_PROMOTE,
     WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT,
     WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE,
     WAIT_EVENT_RECOVERY_PAUSE,
     WAIT_EVENT_REPLICATION_ORIGIN_DROP,
     WAIT_EVENT_REPLICATION_SLOT_DROP,
     WAIT_EVENT_SAFE_SNAPSHOT,
     WAIT_EVENT_SYNC_REP,
     WAIT_EVENT_XACT_GROUP_UPDATE
 } WaitEventIPC;

◆ WaitEventTimeout

enum WaitEventTimeout

Enumerator
WAIT_EVENT_BASE_BACKUP_THROTTLE
WAIT_EVENT_PG_SLEEP
WAIT_EVENT_RECOVERY_APPLY_DELAY
WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL
WAIT_EVENT_VACUUM_DELAY

Definition at line 899 of file pgstat.h.

 {
     WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT,
     WAIT_EVENT_PG_SLEEP,
     WAIT_EVENT_RECOVERY_APPLY_DELAY,
     WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL,
     WAIT_EVENT_VACUUM_DELAY
 } WaitEventTimeout;

Function Documentation

◆ allow_immediate_pgstat_restart()

void allow_immediate_pgstat_restart ( void )

Definition at line 817 of file pgstat.c.

References last_pgstat_start_time.

Referenced by HandleChildCrash().

 {
     last_pgstat_start_time = 0;
 }

◆ AtEOSubXact_PgStat()

void AtEOSubXact_PgStat	(	bool	isCommit,
		int	nestDepth
	)

Definition at line 2230 of file pgstat.c.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

 {
     PgStat_SubXactStatus *xact_state;
 
     /*
      * Transfer transactional insert/update counts into the next higher
      * subtransaction state.
      */
     xact_state = pgStatXactStack;
     if (xact_state != NULL &&
         xact_state->nest_level >= nestDepth)
     {
         PgStat_TableXactStatus *trans;
         PgStat_TableXactStatus *next_trans;
 
         /* delink xact_state from stack immediately to simplify reuse case */
         pgStatXactStack = xact_state->prev;
 
         for (trans = xact_state->first; trans != NULL; trans = next_trans)
         {
             PgStat_TableStatus *tabstat;
 
             next_trans = trans->next;
             Assert(trans->nest_level == nestDepth);
             tabstat = trans->parent;
             Assert(tabstat->trans == trans);
             if (isCommit)
             {
                 if (trans->upper && trans->upper->nest_level == nestDepth - 1)
                 {
                     if (trans->truncated)
                     {
                         /* propagate the truncate status one level up */
                         pgstat_truncate_save_counters(trans->upper);
                         /* replace upper xact stats with ours */
                         trans->upper->tuples_inserted = trans->tuples_inserted;
                         trans->upper->tuples_updated = trans->tuples_updated;
                         trans->upper->tuples_deleted = trans->tuples_deleted;
                     }
                     else
                     {
                         trans->upper->tuples_inserted += trans->tuples_inserted;
                         trans->upper->tuples_updated += trans->tuples_updated;
                         trans->upper->tuples_deleted += trans->tuples_deleted;
                     }
                     tabstat->trans = trans->upper;
                     pfree(trans);
                 }
                 else
                 {
                     /*
                      * When there isn't an immediate parent state, we can just
                      * reuse the record instead of going through a
                      * palloc/pfree pushup (this works since it's all in
                      * TopTransactionContext anyway).  We have to re-link it
                      * into the parent level, though, and that might mean
                      * pushing a new entry into the pgStatXactStack.
                      */
                     PgStat_SubXactStatus *upper_xact_state;
 
                     upper_xact_state = get_tabstat_stack_level(nestDepth - 1);
                     trans->next = upper_xact_state->first;
                     upper_xact_state->first = trans;
                     trans->nest_level = nestDepth - 1;
                 }
             }
             else
             {
                 /*
                  * On abort, update top-level tabstat counts, then forget the
                  * subtransaction
                  */
 
                 /* first restore values obliterated by truncate */
                 pgstat_truncate_restore_counters(trans);
                 /* count attempted actions regardless of commit/abort */
                 tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
                 tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
                 tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
                 /* inserted tuples are dead, deleted tuples are unaffected */
                 tabstat->t_counts.t_delta_dead_tuples +=
                     trans->tuples_inserted + trans->tuples_updated;
                 tabstat->trans = trans->upper;
                 pfree(trans);
             }
         }
         pfree(xact_state);
     }
 }

◆ AtEOXact_PgStat()

void AtEOXact_PgStat	(	bool	isCommit,
		bool	parallel
	)

Definition at line 2143 of file pgstat.c.

Referenced by AbortTransaction(), CommitTransaction(), and FinishPreparedTransaction().

 {
     PgStat_SubXactStatus *xact_state;
 
     /* Don't count parallel worker transaction stats */
     if (!parallel)
     {
         /*
          * Count transaction commit or abort.  (We use counters, not just
          * bools, in case the reporting message isn't sent right away.)
          */
         if (isCommit)
             pgStatXactCommit++;
         else
             pgStatXactRollback++;
     }
 
     /*
      * Transfer transactional insert/update counts into the base tabstat
      * entries.  We don't bother to free any of the transactional state, since
      * it's all in TopTransactionContext and will go away anyway.
      */
     xact_state = pgStatXactStack;
     if (xact_state != NULL)
     {
         PgStat_TableXactStatus *trans;
 
         Assert(xact_state->nest_level == 1);
         Assert(xact_state->prev == NULL);
         for (trans = xact_state->first; trans != NULL; trans = trans->next)
         {
             PgStat_TableStatus *tabstat;
 
             Assert(trans->nest_level == 1);
             Assert(trans->upper == NULL);
             tabstat = trans->parent;
             Assert(tabstat->trans == trans);
             /* restore pre-truncate stats (if any) in case of aborted xact */
             if (!isCommit)
                 pgstat_truncate_restore_counters(trans);
             /* count attempted actions regardless of commit/abort */
             tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
             tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
             tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
             if (isCommit)
             {
                 tabstat->t_counts.t_truncated = trans->truncated;
                 if (trans->truncated)
                 {
                     /* forget live/dead stats seen by backend thus far */
                     tabstat->t_counts.t_delta_live_tuples = 0;
                     tabstat->t_counts.t_delta_dead_tuples = 0;
                 }
                 /* insert adds a live tuple, delete removes one */
                 tabstat->t_counts.t_delta_live_tuples +=
                     trans->tuples_inserted - trans->tuples_deleted;
                 /* update and delete each create a dead tuple */
                 tabstat->t_counts.t_delta_dead_tuples +=
                     trans->tuples_updated + trans->tuples_deleted;
                 /* insert, update, delete each count as one change event */
                 tabstat->t_counts.t_changed_tuples +=
                     trans->tuples_inserted + trans->tuples_updated +
                     trans->tuples_deleted;
             }
             else
             {
                 /* inserted tuples are dead, deleted tuples are unaffected */
                 tabstat->t_counts.t_delta_dead_tuples +=
                     trans->tuples_inserted + trans->tuples_updated;
                 /* an aborted xact generates no changed_tuple events */
             }
             tabstat->trans = NULL;
         }
     }
     pgStatXactStack = NULL;
 
     /* Make sure any stats snapshot is thrown away */
     pgstat_clear_snapshot();
 }

◆ AtPrepare_PgStat()

void AtPrepare_PgStat ( void )

Definition at line 2329 of file pgstat.c.

Referenced by PrepareTransaction().

 {
     PgStat_SubXactStatus *xact_state;
 
     xact_state = pgStatXactStack;
     if (xact_state != NULL)
     {
         PgStat_TableXactStatus *trans;
 
         Assert(xact_state->nest_level == 1);
         Assert(xact_state->prev == NULL);
         for (trans = xact_state->first; trans != NULL; trans = trans->next)
         {
             PgStat_TableStatus *tabstat;
             TwoPhasePgStatRecord record;
 
             Assert(trans->nest_level == 1);
             Assert(trans->upper == NULL);
             tabstat = trans->parent;
             Assert(tabstat->trans == trans);
 
             record.tuples_inserted = trans->tuples_inserted;
             record.tuples_updated = trans->tuples_updated;
             record.tuples_deleted = trans->tuples_deleted;
             record.inserted_pre_trunc = trans->inserted_pre_trunc;
             record.updated_pre_trunc = trans->updated_pre_trunc;
             record.deleted_pre_trunc = trans->deleted_pre_trunc;
             record.t_id = tabstat->t_id;
             record.t_shared = tabstat->t_shared;
             record.t_truncated = trans->truncated;
 
             RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
                                    &record, sizeof(TwoPhasePgStatRecord));
         }
     }
 }

◆ BackendStatusShmemSize()

Size BackendStatusShmemSize ( void )

Definition at line 2718 of file pgstat.c.

References add_size(), mul_size(), NAMEDATALEN, NumBackendStatSlots, and pgstat_track_activity_query_size.

Referenced by CreateSharedMemoryAndSemaphores().

 {
     Size        size;
 
     /* BackendStatusArray: */
     size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
     /* BackendAppnameBuffer: */
     size = add_size(size,
                     mul_size(NAMEDATALEN, NumBackendStatSlots));
     /* BackendClientHostnameBuffer: */
     size = add_size(size,
                     mul_size(NAMEDATALEN, NumBackendStatSlots));
     /* BackendActivityBuffer: */
     size = add_size(size,
                     mul_size(pgstat_track_activity_query_size, NumBackendStatSlots));
 #ifdef USE_SSL
     /* BackendSslStatusBuffer: */
     size = add_size(size,
                     mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots));
 #endif
     return size;
 }

◆ CreateSharedBackendStatus()

void CreateSharedBackendStatus ( void )

Definition at line 2746 of file pgstat.c.

References BackendActivityBuffer, BackendActivityBufferSize, BackendAppnameBuffer, BackendClientHostnameBuffer, i, MemSet, mul_size(), NAMEDATALEN, NumBackendStatSlots, pgstat_track_activity_query_size, ShmemInitStruct(), PgBackendStatus::st_activity_raw, PgBackendStatus::st_appname, PgBackendStatus::st_clienthostname, PgBackendStatus::st_gssstatus, and PgBackendStatus::st_sslstatus.

Referenced by CreateSharedMemoryAndSemaphores().

 {
     Size        size;
     bool        found;
     int         i;
     char       *buffer;
 
     /* Create or attach to the shared array */
     size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
     BackendStatusArray = (PgBackendStatus *)
         ShmemInitStruct("Backend Status Array", size, &found);
 
     if (!found)
     {
         /*
          * We're the first - initialize.
          */
         MemSet(BackendStatusArray, 0, size);
     }
 
     /* Create or attach to the shared appname buffer */
     size = mul_size(NAMEDATALEN, NumBackendStatSlots);
     BackendAppnameBuffer = (char *)
         ShmemInitStruct("Backend Application Name Buffer", size, &found);
 
     if (!found)
     {
         MemSet(BackendAppnameBuffer, 0, size);
 
         /* Initialize st_appname pointers. */
         buffer = BackendAppnameBuffer;
         for (i = 0; i < NumBackendStatSlots; i++)
         {
             BackendStatusArray[i].st_appname = buffer;
             buffer += NAMEDATALEN;
         }
     }
 
     /* Create or attach to the shared client hostname buffer */
     size = mul_size(NAMEDATALEN, NumBackendStatSlots);
     BackendClientHostnameBuffer = (char *)
         ShmemInitStruct("Backend Client Host Name Buffer", size, &found);
 
     if (!found)
     {
         MemSet(BackendClientHostnameBuffer, 0, size);
 
         /* Initialize st_clienthostname pointers. */
         buffer = BackendClientHostnameBuffer;
         for (i = 0; i < NumBackendStatSlots; i++)
         {
             BackendStatusArray[i].st_clienthostname = buffer;
             buffer += NAMEDATALEN;
         }
     }
 
     /* Create or attach to the shared activity buffer */
     BackendActivityBufferSize = mul_size(pgstat_track_activity_query_size,
                                          NumBackendStatSlots);
     BackendActivityBuffer = (char *)
         ShmemInitStruct("Backend Activity Buffer",
                         BackendActivityBufferSize,
                         &found);
 
     if (!found)
     {
         MemSet(BackendActivityBuffer, 0, BackendActivityBufferSize);
 
         /* Initialize st_activity pointers. */
         buffer = BackendActivityBuffer;
         for (i = 0; i < NumBackendStatSlots; i++)
         {
             BackendStatusArray[i].st_activity_raw = buffer;
             buffer += pgstat_track_activity_query_size;
         }
     }
 
 #ifdef USE_SSL
     /* Create or attach to the shared SSL status buffer */
     size = mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots);
     BackendSslStatusBuffer = (PgBackendSSLStatus *)
         ShmemInitStruct("Backend SSL Status Buffer", size, &found);
 
     if (!found)
     {
         PgBackendSSLStatus *ptr;
 
         MemSet(BackendSslStatusBuffer, 0, size);
 
         /* Initialize st_sslstatus pointers. */
         ptr = BackendSslStatusBuffer;
         for (i = 0; i < NumBackendStatSlots; i++)
         {
             BackendStatusArray[i].st_sslstatus = ptr;
             ptr++;
         }
     }
 #endif
 
 #ifdef ENABLE_GSS
     /* Create or attach to the shared GSSAPI status buffer */
     size = mul_size(sizeof(PgBackendGSSStatus), NumBackendStatSlots);
     BackendGssStatusBuffer = (PgBackendGSSStatus *)
         ShmemInitStruct("Backend GSS Status Buffer", size, &found);
 
     if (!found)
     {
         PgBackendGSSStatus *ptr;
 
         MemSet(BackendGssStatusBuffer, 0, size);
 
         /* Initialize st_gssstatus pointers. */
         ptr = BackendGssStatusBuffer;
         for (i = 0; i < NumBackendStatSlots; i++)
         {
             BackendStatusArray[i].st_gssstatus = ptr;
             ptr++;
         }
     }
 #endif
 }

◆ find_funcstat_entry()

PgStat_BackendFunctionEntry* find_funcstat_entry ( Oid func_id )

Definition at line 1727 of file pgstat.c.

References HASH_FIND, and hash_search().

Referenced by pg_stat_get_xact_function_calls(), pg_stat_get_xact_function_self_time(), and pg_stat_get_xact_function_total_time().

 {
     if (pgStatFunctions == NULL)
         return NULL;
 
     return (PgStat_BackendFunctionEntry *) hash_search(pgStatFunctions,
                                                        (void *) &func_id,
                                                        HASH_FIND, NULL);
 }

◆ find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry ( Oid rel_id )

Definition at line 1928 of file pgstat.c.

References HASH_FIND, hash_search(), and TabStatHashEntry::tsa_entry.

Referenced by pg_stat_get_xact_blocks_fetched(), pg_stat_get_xact_blocks_hit(), pg_stat_get_xact_numscans(), pg_stat_get_xact_tuples_deleted(), pg_stat_get_xact_tuples_fetched(), pg_stat_get_xact_tuples_hot_updated(), pg_stat_get_xact_tuples_inserted(), pg_stat_get_xact_tuples_returned(), and pg_stat_get_xact_tuples_updated().

 {
     TabStatHashEntry *hash_entry;
 
     /* If hashtable doesn't exist, there are no entries at all */
     if (!pgStatTabHash)
         return NULL;
 
     hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_FIND, NULL);
     if (!hash_entry)
         return NULL;
 
     /* Note that this step could also return NULL, but that's correct */
     return hash_entry->tsa_entry;
 }

◆ pgstat_bestart()

void pgstat_bestart ( void )

Definition at line 2923 of file pgstat.c.

Referenced by AuxiliaryProcessMain(), and InitPostgres().

 {
     volatile PgBackendStatus *vbeentry = MyBEEntry;
     PgBackendStatus lbeentry;
 #ifdef USE_SSL
     PgBackendSSLStatus lsslstatus;
 #endif
 #ifdef ENABLE_GSS
     PgBackendGSSStatus lgssstatus;
 #endif
 
     /* pgstats state must be initialized from pgstat_initialize() */
     Assert(vbeentry != NULL);
 
     /*
      * To minimize the time spent modifying the PgBackendStatus entry, and
      * avoid risk of errors inside the critical section, we first copy the
      * shared-memory struct to a local variable, then modify the data in the
      * local variable, then copy the local variable back to shared memory.
      * Only the last step has to be inside the critical section.
      *
      * Most of the data we copy from shared memory is just going to be
      * overwritten, but the struct's not so large that it's worth the
      * maintenance hassle to copy only the needful fields.
      */
     memcpy(&lbeentry,
            unvolatize(PgBackendStatus *, vbeentry),
            sizeof(PgBackendStatus));
 
     /* These structs can just start from zeroes each time, though */
 #ifdef USE_SSL
     memset(&lsslstatus, 0, sizeof(lsslstatus));
 #endif
 #ifdef ENABLE_GSS
     memset(&lgssstatus, 0, sizeof(lgssstatus));
 #endif
 
     /*
      * Now fill in all the fields of lbeentry, except for strings that are
      * out-of-line data.  Those have to be handled separately, below.
      */
     lbeentry.st_procpid = MyProcPid;
     lbeentry.st_backendType = MyBackendType;
     lbeentry.st_proc_start_timestamp = MyStartTimestamp;
     lbeentry.st_activity_start_timestamp = 0;
     lbeentry.st_state_start_timestamp = 0;
     lbeentry.st_xact_start_timestamp = 0;
     lbeentry.st_databaseid = MyDatabaseId;
 
     /* We have userid for client-backends, wal-sender and bgworker processes */
     if (lbeentry.st_backendType == B_BACKEND
         || lbeentry.st_backendType == B_WAL_SENDER
         || lbeentry.st_backendType == B_BG_WORKER)
         lbeentry.st_userid = GetSessionUserId();
     else
         lbeentry.st_userid = InvalidOid;
 
     /*
      * We may not have a MyProcPort (eg, if this is the autovacuum process).
      * If so, use all-zeroes client address, which is dealt with specially in
      * pg_stat_get_backend_client_addr and pg_stat_get_backend_client_port.
      */
     if (MyProcPort)
         memcpy(&lbeentry.st_clientaddr, &MyProcPort->raddr,
                sizeof(lbeentry.st_clientaddr));
     else
         MemSet(&lbeentry.st_clientaddr, 0, sizeof(lbeentry.st_clientaddr));
 
 #ifdef USE_SSL
     if (MyProcPort && MyProcPort->ssl_in_use)
     {
         lbeentry.st_ssl = true;
         lsslstatus.ssl_bits = be_tls_get_cipher_bits(MyProcPort);
         lsslstatus.ssl_compression = be_tls_get_compression(MyProcPort);
         strlcpy(lsslstatus.ssl_version, be_tls_get_version(MyProcPort), NAMEDATALEN);
         strlcpy(lsslstatus.ssl_cipher, be_tls_get_cipher(MyProcPort), NAMEDATALEN);
         be_tls_get_peer_subject_name(MyProcPort, lsslstatus.ssl_client_dn, NAMEDATALEN);
         be_tls_get_peer_serial(MyProcPort, lsslstatus.ssl_client_serial, NAMEDATALEN);
         be_tls_get_peer_issuer_name(MyProcPort, lsslstatus.ssl_issuer_dn, NAMEDATALEN);
     }
     else
     {
         lbeentry.st_ssl = false;
     }
 #else
     lbeentry.st_ssl = false;
 #endif
 
 #ifdef ENABLE_GSS
     if (MyProcPort && MyProcPort->gss != NULL)
     {
         lbeentry.st_gss = true;
         lgssstatus.gss_auth = be_gssapi_get_auth(MyProcPort);
         lgssstatus.gss_enc = be_gssapi_get_enc(MyProcPort);
 
         if (lgssstatus.gss_auth)
             strlcpy(lgssstatus.gss_princ, be_gssapi_get_princ(MyProcPort), NAMEDATALEN);
     }
     else
     {
         lbeentry.st_gss = false;
     }
 #else
     lbeentry.st_gss = false;
 #endif
 
     lbeentry.st_state = STATE_UNDEFINED;
     lbeentry.st_progress_command = PROGRESS_COMMAND_INVALID;
     lbeentry.st_progress_command_target = InvalidOid;
 
     /*
      * we don't zero st_progress_param here to save cycles; nobody should
      * examine it until st_progress_command has been set to something other
      * than PROGRESS_COMMAND_INVALID
      */
 
     /*
      * We're ready to enter the critical section that fills the shared-memory
      * status entry.  We follow the protocol of bumping st_changecount before
      * and after; and make sure it's even afterwards.  We use a volatile
      * pointer here to ensure the compiler doesn't try to get cute.
      */
     PGSTAT_BEGIN_WRITE_ACTIVITY(vbeentry);
 
     /* make sure we'll memcpy the same st_changecount back */
     lbeentry.st_changecount = vbeentry->st_changecount;
 
     memcpy(unvolatize(PgBackendStatus *, vbeentry),
            &lbeentry,
            sizeof(PgBackendStatus));
 
     /*
      * We can write the out-of-line strings and structs using the pointers
      * that are in lbeentry; this saves some de-volatilizing messiness.
      */
     lbeentry.st_appname[0] = '\0';
     if (MyProcPort && MyProcPort->remote_hostname)
         strlcpy(lbeentry.st_clienthostname, MyProcPort->remote_hostname,
                 NAMEDATALEN);
     else
         lbeentry.st_clienthostname[0] = '\0';
     lbeentry.st_activity_raw[0] = '\0';
     /* Also make sure the last byte in each string area is always 0 */
     lbeentry.st_appname[NAMEDATALEN - 1] = '\0';
     lbeentry.st_clienthostname[NAMEDATALEN - 1] = '\0';
     lbeentry.st_activity_raw[pgstat_track_activity_query_size - 1] = '\0';
 
 #ifdef USE_SSL
     memcpy(lbeentry.st_sslstatus, &lsslstatus, sizeof(PgBackendSSLStatus));
 #endif
 #ifdef ENABLE_GSS
     memcpy(lbeentry.st_gssstatus, &lgssstatus, sizeof(PgBackendGSSStatus));
 #endif
 
     PGSTAT_END_WRITE_ACTIVITY(vbeentry);
 
     /* Update app name to current GUC setting */
     if (application_name)
         pgstat_report_appname(application_name);
 }

◆ pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void )

Definition at line 5864 of file pgstat.c.

References localNumBackends, and MemoryContextDelete().

Referenced by AtEOXact_PgStat(), autovac_refresh_stats(), AutoVacLauncherMain(), pg_stat_clear_snapshot(), and PostPrepare_PgStat().

 {
     /* Release memory, if any was allocated */
     if (pgStatLocalContext)
         MemoryContextDelete(pgStatLocalContext);
 
     /* Reset variables */
     pgStatLocalContext = NULL;
     pgStatDBHash = NULL;
     localBackendStatusTable = NULL;
     localNumBackends = 0;
 }

◆ pgstat_clip_activity()

char* pgstat_clip_activity ( const char * raw_activity )

Definition at line 6668 of file pgstat.c.

References cliplen(), pg_mbcliplen(), pgstat_track_activity_query_size, and pnstrdup().

Referenced by pg_stat_get_activity(), pg_stat_get_backend_activity(), and pgstat_get_backend_current_activity().

 {
     char       *activity;
     int         rawlen;
     int         cliplen;
 
     /*
      * Some callers, like pgstat_get_backend_current_activity(), do not
      * guarantee that the buffer isn't concurrently modified. We try to take
      * care that the buffer is always terminated by a NUL byte regardless, but
      * let's still be paranoid about the string's length. In those cases the
      * underlying buffer is guaranteed to be pgstat_track_activity_query_size
      * large.
      */
     activity = pnstrdup(raw_activity, pgstat_track_activity_query_size - 1);
 
     /* now double-guaranteed to be NUL terminated */
     rawlen = strlen(activity);
 
     /*
      * All supported server-encodings make it possible to determine the length
      * of a multi-byte character from its first byte (this is not the case for
      * client encodings, see GB18030). As st_activity is always stored using
      * server encoding, this allows us to perform multi-byte aware truncation,
      * even if the string earlier was truncated in the middle of a multi-byte
      * character.
      */
     cliplen = pg_mbcliplen(activity, rawlen,
                            pgstat_track_activity_query_size - 1);
 
     activity[cliplen] = '\0';
 
     return activity;
 }

◆ pgstat_count_heap_delete()

void pgstat_count_heap_delete ( Relation rel )

Definition at line 2043 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_deleted.

Referenced by heap_abort_speculative(), and heap_delete().

 {
     PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
     if (pgstat_info != NULL)
     {
         /* We have to log the effect at the proper transactional level */
         int         nest_level = GetCurrentTransactionNestLevel();
 
         if (pgstat_info->trans == NULL ||
             pgstat_info->trans->nest_level != nest_level)
             add_tabstat_xact_level(pgstat_info, nest_level);
 
         pgstat_info->trans->tuples_deleted++;
     }
 }

◆ pgstat_count_heap_insert()

void pgstat_count_heap_insert	(	Relation	rel,
		PgStat_Counter	n
	)

Definition at line 1997 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_inserted.

Referenced by ExecRefreshMatView(), heap_insert(), and heap_multi_insert().

 {
     PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
     if (pgstat_info != NULL)
     {
         /* We have to log the effect at the proper transactional level */
         int         nest_level = GetCurrentTransactionNestLevel();
 
         if (pgstat_info->trans == NULL ||
             pgstat_info->trans->nest_level != nest_level)
             add_tabstat_xact_level(pgstat_info, nest_level);
 
         pgstat_info->trans->tuples_inserted += n;
     }
 }

◆ pgstat_count_heap_update()

void pgstat_count_heap_update	(	Relation	rel,
		bool	hot
	)

Definition at line 2018 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_tuples_hot_updated, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_updated.

Referenced by heap_update().

 {
     PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
     if (pgstat_info != NULL)
     {
         /* We have to log the effect at the proper transactional level */
         int         nest_level = GetCurrentTransactionNestLevel();
 
         if (pgstat_info->trans == NULL ||
             pgstat_info->trans->nest_level != nest_level)
             add_tabstat_xact_level(pgstat_info, nest_level);
 
         pgstat_info->trans->tuples_updated++;
 
         /* t_tuples_hot_updated is nontransactional, so just advance it */
         if (hot)
             pgstat_info->t_counts.t_tuples_hot_updated++;
     }
 }

◆ pgstat_count_slru_flush()

void pgstat_count_slru_flush ( int slru_idx )

Definition at line 6796 of file pgstat.c.

References PgStat_MsgSLRU::m_flush, and slru_entry().

Referenced by SimpleLruWriteAll().

 {
     slru_entry(slru_idx)->m_flush += 1;
 }

◆ pgstat_count_slru_page_exists()

void pgstat_count_slru_page_exists ( int slru_idx )

Definition at line 6778 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_exists, and slru_entry().

Referenced by SimpleLruDoesPhysicalPageExist().

 {
     slru_entry(slru_idx)->m_blocks_exists += 1;
 }

◆ pgstat_count_slru_page_hit()

void pgstat_count_slru_page_hit ( int slru_idx )

Definition at line 6772 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_hit, and slru_entry().

Referenced by SimpleLruReadPage(), and SimpleLruReadPage_ReadOnly().

 {
     slru_entry(slru_idx)->m_blocks_hit += 1;
 }

◆ pgstat_count_slru_page_read()

void pgstat_count_slru_page_read ( int slru_idx )

Definition at line 6784 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_read, and slru_entry().

Referenced by SimpleLruReadPage().

 {
     slru_entry(slru_idx)->m_blocks_read += 1;
 }

◆ pgstat_count_slru_page_written()

void pgstat_count_slru_page_written ( int slru_idx )

Definition at line 6790 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_written, and slru_entry().

Referenced by SlruPhysicalWritePage().

 {
     slru_entry(slru_idx)->m_blocks_written += 1;
 }

◆ pgstat_count_slru_page_zeroed()

void pgstat_count_slru_page_zeroed ( int slru_idx )

Definition at line 6766 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_zeroed, and slru_entry().

Referenced by SimpleLruZeroPage().

 {
     slru_entry(slru_idx)->m_blocks_zeroed += 1;
 }

◆ pgstat_count_slru_truncate()

void pgstat_count_slru_truncate ( int slru_idx )

Definition at line 6802 of file pgstat.c.

References PgStat_MsgSLRU::m_truncate, and slru_entry().

Referenced by SimpleLruTruncate().

 {
     slru_entry(slru_idx)->m_truncate += 1;
 }

◆ pgstat_count_truncate()

void pgstat_count_truncate ( Relation rel )

Definition at line 2098 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, pgstat_truncate_save_counters(), PgStat_TableStatus::trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, and PgStat_TableXactStatus::tuples_updated.

Referenced by ExecRefreshMatView(), and ExecuteTruncateGuts().

 {
     PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
     if (pgstat_info != NULL)
     {
         /* We have to log the effect at the proper transactional level */
         int         nest_level = GetCurrentTransactionNestLevel();
 
         if (pgstat_info->trans == NULL ||
             pgstat_info->trans->nest_level != nest_level)
             add_tabstat_xact_level(pgstat_info, nest_level);
 
         pgstat_truncate_save_counters(pgstat_info->trans);
         pgstat_info->trans->tuples_inserted = 0;
         pgstat_info->trans->tuples_updated = 0;
         pgstat_info->trans->tuples_deleted = 0;
     }
 }

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid databaseid )

Definition at line 1284 of file pgstat.c.

References PgStat_MsgTabpurge::m_databaseid, PgStat_MsgDropdb::m_databaseid, PgStat_MsgTabpurge::m_hdr, PgStat_MsgDropdb::m_hdr, PgStat_MsgTabpurge::m_nentries, PgStat_MsgTabpurge::m_tableid, MyDatabaseId, offsetof, PGINVALID_SOCKET, PGSTAT_MTYPE_DROPDB, PGSTAT_MTYPE_TABPURGE, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by dropdb(), and pgstat_vacuum_stat().

 {
     PgStat_MsgDropdb msg;
 
     if (pgStatSock == PGINVALID_SOCKET)
         return;
 
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DROPDB);
     msg.m_databaseid = databaseid;
     pgstat_send(&msg, sizeof(msg));
 }

◆ pgstat_end_function_usage()

void pgstat_end_function_usage	(	PgStat_FunctionCallUsage *	fcu,
		bool	finalize
	)

Definition at line 1747 of file pgstat.c.

References PgStat_FunctionCounts::f_numcalls, PgStat_FunctionCounts::f_self_time, PgStat_FunctionCallUsage::f_start, PgStat_FunctionCounts::f_total_time, PgStat_FunctionCallUsage::fs, have_function_stats, INSTR_TIME_ADD, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, PgStat_FunctionCallUsage::save_f_total_time, PgStat_FunctionCallUsage::save_total, and total_func_time.

Referenced by call_pltcl_start_proc(), EventTriggerInvoke(), ExecCallTriggerFunc(), ExecEvalFuncExprFusage(), ExecEvalFuncExprStrictFusage(), ExecMakeFunctionResultSet(), ExecMakeTableFunctionResult(), ExecuteCallStmt(), and fmgr_security_definer().

 {
     PgStat_FunctionCounts *fs = fcu->fs;
     instr_time  f_total;
     instr_time  f_others;
     instr_time  f_self;
 
     /* stats not wanted? */
     if (fs == NULL)
         return;
 
     /* total elapsed time in this function call */
     INSTR_TIME_SET_CURRENT(f_total);
     INSTR_TIME_SUBTRACT(f_total, fcu->f_start);
 
     /* self usage: elapsed minus anything already charged to other calls */
     f_others = total_func_time;
     INSTR_TIME_SUBTRACT(f_others, fcu->save_total);
     f_self = f_total;
     INSTR_TIME_SUBTRACT(f_self, f_others);
 
     /* update backend-wide total time */
     INSTR_TIME_ADD(total_func_time, f_self);
 
     /*
      * Compute the new f_total_time as the total elapsed time added to the
      * pre-call value of f_total_time.  This is necessary to avoid
      * double-counting any time taken by recursive calls of myself.  (We do
      * not need any similar kluge for self time, since that already excludes
      * any recursive calls.)
      */
     INSTR_TIME_ADD(f_total, fcu->save_f_total_time);
 
     /* update counters in function stats table */
     if (finalize)
         fs->f_numcalls++;
     fs->f_total_time = f_total;
     INSTR_TIME_ADD(fs->f_self_time, f_self);
 
     /* indicate that we have something to send */
     have_function_stats = true;
 }

◆ pgstat_fetch_global()

PgStat_GlobalStats* pgstat_fetch_global ( void )

Definition at line 2670 of file pgstat.c.

References backend_read_statsfile(), and globalStats.

Referenced by pg_stat_get_bgwriter_buf_written_checkpoints(), pg_stat_get_bgwriter_buf_written_clean(), pg_stat_get_bgwriter_maxwritten_clean(), pg_stat_get_bgwriter_requested_checkpoints(), pg_stat_get_bgwriter_stat_reset_time(), pg_stat_get_bgwriter_timed_checkpoints(), pg_stat_get_buf_alloc(), pg_stat_get_buf_fsync_backend(), pg_stat_get_buf_written_backend(), pg_stat_get_checkpoint_sync_time(), pg_stat_get_checkpoint_write_time(), and pg_stat_get_snapshot_timestamp().

 {
     backend_read_statsfile();
 
     return &globalStats;
 }

◆ pgstat_fetch_slru()

PgStat_SLRUStats* pgstat_fetch_slru ( void )

Definition at line 2687 of file pgstat.c.

References backend_read_statsfile(), and slruStats.

Referenced by pg_stat_get_slru().

 {
     backend_read_statsfile();
 
     return slruStats;
 }

◆ pgstat_fetch_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver ( void )

Definition at line 2653 of file pgstat.c.

References archiverStats, and backend_read_statsfile().

Referenced by pg_stat_get_archiver().

 {
     backend_read_statsfile();
 
     return &archiverStats;
 }

◆ pgstat_fetch_stat_beentry()

PgBackendStatus* pgstat_fetch_stat_beentry ( int beid )

Definition at line 2596 of file pgstat.c.

References LocalPgBackendStatus::backendStatus, localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_backend_activity(), pg_stat_get_backend_activity_start(), pg_stat_get_backend_client_addr(), pg_stat_get_backend_client_port(), pg_stat_get_backend_dbid(), pg_stat_get_backend_pid(), pg_stat_get_backend_start(), pg_stat_get_backend_userid(), pg_stat_get_backend_wait_event(), pg_stat_get_backend_wait_event_type(), pg_stat_get_backend_xact_start(), and pg_stat_get_db_numbackends().

 {
     pgstat_read_current_status();
 
     if (beid < 1 || beid > localNumBackends)
         return NULL;
 
     return &localBackendStatusTable[beid - 1].backendStatus;
 }

◆ pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry* pgstat_fetch_stat_dbentry ( Oid dbid )

Definition at line 2481 of file pgstat.c.

References backend_read_statsfile(), HASH_FIND, and hash_search().

Referenced by do_autovacuum(), do_start_worker(), pg_stat_get_db_blk_read_time(), pg_stat_get_db_blk_write_time(), pg_stat_get_db_blocks_fetched(), pg_stat_get_db_blocks_hit(), pg_stat_get_db_checksum_failures(), pg_stat_get_db_checksum_last_failure(), pg_stat_get_db_conflict_all(), pg_stat_get_db_conflict_bufferpin(), pg_stat_get_db_conflict_lock(), pg_stat_get_db_conflict_snapshot(), pg_stat_get_db_conflict_startup_deadlock(), pg_stat_get_db_conflict_tablespace(), pg_stat_get_db_deadlocks(), pg_stat_get_db_stat_reset_time(), pg_stat_get_db_temp_bytes(), pg_stat_get_db_temp_files(), pg_stat_get_db_tuples_deleted(), pg_stat_get_db_tuples_fetched(), pg_stat_get_db_tuples_inserted(), pg_stat_get_db_tuples_returned(), pg_stat_get_db_tuples_updated(), pg_stat_get_db_xact_commit(), pg_stat_get_db_xact_rollback(), pgstat_fetch_stat_funcentry(), rebuild_database_list(), and table_recheck_autovac().

 {
     /*
      * If not done for this transaction, read the statistics collector stats
      * file into some hash tables.
      */
     backend_read_statsfile();
 
     /*
      * Lookup the requested database; return NULL if not found
      */
     return (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
                                               (void *) &dbid,
                                               HASH_FIND, NULL);
 }

◆ pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry ( Oid funcid )

Definition at line 2564 of file pgstat.c.

References backend_read_statsfile(), PgStat_StatDBEntry::functions, HASH_FIND, hash_search(), MyDatabaseId, and pgstat_fetch_stat_dbentry().

Referenced by pg_stat_get_function_calls(), pg_stat_get_function_self_time(), and pg_stat_get_function_total_time().

 {
     PgStat_StatDBEntry *dbentry;
     PgStat_StatFuncEntry *funcentry = NULL;
 
     /* load the stats file if needed */
     backend_read_statsfile();
 
     /* Lookup our database, then find the requested function.  */
     dbentry = pgstat_fetch_stat_dbentry(MyDatabaseId);
     if (dbentry != NULL && dbentry->functions != NULL)
     {
         funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,
                                                          (void *) &func_id,
                                                          HASH_FIND, NULL);
     }
 
     return funcentry;
 }

◆ pgstat_fetch_stat_local_beentry()

LocalPgBackendStatus* pgstat_fetch_stat_local_beentry ( int beid )

Definition at line 2618 of file pgstat.c.

References localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_activity(), and pg_stat_get_progress_info().

 {
     pgstat_read_current_status();
 
     if (beid < 1 || beid > localNumBackends)
         return NULL;
 
     return &localBackendStatusTable[beid - 1];
 }

◆ pgstat_fetch_stat_numbackends()

int pgstat_fetch_stat_numbackends ( void )

Definition at line 2637 of file pgstat.c.

References localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_activity(), pg_stat_get_backend_idset(), pg_stat_get_db_numbackends(), and pg_stat_get_progress_info().

 {
     pgstat_read_current_status();
 
     return localNumBackends;
 }

◆ pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry ( Oid relid )

Definition at line 2508 of file pgstat.c.

References backend_read_statsfile(), HASH_FIND, hash_search(), InvalidOid, MyDatabaseId, and PgStat_StatDBEntry::tables.

Referenced by index_concurrently_swap(), pg_stat_get_analyze_count(), pg_stat_get_autoanalyze_count(), pg_stat_get_autovacuum_count(), pg_stat_get_blocks_fetched(), pg_stat_get_blocks_hit(), pg_stat_get_dead_tuples(), pg_stat_get_ins_since_vacuum(), pg_stat_get_last_analyze_time(), pg_stat_get_last_autoanalyze_time(), pg_stat_get_last_autovacuum_time(), pg_stat_get_last_vacuum_time(), pg_stat_get_live_tuples(), pg_stat_get_mod_since_analyze(), pg_stat_get_numscans(), pg_stat_get_tuples_deleted(), pg_stat_get_tuples_fetched(), pg_stat_get_tuples_hot_updated(), pg_stat_get_tuples_inserted(), pg_stat_get_tuples_returned(), pg_stat_get_tuples_updated(), and pg_stat_get_vacuum_count().

 {
     Oid         dbid;
     PgStat_StatDBEntry *dbentry;
     PgStat_StatTabEntry *tabentry;
 
     /*
      * If not done for this transaction, read the statistics collector stats
      * file into some hash tables.
      */
     backend_read_statsfile();
 
     /*
      * Lookup our database, then look in its table hash table.
      */
     dbid = MyDatabaseId;
     dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
                                                  (void *) &dbid,
                                                  HASH_FIND, NULL);
     if (dbentry != NULL && dbentry->tables != NULL)
     {
         tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
                                                        (void *) &relid,
                                                        HASH_FIND, NULL);
         if (tabentry)
             return tabentry;
     }
 
     /*
      * If we didn't find it, maybe it's a shared table.
      */
     dbid = InvalidOid;
     dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
                                                  (void *) &dbid,
                                                  HASH_FIND, NULL);
     if (dbentry != NULL && dbentry->tables != NULL)
     {
         tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
                                                        (void *) &relid,
                                                        HASH_FIND, NULL);
         if (tabentry)
             return tabentry;
     }
 
     return NULL;
 }

◆ pgstat_get_backend_current_activity()

const char* pgstat_get_backend_current_activity	(	int	pid,
		bool	checkUser
	)

Definition at line 4184 of file pgstat.c.

References BackendStatusArray, CHECK_FOR_INTERRUPTS, GetUserId(), i, MaxBackends, pgstat_begin_read_activity, pgstat_clip_activity(), pgstat_end_read_activity, pgstat_read_activity_complete, PgBackendStatus::st_activity_raw, PgBackendStatus::st_procpid, PgBackendStatus::st_userid, and superuser().

Referenced by DeadLockReport().

 {
     PgBackendStatus *beentry;
     int         i;
 
     beentry = BackendStatusArray;
     for (i = 1; i <= MaxBackends; i++)
     {
         /*
          * Although we expect the target backend's entry to be stable, that
          * doesn't imply that anyone else's is.  To avoid identifying the
          * wrong backend, while we check for a match to the desired PID we
          * must follow the protocol of retrying if st_changecount changes
          * while we examine the entry, or if it's odd.  (This might be
          * unnecessary, since fetching or storing an int is almost certainly
          * atomic, but let's play it safe.)  We use a volatile pointer here to
          * ensure the compiler doesn't try to get cute.
          */
         volatile PgBackendStatus *vbeentry = beentry;
         bool        found;
 
         for (;;)
         {
             int         before_changecount;
             int         after_changecount;
 
             pgstat_begin_read_activity(vbeentry, before_changecount);
 
             found = (vbeentry->st_procpid == pid);
 
             pgstat_end_read_activity(vbeentry, after_changecount);
 
             if (pgstat_read_activity_complete(before_changecount,
                                               after_changecount))
                 break;
 
             /* Make sure we can break out of loop if stuck... */
             CHECK_FOR_INTERRUPTS();
         }
 
         if (found)
         {
             /* Now it is safe to use the non-volatile pointer */
             if (checkUser && !superuser() && beentry->st_userid != GetUserId())
                 return "<insufficient privilege>";
             else if (*(beentry->st_activity_raw) == '\0')
                 return "<command string not enabled>";
             else
             {
                 /* this'll leak a bit of memory, but that seems acceptable */
                 return pgstat_clip_activity(beentry->st_activity_raw);
             }
         }
 
         beentry++;
     }
 
     /* If we get here, caller is in error ... */
     return "<backend information not available>";
 }

◆ pgstat_get_crashed_backend_activity()

const char* pgstat_get_crashed_backend_activity	(	int	pid,
		char *	buffer,
		int	buflen
	)

Definition at line 4262 of file pgstat.c.

References ascii_safe_strlcpy(), BackendActivityBuffer, BackendActivityBufferSize, BackendStatusArray, i, MaxBackends, Min, pgstat_track_activity_query_size, PgBackendStatus::st_activity_raw, and PgBackendStatus::st_procpid.

Referenced by LogChildExit().

 {
     volatile PgBackendStatus *beentry;
     int         i;
 
     beentry = BackendStatusArray;
 
     /*
      * We probably shouldn't get here before shared memory has been set up,
      * but be safe.
      */
     if (beentry == NULL || BackendActivityBuffer == NULL)
         return NULL;
 
     for (i = 1; i <= MaxBackends; i++)
     {
         if (beentry->st_procpid == pid)
         {
             /* Read pointer just once, so it can't change after validation */
             const char *activity = beentry->st_activity_raw;
             const char *activity_last;
 
             /*
              * We mustn't access activity string before we verify that it
              * falls within the BackendActivityBuffer. To make sure that the
              * entire string including its ending is contained within the
              * buffer, subtract one activity length from the buffer size.
              */
             activity_last = BackendActivityBuffer + BackendActivityBufferSize
                 - pgstat_track_activity_query_size;
 
             if (activity < BackendActivityBuffer ||
                 activity > activity_last)
                 return NULL;
 
             /* If no string available, no point in a report */
             if (activity[0] == '\0')
                 return NULL;
 
             /*
              * Copy only ASCII-safe characters so we don't run into encoding
              * problems when reporting the message; and be sure not to run off
              * the end of memory.  As only ASCII characters are reported, it
              * doesn't seem necessary to perform multibyte aware clipping.
              */
             ascii_safe_strlcpy(buffer, activity,
                                Min(buflen, pgstat_track_activity_query_size));
 
             return buffer;
         }
 
         beentry++;
     }
 
     /* PID not found */
     return NULL;
 }

◆ pgstat_get_wait_event()

const char* pgstat_get_wait_event ( uint32 wait_event_info )

Definition at line 3568 of file pgstat.c.

References GetLockNameFromTagType(), GetLWLockIdentifier(), PG_WAIT_ACTIVITY, PG_WAIT_BUFFER_PIN, PG_WAIT_CLIENT, PG_WAIT_EXTENSION, PG_WAIT_IO, PG_WAIT_IPC, PG_WAIT_LOCK, PG_WAIT_LWLOCK, PG_WAIT_TIMEOUT, pgstat_get_wait_activity(), pgstat_get_wait_client(), pgstat_get_wait_io(), pgstat_get_wait_ipc(), and pgstat_get_wait_timeout().

Referenced by pg_stat_get_activity(), and pg_stat_get_backend_wait_event().

 {
     uint32      classId;
     uint16      eventId;
     const char *event_name;
 
     /* report process as not waiting. */
     if (wait_event_info == 0)
         return NULL;
 
     classId = wait_event_info & 0xFF000000;
     eventId = wait_event_info & 0x0000FFFF;
 
     switch (classId)
     {
         case PG_WAIT_LWLOCK:
             event_name = GetLWLockIdentifier(classId, eventId);
             break;
         case PG_WAIT_LOCK:
             event_name = GetLockNameFromTagType(eventId);
             break;
         case PG_WAIT_BUFFER_PIN:
             event_name = "BufferPin";
             break;
         case PG_WAIT_ACTIVITY:
             {
                 WaitEventActivity w = (WaitEventActivity) wait_event_info;
 
                 event_name = pgstat_get_wait_activity(w);
                 break;
             }
         case PG_WAIT_CLIENT:
             {
                 WaitEventClient w = (WaitEventClient) wait_event_info;
 
                 event_name = pgstat_get_wait_client(w);
                 break;
             }
         case PG_WAIT_EXTENSION:
             event_name = "Extension";
             break;
         case PG_WAIT_IPC:
             {
                 WaitEventIPC w = (WaitEventIPC) wait_event_info;
 
                 event_name = pgstat_get_wait_ipc(w);
                 break;
             }
         case PG_WAIT_TIMEOUT:
             {
                 WaitEventTimeout w = (WaitEventTimeout) wait_event_info;
 
                 event_name = pgstat_get_wait_timeout(w);
                 break;
             }
         case PG_WAIT_IO:
             {
                 WaitEventIO w = (WaitEventIO) wait_event_info;
 
                 event_name = pgstat_get_wait_io(w);
                 break;
             }
         default:
             event_name = "unknown wait event";
             break;
     }
 
     return event_name;
 }

◆ pgstat_get_wait_event_type()

const char* pgstat_get_wait_event_type ( uint32 wait_event_info )

Definition at line 3513 of file pgstat.c.

References PG_WAIT_ACTIVITY, PG_WAIT_BUFFER_PIN, PG_WAIT_CLIENT, PG_WAIT_EXTENSION, PG_WAIT_IO, PG_WAIT_IPC, PG_WAIT_LOCK, PG_WAIT_LWLOCK, and PG_WAIT_TIMEOUT.

Referenced by pg_stat_get_activity(), and pg_stat_get_backend_wait_event_type().

 {
     uint32      classId;
     const char *event_type;
 
     /* report process as not waiting. */
     if (wait_event_info == 0)
         return NULL;
 
     classId = wait_event_info & 0xFF000000;
 
     switch (classId)
     {
         case PG_WAIT_LWLOCK:
             event_type = "LWLock";
             break;
         case PG_WAIT_LOCK:
             event_type = "Lock";
             break;
         case PG_WAIT_BUFFER_PIN:
             event_type = "BufferPin";
             break;
         case PG_WAIT_ACTIVITY:
             event_type = "Activity";
             break;
         case PG_WAIT_CLIENT:
             event_type = "Client";
             break;
         case PG_WAIT_EXTENSION:
             event_type = "Extension";
             break;
         case PG_WAIT_IPC:
             event_type = "IPC";
             break;
         case PG_WAIT_TIMEOUT:
             event_type = "Timeout";
             break;
         case PG_WAIT_IO:
             event_type = "IO";
             break;
         default:
             event_type = "???";
             break;
     }
 
     return event_type;
 }

◆ pgstat_init()

void pgstat_init ( void )

Definition at line 379 of file pgstat.c.

References addrinfo::ai_next, AI_PASSIVE, bind, closesocket, connect, EINTR, elog, ereport, errcode(), errcode_for_socket_access(), errmsg(), gai_strerror, LOG, pg_freeaddrinfo_all(), pg_getaddrinfo_all(), pg_set_noblock(), PGC_INTERNAL, PGC_S_OVERRIDE, PGINVALID_SOCKET, PGSTAT_MAX_MSG_SIZE, PGSTAT_MIN_RCVBUF, pgStatAddr, pgStatSock, recv, ReserveExternalFD(), select, send, SetConfigOption(), socket, StaticAssertStmt, and TESTBYTEVAL.

Referenced by PostmasterMain().

 {
     ACCEPT_TYPE_ARG3 alen;
     struct addrinfo *addrs = NULL,
                *addr,
                 hints;
     int         ret;
     fd_set      rset;
     struct timeval tv;
     char        test_byte;
     int         sel_res;
     int         tries = 0;
 
 #define TESTBYTEVAL ((char) 199)
 
     /*
      * This static assertion verifies that we didn't mess up the calculations
      * involved in selecting maximum payload sizes for our UDP messages.
      * Because the only consequence of overrunning PGSTAT_MAX_MSG_SIZE would
      * be silent performance loss from fragmentation, it seems worth having a
      * compile-time cross-check that we didn't.
      */
     StaticAssertStmt(sizeof(PgStat_Msg) <= PGSTAT_MAX_MSG_SIZE,
                      "maximum stats message size exceeds PGSTAT_MAX_MSG_SIZE");
 
     /*
      * Create the UDP socket for sending and receiving statistic messages
      */
     hints.ai_flags = AI_PASSIVE;
     hints.ai_family = AF_UNSPEC;
     hints.ai_socktype = SOCK_DGRAM;
     hints.ai_protocol = 0;
     hints.ai_addrlen = 0;
     hints.ai_addr = NULL;
     hints.ai_canonname = NULL;
     hints.ai_next = NULL;
     ret = pg_getaddrinfo_all("localhost", NULL, &hints, &addrs);
     if (ret || !addrs)
     {
         ereport(LOG,
                 (errmsg("could not resolve \"localhost\": %s",
                         gai_strerror(ret))));
         goto startup_failed;
     }
 
     /*
      * On some platforms, pg_getaddrinfo_all() may return multiple addresses
      * only one of which will actually work (eg, both IPv6 and IPv4 addresses
      * when kernel will reject IPv6).  Worse, the failure may occur at the
      * bind() or perhaps even connect() stage.  So we must loop through the
      * results till we find a working combination. We will generate LOG
      * messages, but no error, for bogus combinations.
      */
     for (addr = addrs; addr; addr = addr->ai_next)
     {
 #ifdef HAVE_UNIX_SOCKETS
         /* Ignore AF_UNIX sockets, if any are returned. */
         if (addr->ai_family == AF_UNIX)
             continue;
 #endif
 
         if (++tries > 1)
             ereport(LOG,
                     (errmsg("trying another address for the statistics collector")));
 
         /*
          * Create the socket.
          */
         if ((pgStatSock = socket(addr->ai_family, SOCK_DGRAM, 0)) == PGINVALID_SOCKET)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not create socket for statistics collector: %m")));
             continue;
         }
 
         /*
          * Bind it to a kernel assigned port on localhost and get the assigned
          * port via getsockname().
          */
         if (bind(pgStatSock, addr->ai_addr, addr->ai_addrlen) < 0)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not bind socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
 
         alen = sizeof(pgStatAddr);
         if (getsockname(pgStatSock, (struct sockaddr *) &pgStatAddr, &alen) < 0)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not get address of socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
 
         /*
          * Connect the socket to its own address.  This saves a few cycles by
          * not having to respecify the target address on every send. This also
          * provides a kernel-level check that only packets from this same
          * address will be received.
          */
         if (connect(pgStatSock, (struct sockaddr *) &pgStatAddr, alen) < 0)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not connect socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
 
         /*
          * Try to send and receive a one-byte test message on the socket. This
          * is to catch situations where the socket can be created but will not
          * actually pass data (for instance, because kernel packet filtering
          * rules prevent it).
          */
         test_byte = TESTBYTEVAL;
 
 retry1:
         if (send(pgStatSock, &test_byte, 1, 0) != 1)
         {
             if (errno == EINTR)
                 goto retry1;    /* if interrupted, just retry */
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not send test message on socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
 
         /*
          * There could possibly be a little delay before the message can be
          * received.  We arbitrarily allow up to half a second before deciding
          * it's broken.
          */
         for (;;)                /* need a loop to handle EINTR */
         {
             FD_ZERO(&rset);
             FD_SET(pgStatSock, &rset);
 
             tv.tv_sec = 0;
             tv.tv_usec = 500000;
             sel_res = select(pgStatSock + 1, &rset, NULL, NULL, &tv);
             if (sel_res >= 0 || errno != EINTR)
                 break;
         }
         if (sel_res < 0)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("select() failed in statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
         if (sel_res == 0 || !FD_ISSET(pgStatSock, &rset))
         {
             /*
              * This is the case we actually think is likely, so take pains to
              * give a specific message for it.
              *
              * errno will not be set meaningfully here, so don't use it.
              */
             ereport(LOG,
                     (errcode(ERRCODE_CONNECTION_FAILURE),
                      errmsg("test message did not get through on socket for statistics collector")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
 
         test_byte++;            /* just make sure variable is changed */
 
 retry2:
         if (recv(pgStatSock, &test_byte, 1, 0) != 1)
         {
             if (errno == EINTR)
                 goto retry2;    /* if interrupted, just retry */
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not receive test message on socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
 
         if (test_byte != TESTBYTEVAL)   /* strictly paranoia ... */
         {
             ereport(LOG,
                     (errcode(ERRCODE_INTERNAL_ERROR),
                      errmsg("incorrect test message transmission on socket for statistics collector")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
 
         /* If we get here, we have a working socket */
         break;
     }
 
     /* Did we find a working address? */
     if (!addr || pgStatSock == PGINVALID_SOCKET)
         goto startup_failed;
 
     /*
      * Set the socket to non-blocking IO.  This ensures that if the collector
      * falls behind, statistics messages will be discarded; backends won't
      * block waiting to send messages to the collector.
      */
     if (!pg_set_noblock(pgStatSock))
     {
         ereport(LOG,
                 (errcode_for_socket_access(),
                  errmsg("could not set statistics collector socket to nonblocking mode: %m")));
         goto startup_failed;
     }
 
     /*
      * Try to ensure that the socket's receive buffer is at least
      * PGSTAT_MIN_RCVBUF bytes, so that it won't easily overflow and lose
      * data.  Use of UDP protocol means that we are willing to lose data under
      * heavy load, but we don't want it to happen just because of ridiculously
      * small default buffer sizes (such as 8KB on older Windows versions).
      */
     {
         int         old_rcvbuf;
         int         new_rcvbuf;
         ACCEPT_TYPE_ARG3 rcvbufsize = sizeof(old_rcvbuf);
 
         if (getsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
                        (char *) &old_rcvbuf, &rcvbufsize) < 0)
         {
             elog(LOG, "getsockopt(SO_RCVBUF) failed: %m");
             /* if we can't get existing size, always try to set it */
             old_rcvbuf = 0;
         }
 
         new_rcvbuf = PGSTAT_MIN_RCVBUF;
         if (old_rcvbuf < new_rcvbuf)
         {
             if (setsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
                            (char *) &new_rcvbuf, sizeof(new_rcvbuf)) < 0)
                 elog(LOG, "setsockopt(SO_RCVBUF) failed: %m");
         }
     }
 
     pg_freeaddrinfo_all(hints.ai_family, addrs);
 
     /* Now that we have a long-lived socket, tell fd.c about it. */
     ReserveExternalFD();
 
     return;
 
 startup_failed:
     ereport(LOG,
             (errmsg("disabling statistics collector for lack of working socket")));
 
     if (addrs)
         pg_freeaddrinfo_all(hints.ai_family, addrs);
 
     if (pgStatSock != PGINVALID_SOCKET)
         closesocket(pgStatSock);
     pgStatSock = PGINVALID_SOCKET;
 
     /*
      * Adjust GUC variables to suppress useless activity, and for debugging
      * purposes (seeing track_counts off is a clue that we failed here). We
      * use PGC_S_OVERRIDE because there is no point in trying to turn it back
      * on from postgresql.conf without a restart.
      */
     SetConfigOption("track_counts", "off", PGC_INTERNAL, PGC_S_OVERRIDE);
 }

◆ pgstat_init_function_usage()

void pgstat_init_function_usage	(	struct FunctionCallInfoBaseData *	fcinfo,
		PgStat_FunctionCallUsage *	fcu
	)

◆ pgstat_initialize()

void pgstat_initialize ( void )

Definition at line 2881 of file pgstat.c.

References Assert, InvalidBackendId, MaxBackends, MyAuxProcType, MyBackendId, NotAnAuxProcess, on_shmem_exit(), and pgstat_beshutdown_hook().

Referenced by AuxiliaryProcessMain(), and InitPostgres().

 {
     /* Initialize MyBEEntry */
     if (MyBackendId != InvalidBackendId)
     {
         Assert(MyBackendId >= 1 && MyBackendId <= MaxBackends);
         MyBEEntry = &BackendStatusArray[MyBackendId - 1];
     }
     else
     {
         /* Must be an auxiliary process */
         Assert(MyAuxProcType != NotAnAuxProcess);
 
         /*
          * Assign the MyBEEntry for an auxiliary process.  Since it doesn't
          * have a BackendId, the slot is statically allocated based on the
          * auxiliary process type (MyAuxProcType).  Backends use slots indexed
          * in the range from 1 to MaxBackends (inclusive), so we use
          * MaxBackends + AuxBackendType + 1 as the index of the slot for an
          * auxiliary process.
          */
         MyBEEntry = &BackendStatusArray[MaxBackends + MyAuxProcType];
     }
 
     /* Set up a process-exit hook to clean up */
     on_shmem_exit(pgstat_beshutdown_hook, 0);
 }

◆ pgstat_initstats()

void pgstat_initstats ( Relation rel )

Definition at line 1804 of file pgstat.c.

References get_tabstat_entry(), PGINVALID_SOCKET, RelationData::pgstat_info, pgstat_track_counts, pgStatSock, RelationData::rd_id, RelationData::rd_rel, and PgStat_TableStatus::t_id.

Referenced by relation_open(), and try_relation_open().

 {
     Oid         rel_id = rel->rd_id;
     char        relkind = rel->rd_rel->relkind;
 
     /* We only count stats for things that have storage */
     if (!RELKIND_HAS_STORAGE(relkind))
     {
         rel->pgstat_info = NULL;
         return;
     }
 
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
     {
         /* We're not counting at all */
         rel->pgstat_info = NULL;
         return;
     }
 
     /*
      * If we already set up this relation in the current transaction, nothing
      * to do.
      */
     if (rel->pgstat_info != NULL &&
         rel->pgstat_info->t_id == rel_id)
         return;
 
     /* Else find or make the PgStat_TableStatus entry, and update link */
     rel->pgstat_info = get_tabstat_entry(rel_id, rel->rd_rel->relisshared);
 }

◆ pgstat_ping()

void pgstat_ping ( void )

Definition at line 1640 of file pgstat.c.

References PgStat_MsgDummy::m_hdr, PGINVALID_SOCKET, PGSTAT_MTYPE_DUMMY, pgstat_send(), pgstat_setheader(), and pgStatSock.

 {
     PgStat_MsgDummy msg;
 
     if (pgStatSock == PGINVALID_SOCKET)
         return;
 
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DUMMY);
     pgstat_send(&msg, sizeof(msg));
 }

◆ pgstat_progress_end_command()

void pgstat_progress_end_command ( void )

Definition at line 3282 of file pgstat.c.

References InvalidOid, MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activities, PROGRESS_COMMAND_INVALID, PgBackendStatus::st_progress_command, and PgBackendStatus::st_progress_command_target.

Referenced by AbortSubTransaction(), AbortTransaction(), analyze_rel(), cluster_rel(), DefineIndex(), heap_vacuum_rel(), perform_base_backup(), reindex_index(), and ReindexRelationConcurrently().

 {
     volatile PgBackendStatus *beentry = MyBEEntry;
 
     if (!beentry || !pgstat_track_activities)
         return;
 
     if (beentry->st_progress_command == PROGRESS_COMMAND_INVALID)
         return;
 
     PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
     beentry->st_progress_command = PROGRESS_COMMAND_INVALID;
     beentry->st_progress_command_target = InvalidOid;
     PGSTAT_END_WRITE_ACTIVITY(beentry);
 }

◆ pgstat_progress_start_command()

void pgstat_progress_start_command	(	ProgressCommandType	cmdtype,
		Oid	relid
	)

Definition at line 3210 of file pgstat.c.

References MemSet, MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activities, PgBackendStatus::st_progress_command, PgBackendStatus::st_progress_command_target, and PgBackendStatus::st_progress_param.

Referenced by analyze_rel(), cluster_rel(), DefineIndex(), heap_vacuum_rel(), perform_base_backup(), reindex_index(), and ReindexRelationConcurrently().

 {
     volatile PgBackendStatus *beentry = MyBEEntry;
 
     if (!beentry || !pgstat_track_activities)
         return;
 
     PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
     beentry->st_progress_command = cmdtype;
     beentry->st_progress_command_target = relid;
     MemSet(&beentry->st_progress_param, 0, sizeof(beentry->st_progress_param));
     PGSTAT_END_WRITE_ACTIVITY(beentry);
 }

◆ pgstat_progress_update_multi_param()

void pgstat_progress_update_multi_param	(	int	nparam,
		const int *	index,
		const int64 *	val
	)

Definition at line 3253 of file pgstat.c.

References Assert, i, MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, PGSTAT_NUM_PROGRESS_PARAM, pgstat_track_activities, and PgBackendStatus::st_progress_param.

Referenced by _bt_spools_heapscan(), BuildRelationExtStatistics(), heapam_relation_copy_for_cluster(), index_build(), lazy_scan_heap(), perform_base_backup(), update_basebackup_progress(), validate_index(), and WaitForLockersMultiple().

 {
     volatile PgBackendStatus *beentry = MyBEEntry;
     int         i;
 
     if (!beentry || !pgstat_track_activities || nparam == 0)
         return;
 
     PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
     for (i = 0; i < nparam; ++i)
     {
         Assert(index[i] >= 0 && index[i] < PGSTAT_NUM_PROGRESS_PARAM);
 
         beentry->st_progress_param[index[i]] = val[i];
     }
 
     PGSTAT_END_WRITE_ACTIVITY(beentry);
 }

◆ pgstat_progress_update_param()

void pgstat_progress_update_param	(	int	index,
		int64	val
	)

Definition at line 3231 of file pgstat.c.

References Assert, MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, PGSTAT_NUM_PROGRESS_PARAM, pgstat_track_activities, PgBackendStatus::st_progress_param, and val.

Referenced by _bt_leafbuild(), _bt_load(), _bt_spools_heapscan(), _h_indexbuild(), acquire_inherited_sample_rows(), acquire_sample_rows(), btvacuumscan(), BuildRelationExtStatistics(), cluster_rel(), DefineIndex(), do_analyze_rel(), finish_heap_swap(), hashbuild(), heap_vacuum_rel(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), lazy_cleanup_all_indexes(), lazy_record_dead_tuple(), lazy_scan_heap(), lazy_truncate_heap(), lazy_vacuum_all_indexes(), lazy_vacuum_heap(), lazy_vacuum_page(), perform_base_backup(), reindex_index(), reindex_relation(), ReindexRelationConcurrently(), validate_index(), WaitForLockersMultiple(), and WaitForOlderSnapshots().

 {
     volatile PgBackendStatus *beentry = MyBEEntry;
 
     Assert(index >= 0 && index < PGSTAT_NUM_PROGRESS_PARAM);
 
     if (!beentry || !pgstat_track_activities)
         return;
 
     PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
     beentry->st_progress_param[index] = val;
     PGSTAT_END_WRITE_ACTIVITY(beentry);
 }

◆ pgstat_report_activity()

void pgstat_report_activity	(	BackendState	state,
		const char *	cmd_str
	)

Definition at line 3132 of file pgstat.c.

References GetCurrentStatementStartTimestamp(), GetCurrentTimestamp(), Min, MyBEEntry, MyProc, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activities, pgstat_track_activity_query_size, PgBackendStatus::st_activity_raw, PgBackendStatus::st_activity_start_timestamp, PgBackendStatus::st_state, PgBackendStatus::st_state_start_timestamp, PgBackendStatus::st_xact_start_timestamp, STATE_DISABLED, and PGPROC::wait_event_info.

Referenced by _bt_parallel_build_main(), apply_handle_begin(), apply_handle_commit(), apply_handle_stream_commit(), apply_handle_stream_start(), apply_handle_stream_stop(), autovac_report_activity(), autovac_report_workitem(), exec_bind_message(), exec_execute_message(), exec_parse_message(), exec_replication_command(), exec_simple_query(), initialize_worker_spi(), LogicalRepApplyLoop(), parallel_vacuum_main(), ParallelQueryMain(), and PostgresMain().

 {
     volatile PgBackendStatus *beentry = MyBEEntry;
     TimestampTz start_timestamp;
     TimestampTz current_timestamp;
     int         len = 0;
 
     TRACE_POSTGRESQL_STATEMENT_STATUS(cmd_str);
 
     if (!beentry)
         return;
 
     if (!pgstat_track_activities)
     {
         if (beentry->st_state != STATE_DISABLED)
         {
             volatile PGPROC *proc = MyProc;
 
             /*
              * track_activities is disabled, but we last reported a
              * non-disabled state.  As our final update, change the state and
              * clear fields we will not be updating anymore.
              */
             PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
             beentry->st_state = STATE_DISABLED;
             beentry->st_state_start_timestamp = 0;
             beentry->st_activity_raw[0] = '\0';
             beentry->st_activity_start_timestamp = 0;
             /* st_xact_start_timestamp and wait_event_info are also disabled */
             beentry->st_xact_start_timestamp = 0;
             proc->wait_event_info = 0;
             PGSTAT_END_WRITE_ACTIVITY(beentry);
         }
         return;
     }
 
     /*
      * To minimize the time spent modifying the entry, and avoid risk of
      * errors inside the critical section, fetch all the needed data first.
      */
     start_timestamp = GetCurrentStatementStartTimestamp();
     if (cmd_str != NULL)
     {
         /*
          * Compute length of to-be-stored string unaware of multi-byte
          * characters. For speed reasons that'll get corrected on read, rather
          * than computed every write.
          */
         len = Min(strlen(cmd_str), pgstat_track_activity_query_size - 1);
     }
     current_timestamp = GetCurrentTimestamp();
 
     /*
      * Now update the status entry
      */
     PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
     beentry->st_state = state;
     beentry->st_state_start_timestamp = current_timestamp;
 
     if (cmd_str != NULL)
     {
         memcpy((char *) beentry->st_activity_raw, cmd_str, len);
         beentry->st_activity_raw[len] = '\0';
         beentry->st_activity_start_timestamp = start_timestamp;
     }
 
     PGSTAT_END_WRITE_ACTIVITY(beentry);
 }

◆ pgstat_report_analyze()

void pgstat_report_analyze	(	Relation	rel,
		PgStat_Counter	livetuples,
		PgStat_Counter	deadtuples,
		bool	resetcounter
	)

Definition at line 1491 of file pgstat.c.

Referenced by do_analyze_rel().

 {
     PgStat_MsgAnalyze msg;
 
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
         return;
 
     /*
      * Unlike VACUUM, ANALYZE might be running inside a transaction that has
      * already inserted and/or deleted rows in the target table. ANALYZE will
      * have counted such rows as live or dead respectively. Because we will
      * report our counts of such rows at transaction end, we should subtract
      * off these counts from what we send to the collector now, else they'll
      * be double-counted after commit.  (This approach also ensures that the
      * collector ends up with the right numbers if we abort instead of
      * committing.)
      */
     if (rel->pgstat_info != NULL)
     {
         PgStat_TableXactStatus *trans;
 
         for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
         {
             livetuples -= trans->tuples_inserted - trans->tuples_deleted;
             deadtuples -= trans->tuples_updated + trans->tuples_deleted;
         }
         /* count stuff inserted by already-aborted subxacts, too */
         deadtuples -= rel->pgstat_info->t_counts.t_delta_dead_tuples;
         /* Since ANALYZE's counts are estimates, we could have underflowed */
         livetuples = Max(livetuples, 0);
         deadtuples = Max(deadtuples, 0);
     }
 
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ANALYZE);
     msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
     msg.m_tableoid = RelationGetRelid(rel);
     msg.m_autovacuum = IsAutoVacuumWorkerProcess();
     msg.m_resetcounter = resetcounter;
     msg.m_analyzetime = GetCurrentTimestamp();
     msg.m_live_tuples = livetuples;
     msg.m_dead_tuples = deadtuples;
     pgstat_send(&msg, sizeof(msg));
 }

◆ pgstat_report_appname()

void pgstat_report_appname ( const char * appname )

Definition at line 3305 of file pgstat.c.

References MyBEEntry, NAMEDATALEN, pg_mbcliplen(), PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, and PgBackendStatus::st_appname.

Referenced by assign_application_name(), and pgstat_bestart().

 {
     volatile PgBackendStatus *beentry = MyBEEntry;
     int         len;
 
     if (!beentry)
         return;
 
     /* This should be unnecessary if GUC did its job, but be safe */
     len = pg_mbcliplen(appname, strlen(appname), NAMEDATALEN - 1);
 
     /*
      * Update my status entry, following the protocol of bumping
      * st_changecount before and after.  We use a volatile pointer here to
      * ensure the compiler doesn't try to get cute.
      */
     PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
     memcpy((char *) beentry->st_appname, appname, len);
     beentry->st_appname[len] = '\0';
 
     PGSTAT_END_WRITE_ACTIVITY(beentry);
 }

◆ pgstat_report_autovac()

void pgstat_report_autovac ( Oid dboid )

Definition at line 1441 of file pgstat.c.

References GetCurrentTimestamp(), PgStat_MsgAutovacStart::m_databaseid, PgStat_MsgAutovacStart::m_hdr, PgStat_MsgAutovacStart::m_start_time, PGINVALID_SOCKET, PGSTAT_MTYPE_AUTOVAC_START, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by AutoVacWorkerMain().

 {
     PgStat_MsgAutovacStart msg;
 
     if (pgStatSock == PGINVALID_SOCKET)
         return;
 
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_AUTOVAC_START);
     msg.m_databaseid = dboid;
     msg.m_start_time = GetCurrentTimestamp();
 
     pgstat_send(&msg, sizeof(msg));
 }

◆ pgstat_report_checksum_failure()

void pgstat_report_checksum_failure ( void )

Definition at line 1607 of file pgstat.c.

References MyDatabaseId, and pgstat_report_checksum_failures_in_db().

Referenced by PageIsVerified().

 {
     pgstat_report_checksum_failures_in_db(MyDatabaseId, 1);
 }

◆ pgstat_report_checksum_failures_in_db()

void pgstat_report_checksum_failures_in_db	(	Oid	dboid,
		int	failurecount
	)

Definition at line 1585 of file pgstat.c.

References GetCurrentTimestamp(), PgStat_MsgChecksumFailure::m_databaseid, PgStat_MsgChecksumFailure::m_failure_time, PgStat_MsgChecksumFailure::m_failurecount, PgStat_MsgChecksumFailure::m_hdr, PGINVALID_SOCKET, PGSTAT_MTYPE_CHECKSUMFAILURE, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by pgstat_report_checksum_failure(), and sendFile().

 {
     PgStat_MsgChecksumFailure msg;
 
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
         return;
 
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_CHECKSUMFAILURE);
     msg.m_databaseid = dboid;
     msg.m_failurecount = failurecount;
     msg.m_failure_time = GetCurrentTimestamp();
 
     pgstat_send(&msg, sizeof(msg));
 }

◆ pgstat_report_deadlock()

void pgstat_report_deadlock ( void )

Definition at line 1564 of file pgstat.c.

References PgStat_MsgDeadlock::m_databaseid, PgStat_MsgDeadlock::m_hdr, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_DEADLOCK, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by DeadLockReport().

 {
     PgStat_MsgDeadlock msg;
 
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
         return;
 
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DEADLOCK);
     msg.m_databaseid = MyDatabaseId;
     pgstat_send(&msg, sizeof(msg));
 }

◆ pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int reason )

Definition at line 1544 of file pgstat.c.

References PgStat_MsgRecoveryConflict::m_databaseid, PgStat_MsgRecoveryConflict::m_hdr, PgStat_MsgRecoveryConflict::m_reason, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_RECOVERYCONFLICT, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by ProcessInterrupts().

 {
     PgStat_MsgRecoveryConflict msg;
 
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
         return;
 
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RECOVERYCONFLICT);
     msg.m_databaseid = MyDatabaseId;
     msg.m_reason = reason;
     pgstat_send(&msg, sizeof(msg));
 }

◆ pgstat_report_stat()

void pgstat_report_stat ( bool force )

Definition at line 839 of file pgstat.c.

References Assert, GetCurrentTransactionStopTimestamp(), hash_destroy(), have_function_stats, i, InvalidOid, PgStat_MsgTabstat::m_databaseid, PgStat_MsgTabstat::m_entry, PgStat_MsgTabstat::m_nentries, MemSet, MyDatabaseId, now(), PGSTAT_NUM_TABENTRIES, pgstat_send_funcstats(), pgstat_send_slru(), pgstat_send_tabstat(), PGSTAT_STAT_INTERVAL, pgStatXactCommit, pgStatXactRollback, PgStat_TableStatus::t_counts, PgStat_TableEntry::t_counts, PgStat_TableStatus::t_id, PgStat_TableEntry::t_id, PgStat_TableStatus::t_shared, TimestampDifferenceExceeds(), PgStat_TableStatus::trans, TabStatusArray::tsa_entries, TabStatusArray::tsa_next, and TabStatusArray::tsa_used.

Referenced by apply_handle_commit(), apply_handle_stream_commit(), initialize_worker_spi(), LogicalRepSyncTableStart(), pg_attribute_noreturn(), pgstat_beshutdown_hook(), PostgresMain(), and process_syncing_tables_for_apply().

 {
     /* we assume this inits to all zeroes: */
     static const PgStat_TableCounts all_zeroes;
     static TimestampTz last_report = 0;
 
     TimestampTz now;
     PgStat_MsgTabstat regular_msg;
     PgStat_MsgTabstat shared_msg;
     TabStatusArray *tsa;
     int         i;
 
     /* Don't expend a clock check if nothing to do */
     if ((pgStatTabList == NULL || pgStatTabList->tsa_used == 0) &&
         pgStatXactCommit == 0 && pgStatXactRollback == 0 &&
         !have_function_stats)
         return;
 
     /*
      * Don't send a message unless it's been at least PGSTAT_STAT_INTERVAL
      * msec since we last sent one, or the caller wants to force stats out.
      */
     now = GetCurrentTransactionStopTimestamp();
     if (!force &&
         !TimestampDifferenceExceeds(last_report, now, PGSTAT_STAT_INTERVAL))
         return;
     last_report = now;
 
     /*
      * Destroy pgStatTabHash before we start invalidating PgStat_TableEntry
      * entries it points to.  (Should we fail partway through the loop below,
      * it's okay to have removed the hashtable already --- the only
      * consequence is we'd get multiple entries for the same table in the
      * pgStatTabList, and that's safe.)
      */
     if (pgStatTabHash)
         hash_destroy(pgStatTabHash);
     pgStatTabHash = NULL;
 
     /*
      * Scan through the TabStatusArray struct(s) to find tables that actually
      * have counts, and build messages to send.  We have to separate shared
      * relations from regular ones because the databaseid field in the message
      * header has to depend on that.
      */
     regular_msg.m_databaseid = MyDatabaseId;
     shared_msg.m_databaseid = InvalidOid;
     regular_msg.m_nentries = 0;
     shared_msg.m_nentries = 0;
 
     for (tsa = pgStatTabList; tsa != NULL; tsa = tsa->tsa_next)
     {
         for (i = 0; i < tsa->tsa_used; i++)
         {
             PgStat_TableStatus *entry = &tsa->tsa_entries[i];
             PgStat_MsgTabstat *this_msg;
             PgStat_TableEntry *this_ent;
 
             /* Shouldn't have any pending transaction-dependent counts */
             Assert(entry->trans == NULL);
 
             /*
              * Ignore entries that didn't accumulate any actual counts, such
              * as indexes that were opened by the planner but not used.
              */
             if (memcmp(&entry->t_counts, &all_zeroes,
                        sizeof(PgStat_TableCounts)) == 0)
                 continue;
 
             /*
              * OK, insert data into the appropriate message, and send if full.
              */
             this_msg = entry->t_shared ? &shared_msg : &regular_msg;
             this_ent = &this_msg->m_entry[this_msg->m_nentries];
             this_ent->t_id = entry->t_id;
             memcpy(&this_ent->t_counts, &entry->t_counts,
                    sizeof(PgStat_TableCounts));
             if (++this_msg->m_nentries >= PGSTAT_NUM_TABENTRIES)
             {
                 pgstat_send_tabstat(this_msg);
                 this_msg->m_nentries = 0;
             }
         }
         /* zero out PgStat_TableStatus structs after use */
         MemSet(tsa->tsa_entries, 0,
                tsa->tsa_used * sizeof(PgStat_TableStatus));
         tsa->tsa_used = 0;
     }
 
     /*
      * Send partial messages.  Make sure that any pending xact commit/abort
      * gets counted, even if there are no table stats to send.
      */
     if (regular_msg.m_nentries > 0 ||
         pgStatXactCommit > 0 || pgStatXactRollback > 0)
         pgstat_send_tabstat(&regular_msg);
     if (shared_msg.m_nentries > 0)
         pgstat_send_tabstat(&shared_msg);
 
     /* Now, send function statistics */
     pgstat_send_funcstats();
 
     /* Finally send SLRU statistics */
     pgstat_send_slru();
 }

◆ pgstat_report_tempfile()

void pgstat_report_tempfile ( size_t filesize )

Definition at line 1619 of file pgstat.c.

References PgStat_MsgTempFile::m_databaseid, PgStat_MsgTempFile::m_filesize, PgStat_MsgTempFile::m_hdr, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_TEMPFILE, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by ReportTemporaryFileUsage().

 {
     PgStat_MsgTempFile msg;
 
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
         return;
 
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TEMPFILE);
     msg.m_databaseid = MyDatabaseId;
     msg.m_filesize = filesize;
     pgstat_send(&msg, sizeof(msg));
 }

◆ pgstat_report_vacuum()

void pgstat_report_vacuum	(	Oid	tableoid,
		bool	shared,
		PgStat_Counter	livetuples,
		PgStat_Counter	deadtuples
	)

Definition at line 1463 of file pgstat.c.

References GetCurrentTimestamp(), InvalidOid, IsAutoVacuumWorkerProcess(), PgStat_MsgVacuum::m_autovacuum, PgStat_MsgVacuum::m_databaseid, PgStat_MsgVacuum::m_dead_tuples, PgStat_MsgVacuum::m_hdr, PgStat_MsgVacuum::m_live_tuples, PgStat_MsgVacuum::m_tableoid, PgStat_MsgVacuum::m_vacuumtime, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_VACUUM, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by heap_vacuum_rel().

 {
     PgStat_MsgVacuum msg;
 
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
         return;
 
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_VACUUM);
     msg.m_databaseid = shared ? InvalidOid : MyDatabaseId;
     msg.m_tableoid = tableoid;
     msg.m_autovacuum = IsAutoVacuumWorkerProcess();
     msg.m_vacuumtime = GetCurrentTimestamp();
     msg.m_live_tuples = livetuples;
     msg.m_dead_tuples = deadtuples;
     pgstat_send(&msg, sizeof(msg));
 }

◆ pgstat_report_wait_end()

static void pgstat_report_wait_end ( void )

inlinestatic

Definition at line 1386 of file pgstat.h.

References MyProc, pgstat_track_activities, and PGPROC::wait_event_info.

Referenced by AbortSubTransaction(), AbortTransaction(), AddToDataDirLockFile(), ApplyLogicalMappingFile(), assign_xlog_sync_method(), AutoVacLauncherMain(), BackgroundWriterMain(), basebackup_read_file(), BootStrapXLOG(), CheckpointerMain(), CheckPointLogicalRewriteHeap(), copy_file(), CreateLockFile(), do_pg_stop_backup(), dsm_impl_mmap(), dsm_impl_op(), FilePrefetch(), FileRead(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), heap_xlog_logical_rewrite(), issue_xlog_fsync(), load_relmap_file(), LWLockReportWaitEnd(), ProcArrayGroupClearXid(), ReadControlFile(), readTimeLineHistory(), ReadTwoPhaseFile(), RecheckDataDirLockFile(), recoveryPausesHere(), RecreateTwoPhaseFile(), ReorderBufferSerializeChange(), RestoreSlotFromDisk(), SaveSlotToPath(), SendTimeLineHistory(), ShutdownAuxiliaryProcess(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SnapBuildRestore(), SnapBuildSerialize(), TransactionGroupUpdateXidStatus(), update_controlfile(), vacuum_delay_point(), WaitEventSetWait(), WaitExceedsMaxStandbyDelay(), WALRead(), WalSndErrorCleanup(), WalWriterMain(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), XLogFileCopy(), XLogFileInit(), XLogPageRead(), and XLogWrite().

 {
     volatile PGPROC *proc = MyProc;
 
     if (!pgstat_track_activities || !proc)
         return;
 
     /*
      * Since this is a four-byte field which is always read and written as
      * four-bytes, updates are atomic.
      */
     proc->wait_event_info = 0;
 }

◆ pgstat_report_wait_start()

static void pgstat_report_wait_start ( uint32 wait_event_info )

inlinestatic

Variables
PGDLLIMPORT bool	pgstat_track_activities

PGDLLIMPORT bool	pgstat_track_counts

PGDLLIMPORT int	pgstat_track_functions

PGDLLIMPORT int	pgstat_track_activity_query_size

char *	pgstat_stat_directory

char *	pgstat_stat_tmpname

char *	pgstat_stat_filename

PgStat_MsgBgWriter	BgWriterStats

PgStat_Counter	pgStatBlockReadTime

PgStat_Counter	pgStatBlockWriteTime

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ PG_STAT_TMP_DIR

◆ PG_WAIT_ACTIVITY

◆ PG_WAIT_BUFFER_PIN

◆ PG_WAIT_CLIENT

◆ PG_WAIT_EXTENSION

◆ PG_WAIT_IO

◆ PG_WAIT_IPC

◆ PG_WAIT_LOCK

◆ PG_WAIT_LWLOCK

◆ PG_WAIT_TIMEOUT

◆ pgstat_begin_read_activity

◆ PGSTAT_BEGIN_WRITE_ACTIVITY

◆ pgstat_count_buffer_hit

◆ pgstat_count_buffer_read

◆ pgstat_count_buffer_read_time

◆ pgstat_count_buffer_write_time

◆ pgstat_count_heap_fetch

◆ pgstat_count_heap_getnext

◆ pgstat_count_heap_scan

◆ pgstat_count_index_scan

◆ pgstat_count_index_tuples

◆ pgstat_end_read_activity

◆ PGSTAT_END_WRITE_ACTIVITY

◆ PGSTAT_FILE_FORMAT_ID

◆ PGSTAT_MAX_MSG_SIZE

◆ PGSTAT_MSG_PAYLOAD

◆ PGSTAT_NUM_FUNCENTRIES

◆ PGSTAT_NUM_FUNCPURGE

◆ PGSTAT_NUM_PROGRESS_PARAM

◆ PGSTAT_NUM_TABENTRIES

◆ PGSTAT_NUM_TABPURGE

◆ pgstat_read_activity_complete

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

◆ PGSTAT_STAT_PERMANENT_FILENAME

◆ PGSTAT_STAT_PERMANENT_TMPFILE

Typedef Documentation

◆ BackendState

◆ LocalPgBackendStatus

◆ PgBackendGSSStatus

◆ PgBackendSSLStatus

◆ PgBackendStatus

◆ PgStat_ArchiverStats

◆ PgStat_BackendFunctionEntry

◆ PgStat_Counter

◆ PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

◆ PgStat_FunctionEntry

◆ PgStat_GlobalStats

◆ PgStat_Msg

◆ PgStat_MsgAnalyze

◆ PgStat_MsgArchiver

◆ PgStat_MsgAutovacStart

◆ PgStat_MsgBgWriter

◆ PgStat_MsgChecksumFailure

◆ PgStat_MsgDeadlock

◆ PgStat_MsgDropdb

◆ PgStat_MsgDummy

◆ PgStat_MsgFuncpurge

◆ PgStat_MsgFuncstat

◆ PgStat_MsgHdr

◆ PgStat_MsgInquiry

◆ PgStat_MsgRecoveryConflict

◆ PgStat_MsgResetcounter

◆ PgStat_MsgResetsharedcounter

◆ PgStat_MsgResetsinglecounter

◆ PgStat_MsgResetslrucounter

◆ PgStat_MsgSLRU

◆ PgStat_MsgTabpurge

◆ PgStat_MsgTabstat

◆ PgStat_MsgTempFile

◆ PgStat_MsgVacuum

◆ PgStat_Shared_Reset_Target

◆ PgStat_Single_Reset_Type