pgstat.h File Reference

#include "datatype/timestamp.h"
#include "libpq/pqcomm.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_MsgAutovacStart
struct	PgStat_MsgVacuum
struct	PgStat_MsgAnalyze
struct	PgStat_MsgArchiver
struct	PgStat_MsgBgWriter
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	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_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_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 enum BackendType	BackendType
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_AUTOVAC_START, PGSTAT_MTYPE_VACUUM, PGSTAT_MTYPE_ANALYZE, PGSTAT_MTYPE_ARCHIVER,   PGSTAT_MTYPE_BGWRITER, 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	BackendType {   B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER,   B_BG_WRITER, B_CHECKPOINTER, B_STARTUP, B_WAL_RECEIVER,   B_WAL_SENDER, B_WAL_WRITER }
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_ALL, 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_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,   WAIT_EVENT_GSS_OPEN_SERVER }
enum	WaitEventIPC {   WAIT_EVENT_BGWORKER_SHUTDOWN = PG_WAIT_IPC, WAIT_EVENT_BGWORKER_STARTUP, WAIT_EVENT_BTREE_PAGE, WAIT_EVENT_CLOG_GROUP_UPDATE,   WAIT_EVENT_CHECKPOINT_DONE, WAIT_EVENT_CHECKPOINT_START, WAIT_EVENT_EXECUTE_GATHER, WAIT_EVENT_HASH_BATCH_ALLOCATING,   WAIT_EVENT_HASH_BATCH_ELECTING, WAIT_EVENT_HASH_BATCH_LOADING, WAIT_EVENT_HASH_BUILD_ALLOCATING, WAIT_EVENT_HASH_BUILD_ELECTING,   WAIT_EVENT_HASH_BUILD_HASHING_INNER, WAIT_EVENT_HASH_BUILD_HASHING_OUTER, WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATING, WAIT_EVENT_HASH_GROW_BATCHES_DECIDING,   WAIT_EVENT_HASH_GROW_BATCHES_ELECTING, WAIT_EVENT_HASH_GROW_BATCHES_FINISHING, WAIT_EVENT_HASH_GROW_BATCHES_REPARTITIONING, WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATING,   WAIT_EVENT_HASH_GROW_BUCKETS_ELECTING, WAIT_EVENT_HASH_GROW_BUCKETS_REINSERTING, 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_PROMOTE, WAIT_EVENT_REPLICATION_ORIGIN_DROP, WAIT_EVENT_REPLICATION_SLOT_DROP, WAIT_EVENT_SAFE_SNAPSHOT,   WAIT_EVENT_SYNC_REP }
enum	WaitEventTimeout { WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT, WAIT_EVENT_PG_SLEEP, WAIT_EVENT_RECOVERY_APPLY_DELAY }
enum	WaitEventIO {   WAIT_EVENT_BUFFILE_READ = PG_WAIT_IO, WAIT_EVENT_BUFFILE_WRITE, 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 }
enum	ProgressCommandType { PROGRESS_COMMAND_INVALID, PROGRESS_COMMAND_VACUUM, PROGRESS_COMMAND_CLUSTER, PROGRESS_COMMAND_CREATE_INDEX }

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_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)
const char *	pgstat_get_backend_desc (BackendType backendType)
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)

Variables
bool	pgstat_track_activities
bool	pgstat_track_counts
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

Macro Definition Documentation

PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR   "pg_stat_tmp"

Definition at line 33 of file pgstat.h.

PG_WAIT_ACTIVITY

#define PG_WAIT_ACTIVITY   0x05000000U

Definition at line 757 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 756 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 758 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 759 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 762 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 760 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 755 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 754 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 761 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 1145 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 1130 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 1388 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 1383 of file pgstat.h.

Referenced by ReadBufferExtended().

pgstat_count_buffer_read_time

#define pgstat_count_buffer_read_time

(

n

)

(pgStatBlockReadTime += (n))

Definition at line 1393 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 1395 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 1368 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 1363 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 1358 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 1373 of file pgstat.h.

Referenced by _bt_first(), _hash_first(), bringetbitmap(), ginNewScanKey(), 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 1378 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 1151 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 1137 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 584 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 206 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 207 of file pgstat.h.

PGSTAT_NUM_FUNCENTRIES

#define PGSTAT_NUM_FUNCENTRIES

