#include "datatype/timestamp.h"
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
#include "replication/conflict.h"
#include "utils/backend_progress.h"
#include "utils/backend_status.h"
#include "utils/pgstat_kind.h"
#include "utils/relcache.h"
#include "utils/wait_event.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_FunctionCounts

struct	PgStat_FunctionCallUsage

struct	PgStat_BackendSubEntry

struct	PgStat_TableCounts

struct	PgStat_TableStatus

struct	PgStat_TableXactStatus

struct	PgStat_ArchiverStats

struct	PgStat_BgWriterStats

struct	PgStat_CheckpointerStats

struct	PgStat_BktypeIO

struct	PgStat_PendingIO

struct	PgStat_IO

struct	PgStat_StatDBEntry

struct	PgStat_StatFuncEntry

struct	PgStat_StatReplSlotEntry

struct	PgStat_SLRUStats

struct	PgStat_StatSubEntry

struct	PgStat_StatTabEntry

struct	PgStat_WalCounters

struct	PgStat_WalStats

struct	PgStat_Backend

struct	PgStat_BackendPending

Macros
#define	PGSTAT_STAT_PERMANENT_DIRECTORY "pg_stat"

#define	PGSTAT_STAT_PERMANENT_FILENAME "pg_stat/pgstat.stat"

#define	PGSTAT_STAT_PERMANENT_TMPFILE "pg_stat/pgstat.tmp"

#define	PG_STAT_TMP_DIR "pg_stat_tmp"

#define	PGSTAT_FILE_FORMAT_ID 0x01A5BCB7

#define	IOOBJECT_NUM_TYPES (IOOBJECT_WAL + 1)

#define	IOCONTEXT_NUM_TYPES (IOCONTEXT_VACUUM + 1)

#define	IOOP_NUM_TYPES (IOOP_WRITE + 1)

#define	pgstat_is_ioop_tracked_in_bytes(io_op)

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

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

#define	pgstat_count_conn_active_time(n) (pgStatActiveTime += (n))

#define	pgstat_count_conn_txn_idle_time(n) (pgStatTransactionIdleTime += (n))

#define	pgstat_should_count_relation(rel)

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

Typedefs
typedef enum TrackFunctionsLevel	TrackFunctionsLevel

typedef enum PgStat_FetchConsistency	PgStat_FetchConsistency

typedef enum SessionEndType	SessionEndType

typedef int64	PgStat_Counter

typedef struct PgStat_FunctionCounts	PgStat_FunctionCounts

typedef struct PgStat_FunctionCallUsage	PgStat_FunctionCallUsage

typedef struct PgStat_BackendSubEntry	PgStat_BackendSubEntry

typedef struct PgStat_TableCounts	PgStat_TableCounts

typedef struct PgStat_TableStatus	PgStat_TableStatus

typedef struct PgStat_TableXactStatus	PgStat_TableXactStatus

typedef struct PgStat_ArchiverStats	PgStat_ArchiverStats

typedef struct PgStat_BgWriterStats	PgStat_BgWriterStats

typedef struct PgStat_CheckpointerStats	PgStat_CheckpointerStats

typedef enum IOObject	IOObject

typedef enum IOContext	IOContext

typedef enum IOOp	IOOp

typedef struct PgStat_BktypeIO	PgStat_BktypeIO

typedef struct PgStat_PendingIO	PgStat_PendingIO

typedef struct PgStat_IO	PgStat_IO

typedef struct PgStat_StatDBEntry	PgStat_StatDBEntry

typedef struct PgStat_StatFuncEntry	PgStat_StatFuncEntry

typedef struct PgStat_StatReplSlotEntry	PgStat_StatReplSlotEntry

typedef struct PgStat_SLRUStats	PgStat_SLRUStats

typedef struct PgStat_StatSubEntry	PgStat_StatSubEntry

typedef struct PgStat_StatTabEntry	PgStat_StatTabEntry

typedef struct PgStat_WalCounters	PgStat_WalCounters

typedef struct PgStat_WalStats	PgStat_WalStats

typedef struct PgStat_Backend	PgStat_Backend

typedef struct PgStat_BackendPending	PgStat_BackendPending

Enumerations
enum	TrackFunctionsLevel { TRACK_FUNC_OFF , TRACK_FUNC_PL , TRACK_FUNC_ALL }

enum	PgStat_FetchConsistency { PGSTAT_FETCH_CONSISTENCY_NONE , PGSTAT_FETCH_CONSISTENCY_CACHE , PGSTAT_FETCH_CONSISTENCY_SNAPSHOT }

enum	SessionEndType { DISCONNECT_NOT_YET , DISCONNECT_NORMAL , DISCONNECT_CLIENT_EOF , DISCONNECT_FATAL , DISCONNECT_KILLED }

enum	IOObject { IOOBJECT_RELATION , IOOBJECT_TEMP_RELATION , IOOBJECT_WAL }

enum	IOContext { IOCONTEXT_BULKREAD , IOCONTEXT_BULKWRITE , IOCONTEXT_INIT , IOCONTEXT_NORMAL , IOCONTEXT_VACUUM }

enum	IOOp { IOOP_EVICT , IOOP_FSYNC , IOOP_HIT , IOOP_REUSE , IOOP_WRITEBACK , IOOP_EXTEND , IOOP_READ , IOOP_WRITE }

Functions
Size	StatsShmemSize (void)

void	StatsShmemInit (void)

void	pgstat_restore_stats (void)

void	pgstat_discard_stats (void)

void	pgstat_before_server_shutdown (int code, Datum arg)

void	pgstat_initialize (void)

long	pgstat_report_stat (bool force)

void	pgstat_force_next_flush (void)

void	pgstat_reset_counters (void)

void	pgstat_reset (PgStat_Kind kind, Oid dboid, uint64 objid)

void	pgstat_reset_of_kind (PgStat_Kind kind)

void	pgstat_clear_snapshot (void)

TimestampTz	pgstat_get_stat_snapshot_timestamp (bool *have_snapshot)

PgStat_Kind	pgstat_get_kind_from_str (char *kind_str)

bool	pgstat_have_entry (PgStat_Kind kind, Oid dboid, uint64 objid)

void	pgstat_report_archiver (const char *xlog, bool failed)

PgStat_ArchiverStats *	pgstat_fetch_stat_archiver (void)

void	pgstat_count_backend_io_op_time (IOObject io_object, IOContext io_context, IOOp io_op, instr_time io_time)

void	pgstat_count_backend_io_op (IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt, uint64 bytes)

PgStat_Backend *	pgstat_fetch_stat_backend (ProcNumber procNumber)

PgStat_Backend *	pgstat_fetch_stat_backend_by_pid (int pid, BackendType *bktype)

bool	pgstat_tracks_backend_bktype (BackendType bktype)

void	pgstat_create_backend (ProcNumber procnum)

void	pgstat_report_bgwriter (void)

PgStat_BgWriterStats *	pgstat_fetch_stat_bgwriter (void)

void	pgstat_report_checkpointer (void)

PgStat_CheckpointerStats *	pgstat_fetch_stat_checkpointer (void)

bool	pgstat_bktype_io_stats_valid (PgStat_BktypeIO *backend_io, BackendType bktype)

void	pgstat_count_io_op (IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt, uint64 bytes)

instr_time	pgstat_prepare_io_time (bool track_io_guc)

void	pgstat_count_io_op_time (IOObject io_object, IOContext io_context, IOOp io_op, instr_time start_time, uint32 cnt, uint64 bytes)

PgStat_IO *	pgstat_fetch_stat_io (void)

const char *	pgstat_get_io_context_name (IOContext io_context)

const char *	pgstat_get_io_object_name (IOObject io_object)

bool	pgstat_tracks_io_bktype (BackendType bktype)

bool	pgstat_tracks_io_object (BackendType bktype, IOObject io_object, IOContext io_context)

bool	pgstat_tracks_io_op (BackendType bktype, IOObject io_object, IOContext io_context, IOOp io_op)

void	pgstat_drop_database (Oid databaseid)

void	pgstat_report_autovac (Oid dboid)

void	pgstat_report_recovery_conflict (int reason)

void	pgstat_report_deadlock (void)

void	pgstat_prepare_report_checksum_failure (Oid dboid)

void	pgstat_report_checksum_failures_in_db (Oid dboid, int failurecount)

void	pgstat_report_connect (Oid dboid)

void	pgstat_update_parallel_workers_stats (PgStat_Counter workers_to_launch, PgStat_Counter workers_launched)

PgStat_StatDBEntry *	pgstat_fetch_stat_dbentry (Oid dboid)

void	pgstat_create_function (Oid proid)

void	pgstat_drop_function (Oid proid)

void	pgstat_init_function_usage (struct FunctionCallInfoBaseData fcinfo, PgStat_FunctionCallUsage fcu)

void	pgstat_end_function_usage (PgStat_FunctionCallUsage *fcu, bool finalize)

PgStat_StatFuncEntry *	pgstat_fetch_stat_funcentry (Oid func_id)

PgStat_FunctionCounts *	find_funcstat_entry (Oid func_id)

void	pgstat_create_relation (Relation rel)

void	pgstat_drop_relation (Relation rel)

void	pgstat_copy_relation_stats (Relation dst, Relation src)

void	pgstat_init_relation (Relation rel)

void	pgstat_assoc_relation (Relation rel)

void	pgstat_unlink_relation (Relation rel)

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

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

void	pgstat_count_heap_insert (Relation rel, PgStat_Counter n)

void	pgstat_count_heap_update (Relation rel, bool hot, bool newpage)

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_twophase_postcommit (TransactionId xid, uint16 info, void *recdata, uint32 len)

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

PgStat_StatTabEntry *	pgstat_fetch_stat_tabentry (Oid relid)

PgStat_StatTabEntry *	pgstat_fetch_stat_tabentry_ext (bool shared, Oid reloid)

PgStat_TableStatus *	find_tabstat_entry (Oid rel_id)

void	pgstat_reset_replslot (const char *name)

void	pgstat_report_replslot (struct ReplicationSlot slot, const PgStat_StatReplSlotEntry repSlotStat)

void	pgstat_create_replslot (struct ReplicationSlot *slot)

void	pgstat_acquire_replslot (struct ReplicationSlot *slot)

void	pgstat_drop_replslot (struct ReplicationSlot *slot)

PgStat_StatReplSlotEntry *	pgstat_fetch_replslot (NameData slotname)

void	pgstat_reset_slru (const char *)

void	pgstat_count_slru_page_zeroed (int slru_idx)

void	pgstat_count_slru_page_hit (int slru_idx)

void	pgstat_count_slru_page_read (int slru_idx)

void	pgstat_count_slru_page_written (int slru_idx)

void	pgstat_count_slru_page_exists (int slru_idx)

void	pgstat_count_slru_flush (int slru_idx)

void	pgstat_count_slru_truncate (int slru_idx)

const char *	pgstat_get_slru_name (int slru_idx)

int	pgstat_get_slru_index (const char *name)

PgStat_SLRUStats *	pgstat_fetch_slru (void)

void	pgstat_report_subscription_error (Oid subid, bool is_apply_error)

void	pgstat_report_subscription_conflict (Oid subid, ConflictType type)

void	pgstat_create_subscription (Oid subid)

void	pgstat_drop_subscription (Oid subid)

PgStat_StatSubEntry *	pgstat_fetch_stat_subscription (Oid subid)

void	AtEOXact_PgStat (bool isCommit, bool parallel)

void	AtEOSubXact_PgStat (bool isCommit, int nestDepth)

void	AtPrepare_PgStat (void)

void	PostPrepare_PgStat (void)

int	pgstat_get_transactional_drops (bool isCommit, struct xl_xact_stats_item **items)

void	pgstat_execute_transactional_drops (int ndrops, struct xl_xact_stats_item *items, bool is_redo)

void	pgstat_report_wal (bool force)

PgStat_WalStats *	pgstat_fetch_stat_wal (void)

Macro Definition Documentation

◆ IOCONTEXT_NUM_TYPES

#define IOCONTEXT_NUM_TYPES (IOCONTEXT_VACUUM + 1)

Definition at line 290 of file pgstat.h.

◆ IOOBJECT_NUM_TYPES

#define IOOBJECT_NUM_TYPES (IOOBJECT_WAL + 1)

Definition at line 279 of file pgstat.h.

◆ IOOP_NUM_TYPES

#define IOOP_NUM_TYPES (IOOP_WRITE + 1)

Definition at line 316 of file pgstat.h.

◆ PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR "pg_stat_tmp"

Definition at line 34 of file pgstat.h.

◆ pgstat_count_buffer_hit

#define pgstat_count_buffer_hit ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.blocks_hit++;                \
    } while (0)

Definition at line 709 of file pgstat.h.

◆ pgstat_count_buffer_read

#define pgstat_count_buffer_read ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.blocks_fetched++;            \
    } while (0)

Definition at line 704 of file pgstat.h.

◆ pgstat_count_buffer_read_time

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

Definition at line 620 of file pgstat.h.

◆ pgstat_count_buffer_write_time

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

Definition at line 622 of file pgstat.h.

◆ pgstat_count_conn_active_time

#define pgstat_count_conn_active_time ( n ) (pgStatActiveTime += (n))

Definition at line 624 of file pgstat.h.

◆ pgstat_count_conn_txn_idle_time

#define pgstat_count_conn_txn_idle_time ( n ) (pgStatTransactionIdleTime += (n))

Definition at line 626 of file pgstat.h.

◆ pgstat_count_heap_fetch

#define pgstat_count_heap_fetch ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.tuples_fetched++;            \
    } while (0)

Definition at line 689 of file pgstat.h.

◆ pgstat_count_heap_getnext

#define pgstat_count_heap_getnext ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.tuples_returned++;           \
    } while (0)

Definition at line 684 of file pgstat.h.

◆ pgstat_count_heap_scan

#define pgstat_count_heap_scan ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.numscans++;                  \
    } while (0)

Definition at line 679 of file pgstat.h.

◆ pgstat_count_index_scan

#define pgstat_count_index_scan ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.numscans++;                  \
    } while (0)

Definition at line 694 of file pgstat.h.

◆ pgstat_count_index_tuples

#define pgstat_count_index_tuples	(	rel,
		n
	)

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.tuples_returned += (n);      \
    } while (0)

Definition at line 699 of file pgstat.h.

◆ PGSTAT_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID 0x01A5BCB7

Definition at line 214 of file pgstat.h.

◆ pgstat_is_ioop_tracked_in_bytes

#define pgstat_is_ioop_tracked_in_bytes ( io_op )

Value:

(((unsigned int) (io_op)) < IOOP_NUM_TYPES && \

((unsigned int) (io_op)) >= IOOP_EXTEND)

IOOP_NUM_TYPES

#define IOOP_NUM_TYPES

Definition: pgstat.h:316

IOOP_EXTEND

@ IOOP_EXTEND

Definition: pgstat.h:311

Definition at line 318 of file pgstat.h.

◆ pgstat_should_count_relation

#define pgstat_should_count_relation ( rel )

Value:

(likely((rel)->pgstat_info != NULL) ? true : \

((rel)->pgstat_enabled ? pgstat_assoc_relation(rel), true : false))

likely

#define likely(x)

Definition: c.h:346

true

return true

Definition: isn.c:130

pgstat_assoc_relation

void pgstat_assoc_relation(Relation rel)

Definition: pgstat_relation.c:131

Definition at line 673 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

#define PGSTAT_STAT_PERMANENT_DIRECTORY "pg_stat"

Definition at line 29 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_FILENAME

#define PGSTAT_STAT_PERMANENT_FILENAME "pg_stat/pgstat.stat"

Definition at line 30 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_TMPFILE

#define PGSTAT_STAT_PERMANENT_TMPFILE "pg_stat/pgstat.tmp"

Definition at line 31 of file pgstat.h.

