pgstat_internal.h File Reference

#include "common/hashfn_unstable.h"
#include "lib/dshash.h"
#include "lib/ilist.h"
#include "pgstat.h"
#include "storage/lwlock.h"
#include "utils/dsa.h"

Include dependency graph for pgstat_internal.h:

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

Go to the source code of this file.

Data Structures
struct	PgStat_HashKey
struct	PgStatShared_HashEntry
struct	PgStatShared_Common
struct	PgStat_EntryRef
struct	PgStat_SubXactStatus
struct	PgStat_KindInfo
struct	PgStatShared_Archiver
struct	PgStatShared_BgWriter
struct	PgStatShared_Checkpointer
struct	PgStatShared_IO
struct	PgStatShared_SLRU
struct	PgStatShared_Wal
struct	PgStatShared_Database
struct	PgStatShared_Relation
struct	PgStatShared_Function
struct	PgStatShared_Subscription
struct	PgStatShared_ReplSlot
struct	PgStatShared_Backend
struct	PgStat_ShmemControl
struct	PgStat_Snapshot
struct	PgStat_LocalState

Macros
#define	SLRU_NUM_ELEMENTS   lengthof(slru_names)
#define	pgstat_assert_is_up()   ((void)true)
#define	PGSTAT_BACKEND_FLUSH_IO   (1 << 0) /* Flush I/O statistics */
#define	PGSTAT_BACKEND_FLUSH_WAL   (1 << 1) /* Flush WAL statistics */
#define	PGSTAT_BACKEND_FLUSH_ALL   (PGSTAT_BACKEND_FLUSH_IO | PGSTAT_BACKEND_FLUSH_WAL)

Typedefs
typedef struct PgStat_HashKey	PgStat_HashKey
typedef struct PgStatShared_HashEntry	PgStatShared_HashEntry
typedef struct PgStatShared_Common	PgStatShared_Common
typedef struct PgStat_EntryRef	PgStat_EntryRef
typedef struct PgStat_SubXactStatus	PgStat_SubXactStatus
typedef struct PgStat_KindInfo	PgStat_KindInfo
typedef struct PgStatShared_Archiver	PgStatShared_Archiver
typedef struct PgStatShared_BgWriter	PgStatShared_BgWriter
typedef struct PgStatShared_Checkpointer	PgStatShared_Checkpointer
typedef struct PgStatShared_IO	PgStatShared_IO
typedef struct PgStatShared_SLRU	PgStatShared_SLRU
typedef struct PgStatShared_Wal	PgStatShared_Wal
typedef struct PgStatShared_Database	PgStatShared_Database
typedef struct PgStatShared_Relation	PgStatShared_Relation
typedef struct PgStatShared_Function	PgStatShared_Function
typedef struct PgStatShared_Subscription	PgStatShared_Subscription
typedef struct PgStatShared_ReplSlot	PgStatShared_ReplSlot
typedef struct PgStatShared_Backend	PgStatShared_Backend
typedef struct PgStat_ShmemControl	PgStat_ShmemControl
typedef struct PgStat_Snapshot	PgStat_Snapshot
typedef struct PgStat_LocalState	PgStat_LocalState

Functions
static void	pgstat_begin_changecount_write (uint32 *cc)
static void	pgstat_end_changecount_write (uint32 *cc)
static uint32	pgstat_begin_changecount_read (uint32 *cc)
static bool	pgstat_end_changecount_read (uint32 *cc, uint32 cc_before)
static void	pgstat_copy_changecounted_stats (void *dst, void *src, size_t len, uint32 *cc)
static int	pgstat_cmp_hash_key (const void *a, const void *b, size_t size, void *arg)
static uint32	pgstat_hash_hash_key (const void *d, size_t size, void *arg)
static size_t	pgstat_get_entry_len (PgStat_Kind kind)
static void *	pgstat_get_entry_data (PgStat_Kind kind, PgStatShared_Common *entry)
static void *	pgstat_get_custom_shmem_data (PgStat_Kind kind)
static void *	pgstat_get_custom_snapshot_data (PgStat_Kind kind)
const PgStat_KindInfo *	pgstat_get_kind_info (PgStat_Kind kind)
void	pgstat_register_kind (PgStat_Kind kind, const PgStat_KindInfo *kind_info)
void	pgstat_delete_pending_entry (PgStat_EntryRef *entry_ref)
PgStat_EntryRef *	pgstat_prep_pending_entry (PgStat_Kind kind, Oid dboid, uint64 objid, bool *created_entry)
PgStat_EntryRef *	pgstat_fetch_pending_entry (PgStat_Kind kind, Oid dboid, uint64 objid)
void *	pgstat_fetch_entry (PgStat_Kind kind, Oid dboid, uint64 objid)
void	pgstat_snapshot_fixed (PgStat_Kind kind)
void	pgstat_archiver_init_shmem_cb (void *stats)
void	pgstat_archiver_reset_all_cb (TimestampTz ts)
void	pgstat_archiver_snapshot_cb (void)
bool	pgstat_flush_backend (bool nowait, bits32 flags)
bool	pgstat_backend_flush_cb (bool nowait)
bool	pgstat_backend_have_pending_cb (void)
void	pgstat_backend_reset_timestamp_cb (PgStatShared_Common *header, TimestampTz ts)
void	pgstat_bgwriter_init_shmem_cb (void *stats)
void	pgstat_bgwriter_reset_all_cb (TimestampTz ts)
void	pgstat_bgwriter_snapshot_cb (void)
void	pgstat_checkpointer_init_shmem_cb (void *stats)
void	pgstat_checkpointer_reset_all_cb (TimestampTz ts)
void	pgstat_checkpointer_snapshot_cb (void)
void	pgstat_report_disconnect (Oid dboid)
void	pgstat_update_dbstats (TimestampTz ts)
void	AtEOXact_PgStat_Database (bool isCommit, bool parallel)
PgStat_StatDBEntry *	pgstat_prep_database_pending (Oid dboid)
void	pgstat_reset_database_timestamp (Oid dboid, TimestampTz ts)
bool	pgstat_database_flush_cb (PgStat_EntryRef *entry_ref, bool nowait)
void	pgstat_database_reset_timestamp_cb (PgStatShared_Common *header, TimestampTz ts)
bool	pgstat_function_flush_cb (PgStat_EntryRef *entry_ref, bool nowait)
void	pgstat_flush_io (bool nowait)
bool	pgstat_io_have_pending_cb (void)
bool	pgstat_io_flush_cb (bool nowait)
void	pgstat_io_init_shmem_cb (void *stats)
void	pgstat_io_reset_all_cb (TimestampTz ts)
void	pgstat_io_snapshot_cb (void)
void	AtEOXact_PgStat_Relations (PgStat_SubXactStatus *xact_state, bool isCommit)
void	AtEOSubXact_PgStat_Relations (PgStat_SubXactStatus *xact_state, bool isCommit, int nestDepth)
void	AtPrepare_PgStat_Relations (PgStat_SubXactStatus *xact_state)
void	PostPrepare_PgStat_Relations (PgStat_SubXactStatus *xact_state)
bool	pgstat_relation_flush_cb (PgStat_EntryRef *entry_ref, bool nowait)
void	pgstat_relation_delete_pending_cb (PgStat_EntryRef *entry_ref)
void	pgstat_replslot_reset_timestamp_cb (PgStatShared_Common *header, TimestampTz ts)
void	pgstat_replslot_to_serialized_name_cb (const PgStat_HashKey *key, const PgStatShared_Common *header, NameData *name)
bool	pgstat_replslot_from_serialized_name_cb (const NameData *name, PgStat_HashKey *key)
void	pgstat_attach_shmem (void)
void	pgstat_detach_shmem (void)
PgStat_EntryRef *	pgstat_get_entry_ref (PgStat_Kind kind, Oid dboid, uint64 objid, bool create, bool *created_entry)
bool	pgstat_lock_entry (PgStat_EntryRef *entry_ref, bool nowait)
bool	pgstat_lock_entry_shared (PgStat_EntryRef *entry_ref, bool nowait)
void	pgstat_unlock_entry (PgStat_EntryRef *entry_ref)
bool	pgstat_drop_entry (PgStat_Kind kind, Oid dboid, uint64 objid)
void	pgstat_drop_all_entries (void)
void	pgstat_drop_matching_entries (bool(*do_drop)(PgStatShared_HashEntry *, Datum), Datum match_data)
PgStat_EntryRef *	pgstat_get_entry_ref_locked (PgStat_Kind kind, Oid dboid, uint64 objid, bool nowait)
void	pgstat_reset_entry (PgStat_Kind kind, Oid dboid, uint64 objid, TimestampTz ts)
void	pgstat_reset_entries_of_kind (PgStat_Kind kind, TimestampTz ts)
void	pgstat_reset_matching_entries (bool(*do_reset)(PgStatShared_HashEntry *, Datum), Datum match_data, TimestampTz ts)
void	pgstat_request_entry_refs_gc (void)
PgStatShared_Common *	pgstat_init_entry (PgStat_Kind kind, PgStatShared_HashEntry *shhashent)
bool	pgstat_slru_have_pending_cb (void)
bool	pgstat_slru_flush_cb (bool nowait)
void	pgstat_slru_init_shmem_cb (void *stats)
void	pgstat_slru_reset_all_cb (TimestampTz ts)
void	pgstat_slru_snapshot_cb (void)
void	pgstat_wal_init_backend_cb (void)
bool	pgstat_wal_have_pending_cb (void)
bool	pgstat_wal_flush_cb (bool nowait)
void	pgstat_wal_init_shmem_cb (void *stats)
void	pgstat_wal_reset_all_cb (TimestampTz ts)
void	pgstat_wal_snapshot_cb (void)
bool	pgstat_subscription_flush_cb (PgStat_EntryRef *entry_ref, bool nowait)
void	pgstat_subscription_reset_timestamp_cb (PgStatShared_Common *header, TimestampTz ts)
PgStat_SubXactStatus *	pgstat_get_xact_stack_level (int nest_level)
void	pgstat_drop_transactional (PgStat_Kind kind, Oid dboid, uint64 objid)
void	pgstat_create_transactional (PgStat_Kind kind, Oid dboid, uint64 objid)

Variables
static const char *const	slru_names []
PGDLLIMPORT PgStat_LocalState	pgStatLocal

Macro Definition Documentation

pgstat_assert_is_up

#define pgstat_assert_is_up

(

)

((void)true)

Definition at line 597 of file pgstat_internal.h.

PGSTAT_BACKEND_FLUSH_ALL

#define PGSTAT_BACKEND_FLUSH_ALL   (PGSTAT_BACKEND_FLUSH_IO | PGSTAT_BACKEND_FLUSH_WAL)

Definition at line 626 of file pgstat_internal.h.

PGSTAT_BACKEND_FLUSH_IO

#define PGSTAT_BACKEND_FLUSH_IO   (1 << 0) /* Flush I/O statistics */

Definition at line 624 of file pgstat_internal.h.

PGSTAT_BACKEND_FLUSH_WAL

#define PGSTAT_BACKEND_FLUSH_WAL   (1 << 1) /* Flush WAL statistics */

Definition at line 625 of file pgstat_internal.h.

SLRU_NUM_ELEMENTS

#define SLRU_NUM_ELEMENTS   lengthof(slru_names)

Definition at line 345 of file pgstat_internal.h.

Typedef Documentation

PgStat_EntryRef

typedef struct PgStat_EntryRef PgStat_EntryRef

PgStat_HashKey

typedef struct PgStat_HashKey PgStat_HashKey

PgStat_KindInfo

typedef struct PgStat_KindInfo PgStat_KindInfo

PgStat_LocalState

typedef struct PgStat_LocalState PgStat_LocalState

PgStat_ShmemControl

typedef struct PgStat_ShmemControl PgStat_ShmemControl

PgStat_Snapshot

typedef struct PgStat_Snapshot PgStat_Snapshot

PgStat_SubXactStatus

typedef struct PgStat_SubXactStatus PgStat_SubXactStatus

PgStatShared_Archiver

typedef struct PgStatShared_Archiver PgStatShared_Archiver

PgStatShared_Backend

typedef struct PgStatShared_Backend PgStatShared_Backend

PgStatShared_BgWriter

typedef struct PgStatShared_BgWriter PgStatShared_BgWriter

PgStatShared_Checkpointer

typedef struct PgStatShared_Checkpointer PgStatShared_Checkpointer

PgStatShared_Common

typedef struct PgStatShared_Common PgStatShared_Common

PgStatShared_Database

typedef struct PgStatShared_Database PgStatShared_Database

PgStatShared_Function

typedef struct PgStatShared_Function PgStatShared_Function

PgStatShared_HashEntry

typedef struct PgStatShared_HashEntry PgStatShared_HashEntry

PgStatShared_IO

typedef struct PgStatShared_IO PgStatShared_IO

PgStatShared_Relation

typedef struct PgStatShared_Relation PgStatShared_Relation

PgStatShared_ReplSlot

typedef struct PgStatShared_ReplSlot PgStatShared_ReplSlot

PgStatShared_SLRU

typedef struct PgStatShared_SLRU PgStatShared_SLRU

PgStatShared_Subscription

typedef struct PgStatShared_Subscription PgStatShared_Subscription

PgStatShared_Wal

typedef struct PgStatShared_Wal PgStatShared_Wal

Function Documentation

AtEOSubXact_PgStat_Relations()

void AtEOSubXact_PgStat_Relations	(	PgStat_SubXactStatus *	xact_state,
		bool	isCommit,
		int	nestDepth
	)

Definition at line 609 of file pgstat_relation.c.

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

References Assert(), PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, PgStat_SubXactStatus::first, pfree(), pgstat_get_xact_stack_level(), restore_truncdrop_counters(), save_truncdrop_counters(), PgStat_TableStatus::trans, trans, PgStat_TableCounts::tuples_deleted, PgStat_TableCounts::tuples_inserted, and PgStat_TableCounts::tuples_updated.

Referenced by AtEOSubXact_PgStat().

AtEOXact_PgStat_Database()

void AtEOXact_PgStat_Database	(	bool	isCommit,
		bool	parallel
	)

Definition at line 285 of file pgstat_database.c.