Value:

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

Definition at line 493 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))

Definition at line 510 of file pgstat.h.

Referenced by pgstat_vacuum_stat().

PGSTAT_NUM_PROGRESS_PARAM

#define PGSTAT_NUM_PROGRESS_PARAM   20

Definition at line 962 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))

Definition at line 263 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))

Definition at line 285 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 1157 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 28 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 29 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 30 of file pgstat.h.

Referenced by pgstat_write_statsfiles().

Typedef Documentation

BackendState

typedef enum BackendState BackendState

BackendType

typedef enum BackendType BackendType

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 74 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_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_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 738 of file pgstat.h.

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

BackendType

enum BackendType

Enumerator
B_AUTOVAC_LAUNCHER
B_AUTOVAC_WORKER
B_BACKEND
B_BG_WORKER
B_BG_WRITER
B_CHECKPOINTER
B_STARTUP
B_WAL_RECEIVER
B_WAL_SENDER
B_WAL_WRITER

Definition at line 719 of file pgstat.h.

{
    B_AUTOVAC_LAUNCHER,
    B_AUTOVAC_WORKER,
    B_BACKEND,
    B_BG_WORKER,
    B_BG_WRITER,
    B_CHECKPOINTER,
    B_STARTUP,
    B_WAL_RECEIVER,
    B_WAL_SENDER,
    B_WAL_WRITER
} BackendType;

PgStat_Shared_Reset_Target

enum PgStat_Shared_Reset_Target

Enumerator
RESET_ARCHIVER
RESET_BGWRITER

Definition at line 119 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 126 of file pgstat.h.

{
    RESET_TABLE,
    RESET_FUNCTION
} PgStat_Single_Reset_Type;

ProgressCommandType

enum ProgressCommandType

Enumerator
PROGRESS_COMMAND_INVALID
PROGRESS_COMMAND_VACUUM
PROGRESS_COMMAND_CLUSTER
PROGRESS_COMMAND_CREATE_INDEX

Definition at line 954 of file pgstat.h.

{
    PROGRESS_COMMAND_INVALID,
    PROGRESS_COMMAND_VACUUM,
    PROGRESS_COMMAND_CLUSTER,
    PROGRESS_COMMAND_CREATE_INDEX
} 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_AUTOVAC_START
PGSTAT_MTYPE_VACUUM
PGSTAT_MTYPE_ANALYZE
PGSTAT_MTYPE_ARCHIVER
PGSTAT_MTYPE_BGWRITER
PGSTAT_MTYPE_FUNCSTAT
PGSTAT_MTYPE_FUNCPURGE
PGSTAT_MTYPE_RECOVERYCONFLICT
PGSTAT_MTYPE_TEMPFILE
PGSTAT_MTYPE_DEADLOCK
PGSTAT_MTYPE_CHECKSUMFAILURE

Definition at line 47 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_AUTOVAC_START,
    PGSTAT_MTYPE_VACUUM,
    PGSTAT_MTYPE_ANALYZE,
    PGSTAT_MTYPE_ARCHIVER,
    PGSTAT_MTYPE_BGWRITER,
    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 36 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_ALL
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 772 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_ALL,
    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_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
WAIT_EVENT_GSS_OPEN_SERVER

Definition at line 798 of file pgstat.h.

{
    WAIT_EVENT_CLIENT_READ = PG_WAIT_CLIENT,
    WAIT_EVENT_CLIENT_WRITE,
    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,
    WAIT_EVENT_GSS_OPEN_SERVER,
} WaitEventClient;

WaitEventIO

enum WaitEventIO

Enumerator
WAIT_EVENT_BUFFILE_READ
WAIT_EVENT_BUFFILE_WRITE
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

Definition at line 878 of file pgstat.h.

{
    WAIT_EVENT_BUFFILE_READ = PG_WAIT_IO,
    WAIT_EVENT_BUFFILE_WRITE,
    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
} WaitEventIO;

WaitEventIPC

enum WaitEventIPC