Typedef Documentation

◆ IOContext

typedef enum IOContext IOContext

◆ IOObject

typedef enum IOObject IOObject

◆ IOOp

typedef enum IOOp IOOp

◆ PgStat_ArchiverStats

typedef struct PgStat_ArchiverStats PgStat_ArchiverStats

◆ PgStat_Backend

typedef struct PgStat_Backend PgStat_Backend

◆ PgStat_BackendPending

typedef struct PgStat_BackendPending PgStat_BackendPending

◆ PgStat_BackendSubEntry

typedef struct PgStat_BackendSubEntry PgStat_BackendSubEntry

◆ PgStat_BgWriterStats

typedef struct PgStat_BgWriterStats PgStat_BgWriterStats

◆ PgStat_BktypeIO

typedef struct PgStat_BktypeIO PgStat_BktypeIO

◆ PgStat_CheckpointerStats

typedef struct PgStat_CheckpointerStats PgStat_CheckpointerStats

◆ PgStat_Counter

typedef int64 PgStat_Counter

Definition at line 65 of file pgstat.h.

◆ PgStat_FetchConsistency

typedef enum PgStat_FetchConsistency PgStat_FetchConsistency

◆ PgStat_FunctionCallUsage

typedef struct PgStat_FunctionCallUsage PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

typedef struct PgStat_FunctionCounts PgStat_FunctionCounts

◆ PgStat_IO

typedef struct PgStat_IO PgStat_IO

◆ PgStat_PendingIO

typedef struct PgStat_PendingIO PgStat_PendingIO

◆ PgStat_SLRUStats

typedef struct PgStat_SLRUStats PgStat_SLRUStats

◆ PgStat_StatDBEntry

typedef struct PgStat_StatDBEntry PgStat_StatDBEntry

◆ PgStat_StatFuncEntry

typedef struct PgStat_StatFuncEntry PgStat_StatFuncEntry

◆ PgStat_StatReplSlotEntry

typedef struct PgStat_StatReplSlotEntry PgStat_StatReplSlotEntry

◆ PgStat_StatSubEntry

typedef struct PgStat_StatSubEntry PgStat_StatSubEntry

◆ PgStat_StatTabEntry

typedef struct PgStat_StatTabEntry PgStat_StatTabEntry

◆ PgStat_TableCounts

typedef struct PgStat_TableCounts PgStat_TableCounts

◆ PgStat_TableStatus

typedef struct PgStat_TableStatus PgStat_TableStatus

◆ PgStat_TableXactStatus

typedef struct PgStat_TableXactStatus PgStat_TableXactStatus

◆ PgStat_WalCounters

typedef struct PgStat_WalCounters PgStat_WalCounters

◆ PgStat_WalStats

typedef struct PgStat_WalStats PgStat_WalStats

◆ SessionEndType

typedef enum SessionEndType SessionEndType

◆ TrackFunctionsLevel

typedef enum TrackFunctionsLevel TrackFunctionsLevel

Enumeration Type Documentation

◆ IOContext

enum IOContext

Enumerator
IOCONTEXT_BULKREAD
IOCONTEXT_BULKWRITE
IOCONTEXT_INIT
IOCONTEXT_NORMAL
IOCONTEXT_VACUUM

Definition at line 281 of file pgstat.h.

{
    IOCONTEXT_BULKREAD,
    IOCONTEXT_BULKWRITE,
    IOCONTEXT_INIT,
    IOCONTEXT_NORMAL,
    IOCONTEXT_VACUUM,
} IOContext;

◆ IOObject

enum IOObject

Enumerator
IOOBJECT_RELATION
IOOBJECT_TEMP_RELATION
IOOBJECT_WAL

Definition at line 272 of file pgstat.h.

{
    IOOBJECT_RELATION,
    IOOBJECT_TEMP_RELATION,
    IOOBJECT_WAL,
} IOObject;

◆ IOOp

enum IOOp

Enumerator
IOOP_EVICT
IOOP_FSYNC
IOOP_HIT
IOOP_REUSE
IOOP_WRITEBACK
IOOP_EXTEND
IOOP_READ
IOOP_WRITE

Definition at line 301 of file pgstat.h.

{
    /* IOs not tracked in bytes */
    IOOP_EVICT,
    IOOP_FSYNC,
    IOOP_HIT,
    IOOP_REUSE,
    IOOP_WRITEBACK,
 
    /* IOs tracked in bytes */
    IOOP_EXTEND,
    IOOP_READ,
    IOOP_WRITE,
} IOOp;

◆ PgStat_FetchConsistency

enum PgStat_FetchConsistency

Enumerator
PGSTAT_FETCH_CONSISTENCY_NONE
PGSTAT_FETCH_CONSISTENCY_CACHE
PGSTAT_FETCH_CONSISTENCY_SNAPSHOT

Definition at line 44 of file pgstat.h.

{
    PGSTAT_FETCH_CONSISTENCY_NONE,
    PGSTAT_FETCH_CONSISTENCY_CACHE,
    PGSTAT_FETCH_CONSISTENCY_SNAPSHOT,
} PgStat_FetchConsistency;

◆ SessionEndType

enum SessionEndType

Enumerator
DISCONNECT_NOT_YET
DISCONNECT_NORMAL
DISCONNECT_CLIENT_EOF
DISCONNECT_FATAL
DISCONNECT_KILLED

Definition at line 52 of file pgstat.h.

{
    DISCONNECT_NOT_YET,         /* still active */
    DISCONNECT_NORMAL,
    DISCONNECT_CLIENT_EOF,
    DISCONNECT_FATAL,
    DISCONNECT_KILLED,
} SessionEndType;

◆ TrackFunctionsLevel

enum TrackFunctionsLevel

Enumerator
TRACK_FUNC_OFF
TRACK_FUNC_PL
TRACK_FUNC_ALL

Definition at line 37 of file pgstat.h.

{
    TRACK_FUNC_OFF,
    TRACK_FUNC_PL,
    TRACK_FUNC_ALL,
}           TrackFunctionsLevel;

Function Documentation

◆ AtEOSubXact_PgStat()

void AtEOSubXact_PgStat	(	bool	isCommit,
		int	nestDepth
	)

Definition at line 113 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state;
 
    /* merge the sub-transaction's transactional stats into the parent */
    xact_state = pgStatXactStack;
    if (xact_state != NULL &&
        xact_state->nest_level >= nestDepth)
    {
        /* delink xact_state from stack immediately to simplify reuse case */
        pgStatXactStack = xact_state->prev;
 
        AtEOSubXact_PgStat_Relations(xact_state, isCommit, nestDepth);
        AtEOSubXact_PgStat_DroppedStats(xact_state, isCommit, nestDepth);
 
        pfree(xact_state);
    }
}

References AtEOSubXact_PgStat_DroppedStats(), AtEOSubXact_PgStat_Relations(), PgStat_SubXactStatus::nest_level, pfree(), pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AtEOXact_PgStat()

void AtEOXact_PgStat	(	bool	isCommit,
		bool	parallel
	)

Definition at line 40 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state;
 
    AtEOXact_PgStat_Database(isCommit, parallel);
 
    /* handle transactional stats information */
    xact_state = pgStatXactStack;
    if (xact_state != NULL)
    {
        Assert(xact_state->nest_level == 1);
        Assert(xact_state->prev == NULL);
 
        AtEOXact_PgStat_Relations(xact_state, isCommit);
        AtEOXact_PgStat_DroppedStats(xact_state, isCommit);
    }
    pgStatXactStack = NULL;
 
    /* Make sure any stats snapshot is thrown away */
    pgstat_clear_snapshot();
}

References Assert(), AtEOXact_PgStat_Database(), AtEOXact_PgStat_DroppedStats(), AtEOXact_PgStat_Relations(), PgStat_SubXactStatus::nest_level, pgstat_clear_snapshot(), pgStatXactStack, and PgStat_SubXactStatus::prev.

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

◆ AtPrepare_PgStat()

void AtPrepare_PgStat ( void )

Definition at line 191 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state;
 
    xact_state = pgStatXactStack;
    if (xact_state != NULL)
    {
        Assert(xact_state->nest_level == 1);
        Assert(xact_state->prev == NULL);
 
        AtPrepare_PgStat_Relations(xact_state);
    }
}

References Assert(), AtPrepare_PgStat_Relations(), PgStat_SubXactStatus::nest_level, pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by PrepareTransaction().

◆ find_funcstat_entry()

PgStat_FunctionCounts * find_funcstat_entry ( Oid func_id )

Definition at line 223 of file pgstat_function.c.

{
    PgStat_EntryRef *entry_ref;
 
    entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_FUNCTION, MyDatabaseId, func_id);
 
    if (entry_ref)
        return entry_ref->pending;
    return NULL;
}

References MyDatabaseId, PgStat_EntryRef::pending, pgstat_fetch_pending_entry(), and PGSTAT_KIND_FUNCTION.

Referenced by pg_stat_get_xact_function_calls().

◆ find_tabstat_entry()

PgStat_TableStatus * find_tabstat_entry ( Oid rel_id )

Definition at line 501 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStat_TableXactStatus *trans;
    PgStat_TableStatus *tabentry = NULL;
    PgStat_TableStatus *tablestatus = NULL;
 
    entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, MyDatabaseId, rel_id);
    if (!entry_ref)
    {
        entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, InvalidOid, rel_id);
        if (!entry_ref)
            return tablestatus;
    }
 
    tabentry = (PgStat_TableStatus *) entry_ref->pending;
    tablestatus = palloc(sizeof(PgStat_TableStatus));
    *tablestatus = *tabentry;
 
    /*
     * Reset tablestatus->trans in the copy of PgStat_TableStatus as it may
     * point to a shared memory area.  Its data is saved below, so removing it
     * does not matter.
     */
    tablestatus->trans = NULL;
 
    /*
     * Live subtransaction counts are not included yet.  This is not a hot
     * code path so reconcile tuples_inserted, tuples_updated and
     * tuples_deleted even if the caller may not be interested in this data.
     */
    for (trans = tabentry->trans; trans != NULL; trans = trans->upper)
    {
        tablestatus->counts.tuples_inserted += trans->tuples_inserted;
        tablestatus->counts.tuples_updated += trans->tuples_updated;
        tablestatus->counts.tuples_deleted += trans->tuples_deleted;
    }
 
    return tablestatus;
}

References PgStat_TableStatus::counts, InvalidOid, MyDatabaseId, palloc(), PgStat_EntryRef::pending, pgstat_fetch_pending_entry(), PGSTAT_KIND_RELATION, PgStat_TableStatus::trans, trans, PgStat_TableCounts::tuples_deleted, PgStat_TableCounts::tuples_inserted, and PgStat_TableCounts::tuples_updated.

◆ pgstat_acquire_replslot()

void pgstat_acquire_replslot ( struct ReplicationSlot * slot )

Definition at line 146 of file pgstat_replslot.c.

{
    pgstat_get_entry_ref(PGSTAT_KIND_REPLSLOT, InvalidOid,
                         ReplicationSlotIndex(slot), true, NULL);
}

References InvalidOid, pgstat_get_entry_ref(), PGSTAT_KIND_REPLSLOT, and ReplicationSlotIndex().

Referenced by ReplicationSlotAcquire().

◆ pgstat_assoc_relation()

void pgstat_assoc_relation ( Relation rel )

Definition at line 131 of file pgstat_relation.c.

{
    Assert(rel->pgstat_enabled);
    Assert(rel->pgstat_info == NULL);
 
    /* Else find or make the PgStat_TableStatus entry, and update link */
    rel->pgstat_info = pgstat_prep_relation_pending(RelationGetRelid(rel),
                                                    rel->rd_rel->relisshared);
 
    /* don't allow link a stats to multiple relcache entries */
    Assert(rel->pgstat_info->relation == NULL);
 
    /* mark this relation as the owner */
    rel->pgstat_info->relation = rel;
}

References Assert(), RelationData::pgstat_enabled, RelationData::pgstat_info, pgstat_prep_relation_pending(), RelationData::rd_rel, PgStat_TableStatus::relation, and RelationGetRelid.

◆ pgstat_before_server_shutdown()

void pgstat_before_server_shutdown	(	int	code,
		Datum	arg
	)

Definition at line 559 of file pgstat.c.

{
    Assert(pgStatLocal.shmem != NULL);
    Assert(!pgStatLocal.shmem->is_shutdown);
 
    /*
     * Stats should only be reported after pgstat_initialize() and before
     * pgstat_shutdown(). This is a convenient point to catch most violations
     * of this rule.
     */
    Assert(pgstat_is_initialized && !pgstat_is_shutdown);
 
    /* flush out our own pending changes before writing out */
    pgstat_report_stat(true);
 
    /*
     * Only write out file during normal shutdown. Don't even signal that
     * we've shutdown during irregular shutdowns, because the shutdown
     * sequence isn't coordinated to ensure this backend shuts down last.
     */
    if (code == 0)
    {
        pgStatLocal.shmem->is_shutdown = true;
        pgstat_write_statsfile();
    }

References Assert(), PgStat_ShmemControl::is_shutdown, pgstat_report_stat(), pgstat_write_statsfile(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by CheckpointerMain(), and InitPostgres().

◆ pgstat_bktype_io_stats_valid()

bool pgstat_bktype_io_stats_valid	(	PgStat_BktypeIO *	backend_io,
		BackendType	bktype
	)

Definition at line 37 of file pgstat_io.c.

{
    for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++)
    {
        for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++)
        {
            for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++)
            {
                /* we do track it */
                if (pgstat_tracks_io_op(bktype, io_object, io_context, io_op))
                {
                    /* ensure that if IO times are non-zero, counts are > 0 */
                    if (backend_io->times[io_object][io_context][io_op] != 0 &&
                        backend_io->counts[io_object][io_context][io_op] <= 0)
                        return false;
 
                    continue;
                }
 
                /* we don't track it, and it is not 0 */
                if (backend_io->counts[io_object][io_context][io_op] != 0)
                    return false;
            }
        }
    }
 
    return true;
}

References PgStat_BktypeIO::counts, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, pgstat_tracks_io_op(), and PgStat_BktypeIO::times.

Referenced by pg_stat_get_backend_io(), pg_stat_get_io(), and pgstat_io_flush_cb().

◆ pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void )

Definition at line 917 of file pgstat.c.

{
    pgstat_assert_is_up();
 
    memset(&pgStatLocal.snapshot.fixed_valid, 0,
           sizeof(pgStatLocal.snapshot.fixed_valid));
    memset(&pgStatLocal.snapshot.custom_valid, 0,
           sizeof(pgStatLocal.snapshot.custom_valid));
    pgStatLocal.snapshot.stats = NULL;
    pgStatLocal.snapshot.mode = PGSTAT_FETCH_CONSISTENCY_NONE;
 
    /* Release memory, if any was allocated */
    if (pgStatLocal.snapshot.context)
    {
        MemoryContextDelete(pgStatLocal.snapshot.context);
 
        /* Reset variables */
        pgStatLocal.snapshot.context = NULL;
    }
 
    /*
     * Historically the backend_status.c facilities lived in this file, and
     * were reset with the same function. For now keep it that way, and
     * forward the reset request.
     */
    pgstat_clear_backend_activity_snapshot();
 
    /* Reset this flag, as it may be possible that a cleanup was forced. */
    force_stats_snapshot_clear = false;

References PgStat_Snapshot::context, PgStat_Snapshot::custom_valid, PgStat_Snapshot::fixed_valid, force_stats_snapshot_clear, MemoryContextDelete(), PgStat_Snapshot::mode, pgstat_assert_is_up, pgstat_clear_backend_activity_snapshot(), PGSTAT_FETCH_CONSISTENCY_NONE, pgStatLocal, PgStat_LocalState::snapshot, and PgStat_Snapshot::stats.

Referenced by AtEOXact_PgStat(), pg_stat_clear_snapshot(), pgstat_get_stat_snapshot_timestamp(), pgstat_prep_snapshot(), pgstat_snapshot_fixed(), and PostPrepare_PgStat().

◆ pgstat_copy_relation_stats()

void pgstat_copy_relation_stats	(	Relation	dst,
		Relation	src
	)

Definition at line 57 of file pgstat_relation.c.

{
    PgStat_StatTabEntry *srcstats;
    PgStatShared_Relation *dstshstats;
    PgStat_EntryRef *dst_ref;
 
    srcstats = pgstat_fetch_stat_tabentry_ext(src->rd_rel->relisshared,
                                              RelationGetRelid(src));
    if (!srcstats)
        return;
 
    dst_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
                                          dst->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
                                          RelationGetRelid(dst),
                                          false);
 
    dstshstats = (PgStatShared_Relation *) dst_ref->shared_stats;
    dstshstats->stats = *srcstats;
 
    pgstat_unlock_entry(dst_ref);
}