{
    /* Don't count parallel worker transaction stats */
    if (!parallel)
    {
        /*
         * Count transaction commit or abort.  (We use counters, not just
         * bools, in case the reporting message isn't sent right away.)
         */
        if (isCommit)
            pgStatXactCommit++;
        else
            pgStatXactRollback++;
    }
}

References pgStatXactCommit, and pgStatXactRollback.

Referenced by AtEOXact_PgStat().

AtEOXact_PgStat_Relations()

void AtEOXact_PgStat_Relations	(	PgStat_SubXactStatus *	xact_state,
		bool	isCommit
	)

Definition at line 551 of file pgstat_relation.c.

{
    PgStat_TableXactStatus *trans;
 
    for (trans = xact_state->first; trans != NULL; trans = trans->next)
    {
        PgStat_TableStatus *tabstat;
 
        Assert(trans->nest_level == 1);
        Assert(trans->upper == NULL);
        tabstat = trans->parent;
        Assert(tabstat->trans == trans);
        /* restore pre-truncate/drop stats (if any) in case of aborted xact */
        if (!isCommit)
            restore_truncdrop_counters(trans);
        /* count attempted actions regardless of commit/abort */
        tabstat->counts.tuples_inserted += trans->tuples_inserted;
        tabstat->counts.tuples_updated += trans->tuples_updated;
        tabstat->counts.tuples_deleted += trans->tuples_deleted;
        if (isCommit)
        {
            tabstat->counts.truncdropped = trans->truncdropped;
            if (trans->truncdropped)
            {
                /* forget live/dead stats seen by backend thus far */
                tabstat->counts.delta_live_tuples = 0;
                tabstat->counts.delta_dead_tuples = 0;
            }
            /* insert adds a live tuple, delete removes one */
            tabstat->counts.delta_live_tuples +=
                trans->tuples_inserted - trans->tuples_deleted;
            /* update and delete each create a dead tuple */
            tabstat->counts.delta_dead_tuples +=
                trans->tuples_updated + trans->tuples_deleted;
            /* insert, update, delete each count as one change event */
            tabstat->counts.changed_tuples +=
                trans->tuples_inserted + trans->tuples_updated +
                trans->tuples_deleted;
        }
        else
        {
            /* inserted tuples are dead, deleted tuples are unaffected */
            tabstat->counts.delta_dead_tuples +=
                trans->tuples_inserted + trans->tuples_updated;
            /* an aborted xact generates no changed_tuple events */
        }
        tabstat->trans = NULL;
    }
}

References Assert(), PgStat_TableCounts::changed_tuples, PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, PgStat_TableCounts::delta_live_tuples, PgStat_SubXactStatus::first, restore_truncdrop_counters(), PgStat_TableStatus::trans, trans, PgStat_TableCounts::truncdropped, PgStat_TableCounts::tuples_deleted, PgStat_TableCounts::tuples_inserted, and PgStat_TableCounts::tuples_updated.

Referenced by AtEOXact_PgStat().

AtPrepare_PgStat_Relations()

void AtPrepare_PgStat_Relations

(

PgStat_SubXactStatus *

xact_state

)

Definition at line 690 of file pgstat_relation.c.

{
    PgStat_TableXactStatus *trans;
 
    for (trans = xact_state->first; trans != NULL; trans = trans->next)
    {
        PgStat_TableStatus *tabstat PG_USED_FOR_ASSERTS_ONLY;
        TwoPhasePgStatRecord record;
 
        Assert(trans->nest_level == 1);
        Assert(trans->upper == NULL);
        tabstat = trans->parent;
        Assert(tabstat->trans == trans);
 
        record.tuples_inserted = trans->tuples_inserted;
        record.tuples_updated = trans->tuples_updated;
        record.tuples_deleted = trans->tuples_deleted;
        record.inserted_pre_truncdrop = trans->inserted_pre_truncdrop;
        record.updated_pre_truncdrop = trans->updated_pre_truncdrop;
        record.deleted_pre_truncdrop = trans->deleted_pre_truncdrop;
        record.id = tabstat->id;
        record.shared = tabstat->shared;
        record.truncdropped = trans->truncdropped;
 
        RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
                               &record, sizeof(TwoPhasePgStatRecord));
    }
}

References Assert(), TwoPhasePgStatRecord::deleted_pre_truncdrop, PgStat_SubXactStatus::first, TwoPhasePgStatRecord::id, TwoPhasePgStatRecord::inserted_pre_truncdrop, PG_USED_FOR_ASSERTS_ONLY, RegisterTwoPhaseRecord(), TwoPhasePgStatRecord::shared, trans, TwoPhasePgStatRecord::truncdropped, TwoPhasePgStatRecord::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, TwoPhasePgStatRecord::tuples_updated, TWOPHASE_RM_PGSTAT_ID, and TwoPhasePgStatRecord::updated_pre_truncdrop.

Referenced by AtPrepare_PgStat().

pgstat_archiver_init_shmem_cb()

void pgstat_archiver_init_shmem_cb

(

void *

stats

)

Definition at line 66 of file pgstat_archiver.c.

{
    PgStatShared_Archiver *stats_shmem = (PgStatShared_Archiver *) stats;
 
    LWLockInitialize(&stats_shmem->lock, LWTRANCHE_PGSTATS_DATA);
}

References PgStatShared_Archiver::lock, LWLockInitialize(), and LWTRANCHE_PGSTATS_DATA.

pgstat_archiver_reset_all_cb()

void pgstat_archiver_reset_all_cb

(

TimestampTz

ts

)

Definition at line 74 of file pgstat_archiver.c.

{
    PgStatShared_Archiver *stats_shmem = &pgStatLocal.shmem->archiver;
 
    /* see explanation above PgStatShared_Archiver for the reset protocol */
    LWLockAcquire(&stats_shmem->lock, LW_EXCLUSIVE);
    pgstat_copy_changecounted_stats(&stats_shmem->reset_offset,
                                    &stats_shmem->stats,
                                    sizeof(stats_shmem->stats),
                                    &stats_shmem->changecount);
    stats_shmem->stats.stat_reset_timestamp = ts;
    LWLockRelease(&stats_shmem->lock);
}

References PgStat_ShmemControl::archiver, PgStatShared_Archiver::changecount, PgStatShared_Archiver::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pgstat_copy_changecounted_stats(), pgStatLocal, PgStatShared_Archiver::reset_offset, PgStat_LocalState::shmem, PgStat_ArchiverStats::stat_reset_timestamp, and PgStatShared_Archiver::stats.

pgstat_archiver_snapshot_cb()

void pgstat_archiver_snapshot_cb

(

void

)

Definition at line 89 of file pgstat_archiver.c.

{
    PgStatShared_Archiver *stats_shmem = &pgStatLocal.shmem->archiver;
    PgStat_ArchiverStats *stat_snap = &pgStatLocal.snapshot.archiver;
    PgStat_ArchiverStats *reset_offset = &stats_shmem->reset_offset;
    PgStat_ArchiverStats reset;
 
    pgstat_copy_changecounted_stats(stat_snap,
                                    &stats_shmem->stats,
                                    sizeof(stats_shmem->stats),
                                    &stats_shmem->changecount);
 
    LWLockAcquire(&stats_shmem->lock, LW_SHARED);
    memcpy(&reset, reset_offset, sizeof(stats_shmem->stats));
    LWLockRelease(&stats_shmem->lock);
 
    /* compensate by reset offsets */
    if (stat_snap->archived_count == reset.archived_count)
    {
        stat_snap->last_archived_wal[0] = 0;
        stat_snap->last_archived_timestamp = 0;
    }
    stat_snap->archived_count -= reset.archived_count;
 
    if (stat_snap->failed_count == reset.failed_count)
    {
        stat_snap->last_failed_wal[0] = 0;
        stat_snap->last_failed_timestamp = 0;
    }
    stat_snap->failed_count -= reset.failed_count;
}

References PgStat_ArchiverStats::archived_count, PgStat_ShmemControl::archiver, PgStat_Snapshot::archiver, PgStatShared_Archiver::changecount, PgStat_ArchiverStats::failed_count, PgStat_ArchiverStats::last_archived_timestamp, PgStat_ArchiverStats::last_archived_wal, PgStat_ArchiverStats::last_failed_timestamp, PgStat_ArchiverStats::last_failed_wal, PgStatShared_Archiver::lock, LW_SHARED, LWLockAcquire(), LWLockRelease(), pgstat_copy_changecounted_stats(), pgStatLocal, reset(), PgStatShared_Archiver::reset_offset, PgStat_LocalState::shmem, PgStat_LocalState::snapshot, and PgStatShared_Archiver::stats.

pgstat_attach_shmem()

void pgstat_attach_shmem

(

void

)

Definition at line 244 of file pgstat_shmem.c.

{
    MemoryContext oldcontext;
 
    Assert(pgStatLocal.dsa == NULL);
 
    /* stats shared memory persists for the backend lifetime */
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
 
    pgStatLocal.dsa = dsa_attach_in_place(pgStatLocal.shmem->raw_dsa_area,
                                          NULL);
    dsa_pin_mapping(pgStatLocal.dsa);
 
    pgStatLocal.shared_hash = dshash_attach(pgStatLocal.dsa, &dsh_params,
                                            pgStatLocal.shmem->hash_handle, 0);
 
    MemoryContextSwitchTo(oldcontext);
}

References Assert(), PgStat_LocalState::dsa, dsa_attach_in_place(), dsa_pin_mapping(), dsh_params, dshash_attach(), PgStat_ShmemControl::hash_handle, MemoryContextSwitchTo(), pgStatLocal, PgStat_ShmemControl::raw_dsa_area, PgStat_LocalState::shared_hash, PgStat_LocalState::shmem, and TopMemoryContext.

Referenced by pgstat_initialize().

pgstat_backend_flush_cb()

bool pgstat_backend_flush_cb

(

bool

nowait

)

Definition at line 322 of file pgstat_backend.c.

{
    return pgstat_flush_backend(nowait, PGSTAT_BACKEND_FLUSH_ALL);
}

References PGSTAT_BACKEND_FLUSH_ALL, and pgstat_flush_backend().

pgstat_backend_have_pending_cb()

bool pgstat_backend_have_pending_cb

(

void

)

Definition at line 308 of file pgstat_backend.c.

{
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return false;
 
    return (backend_has_iostats || pgstat_backend_wal_have_pending());
}

References backend_has_iostats, MyBackendType, pgstat_backend_wal_have_pending(), and pgstat_tracks_backend_bktype().

pgstat_backend_reset_timestamp_cb()

void pgstat_backend_reset_timestamp_cb	(	PgStatShared_Common *	header,
		TimestampTz	ts
	)

Definition at line 409 of file pgstat_backend.c.

{
    ((PgStatShared_Backend *) header)->stats.stat_reset_timestamp = ts;
}

pgstat_begin_changecount_read()

static uint32 pgstat_begin_changecount_read ( uint32 *  cc )

inlinestatic

Definition at line 816 of file pgstat_internal.h.

{
    uint32      before_cc = *cc;
 
    CHECK_FOR_INTERRUPTS();
 
    pg_read_barrier();
 
    return before_cc;
}

References CHECK_FOR_INTERRUPTS, and pg_read_barrier.

Referenced by pgstat_copy_changecounted_stats().

pgstat_begin_changecount_write()

static void pgstat_begin_changecount_write ( uint32 *  cc )

inlinestatic

Definition at line 794 of file pgstat_internal.h.

{
    Assert((*cc & 1) == 0);
 
    START_CRIT_SECTION();
    (*cc)++;
    pg_write_barrier();
}

References Assert(), pg_write_barrier, and START_CRIT_SECTION.

Referenced by pgstat_report_archiver(), pgstat_report_bgwriter(), pgstat_report_checkpointer(), and pgstat_report_inj_fixed().

pgstat_bgwriter_init_shmem_cb()

void pgstat_bgwriter_init_shmem_cb

(

void *

stats

)

Definition at line 80 of file pgstat_bgwriter.c.

{
    PgStatShared_BgWriter *stats_shmem = (PgStatShared_BgWriter *) stats;
 
    LWLockInitialize(&stats_shmem->lock, LWTRANCHE_PGSTATS_DATA);
}

References PgStatShared_BgWriter::lock, LWLockInitialize(), and LWTRANCHE_PGSTATS_DATA.

pgstat_bgwriter_reset_all_cb()

void pgstat_bgwriter_reset_all_cb

(

TimestampTz

ts

)

Definition at line 88 of file pgstat_bgwriter.c.

{
    PgStatShared_BgWriter *stats_shmem = &pgStatLocal.shmem->bgwriter;
 
    /* see explanation above PgStatShared_BgWriter for the reset protocol */
    LWLockAcquire(&stats_shmem->lock, LW_EXCLUSIVE);
    pgstat_copy_changecounted_stats(&stats_shmem->reset_offset,
                                    &stats_shmem->stats,
                                    sizeof(stats_shmem->stats),
                                    &stats_shmem->changecount);
    stats_shmem->stats.stat_reset_timestamp = ts;
    LWLockRelease(&stats_shmem->lock);
}

References PgStat_ShmemControl::bgwriter, PgStatShared_BgWriter::changecount, PgStatShared_BgWriter::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pgstat_copy_changecounted_stats(), pgStatLocal, PgStatShared_BgWriter::reset_offset, PgStat_LocalState::shmem, PgStat_BgWriterStats::stat_reset_timestamp, and PgStatShared_BgWriter::stats.

pgstat_bgwriter_snapshot_cb()

void pgstat_bgwriter_snapshot_cb

(

void

)

Definition at line 103 of file pgstat_bgwriter.c.

{
    PgStatShared_BgWriter *stats_shmem = &pgStatLocal.shmem->bgwriter;
    PgStat_BgWriterStats *reset_offset = &stats_shmem->reset_offset;
    PgStat_BgWriterStats reset;
 
    pgstat_copy_changecounted_stats(&pgStatLocal.snapshot.bgwriter,
                                    &stats_shmem->stats,
                                    sizeof(stats_shmem->stats),
                                    &stats_shmem->changecount);
 
    LWLockAcquire(&stats_shmem->lock, LW_SHARED);
    memcpy(&reset, reset_offset, sizeof(stats_shmem->stats));
    LWLockRelease(&stats_shmem->lock);
 
    /* compensate by reset offsets */
#define BGWRITER_COMP(fld) pgStatLocal.snapshot.bgwriter.fld -= reset.fld;
    BGWRITER_COMP(buf_written_clean);
    BGWRITER_COMP(maxwritten_clean);
    BGWRITER_COMP(buf_alloc);
#undef BGWRITER_COMP
}