Enumerator
WAIT_EVENT_BGWORKER_SHUTDOWN
WAIT_EVENT_BGWORKER_STARTUP
WAIT_EVENT_BTREE_PAGE
WAIT_EVENT_CLOG_GROUP_UPDATE
WAIT_EVENT_CHECKPOINT_DONE
WAIT_EVENT_CHECKPOINT_START
WAIT_EVENT_EXECUTE_GATHER
WAIT_EVENT_HASH_BATCH_ALLOCATING
WAIT_EVENT_HASH_BATCH_ELECTING
WAIT_EVENT_HASH_BATCH_LOADING
WAIT_EVENT_HASH_BUILD_ALLOCATING
WAIT_EVENT_HASH_BUILD_ELECTING
WAIT_EVENT_HASH_BUILD_HASHING_INNER
WAIT_EVENT_HASH_BUILD_HASHING_OUTER
WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATING
WAIT_EVENT_HASH_GROW_BATCHES_DECIDING
WAIT_EVENT_HASH_GROW_BATCHES_ELECTING
WAIT_EVENT_HASH_GROW_BATCHES_FINISHING
WAIT_EVENT_HASH_GROW_BATCHES_REPARTITIONING
WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATING
WAIT_EVENT_HASH_GROW_BUCKETS_ELECTING
WAIT_EVENT_HASH_GROW_BUCKETS_REINSERTING
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_PROMOTE
WAIT_EVENT_REPLICATION_ORIGIN_DROP
WAIT_EVENT_REPLICATION_SLOT_DROP
WAIT_EVENT_SAFE_SNAPSHOT
WAIT_EVENT_SYNC_REP

Definition at line 818 of file pgstat.h.

{
    WAIT_EVENT_BGWORKER_SHUTDOWN = PG_WAIT_IPC,
    WAIT_EVENT_BGWORKER_STARTUP,
    WAIT_EVENT_BTREE_PAGE,
    WAIT_EVENT_CLOG_GROUP_UPDATE,
    WAIT_EVENT_CHECKPOINT_DONE,
    WAIT_EVENT_CHECKPOINT_START,
    WAIT_EVENT_EXECUTE_GATHER,
    WAIT_EVENT_HASH_BATCH_ALLOCATING,
    WAIT_EVENT_HASH_BATCH_ELECTING,
    WAIT_EVENT_HASH_BATCH_LOADING,
    WAIT_EVENT_HASH_BUILD_ALLOCATING,
    WAIT_EVENT_HASH_BUILD_ELECTING,
    WAIT_EVENT_HASH_BUILD_HASHING_INNER,
    WAIT_EVENT_HASH_BUILD_HASHING_OUTER,
    WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATING,
    WAIT_EVENT_HASH_GROW_BATCHES_DECIDING,
    WAIT_EVENT_HASH_GROW_BATCHES_ELECTING,
    WAIT_EVENT_HASH_GROW_BATCHES_FINISHING,
    WAIT_EVENT_HASH_GROW_BATCHES_REPARTITIONING,
    WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATING,
    WAIT_EVENT_HASH_GROW_BUCKETS_ELECTING,
    WAIT_EVENT_HASH_GROW_BUCKETS_REINSERTING,
    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_PROMOTE,
    WAIT_EVENT_REPLICATION_ORIGIN_DROP,
    WAIT_EVENT_REPLICATION_SLOT_DROP,
    WAIT_EVENT_SAFE_SNAPSHOT,
    WAIT_EVENT_SYNC_REP
} WaitEventIPC;

WaitEventTimeout

enum WaitEventTimeout

Enumerator
WAIT_EVENT_BASE_BACKUP_THROTTLE
WAIT_EVENT_PG_SLEEP
WAIT_EVENT_RECOVERY_APPLY_DELAY

Definition at line 865 of file pgstat.h.

{
    WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT,
    WAIT_EVENT_PG_SLEEP,
    WAIT_EVENT_RECOVERY_APPLY_DELAY
} WaitEventTimeout;

Function Documentation

allow_immediate_pgstat_restart()

void allow_immediate_pgstat_restart

(

void

)

Definition at line 789 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 2179 of file pgstat.c.

References Assert, PgStat_SubXactStatus::first, get_tabstat_stack_level(), PgStat_TableXactStatus::nest_level, PgStat_SubXactStatus::nest_level, PgStat_TableXactStatus::next, PgStat_TableXactStatus::parent, pfree(), pgstat_truncate_restore_counters(), pgstat_truncate_save_counters(), pgStatXactStack, PgStat_SubXactStatus::prev, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_delta_dead_tuples, PgStat_TableCounts::t_tuples_deleted, PgStat_TableCounts::t_tuples_inserted, PgStat_TableCounts::t_tuples_updated, PgStat_TableStatus::trans, trans, PgStat_TableXactStatus::truncated, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, PgStat_TableXactStatus::tuples_updated, and PgStat_TableXactStatus::upper.

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 2092 of file pgstat.c.