References InvalidOid, MyDatabaseId, pgstat_fetch_stat_tabentry_ext(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_RELATION, pgstat_unlock_entry(), RelationData::rd_rel, RelationGetRelid, PgStat_EntryRef::shared_stats, and PgStatShared_Relation::stats.

Referenced by index_concurrently_swap().

◆ pgstat_count_backend_io_op()

void pgstat_count_backend_io_op	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op,
		uint32	cnt,
		uint64	bytes
	)

Definition at line 72 of file pgstat_backend.c.

{
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return;
 
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    PendingBackendStats.pending_io.counts[io_object][io_context][io_op] += cnt;
    PendingBackendStats.pending_io.bytes[io_object][io_context][io_op] += bytes;
 
    backend_has_iostats = true;
}

References Assert(), backend_has_iostats, PgStat_PendingIO::bytes, PgStat_PendingIO::counts, MyBackendType, PgStat_BackendPending::pending_io, PendingBackendStats, pgstat_tracks_backend_bktype(), and pgstat_tracks_io_op().

Referenced by pgstat_count_io_op().

◆ pgstat_count_backend_io_op_time()

void pgstat_count_backend_io_op_time	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op,
		instr_time	io_time
	)

Definition at line 55 of file pgstat_backend.c.

{
    Assert(track_io_timing || track_wal_io_timing);
 
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return;
 
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    INSTR_TIME_ADD(PendingBackendStats.pending_io.pending_times[io_object][io_context][io_op],
                   io_time);
 
    backend_has_iostats = true;
}

References Assert(), backend_has_iostats, INSTR_TIME_ADD, MyBackendType, PgStat_BackendPending::pending_io, PgStat_PendingIO::pending_times, PendingBackendStats, pgstat_tracks_backend_bktype(), pgstat_tracks_io_op(), track_io_timing, and track_wal_io_timing.

Referenced by pgstat_count_io_op_time().

◆ pgstat_count_heap_delete()

void pgstat_count_heap_delete ( Relation rel )

Definition at line 415 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        pgstat_info->trans->tuples_deleted++;
    }
}

References ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_deleted.

Referenced by heap_abort_speculative(), and heap_delete().

◆ pgstat_count_heap_insert()

void pgstat_count_heap_insert	(	Relation	rel,
		PgStat_Counter	n
	)

Definition at line 374 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        pgstat_info->trans->tuples_inserted += n;
    }
}

References ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_inserted.

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

◆ pgstat_count_heap_update()

void pgstat_count_heap_update	(	Relation	rel,
		bool	hot,
		bool	newpage
	)

Definition at line 389 of file pgstat_relation.c.

{
    Assert(!(hot && newpage));
 
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        pgstat_info->trans->tuples_updated++;
 
        /*
         * tuples_hot_updated and tuples_newpage_updated counters are
         * nontransactional, so just advance them
         */
        if (hot)
            pgstat_info->counts.tuples_hot_updated++;
        else if (newpage)
            pgstat_info->counts.tuples_newpage_updated++;
    }
}

References Assert(), PgStat_TableStatus::counts, ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, PgStat_TableStatus::trans, PgStat_TableCounts::tuples_hot_updated, PgStat_TableCounts::tuples_newpage_updated, and PgStat_TableXactStatus::tuples_updated.

Referenced by heap_update().

◆ pgstat_count_io_op()

void pgstat_count_io_op	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op,
		uint32	cnt,
		uint64	bytes
	)

Definition at line 68 of file pgstat_io.c.

{
    Assert((unsigned int) io_object < IOOBJECT_NUM_TYPES);
    Assert((unsigned int) io_context < IOCONTEXT_NUM_TYPES);
    Assert(pgstat_is_ioop_tracked_in_bytes(io_op) || bytes == 0);
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    PendingIOStats.counts[io_object][io_context][io_op] += cnt;
    PendingIOStats.bytes[io_object][io_context][io_op] += bytes;
 
    /* Add the per-backend counts */
    pgstat_count_backend_io_op(io_object, io_context, io_op, cnt, bytes);
 
    have_iostats = true;
}

References Assert(), PgStat_PendingIO::bytes, PgStat_PendingIO::counts, have_iostats, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, MyBackendType, PendingIOStats, pgstat_count_backend_io_op(), pgstat_is_ioop_tracked_in_bytes, and pgstat_tracks_io_op().

Referenced by AsyncReadBuffers(), GetLocalVictimBuffer(), GetVictimBuffer(), pgstat_count_io_op_time(), and PinBufferForBlock().

◆ pgstat_count_io_op_time()

void pgstat_count_io_op_time	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op,
		instr_time	start_time,
		uint32	cnt,
		uint64	bytes
	)

Definition at line 121 of file pgstat_io.c.

{
    if (!INSTR_TIME_IS_ZERO(start_time))
    {
        instr_time  io_time;
 
        INSTR_TIME_SET_CURRENT(io_time);
        INSTR_TIME_SUBTRACT(io_time, start_time);
 
        if (io_object != IOOBJECT_WAL)
        {
            if (io_op == IOOP_WRITE || io_op == IOOP_EXTEND)
            {
                pgstat_count_buffer_write_time(INSTR_TIME_GET_MICROSEC(io_time));
                if (io_object == IOOBJECT_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.shared_blk_write_time, io_time);
                else if (io_object == IOOBJECT_TEMP_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.local_blk_write_time, io_time);
            }
            else if (io_op == IOOP_READ)
            {
                pgstat_count_buffer_read_time(INSTR_TIME_GET_MICROSEC(io_time));
                if (io_object == IOOBJECT_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.shared_blk_read_time, io_time);
                else if (io_object == IOOBJECT_TEMP_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.local_blk_read_time, io_time);
            }
        }
 
        INSTR_TIME_ADD(PendingIOStats.pending_times[io_object][io_context][io_op],
                       io_time);
 
        /* Add the per-backend count */
        pgstat_count_backend_io_op_time(io_object, io_context, io_op,
                                        io_time);
    }
 
    pgstat_count_io_op(io_object, io_context, io_op, cnt, bytes);
}

References INSTR_TIME_ADD, INSTR_TIME_GET_MICROSEC, INSTR_TIME_IS_ZERO, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, IOOBJECT_RELATION, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, IOOP_EXTEND, IOOP_READ, IOOP_WRITE, BufferUsage::local_blk_read_time, BufferUsage::local_blk_write_time, PgStat_PendingIO::pending_times, PendingIOStats, pgBufferUsage, pgstat_count_backend_io_op_time(), pgstat_count_buffer_read_time, pgstat_count_buffer_write_time, pgstat_count_io_op(), BufferUsage::shared_blk_read_time, BufferUsage::shared_blk_write_time, and start_time.

Referenced by AsyncReadBuffers(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushLocalBuffer(), issue_xlog_fsync(), IssuePendingWritebacks(), mdsyncfiletag(), register_dirty_segment(), WaitReadBuffers(), WALRead(), XLogFileInitInternal(), XLogPageRead(), XLogWalRcvWrite(), and XLogWrite().

◆ pgstat_count_slru_flush()

void pgstat_count_slru_flush ( int slru_idx )

Definition at line 89 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->flush += 1;
}

References PgStat_SLRUStats::flush, and get_slru_entry().

Referenced by SimpleLruWriteAll().

◆ pgstat_count_slru_page_exists()

void pgstat_count_slru_page_exists ( int slru_idx )

Definition at line 71 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_exists += 1;
}

References PgStat_SLRUStats::blocks_exists, and get_slru_entry().

Referenced by SimpleLruDoesPhysicalPageExist().

◆ pgstat_count_slru_page_hit()

void pgstat_count_slru_page_hit ( int slru_idx )

Definition at line 65 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_hit += 1;
}

References PgStat_SLRUStats::blocks_hit, and get_slru_entry().

Referenced by SimpleLruReadPage(), and SimpleLruReadPage_ReadOnly().

◆ pgstat_count_slru_page_read()

void pgstat_count_slru_page_read ( int slru_idx )

Definition at line 77 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_read += 1;
}

References PgStat_SLRUStats::blocks_read, and get_slru_entry().

Referenced by SimpleLruReadPage().

◆ pgstat_count_slru_page_written()

void pgstat_count_slru_page_written ( int slru_idx )

Definition at line 83 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_written += 1;
}

References PgStat_SLRUStats::blocks_written, and get_slru_entry().

Referenced by SlruPhysicalWritePage().

◆ pgstat_count_slru_page_zeroed()

void pgstat_count_slru_page_zeroed ( int slru_idx )

Definition at line 59 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_zeroed += 1;
}

References PgStat_SLRUStats::blocks_zeroed, and get_slru_entry().

Referenced by SimpleLruZeroPage().

◆ pgstat_count_slru_truncate()

void pgstat_count_slru_truncate ( int slru_idx )

Definition at line 95 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->truncate += 1;
}

References get_slru_entry(), and PgStat_SLRUStats::truncate.

Referenced by SimpleLruTruncate().

◆ pgstat_count_truncate()

void pgstat_count_truncate ( Relation rel )

Definition at line 430 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        save_truncdrop_counters(pgstat_info->trans, false);
        pgstat_info->trans->tuples_inserted = 0;
        pgstat_info->trans->tuples_updated = 0;
        pgstat_info->trans->tuples_deleted = 0;
    }
}

References ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, save_truncdrop_counters(), PgStat_TableStatus::trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, and PgStat_TableXactStatus::tuples_updated.

Referenced by ExecuteTruncateGuts(), and RefreshMatViewByOid().

◆ pgstat_create_backend()

void pgstat_create_backend ( ProcNumber procnum )

Definition at line 331 of file pgstat_backend.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Backend *shstatent;
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_BACKEND, InvalidOid,
                                            MyProcNumber, false);
    shstatent = (PgStatShared_Backend *) entry_ref->shared_stats;
 
    /*
     * NB: need to accept that there might be stats from an older backend,
     * e.g. if we previously used this proc number.
     */
    memset(&shstatent->stats, 0, sizeof(shstatent->stats));
    pgstat_unlock_entry(entry_ref);
 
    MemSet(&PendingBackendStats, 0, sizeof(PgStat_BackendPending));
    backend_has_iostats = false;
 
    /*
     * Initialize prevBackendWalUsage with pgWalUsage so that
     * pgstat_backend_flush_cb() can calculate how much pgWalUsage counters
     * are increased by subtracting prevBackendWalUsage from pgWalUsage.
     */
    prevBackendWalUsage = pgWalUsage;
}

References backend_has_iostats, InvalidOid, MemSet, MyProcNumber, PendingBackendStats, pgstat_get_entry_ref_locked(), PGSTAT_KIND_BACKEND, pgstat_unlock_entry(), pgWalUsage, prevBackendWalUsage, PgStat_EntryRef::shared_stats, and PgStatShared_Backend::stats.

Referenced by pgstat_bestart_final().

◆ pgstat_create_function()

void pgstat_create_function ( Oid proid )

Definition at line 45 of file pgstat_function.c.

{
    pgstat_create_transactional(PGSTAT_KIND_FUNCTION,
                                MyDatabaseId,
                                proid);
}

References MyDatabaseId, pgstat_create_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by ProcedureCreate().

◆ pgstat_create_relation()

void pgstat_create_relation ( Relation rel )

Definition at line 168 of file pgstat_relation.c.

{
    pgstat_create_transactional(PGSTAT_KIND_RELATION,
                                rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
                                RelationGetRelid(rel));
}

References InvalidOid, MyDatabaseId, pgstat_create_transactional(), PGSTAT_KIND_RELATION, RelationData::rd_rel, and RelationGetRelid.

Referenced by heap_create().

◆ pgstat_create_replslot()

void pgstat_create_replslot ( struct ReplicationSlot * slot )

Definition at line 111 of file pgstat_replslot.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_ReplSlot *shstatent;
 
    Assert(LWLockHeldByMeInMode(ReplicationSlotAllocationLock, LW_EXCLUSIVE));
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_REPLSLOT, InvalidOid,
                                            ReplicationSlotIndex(slot), false);
    shstatent = (PgStatShared_ReplSlot *) entry_ref->shared_stats;
 
    /*
     * NB: need to accept that there might be stats from an older slot, e.g.
     * if we previously crashed after dropping a slot.
     */
    memset(&shstatent->stats, 0, sizeof(shstatent->stats));
 
    pgstat_unlock_entry(entry_ref);
}

References Assert(), InvalidOid, LW_EXCLUSIVE, LWLockHeldByMeInMode(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_REPLSLOT, pgstat_unlock_entry(), ReplicationSlotIndex(), PgStat_EntryRef::shared_stats, and PgStatShared_ReplSlot::stats.

Referenced by ReplicationSlotCreate().

◆ pgstat_create_subscription()

void pgstat_create_subscription ( Oid subid )

Definition at line 61 of file pgstat_subscription.c.

{
    /* Ensures that stats are dropped if transaction rolls back */
    pgstat_create_transactional(PGSTAT_KIND_SUBSCRIPTION,
                                InvalidOid, subid);
 
    /* Create and initialize the subscription stats entry */
    pgstat_get_entry_ref(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid,
                         true, NULL);
    pgstat_reset_entry(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid, 0);
}

References InvalidOid, pgstat_create_transactional(), pgstat_get_entry_ref(), PGSTAT_KIND_SUBSCRIPTION, and pgstat_reset_entry().

Referenced by CreateSubscription().

◆ pgstat_discard_stats()

void pgstat_discard_stats ( void )

Definition at line 516 of file pgstat.c.

{
    int         ret;
 
    /* NB: this needs to be done even in single user mode */
 
    ret = unlink(PGSTAT_STAT_PERMANENT_FILENAME);
    if (ret != 0)
    {
        if (errno == ENOENT)
            elog(DEBUG2,
                 "didn't need to unlink permanent stats file \"%s\" - didn't exist",
                 PGSTAT_STAT_PERMANENT_FILENAME);
        else
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not unlink permanent statistics file \"%s\": %m",
                            PGSTAT_STAT_PERMANENT_FILENAME)));
    }
    else
    {
        ereport(DEBUG2,
                (errcode_for_file_access(),
                 errmsg_internal("unlinked permanent statistics file \"%s\"",
                                 PGSTAT_STAT_PERMANENT_FILENAME)));
    }
 
    /*
     * Reset stats contents. This will set reset timestamps of fixed-numbered
     * stats to the current time (no variable stats exist).
     */
    pgstat_reset_after_failure();

References DEBUG2, elog, ereport, errcode_for_file_access(), errmsg(), errmsg_internal(), LOG, pgstat_reset_after_failure(), and PGSTAT_STAT_PERMANENT_FILENAME.

Referenced by StartupXLOG().

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid databaseid )

Definition at line 44 of file pgstat_database.c.

{
    pgstat_drop_transactional(PGSTAT_KIND_DATABASE, databaseid, InvalidOid);
}

