LCOV - code coverage report
Current view: top level - src/include/utils - pgstat_internal.h (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 41 42 97.6 %
Date: 2025-02-22 07:14:56 Functions: 11 11 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* ----------
       2             :  * pgstat_internal.h
       3             :  *
       4             :  * Definitions for the PostgreSQL cumulative statistics system that should
       5             :  * only be needed by files implementing statistics support (rather than ones
       6             :  * reporting / querying stats).
       7             :  *
       8             :  * Copyright (c) 2001-2025, PostgreSQL Global Development Group
       9             :  *
      10             :  * src/include/utils/pgstat_internal.h
      11             :  * ----------
      12             :  */
      13             : #ifndef PGSTAT_INTERNAL_H
      14             : #define PGSTAT_INTERNAL_H
      15             : 
      16             : 
      17             : #include "common/hashfn_unstable.h"
      18             : #include "lib/dshash.h"
      19             : #include "lib/ilist.h"
      20             : #include "pgstat.h"
      21             : #include "storage/lwlock.h"
      22             : #include "utils/dsa.h"
      23             : 
      24             : 
      25             : /*
      26             :  * Types related to shared memory storage of statistics.
      27             :  *
      28             :  * Per-object statistics are stored in the "shared stats" hashtable. That
      29             :  * table's entries (PgStatShared_HashEntry) contain a pointer to the actual stats
      30             :  * data for the object (the size of the stats data varies depending on the
      31             :  * kind of stats). The table is keyed by PgStat_HashKey.
      32             :  *
      33             :  * Once a backend has a reference to a shared stats entry, it increments the
      34             :  * entry's refcount. Even after stats data is dropped (e.g., due to a DROP
      35             :  * TABLE), the entry itself can only be deleted once all references have been
      36             :  * released.
      37             :  *
      38             :  * These refcounts, in combination with a backend local hashtable
      39             :  * (pgStatEntryRefHash, with entries pointing to PgStat_EntryRef) in front of
      40             :  * the shared hash table, mean that most stats work can happen without
      41             :  * touching the shared hash table, reducing contention.
      42             :  *
      43             :  * Once there are pending stats updates for a table PgStat_EntryRef->pending
      44             :  * is allocated to contain a working space for as-of-yet-unapplied stats
      45             :  * updates. Once the stats are flushed, PgStat_EntryRef->pending is freed.
      46             :  *
      47             :  * Each stat kind in the shared hash table has a fixed member
      48             :  * PgStatShared_Common as the first element.
      49             :  */
      50             : 
      51             : /* struct for shared statistics hash entry key. */
      52             : typedef struct PgStat_HashKey
      53             : {
      54             :     PgStat_Kind kind;           /* statistics entry kind */
      55             :     Oid         dboid;          /* database ID. InvalidOid for shared objects. */
      56             :     uint64      objid;          /* object ID (table, function, etc.), or
      57             :                                  * identifier. */
      58             : } PgStat_HashKey;
      59             : 
      60             : /*
      61             :  * Shared statistics hash entry. Doesn't itself contain any stats, but points
      62             :  * to them (with ->body). That allows the stats entries themselves to be of
      63             :  * variable size.
      64             :  */
      65             : typedef struct PgStatShared_HashEntry
      66             : {
      67             :     PgStat_HashKey key;         /* hash key */
      68             : 
      69             :     /*
      70             :      * If dropped is set, backends need to release their references so that
      71             :      * the memory for the entry can be freed. No new references may be made
      72             :      * once marked as dropped.
      73             :      */
      74             :     bool        dropped;
      75             : 
      76             :     /*
      77             :      * Refcount managing lifetime of the entry itself (as opposed to the
      78             :      * dshash entry pointing to it). The stats lifetime has to be separate
      79             :      * from the hash table entry lifetime because we allow backends to point
      80             :      * to a stats entry without holding a hash table lock (and some other
      81             :      * reasons).
      82             :      *
      83             :      * As long as the entry is not dropped, 1 is added to the refcount
      84             :      * representing that the entry should not be dropped. In addition each
      85             :      * backend that has a reference to the entry needs to increment the
      86             :      * refcount as long as it does.
      87             :      *
      88             :      * May only be incremented / decremented while holding at least a shared
      89             :      * lock on the dshash partition containing the entry. It needs to be an
      90             :      * atomic variable because multiple backends can increment the refcount
      91             :      * with just a shared lock.
      92             :      *
      93             :      * When the refcount reaches 0 the entry needs to be freed.
      94             :      */
      95             :     pg_atomic_uint32 refcount;
      96             : 
      97             :     /*
      98             :      * Counter tracking the number of times the entry has been reused.
      99             :      *
     100             :      * Set to 0 when the entry is created, and incremented by one each time
     101             :      * the shared entry is reinitialized with pgstat_reinit_entry().
     102             :      *
     103             :      * May only be incremented / decremented while holding at least a shared
     104             :      * lock on the dshash partition containing the entry. Like refcount, it
     105             :      * needs to be an atomic variable because multiple backends can increment
     106             :      * the generation with just a shared lock.
     107             :      */
     108             :     pg_atomic_uint32 generation;
     109             : 
     110             :     /*
     111             :      * Pointer to shared stats. The stats entry always starts with
     112             :      * PgStatShared_Common, embedded in a larger struct containing the
     113             :      * PgStat_Kind specific stats fields.
     114             :      */
     115             :     dsa_pointer body;
     116             : } PgStatShared_HashEntry;
     117             : 
     118             : /*
     119             :  * Common header struct for PgStatShared_*.
     120             :  */
     121             : typedef struct PgStatShared_Common
     122             : {
     123             :     uint32      magic;          /* just a validity cross-check */
     124             :     /* lock protecting stats contents (i.e. data following the header) */
     125             :     LWLock      lock;
     126             : } PgStatShared_Common;
     127             : 
     128             : /*
     129             :  * A backend local reference to a shared stats entry. As long as at least one
     130             :  * such reference exists, the shared stats entry will not be released.
     131             :  *
     132             :  * If there are pending stats update to the shared stats, these are stored in
     133             :  * ->pending.
     134             :  */
     135             : typedef struct PgStat_EntryRef
     136             : {
     137             :     /*
     138             :      * Pointer to the PgStatShared_HashEntry entry in the shared stats
     139             :      * hashtable.
     140             :      */
     141             :     PgStatShared_HashEntry *shared_entry;
     142             : 
     143             :     /*
     144             :      * Pointer to the stats data (i.e. PgStatShared_HashEntry->body), resolved
     145             :      * as a local pointer, to avoid repeated dsa_get_address() calls.
     146             :      */
     147             :     PgStatShared_Common *shared_stats;
     148             : 
     149             :     /*
     150             :      * Copy of PgStatShared_HashEntry->generation, keeping locally track of
     151             :      * the shared stats entry "generation" retrieved (number of times reused).
     152             :      */
     153             :     uint32      generation;
     154             : 
     155             :     /*
     156             :      * Pending statistics data that will need to be flushed to shared memory
     157             :      * stats eventually. Each stats kind utilizing pending data defines what
     158             :      * format its pending data has and needs to provide a
     159             :      * PgStat_KindInfo->flush_pending_cb callback to merge pending entries
     160             :      * into the shared stats hash table.
     161             :      */
     162             :     void       *pending;
     163             :     dlist_node  pending_node;   /* membership in pgStatPending list */
     164             : } PgStat_EntryRef;
     165             : 
     166             : 
     167             : /*
     168             :  * Some stats changes are transactional. To maintain those, a stack of
     169             :  * PgStat_SubXactStatus entries is maintained, which contain data pertaining
     170             :  * to the current transaction and its active subtransactions.
     171             :  */
     172             : typedef struct PgStat_SubXactStatus
     173             : {
     174             :     int         nest_level;     /* subtransaction nest level */
     175             : 
     176             :     struct PgStat_SubXactStatus *prev;  /* higher-level subxact if any */
     177             : 
     178             :     /*
     179             :      * Statistics for transactionally dropped objects need to be
     180             :      * transactionally dropped as well. Collect the stats dropped in the
     181             :      * current (sub-)transaction and only execute the stats drop when we know
     182             :      * if the transaction commits/aborts. To handle replicas and crashes,
     183             :      * stats drops are included in commit / abort records.
     184             :      */
     185             :     dclist_head pending_drops;
     186             : 
     187             :     /*
     188             :      * Tuple insertion/deletion counts for an open transaction can't be
     189             :      * propagated into PgStat_TableStatus counters until we know if it is
     190             :      * going to commit or abort.  Hence, we keep these counts in per-subxact
     191             :      * structs that live in TopTransactionContext.  This data structure is
     192             :      * designed on the assumption that subxacts won't usually modify very many
     193             :      * tables.
     194             :      */
     195             :     PgStat_TableXactStatus *first;  /* head of list for this subxact */
     196             : } PgStat_SubXactStatus;
     197             : 
     198             : 
     199             : /*
     200             :  * Metadata for a specific kind of statistics.
     201             :  */
     202             : typedef struct PgStat_KindInfo
     203             : {
     204             :     /*
     205             :      * Do a fixed number of stats objects exist for this kind of stats (e.g.
     206             :      * bgwriter stats) or not (e.g. tables).
     207             :      */
     208             :     bool        fixed_amount:1;
     209             : 
     210             :     /*
     211             :      * Can stats of this kind be accessed from another database? Determines
     212             :      * whether a stats object gets included in stats snapshots.
     213             :      */
     214             :     bool        accessed_across_databases:1;
     215             : 
     216             :     /* Should stats be written to the on-disk stats file? */
     217             :     bool        write_to_file:1;
     218             : 
     219             :     /*
     220             :      * The size of an entry in the shared stats hash table (pointed to by
     221             :      * PgStatShared_HashEntry->body).  For fixed-numbered statistics, this is
     222             :      * the size of an entry in PgStat_ShmemControl->custom_data.
     223             :      */
     224             :     uint32      shared_size;
     225             : 
     226             :     /*
     227             :      * The offset of the statistics struct in the cached statistics snapshot
     228             :      * PgStat_Snapshot, for fixed-numbered statistics.
     229             :      */
     230             :     uint32      snapshot_ctl_off;
     231             : 
     232             :     /*
     233             :      * The offset of the statistics struct in the containing shared memory
     234             :      * control structure PgStat_ShmemControl, for fixed-numbered statistics.
     235             :      */
     236             :     uint32      shared_ctl_off;
     237             : 
     238             :     /*
     239             :      * The offset/size of statistics inside the shared stats entry. Used when
     240             :      * [de-]serializing statistics to / from disk respectively. Separate from
     241             :      * shared_size because [de-]serialization may not include in-memory state
     242             :      * like lwlocks.
     243             :      */
     244             :     uint32      shared_data_off;
     245             :     uint32      shared_data_len;
     246             : 
     247             :     /*
     248             :      * The size of the pending data for this kind. E.g. how large
     249             :      * PgStat_EntryRef->pending is. Used for allocations.
     250             :      *
     251             :      * 0 signals that an entry of this kind should never have a pending entry.
     252             :      */
     253             :     uint32      pending_size;
     254             : 
     255             :     /*
     256             :      * Perform custom actions when initializing a backend (standalone or under
     257             :      * postmaster). Optional.
     258             :      */
     259             :     void        (*init_backend_cb) (void);
     260             : 
     261             :     /*
     262             :      * For variable-numbered stats: flush pending stats. Required if pending
     263             :      * data is used. See flush_static_cb when dealing with stats data that
     264             :      * that cannot use PgStat_EntryRef->pending.
     265             :      */
     266             :     bool        (*flush_pending_cb) (PgStat_EntryRef *sr, bool nowait);
     267             : 
     268             :     /*
     269             :      * For variable-numbered stats: delete pending stats. Optional.
     270             :      */
     271             :     void        (*delete_pending_cb) (PgStat_EntryRef *sr);
     272             : 
     273             :     /*
     274             :      * For variable-numbered stats: reset the reset timestamp. Optional.
     275             :      */
     276             :     void        (*reset_timestamp_cb) (PgStatShared_Common *header, TimestampTz ts);
     277             : 
     278             :     /*
     279             :      * For variable-numbered stats. Optional.
     280             :      */
     281             :     void        (*to_serialized_name) (const PgStat_HashKey *key,
     282             :                                        const PgStatShared_Common *header, NameData *name);
     283             :     bool        (*from_serialized_name) (const NameData *name, PgStat_HashKey *key);
     284             : 
     285             :     /*
     286             :      * For fixed-numbered statistics: Initialize shared memory state.
     287             :      *
     288             :      * "stats" is the pointer to the allocated shared memory area.
     289             :      */
     290             :     void        (*init_shmem_cb) (void *stats);
     291             : 
     292             :     /*
     293             :      * For fixed-numbered or variable-numbered statistics: Flush pending stats
     294             :      * entries, for stats kinds that do not use PgStat_EntryRef->pending.
     295             :      *
     296             :      * Returns true if some of the stats could not be flushed, due to lock
     297             :      * contention for example. Optional.
     298             :      */
     299             :     bool        (*flush_static_cb) (bool nowait);
     300             : 
     301             :     /*
     302             :      * For fixed-numbered or variable-numbered statistics: Check for pending
     303             :      * stats in need of flush with flush_static_cb, when these do not use
     304             :      * PgStat_EntryRef->pending.
     305             :      *
     306             :      * Returns true if there are any stats pending for flush, triggering
     307             :      * flush_static_cb. Optional.
     308             :      */
     309             :     bool        (*have_static_pending_cb) (void);
     310             : 
     311             :     /*
     312             :      * For fixed-numbered statistics: Reset All.
     313             :      */
     314             :     void        (*reset_all_cb) (TimestampTz ts);
     315             : 
     316             :     /*
     317             :      * For fixed-numbered statistics: Build snapshot for entry
     318             :      */
     319             :     void        (*snapshot_cb) (void);
     320             : 
     321             :     /* name of the kind of stats */
     322             :     const char *const name;
     323             : } PgStat_KindInfo;
     324             : 
     325             : 
     326             : /*
     327             :  * List of SLRU names that we keep stats for.  There is no central registry of
     328             :  * SLRUs, so we use this fixed list instead.  The "other" entry is used for
     329             :  * all SLRUs without an explicit entry (e.g. SLRUs in extensions).
     330             :  *
     331             :  * This is only defined here so that SLRU_NUM_ELEMENTS is known for later type
     332             :  * definitions.
     333             :  */
     334             : static const char *const slru_names[] = {
     335             :     "commit_timestamp",
     336             :     "multixact_member",
     337             :     "multixact_offset",
     338             :     "notify",
     339             :     "serializable",
     340             :     "subtransaction",
     341             :     "transaction",
     342             :     "other"                       /* has to be last */
     343             : };
     344             : 
     345             : #define SLRU_NUM_ELEMENTS   lengthof(slru_names)
     346             : 
     347             : 
     348             : /* ----------
     349             :  * Types and definitions for different kinds of fixed-amount stats.
     350             :  *
     351             :  * Single-writer stats use the changecount mechanism to achieve low-overhead
     352             :  * writes - they're obviously more performance critical than reads. Check the
     353             :  * definition of struct PgBackendStatus for some explanation of the
     354             :  * changecount mechanism.
     355             :  *
     356             :  * Because the obvious implementation of resetting single-writer stats isn't
     357             :  * compatible with that (another backend needs to write), we don't scribble on
     358             :  * shared stats while resetting. Instead, just record the current counter
     359             :  * values in a copy of the stats data, which is protected by ->lock. See
     360             :  * pgstat_fetch_stat_(archiver|bgwriter|checkpointer) for the reader side.
     361             :  *
     362             :  * The only exception to that is the stat_reset_timestamp in these structs,
     363             :  * which is protected by ->lock, because it has to be written by another
     364             :  * backend while resetting.
     365             :  * ----------
     366             :  */
     367             : 
     368             : typedef struct PgStatShared_Archiver
     369             : {
     370             :     /* lock protects ->reset_offset as well as stats->stat_reset_timestamp */
     371             :     LWLock      lock;
     372             :     uint32      changecount;
     373             :     PgStat_ArchiverStats stats;
     374             :     PgStat_ArchiverStats reset_offset;
     375             : } PgStatShared_Archiver;
     376             : 
     377             : typedef struct PgStatShared_BgWriter
     378             : {
     379             :     /* lock protects ->reset_offset as well as stats->stat_reset_timestamp */
     380             :     LWLock      lock;
     381             :     uint32      changecount;
     382             :     PgStat_BgWriterStats stats;
     383             :     PgStat_BgWriterStats reset_offset;
     384             : } PgStatShared_BgWriter;
     385             : 
     386             : typedef struct PgStatShared_Checkpointer
     387             : {
     388             :     /* lock protects ->reset_offset as well as stats->stat_reset_timestamp */
     389             :     LWLock      lock;
     390             :     uint32      changecount;
     391             :     PgStat_CheckpointerStats stats;
     392             :     PgStat_CheckpointerStats reset_offset;
     393             : } PgStatShared_Checkpointer;
     394             : 
     395             : /* Shared-memory ready PgStat_IO */
     396             : typedef struct PgStatShared_IO
     397             : {
     398             :     /*
     399             :      * locks[i] protects stats.stats[i]. locks[0] also protects
     400             :      * stats.stat_reset_timestamp.
     401             :      */
     402             :     LWLock      locks[BACKEND_NUM_TYPES];
     403             :     PgStat_IO   stats;
     404             : } PgStatShared_IO;
     405             : 
     406             : typedef struct PgStatShared_SLRU
     407             : {
     408             :     /* lock protects ->stats */
     409             :     LWLock      lock;
     410             :     PgStat_SLRUStats stats[SLRU_NUM_ELEMENTS];
     411             : } PgStatShared_SLRU;
     412             : 
     413             : typedef struct PgStatShared_Wal
     414             : {
     415             :     /* lock protects ->stats */
     416             :     LWLock      lock;
     417             :     PgStat_WalStats stats;
     418             : } PgStatShared_Wal;
     419             : 
     420             : 
     421             : 
     422             : /* ----------
     423             :  * Types and definitions for different kinds of variable-amount stats.
     424             :  *
     425             :  * Each struct has to start with PgStatShared_Common, containing information
     426             :  * common across the different types of stats. Kind-specific data follows.
     427             :  * ----------
     428             :  */
     429             : 
     430             : typedef struct PgStatShared_Database
     431             : {
     432             :     PgStatShared_Common header;
     433             :     PgStat_StatDBEntry stats;
     434             : } PgStatShared_Database;
     435             : 
     436             : typedef struct PgStatShared_Relation
     437             : {
     438             :     PgStatShared_Common header;
     439             :     PgStat_StatTabEntry stats;
     440             : } PgStatShared_Relation;
     441             : 
     442             : typedef struct PgStatShared_Function
     443             : {
     444             :     PgStatShared_Common header;
     445             :     PgStat_StatFuncEntry stats;
     446             : } PgStatShared_Function;
     447             : 
     448             : typedef struct PgStatShared_Subscription
     449             : {
     450             :     PgStatShared_Common header;
     451             :     PgStat_StatSubEntry stats;
     452             : } PgStatShared_Subscription;
     453             : 
     454             : typedef struct PgStatShared_ReplSlot
     455             : {
     456             :     PgStatShared_Common header;
     457             :     PgStat_StatReplSlotEntry stats;
     458             : } PgStatShared_ReplSlot;
     459             : 
     460             : typedef struct PgStatShared_Backend
     461             : {
     462             :     PgStatShared_Common header;
     463             :     PgStat_Backend stats;
     464             : } PgStatShared_Backend;
     465             : 
     466             : /*
     467             :  * Central shared memory entry for the cumulative stats system.
     468             :  *
     469             :  * Fixed amount stats, the dynamic shared memory hash table for
     470             :  * non-fixed-amount stats, as well as remaining bits and pieces are all
     471             :  * reached from here.
     472             :  */
     473             : typedef struct PgStat_ShmemControl
     474             : {
     475             :     void       *raw_dsa_area;
     476             : 
     477             :     /*
     478             :      * Stats for variable-numbered objects are kept in this shared hash table.
     479             :      * See comment above PgStat_Kind for details.
     480             :      */
     481             :     dshash_table_handle hash_handle;    /* shared dbstat hash */
     482             : 
     483             :     /* Has the stats system already been shut down? Just a debugging check. */
     484             :     bool        is_shutdown;
     485             : 
     486             :     /*
     487             :      * Whenever statistics for dropped objects could not be freed - because
     488             :      * backends still have references - the dropping backend calls
     489             :      * pgstat_request_entry_refs_gc() incrementing this counter. Eventually
     490             :      * that causes backends to run pgstat_gc_entry_refs(), allowing memory to
     491             :      * be reclaimed.
     492             :      */
     493             :     pg_atomic_uint64 gc_request_count;
     494             : 
     495             :     /*
     496             :      * Stats data for fixed-numbered objects.
     497             :      */
     498             :     PgStatShared_Archiver archiver;
     499             :     PgStatShared_BgWriter bgwriter;
     500             :     PgStatShared_Checkpointer checkpointer;
     501             :     PgStatShared_IO io;
     502             :     PgStatShared_SLRU slru;
     503             :     PgStatShared_Wal wal;
     504             : 
     505             :     /*
     506             :      * Custom stats data with fixed-numbered objects, indexed by (PgStat_Kind
     507             :      * - PGSTAT_KIND_CUSTOM_MIN).
     508             :      */
     509             :     void       *custom_data[PGSTAT_KIND_CUSTOM_SIZE];
     510             : 
     511             : } PgStat_ShmemControl;
     512             : 
     513             : 
     514             : /*
     515             :  * Cached statistics snapshot
     516             :  */
     517             : typedef struct PgStat_Snapshot
     518             : {
     519             :     PgStat_FetchConsistency mode;
     520             : 
     521             :     /* time at which snapshot was taken */
     522             :     TimestampTz snapshot_timestamp;
     523             : 
     524             :     bool        fixed_valid[PGSTAT_KIND_BUILTIN_SIZE];
     525             : 
     526             :     PgStat_ArchiverStats archiver;
     527             : 
     528             :     PgStat_BgWriterStats bgwriter;
     529             : 
     530             :     PgStat_CheckpointerStats checkpointer;
     531             : 
     532             :     PgStat_IO   io;
     533             : 
     534             :     PgStat_SLRUStats slru[SLRU_NUM_ELEMENTS];
     535             : 
     536             :     PgStat_WalStats wal;
     537             : 
     538             :     /*
     539             :      * Data in snapshot for custom fixed-numbered statistics, indexed by
     540             :      * (PgStat_Kind - PGSTAT_KIND_CUSTOM_MIN).  Each entry is allocated in
     541             :      * TopMemoryContext, for a size of PgStat_KindInfo->shared_data_len.
     542             :      */
     543             :     bool        custom_valid[PGSTAT_KIND_CUSTOM_SIZE];
     544             :     void       *custom_data[PGSTAT_KIND_CUSTOM_SIZE];
     545             : 
     546             :     /* to free snapshot in bulk */
     547             :     MemoryContext context;
     548             :     struct pgstat_snapshot_hash *stats;
     549             : } PgStat_Snapshot;
     550             : 
     551             : 
     552             : /*
     553             :  * Collection of backend-local stats state.
     554             :  */
     555             : typedef struct PgStat_LocalState
     556             : {
     557             :     PgStat_ShmemControl *shmem;
     558             :     dsa_area   *dsa;
     559             :     dshash_table *shared_hash;
     560             : 
     561             :     /* the current statistics snapshot */
     562             :     PgStat_Snapshot snapshot;
     563             : } PgStat_LocalState;
     564             : 
     565             : 
     566             : /*
     567             :  * Inline functions defined further below.
     568             :  */
     569             : 
     570             : static inline void pgstat_begin_changecount_write(uint32 *cc);
     571             : static inline void pgstat_end_changecount_write(uint32 *cc);
     572             : static inline uint32 pgstat_begin_changecount_read(uint32 *cc);
     573             : static inline bool pgstat_end_changecount_read(uint32 *cc, uint32 cc_before);
     574             : 
     575             : static inline void pgstat_copy_changecounted_stats(void *dst, void *src, size_t len,
     576             :                                                    uint32 *cc);
     577             : 
     578             : static inline int pgstat_cmp_hash_key(const void *a, const void *b, size_t size, void *arg);
     579             : static inline uint32 pgstat_hash_hash_key(const void *d, size_t size, void *arg);
     580             : static inline size_t pgstat_get_entry_len(PgStat_Kind kind);
     581             : static inline void *pgstat_get_entry_data(PgStat_Kind kind, PgStatShared_Common *entry);
     582             : static inline void *pgstat_get_custom_shmem_data(PgStat_Kind kind);
     583             : static inline void *pgstat_get_custom_snapshot_data(PgStat_Kind kind);
     584             : 
     585             : 
     586             : /*
     587             :  * Functions in pgstat.c
     588             :  */
     589             : 
     590             : extern const PgStat_KindInfo *pgstat_get_kind_info(PgStat_Kind kind);
     591             : extern void pgstat_register_kind(PgStat_Kind kind,
     592             :                                  const PgStat_KindInfo *kind_info);
     593             : 
     594             : #ifdef USE_ASSERT_CHECKING
     595             : extern void pgstat_assert_is_up(void);
     596             : #else
     597             : #define pgstat_assert_is_up() ((void)true)
     598             : #endif
     599             : 
     600             : extern void pgstat_delete_pending_entry(PgStat_EntryRef *entry_ref);
     601             : extern PgStat_EntryRef *pgstat_prep_pending_entry(PgStat_Kind kind, Oid dboid,
     602             :                                                   uint64 objid,
     603             :                                                   bool *created_entry);
     604             : extern PgStat_EntryRef *pgstat_fetch_pending_entry(PgStat_Kind kind,
     605             :                                                    Oid dboid, uint64 objid);
     606             : 
     607             : extern void *pgstat_fetch_entry(PgStat_Kind kind, Oid dboid, uint64 objid);
     608             : extern void pgstat_snapshot_fixed(PgStat_Kind kind);
     609             : 
     610             : 
     611             : /*
     612             :  * Functions in pgstat_archiver.c
     613             :  */
     614             : 
     615             : extern void pgstat_archiver_init_shmem_cb(void *stats);
     616             : extern void pgstat_archiver_reset_all_cb(TimestampTz ts);
     617             : extern void pgstat_archiver_snapshot_cb(void);
     618             : 
     619             : /*
     620             :  * Functions in pgstat_backend.c
     621             :  */
     622             : 
     623             : /* flags for pgstat_flush_backend() */
     624             : #define PGSTAT_BACKEND_FLUSH_IO     (1 << 0)  /* Flush I/O statistics */
     625             : #define PGSTAT_BACKEND_FLUSH_ALL    (PGSTAT_BACKEND_FLUSH_IO)
     626             : 
     627             : extern bool pgstat_flush_backend(bool nowait, bits32 flags);
     628             : extern bool pgstat_backend_flush_cb(bool nowait);
     629             : extern bool pgstat_backend_have_pending_cb(void);
     630             : extern void pgstat_backend_reset_timestamp_cb(PgStatShared_Common *header,
     631             :                                               TimestampTz ts);
     632             : 
     633             : /*
     634             :  * Functions in pgstat_bgwriter.c
     635             :  */
     636             : 
     637             : extern void pgstat_bgwriter_init_shmem_cb(void *stats);
     638             : extern void pgstat_bgwriter_reset_all_cb(TimestampTz ts);
     639             : extern void pgstat_bgwriter_snapshot_cb(void);
     640             : 
     641             : 
     642             : /*
     643             :  * Functions in pgstat_checkpointer.c
     644             :  */
     645             : 
     646             : extern void pgstat_checkpointer_init_shmem_cb(void *stats);
     647             : extern void pgstat_checkpointer_reset_all_cb(TimestampTz ts);
     648             : extern void pgstat_checkpointer_snapshot_cb(void);
     649             : 
     650             : 
     651             : /*
     652             :  * Functions in pgstat_database.c
     653             :  */
     654             : 
     655             : extern void pgstat_report_disconnect(Oid dboid);
     656             : extern void pgstat_update_dbstats(TimestampTz ts);
     657             : extern void AtEOXact_PgStat_Database(bool isCommit, bool parallel);
     658             : 
     659             : extern PgStat_StatDBEntry *pgstat_prep_database_pending(Oid dboid);
     660             : extern void pgstat_reset_database_timestamp(Oid dboid, TimestampTz ts);
     661             : extern bool pgstat_database_flush_cb(PgStat_EntryRef *entry_ref, bool nowait);
     662             : extern void pgstat_database_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts);
     663             : 
     664             : 
     665             : /*
     666             :  * Functions in pgstat_function.c
     667             :  */
     668             : 
     669             : extern bool pgstat_function_flush_cb(PgStat_EntryRef *entry_ref, bool nowait);
     670             : 
     671             : 
     672             : /*
     673             :  * Functions in pgstat_io.c
     674             :  */
     675             : 
     676             : extern void pgstat_flush_io(bool nowait);
     677             : 
     678             : extern bool pgstat_io_have_pending_cb(void);
     679             : extern bool pgstat_io_flush_cb(bool nowait);
     680             : extern void pgstat_io_init_shmem_cb(void *stats);
     681             : extern void pgstat_io_reset_all_cb(TimestampTz ts);
     682             : extern void pgstat_io_snapshot_cb(void);
     683             : 
     684             : 
     685             : /*
     686             :  * Functions in pgstat_relation.c
     687             :  */
     688             : 
     689             : extern void AtEOXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit);
     690             : extern void AtEOSubXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit, int nestDepth);
     691             : extern void AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state);
     692             : extern void PostPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state);
     693             : 
     694             : extern bool pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool nowait);
     695             : extern void pgstat_relation_delete_pending_cb(PgStat_EntryRef *entry_ref);
     696             : 
     697             : 
     698             : /*
     699             :  * Functions in pgstat_replslot.c
     700             :  */
     701             : 
     702             : extern void pgstat_replslot_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts);
     703             : extern void pgstat_replslot_to_serialized_name_cb(const PgStat_HashKey *key, const PgStatShared_Common *header, NameData *name);
     704             : extern bool pgstat_replslot_from_serialized_name_cb(const NameData *name, PgStat_HashKey *key);
     705             : 
     706             : 
     707             : /*
     708             :  * Functions in pgstat_shmem.c
     709             :  */
     710             : 
     711             : extern void pgstat_attach_shmem(void);
     712             : extern void pgstat_detach_shmem(void);
     713             : 
     714             : extern PgStat_EntryRef *pgstat_get_entry_ref(PgStat_Kind kind, Oid dboid, uint64 objid,
     715             :                                              bool create, bool *created_entry);
     716             : extern bool pgstat_lock_entry(PgStat_EntryRef *entry_ref, bool nowait);
     717             : extern bool pgstat_lock_entry_shared(PgStat_EntryRef *entry_ref, bool nowait);
     718             : extern void pgstat_unlock_entry(PgStat_EntryRef *entry_ref);
     719             : extern bool pgstat_drop_entry(PgStat_Kind kind, Oid dboid, uint64 objid);
     720             : extern void pgstat_drop_all_entries(void);
     721             : extern void pgstat_drop_matching_entries(bool (*do_drop) (PgStatShared_HashEntry *, Datum),
     722             :                                          Datum match_data);
     723             : extern PgStat_EntryRef *pgstat_get_entry_ref_locked(PgStat_Kind kind, Oid dboid, uint64 objid,
     724             :                                                     bool nowait);
     725             : extern void pgstat_reset_entry(PgStat_Kind kind, Oid dboid, uint64 objid, TimestampTz ts);
     726             : extern void pgstat_reset_entries_of_kind(PgStat_Kind kind, TimestampTz ts);
     727             : extern void pgstat_reset_matching_entries(bool (*do_reset) (PgStatShared_HashEntry *, Datum),
     728             :                                           Datum match_data,
     729             :                                           TimestampTz ts);
     730             : 
     731             : extern void pgstat_request_entry_refs_gc(void);
     732             : extern PgStatShared_Common *pgstat_init_entry(PgStat_Kind kind,
     733             :                                               PgStatShared_HashEntry *shhashent);
     734             : 
     735             : 
     736             : /*
     737             :  * Functions in pgstat_slru.c
     738             :  */
     739             : 
     740             : extern bool pgstat_slru_have_pending_cb(void);
     741             : extern bool pgstat_slru_flush_cb(bool nowait);
     742             : extern void pgstat_slru_init_shmem_cb(void *stats);
     743             : extern void pgstat_slru_reset_all_cb(TimestampTz ts);
     744             : extern void pgstat_slru_snapshot_cb(void);
     745             : 
     746             : 
     747             : /*
     748             :  * Functions in pgstat_wal.c
     749             :  */
     750             : 
     751             : extern void pgstat_flush_wal(bool nowait);
     752             : 
     753             : extern void pgstat_wal_init_backend_cb(void);
     754             : extern bool pgstat_wal_have_pending_cb(void);
     755             : extern bool pgstat_wal_flush_cb(bool nowait);
     756             : extern void pgstat_wal_init_shmem_cb(void *stats);
     757             : extern void pgstat_wal_reset_all_cb(TimestampTz ts);
     758             : extern void pgstat_wal_snapshot_cb(void);
     759             : 
     760             : 
     761             : /*
     762             :  * Functions in pgstat_subscription.c
     763             :  */
     764             : 
     765             : extern bool pgstat_subscription_flush_cb(PgStat_EntryRef *entry_ref, bool nowait);
     766             : extern void pgstat_subscription_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts);
     767             : 
     768             : 
     769             : /*
     770             :  * Functions in pgstat_xact.c
     771             :  */
     772             : 
     773             : extern PgStat_SubXactStatus *pgstat_get_xact_stack_level(int nest_level);
     774             : extern void pgstat_drop_transactional(PgStat_Kind kind, Oid dboid, uint64 objid);
     775             : extern void pgstat_create_transactional(PgStat_Kind kind, Oid dboid, uint64 objid);
     776             : 
     777             : 
     778             : /*
     779             :  * Variables in pgstat.c
     780             :  */
     781             : 
     782             : extern PGDLLIMPORT PgStat_LocalState pgStatLocal;
     783             : 
     784             : 
     785             : /*
     786             :  * Implementation of inline functions declared above.
     787             :  */
     788             : 
     789             : /*
     790             :  * Helpers for changecount manipulation. See comments around struct
     791             :  * PgBackendStatus for details.
     792             :  */
     793             : 
     794             : static inline void
     795       19310 : pgstat_begin_changecount_write(uint32 *cc)
     796             : {
     797             :     Assert((*cc & 1) == 0);
     798             : 
     799       19310 :     START_CRIT_SECTION();
     800       19310 :     (*cc)++;
     801       19310 :     pg_write_barrier();
     802       19310 : }
     803             : 
     804             : static inline void
     805       19310 : pgstat_end_changecount_write(uint32 *cc)
     806             : {
     807             :     Assert((*cc & 1) == 1);
     808             : 
     809       19310 :     pg_write_barrier();
     810             : 
     811       19310 :     (*cc)++;
     812             : 
     813       19310 :     END_CRIT_SECTION();
     814       19310 : }
     815             : 
     816             : static inline uint32
     817        4992 : pgstat_begin_changecount_read(uint32 *cc)
     818             : {
     819        4992 :     uint32      before_cc = *cc;
     820             : 
     821        4992 :     CHECK_FOR_INTERRUPTS();
     822             : 
     823        4992 :     pg_read_barrier();
     824             : 
     825        4992 :     return before_cc;
     826             : }
     827             : 
     828             : /*
     829             :  * Returns true if the read succeeded, false if it needs to be repeated.
     830             :  */
     831             : static inline bool
     832        4992 : pgstat_end_changecount_read(uint32 *cc, uint32 before_cc)
     833             : {
     834             :     uint32      after_cc;
     835             : 
     836        4992 :     pg_read_barrier();
     837             : 
     838        4992 :     after_cc = *cc;
     839             : 
     840             :     /* was a write in progress when we started? */
     841        4992 :     if (before_cc & 1)
     842           0 :         return false;
     843             : 
     844             :     /* did writes start and complete while we read? */
     845        4992 :     return before_cc == after_cc;
     846             : }
     847             : 
     848             : 
     849             : /*
     850             :  * helper function for PgStat_KindInfo->snapshot_cb
     851             :  * PgStat_KindInfo->reset_all_cb callbacks.
     852             :  *
     853             :  * Copies out the specified memory area following change-count protocol.
     854             :  */
     855             : static inline void
     856        4992 : pgstat_copy_changecounted_stats(void *dst, void *src, size_t len,
     857             :                                 uint32 *cc)
     858             : {
     859             :     uint32      cc_before;
     860             : 
     861             :     do
     862             :     {
     863        4992 :         cc_before = pgstat_begin_changecount_read(cc);
     864             : 
     865        4992 :         memcpy(dst, src, len);
     866             :     }
     867        4992 :     while (!pgstat_end_changecount_read(cc, cc_before));
     868        4992 : }
     869             : 
     870             : /* helpers for dshash / simplehash hashtables */
     871             : static inline int
     872     8395066 : pgstat_cmp_hash_key(const void *a, const void *b, size_t size, void *arg)
     873             : {
     874             :     Assert(size == sizeof(PgStat_HashKey) && arg == NULL);
     875     8395066 :     return memcmp(a, b, sizeof(PgStat_HashKey));
     876             : }
     877             : 
     878             : static inline uint32
     879    10706616 : pgstat_hash_hash_key(const void *d, size_t size, void *arg)
     880             : {
     881    10706616 :     const char *key = (const char *) d;
     882             : 
     883             :     Assert(size == sizeof(PgStat_HashKey) && arg == NULL);
     884    10706616 :     return fasthash32(key, size, 0);
     885             : }
     886             : 
     887             : /*
     888             :  * The length of the data portion of a shared memory stats entry (i.e. without
     889             :  * transient data such as refcounts, lwlocks, ...).
     890             :  */
     891             : static inline size_t
     892      666880 : pgstat_get_entry_len(PgStat_Kind kind)
     893             : {
     894      666880 :     return pgstat_get_kind_info(kind)->shared_data_len;
     895             : }
     896             : 
     897             : /*
     898             :  * Returns a pointer to the data portion of a shared memory stats entry.
     899             :  */
     900             : static inline void *
     901     1069942 : pgstat_get_entry_data(PgStat_Kind kind, PgStatShared_Common *entry)
     902             : {
     903     1069942 :     size_t      off = pgstat_get_kind_info(kind)->shared_data_off;
     904             : 
     905             :     Assert(off != 0 && off < PG_UINT32_MAX);
     906             : 
     907     1069942 :     return ((char *) (entry)) + off;
     908             : }
     909             : 
     910             : /*
     911             :  * Returns a pointer to the shared memory area of custom stats for
     912             :  * fixed-numbered statistics.
     913             :  */
     914             : static inline void *
     915          30 : pgstat_get_custom_shmem_data(PgStat_Kind kind)
     916             : {
     917          30 :     int         idx = kind - PGSTAT_KIND_CUSTOM_MIN;
     918             : 
     919             :     Assert(pgstat_is_kind_custom(kind));
     920             :     Assert(pgstat_get_kind_info(kind)->fixed_amount);
     921             : 
     922          30 :     return pgStatLocal.shmem->custom_data[idx];
     923             : }
     924             : 
     925             : /*
     926             :  * Returns a pointer to the portion of custom data for fixed-numbered
     927             :  * statistics in the current snapshot.
     928             :  */
     929             : static inline void *
     930          18 : pgstat_get_custom_snapshot_data(PgStat_Kind kind)
     931             : {
     932          18 :     int         idx = kind - PGSTAT_KIND_CUSTOM_MIN;
     933             : 
     934             :     Assert(pgstat_is_kind_custom(kind));
     935             :     Assert(pgstat_get_kind_info(kind)->fixed_amount);
     936             : 
     937          18 :     return pgStatLocal.snapshot.custom_data[idx];
     938             : }
     939             : 
     940             : #endif                          /* PGSTAT_INTERNAL_H */

Generated by: LCOV version 1.14