References PgStat_ShmemControl::bgwriter, PgStat_Snapshot::bgwriter, BGWRITER_COMP, PgStatShared_BgWriter::changecount, PgStatShared_BgWriter::lock, LW_SHARED, LWLockAcquire(), LWLockRelease(), pgstat_copy_changecounted_stats(), pgStatLocal, reset(), PgStatShared_BgWriter::reset_offset, PgStat_LocalState::shmem, PgStat_LocalState::snapshot, and PgStatShared_BgWriter::stats.

pgstat_checkpointer_init_shmem_cb()

void pgstat_checkpointer_init_shmem_cb

(

void *

stats

)

Definition at line 89 of file pgstat_checkpointer.c.

{
    PgStatShared_Checkpointer *stats_shmem = (PgStatShared_Checkpointer *) stats;
 
    LWLockInitialize(&stats_shmem->lock, LWTRANCHE_PGSTATS_DATA);
}

References PgStatShared_Checkpointer::lock, LWLockInitialize(), and LWTRANCHE_PGSTATS_DATA.

pgstat_checkpointer_reset_all_cb()

void pgstat_checkpointer_reset_all_cb

(

TimestampTz

ts

)

Definition at line 97 of file pgstat_checkpointer.c.

{
    PgStatShared_Checkpointer *stats_shmem = &pgStatLocal.shmem->checkpointer;
 
    /* see explanation above PgStatShared_Checkpointer for the reset protocol */
    LWLockAcquire(&stats_shmem->lock, LW_EXCLUSIVE);
    pgstat_copy_changecounted_stats(&stats_shmem->reset_offset,
                                    &stats_shmem->stats,
                                    sizeof(stats_shmem->stats),
                                    &stats_shmem->changecount);
    stats_shmem->stats.stat_reset_timestamp = ts;
    LWLockRelease(&stats_shmem->lock);
}

References PgStatShared_Checkpointer::changecount, PgStat_ShmemControl::checkpointer, PgStatShared_Checkpointer::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pgstat_copy_changecounted_stats(), pgStatLocal, PgStatShared_Checkpointer::reset_offset, PgStat_LocalState::shmem, PgStat_CheckpointerStats::stat_reset_timestamp, and PgStatShared_Checkpointer::stats.

pgstat_checkpointer_snapshot_cb()

void pgstat_checkpointer_snapshot_cb

(

void

)

Definition at line 112 of file pgstat_checkpointer.c.

{
    PgStatShared_Checkpointer *stats_shmem = &pgStatLocal.shmem->checkpointer;
    PgStat_CheckpointerStats *reset_offset = &stats_shmem->reset_offset;
    PgStat_CheckpointerStats reset;
 
    pgstat_copy_changecounted_stats(&pgStatLocal.snapshot.checkpointer,
                                    &stats_shmem->stats,
                                    sizeof(stats_shmem->stats),
                                    &stats_shmem->changecount);
 
    LWLockAcquire(&stats_shmem->lock, LW_SHARED);
    memcpy(&reset, reset_offset, sizeof(stats_shmem->stats));
    LWLockRelease(&stats_shmem->lock);
 
    /* compensate by reset offsets */
#define CHECKPOINTER_COMP(fld) pgStatLocal.snapshot.checkpointer.fld -= reset.fld;
    CHECKPOINTER_COMP(num_timed);
    CHECKPOINTER_COMP(num_requested);
    CHECKPOINTER_COMP(num_performed);
    CHECKPOINTER_COMP(restartpoints_timed);
    CHECKPOINTER_COMP(restartpoints_requested);
    CHECKPOINTER_COMP(restartpoints_performed);
    CHECKPOINTER_COMP(write_time);
    CHECKPOINTER_COMP(sync_time);
    CHECKPOINTER_COMP(buffers_written);
    CHECKPOINTER_COMP(slru_written);
#undef CHECKPOINTER_COMP
}

References PgStatShared_Checkpointer::changecount, PgStat_ShmemControl::checkpointer, PgStat_Snapshot::checkpointer, CHECKPOINTER_COMP, PgStatShared_Checkpointer::lock, LW_SHARED, LWLockAcquire(), LWLockRelease(), pgstat_copy_changecounted_stats(), pgStatLocal, reset(), PgStatShared_Checkpointer::reset_offset, PgStat_LocalState::shmem, PgStat_LocalState::snapshot, and PgStatShared_Checkpointer::stats.

pgstat_cmp_hash_key()

static int pgstat_cmp_hash_key ( const void *  a, const void *  b, size_t  size, void *  arg  )

inlinestatic

Definition at line 871 of file pgstat_internal.h.

{
    Assert(size == sizeof(PgStat_HashKey) && arg == NULL);
    return memcmp(a, b, sizeof(PgStat_HashKey));
}

References a, arg, Assert(), and b.

pgstat_copy_changecounted_stats()

static void pgstat_copy_changecounted_stats ( void *  dst, void *  src, size_t  len, uint32 *  cc  )

inlinestatic

Definition at line 855 of file pgstat_internal.h.

{
    uint32      cc_before;
 
    do
    {
        cc_before = pgstat_begin_changecount_read(cc);
 
        memcpy(dst, src, len);
    }
    while (!pgstat_end_changecount_read(cc, cc_before));
}

References len, pgstat_begin_changecount_read(), and pgstat_end_changecount_read().

Referenced by injection_stats_fixed_reset_all_cb(), injection_stats_fixed_snapshot_cb(), pgstat_archiver_reset_all_cb(), pgstat_archiver_snapshot_cb(), pgstat_bgwriter_reset_all_cb(), pgstat_bgwriter_snapshot_cb(), pgstat_checkpointer_reset_all_cb(), and pgstat_checkpointer_snapshot_cb().

pgstat_create_transactional()

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

Definition at line 361 of file pgstat_xact.c.

{
    if (pgstat_get_entry_ref(kind, dboid, objid, false, NULL))
    {
        ereport(WARNING,
                errmsg("resetting existing statistics for kind %s, db=%u, oid=%" PRIu64,
                       (pgstat_get_kind_info(kind))->name, dboid,
                       objid));
 
        pgstat_reset(kind, dboid, objid);
    }
 
    create_drop_transactional_internal(kind, dboid, objid, /* create */ true);
}

References create_drop_transactional_internal(), ereport, errmsg(), name, pgstat_get_entry_ref(), pgstat_get_kind_info(), pgstat_reset(), and WARNING.

Referenced by pgstat_create_function(), pgstat_create_relation(), and pgstat_create_subscription().

pgstat_database_flush_cb()

bool pgstat_database_flush_cb	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 428 of file pgstat_database.c.

{
    PgStatShared_Database *sharedent;
    PgStat_StatDBEntry *pendingent;
 
    pendingent = (PgStat_StatDBEntry *) entry_ref->pending;
    sharedent = (PgStatShared_Database *) entry_ref->shared_stats;
 
    if (!pgstat_lock_entry(entry_ref, nowait))
        return false;
 
#define PGSTAT_ACCUM_DBCOUNT(item)      \
    (sharedent)->stats.item += (pendingent)->item
 
    PGSTAT_ACCUM_DBCOUNT(xact_commit);
    PGSTAT_ACCUM_DBCOUNT(xact_rollback);
    PGSTAT_ACCUM_DBCOUNT(blocks_fetched);
    PGSTAT_ACCUM_DBCOUNT(blocks_hit);
 
    PGSTAT_ACCUM_DBCOUNT(tuples_returned);
    PGSTAT_ACCUM_DBCOUNT(tuples_fetched);
    PGSTAT_ACCUM_DBCOUNT(tuples_inserted);
    PGSTAT_ACCUM_DBCOUNT(tuples_updated);
    PGSTAT_ACCUM_DBCOUNT(tuples_deleted);
 
    /* last_autovac_time is reported immediately */
    Assert(pendingent->last_autovac_time == 0);
 
    PGSTAT_ACCUM_DBCOUNT(conflict_tablespace);
    PGSTAT_ACCUM_DBCOUNT(conflict_lock);
    PGSTAT_ACCUM_DBCOUNT(conflict_snapshot);
    PGSTAT_ACCUM_DBCOUNT(conflict_logicalslot);
    PGSTAT_ACCUM_DBCOUNT(conflict_bufferpin);
    PGSTAT_ACCUM_DBCOUNT(conflict_startup_deadlock);
 
    PGSTAT_ACCUM_DBCOUNT(temp_bytes);
    PGSTAT_ACCUM_DBCOUNT(temp_files);
    PGSTAT_ACCUM_DBCOUNT(deadlocks);
 
    /* checksum failures are reported immediately */
    Assert(pendingent->checksum_failures == 0);
    Assert(pendingent->last_checksum_failure == 0);
 
    PGSTAT_ACCUM_DBCOUNT(blk_read_time);
    PGSTAT_ACCUM_DBCOUNT(blk_write_time);
 
    PGSTAT_ACCUM_DBCOUNT(sessions);
    PGSTAT_ACCUM_DBCOUNT(session_time);
    PGSTAT_ACCUM_DBCOUNT(active_time);
    PGSTAT_ACCUM_DBCOUNT(idle_in_transaction_time);
    PGSTAT_ACCUM_DBCOUNT(sessions_abandoned);
    PGSTAT_ACCUM_DBCOUNT(sessions_fatal);
    PGSTAT_ACCUM_DBCOUNT(sessions_killed);
    PGSTAT_ACCUM_DBCOUNT(parallel_workers_to_launch);
    PGSTAT_ACCUM_DBCOUNT(parallel_workers_launched);
#undef PGSTAT_ACCUM_DBCOUNT
 
    pgstat_unlock_entry(entry_ref);
 
    memset(pendingent, 0, sizeof(*pendingent));
 
    return true;
}

References Assert(), PgStat_StatDBEntry::checksum_failures, PgStat_StatDBEntry::last_autovac_time, PgStat_StatDBEntry::last_checksum_failure, PgStat_EntryRef::pending, PGSTAT_ACCUM_DBCOUNT, pgstat_lock_entry(), pgstat_unlock_entry(), and PgStat_EntryRef::shared_stats.

pgstat_database_reset_timestamp_cb()

void pgstat_database_reset_timestamp_cb	(	PgStatShared_Common *	header,
		TimestampTz	ts
	)

Definition at line 493 of file pgstat_database.c.

{
    ((PgStatShared_Database *) header)->stats.stat_reset_timestamp = ts;
}

pgstat_delete_pending_entry()

void pgstat_delete_pending_entry

(

PgStat_EntryRef *

entry_ref

)

Definition at line 1331 of file pgstat.c.

{
    PgStat_Kind kind = entry_ref->shared_entry->key.kind;
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
    void       *pending_data = entry_ref->pending;
 
    Assert(pending_data != NULL);
    /* !fixed_amount stats should be handled explicitly */
    Assert(!pgstat_get_kind_info(kind)->fixed_amount);
 
    if (kind_info->delete_pending_cb)
        kind_info->delete_pending_cb(entry_ref);
 
    pfree(pending_data);
    entry_ref->pending = NULL;
 
    dlist_delete(&entry_ref->pending_node);

References Assert(), PgStat_KindInfo::delete_pending_cb, dlist_delete(), PgStatShared_HashEntry::key, PgStat_HashKey::kind, PgStat_EntryRef::pending, PgStat_EntryRef::pending_node, pfree(), pgstat_get_kind_info(), PgStat_Kind, and PgStat_EntryRef::shared_entry.

Referenced by pgstat_flush_pending_entries(), and pgstat_release_entry_ref().

pgstat_detach_shmem()

void pgstat_detach_shmem

(

void

)

Definition at line 264 of file pgstat_shmem.c.

{
    Assert(pgStatLocal.dsa);
 
    /* we shouldn't leave references to shared stats */
    pgstat_release_all_entry_refs(false);
 
    dshash_detach(pgStatLocal.shared_hash);
    pgStatLocal.shared_hash = NULL;
 
    dsa_detach(pgStatLocal.dsa);
 
    /*
     * dsa_detach() does not decrement the DSA reference count as no segment
     * was provided to dsa_attach_in_place(), causing no cleanup callbacks to
     * be registered.  Hence, release it manually now.
     */
    dsa_release_in_place(pgStatLocal.shmem->raw_dsa_area);
 
    pgStatLocal.dsa = NULL;
}

References Assert(), PgStat_LocalState::dsa, dsa_detach(), dsa_release_in_place(), dshash_detach(), pgstat_release_all_entry_refs(), pgStatLocal, PgStat_ShmemControl::raw_dsa_area, PgStat_LocalState::shared_hash, and PgStat_LocalState::shmem.

Referenced by pgstat_shutdown_hook().

pgstat_drop_all_entries()

void pgstat_drop_all_entries

(

void

)

Definition at line 1051 of file pgstat_shmem.c.

{
    pgstat_drop_matching_entries(NULL, 0);
}

References pgstat_drop_matching_entries().

Referenced by pgstat_reset_after_failure().

pgstat_drop_entry()

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

Definition at line 962 of file pgstat_shmem.c.

{
    PgStat_HashKey key;
    PgStatShared_HashEntry *shent;
    bool        freed = true;
 
    /* clear padding */
    memset(&key, 0, sizeof(struct PgStat_HashKey));
 
    key.kind = kind;
    key.dboid = dboid;
    key.objid = objid;
 
    /* delete local reference */
    if (pgStatEntryRefHash)
    {
        PgStat_EntryRefHashEntry *lohashent =
            pgstat_entry_ref_hash_lookup(pgStatEntryRefHash, key);
 
        if (lohashent)
            pgstat_release_entry_ref(lohashent->key, lohashent->entry_ref,
                                     true);
    }
 
    /* mark entry in shared hashtable as deleted, drop if possible */
    shent = dshash_find(pgStatLocal.shared_hash, &key, true);
    if (shent)
    {
        freed = pgstat_drop_entry_internal(shent, NULL);
 
        /*
         * Database stats contain other stats. Drop those as well when
         * dropping the database. XXX: Perhaps this should be done in a
         * slightly more principled way? But not obvious what that'd look
         * like, and so far this is the only case...
         */
        if (key.kind == PGSTAT_KIND_DATABASE)
            pgstat_drop_database_and_contents(key.dboid);
    }
 
    return freed;
}

References dshash_find(), PgStat_EntryRefHashEntry::entry_ref, PgStat_EntryRefHashEntry::key, sort-test::key, pgstat_drop_database_and_contents(), pgstat_drop_entry_internal(), PGSTAT_KIND_DATABASE, pgstat_release_entry_ref(), pgStatEntryRefHash, pgStatLocal, and PgStat_LocalState::shared_hash.

Referenced by AtEOSubXact_PgStat_DroppedStats(), AtEOXact_PgStat_DroppedStats(), pgstat_drop_inj(), pgstat_drop_replslot(), pgstat_execute_transactional_drops(), pgstat_init_function_usage(), and pgstat_shutdown_hook().

pgstat_drop_matching_entries()

void pgstat_drop_matching_entries	(	bool(*)(PgStatShared_HashEntry *, Datum)	do_drop,
		Datum	match_data
	)

Definition at line 1010 of file pgstat_shmem.c.

{
    dshash_seq_status hstat;
    PgStatShared_HashEntry *ps;
    uint64      not_freed_count = 0;
 
    /* entries are removed, take an exclusive lock */
    dshash_seq_init(&hstat, pgStatLocal.shared_hash, true);
    while ((ps = dshash_seq_next(&hstat)) != NULL)
    {
        if (ps->dropped)
            continue;
 
        if (do_drop != NULL && !do_drop(ps, match_data))
            continue;
 
        /* delete local reference */
        if (pgStatEntryRefHash)
        {
            PgStat_EntryRefHashEntry *lohashent =
                pgstat_entry_ref_hash_lookup(pgStatEntryRefHash, ps->key);
 
            if (lohashent)
                pgstat_release_entry_ref(lohashent->key, lohashent->entry_ref,
                                         true);
        }
 
        if (!pgstat_drop_entry_internal(ps, &hstat))
            not_freed_count++;
    }
    dshash_seq_term(&hstat);
 
    if (not_freed_count > 0)
        pgstat_request_entry_refs_gc();
}

References dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), PgStat_EntryRefHashEntry::entry_ref, PgStat_EntryRefHashEntry::key, pgstat_drop_entry_internal(), pgstat_release_entry_ref(), pgstat_request_entry_refs_gc(), pgStatEntryRefHash, pgStatLocal, ps, and PgStat_LocalState::shared_hash.