References InvalidOid, pgstat_drop_transactional(), and PGSTAT_KIND_DATABASE.

Referenced by dropdb().

◆ pgstat_drop_function()

void pgstat_drop_function ( Oid proid )

Definition at line 60 of file pgstat_function.c.

{
    pgstat_drop_transactional(PGSTAT_KIND_FUNCTION,
                              MyDatabaseId,
                              proid);
}

References MyDatabaseId, pgstat_drop_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by RemoveFunctionById().

◆ pgstat_drop_relation()

void pgstat_drop_relation ( Relation rel )

Definition at line 179 of file pgstat_relation.c.

{
    int         nest_level = GetCurrentTransactionNestLevel();
    PgStat_TableStatus *pgstat_info;
 
    pgstat_drop_transactional(PGSTAT_KIND_RELATION,
                              rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
                              RelationGetRelid(rel));
 
    if (!pgstat_should_count_relation(rel))
        return;
 
    /*
     * Transactionally set counters to 0. That ensures that accesses to
     * pg_stat_xact_all_tables inside the transaction show 0.
     */
    pgstat_info = rel->pgstat_info;
    if (pgstat_info->trans &&
        pgstat_info->trans->nest_level == nest_level)
    {
        save_truncdrop_counters(pgstat_info->trans, true);
        pgstat_info->trans->tuples_inserted = 0;
        pgstat_info->trans->tuples_updated = 0;
        pgstat_info->trans->tuples_deleted = 0;
    }
}

References GetCurrentTransactionNestLevel(), InvalidOid, MyDatabaseId, PgStat_TableXactStatus::nest_level, pgstat_drop_transactional(), RelationData::pgstat_info, PGSTAT_KIND_RELATION, pgstat_should_count_relation, RelationData::rd_rel, RelationGetRelid, save_truncdrop_counters(), PgStat_TableStatus::trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, and PgStat_TableXactStatus::tuples_updated.

Referenced by heap_drop_with_catalog(), and index_drop().

◆ pgstat_drop_replslot()

void pgstat_drop_replslot ( struct ReplicationSlot * slot )

Definition at line 156 of file pgstat_replslot.c.

{
    Assert(LWLockHeldByMeInMode(ReplicationSlotAllocationLock, LW_EXCLUSIVE));
 
    if (!pgstat_drop_entry(PGSTAT_KIND_REPLSLOT, InvalidOid,
                           ReplicationSlotIndex(slot)))
        pgstat_request_entry_refs_gc();
}

References Assert(), InvalidOid, LW_EXCLUSIVE, LWLockHeldByMeInMode(), pgstat_drop_entry(), PGSTAT_KIND_REPLSLOT, pgstat_request_entry_refs_gc(), and ReplicationSlotIndex().

Referenced by ReplicationSlotDropPtr().

◆ pgstat_drop_subscription()

void pgstat_drop_subscription ( Oid subid )

Definition at line 79 of file pgstat_subscription.c.

{
    pgstat_drop_transactional(PGSTAT_KIND_SUBSCRIPTION,
                              InvalidOid, subid);
}

References InvalidOid, pgstat_drop_transactional(), and PGSTAT_KIND_SUBSCRIPTION.

Referenced by DropSubscription().

◆ pgstat_end_function_usage()

void pgstat_end_function_usage	(	PgStat_FunctionCallUsage *	fcu,
		bool	finalize
	)

Definition at line 146 of file pgstat_function.c.

{
    PgStat_FunctionCounts *fs = fcu->fs;
    instr_time  total;
    instr_time  others;
    instr_time  self;
 
    /* stats not wanted? */
    if (fs == NULL)
        return;
 
    /* total elapsed time in this function call */
    INSTR_TIME_SET_CURRENT(total);
    INSTR_TIME_SUBTRACT(total, fcu->start);
 
    /* self usage: elapsed minus anything already charged to other calls */
    others = total_func_time;
    INSTR_TIME_SUBTRACT(others, fcu->save_total);
    self = total;
    INSTR_TIME_SUBTRACT(self, others);
 
    /* update backend-wide total time */
    INSTR_TIME_ADD(total_func_time, self);
 
    /*
     * Compute the new total_time as the total elapsed time added to the
     * pre-call value of 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(total, fcu->save_f_total_time);
 
    /* update counters in function stats table */
    if (finalize)
        fs->numcalls++;
    fs->total_time = total;
    INSTR_TIME_ADD(fs->self_time, self);
}

References PgStat_FunctionCallUsage::fs, INSTR_TIME_ADD, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, PgStat_FunctionCounts::numcalls, PgStat_FunctionCallUsage::save_f_total_time, PgStat_FunctionCallUsage::save_total, PgStat_FunctionCounts::self_time, PgStat_FunctionCallUsage::start, total_func_time, and PgStat_FunctionCounts::total_time.

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

◆ pgstat_execute_transactional_drops()

void pgstat_execute_transactional_drops	(	int	ndrops,
		struct xl_xact_stats_item *	items,
		bool	is_redo
	)

Definition at line 314 of file pgstat_xact.c.

{
    int         not_freed_count = 0;
 
    if (ndrops == 0)
        return;
 
    for (int i = 0; i < ndrops; i++)
    {
        xl_xact_stats_item *it = &items[i];
        uint64      objid = ((uint64) it->objid_hi) << 32 | it->objid_lo;
 
        if (!pgstat_drop_entry(it->kind, it->dboid, objid))
            not_freed_count++;
    }
 
    if (not_freed_count > 0)
        pgstat_request_entry_refs_gc();
}

References xl_xact_stats_item::dboid, i, items, xl_xact_stats_item::kind, xl_xact_stats_item::objid_hi, xl_xact_stats_item::objid_lo, pgstat_drop_entry(), and pgstat_request_entry_refs_gc().

Referenced by FinishPreparedTransaction(), xact_redo_abort(), and xact_redo_commit().

◆ pgstat_fetch_replslot()

PgStat_StatReplSlotEntry * pgstat_fetch_replslot ( NameData slotname )

Definition at line 170 of file pgstat_replslot.c.

{
    int         idx;
    PgStat_StatReplSlotEntry *slotentry = NULL;
 
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
    idx = get_replslot_index(NameStr(slotname), false);
 
    if (idx != -1)
        slotentry = (PgStat_StatReplSlotEntry *) pgstat_fetch_entry(PGSTAT_KIND_REPLSLOT,
                                                                    InvalidOid, idx);
 
    LWLockRelease(ReplicationSlotControlLock);
 
    return slotentry;
}

References get_replslot_index(), idx(), InvalidOid, LW_SHARED, LWLockAcquire(), LWLockRelease(), NameStr, pgstat_fetch_entry(), and PGSTAT_KIND_REPLSLOT.

Referenced by pg_stat_get_replication_slot().

◆ pgstat_fetch_slru()

PgStat_SLRUStats * pgstat_fetch_slru ( void )

Definition at line 105 of file pgstat_slru.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_SLRU);
 
    return pgStatLocal.snapshot.slru;
}

References PGSTAT_KIND_SLRU, pgstat_snapshot_fixed(), pgStatLocal, PgStat_Snapshot::slru, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_slru().

◆ pgstat_fetch_stat_archiver()

PgStat_ArchiverStats * pgstat_fetch_stat_archiver ( void )

Definition at line 58 of file pgstat_archiver.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_ARCHIVER);
 
    return &pgStatLocal.snapshot.archiver;
}

References PgStat_Snapshot::archiver, PGSTAT_KIND_ARCHIVER, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_archiver().

◆ pgstat_fetch_stat_backend()

PgStat_Backend * pgstat_fetch_stat_backend ( ProcNumber procNumber )

Definition at line 90 of file pgstat_backend.c.

{
    PgStat_Backend *backend_entry;
 
    backend_entry = (PgStat_Backend *) pgstat_fetch_entry(PGSTAT_KIND_BACKEND,
                                                          InvalidOid, procNumber);
 
    return backend_entry;
}

References InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_BACKEND.

Referenced by pgstat_fetch_stat_backend_by_pid().

◆ pgstat_fetch_stat_backend_by_pid()

PgStat_Backend * pgstat_fetch_stat_backend_by_pid	(	int	pid,
		BackendType *	bktype
	)

Definition at line 108 of file pgstat_backend.c.

{
    PGPROC     *proc;
    PgBackendStatus *beentry;
    ProcNumber  procNumber;
    PgStat_Backend *backend_stats;
 
    proc = BackendPidGetProc(pid);
    if (bktype)
        *bktype = B_INVALID;
 
    /* this could be an auxiliary process */
    if (!proc)
        proc = AuxiliaryPidGetProc(pid);
 
    if (!proc)
        return NULL;
 
    procNumber = GetNumberFromPGProc(proc);
 
    beentry = pgstat_get_beentry_by_proc_number(procNumber);
    if (!beentry)
        return NULL;
 
    /* check if the backend type tracks statistics */
    if (!pgstat_tracks_backend_bktype(beentry->st_backendType))
        return NULL;
 
    /* if PID does not match, leave */
    if (beentry->st_procpid != pid)
        return NULL;
 
    if (bktype)
        *bktype = beentry->st_backendType;
 
    /*
     * Retrieve the entry.  Note that "beentry" may be freed depending on the
     * value of stats_fetch_consistency, so do not access it from this point.
     */
    backend_stats = pgstat_fetch_stat_backend(procNumber);
    if (!backend_stats)
    {
        if (bktype)
            *bktype = B_INVALID;
        return NULL;
    }
 
    return backend_stats;
}

References AuxiliaryPidGetProc(), B_INVALID, BackendPidGetProc(), GetNumberFromPGProc, pgstat_fetch_stat_backend(), pgstat_get_beentry_by_proc_number(), pgstat_tracks_backend_bktype(), PgBackendStatus::st_backendType, and PgBackendStatus::st_procpid.

Referenced by pg_stat_get_backend_io(), and pg_stat_get_backend_wal().

◆ pgstat_fetch_stat_bgwriter()

PgStat_BgWriterStats * pgstat_fetch_stat_bgwriter ( void )

Definition at line 72 of file pgstat_bgwriter.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_BGWRITER);
 
    return &pgStatLocal.snapshot.bgwriter;
}

References PgStat_Snapshot::bgwriter, PGSTAT_KIND_BGWRITER, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_bgwriter_buf_written_clean(), pg_stat_get_bgwriter_maxwritten_clean(), pg_stat_get_bgwriter_stat_reset_time(), and pg_stat_get_buf_alloc().

◆ pgstat_fetch_stat_checkpointer()

PgStat_CheckpointerStats * pgstat_fetch_stat_checkpointer ( void )

Definition at line 81 of file pgstat_checkpointer.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_CHECKPOINTER);
 
    return &pgStatLocal.snapshot.checkpointer;
}

References PgStat_Snapshot::checkpointer, PGSTAT_KIND_CHECKPOINTER, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_checkpointer_buffers_written(), pg_stat_get_checkpointer_num_performed(), pg_stat_get_checkpointer_num_requested(), pg_stat_get_checkpointer_num_timed(), pg_stat_get_checkpointer_restartpoints_performed(), pg_stat_get_checkpointer_restartpoints_requested(), pg_stat_get_checkpointer_restartpoints_timed(), pg_stat_get_checkpointer_slru_written(), pg_stat_get_checkpointer_stat_reset_time(), pg_stat_get_checkpointer_sync_time(), and pg_stat_get_checkpointer_write_time().

◆ pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry * pgstat_fetch_stat_dbentry ( Oid dboid )

Definition at line 278 of file pgstat_database.c.

{
    return (PgStat_StatDBEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_DATABASE, dboid, InvalidOid);
}

References InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_DATABASE.

Referenced by do_start_worker(), pg_stat_get_db_checksum_failures(), pg_stat_get_db_checksum_last_failure(), pg_stat_get_db_conflict_all(), pg_stat_get_db_stat_reset_time(), and rebuild_database_list().

◆ pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry * pgstat_fetch_stat_funcentry ( Oid func_id )

Definition at line 239 of file pgstat_function.c.

{
    return (PgStat_StatFuncEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_FUNCTION, MyDatabaseId, func_id);
}

References MyDatabaseId, pgstat_fetch_entry(), and PGSTAT_KIND_FUNCTION.

Referenced by pg_stat_get_function_calls().

◆ pgstat_fetch_stat_io()

PgStat_IO * pgstat_fetch_stat_io ( void )

Definition at line 163 of file pgstat_io.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_IO);
 
    return &pgStatLocal.snapshot.io;
}

References PgStat_Snapshot::io, PGSTAT_KIND_IO, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_io().

◆ pgstat_fetch_stat_subscription()

PgStat_StatSubEntry * pgstat_fetch_stat_subscription ( Oid subid )

Definition at line 90 of file pgstat_subscription.c.

{
    return (PgStat_StatSubEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid);
}

References InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_SUBSCRIPTION.

Referenced by pg_stat_get_subscription_stats().

◆ pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry * pgstat_fetch_stat_tabentry ( Oid relid )

Definition at line 470 of file pgstat_relation.c.

{
    return pgstat_fetch_stat_tabentry_ext(IsSharedRelation(relid), relid);
}

References IsSharedRelation(), and pgstat_fetch_stat_tabentry_ext().

◆ pgstat_fetch_stat_tabentry_ext()

PgStat_StatTabEntry * pgstat_fetch_stat_tabentry_ext	(	bool	shared,
		Oid	reloid
	)

Definition at line 480 of file pgstat_relation.c.

{
    Oid         dboid = (shared ? InvalidOid : MyDatabaseId);
 
    return (PgStat_StatTabEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_RELATION, dboid, reloid);
}

References InvalidOid, MyDatabaseId, pgstat_fetch_entry(), and PGSTAT_KIND_RELATION.

Referenced by do_autovacuum(), pgstat_copy_relation_stats(), pgstat_fetch_stat_tabentry(), and recheck_relation_needs_vacanalyze().

◆ pgstat_fetch_stat_wal()

PgStat_WalStats * pgstat_fetch_stat_wal ( void )

Definition at line 67 of file pgstat_wal.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_WAL);
 
    return &pgStatLocal.snapshot.wal;
}

References PGSTAT_KIND_WAL, pgstat_snapshot_fixed(), pgStatLocal, PgStat_LocalState::snapshot, and PgStat_Snapshot::wal.

Referenced by pg_stat_get_wal().

◆ pgstat_force_next_flush()

void pgstat_force_next_flush ( void )

Definition at line 829 of file pgstat.c.