References Assert, PgStat_SubXactStatus::first, PgStat_TableXactStatus::nest_level, PgStat_SubXactStatus::nest_level, PgStat_TableXactStatus::next, PgStat_TableXactStatus::parent, pgstat_clear_snapshot(), pgstat_truncate_restore_counters(), pgStatXactCommit, pgStatXactRollback, pgStatXactStack, PgStat_SubXactStatus::prev, PgStat_TableCounts::t_changed_tuples, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_delta_dead_tuples, PgStat_TableCounts::t_delta_live_tuples, PgStat_TableCounts::t_truncated, PgStat_TableCounts::t_tuples_deleted, PgStat_TableCounts::t_tuples_inserted, PgStat_TableCounts::t_tuples_updated, PgStat_TableStatus::trans, trans, PgStat_TableXactStatus::truncated, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, PgStat_TableXactStatus::tuples_updated, and PgStat_TableXactStatus::upper.

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 2278 of file pgstat.c.

References Assert, PgStat_TableXactStatus::deleted_pre_trunc, TwoPhasePgStatRecord::deleted_pre_trunc, PgStat_SubXactStatus::first, PgStat_TableXactStatus::inserted_pre_trunc, TwoPhasePgStatRecord::inserted_pre_trunc, PgStat_TableXactStatus::nest_level, PgStat_SubXactStatus::nest_level, PgStat_TableXactStatus::next, PgStat_TableXactStatus::parent, pgStatXactStack, PgStat_SubXactStatus::prev, RegisterTwoPhaseRecord(), PgStat_TableStatus::t_id, TwoPhasePgStatRecord::t_id, PgStat_TableStatus::t_shared, TwoPhasePgStatRecord::t_shared, TwoPhasePgStatRecord::t_truncated, PgStat_TableStatus::trans, trans, PgStat_TableXactStatus::truncated, PgStat_TableXactStatus::tuples_deleted, TwoPhasePgStatRecord::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, TwoPhasePgStatRecord::tuples_inserted, PgStat_TableXactStatus::tuples_updated, TwoPhasePgStatRecord::tuples_updated, TWOPHASE_RM_PGSTAT_ID, PgStat_TableXactStatus::updated_pre_trunc, TwoPhasePgStatRecord::updated_pre_trunc, and PgStat_TableXactStatus::upper.

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 2650 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 2678 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 1672 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 1877 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 2855 of file pgstat.c.