Referenced by injection_points_stats_drop(), and pgstat_drop_all_entries().

pgstat_drop_transactional()

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

Definition at line 384 of file pgstat_xact.c.

{
    create_drop_transactional_internal(kind, dboid, objid, /* create */ false);
}

References create_drop_transactional_internal().

Referenced by pgstat_drop_database(), pgstat_drop_function(), pgstat_drop_relation(), and pgstat_drop_subscription().

pgstat_end_changecount_read()

static bool pgstat_end_changecount_read ( uint32 *  cc, uint32  cc_before  )

inlinestatic

Definition at line 831 of file pgstat_internal.h.

{
    uint32      after_cc;
 
    pg_read_barrier();
 
    after_cc = *cc;
 
    /* was a write in progress when we started? */
    if (before_cc & 1)
        return false;
 
    /* did writes start and complete while we read? */
    return before_cc == after_cc;
}

References pg_read_barrier.

Referenced by pgstat_copy_changecounted_stats().

pgstat_end_changecount_write()

static void pgstat_end_changecount_write ( uint32 *  cc )

inlinestatic

Definition at line 804 of file pgstat_internal.h.

{
    Assert((*cc & 1) == 1);
 
    pg_write_barrier();
 
    (*cc)++;
 
    END_CRIT_SECTION();
}

References Assert(), END_CRIT_SECTION, and pg_write_barrier.

Referenced by pgstat_report_archiver(), pgstat_report_bgwriter(), pgstat_report_checkpointer(), and pgstat_report_inj_fixed().

pgstat_fetch_entry()

void * pgstat_fetch_entry	(	PgStat_Kind	kind,
		Oid	dboid,
		uint64	objid
	)

Definition at line 946 of file pgstat.c.