831{

832 pgStatForceNextFlush = true;

pgStatForceNextFlush

static bool pgStatForceNextFlush

Definition: pgstat.c:244

References pgStatForceNextFlush.

Referenced by pg_stat_force_next_flush().

◆ pgstat_get_io_context_name()

const char * pgstat_get_io_context_name ( IOContext io_context )

Definition at line 248 of file pgstat_io.c.

{
    switch (io_context)
    {
        case IOCONTEXT_BULKREAD:
            return "bulkread";
        case IOCONTEXT_BULKWRITE:
            return "bulkwrite";
        case IOCONTEXT_INIT:
            return "init";
        case IOCONTEXT_NORMAL:
            return "normal";
        case IOCONTEXT_VACUUM:
            return "vacuum";
    }
 
    elog(ERROR, "unrecognized IOContext value: %d", io_context);
    pg_unreachable();
}

References elog, ERROR, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_INIT, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, and pg_unreachable.

Referenced by pg_stat_io_build_tuples().

◆ pgstat_get_io_object_name()

const char * pgstat_get_io_object_name ( IOObject io_object )

Definition at line 269 of file pgstat_io.c.

{
    switch (io_object)
    {
        case IOOBJECT_RELATION:
            return "relation";
        case IOOBJECT_TEMP_RELATION:
            return "temp relation";
        case IOOBJECT_WAL:
            return "wal";
    }
 
    elog(ERROR, "unrecognized IOObject value: %d", io_object);
    pg_unreachable();
}

References elog, ERROR, IOOBJECT_RELATION, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, and pg_unreachable.

Referenced by pg_stat_io_build_tuples().

◆ pgstat_get_kind_from_str()

PgStat_Kind pgstat_get_kind_from_str ( char * kind_str )

Definition at line 1419 of file pgstat.c.

{
    for (PgStat_Kind kind = PGSTAT_KIND_BUILTIN_MIN; kind <= PGSTAT_KIND_BUILTIN_MAX; kind++)
    {
        if (pg_strcasecmp(kind_str, pgstat_kind_builtin_infos[kind].name) == 0)
            return kind;
    }
 
    /* Check the custom set of cumulative stats */
    if (pgstat_kind_custom_infos)
    {
        for (PgStat_Kind kind = PGSTAT_KIND_CUSTOM_MIN; kind <= PGSTAT_KIND_CUSTOM_MAX; kind++)
        {
            uint32      idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
            if (pgstat_kind_custom_infos[idx] &&
                pg_strcasecmp(kind_str, pgstat_kind_custom_infos[idx]->name) == 0)
                return kind;
        }
    }
 
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("invalid statistics kind: \"%s\"", kind_str)));
    return PGSTAT_KIND_INVALID; /* avoid compiler warnings */

References ereport, errcode(), errmsg(), ERROR, idx(), name, pg_strcasecmp(), PgStat_Kind, pgstat_kind_builtin_infos, PGSTAT_KIND_BUILTIN_MAX, PGSTAT_KIND_BUILTIN_MIN, pgstat_kind_custom_infos, PGSTAT_KIND_CUSTOM_MAX, PGSTAT_KIND_CUSTOM_MIN, and PGSTAT_KIND_INVALID.

Referenced by pg_stat_have_stats().

◆ pgstat_get_slru_index()

int pgstat_get_slru_index ( const char * name )

Definition at line 132 of file pgstat_slru.c.

{
    int         i;
 
    for (i = 0; i < SLRU_NUM_ELEMENTS; i++)
    {
        if (strcmp(slru_names[i], name) == 0)
            return i;
    }
 
    /* return index of the last entry (which is the "other" one) */
    return (SLRU_NUM_ELEMENTS - 1);
}

References i, name, slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pgstat_reset_slru(), and SimpleLruInit().

◆ pgstat_get_slru_name()

const char * pgstat_get_slru_name ( int slru_idx )

Definition at line 118 of file pgstat_slru.c.

{
    if (slru_idx < 0 || slru_idx >= SLRU_NUM_ELEMENTS)
        return NULL;
 
    return slru_names[slru_idx];
}

References slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pg_stat_get_slru().

◆ pgstat_get_stat_snapshot_timestamp()

TimestampTz pgstat_get_stat_snapshot_timestamp ( bool * have_snapshot )

Definition at line 1045 of file pgstat.c.

{
    if (force_stats_snapshot_clear)
        pgstat_clear_snapshot();
 
    if (pgStatLocal.snapshot.mode == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT)
    {
        *have_snapshot = true;
        return pgStatLocal.snapshot.snapshot_timestamp;
    }
 
    *have_snapshot = false;
 
    return 0;

References force_stats_snapshot_clear, PgStat_Snapshot::mode, pgstat_clear_snapshot(), PGSTAT_FETCH_CONSISTENCY_SNAPSHOT, pgStatLocal, PgStat_LocalState::snapshot, and PgStat_Snapshot::snapshot_timestamp.

Referenced by pg_stat_get_snapshot_timestamp().

◆ pgstat_get_transactional_drops()

int pgstat_get_transactional_drops	(	bool	isCommit,
		struct xl_xact_stats_item **	items
	)

Definition at line 272 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state = pgStatXactStack;
    int         nitems = 0;
    dlist_iter  iter;
 
    if (xact_state == NULL)
        return 0;
 
    /*
     * We expect to be called for subtransaction abort (which logs a WAL
     * record), but not for subtransaction commit (which doesn't).
     */
    Assert(!isCommit || xact_state->nest_level == 1);
    Assert(!isCommit || xact_state->prev == NULL);
 
    *items = palloc(dclist_count(&xact_state->pending_drops)
                    * sizeof(xl_xact_stats_item));
 
    dclist_foreach(iter, &xact_state->pending_drops)
    {
        PgStat_PendingDroppedStatsItem *pending =
            dclist_container(PgStat_PendingDroppedStatsItem, node, iter.cur);
 
        if (isCommit && pending->is_create)
            continue;
        if (!isCommit && !pending->is_create)
            continue;
 
        Assert(nitems < dclist_count(&xact_state->pending_drops));
        (*items)[nitems++] = pending->item;
    }
 
    return nitems;
}

References Assert(), dlist_iter::cur, dclist_container, dclist_count(), dclist_foreach, PgStat_PendingDroppedStatsItem::is_create, PgStat_PendingDroppedStatsItem::item, items, PgStat_SubXactStatus::nest_level, nitems, palloc(), PgStat_SubXactStatus::pending_drops, pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by RecordTransactionAbort(), RecordTransactionCommit(), and StartPrepare().

◆ pgstat_have_entry()

bool pgstat_have_entry	(	PgStat_Kind	kind,
		Oid	dboid,
		uint64	objid
	)

Definition at line 1062 of file pgstat.c.

{
    /* fixed-numbered stats always exist */
    if (pgstat_get_kind_info(kind)->fixed_amount)
        return true;
 
    return pgstat_get_entry_ref(kind, dboid, objid, false, NULL) != NULL;

References pgstat_get_entry_ref(), and pgstat_get_kind_info().

Referenced by pg_stat_have_stats().

◆ pgstat_init_function_usage()

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

◆ pgstat_init_relation()

void pgstat_init_relation ( Relation rel )

Definition at line 91 of file pgstat_relation.c.

{
    char        relkind = rel->rd_rel->relkind;
 
    /*
     * We only count stats for relations with storage and partitioned tables
     */
    if (!RELKIND_HAS_STORAGE(relkind) && relkind != RELKIND_PARTITIONED_TABLE)
    {
        rel->pgstat_enabled = false;
        rel->pgstat_info = NULL;
        return;
    }
 
    if (!pgstat_track_counts)
    {
        if (rel->pgstat_info)
            pgstat_unlink_relation(rel);
 
        /* We're not counting at all */
        rel->pgstat_enabled = false;
        rel->pgstat_info = NULL;
        return;
    }
 
    rel->pgstat_enabled = true;
}

References RelationData::pgstat_enabled, RelationData::pgstat_info, pgstat_track_counts, pgstat_unlink_relation(), and RelationData::rd_rel.

Referenced by relation_open(), and try_relation_open().

◆ pgstat_initialize()

void pgstat_initialize ( void )

Definition at line 638 of file pgstat.c.

{
    Assert(!pgstat_is_initialized);
 
    pgstat_attach_shmem();
 
    pgstat_init_snapshot_fixed();
 
    /* Backend initialization callbacks */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info == NULL || kind_info->init_backend_cb == NULL)
            continue;
 
        kind_info->init_backend_cb();
    }
 
    /* Set up a process-exit hook to clean up */
    before_shmem_exit(pgstat_shutdown_hook, 0);
 
#ifdef USE_ASSERT_CHECKING
    pgstat_is_initialized = true;
#endif

References Assert(), before_shmem_exit(), PgStat_KindInfo::init_backend_cb, pgstat_attach_shmem(), pgstat_get_kind_info(), pgstat_init_snapshot_fixed(), PgStat_Kind, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, and pgstat_shutdown_hook().

Referenced by BaseInit().

◆ pgstat_prepare_io_time()

instr_time pgstat_prepare_io_time ( bool track_io_guc )

Definition at line 90 of file pgstat_io.c.

{
    instr_time  io_start;
 
    if (track_io_guc)
        INSTR_TIME_SET_CURRENT(io_start);
    else
    {
        /*
         * There is no need to set io_start when an IO timing GUC is disabled.
         * Initialize it to zero to avoid compiler warnings and to let
         * pgstat_count_io_op_time() know that timings should be ignored.
         */
        INSTR_TIME_SET_ZERO(io_start);
    }
 
    return io_start;
}

References INSTR_TIME_SET_CURRENT, and INSTR_TIME_SET_ZERO.

Referenced by AsyncReadBuffers(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushLocalBuffer(), issue_xlog_fsync(), IssuePendingWritebacks(), mdsyncfiletag(), register_dirty_segment(), WaitReadBuffers(), WALRead(), XLogFileInitInternal(), XLogPageRead(), XLogWalRcvWrite(), and XLogWrite().

◆ pgstat_prepare_report_checksum_failure()

void pgstat_prepare_report_checksum_failure ( Oid dboid )

Definition at line 145 of file pgstat_database.c.

{
    Assert(!CritSectionCount);
 
    /*
     * Just need to ensure this backend has an entry ref for the database.
     * That will allows us to report checksum failures without e.g. needing to
     * map in DSM segments.
     */
    pgstat_get_entry_ref(PGSTAT_KIND_DATABASE, dboid, InvalidOid,
                         true, NULL);
}

References Assert(), CritSectionCount, InvalidOid, pgstat_get_entry_ref(), and PGSTAT_KIND_DATABASE.

Referenced by AsyncReadBuffers(), read_rel_block_ll(), RelationCopyStorage(), and sendFile().

◆ pgstat_report_analyze()

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

Definition at line 282 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Relation *shtabentry;
    PgStat_StatTabEntry *tabentry;
    Oid         dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId);
    TimestampTz ts;
    PgStat_Counter elapsedtime;
 
    if (!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 the update we're making now, else they'll be
     * double-counted after commit.  (This approach also ensures that the
     * shared stats entry ends up with the right numbers if we abort instead
     * of committing.)
     *
     * Waste no time on partitioned tables, though.
     */
    if (pgstat_should_count_relation(rel) &&
        rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
    {
        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->counts.delta_dead_tuples;
        /* Since ANALYZE's counts are estimates, we could have underflowed */
        livetuples = Max(livetuples, 0);
        deadtuples = Max(deadtuples, 0);
    }
 
    /* Store the data in the table's hash table entry. */
    ts = GetCurrentTimestamp();
    elapsedtime = TimestampDifferenceMilliseconds(starttime, ts);
 
    /* block acquiring lock for the same reason as pgstat_report_autovac() */
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION, dboid,
                                            RelationGetRelid(rel),
                                            false);
    /* can't get dropped while accessed */
    Assert(entry_ref != NULL && entry_ref->shared_stats != NULL);
 
    shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
    tabentry = &shtabentry->stats;
 
    tabentry->live_tuples = livetuples;
    tabentry->dead_tuples = deadtuples;
 
    /*
     * If commanded, reset mod_since_analyze to zero.  This forgets any
     * changes that were committed while the ANALYZE was in progress, but we
     * have no good way to estimate how many of those there were.
     */
    if (resetcounter)
        tabentry->mod_since_analyze = 0;
 
    if (AmAutoVacuumWorkerProcess())
    {
        tabentry->last_autoanalyze_time = ts;
        tabentry->autoanalyze_count++;
        tabentry->total_autoanalyze_time += elapsedtime;
    }
    else
    {
        tabentry->last_analyze_time = ts;
        tabentry->analyze_count++;
        tabentry->total_analyze_time += elapsedtime;
    }
 
    pgstat_unlock_entry(entry_ref);
 
    /* see pgstat_report_vacuum() */
    pgstat_flush_io(false);
    (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO);
}

Referenced by do_analyze_rel().

◆ pgstat_report_archiver()

void pgstat_report_archiver	(	const char *	xlog,
		bool	failed
	)

Definition at line 28 of file pgstat_archiver.c.

{
    PgStatShared_Archiver *stats_shmem = &pgStatLocal.shmem->archiver;
    TimestampTz now = GetCurrentTimestamp();
 
    pgstat_begin_changecount_write(&stats_shmem->changecount);
 
    if (failed)
    {
        ++stats_shmem->stats.failed_count;
        memcpy(&stats_shmem->stats.last_failed_wal, xlog,
               sizeof(stats_shmem->stats.last_failed_wal));
        stats_shmem->stats.last_failed_timestamp = now;
    }
    else
    {
        ++stats_shmem->stats.archived_count;
        memcpy(&stats_shmem->stats.last_archived_wal, xlog,
               sizeof(stats_shmem->stats.last_archived_wal));
        stats_shmem->stats.last_archived_timestamp = now;
    }
 
    pgstat_end_changecount_write(&stats_shmem->changecount);
}

References PgStat_ArchiverStats::archived_count, PgStat_ShmemControl::archiver, PgStatShared_Archiver::changecount, PgStat_ArchiverStats::failed_count, GetCurrentTimestamp(), PgStat_ArchiverStats::last_archived_timestamp, PgStat_ArchiverStats::last_archived_wal, PgStat_ArchiverStats::last_failed_timestamp, PgStat_ArchiverStats::last_failed_wal, now(), pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgStatLocal, PgStat_LocalState::shmem, and PgStatShared_Archiver::stats.

Referenced by pgarch_ArchiverCopyLoop().

◆ pgstat_report_autovac()

void pgstat_report_autovac ( Oid dboid )

Definition at line 55 of file pgstat_database.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Database *dbentry;
 
    /* can't get here in single user mode */
    Assert(IsUnderPostmaster);
 
    /*
     * End-of-vacuum is reported instantly. Report the start the same way for
     * consistency. Vacuum doesn't run frequently and is a long-lasting
     * operation so it doesn't matter if we get blocked here a little.
     */
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_DATABASE,
                                            dboid, InvalidOid, false);
 
    dbentry = (PgStatShared_Database *) entry_ref->shared_stats;
    dbentry->stats.last_autovac_time = GetCurrentTimestamp();
 
    pgstat_unlock_entry(entry_ref);
}

References Assert(), GetCurrentTimestamp(), InvalidOid, IsUnderPostmaster, PgStat_StatDBEntry::last_autovac_time, pgstat_get_entry_ref_locked(), PGSTAT_KIND_DATABASE, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, and PgStatShared_Database::stats.

Referenced by AutoVacWorkerMain().

◆ pgstat_report_bgwriter()

void pgstat_report_bgwriter ( void )

Definition at line 31 of file pgstat_bgwriter.c.

{
    PgStatShared_BgWriter *stats_shmem = &pgStatLocal.shmem->bgwriter;
 
    Assert(!pgStatLocal.shmem->is_shutdown);
    pgstat_assert_is_up();
 
    /*
     * This function can be called even if nothing at all has happened. In
     * this case, avoid unnecessarily modifying the stats entry.
     */
    if (pg_memory_is_all_zeros(&PendingBgWriterStats,
                               sizeof(struct PgStat_BgWriterStats)))
        return;
 
    pgstat_begin_changecount_write(&stats_shmem->changecount);
 
#define BGWRITER_ACC(fld) stats_shmem->stats.fld += PendingBgWriterStats.fld
    BGWRITER_ACC(buf_written_clean);
    BGWRITER_ACC(maxwritten_clean);
    BGWRITER_ACC(buf_alloc);
#undef BGWRITER_ACC
 
    pgstat_end_changecount_write(&stats_shmem->changecount);
 
    /*
     * Clear out the statistics buffer, so it can be re-used.
     */
    MemSet(&PendingBgWriterStats, 0, sizeof(PendingBgWriterStats));
 
    /*
     * Report IO statistics
     */
    pgstat_flush_io(false);
}