References am_walsender, application_name, Assert, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, B_WAL_WRITER, be_gssapi_get_auth(), be_gssapi_get_enc(), be_gssapi_get_princ(), be_tls_get_cipher(), be_tls_get_cipher_bits(), be_tls_get_compression(), be_tls_get_peer_issuer_name(), be_tls_get_peer_serial(), be_tls_get_peer_subject_name(), be_tls_get_version(), BgWriterProcess, CheckpointerProcess, elog, FATAL, GetSessionUserId(), Port::gss, PgBackendGSSStatus::gss_auth, PgBackendGSSStatus::gss_enc, PgBackendGSSStatus::gss_princ, InvalidBackendId, InvalidOid, IsAutoVacuumLauncherProcess(), IsAutoVacuumWorkerProcess(), IsBackgroundWorker, MemSet, MyAuxProcType, MyBackendId, MyBEEntry, MyDatabaseId, MyProcPid, MyProcPort, MyStartTimestamp, NAMEDATALEN, NotAnAuxProcess, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_report_appname(), pgstat_track_activity_query_size, PROGRESS_COMMAND_INVALID, Port::raddr, Port::remote_hostname, PgBackendSSLStatus::ssl_bits, PgBackendSSLStatus::ssl_cipher, PgBackendSSLStatus::ssl_client_dn, PgBackendSSLStatus::ssl_client_serial, PgBackendSSLStatus::ssl_compression, PgBackendSSLStatus::ssl_issuer_dn, PgBackendSSLStatus::ssl_version, PgBackendStatus::st_activity_raw, PgBackendStatus::st_activity_start_timestamp, PgBackendStatus::st_appname, PgBackendStatus::st_backendType, PgBackendStatus::st_changecount, PgBackendStatus::st_clientaddr, PgBackendStatus::st_clienthostname, PgBackendStatus::st_databaseid, PgBackendStatus::st_gss, PgBackendStatus::st_gssstatus, PgBackendStatus::st_proc_start_timestamp, PgBackendStatus::st_procpid, PgBackendStatus::st_progress_command, PgBackendStatus::st_progress_command_target, PgBackendStatus::st_ssl, PgBackendStatus::st_sslstatus, PgBackendStatus::st_state, PgBackendStatus::st_state_start_timestamp, PgBackendStatus::st_userid, PgBackendStatus::st_xact_start_timestamp, StartupProcess, STATE_UNDEFINED, strlcpy(), unvolatize, WalReceiverProcess, and WalWriterProcess.

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;

    if (MyBackendId != InvalidBackendId)
    {
        if (IsAutoVacuumLauncherProcess())
        {
            /* Autovacuum Launcher */
            lbeentry.st_backendType = B_AUTOVAC_LAUNCHER;
        }
        else if (IsAutoVacuumWorkerProcess())
        {
            /* Autovacuum Worker */
            lbeentry.st_backendType = B_AUTOVAC_WORKER;
        }
        else if (am_walsender)
        {
            /* Wal sender */
            lbeentry.st_backendType = B_WAL_SENDER;
        }
        else if (IsBackgroundWorker)
        {
            /* bgworker */
            lbeentry.st_backendType = B_BG_WORKER;
        }
        else
        {
            /* client-backend */
            lbeentry.st_backendType = B_BACKEND;
        }
    }
    else
    {
        /* Must be an auxiliary process */
        Assert(MyAuxProcType != NotAnAuxProcess);
        switch (MyAuxProcType)
        {
            case StartupProcess:
                lbeentry.st_backendType = B_STARTUP;
                break;
            case BgWriterProcess:
                lbeentry.st_backendType = B_BG_WRITER;
                break;
            case CheckpointerProcess:
                lbeentry.st_backendType = B_CHECKPOINTER;
                break;
            case WalWriterProcess:
                lbeentry.st_backendType = B_WAL_WRITER;
                break;
            case WalReceiverProcess:
                lbeentry.st_backendType = B_WAL_RECEIVER;
                break;
            default:
                elog(FATAL, "unrecognized process type: %d",
                     (int) MyAuxProcType);
        }
    }

    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 != NULL)
    {
        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 5794 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 6542 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 1992 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 1946 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 1967 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_truncate()

void pgstat_count_truncate

(

Relation

rel

)

Definition at line 2047 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 1253 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 1692 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 2619 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_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver

(

void

)

Definition at line 2602 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 2545 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 2430 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 2513 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 2567 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 2586 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 2457 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_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 4135 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_backend_desc()

const char* pgstat_get_backend_desc

(

BackendType

backendType

)

Definition at line 4272 of file pgstat.c.

References B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, and B_WAL_WRITER.

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), AuxiliaryProcessMain(), BackendInitialize(), and pg_stat_get_activity().

{
    const char *backendDesc = "unknown process type";

    switch (backendType)
    {
        case B_AUTOVAC_LAUNCHER:
            backendDesc = "autovacuum launcher";
            break;
        case B_AUTOVAC_WORKER:
            backendDesc = "autovacuum worker";
            break;
        case B_BACKEND:
            backendDesc = "client backend";
            break;
        case B_BG_WORKER:
            backendDesc = "background worker";
            break;
        case B_BG_WRITER:
            backendDesc = "background writer";
            break;
        case B_CHECKPOINTER:
            backendDesc = "checkpointer";
            break;
        case B_STARTUP:
            backendDesc = "startup";
            break;
        case B_WAL_RECEIVER:
            backendDesc = "walreceiver";
            break;
        case B_WAL_SENDER:
            backendDesc = "walsender";
            break;
        case B_WAL_WRITER:
            backendDesc = "walwriter";
            break;
    }

    return backendDesc;
}

pgstat_get_crashed_backend_activity()

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

Definition at line 4213 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 3555 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 3500 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 354 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, 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);

    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 2813 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 1749 of file pgstat.c.