{
    PgStat_HashKey key;
    PgStat_EntryRef *entry_ref;
    void       *stats_data;
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
    /* should be called from backends */
    Assert(IsUnderPostmaster || !IsPostmasterEnvironment);
    Assert(!kind_info->fixed_amount);
 
    pgstat_prep_snapshot();
 
    /* clear padding */
    memset(&key, 0, sizeof(struct PgStat_HashKey));
 
    key.kind = kind;
    key.dboid = dboid;
    key.objid = objid;
 
    /* if we need to build a full snapshot, do so */
    if (pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT)
        pgstat_build_snapshot();
 
    /* if caching is desired, look up in cache */
    if (pgstat_fetch_consistency > PGSTAT_FETCH_CONSISTENCY_NONE)
    {
        PgStat_SnapshotEntry *entry = NULL;
 
        entry = pgstat_snapshot_lookup(pgStatLocal.snapshot.stats, key);
 
        if (entry)
            return entry->data;
 
        /*
         * If we built a full snapshot and the key is not in
         * pgStatLocal.snapshot.stats, there are no matching stats.
         */
        if (pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT)
            return NULL;
    }
 
    pgStatLocal.snapshot.mode = pgstat_fetch_consistency;
 
    entry_ref = pgstat_get_entry_ref(kind, dboid, objid, false, NULL);
 
    if (entry_ref == NULL || entry_ref->shared_entry->dropped)
    {
        /* create empty entry when using PGSTAT_FETCH_CONSISTENCY_CACHE */
        if (pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_CACHE)
        {
            PgStat_SnapshotEntry *entry = NULL;
            bool        found;
 
            entry = pgstat_snapshot_insert(pgStatLocal.snapshot.stats, key, &found);
            Assert(!found);
            entry->data = NULL;
        }
        return NULL;
    }
 
    /*
     * Allocate in caller's context for PGSTAT_FETCH_CONSISTENCY_NONE,
     * otherwise we could quickly end up with a fair bit of memory used due to
     * repeated accesses.
     */
    if (pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_NONE)
        stats_data = palloc(kind_info->shared_data_len);
    else
        stats_data = MemoryContextAlloc(pgStatLocal.snapshot.context,
                                        kind_info->shared_data_len);
 
    (void) pgstat_lock_entry_shared(entry_ref, false);
    memcpy(stats_data,
           pgstat_get_entry_data(kind, entry_ref->shared_stats),
           kind_info->shared_data_len);
    pgstat_unlock_entry(entry_ref);
 
    if (pgstat_fetch_consistency > PGSTAT_FETCH_CONSISTENCY_NONE)
    {
        PgStat_SnapshotEntry *entry = NULL;
        bool        found;
 
        entry = pgstat_snapshot_insert(pgStatLocal.snapshot.stats, key, &found);
        entry->data = stats_data;
    }
 
    return stats_data;

References Assert(), PgStat_Snapshot::context, PgStat_SnapshotEntry::data, PgStatShared_HashEntry::dropped, PgStat_KindInfo::fixed_amount, IsPostmasterEnvironment, IsUnderPostmaster, sort-test::key, MemoryContextAlloc(), PgStat_Snapshot::mode, palloc(), pgstat_build_snapshot(), pgstat_fetch_consistency, PGSTAT_FETCH_CONSISTENCY_CACHE, PGSTAT_FETCH_CONSISTENCY_NONE, PGSTAT_FETCH_CONSISTENCY_SNAPSHOT, pgstat_get_entry_data(), pgstat_get_entry_ref(), pgstat_get_kind_info(), pgstat_lock_entry_shared(), pgstat_prep_snapshot(), pgstat_unlock_entry(), pgStatLocal, PgStat_KindInfo::shared_data_len, PgStat_EntryRef::shared_entry, PgStat_EntryRef::shared_stats, PgStat_LocalState::snapshot, and PgStat_Snapshot::stats.

Referenced by pgstat_fetch_replslot(), pgstat_fetch_stat_backend(), pgstat_fetch_stat_dbentry(), pgstat_fetch_stat_funcentry(), pgstat_fetch_stat_injentry(), pgstat_fetch_stat_subscription(), and pgstat_fetch_stat_tabentry_ext().

pgstat_fetch_pending_entry()

PgStat_EntryRef * pgstat_fetch_pending_entry	(	PgStat_Kind	kind,
		Oid	dboid,
		uint64	objid
	)

Definition at line 1318 of file pgstat.c.

{
    PgStat_EntryRef *entry_ref;
 
    entry_ref = pgstat_get_entry_ref(kind, dboid, objid, false, NULL);
 
    if (entry_ref == NULL || entry_ref->pending == NULL)
        return NULL;
 
    return entry_ref;

References PgStat_EntryRef::pending, and pgstat_get_entry_ref().

Referenced by find_funcstat_entry(), and find_tabstat_entry().

pgstat_flush_backend()

bool pgstat_flush_backend	(	bool	nowait,
		bits32	flags
	)

Definition at line 267 of file pgstat_backend.c.

{
    PgStat_EntryRef *entry_ref;
    bool        has_pending_data = false;
 
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return false;
 
    /* Some IO data pending? */
    if ((flags & PGSTAT_BACKEND_FLUSH_IO) && backend_has_iostats)
        has_pending_data = true;
 
    /* Some WAL data pending? */
    if ((flags & PGSTAT_BACKEND_FLUSH_WAL) &&
        pgstat_backend_wal_have_pending())
        has_pending_data = true;
 
    if (!has_pending_data)
        return false;
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_BACKEND, InvalidOid,
                                            MyProcNumber, nowait);
    if (!entry_ref)
        return true;
 
    /* Flush requested statistics */
    if (flags & PGSTAT_BACKEND_FLUSH_IO)
        pgstat_flush_backend_entry_io(entry_ref);
 
    if (flags & PGSTAT_BACKEND_FLUSH_WAL)
        pgstat_flush_backend_entry_wal(entry_ref);
 
    pgstat_unlock_entry(entry_ref);
 
    return false;
}

References backend_has_iostats, InvalidOid, MyBackendType, MyProcNumber, PGSTAT_BACKEND_FLUSH_IO, PGSTAT_BACKEND_FLUSH_WAL, pgstat_backend_wal_have_pending(), pgstat_flush_backend_entry_io(), pgstat_flush_backend_entry_wal(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_BACKEND, pgstat_tracks_backend_bktype(), and pgstat_unlock_entry().

Referenced by pgstat_backend_flush_cb(), pgstat_report_analyze(), pgstat_report_vacuum(), pgstat_report_wal(), WalSndLoop(), and WalSndWaitForWal().

pgstat_flush_io()

void pgstat_flush_io

(

bool

nowait

)

Definition at line 183 of file pgstat_io.c.

{
    (void) pgstat_io_flush_cb(nowait);
}

References pgstat_io_flush_cb().

Referenced by pgstat_report_analyze(), pgstat_report_bgwriter(), pgstat_report_checkpointer(), pgstat_report_vacuum(), pgstat_report_wal(), WalSndLoop(), and WalSndWaitForWal().

pgstat_function_flush_cb()

bool pgstat_function_flush_cb	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 193 of file pgstat_function.c.

{
    PgStat_FunctionCounts *localent;
    PgStatShared_Function *shfuncent;
 
    localent = (PgStat_FunctionCounts *) entry_ref->pending;
    shfuncent = (PgStatShared_Function *) entry_ref->shared_stats;
 
    /* localent always has non-zero content */
 
    if (!pgstat_lock_entry(entry_ref, nowait))
        return false;
 
    shfuncent->stats.numcalls += localent->numcalls;
    shfuncent->stats.total_time +=
        INSTR_TIME_GET_MICROSEC(localent->total_time);
    shfuncent->stats.self_time +=
        INSTR_TIME_GET_MICROSEC(localent->self_time);
 
    pgstat_unlock_entry(entry_ref);
 
    return true;
}

References INSTR_TIME_GET_MICROSEC, PgStat_FunctionCounts::numcalls, PgStat_StatFuncEntry::numcalls, PgStat_EntryRef::pending, pgstat_lock_entry(), pgstat_unlock_entry(), PgStat_FunctionCounts::self_time, PgStat_StatFuncEntry::self_time, PgStat_EntryRef::shared_stats, PgStatShared_Function::stats, PgStat_FunctionCounts::total_time, and PgStat_StatFuncEntry::total_time.

pgstat_get_custom_shmem_data()

static void * pgstat_get_custom_shmem_data ( PgStat_Kind  kind )

inlinestatic

Definition at line 914 of file pgstat_internal.h.

{
    int         idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
    Assert(pgstat_is_kind_custom(kind));
    Assert(pgstat_get_kind_info(kind)->fixed_amount);
 
    return pgStatLocal.shmem->custom_data[idx];
}

References Assert(), PgStat_ShmemControl::custom_data, idx(), pgstat_get_kind_info(), pgstat_is_kind_custom(), PGSTAT_KIND_CUSTOM_MIN, pgStatLocal, and PgStat_LocalState::shmem.

Referenced by injection_stats_fixed_reset_all_cb(), injection_stats_fixed_snapshot_cb(), and pgstat_report_inj_fixed().

pgstat_get_custom_snapshot_data()

static void * pgstat_get_custom_snapshot_data ( PgStat_Kind  kind )

inlinestatic

Definition at line 929 of file pgstat_internal.h.

{
    int         idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
    Assert(pgstat_is_kind_custom(kind));
    Assert(pgstat_get_kind_info(kind)->fixed_amount);
 
    return pgStatLocal.snapshot.custom_data[idx];
}

References Assert(), PgStat_Snapshot::custom_data, idx(), pgstat_get_kind_info(), pgstat_is_kind_custom(), PGSTAT_KIND_CUSTOM_MIN, pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by injection_points_stats_fixed(), and injection_stats_fixed_snapshot_cb().

pgstat_get_entry_data()

static void * pgstat_get_entry_data ( PgStat_Kind  kind, PgStatShared_Common *  entry  )

inlinestatic

Definition at line 900 of file pgstat_internal.h.

{
    size_t      off = pgstat_get_kind_info(kind)->shared_data_off;
 
    Assert(off != 0 && off < PG_UINT32_MAX);
 
    return ((char *) (entry)) + off;
}

References Assert(), PG_UINT32_MAX, pgstat_get_kind_info(), and PgStat_KindInfo::shared_data_off.

Referenced by pgstat_build_snapshot(), pgstat_fetch_entry(), pgstat_read_statsfile(), pgstat_reinit_entry(), pgstat_write_statsfile(), and shared_stat_reset_contents().

pgstat_get_entry_len()

static size_t pgstat_get_entry_len ( PgStat_Kind  kind )

inlinestatic

Definition at line 891 of file pgstat_internal.h.

{
    return pgstat_get_kind_info(kind)->shared_data_len;
}

References pgstat_get_kind_info(), and PgStat_KindInfo::shared_data_len.

Referenced by pgstat_build_snapshot(), pgstat_read_statsfile(), pgstat_reinit_entry(), pgstat_write_statsfile(), and shared_stat_reset_contents().

pgstat_get_entry_ref()

PgStat_EntryRef * pgstat_get_entry_ref	(	PgStat_Kind	kind,
		Oid	dboid,
		uint64	objid,
		bool	create,
		bool *	created_entry
	)

Definition at line 444 of file pgstat_shmem.c.

{
    PgStat_HashKey key;
    PgStatShared_HashEntry *shhashent;
    PgStatShared_Common *shheader = NULL;
    PgStat_EntryRef *entry_ref;
 
    /* clear padding */
    memset(&key, 0, sizeof(struct PgStat_HashKey));
 
    key.kind = kind;
    key.dboid = dboid;
    key.objid = objid;
 
    /*
     * passing in created_entry only makes sense if we possibly could create
     * entry.
     */
    Assert(create || created_entry == NULL);
    pgstat_assert_is_up();
    Assert(pgStatLocal.shared_hash != NULL);
    Assert(!pgStatLocal.shmem->is_shutdown);
 
    pgstat_setup_memcxt();
    pgstat_setup_shared_refs();
 
    if (created_entry != NULL)
        *created_entry = false;
 
    /*
     * Check if other backends dropped stats that could not be deleted because
     * somebody held references to it. If so, check this backend's references.
     * This is not expected to happen often. The location of the check is a
     * bit random, but this is a relatively frequently called path, so better
     * than most.
     */
    if (pgstat_need_entry_refs_gc())
        pgstat_gc_entry_refs();
 
    /*
     * First check the lookup cache hashtable in local memory. If we find a
     * match here we can avoid taking locks / causing contention.
     */
    if (pgstat_get_entry_ref_cached(key, &entry_ref))
        return entry_ref;
 
    Assert(entry_ref != NULL);
 
    /*
     * Do a lookup in the hash table first - it's quite likely that the entry
     * already exists, and that way we only need a shared lock.
     */
    shhashent = dshash_find(pgStatLocal.shared_hash, &key, false);
 
    if (create && !shhashent)
    {
        bool        shfound;
 
        /*
         * It's possible that somebody created the entry since the above
         * lookup. If so, fall through to the same path as if we'd have if it
         * already had been created before the dshash_find() calls.
         */
        shhashent = dshash_find_or_insert(pgStatLocal.shared_hash, &key, &shfound);
        if (!shfound)
        {
            shheader = pgstat_init_entry(kind, shhashent);
            pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
 
            if (created_entry != NULL)
                *created_entry = true;
 
            return entry_ref;
        }
    }
 
    if (!shhashent)
    {
        /*
         * If we're not creating, delete the reference again. In all
         * likelihood it's just a stats lookup - no point wasting memory for a
         * shared ref to nothing...
         */
        pgstat_release_entry_ref(key, entry_ref, false);
 
        return NULL;
    }
    else
    {
        /*
         * Can get here either because dshash_find() found a match, or if
         * dshash_find_or_insert() found a concurrently inserted entry.
         */
 
        if (shhashent->dropped && create)
        {
            /*
             * There are legitimate cases where the old stats entry might not
             * yet have been dropped by the time it's reused. The most obvious
             * case are replication slot stats, where a new slot can be
             * created with the same index just after dropping. But oid
             * wraparound can lead to other cases as well. We just reset the
             * stats to their plain state, while incrementing its "generation"
             * in the shared entry for any remaining local references.
             */
            shheader = pgstat_reinit_entry(kind, shhashent);
            pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
 
            if (created_entry != NULL)
                *created_entry = true;
 
            return entry_ref;
        }
        else if (shhashent->dropped)
        {
            dshash_release_lock(pgStatLocal.shared_hash, shhashent);
            pgstat_release_entry_ref(key, entry_ref, false);
 
            return NULL;
        }
        else
        {
            shheader = dsa_get_address(pgStatLocal.dsa, shhashent->body);
            pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
 
            return entry_ref;
        }
    }
}

References Assert(), PgStatShared_HashEntry::body, PgStatShared_HashEntry::dropped, PgStat_LocalState::dsa, dsa_get_address(), dshash_find(), dshash_find_or_insert(), dshash_release_lock(), PgStat_ShmemControl::is_shutdown, sort-test::key, pgstat_acquire_entry_ref(), pgstat_assert_is_up, pgstat_gc_entry_refs(), pgstat_get_entry_ref_cached(), pgstat_init_entry(), pgstat_need_entry_refs_gc(), pgstat_reinit_entry(), pgstat_release_entry_ref(), pgstat_setup_memcxt(), pgstat_setup_shared_refs(), pgStatLocal, PgStat_LocalState::shared_hash, and PgStat_LocalState::shmem.

Referenced by pgstat_acquire_replslot(), pgstat_create_subscription(), pgstat_create_transactional(), pgstat_fetch_entry(), pgstat_fetch_pending_entry(), pgstat_get_entry_ref_locked(), pgstat_have_entry(), pgstat_prep_pending_entry(), pgstat_prepare_report_checksum_failure(), pgstat_report_checksum_failures_in_db(), and pgstat_reset_entry().

pgstat_get_entry_ref_locked()

PgStat_EntryRef * pgstat_get_entry_ref_locked	(	PgStat_Kind	kind,
		Oid	dboid,
		uint64	objid,
		bool	nowait
	)

Definition at line 693 of file pgstat_shmem.c.

{
    PgStat_EntryRef *entry_ref;
 
    /* find shared table stats entry corresponding to the local entry */
    entry_ref = pgstat_get_entry_ref(kind, dboid, objid, true, NULL);
 
    /* lock the shared entry to protect the content, skip if failed */
    if (!pgstat_lock_entry(entry_ref, nowait))
        return NULL;
 
    return entry_ref;
}

References pgstat_get_entry_ref(), and pgstat_lock_entry().

Referenced by pgstat_copy_relation_stats(), pgstat_create_backend(), pgstat_create_replslot(), pgstat_flush_backend(), pgstat_report_analyze(), pgstat_report_autovac(), pgstat_report_replslot(), pgstat_report_vacuum(), and pgstat_reset_database_timestamp().

pgstat_get_kind_info()

const PgStat_KindInfo * pgstat_get_kind_info

(

PgStat_Kind

kind

)

Definition at line 1450 of file pgstat.c.

{
    if (pgstat_is_kind_builtin(kind))
        return &pgstat_kind_builtin_infos[kind];
 
    if (pgstat_is_kind_custom(kind))
    {
        uint32      idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
        if (pgstat_kind_custom_infos == NULL ||
            pgstat_kind_custom_infos[idx] == NULL)
            return NULL;
        return pgstat_kind_custom_infos[idx];
    }
 
    return NULL;

References idx(), pgstat_is_kind_builtin(), pgstat_is_kind_custom(), pgstat_kind_builtin_infos, pgstat_kind_custom_infos, and PGSTAT_KIND_CUSTOM_MIN.

Referenced by pgstat_build_snapshot(), pgstat_build_snapshot_fixed(), pgstat_create_transactional(), pgstat_delete_pending_entry(), pgstat_drop_entry_internal(), pgstat_fetch_entry(), pgstat_flush_pending_entries(), pgstat_get_custom_shmem_data(), pgstat_get_custom_snapshot_data(), pgstat_get_entry_data(), pgstat_get_entry_len(), pgstat_have_entry(), pgstat_init_entry(), pgstat_init_snapshot_fixed(), pgstat_initialize(), pgstat_prep_pending_entry(), pgstat_read_statsfile(), pgstat_report_stat(), pgstat_reset(), pgstat_reset_after_failure(), pgstat_reset_entry(), pgstat_reset_of_kind(), pgstat_snapshot_fixed(), pgstat_write_statsfile(), shared_stat_reset_contents(), StatsShmemInit(), and StatsShmemSize().

pgstat_get_xact_stack_level()

PgStat_SubXactStatus * pgstat_get_xact_stack_level

(

int

nest_level

)

Definition at line 238 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state;
 
    xact_state = pgStatXactStack;
    if (xact_state == NULL || xact_state->nest_level != nest_level)
    {
        xact_state = (PgStat_SubXactStatus *)
            MemoryContextAlloc(TopTransactionContext,
                               sizeof(PgStat_SubXactStatus));
        dclist_init(&xact_state->pending_drops);
        xact_state->nest_level = nest_level;
        xact_state->prev = pgStatXactStack;
        xact_state->first = NULL;
        pgStatXactStack = xact_state;
    }
    return xact_state;
}

References dclist_init(), PgStat_SubXactStatus::first, MemoryContextAlloc(), PgStat_SubXactStatus::nest_level, PgStat_SubXactStatus::pending_drops, pgStatXactStack, PgStat_SubXactStatus::prev, and TopTransactionContext.

Referenced by add_tabstat_xact_level(), AtEOSubXact_PgStat_DroppedStats(), AtEOSubXact_PgStat_Relations(), and create_drop_transactional_internal().

pgstat_hash_hash_key()

static uint32 pgstat_hash_hash_key ( const void *  d, size_t  size, void *  arg  )

inlinestatic

Definition at line 878 of file pgstat_internal.h.

{
    const char *key = (const char *) d;
 
    Assert(size == sizeof(PgStat_HashKey) && arg == NULL);
    return fasthash32(key, size, 0);
}

References arg, Assert(), fasthash32(), and sort-test::key.

pgstat_init_entry()

PgStatShared_Common * pgstat_init_entry	(	PgStat_Kind	kind,
		PgStatShared_HashEntry *	shhashent
	)

Definition at line 293 of file pgstat_shmem.c.

{
    /* Create new stats entry. */
    dsa_pointer chunk;
    PgStatShared_Common *shheader;
 
    /*
     * Initialize refcount to 1, marking it as valid / not dropped. The entry
     * can't be freed before the initialization because it can't be found as
     * long as we hold the dshash partition lock. Caller needs to increase
     * further if a longer lived reference is needed.
     */
    pg_atomic_init_u32(&shhashent->refcount, 1);
 
    /*
     * Initialize "generation" to 0, as freshly created.
     */
    pg_atomic_init_u32(&shhashent->generation, 0);
    shhashent->dropped = false;
 
    chunk = dsa_allocate0(pgStatLocal.dsa, pgstat_get_kind_info(kind)->shared_size);
    shheader = dsa_get_address(pgStatLocal.dsa, chunk);
    shheader->magic = 0xdeadbeef;
 
    /* Link the new entry from the hash entry. */
    shhashent->body = chunk;
 
    LWLockInitialize(&shheader->lock, LWTRANCHE_PGSTATS_DATA);
 
    return shheader;
}

References PgStatShared_HashEntry::body, PgStatShared_HashEntry::dropped, PgStat_LocalState::dsa, dsa_allocate0, dsa_get_address(), PgStatShared_HashEntry::generation, PgStatShared_Common::lock, LWLockInitialize(), LWTRANCHE_PGSTATS_DATA, PgStatShared_Common::magic, pg_atomic_init_u32(), pgstat_get_kind_info(), pgStatLocal, and PgStatShared_HashEntry::refcount.

Referenced by pgstat_get_entry_ref(), and pgstat_read_statsfile().

pgstat_io_flush_cb()

bool pgstat_io_flush_cb

(

bool

nowait

)

Definition at line 197 of file pgstat_io.c.

{
    LWLock     *bktype_lock;
    PgStat_BktypeIO *bktype_shstats;
 
    if (!have_iostats)
        return false;
 
    bktype_lock = &pgStatLocal.shmem->io.locks[MyBackendType];
    bktype_shstats =
        &pgStatLocal.shmem->io.stats.stats[MyBackendType];
 
    if (!nowait)
        LWLockAcquire(bktype_lock, LW_EXCLUSIVE);
    else if (!LWLockConditionalAcquire(bktype_lock, LW_EXCLUSIVE))
        return true;
 
    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++)
            {
                instr_time  time;
 
                bktype_shstats->counts[io_object][io_context][io_op] +=
                    PendingIOStats.counts[io_object][io_context][io_op];
 
                bktype_shstats->bytes[io_object][io_context][io_op] +=
                    PendingIOStats.bytes[io_object][io_context][io_op];
 
                time = PendingIOStats.pending_times[io_object][io_context][io_op];
 
                bktype_shstats->times[io_object][io_context][io_op] +=
                    INSTR_TIME_GET_MICROSEC(time);
            }
        }
    }
 
    Assert(pgstat_bktype_io_stats_valid(bktype_shstats, MyBackendType));
 
    LWLockRelease(bktype_lock);
 
    memset(&PendingIOStats, 0, sizeof(PendingIOStats));
 
    have_iostats = false;
 
    return false;
}

References Assert(), PgStat_BktypeIO::bytes, PgStat_PendingIO::bytes, PgStat_BktypeIO::counts, PgStat_PendingIO::counts, have_iostats, INSTR_TIME_GET_MICROSEC, PgStat_ShmemControl::io, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, PgStatShared_IO::locks, LW_EXCLUSIVE, LWLockAcquire(), LWLockConditionalAcquire(), LWLockRelease(), MyBackendType, PgStat_PendingIO::pending_times, PendingIOStats, pgstat_bktype_io_stats_valid(), pgStatLocal, PgStat_LocalState::shmem, PgStat_IO::stats, PgStatShared_IO::stats, and PgStat_BktypeIO::times.

Referenced by pgstat_flush_io().

pgstat_io_have_pending_cb()

bool pgstat_io_have_pending_cb

(

void

)

Definition at line 174 of file pgstat_io.c.

{
    return have_iostats;
}

References have_iostats.

pgstat_io_init_shmem_cb()

void pgstat_io_init_shmem_cb