References Assert(), PgStat_ShmemControl::bgwriter, BGWRITER_ACC, PgStatShared_BgWriter::changecount, PgStat_ShmemControl::is_shutdown, MemSet, PendingBgWriterStats, pg_memory_is_all_zeros(), pgstat_assert_is_up, pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgstat_flush_io(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by BackgroundWriterMain().

◆ pgstat_report_checkpointer()

void pgstat_report_checkpointer ( void )

Definition at line 31 of file pgstat_checkpointer.c.

{
    PgStatShared_Checkpointer *stats_shmem = &pgStatLocal.shmem->checkpointer;
 
    Assert(!pgStatLocal.shmem->is_shutdown);
    pgstat_assert_is_up();
 
    /*
     * This function can be called even if nothing at all has happened. In
     * this case, avoid unnecessarily modifying the stats entry.
     */
    if (pg_memory_is_all_zeros(&PendingCheckpointerStats,
                               sizeof(struct PgStat_CheckpointerStats)))
        return;
 
    pgstat_begin_changecount_write(&stats_shmem->changecount);
 
#define CHECKPOINTER_ACC(fld) stats_shmem->stats.fld += PendingCheckpointerStats.fld
    CHECKPOINTER_ACC(num_timed);
    CHECKPOINTER_ACC(num_requested);
    CHECKPOINTER_ACC(num_performed);
    CHECKPOINTER_ACC(restartpoints_timed);
    CHECKPOINTER_ACC(restartpoints_requested);
    CHECKPOINTER_ACC(restartpoints_performed);
    CHECKPOINTER_ACC(write_time);
    CHECKPOINTER_ACC(sync_time);
    CHECKPOINTER_ACC(buffers_written);
    CHECKPOINTER_ACC(slru_written);
#undef CHECKPOINTER_ACC
 
    pgstat_end_changecount_write(&stats_shmem->changecount);
 
    /*
     * Clear out the statistics buffer, so it can be re-used.
     */
    MemSet(&PendingCheckpointerStats, 0, sizeof(PendingCheckpointerStats));
 
    /*
     * Report IO statistics
     */
    pgstat_flush_io(false);
}

References Assert(), PgStatShared_Checkpointer::changecount, PgStat_ShmemControl::checkpointer, CHECKPOINTER_ACC, PgStat_ShmemControl::is_shutdown, MemSet, PendingCheckpointerStats, pg_memory_is_all_zeros(), pgstat_assert_is_up, pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgstat_flush_io(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by CheckpointerMain(), and CheckpointWriteDelay().

◆ pgstat_report_checksum_failures_in_db()

void pgstat_report_checksum_failures_in_db	(	Oid	dboid,
		int	failurecount
	)

Definition at line 166 of file pgstat_database.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Database *sharedent;
 
    if (!pgstat_track_counts)
        return;
 
    /*
     * Update the shared stats directly - checksum failures should never be
     * common enough for that to be a problem. Note that we pass create=false
     * here, as we want to be sure to not require memory allocations, so this
     * can be called in critical sections.
     */
    entry_ref = pgstat_get_entry_ref(PGSTAT_KIND_DATABASE, dboid, InvalidOid,
                                     false, NULL);
 
    /*
     * Should always have been created by
     * pgstat_prepare_report_checksum_failure().
     *
     * When not using assertions, we don't want to crash should something have
     * gone wrong, so just return.
     */
    Assert(entry_ref);
    if (!entry_ref)
    {
        elog(WARNING, "could not report %d conflicts for DB %u",
             failurecount, dboid);
        return;
    }
 
    (void) pgstat_lock_entry(entry_ref, false);
 
    sharedent = (PgStatShared_Database *) entry_ref->shared_stats;
    sharedent->stats.checksum_failures += failurecount;
    sharedent->stats.last_checksum_failure = GetCurrentTimestamp();
 
    pgstat_unlock_entry(entry_ref);
}

References Assert(), PgStat_StatDBEntry::checksum_failures, elog, GetCurrentTimestamp(), InvalidOid, PgStat_StatDBEntry::last_checksum_failure, pgstat_get_entry_ref(), PGSTAT_KIND_DATABASE, pgstat_lock_entry(), pgstat_track_counts, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, PgStatShared_Database::stats, and WARNING.

Referenced by buffer_readv_complete(), RelationCopyStorage(), sendFile(), and shared_buffer_readv_complete_local().

◆ pgstat_report_connect()

void pgstat_report_connect ( Oid dboid )

Definition at line 227 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbentry;
 
    if (!pgstat_should_report_connstat())
        return;
 
    pgLastSessionReportTime = MyStartTimestamp;
 
    dbentry = pgstat_prep_database_pending(MyDatabaseId);
    dbentry->sessions++;
}

References MyDatabaseId, MyStartTimestamp, pgLastSessionReportTime, pgstat_prep_database_pending(), pgstat_should_report_connstat(), and PgStat_StatDBEntry::sessions.

Referenced by PostgresMain().

◆ pgstat_report_deadlock()

void pgstat_report_deadlock ( void )

Definition at line 125 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbent;
 
    if (!pgstat_track_counts)
        return;
 
    dbent = pgstat_prep_database_pending(MyDatabaseId);
    dbent->deadlocks++;
}

References PgStat_StatDBEntry::deadlocks, MyDatabaseId, pgstat_prep_database_pending(), and pgstat_track_counts.

Referenced by DeadLockReport().

◆ pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int reason )

Definition at line 81 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbentry;
 
    Assert(IsUnderPostmaster);
    if (!pgstat_track_counts)
        return;
 
    dbentry = pgstat_prep_database_pending(MyDatabaseId);
 
    switch (reason)
    {
        case PROCSIG_RECOVERY_CONFLICT_DATABASE:
 
            /*
             * Since we drop the information about the database as soon as it
             * replicates, there is no point in counting these conflicts.
             */
            break;
        case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
            dbentry->conflict_tablespace++;
            break;
        case PROCSIG_RECOVERY_CONFLICT_LOCK:
            dbentry->conflict_lock++;
            break;
        case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
            dbentry->conflict_snapshot++;
            break;
        case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
            dbentry->conflict_bufferpin++;
            break;
        case PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT:
            dbentry->conflict_logicalslot++;
            break;
        case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
            dbentry->conflict_startup_deadlock++;
            break;
    }
}

References Assert(), PgStat_StatDBEntry::conflict_bufferpin, PgStat_StatDBEntry::conflict_lock, PgStat_StatDBEntry::conflict_logicalslot, PgStat_StatDBEntry::conflict_snapshot, PgStat_StatDBEntry::conflict_startup_deadlock, PgStat_StatDBEntry::conflict_tablespace, IsUnderPostmaster, MyDatabaseId, pgstat_prep_database_pending(), pgstat_track_counts, PROCSIG_RECOVERY_CONFLICT_BUFFERPIN, PROCSIG_RECOVERY_CONFLICT_DATABASE, PROCSIG_RECOVERY_CONFLICT_LOCK, PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT, PROCSIG_RECOVERY_CONFLICT_SNAPSHOT, PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK, and PROCSIG_RECOVERY_CONFLICT_TABLESPACE.

Referenced by ProcessRecoveryConflictInterrupt().

◆ pgstat_report_replslot()

void pgstat_report_replslot	(	struct ReplicationSlot *	slot,
		const PgStat_StatReplSlotEntry *	repSlotStat
	)

Definition at line 78 of file pgstat_replslot.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_ReplSlot *shstatent;
    PgStat_StatReplSlotEntry *statent;
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_REPLSLOT, InvalidOid,
                                            ReplicationSlotIndex(slot), false);
    shstatent = (PgStatShared_ReplSlot *) entry_ref->shared_stats;
    statent = &shstatent->stats;
 
    /* Update the replication slot statistics */
#define REPLSLOT_ACC(fld) statent->fld += repSlotStat->fld
    REPLSLOT_ACC(spill_txns);
    REPLSLOT_ACC(spill_count);
    REPLSLOT_ACC(spill_bytes);
    REPLSLOT_ACC(stream_txns);
    REPLSLOT_ACC(stream_count);
    REPLSLOT_ACC(stream_bytes);
    REPLSLOT_ACC(total_txns);
    REPLSLOT_ACC(total_bytes);
#undef REPLSLOT_ACC
 
    pgstat_unlock_entry(entry_ref);
}

References InvalidOid, pgstat_get_entry_ref_locked(), PGSTAT_KIND_REPLSLOT, pgstat_unlock_entry(), ReplicationSlotIndex(), REPLSLOT_ACC, PgStat_EntryRef::shared_stats, and PgStatShared_ReplSlot::stats.

Referenced by UpdateDecodingStats().

◆ pgstat_report_stat()

long pgstat_report_stat ( bool force )

Definition at line 691 of file pgstat.c.

{
    static TimestampTz pending_since = 0;
    static TimestampTz last_flush = 0;
    bool        partial_flush;
    TimestampTz now;
    bool        nowait;
 
    pgstat_assert_is_up();
    Assert(!IsTransactionOrTransactionBlock());
 
    /* "absorb" the forced flush even if there's nothing to flush */
    if (pgStatForceNextFlush)
    {
        force = true;
        pgStatForceNextFlush = false;
    }
 
    /* Don't expend a clock check if nothing to do */
    if (dlist_is_empty(&pgStatPending))
    {
        bool        do_flush = false;
 
        /* Check for pending stats */
        for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
        {
            const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
            if (!kind_info)
                continue;
            if (!kind_info->have_static_pending_cb)
                continue;
 
            if (kind_info->have_static_pending_cb())
            {
                do_flush = true;
                break;
            }
        }
 
        if (!do_flush)
        {
            Assert(pending_since == 0);
            return 0;
        }
    }
 
    /*
     * There should never be stats to report once stats are shut down. Can't
     * assert that before the checks above, as there is an unconditional
     * pgstat_report_stat() call in pgstat_shutdown_hook() - which at least
     * the process that ran pgstat_before_server_shutdown() will still call.
     */
    Assert(!pgStatLocal.shmem->is_shutdown);
 
    if (force)
    {
        /*
         * Stats reports are forced either when it's been too long since stats
         * have been reported or in processes that force stats reporting to
         * happen at specific points (including shutdown). In the former case
         * the transaction stop time might be quite old, in the latter it
         * would never get cleared.
         */
        now = GetCurrentTimestamp();
    }
    else
    {
        now = GetCurrentTransactionStopTimestamp();
 
        if (pending_since > 0 &&
            TimestampDifferenceExceeds(pending_since, now, PGSTAT_MAX_INTERVAL))
        {
            /* don't keep pending updates longer than PGSTAT_MAX_INTERVAL */
            force = true;
        }
        else if (last_flush > 0 &&
                 !TimestampDifferenceExceeds(last_flush, now, PGSTAT_MIN_INTERVAL))
        {
            /* don't flush too frequently */
            if (pending_since == 0)
                pending_since = now;
 
            return PGSTAT_IDLE_INTERVAL;
        }
    }
 
    pgstat_update_dbstats(now);
 
    /* don't wait for lock acquisition when !force */
    nowait = !force;
 
    partial_flush = false;
 
    /* flush of variable-numbered stats tracked in pending entries list */
    partial_flush |= pgstat_flush_pending_entries(nowait);
 
    /* flush of other stats kinds */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (!kind_info)
            continue;
        if (!kind_info->flush_static_cb)
            continue;
 
        partial_flush |= kind_info->flush_static_cb(nowait);
    }
 
    last_flush = now;
 
    /*
     * If some of the pending stats could not be flushed due to lock
     * contention, let the caller know when to retry.
     */
    if (partial_flush)
    {
        /* force should have prevented us from getting here */
        Assert(!force);
 
        /* remember since when stats have been pending */
        if (pending_since == 0)
            pending_since = now;
 
        return PGSTAT_IDLE_INTERVAL;
    }
 
    pending_since = 0;
 
    return 0;

References Assert(), dlist_is_empty(), PgStat_KindInfo::flush_static_cb, GetCurrentTimestamp(), GetCurrentTransactionStopTimestamp(), PgStat_KindInfo::have_static_pending_cb, PgStat_ShmemControl::is_shutdown, IsTransactionOrTransactionBlock(), now(), pgstat_assert_is_up, pgstat_flush_pending_entries(), pgstat_get_kind_info(), PGSTAT_IDLE_INTERVAL, PgStat_Kind, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, PGSTAT_MAX_INTERVAL, PGSTAT_MIN_INTERVAL, pgstat_update_dbstats(), pgStatForceNextFlush, pgStatLocal, pgStatPending, PgStat_LocalState::shmem, and TimestampDifferenceExceeds().

Referenced by AllTablesyncsReady(), apply_handle_commit_internal(), apply_handle_commit_prepared(), apply_handle_prepare(), apply_handle_rollback_prepared(), apply_handle_stream_prepare(), finish_sync_worker(), LogicalRepApplyLoop(), LogicalRepSyncTableStart(), pgstat_before_server_shutdown(), pgstat_shutdown_hook(), PostgresMain(), process_syncing_tables_for_apply(), process_syncing_tables_for_sync(), ProcessInterrupts(), standby_redo(), and worker_spi_main().

◆ pgstat_report_subscription_conflict()

void pgstat_report_subscription_conflict	(	Oid	subid,
		ConflictType	type
	)

Definition at line 46 of file pgstat_subscription.c.

{
    PgStat_EntryRef *entry_ref;
    PgStat_BackendSubEntry *pending;
 
    entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_SUBSCRIPTION,
                                          InvalidOid, subid, NULL);
    pending = entry_ref->pending;
    pending->conflict_count[type]++;
}

References PgStat_BackendSubEntry::conflict_count, InvalidOid, PgStat_EntryRef::pending, PGSTAT_KIND_SUBSCRIPTION, pgstat_prep_pending_entry(), and type.

Referenced by ReportApplyConflict().

◆ pgstat_report_subscription_error()

void pgstat_report_subscription_error	(	Oid	subid,
		bool	is_apply_error
	)

Definition at line 27 of file pgstat_subscription.c.

{
    PgStat_EntryRef *entry_ref;
    PgStat_BackendSubEntry *pending;
 
    entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_SUBSCRIPTION,
                                          InvalidOid, subid, NULL);
    pending = entry_ref->pending;
 
    if (is_apply_error)
        pending->apply_error_count++;
    else
        pending->sync_error_count++;
}

References PgStat_BackendSubEntry::apply_error_count, InvalidOid, PgStat_EntryRef::pending, PGSTAT_KIND_SUBSCRIPTION, pgstat_prep_pending_entry(), and PgStat_BackendSubEntry::sync_error_count.

Referenced by DisableSubscriptionAndExit(), start_apply(), and start_table_sync().

◆ pgstat_report_vacuum()

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

Definition at line 210 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Relation *shtabentry;
    PgStat_StatTabEntry *tabentry;
    Oid         dboid = (shared ? InvalidOid : MyDatabaseId);
    TimestampTz ts;
    PgStat_Counter elapsedtime;
 
    if (!pgstat_track_counts)
        return;
 
    /* Store the data in the table's hash table entry. */
    ts = GetCurrentTimestamp();
    elapsedtime = TimestampDifferenceMilliseconds(starttime, ts);
 
    /* block acquiring lock for the same reason as pgstat_report_autovac() */
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
                                            dboid, tableoid, false);
 
    shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
    tabentry = &shtabentry->stats;
 
    tabentry->live_tuples = livetuples;
    tabentry->dead_tuples = deadtuples;
 
    /*
     * It is quite possible that a non-aggressive VACUUM ended up skipping
     * various pages, however, we'll zero the insert counter here regardless.
     * It's currently used only to track when we need to perform an "insert"
     * autovacuum, which are mainly intended to freeze newly inserted tuples.
     * Zeroing this may just mean we'll not try to vacuum the table again
     * until enough tuples have been inserted to trigger another insert
     * autovacuum.  An anti-wraparound autovacuum will catch any persistent
     * stragglers.
     */
    tabentry->ins_since_vacuum = 0;
 
    if (AmAutoVacuumWorkerProcess())
    {
        tabentry->last_autovacuum_time = ts;
        tabentry->autovacuum_count++;
        tabentry->total_autovacuum_time += elapsedtime;
    }
    else
    {
        tabentry->last_vacuum_time = ts;
        tabentry->vacuum_count++;
        tabentry->total_vacuum_time += elapsedtime;
    }
 
    pgstat_unlock_entry(entry_ref);
 
    /*
     * Flush IO statistics now. pgstat_report_stat() will flush IO stats,
     * however this will not be called until after an entire autovacuum cycle
     * is done -- which will likely vacuum many relations -- or until the
     * VACUUM command has processed all tables and committed.
     */
    pgstat_flush_io(false);
    (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO);
}