References get_tabstat_entry(), PGINVALID_SOCKET, RelationData::pgstat_info, pgstat_track_counts, pgStatSock, RelationData::rd_id, RelationData::rd_rel, relkind, 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 == RELKIND_RELATION ||
          relkind == RELKIND_MATVIEW ||
          relkind == RELKIND_INDEX ||
          relkind == RELKIND_TOASTVALUE ||
          relkind == RELKIND_SEQUENCE))
    {
        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 1585 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 3269 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(), cluster_rel(), DefineIndex(), heap_vacuum_rel(), 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 3197 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 cluster_rel(), DefineIndex(), heap_vacuum_rel(), 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 3240 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(), heapam_relation_copy_for_cluster(), index_build(), lazy_scan_heap(), 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 3218 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(), btvacuumscan(), cluster_rel(), DefineIndex(), finish_heap_swap(), hashbuild(), heap_vacuum_rel(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), lazy_record_dead_tuple(), lazy_scan_heap(), lazy_truncate_heap(), lazy_vacuum_page(), 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 3119 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(), 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(), 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 1436 of file pgstat.c.

References GetCurrentTimestamp(), InvalidOid, IsAutoVacuumWorkerProcess(), PgStat_MsgAnalyze::m_analyzetime, PgStat_MsgAnalyze::m_autovacuum, PgStat_MsgAnalyze::m_databaseid, PgStat_MsgAnalyze::m_dead_tuples, PgStat_MsgAnalyze::m_hdr, PgStat_MsgAnalyze::m_live_tuples, PgStat_MsgAnalyze::m_resetcounter, PgStat_MsgAnalyze::m_tableoid, Max, MyDatabaseId, PGINVALID_SOCKET, RelationData::pgstat_info, PGSTAT_MTYPE_ANALYZE, pgstat_send(), pgstat_setheader(), pgstat_track_counts, pgStatSock, RelationData::rd_rel, RelationGetRelid, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_delta_dead_tuples, PgStat_TableStatus::trans, trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, PgStat_TableXactStatus::tuples_updated, and PgStat_TableXactStatus::upper.

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 3292 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 1386 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 1552 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 1530 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 1509 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 1489 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 811 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_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(), 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();
}

pgstat_report_tempfile()

void pgstat_report_tempfile

(

size_t

filesize

)

Definition at line 1564 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 1408 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 1342 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(), BootStrapXLOG(), CheckpointerMain(), CheckPointLogicalRewriteHeap(), copy_file(), CreateLockFile(), dsm_impl_mmap(), FilePrefetch(), FileRead(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), heap_xlog_logical_rewrite(), issue_xlog_fsync(), load_relmap_file(), LWLockReportWaitEnd(), ProcArrayGroupClearXid(), ReadControlFile(), ReadTwoPhaseFile(), RecheckDataDirLockFile(), RecreateTwoPhaseFile(), ReorderBufferRestoreChanges(), ReorderBufferSerializeChange(), RestoreSlotFromDisk(), SaveSlotToPath(), SendTimeLineHistory(), ShutdownAuxiliaryProcess(), SimpleLruFlush(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SnapBuildRestore(), SnapBuildSerialize(), TransactionGroupUpdateXidStatus(), update_controlfile(), WaitEventSetWait(), 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

Definition at line 1318 of file pgstat.h.

References MyProc, pgstat_track_activities, and PGPROC::wait_event_info.

Referenced by AddToDataDirLockFile(), ApplyLogicalMappingFile(), assign_xlog_sync_method(), BootStrapXLOG(), CheckPointLogicalRewriteHeap(), copy_file(), CreateLockFile(), dsm_impl_mmap(), FilePrefetch(), FileRead(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), heap_xlog_logical_rewrite(), issue_xlog_fsync(), load_relmap_file(), LWLockReportWaitStart(), ProcArrayGroupClearXid(), ReadControlFile(), ReadTwoPhaseFile(), RecheckDataDirLockFile(), RecreateTwoPhaseFile(), ReorderBufferRestoreChanges(), ReorderBufferSerializeChange(), RestoreSlotFromDisk(), SaveSlotToPath(), SendTimeLineHistory(), SimpleLruFlush(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SnapBuildRestore(), SnapBuildSerialize(), TransactionGroupUpdateXidStatus(), update_controlfile(), WaitEventSetWait(), WALRead(), 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 = wait_event_info;
}