(

void *

stats

)

Definition at line 286 of file pgstat_io.c.

{
    PgStatShared_IO *stat_shmem = (PgStatShared_IO *) stats;
 
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
        LWLockInitialize(&stat_shmem->locks[i], LWTRANCHE_PGSTATS_DATA);
}

References BACKEND_NUM_TYPES, i, PgStatShared_IO::locks, LWLockInitialize(), and LWTRANCHE_PGSTATS_DATA.

pgstat_io_reset_all_cb()

void pgstat_io_reset_all_cb

(

TimestampTz

ts

)

Definition at line 295 of file pgstat_io.c.

{
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
    {
        LWLock     *bktype_lock = &pgStatLocal.shmem->io.locks[i];
        PgStat_BktypeIO *bktype_shstats = &pgStatLocal.shmem->io.stats.stats[i];
 
        LWLockAcquire(bktype_lock, LW_EXCLUSIVE);
 
        /*
         * Use the lock in the first BackendType's PgStat_BktypeIO to protect
         * the reset timestamp as well.
         */
        if (i == 0)
            pgStatLocal.shmem->io.stats.stat_reset_timestamp = ts;
 
        memset(bktype_shstats, 0, sizeof(*bktype_shstats));
        LWLockRelease(bktype_lock);
    }
}

References BACKEND_NUM_TYPES, i, PgStat_ShmemControl::io, PgStatShared_IO::locks, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pgStatLocal, PgStat_LocalState::shmem, PgStat_IO::stat_reset_timestamp, PgStat_IO::stats, and PgStatShared_IO::stats.

pgstat_io_snapshot_cb()

void pgstat_io_snapshot_cb

(

void

)

Definition at line 317 of file pgstat_io.c.

{
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
    {
        LWLock     *bktype_lock = &pgStatLocal.shmem->io.locks[i];
        PgStat_BktypeIO *bktype_shstats = &pgStatLocal.shmem->io.stats.stats[i];
        PgStat_BktypeIO *bktype_snap = &pgStatLocal.snapshot.io.stats[i];
 
        LWLockAcquire(bktype_lock, LW_SHARED);
 
        /*
         * Use the lock in the first BackendType's PgStat_BktypeIO to protect
         * the reset timestamp as well.
         */
        if (i == 0)
            pgStatLocal.snapshot.io.stat_reset_timestamp =
                pgStatLocal.shmem->io.stats.stat_reset_timestamp;
 
        /* using struct assignment due to better type safety */
        *bktype_snap = *bktype_shstats;
        LWLockRelease(bktype_lock);
    }
}

References BACKEND_NUM_TYPES, i, PgStat_ShmemControl::io, PgStat_Snapshot::io, PgStatShared_IO::locks, LW_SHARED, LWLockAcquire(), LWLockRelease(), pgStatLocal, PgStat_LocalState::shmem, PgStat_LocalState::snapshot, PgStat_IO::stat_reset_timestamp, PgStat_IO::stats, and PgStatShared_IO::stats.

pgstat_lock_entry()

bool pgstat_lock_entry	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 654 of file pgstat_shmem.c.

{
    LWLock     *lock = &entry_ref->shared_stats->lock;
 
    if (nowait)
        return LWLockConditionalAcquire(lock, LW_EXCLUSIVE);
 
    LWLockAcquire(lock, LW_EXCLUSIVE);
    return true;
}

References PgStatShared_Common::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockConditionalAcquire(), and PgStat_EntryRef::shared_stats.

Referenced by injection_stats_flush_cb(), pgstat_database_flush_cb(), pgstat_function_flush_cb(), pgstat_get_entry_ref_locked(), pgstat_relation_flush_cb(), pgstat_report_checksum_failures_in_db(), pgstat_reset_entry(), and pgstat_subscription_flush_cb().

pgstat_lock_entry_shared()

bool pgstat_lock_entry_shared	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 672 of file pgstat_shmem.c.

{
    LWLock     *lock = &entry_ref->shared_stats->lock;
 
    if (nowait)
        return LWLockConditionalAcquire(lock, LW_SHARED);
 
    LWLockAcquire(lock, LW_SHARED);
    return true;
}

References PgStatShared_Common::lock, LW_SHARED, LWLockAcquire(), LWLockConditionalAcquire(), and PgStat_EntryRef::shared_stats.

Referenced by pgstat_fetch_entry().

pgstat_prep_database_pending()

PgStat_StatDBEntry * pgstat_prep_database_pending

(

Oid

dboid

)

Definition at line 386 of file pgstat_database.c.

{
    PgStat_EntryRef *entry_ref;
 
    /*
     * This should not report stats on database objects before having
     * connected to a database.
     */
    Assert(!OidIsValid(dboid) || OidIsValid(MyDatabaseId));
 
    entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_DATABASE, dboid, InvalidOid,
                                          NULL);
 
    return entry_ref->pending;
}

References Assert(), InvalidOid, MyDatabaseId, OidIsValid, PgStat_EntryRef::pending, PGSTAT_KIND_DATABASE, and pgstat_prep_pending_entry().

Referenced by pgstat_relation_flush_cb(), pgstat_report_connect(), pgstat_report_deadlock(), pgstat_report_disconnect(), pgstat_report_recovery_conflict(), pgstat_report_tempfile(), pgstat_update_dbstats(), and pgstat_update_parallel_workers_stats().

pgstat_prep_pending_entry()

PgStat_EntryRef * pgstat_prep_pending_entry	(	PgStat_Kind	kind,
		Oid	dboid,
		uint64	objid,
		bool *	created_entry
	)

Definition at line 1280 of file pgstat.c.

{
    PgStat_EntryRef *entry_ref;
 
    /* need to be able to flush out */
    Assert(pgstat_get_kind_info(kind)->flush_pending_cb != NULL);
 
    if (unlikely(!pgStatPendingContext))
    {
        pgStatPendingContext =
            AllocSetContextCreate(TopMemoryContext,
                                  "PgStat Pending",
                                  ALLOCSET_SMALL_SIZES);
    }
 
    entry_ref = pgstat_get_entry_ref(kind, dboid, objid,
                                     true, created_entry);
 
    if (entry_ref->pending == NULL)
    {
        size_t      entrysize = pgstat_get_kind_info(kind)->pending_size;
 
        Assert(entrysize != (size_t) -1);
 
        entry_ref->pending = MemoryContextAllocZero(pgStatPendingContext, entrysize);
        dlist_push_tail(&pgStatPending, &entry_ref->pending_node);
    }
 
    return entry_ref;

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, Assert(), dlist_push_tail(), MemoryContextAllocZero(), PgStat_EntryRef::pending, PgStat_EntryRef::pending_node, PgStat_KindInfo::pending_size, pgstat_get_entry_ref(), pgstat_get_kind_info(), pgStatPending, pgStatPendingContext, TopMemoryContext, and unlikely.

Referenced by pgstat_create_inj(), pgstat_init_function_usage(), pgstat_prep_database_pending(), pgstat_prep_relation_pending(), pgstat_report_inj(), pgstat_report_subscription_conflict(), and pgstat_report_subscription_error().

pgstat_register_kind()

void pgstat_register_kind	(	PgStat_Kind	kind,
		const PgStat_KindInfo *	kind_info
	)

Definition at line 1478 of file pgstat.c.

{
    uint32      idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
    if (kind_info->name == NULL || strlen(kind_info->name) == 0)
        ereport(ERROR,
                (errmsg("custom cumulative statistics name is invalid"),
                 errhint("Provide a non-empty name for the custom cumulative statistics.")));
 
    if (!pgstat_is_kind_custom(kind))
        ereport(ERROR, (errmsg("custom cumulative statistics ID %u is out of range", kind),
                        errhint("Provide a custom cumulative statistics ID between %u and %u.",
                                PGSTAT_KIND_CUSTOM_MIN, PGSTAT_KIND_CUSTOM_MAX)));
 
    if (!process_shared_preload_libraries_in_progress)
        ereport(ERROR,
                (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                 errdetail("Custom cumulative statistics must be registered while initializing modules in \"shared_preload_libraries\".")));
 
    /*
     * Check some data for fixed-numbered stats.
     */
    if (kind_info->fixed_amount)
    {
        if (kind_info->shared_size == 0)
            ereport(ERROR,
                    (errmsg("custom cumulative statistics property is invalid"),
                     errhint("Custom cumulative statistics require a shared memory size for fixed-numbered objects.")));
    }
 
    /*
     * If pgstat_kind_custom_infos is not available yet, allocate it.
     */
    if (pgstat_kind_custom_infos == NULL)
    {
        pgstat_kind_custom_infos = (const PgStat_KindInfo **)
            MemoryContextAllocZero(TopMemoryContext,
                                   sizeof(PgStat_KindInfo *) * PGSTAT_KIND_CUSTOM_SIZE);
    }
 
    if (pgstat_kind_custom_infos[idx] != NULL &&
        pgstat_kind_custom_infos[idx]->name != NULL)
        ereport(ERROR,
                (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                 errdetail("Custom cumulative statistics \"%s\" already registered with the same ID.",
                           pgstat_kind_custom_infos[idx]->name)));
 
    /* check for existing custom stats with the same name */
    for (PgStat_Kind existing_kind = PGSTAT_KIND_CUSTOM_MIN; existing_kind <= PGSTAT_KIND_CUSTOM_MAX; existing_kind++)
    {
        uint32      existing_idx = existing_kind - PGSTAT_KIND_CUSTOM_MIN;
 
        if (pgstat_kind_custom_infos[existing_idx] == NULL)
            continue;
        if (!pg_strcasecmp(pgstat_kind_custom_infos[existing_idx]->name, kind_info->name))
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errdetail("Existing cumulative statistics with ID %u has the same name.", existing_kind)));
    }
 
    /* Register it */
    pgstat_kind_custom_infos[idx] = kind_info;
    ereport(LOG,
            (errmsg("registered custom cumulative statistics \"%s\" with ID %u",
                    kind_info->name, kind)));

References ereport, errdetail(), errhint(), errmsg(), ERROR, PgStat_KindInfo::fixed_amount, idx(), LOG, MemoryContextAllocZero(), name, PgStat_KindInfo::name, pg_strcasecmp(), pgstat_is_kind_custom(), PgStat_Kind, pgstat_kind_custom_infos, PGSTAT_KIND_CUSTOM_MAX, PGSTAT_KIND_CUSTOM_MIN, PGSTAT_KIND_CUSTOM_SIZE, process_shared_preload_libraries_in_progress, PgStat_KindInfo::shared_size, and TopMemoryContext.

Referenced by pgstat_register_inj(), and pgstat_register_inj_fixed().

pgstat_relation_delete_pending_cb()

void pgstat_relation_delete_pending_cb

(

PgStat_EntryRef *

entry_ref

)

Definition at line 905 of file pgstat_relation.c.

{
    PgStat_TableStatus *pending = (PgStat_TableStatus *) entry_ref->pending;
 
    if (pending->relation)
        pgstat_unlink_relation(pending->relation);
}

References if(), PgStat_EntryRef::pending, pgstat_unlink_relation(), and PgStat_TableStatus::relation.

pgstat_relation_flush_cb()

bool pgstat_relation_flush_cb	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 816 of file pgstat_relation.c.

{
    Oid         dboid;
    PgStat_TableStatus *lstats; /* pending stats entry  */
    PgStatShared_Relation *shtabstats;
    PgStat_StatTabEntry *tabentry;  /* table entry of shared stats */
    PgStat_StatDBEntry *dbentry;    /* pending database entry */
 
    dboid = entry_ref->shared_entry->key.dboid;
    lstats = (PgStat_TableStatus *) entry_ref->pending;
    shtabstats = (PgStatShared_Relation *) entry_ref->shared_stats;
 
    /*
     * Ignore entries that didn't accumulate any actual counts, such as
     * indexes that were opened by the planner but not used.
     */
    if (pg_memory_is_all_zeros(&lstats->counts,
                               sizeof(struct PgStat_TableCounts)))
        return true;
 
    if (!pgstat_lock_entry(entry_ref, nowait))
        return false;
 
    /* add the values to the shared entry. */
    tabentry = &shtabstats->stats;
 
    tabentry->numscans += lstats->counts.numscans;
    if (lstats->counts.numscans)
    {
        TimestampTz t = GetCurrentTransactionStopTimestamp();
 
        if (t > tabentry->lastscan)
            tabentry->lastscan = t;
    }
    tabentry->tuples_returned += lstats->counts.tuples_returned;
    tabentry->tuples_fetched += lstats->counts.tuples_fetched;
    tabentry->tuples_inserted += lstats->counts.tuples_inserted;
    tabentry->tuples_updated += lstats->counts.tuples_updated;
    tabentry->tuples_deleted += lstats->counts.tuples_deleted;
    tabentry->tuples_hot_updated += lstats->counts.tuples_hot_updated;
    tabentry->tuples_newpage_updated += lstats->counts.tuples_newpage_updated;
 
    /*
     * If table was truncated/dropped, first reset the live/dead counters.
     */
    if (lstats->counts.truncdropped)
    {
        tabentry->live_tuples = 0;
        tabentry->dead_tuples = 0;
        tabentry->ins_since_vacuum = 0;
    }
 
    tabentry->live_tuples += lstats->counts.delta_live_tuples;
    tabentry->dead_tuples += lstats->counts.delta_dead_tuples;
    tabentry->mod_since_analyze += lstats->counts.changed_tuples;
 
    /*
     * Using tuples_inserted to update ins_since_vacuum does mean that we'll
     * track aborted inserts too.  This isn't ideal, but otherwise probably
     * not worth adding an extra field for.  It may just amount to autovacuums
     * triggering for inserts more often than they maybe should, which is
     * probably not going to be common enough to be too concerned about here.
     */
    tabentry->ins_since_vacuum += lstats->counts.tuples_inserted;
 
    tabentry->blocks_fetched += lstats->counts.blocks_fetched;
    tabentry->blocks_hit += lstats->counts.blocks_hit;
 
    /* Clamp live_tuples in case of negative delta_live_tuples */
    tabentry->live_tuples = Max(tabentry->live_tuples, 0);
    /* Likewise for dead_tuples */
    tabentry->dead_tuples = Max(tabentry->dead_tuples, 0);
 
    pgstat_unlock_entry(entry_ref);
 
    /* The entry was successfully flushed, add the same to database stats */
    dbentry = pgstat_prep_database_pending(dboid);
    dbentry->tuples_returned += lstats->counts.tuples_returned;
    dbentry->tuples_fetched += lstats->counts.tuples_fetched;
    dbentry->tuples_inserted += lstats->counts.tuples_inserted;
    dbentry->tuples_updated += lstats->counts.tuples_updated;
    dbentry->tuples_deleted += lstats->counts.tuples_deleted;
    dbentry->blocks_fetched += lstats->counts.blocks_fetched;
    dbentry->blocks_hit += lstats->counts.blocks_hit;
 
    return true;
}