Referenced by heap_vacuum_rel().

◆ pgstat_report_wal()

void pgstat_report_wal ( bool force )

Definition at line 46 of file pgstat_wal.c.

{
    bool        nowait;
 
    /* like in pgstat.c, don't wait for lock acquisition when !force */
    nowait = !force;
 
    /* flush wal stats */
    (void) pgstat_wal_flush_cb(nowait);
    pgstat_flush_backend(nowait, PGSTAT_BACKEND_FLUSH_WAL);
 
    /* flush IO stats */
    pgstat_flush_io(nowait);
    (void) pgstat_flush_backend(nowait, PGSTAT_BACKEND_FLUSH_IO);
}

References PGSTAT_BACKEND_FLUSH_IO, PGSTAT_BACKEND_FLUSH_WAL, pgstat_flush_backend(), pgstat_flush_io(), and pgstat_wal_flush_cb().

Referenced by BackgroundWriterMain(), CheckpointerMain(), summarizer_wait_for_wal(), WalReceiverMain(), and WalWriterMain().

◆ pgstat_reset()

void pgstat_reset	(	PgStat_Kind	kind,
		Oid	dboid,
		uint64	objid
	)

Definition at line 869 of file pgstat.c.

{
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
    TimestampTz ts = GetCurrentTimestamp();
 
    /* not needed atm, and doesn't make sense with the current signature */
    Assert(!pgstat_get_kind_info(kind)->fixed_amount);
 
    /* reset the "single counter" */
    pgstat_reset_entry(kind, dboid, objid, ts);
 
    if (!kind_info->accessed_across_databases)
        pgstat_reset_database_timestamp(dboid, ts);

References PgStat_KindInfo::accessed_across_databases, Assert(), GetCurrentTimestamp(), pgstat_get_kind_info(), pgstat_reset_database_timestamp(), and pgstat_reset_entry().

Referenced by pg_stat_reset_backend_stats(), pg_stat_reset_single_function_counters(), pg_stat_reset_single_table_counters(), pg_stat_reset_subscription_stats(), pgstat_create_transactional(), and pgstat_reset_replslot().

◆ pgstat_reset_counters()

void pgstat_reset_counters ( void )

Definition at line 850 of file pgstat.c.

{
    TimestampTz ts = GetCurrentTimestamp();
 
    pgstat_reset_matching_entries(match_db_entries,
                                  ObjectIdGetDatum(MyDatabaseId),
                                  ts);

References GetCurrentTimestamp(), match_db_entries(), MyDatabaseId, ObjectIdGetDatum(), and pgstat_reset_matching_entries().

Referenced by pg_stat_reset().

◆ pgstat_reset_of_kind()

void pgstat_reset_of_kind ( PgStat_Kind kind )

Definition at line 891 of file pgstat.c.

{
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
    TimestampTz ts = GetCurrentTimestamp();
 
    if (kind_info->fixed_amount)
        kind_info->reset_all_cb(ts);
    else
        pgstat_reset_entries_of_kind(kind, ts);

References PgStat_KindInfo::fixed_amount, GetCurrentTimestamp(), pgstat_get_kind_info(), pgstat_reset_entries_of_kind(), and PgStat_KindInfo::reset_all_cb.

Referenced by pg_stat_reset_replication_slot(), pg_stat_reset_shared(), pg_stat_reset_slru(), and pg_stat_reset_subscription_stats().

◆ pgstat_reset_replslot()

void pgstat_reset_replslot ( const char * name )

Definition at line 42 of file pgstat_replslot.c.

{
    ReplicationSlot *slot;
 
    Assert(name != NULL);
 
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
    /* Check if the slot exits with the given name. */
    slot = SearchNamedReplicationSlot(name, false);
 
    if (!slot)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("replication slot \"%s\" does not exist",
                        name)));
 
    /*
     * Reset stats if it is a logical slot. Nothing to do for physical slots
     * as we collect stats only for logical slots.
     */
    if (SlotIsLogical(slot))
        pgstat_reset(PGSTAT_KIND_REPLSLOT, InvalidOid,
                     ReplicationSlotIndex(slot));
 
    LWLockRelease(ReplicationSlotControlLock);
}

References Assert(), ereport, errcode(), errmsg(), ERROR, InvalidOid, LW_SHARED, LWLockAcquire(), LWLockRelease(), name, PGSTAT_KIND_REPLSLOT, pgstat_reset(), ReplicationSlotIndex(), SearchNamedReplicationSlot(), and SlotIsLogical.

Referenced by pg_stat_reset_replication_slot().

◆ pgstat_reset_slru()

void pgstat_reset_slru ( const char * name )

Definition at line 45 of file pgstat_slru.c.

{
    TimestampTz ts = GetCurrentTimestamp();
 
    Assert(name != NULL);
 
    pgstat_reset_slru_counter_internal(pgstat_get_slru_index(name), ts);
}

References Assert(), GetCurrentTimestamp(), name, pgstat_get_slru_index(), and pgstat_reset_slru_counter_internal().

Referenced by pg_stat_reset_slru().

◆ pgstat_restore_stats()

void pgstat_restore_stats ( void )

Definition at line 504 of file pgstat.c.

506{

507 pgstat_read_statsfile();

pgstat_read_statsfile

static void pgstat_read_statsfile(void)

Definition: pgstat.c:1770

References pgstat_read_statsfile().

Referenced by StartupXLOG().

◆ pgstat_tracks_backend_bktype()

bool pgstat_tracks_backend_bktype ( BackendType bktype )

Definition at line 374 of file pgstat_backend.c.

{
    /*
     * List every type so that new backend types trigger a warning about
     * needing to adjust this switch.
     */
    switch (bktype)
    {
        case B_INVALID:
        case B_AUTOVAC_LAUNCHER:
        case B_DEAD_END_BACKEND:
        case B_ARCHIVER:
        case B_LOGGER:
        case B_BG_WRITER:
        case B_CHECKPOINTER:
        case B_IO_WORKER:
        case B_STARTUP:
            return false;
 
        case B_AUTOVAC_WORKER:
        case B_BACKEND:
        case B_BG_WORKER:
        case B_STANDALONE_BACKEND:
        case B_SLOTSYNC_WORKER:
        case B_WAL_RECEIVER:
        case B_WAL_SENDER:
        case B_WAL_SUMMARIZER:
        case B_WAL_WRITER:
            return true;
    }
 
    return false;
}

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

Referenced by pg_stat_reset_backend_stats(), pgstat_backend_have_pending_cb(), pgstat_bestart_final(), pgstat_count_backend_io_op(), pgstat_count_backend_io_op_time(), pgstat_fetch_stat_backend_by_pid(), and pgstat_flush_backend().

◆ pgstat_tracks_io_bktype()

bool pgstat_tracks_io_bktype ( BackendType bktype )

Definition at line 359 of file pgstat_io.c.

{
    /*
     * List every type so that new backend types trigger a warning about
     * needing to adjust this switch.
     */
    switch (bktype)
    {
        case B_INVALID:
        case B_DEAD_END_BACKEND:
        case B_ARCHIVER:
        case B_LOGGER:
            return false;
 
        case B_AUTOVAC_LAUNCHER:
        case B_AUTOVAC_WORKER:
        case B_BACKEND:
        case B_BG_WORKER:
        case B_BG_WRITER:
        case B_CHECKPOINTER:
        case B_IO_WORKER:
        case B_SLOTSYNC_WORKER:
        case B_STANDALONE_BACKEND:
        case B_STARTUP:
        case B_WAL_RECEIVER:
        case B_WAL_SENDER:
        case B_WAL_SUMMARIZER:
        case B_WAL_WRITER:
            return true;
    }
 
    return false;
}

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

Referenced by pg_stat_get_io(), and pgstat_tracks_io_object().

◆ pgstat_tracks_io_object()

bool pgstat_tracks_io_object	(	BackendType	bktype,
		IOObject	io_object,
		IOContext	io_context
	)

Definition at line 401 of file pgstat_io.c.

{
    bool        no_temp_rel;
 
    /*
     * Some BackendTypes should never track IO statistics.
     */
    if (!pgstat_tracks_io_bktype(bktype))
        return false;
 
    /*
     * Currently, IO on IOOBJECT_WAL objects can only occur in the
     * IOCONTEXT_NORMAL and IOCONTEXT_INIT IOContexts.
     */
    if (io_object == IOOBJECT_WAL &&
        (io_context != IOCONTEXT_NORMAL &&
         io_context != IOCONTEXT_INIT))
        return false;
 
    /*
     * Currently, IO on temporary relations can only occur in the
     * IOCONTEXT_NORMAL IOContext.
     */
    if (io_context != IOCONTEXT_NORMAL &&
        io_object == IOOBJECT_TEMP_RELATION)
        return false;
 
    /*
     * In core Postgres, only regular backends and WAL Sender processes
     * executing queries will use local buffers and operate on temporary
     * relations. Parallel workers will not use local buffers (see
     * InitLocalBuffers()); however, extensions leveraging background workers
     * have no such limitation, so track IO on IOOBJECT_TEMP_RELATION for
     * BackendType B_BG_WORKER.
     */
    no_temp_rel = bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
        bktype == B_CHECKPOINTER || bktype == B_AUTOVAC_WORKER ||
        bktype == B_STANDALONE_BACKEND || bktype == B_STARTUP ||
        bktype == B_WAL_SUMMARIZER || bktype == B_WAL_WRITER ||
        bktype == B_WAL_RECEIVER;
 
    if (no_temp_rel && io_context == IOCONTEXT_NORMAL &&
        io_object == IOOBJECT_TEMP_RELATION)
        return false;
 
    /*
     * Some BackendTypes only perform IO under IOOBJECT_WAL, hence exclude all
     * rows for all the other objects for these.
     */
    if ((bktype == B_WAL_SUMMARIZER || bktype == B_WAL_RECEIVER ||
         bktype == B_WAL_WRITER) && io_object != IOOBJECT_WAL)
        return false;
 
    /*
     * Some BackendTypes do not currently perform any IO in certain
     * IOContexts, and, while it may not be inherently incorrect for them to
     * do so, excluding those rows from the view makes the view easier to use.
     */
    if ((bktype == B_CHECKPOINTER || bktype == B_BG_WRITER) &&
        (io_context == IOCONTEXT_BULKREAD ||
         io_context == IOCONTEXT_BULKWRITE ||
         io_context == IOCONTEXT_VACUUM))
        return false;
 
    if (bktype == B_AUTOVAC_LAUNCHER && io_context == IOCONTEXT_VACUUM)
        return false;
 
    if ((bktype == B_AUTOVAC_WORKER || bktype == B_AUTOVAC_LAUNCHER) &&
        io_context == IOCONTEXT_BULKWRITE)
        return false;
 
    return true;
}

References B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_STANDALONE_BACKEND, B_STARTUP, B_WAL_RECEIVER, B_WAL_SUMMARIZER, B_WAL_WRITER, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_INIT, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, and pgstat_tracks_io_bktype().

Referenced by pg_stat_io_build_tuples(), and pgstat_tracks_io_op().

◆ pgstat_tracks_io_op()

bool pgstat_tracks_io_op	(	BackendType	bktype,
		IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op
	)

Definition at line 485 of file pgstat_io.c.

{
    bool        strategy_io_context;
 
    /* if (io_context, io_object) will never collect stats, we're done */
    if (!pgstat_tracks_io_object(bktype, io_object, io_context))
        return false;
 
    /*
     * Some BackendTypes will not do certain IOOps.
     */
    if (bktype == B_BG_WRITER &&
        (io_op == IOOP_READ || io_op == IOOP_EVICT || io_op == IOOP_HIT))
        return false;
 
    if (bktype == B_CHECKPOINTER &&
        ((io_object != IOOBJECT_WAL && io_op == IOOP_READ) ||
         (io_op == IOOP_EVICT || io_op == IOOP_HIT)))
        return false;
 
    if ((bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
         bktype == B_CHECKPOINTER) && io_op == IOOP_EXTEND)
        return false;
 
    /*
     * Some BackendTypes do not perform reads with IOOBJECT_WAL.
     */
    if (io_object == IOOBJECT_WAL && io_op == IOOP_READ &&
        (bktype == B_WAL_RECEIVER || bktype == B_BG_WRITER ||
         bktype == B_AUTOVAC_LAUNCHER || bktype == B_AUTOVAC_WORKER ||
         bktype == B_WAL_WRITER))
        return false;
 
    /*
     * Temporary tables are not logged and thus do not require fsync'ing.
     * Writeback is not requested for temporary tables.
     */
    if (io_object == IOOBJECT_TEMP_RELATION &&
        (io_op == IOOP_FSYNC || io_op == IOOP_WRITEBACK))
        return false;
 
    /*
     * Some IOOps are not valid in certain IOContexts and some IOOps are only
     * valid in certain contexts.
     */
    if (io_context == IOCONTEXT_BULKREAD && io_op == IOOP_EXTEND)
        return false;
 
    strategy_io_context = io_context == IOCONTEXT_BULKREAD ||
        io_context == IOCONTEXT_BULKWRITE || io_context == IOCONTEXT_VACUUM;
 
    /*
     * IOOP_REUSE is only relevant when a BufferAccessStrategy is in use.
     */
    if (!strategy_io_context && io_op == IOOP_REUSE)
        return false;
 
    /*
     * IOOBJECT_WAL IOObject will not do certain IOOps depending on IOContext.
     */
    if (io_object == IOOBJECT_WAL && io_context == IOCONTEXT_INIT &&
        !(io_op == IOOP_WRITE || io_op == IOOP_FSYNC))
        return false;
 
    if (io_object == IOOBJECT_WAL && io_context == IOCONTEXT_NORMAL &&
        !(io_op == IOOP_WRITE || io_op == IOOP_READ || io_op == IOOP_FSYNC))
        return false;
 
    /*
     * IOOP_FSYNC IOOps done by a backend using a BufferAccessStrategy are
     * counted in the IOCONTEXT_NORMAL IOContext. See comment in
     * register_dirty_segment() for more details.
     */
    if (strategy_io_context && io_op == IOOP_FSYNC)
        return false;
 
 
    return true;
}

References B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_WAL_RECEIVER, B_WAL_WRITER, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_INIT, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, IOOP_EVICT, IOOP_EXTEND, IOOP_FSYNC, IOOP_HIT, IOOP_READ, IOOP_REUSE, IOOP_WRITE, IOOP_WRITEBACK, and pgstat_tracks_io_object().

Referenced by pg_stat_io_build_tuples(), pgstat_bktype_io_stats_valid(), pgstat_count_backend_io_op(), pgstat_count_backend_io_op_time(), and pgstat_count_io_op().

◆ pgstat_twophase_postabort()

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

Definition at line 783 of file pgstat_relation.c.

{
    TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
    PgStat_TableStatus *pgstat_info;
 
    /* Find or create a tabstat entry for the rel */
    pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
 
    /* Same math as in AtEOXact_PgStat, abort case */
    if (rec->truncdropped)
    {
        rec->tuples_inserted = rec->inserted_pre_truncdrop;
        rec->tuples_updated = rec->updated_pre_truncdrop;
        rec->tuples_deleted = rec->deleted_pre_truncdrop;
    }
    pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
    pgstat_info->counts.tuples_updated += rec->tuples_updated;
    pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
    pgstat_info->counts.delta_dead_tuples +=
        rec->tuples_inserted + rec->tuples_updated;
}

References PgStat_TableStatus::counts, TwoPhasePgStatRecord::deleted_pre_truncdrop, PgStat_TableCounts::delta_dead_tuples, TwoPhasePgStatRecord::id, TwoPhasePgStatRecord::inserted_pre_truncdrop, pgstat_prep_relation_pending(), TwoPhasePgStatRecord::shared, TwoPhasePgStatRecord::truncdropped, TwoPhasePgStatRecord::tuples_deleted, PgStat_TableCounts::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, PgStat_TableCounts::tuples_inserted, TwoPhasePgStatRecord::tuples_updated, PgStat_TableCounts::tuples_updated, and TwoPhasePgStatRecord::updated_pre_truncdrop.

◆ pgstat_twophase_postcommit()

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

Definition at line 747 of file pgstat_relation.c.

{
    TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
    PgStat_TableStatus *pgstat_info;
 
    /* Find or create a tabstat entry for the rel */
    pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
 
    /* Same math as in AtEOXact_PgStat, commit case */
    pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
    pgstat_info->counts.tuples_updated += rec->tuples_updated;
    pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
    pgstat_info->counts.truncdropped = rec->truncdropped;
    if (rec->truncdropped)
    {
        /* forget live/dead stats seen by backend thus far */
        pgstat_info->counts.delta_live_tuples = 0;
        pgstat_info->counts.delta_dead_tuples = 0;
    }
    pgstat_info->counts.delta_live_tuples +=
        rec->tuples_inserted - rec->tuples_deleted;
    pgstat_info->counts.delta_dead_tuples +=
        rec->tuples_updated + rec->tuples_deleted;
    pgstat_info->counts.changed_tuples +=
        rec->tuples_inserted + rec->tuples_updated +
        rec->tuples_deleted;
}

References PgStat_TableCounts::changed_tuples, PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, PgStat_TableCounts::delta_live_tuples, TwoPhasePgStatRecord::id, pgstat_prep_relation_pending(), TwoPhasePgStatRecord::shared, TwoPhasePgStatRecord::truncdropped, PgStat_TableCounts::truncdropped, TwoPhasePgStatRecord::tuples_deleted, PgStat_TableCounts::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, PgStat_TableCounts::tuples_inserted, TwoPhasePgStatRecord::tuples_updated, and PgStat_TableCounts::tuples_updated.

◆ pgstat_unlink_relation()

void pgstat_unlink_relation ( Relation rel )

Definition at line 152 of file pgstat_relation.c.

{
    /* remove the link to stats info if any */
    if (rel->pgstat_info == NULL)
        return;
 
    /* link sanity check */
    Assert(rel->pgstat_info->relation == rel);
    rel->pgstat_info->relation = NULL;
    rel->pgstat_info = NULL;
}

References Assert(), RelationData::pgstat_info, and PgStat_TableStatus::relation.

Referenced by pgstat_init_relation(), pgstat_relation_delete_pending_cb(), and RelationDestroyRelation().

◆ pgstat_update_heap_dead_tuples()

void pgstat_update_heap_dead_tuples	(	Relation	rel,
		int	delta
	)

Definition at line 453 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        pgstat_info->counts.delta_dead_tuples -= delta;
    }
}

References PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, RelationData::pgstat_info, and pgstat_should_count_relation.

Referenced by heap_page_prune_opt().

◆ pgstat_update_parallel_workers_stats()

void pgstat_update_parallel_workers_stats	(	PgStat_Counter	workers_to_launch,
		PgStat_Counter	workers_launched
	)

Definition at line 305 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbentry;
 
    if (!OidIsValid(MyDatabaseId))
        return;
 
    dbentry = pgstat_prep_database_pending(MyDatabaseId);
    dbentry->parallel_workers_to_launch += workers_to_launch;
    dbentry->parallel_workers_launched += workers_launched;
}

References MyDatabaseId, OidIsValid, PgStat_StatDBEntry::parallel_workers_launched, PgStat_StatDBEntry::parallel_workers_to_launch, and pgstat_prep_database_pending().

Referenced by standard_ExecutorEnd().

◆ PostPrepare_PgStat()

void PostPrepare_PgStat ( void )

Definition at line 211 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state;
 
    /*
     * 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)
    {
        Assert(xact_state->nest_level == 1);
        Assert(xact_state->prev == NULL);
 
        PostPrepare_PgStat_Relations(xact_state);
    }
    pgStatXactStack = NULL;
 
    /* Make sure any stats snapshot is thrown away */
    pgstat_clear_snapshot();
}

References Assert(), PgStat_SubXactStatus::nest_level, pgstat_clear_snapshot(), pgStatXactStack, PostPrepare_PgStat_Relations(), and PgStat_SubXactStatus::prev.

Referenced by PrepareTransaction().

◆ StatsShmemInit()

void StatsShmemInit ( void )

Definition at line 156 of file pgstat_shmem.c.

{
    bool        found;
    Size        sz;
 
    sz = StatsShmemSize();
    pgStatLocal.shmem = (PgStat_ShmemControl *)
        ShmemInitStruct("Shared Memory Stats", sz, &found);
 
    if (!IsUnderPostmaster)
    {
        dsa_area   *dsa;
        dshash_table *dsh;
        PgStat_ShmemControl *ctl = pgStatLocal.shmem;
        char       *p = (char *) ctl;
 
        Assert(!found);
 
        /* the allocation of pgStatLocal.shmem itself */
        p += MAXALIGN(sizeof(PgStat_ShmemControl));
 
        /*
         * Create a small dsa allocation in plain shared memory. This is
         * required because postmaster cannot use dsm segments. It also
         * provides a small efficiency win.
         */
        ctl->raw_dsa_area = p;
        p += MAXALIGN(pgstat_dsa_init_size());
        dsa = dsa_create_in_place(ctl->raw_dsa_area,
                                  pgstat_dsa_init_size(),
                                  LWTRANCHE_PGSTATS_DSA, 0);
        dsa_pin(dsa);
 
        /*
         * To ensure dshash is created in "plain" shared memory, temporarily
         * limit size of dsa to the initial size of the dsa.
         */
        dsa_set_size_limit(dsa, pgstat_dsa_init_size());
 
        /*
         * With the limit in place, create the dshash table. XXX: It'd be nice
         * if there were dshash_create_in_place().
         */
        dsh = dshash_create(dsa, &dsh_params, NULL);
        ctl->hash_handle = dshash_get_hash_table_handle(dsh);
 
        /* lift limit set above */
        dsa_set_size_limit(dsa, -1);
 
        /*
         * Postmaster will never access these again, thus free the local
         * dsa/dshash references.
         */
        dshash_detach(dsh);
        dsa_detach(dsa);
 
        pg_atomic_init_u64(&ctl->gc_request_count, 1);
 
        /* initialize fixed-numbered stats */
        for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
        {
            const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
            char       *ptr;
 
            if (!kind_info || !kind_info->fixed_amount)
                continue;
 
            if (pgstat_is_kind_builtin(kind))
                ptr = ((char *) ctl) + kind_info->shared_ctl_off;
            else
            {
                int         idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
                Assert(kind_info->shared_size != 0);
                ctl->custom_data[idx] = ShmemAlloc(kind_info->shared_size);
                ptr = ctl->custom_data[idx];
            }
 
            kind_info->init_shmem_cb(ptr);
        }
    }
    else
    {
        Assert(found);
    }
}

References Assert(), ctl, dsa_create_in_place, dsa_detach(), dsa_pin(), dsa_set_size_limit(), dsh_params, dshash_create(), dshash_detach(), dshash_get_hash_table_handle(), PgStat_KindInfo::fixed_amount, idx(), PgStat_KindInfo::init_shmem_cb, IsUnderPostmaster, LWTRANCHE_PGSTATS_DSA, MAXALIGN, pg_atomic_init_u64(), pgstat_dsa_init_size(), pgstat_get_kind_info(), pgstat_is_kind_builtin(), PgStat_Kind, PGSTAT_KIND_CUSTOM_MIN, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, pgStatLocal, PgStat_KindInfo::shared_ctl_off, PgStat_KindInfo::shared_size, PgStat_LocalState::shmem, ShmemAlloc(), ShmemInitStruct(), and StatsShmemSize().

Referenced by CreateOrAttachShmemStructs().

◆ StatsShmemSize()

Size StatsShmemSize ( void )

Definition at line 127 of file pgstat_shmem.c.

{
    Size        sz;
 
    sz = MAXALIGN(sizeof(PgStat_ShmemControl));
    sz = add_size(sz, pgstat_dsa_init_size());
 
    /* Add shared memory for all the custom fixed-numbered statistics */
    for (PgStat_Kind kind = PGSTAT_KIND_CUSTOM_MIN; kind <= PGSTAT_KIND_CUSTOM_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (!kind_info)
            continue;
        if (!kind_info->fixed_amount)
            continue;
 
        Assert(kind_info->shared_size != 0);
 
        sz += MAXALIGN(kind_info->shared_size);
    }
 
    return sz;
}

References add_size(), Assert(), PgStat_KindInfo::fixed_amount, MAXALIGN, pgstat_dsa_init_size(), pgstat_get_kind_info(), PgStat_Kind, PGSTAT_KIND_CUSTOM_MAX, PGSTAT_KIND_CUSTOM_MIN, and PgStat_KindInfo::shared_size.

Referenced by CalculateShmemSize(), and StatsShmemInit().

Variable Documentation

◆ PendingBgWriterStats

PGDLLIMPORT PgStat_BgWriterStats PendingBgWriterStats

extern

Definition at line 24 of file pgstat_bgwriter.c.

Referenced by BgBufferSync(), and pgstat_report_bgwriter().

◆ PendingCheckpointerStats

PGDLLIMPORT PgStat_CheckpointerStats PendingCheckpointerStats

extern

Definition at line 24 of file pgstat_checkpointer.c.

Referenced by BufferSync(), CheckpointerMain(), LogCheckpointEnd(), pgstat_report_checkpointer(), and SlruInternalWritePage().

◆ pgstat_fetch_consistency

PGDLLIMPORT int pgstat_fetch_consistency

extern

Definition at line 204 of file pgstat.c.

Referenced by assign_stats_fetch_consistency(), pgstat_build_snapshot(), pgstat_build_snapshot_fixed(), pgstat_fetch_entry(), pgstat_prep_snapshot(), pgstat_snapshot_fixed(), and pgstat_write_statsfile().

◆ pgstat_track_counts

PGDLLIMPORT bool pgstat_track_counts

extern

Definition at line 203 of file pgstat.c.

Referenced by autovac_init(), AutoVacuumingActive(), pgstat_init_relation(), pgstat_report_analyze(), pgstat_report_checksum_failures_in_db(), pgstat_report_deadlock(), pgstat_report_recovery_conflict(), pgstat_report_tempfile(), and pgstat_report_vacuum().

◆ pgstat_track_functions

PGDLLIMPORT int pgstat_track_functions

extern

Definition at line 30 of file pgstat_function.c.

◆ pgStatActiveTime

PGDLLIMPORT PgStat_Counter pgStatActiveTime

extern

Definition at line 30 of file pgstat_database.c.

Referenced by pgstat_update_dbstats().

◆ pgStatBlockReadTime

PGDLLIMPORT PgStat_Counter pgStatBlockReadTime

extern

Definition at line 28 of file pgstat_database.c.

Referenced by do_analyze_rel(), heap_vacuum_rel(), and pgstat_update_dbstats().

◆ pgStatBlockWriteTime

PGDLLIMPORT PgStat_Counter pgStatBlockWriteTime

extern

Definition at line 29 of file pgstat_database.c.

Referenced by do_analyze_rel(), heap_vacuum_rel(), and pgstat_update_dbstats().

◆ pgStatSessionEndCause

PGDLLIMPORT SessionEndType pgStatSessionEndCause

extern

Definition at line 32 of file pgstat_database.c.

Referenced by die(), errfinish(), pgstat_report_disconnect(), and PostgresMain().

◆ pgStatTransactionIdleTime

PGDLLIMPORT PgStat_Counter pgStatTransactionIdleTime

extern

Definition at line 31 of file pgstat_database.c.

Referenced by pgstat_update_dbstats().

Variables
PGDLLIMPORT bool	pgstat_track_counts

PGDLLIMPORT int	pgstat_track_functions

PGDLLIMPORT int	pgstat_fetch_consistency

PGDLLIMPORT PgStat_BgWriterStats	PendingBgWriterStats

PGDLLIMPORT PgStat_CheckpointerStats	PendingCheckpointerStats

PGDLLIMPORT PgStat_Counter	pgStatBlockReadTime

PGDLLIMPORT PgStat_Counter	pgStatBlockWriteTime

PGDLLIMPORT PgStat_Counter	pgStatActiveTime

PGDLLIMPORT PgStat_Counter	pgStatTransactionIdleTime

PGDLLIMPORT SessionEndType	pgStatSessionEndCause

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ IOCONTEXT_NUM_TYPES

◆ IOOBJECT_NUM_TYPES

◆ IOOP_NUM_TYPES

◆ PG_STAT_TMP_DIR

◆ pgstat_count_buffer_hit

◆ pgstat_count_buffer_read

◆ pgstat_count_buffer_read_time

◆ pgstat_count_buffer_write_time

◆ pgstat_count_conn_active_time

◆ pgstat_count_conn_txn_idle_time

◆ pgstat_count_heap_fetch

◆ pgstat_count_heap_getnext

◆ pgstat_count_heap_scan

◆ pgstat_count_index_scan

◆ pgstat_count_index_tuples

◆ PGSTAT_FILE_FORMAT_ID

◆ pgstat_is_ioop_tracked_in_bytes

◆ pgstat_should_count_relation

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

◆ PGSTAT_STAT_PERMANENT_FILENAME

◆ PGSTAT_STAT_PERMANENT_TMPFILE

Typedef Documentation

◆ IOContext

◆ IOObject

◆ IOOp

◆ PgStat_ArchiverStats

◆ PgStat_Backend

◆ PgStat_BackendPending

◆ PgStat_BackendSubEntry

◆ PgStat_BgWriterStats

◆ PgStat_BktypeIO

◆ PgStat_CheckpointerStats

◆ PgStat_Counter

◆ PgStat_FetchConsistency

◆ PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

◆ PgStat_IO

◆ PgStat_PendingIO

◆ PgStat_SLRUStats

◆ PgStat_StatDBEntry

◆ PgStat_StatFuncEntry

◆ PgStat_StatReplSlotEntry

◆ PgStat_StatSubEntry

◆ PgStat_StatTabEntry

◆ PgStat_TableCounts

◆ PgStat_TableStatus

◆ PgStat_TableXactStatus

◆ PgStat_WalCounters

◆ PgStat_WalStats

◆ SessionEndType

◆ TrackFunctionsLevel

Enumeration Type Documentation

◆ IOContext

◆ IOObject

◆ IOOp

◆ PgStat_FetchConsistency

◆ SessionEndType

◆ TrackFunctionsLevel

Function Documentation

◆ AtEOSubXact_PgStat()

◆ AtEOXact_PgStat()

◆ AtPrepare_PgStat()

◆ find_funcstat_entry()

◆ find_tabstat_entry()

◆ pgstat_acquire_replslot()

◆ pgstat_assoc_relation()

◆ pgstat_before_server_shutdown()

◆ pgstat_bktype_io_stats_valid()

◆ pgstat_clear_snapshot()

◆ pgstat_copy_relation_stats()

◆ pgstat_count_backend_io_op()

◆ pgstat_count_backend_io_op_time()

◆ pgstat_count_heap_delete()