References PgStat_TableCounts::blocks_fetched, PgStat_StatDBEntry::blocks_fetched, PgStat_StatTabEntry::blocks_fetched, PgStat_TableCounts::blocks_hit, PgStat_StatDBEntry::blocks_hit, PgStat_StatTabEntry::blocks_hit, PgStat_TableCounts::changed_tuples, PgStat_TableStatus::counts, PgStat_HashKey::dboid, PgStat_StatTabEntry::dead_tuples, PgStat_TableCounts::delta_dead_tuples, PgStat_TableCounts::delta_live_tuples, GetCurrentTransactionStopTimestamp(), PgStat_StatTabEntry::ins_since_vacuum, PgStatShared_HashEntry::key, PgStat_StatTabEntry::lastscan, PgStat_StatTabEntry::live_tuples, Max, PgStat_StatTabEntry::mod_since_analyze, PgStat_TableCounts::numscans, PgStat_StatTabEntry::numscans, PgStat_EntryRef::pending, pg_memory_is_all_zeros(), pgstat_lock_entry(), pgstat_prep_database_pending(), pgstat_unlock_entry(), PgStat_EntryRef::shared_entry, PgStat_EntryRef::shared_stats, PgStatShared_Relation::stats, PgStat_TableCounts::truncdropped, PgStat_TableCounts::tuples_deleted, PgStat_StatDBEntry::tuples_deleted, PgStat_StatTabEntry::tuples_deleted, PgStat_TableCounts::tuples_fetched, PgStat_StatDBEntry::tuples_fetched, PgStat_StatTabEntry::tuples_fetched, PgStat_TableCounts::tuples_hot_updated, PgStat_StatTabEntry::tuples_hot_updated, PgStat_TableCounts::tuples_inserted, PgStat_StatDBEntry::tuples_inserted, PgStat_StatTabEntry::tuples_inserted, PgStat_TableCounts::tuples_newpage_updated, PgStat_StatTabEntry::tuples_newpage_updated, PgStat_TableCounts::tuples_returned, PgStat_StatDBEntry::tuples_returned, PgStat_StatTabEntry::tuples_returned, PgStat_TableCounts::tuples_updated, PgStat_StatDBEntry::tuples_updated, and PgStat_StatTabEntry::tuples_updated.

pgstat_replslot_from_serialized_name_cb()

bool pgstat_replslot_from_serialized_name_cb	(	const NameData *	name,
		PgStat_HashKey *	key
	)

Definition at line 202 of file pgstat_replslot.c.

{
    int         idx = get_replslot_index(NameStr(*name), true);
 
    /* slot might have been deleted */
    if (idx == -1)
        return false;
 
    key->kind = PGSTAT_KIND_REPLSLOT;
    key->dboid = InvalidOid;
    key->objid = idx;
 
    return true;
}

References get_replslot_index(), idx(), InvalidOid, sort-test::key, name, NameStr, and PGSTAT_KIND_REPLSLOT.

pgstat_replslot_reset_timestamp_cb()

void pgstat_replslot_reset_timestamp_cb	(	PgStatShared_Common *	header,
		TimestampTz	ts
	)

Definition at line 218 of file pgstat_replslot.c.

{
    ((PgStatShared_ReplSlot *) header)->stats.stat_reset_timestamp = ts;
}

pgstat_replslot_to_serialized_name_cb()

void pgstat_replslot_to_serialized_name_cb	(	const PgStat_HashKey *	key,
		const PgStatShared_Common *	header,
		NameData *	name
	)

Definition at line 189 of file pgstat_replslot.c.

{
    /*
     * This is only called late during shutdown. The set of existing slots
     * isn't allowed to change at this point, we can assume that a slot exists
     * at the offset.
     */
    if (!ReplicationSlotName(key->objid, name))
        elog(ERROR, "could not find name for replication slot index %" PRIu64,
             key->objid);
}

References elog, ERROR, sort-test::key, name, and ReplicationSlotName().

pgstat_report_disconnect()

void pgstat_report_disconnect

(

Oid

dboid

)

Definition at line 244 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbentry;
 
    if (!pgstat_should_report_connstat())
        return;
 
    dbentry = pgstat_prep_database_pending(MyDatabaseId);
 
    switch (pgStatSessionEndCause)
    {
        case DISCONNECT_NOT_YET:
        case DISCONNECT_NORMAL:
            /* we don't collect these */
            break;
        case DISCONNECT_CLIENT_EOF:
            dbentry->sessions_abandoned++;
            break;
        case DISCONNECT_FATAL:
            dbentry->sessions_fatal++;
            break;
        case DISCONNECT_KILLED:
            dbentry->sessions_killed++;
            break;
    }
}

References DISCONNECT_CLIENT_EOF, DISCONNECT_FATAL, DISCONNECT_KILLED, DISCONNECT_NORMAL, DISCONNECT_NOT_YET, MyDatabaseId, pgstat_prep_database_pending(), pgstat_should_report_connstat(), pgStatSessionEndCause, PgStat_StatDBEntry::sessions_abandoned, PgStat_StatDBEntry::sessions_fatal, and PgStat_StatDBEntry::sessions_killed.

Referenced by pgstat_shutdown_hook().

pgstat_request_entry_refs_gc()

void pgstat_request_entry_refs_gc

(

void

)

Definition at line 709 of file pgstat_shmem.c.

{
    pg_atomic_fetch_add_u64(&pgStatLocal.shmem->gc_request_count, 1);
}

References PgStat_ShmemControl::gc_request_count, pg_atomic_fetch_add_u64(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by AtEOSubXact_PgStat_DroppedStats(), AtEOXact_PgStat_DroppedStats(), pgstat_drop_database_and_contents(), pgstat_drop_inj(), pgstat_drop_matching_entries(), pgstat_drop_replslot(), pgstat_execute_transactional_drops(), and pgstat_shutdown_hook().

pgstat_reset_database_timestamp()

void pgstat_reset_database_timestamp	(	Oid	dboid,
		TimestampTz	ts
	)

Definition at line 407 of file pgstat_database.c.

{
    PgStat_EntryRef *dbref;
    PgStatShared_Database *dbentry;
 
    dbref = pgstat_get_entry_ref_locked(PGSTAT_KIND_DATABASE, MyDatabaseId, InvalidOid,
                                        false);
 
    dbentry = (PgStatShared_Database *) dbref->shared_stats;
    dbentry->stats.stat_reset_timestamp = ts;
 
    pgstat_unlock_entry(dbref);
}

References InvalidOid, MyDatabaseId, pgstat_get_entry_ref_locked(), PGSTAT_KIND_DATABASE, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, PgStat_StatDBEntry::stat_reset_timestamp, and PgStatShared_Database::stats.

Referenced by pgstat_reset().

pgstat_reset_entries_of_kind()

void pgstat_reset_entries_of_kind	(	PgStat_Kind	kind,
		TimestampTz	ts
	)

Definition at line 1129 of file pgstat_shmem.c.

{
    pgstat_reset_matching_entries(match_kind, Int32GetDatum(kind), ts);
}

References Int32GetDatum(), match_kind(), and pgstat_reset_matching_entries().

Referenced by pgstat_reset_of_kind().

pgstat_reset_entry()

void pgstat_reset_entry	(	PgStat_Kind	kind,
		Oid	dboid,
		uint64	objid,
		TimestampTz	ts
	)

Definition at line 1073 of file pgstat_shmem.c.

{
    PgStat_EntryRef *entry_ref;
 
    Assert(!pgstat_get_kind_info(kind)->fixed_amount);
 
    entry_ref = pgstat_get_entry_ref(kind, dboid, objid, false, NULL);
    if (!entry_ref || entry_ref->shared_entry->dropped)
        return;
 
    (void) pgstat_lock_entry(entry_ref, false);
    shared_stat_reset_contents(kind, entry_ref->shared_stats, ts);
    pgstat_unlock_entry(entry_ref);
}

References Assert(), PgStatShared_HashEntry::dropped, pgstat_get_entry_ref(), pgstat_get_kind_info(), pgstat_lock_entry(), pgstat_unlock_entry(), PgStat_EntryRef::shared_entry, shared_stat_reset_contents(), and PgStat_EntryRef::shared_stats.

Referenced by pgstat_create_subscription(), and pgstat_reset().

pgstat_reset_matching_entries()

void pgstat_reset_matching_entries	(	bool(*)(PgStatShared_HashEntry *, Datum)	do_reset,
		Datum	match_data,
		TimestampTz	ts
	)

Definition at line 1093 of file pgstat_shmem.c.

{
    dshash_seq_status hstat;
    PgStatShared_HashEntry *p;
 
    /* dshash entry is not modified, take shared lock */
    dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
    while ((p = dshash_seq_next(&hstat)) != NULL)
    {
        PgStatShared_Common *header;
 
        if (p->dropped)
            continue;
 
        if (!do_reset(p, match_data))
            continue;
 
        header = dsa_get_address(pgStatLocal.dsa, p->body);
 
        LWLockAcquire(&header->lock, LW_EXCLUSIVE);
 
        shared_stat_reset_contents(p->key.kind, header, ts);
 
        LWLockRelease(&header->lock);
    }
    dshash_seq_term(&hstat);
}

References PgStatShared_HashEntry::body, PgStatShared_HashEntry::dropped, PgStat_LocalState::dsa, dsa_get_address(), dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), PgStatShared_HashEntry::key, PgStat_HashKey::kind, PgStatShared_Common::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pgStatLocal, PgStat_LocalState::shared_hash, and shared_stat_reset_contents().

Referenced by pgstat_reset_counters(), and pgstat_reset_entries_of_kind().

pgstat_slru_flush_cb()

bool pgstat_slru_flush_cb

(

bool

nowait

)

Definition at line 165 of file pgstat_slru.c.

{
    PgStatShared_SLRU *stats_shmem = &pgStatLocal.shmem->slru;
    int         i;
 
    if (!have_slrustats)
        return false;
 
    if (!nowait)
        LWLockAcquire(&stats_shmem->lock, LW_EXCLUSIVE);
    else if (!LWLockConditionalAcquire(&stats_shmem->lock, LW_EXCLUSIVE))
        return true;
 
    for (i = 0; i < SLRU_NUM_ELEMENTS; i++)
    {
        PgStat_SLRUStats *sharedent = &stats_shmem->stats[i];
        PgStat_SLRUStats *pendingent = &pending_SLRUStats[i];
 
#define SLRU_ACC(fld) sharedent->fld += pendingent->fld
        SLRU_ACC(blocks_zeroed);
        SLRU_ACC(blocks_hit);
        SLRU_ACC(blocks_read);
        SLRU_ACC(blocks_written);
        SLRU_ACC(blocks_exists);
        SLRU_ACC(flush);
        SLRU_ACC(truncate);
#undef SLRU_ACC
    }
 
    /* done, clear the pending entry */
    MemSet(pending_SLRUStats, 0, sizeof(pending_SLRUStats));
 
    LWLockRelease(&stats_shmem->lock);
 
    have_slrustats = false;
 
    return false;
}

References blocks_written, have_slrustats, i, PgStatShared_SLRU::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockConditionalAcquire(), LWLockRelease(), MemSet, pending_SLRUStats, pgStatLocal, PgStat_LocalState::shmem, PgStat_ShmemControl::slru, SLRU_ACC, SLRU_NUM_ELEMENTS, and PgStatShared_SLRU::stats.

pgstat_slru_have_pending_cb()

bool pgstat_slru_have_pending_cb

(

void

)

Definition at line 150 of file pgstat_slru.c.

{
    return have_slrustats;
}

References have_slrustats.

pgstat_slru_init_shmem_cb()

void pgstat_slru_init_shmem_cb

(

void *

stats

)

Definition at line 205 of file pgstat_slru.c.

{
    PgStatShared_SLRU *stats_shmem = (PgStatShared_SLRU *) stats;
 
    LWLockInitialize(&stats_shmem->lock, LWTRANCHE_PGSTATS_DATA);
}

References PgStatShared_SLRU::lock, LWLockInitialize(), and LWTRANCHE_PGSTATS_DATA.

pgstat_slru_reset_all_cb()

void pgstat_slru_reset_all_cb

(

TimestampTz

ts

)

Definition at line 213 of file pgstat_slru.c.

{
    for (int i = 0; i < SLRU_NUM_ELEMENTS; i++)
        pgstat_reset_slru_counter_internal(i, ts);
}

References i, pgstat_reset_slru_counter_internal(), and SLRU_NUM_ELEMENTS.

pgstat_slru_snapshot_cb()

void pgstat_slru_snapshot_cb

(

void

)

Definition at line 220 of file pgstat_slru.c.

{
    PgStatShared_SLRU *stats_shmem = &pgStatLocal.shmem->slru;
 
    LWLockAcquire(&stats_shmem->lock, LW_SHARED);
 
    memcpy(pgStatLocal.snapshot.slru, &stats_shmem->stats,
           sizeof(stats_shmem->stats));
 
    LWLockRelease(&stats_shmem->lock);
}

References PgStatShared_SLRU::lock, LW_SHARED, LWLockAcquire(), LWLockRelease(), pgStatLocal, PgStat_LocalState::shmem, PgStat_ShmemControl::slru, PgStat_Snapshot::slru, PgStat_LocalState::snapshot, and PgStatShared_SLRU::stats.

pgstat_snapshot_fixed()

void pgstat_snapshot_fixed

(

PgStat_Kind

kind

)

Definition at line 1075 of file pgstat.c.

{
    Assert(pgstat_is_kind_valid(kind));
    Assert(pgstat_get_kind_info(kind)->fixed_amount);
 
    if (force_stats_snapshot_clear)
        pgstat_clear_snapshot();
 
    if (pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT)
        pgstat_build_snapshot();
    else
        pgstat_build_snapshot_fixed(kind);
 
    if (pgstat_is_kind_builtin(kind))
        Assert(pgStatLocal.snapshot.fixed_valid[kind]);
    else if (pgstat_is_kind_custom(kind))
        Assert(pgStatLocal.snapshot.custom_valid[kind - PGSTAT_KIND_CUSTOM_MIN]);

References Assert(), PgStat_Snapshot::custom_valid, PgStat_Snapshot::fixed_valid, force_stats_snapshot_clear, pgstat_build_snapshot(), pgstat_build_snapshot_fixed(), pgstat_clear_snapshot(), pgstat_fetch_consistency, PGSTAT_FETCH_CONSISTENCY_SNAPSHOT, pgstat_get_kind_info(), pgstat_is_kind_builtin(), pgstat_is_kind_custom(), pgstat_is_kind_valid(), PGSTAT_KIND_CUSTOM_MIN, pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by injection_points_stats_fixed(), pgstat_fetch_slru(), pgstat_fetch_stat_archiver(), pgstat_fetch_stat_bgwriter(), pgstat_fetch_stat_checkpointer(), pgstat_fetch_stat_io(), and pgstat_fetch_stat_wal().

pgstat_subscription_flush_cb()

bool pgstat_subscription_flush_cb	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 103 of file pgstat_subscription.c.

{
    PgStat_BackendSubEntry *localent;
    PgStatShared_Subscription *shsubent;
 
    localent = (PgStat_BackendSubEntry *) entry_ref->pending;
    shsubent = (PgStatShared_Subscription *) entry_ref->shared_stats;
 
    /* localent always has non-zero content */
 
    if (!pgstat_lock_entry(entry_ref, nowait))
        return false;
 
#define SUB_ACC(fld) shsubent->stats.fld += localent->fld
    SUB_ACC(apply_error_count);
    SUB_ACC(sync_error_count);
    for (int i = 0; i < CONFLICT_NUM_TYPES; i++)
        SUB_ACC(conflict_count[i]);
#undef SUB_ACC
 
    pgstat_unlock_entry(entry_ref);
    return true;
}

References CONFLICT_NUM_TYPES, i, PgStat_EntryRef::pending, pgstat_lock_entry(), pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, and SUB_ACC.

pgstat_subscription_reset_timestamp_cb()

void pgstat_subscription_reset_timestamp_cb	(	PgStatShared_Common *	header,
		TimestampTz	ts
	)

Definition at line 128 of file pgstat_subscription.c.

{
    ((PgStatShared_Subscription *) header)->stats.stat_reset_timestamp = ts;
}

pgstat_unlock_entry()

void pgstat_unlock_entry

(

PgStat_EntryRef *

entry_ref

)

Definition at line 684 of file pgstat_shmem.c.

{
    LWLockRelease(&entry_ref->shared_stats->lock);
}

References PgStatShared_Common::lock, LWLockRelease(), and PgStat_EntryRef::shared_stats.

Referenced by injection_stats_flush_cb(), pgstat_copy_relation_stats(), pgstat_create_backend(), pgstat_create_replslot(), pgstat_database_flush_cb(), pgstat_fetch_entry(), pgstat_flush_backend(), pgstat_function_flush_cb(), pgstat_relation_flush_cb(), pgstat_report_analyze(), pgstat_report_autovac(), pgstat_report_checksum_failures_in_db(), pgstat_report_replslot(), pgstat_report_vacuum(), pgstat_reset_database_timestamp(), pgstat_reset_entry(), and pgstat_subscription_flush_cb().

pgstat_update_dbstats()

void pgstat_update_dbstats

(

TimestampTz

ts

)

Definition at line 323 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbentry;
 
    /*
     * If not connected to a database yet, don't attribute time to "shared
     * state" (InvalidOid is used to track stats for shared relations, etc.).
     */
    if (!OidIsValid(MyDatabaseId))
        return;
 
    dbentry = pgstat_prep_database_pending(MyDatabaseId);
 
    /*
     * Accumulate xact commit/rollback and I/O timings to stats entry of the
     * current database.
     */
    dbentry->xact_commit += pgStatXactCommit;
    dbentry->xact_rollback += pgStatXactRollback;
    dbentry->blk_read_time += pgStatBlockReadTime;
    dbentry->blk_write_time += pgStatBlockWriteTime;
 
    if (pgstat_should_report_connstat())
    {
        long        secs;
        int         usecs;
 
        /*
         * pgLastSessionReportTime is initialized to MyStartTimestamp by
         * pgstat_report_connect().
         */
        TimestampDifference(pgLastSessionReportTime, ts, &secs, &usecs);
        pgLastSessionReportTime = ts;
        dbentry->session_time += (PgStat_Counter) secs * 1000000 + usecs;
        dbentry->active_time += pgStatActiveTime;
        dbentry->idle_in_transaction_time += pgStatTransactionIdleTime;
    }
 
    pgStatXactCommit = 0;
    pgStatXactRollback = 0;
    pgStatBlockReadTime = 0;
    pgStatBlockWriteTime = 0;
    pgStatActiveTime = 0;
    pgStatTransactionIdleTime = 0;
}

References PgStat_StatDBEntry::active_time, PgStat_StatDBEntry::blk_read_time, PgStat_StatDBEntry::blk_write_time, PgStat_StatDBEntry::idle_in_transaction_time, MyDatabaseId, OidIsValid, pgLastSessionReportTime, pgstat_prep_database_pending(), pgstat_should_report_connstat(), pgStatActiveTime, pgStatBlockReadTime, pgStatBlockWriteTime, pgStatTransactionIdleTime, pgStatXactCommit, pgStatXactRollback, PgStat_StatDBEntry::session_time, TimestampDifference(), PgStat_StatDBEntry::xact_commit, and PgStat_StatDBEntry::xact_rollback.

Referenced by pgstat_report_stat().

pgstat_wal_flush_cb()

bool pgstat_wal_flush_cb

(

bool

nowait

)

Definition at line 82 of file pgstat_wal.c.

{
    PgStatShared_Wal *stats_shmem = &pgStatLocal.shmem->wal;
    WalUsage    wal_usage_diff = {0};
 
    Assert(IsUnderPostmaster || !IsPostmasterEnvironment);
    Assert(pgStatLocal.shmem != NULL &&
           !pgStatLocal.shmem->is_shutdown);
 
    /*
     * This function can be called even if nothing at all has happened. Avoid
     * taking lock for nothing in that case.
     */
    if (!pgstat_wal_have_pending_cb())
        return false;
 
    /*
     * We don't update the WAL usage portion of the local WalStats elsewhere.
     * Calculate how much WAL usage counters were increased by subtracting the
     * previous counters from the current ones.
     */
    WalUsageAccumDiff(&wal_usage_diff, &pgWalUsage, &prevWalUsage);
 
    if (!nowait)
        LWLockAcquire(&stats_shmem->lock, LW_EXCLUSIVE);
    else if (!LWLockConditionalAcquire(&stats_shmem->lock, LW_EXCLUSIVE))
        return true;
 
#define WALSTAT_ACC(fld, var_to_add) \
    (stats_shmem->stats.wal_counters.fld += var_to_add.fld)
    WALSTAT_ACC(wal_records, wal_usage_diff);
    WALSTAT_ACC(wal_fpi, wal_usage_diff);
    WALSTAT_ACC(wal_bytes, wal_usage_diff);
    WALSTAT_ACC(wal_buffers_full, wal_usage_diff);
#undef WALSTAT_ACC
 
    LWLockRelease(&stats_shmem->lock);
 
    /*
     * Save the current counters for the subsequent calculation of WAL usage.
     */
    prevWalUsage = pgWalUsage;
 
    return false;
}

References Assert(), PgStat_ShmemControl::is_shutdown, IsPostmasterEnvironment, IsUnderPostmaster, PgStatShared_Wal::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockConditionalAcquire(), LWLockRelease(), pgstat_wal_have_pending_cb(), pgStatLocal, pgWalUsage, prevWalUsage, PgStat_LocalState::shmem, PgStat_ShmemControl::wal, WALSTAT_ACC, and WalUsageAccumDiff().

Referenced by pgstat_report_wal().

pgstat_wal_have_pending_cb()

bool pgstat_wal_have_pending_cb

(

void

)

Definition at line 143 of file pgstat_wal.c.

{
    return pgWalUsage.wal_records != prevWalUsage.wal_records;
}

References pgWalUsage, prevWalUsage, and WalUsage::wal_records.

Referenced by pgstat_wal_flush_cb().

pgstat_wal_init_backend_cb()

void pgstat_wal_init_backend_cb

(

void

)

Definition at line 129 of file pgstat_wal.c.

{
    /*
     * Initialize prevWalUsage with pgWalUsage so that pgstat_wal_flush_cb()
     * can calculate how much pgWalUsage counters are increased by subtracting
     * prevWalUsage from pgWalUsage.
     */
    prevWalUsage = pgWalUsage;
}

References pgWalUsage, and prevWalUsage.

pgstat_wal_init_shmem_cb()

void pgstat_wal_init_shmem_cb

(

void *

stats

)

Definition at line 149 of file pgstat_wal.c.

{
    PgStatShared_Wal *stats_shmem = (PgStatShared_Wal *) stats;
 
    LWLockInitialize(&stats_shmem->lock, LWTRANCHE_PGSTATS_DATA);
}

References PgStatShared_Wal::lock, LWLockInitialize(), and LWTRANCHE_PGSTATS_DATA.

pgstat_wal_reset_all_cb()

void pgstat_wal_reset_all_cb

(

TimestampTz

ts

)

Definition at line 157 of file pgstat_wal.c.

{
    PgStatShared_Wal *stats_shmem = &pgStatLocal.shmem->wal;
 
    LWLockAcquire(&stats_shmem->lock, LW_EXCLUSIVE);
    memset(&stats_shmem->stats, 0, sizeof(stats_shmem->stats));
    stats_shmem->stats.stat_reset_timestamp = ts;
    LWLockRelease(&stats_shmem->lock);
}

References PgStatShared_Wal::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pgStatLocal, PgStat_LocalState::shmem, PgStat_WalStats::stat_reset_timestamp, PgStatShared_Wal::stats, and PgStat_ShmemControl::wal.

pgstat_wal_snapshot_cb()

void pgstat_wal_snapshot_cb

(

void

)

Definition at line 168 of file pgstat_wal.c.

{
    PgStatShared_Wal *stats_shmem = &pgStatLocal.shmem->wal;
 
    LWLockAcquire(&stats_shmem->lock, LW_SHARED);
    memcpy(&pgStatLocal.snapshot.wal, &stats_shmem->stats,
           sizeof(pgStatLocal.snapshot.wal));
    LWLockRelease(&stats_shmem->lock);
}

References PgStatShared_Wal::lock, LW_SHARED, LWLockAcquire(), LWLockRelease(), pgStatLocal, PgStat_LocalState::shmem, PgStat_LocalState::snapshot, PgStatShared_Wal::stats, PgStat_ShmemControl::wal, and PgStat_Snapshot::wal.

PostPrepare_PgStat_Relations()

void PostPrepare_PgStat_Relations

(

PgStat_SubXactStatus *

xact_state

)

Definition at line 728 of file pgstat_relation.c.

{
    PgStat_TableXactStatus *trans;
 
    for (trans = xact_state->first; trans != NULL; trans = trans->next)
    {
        PgStat_TableStatus *tabstat;
 
        tabstat = trans->parent;
        tabstat->trans = NULL;
    }
}

References PgStat_SubXactStatus::first, PgStat_TableStatus::trans, and trans.

Referenced by PostPrepare_PgStat().

Variable Documentation

pgStatLocal

PGDLLIMPORT PgStat_LocalState pgStatLocal

extern

Definition at line 212 of file pgstat.c.

Referenced by pgstat_acquire_entry_ref(), pgstat_archiver_reset_all_cb(), pgstat_archiver_snapshot_cb(), pgstat_attach_shmem(), pgstat_before_server_shutdown(), pgstat_bgwriter_reset_all_cb(), pgstat_bgwriter_snapshot_cb(), pgstat_build_snapshot(), pgstat_build_snapshot_fixed(), pgstat_checkpointer_reset_all_cb(), pgstat_checkpointer_snapshot_cb(), pgstat_clear_snapshot(), pgstat_detach_shmem(), pgstat_drop_database_and_contents(), pgstat_drop_entry(), pgstat_drop_entry_internal(), pgstat_drop_matching_entries(), pgstat_fetch_entry(), pgstat_fetch_slru(), pgstat_fetch_stat_archiver(), pgstat_fetch_stat_bgwriter(), pgstat_fetch_stat_checkpointer(), pgstat_fetch_stat_io(), pgstat_fetch_stat_wal(), pgstat_free_entry(), pgstat_gc_entry_refs(), pgstat_get_custom_shmem_data(), pgstat_get_custom_snapshot_data(), pgstat_get_entry_ref(), pgstat_get_stat_snapshot_timestamp(), pgstat_init_entry(), pgstat_init_snapshot_fixed(), pgstat_io_flush_cb(), pgstat_io_reset_all_cb(), pgstat_io_snapshot_cb(), pgstat_need_entry_refs_gc(), pgstat_prep_snapshot(), pgstat_read_statsfile(), pgstat_reinit_entry(), pgstat_release_entry_ref(), pgstat_report_archiver(), pgstat_report_bgwriter(), pgstat_report_checkpointer(), pgstat_report_stat(), pgstat_request_entry_refs_gc(), pgstat_reset_matching_entries(), pgstat_reset_slru_counter_internal(), pgstat_setup_shared_refs(), pgstat_slru_flush_cb(), pgstat_slru_snapshot_cb(), pgstat_snapshot_fixed(), pgstat_wal_flush_cb(), pgstat_wal_reset_all_cb(), pgstat_wal_snapshot_cb(), pgstat_write_statsfile(), and StatsShmemInit().

slru_names

const char* const slru_names[]

static

Initial value:

= {
    "commit_timestamp",
    "multixact_member",
    "multixact_offset",
    "notify",
    "serializable",
    "subtransaction",
    "transaction",
    "other"                     
}

Definition at line 334 of file pgstat_internal.h.

Referenced by pgstat_get_slru_index(), and pgstat_get_slru_name().