pgstat.c File Reference

#include "postgres.h"
#include <unistd.h>
#include "access/xact.h"
#include "lib/dshash.h"
#include "pgstat.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/lwlock.h"
#include "utils/guc_hooks.h"
#include "utils/memutils.h"
#include "utils/pgstat_internal.h"
#include "utils/timestamp.h"
#include "lib/simplehash.h"

Include dependency graph for pgstat.c:

Go to the source code of this file.

Data Structures
struct	PgStat_SnapshotEntry

Macros
#define	PGSTAT_MIN_INTERVAL   1000
#define	PGSTAT_MAX_INTERVAL   60000
#define	PGSTAT_IDLE_INTERVAL   10000
#define	PGSTAT_SNAPSHOT_HASH_SIZE   512
#define	PGSTAT_FILE_ENTRY_END   'E' /* end of file */
#define	PGSTAT_FILE_ENTRY_FIXED   'F' /* fixed-numbered stats entry */
#define	PGSTAT_FILE_ENTRY_NAME   'N' /* stats entry identified by name */
#define	PGSTAT_FILE_ENTRY_HASH
#define	SH_PREFIX   pgstat_snapshot
#define	SH_ELEMENT_TYPE   PgStat_SnapshotEntry
#define	SH_KEY_TYPE   PgStat_HashKey
#define	SH_KEY   key
#define	SH_HASH_KEY(tb, key)    pgstat_hash_hash_key(&key, sizeof(PgStat_HashKey), NULL)
#define	SH_EQUAL(tb, a, b)    pgstat_cmp_hash_key(&a, &b, sizeof(PgStat_HashKey), NULL) == 0
#define	SH_SCOPE   static inline
#define	SH_DEFINE
#define	SH_DECLARE
#define	write_chunk_s(fpout, ptr)   write_chunk(fpout, ptr, sizeof(*ptr))
#define	read_chunk_s(fpin, ptr)   read_chunk(fpin, ptr, sizeof(*ptr))

Typedefs
typedef struct PgStat_SnapshotEntry	PgStat_SnapshotEntry

Functions
static void	pgstat_write_statsfile (void)
static void	pgstat_read_statsfile (void)
static void	pgstat_init_snapshot_fixed (void)
static void	pgstat_reset_after_failure (void)
static bool	pgstat_flush_pending_entries (bool nowait)
static void	pgstat_prep_snapshot (void)
static void	pgstat_build_snapshot (void)
static void	pgstat_build_snapshot_fixed (PgStat_Kind kind)
static bool	pgstat_is_kind_valid (PgStat_Kind kind)
void	pgstat_restore_stats (void)
void	pgstat_discard_stats (void)
void	pgstat_before_server_shutdown (int code, Datum arg)
static void	pgstat_shutdown_hook (int code, Datum arg)
void	pgstat_initialize (void)
long	pgstat_report_stat (bool force)
void	pgstat_force_next_flush (void)
static bool	match_db_entries (PgStatShared_HashEntry *entry, Datum match_data)
void	pgstat_reset_counters (void)
void	pgstat_reset (PgStat_Kind kind, Oid dboid, uint64 objid)
void	pgstat_reset_of_kind (PgStat_Kind kind)
void	pgstat_clear_snapshot (void)
void *	pgstat_fetch_entry (PgStat_Kind kind, Oid dboid, uint64 objid, bool *may_free)
TimestampTz	pgstat_get_stat_snapshot_timestamp (bool *have_snapshot)
bool	pgstat_have_entry (PgStat_Kind kind, Oid dboid, uint64 objid)
void	pgstat_snapshot_fixed (PgStat_Kind kind)
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_delete_pending_entry (PgStat_EntryRef *entry_ref)
PgStat_Kind	pgstat_get_kind_from_str (char *kind_str)
const PgStat_KindInfo *	pgstat_get_kind_info (PgStat_Kind kind)
void	pgstat_register_kind (PgStat_Kind kind, const PgStat_KindInfo *kind_info)
static void	write_chunk (FILE *fpout, void *ptr, size_t len)
static bool	read_chunk (FILE *fpin, void *ptr, size_t len)
void	assign_stats_fetch_consistency (int newval, void *extra)

Variables
bool	pgstat_track_counts = false
int	pgstat_fetch_consistency = PGSTAT_FETCH_CONSISTENCY_CACHE
PgStat_LocalState	pgStatLocal
bool	pgstat_report_fixed = false
static MemoryContext	pgStatPendingContext = NULL
static dlist_head	pgStatPending = DLIST_STATIC_INIT(pgStatPending)
static bool	pgStatForceNextFlush = false
static bool	force_stats_snapshot_clear = false
static const PgStat_KindInfo	pgstat_kind_builtin_infos [PGSTAT_KIND_BUILTIN_SIZE]
static const PgStat_KindInfo **	pgstat_kind_custom_infos = NULL

Macro Definition Documentation

PGSTAT_FILE_ENTRY_END

#define PGSTAT_FILE_ENTRY_END   'E' /* end of file */

Definition at line 144 of file pgstat.c.

PGSTAT_FILE_ENTRY_FIXED

#define PGSTAT_FILE_ENTRY_FIXED   'F' /* fixed-numbered stats entry */

Definition at line 145 of file pgstat.c.

PGSTAT_FILE_ENTRY_HASH

#define PGSTAT_FILE_ENTRY_HASH

Value:

                                     'S' /* stats entry identified by
                                     * PgStat_HashKey */

Definition at line 147 of file pgstat.c.

{
    PgStat_HashKey key;
    char        status;         /* for simplehash use */
    void       *data;           /* the stats data itself */
} PgStat_SnapshotEntry;
 
 
/* ----------
 * Backend-local Hash Table Definitions
 * ----------
 */
 
/* for stats snapshot entries */
#define SH_PREFIX pgstat_snapshot
#define SH_ELEMENT_TYPE PgStat_SnapshotEntry
#define SH_KEY_TYPE PgStat_HashKey
#define SH_KEY key
#define SH_HASH_KEY(tb, key) \
    pgstat_hash_hash_key(&key, sizeof(PgStat_HashKey), NULL)
#define SH_EQUAL(tb, a, b) \
    pgstat_cmp_hash_key(&a, &b, sizeof(PgStat_HashKey), NULL) == 0
#define SH_SCOPE static inline
#define SH_DEFINE
#define SH_DECLARE
#include "lib/simplehash.h"
 
 
/* ----------
 * Local function forward declarations
 * ----------
 */
 
static void pgstat_write_statsfile(void);
static void pgstat_read_statsfile(void);
 
static void pgstat_init_snapshot_fixed(void);
 
static void pgstat_reset_after_failure(void);
 
static bool pgstat_flush_pending_entries(bool nowait);
 
static void pgstat_prep_snapshot(void);
static void pgstat_build_snapshot(void);
static void pgstat_build_snapshot_fixed(PgStat_Kind kind);
 
static inline bool pgstat_is_kind_valid(PgStat_Kind kind);
 
 
/* ----------
 * GUC parameters
 * ----------
 */
 
bool        pgstat_track_counts = false;
int         pgstat_fetch_consistency = PGSTAT_FETCH_CONSISTENCY_CACHE;
 
 
/* ----------
 * state shared with pgstat_*.c
 * ----------
 */
 
PgStat_LocalState pgStatLocal;
 
/*
 * Track pending reports for fixed-numbered stats, used by
 * pgstat_report_stat().
 */
bool        pgstat_report_fixed = false;
 
/* ----------
 * Local data
 *
 * NB: There should be only variables related to stats infrastructure here,
 * not for specific kinds of stats.
 * ----------
 */
 
/*
 * Memory contexts containing the pgStatEntryRefHash table, the
 * pgStatSharedRef entries, and pending data respectively. Mostly to make it
 * easier to track / attribute memory usage.
 */
 
static MemoryContext pgStatPendingContext = NULL;
 
/*
 * Backend local list of PgStat_EntryRef with unflushed pending stats.
 *
 * Newly pending entries should only ever be added to the end of the list,
 * otherwise pgstat_flush_pending_entries() might not see them immediately.
 */
static dlist_head pgStatPending = DLIST_STATIC_INIT(pgStatPending);
 
 
/*
 * Force the next stats flush to happen regardless of
 * PGSTAT_MIN_INTERVAL. Useful in test scripts.
 */
static bool pgStatForceNextFlush = false;
 
/*
 * Force-clear existing snapshot before next use when stats_fetch_consistency
 * is changed.
 */
static bool force_stats_snapshot_clear = false;
 
 
/*
 * For assertions that check pgstat is not used before initialization / after
 * shutdown.
 */
#ifdef USE_ASSERT_CHECKING
static bool pgstat_is_initialized = false;
static bool pgstat_is_shutdown = false;
#endif
 
 
/*
 * The different kinds of built-in statistics.
 *
 * If reasonably possible, handling specific to one kind of stats should go
 * through this abstraction, rather than making more of pgstat.c aware.
 *
 * See comments for struct PgStat_KindInfo for details about the individual
 * fields.
 *
 * XXX: It'd be nicer to define this outside of this file. But there doesn't
 * seem to be a great way of doing that, given the split across multiple
 * files.
 */
static const PgStat_KindInfo pgstat_kind_builtin_infos[PGSTAT_KIND_BUILTIN_SIZE] = {
 
    /* stats kinds for variable-numbered objects */
 
    [PGSTAT_KIND_DATABASE] = {
        .name = "database",
 
        .fixed_amount = false,
        .write_to_file = true,
        /* so pg_stat_database entries can be seen in all databases */
        .accessed_across_databases = true,
 
        .shared_size = sizeof(PgStatShared_Database),
        .shared_data_off = offsetof(PgStatShared_Database, stats),
        .shared_data_len = sizeof(((PgStatShared_Database *) 0)->stats),
        .pending_size = sizeof(PgStat_StatDBEntry),
 
        .flush_pending_cb = pgstat_database_flush_cb,
        .reset_timestamp_cb = pgstat_database_reset_timestamp_cb,
    },
 
    [PGSTAT_KIND_RELATION] = {
        .name = "relation",
 
        .fixed_amount = false,
        .write_to_file = true,
 
        .shared_size = sizeof(PgStatShared_Relation),
        .shared_data_off = offsetof(PgStatShared_Relation, stats),
        .shared_data_len = sizeof(((PgStatShared_Relation *) 0)->stats),
        .pending_size = sizeof(PgStat_TableStatus),
 
        .flush_pending_cb = pgstat_relation_flush_cb,
        .delete_pending_cb = pgstat_relation_delete_pending_cb,
        .reset_timestamp_cb = pgstat_relation_reset_timestamp_cb,
    },
 
    [PGSTAT_KIND_FUNCTION] = {
        .name = "function",
 
        .fixed_amount = false,
        .write_to_file = true,
 
        .shared_size = sizeof(PgStatShared_Function),
        .shared_data_off = offsetof(PgStatShared_Function, stats),
        .shared_data_len = sizeof(((PgStatShared_Function *) 0)->stats),
        .pending_size = sizeof(PgStat_FunctionCounts),
 
        .flush_pending_cb = pgstat_function_flush_cb,
        .reset_timestamp_cb = pgstat_function_reset_timestamp_cb,
    },
 
    [PGSTAT_KIND_REPLSLOT] = {
        .name = "replslot",
 
        .fixed_amount = false,
        .write_to_file = true,
 
        .accessed_across_databases = true,
 
        .shared_size = sizeof(PgStatShared_ReplSlot),
        .shared_data_off = offsetof(PgStatShared_ReplSlot, stats),
        .shared_data_len = sizeof(((PgStatShared_ReplSlot *) 0)->stats),
 
        .reset_timestamp_cb = pgstat_replslot_reset_timestamp_cb,
        .to_serialized_name = pgstat_replslot_to_serialized_name_cb,
        .from_serialized_name = pgstat_replslot_from_serialized_name_cb,
    },
 
    [PGSTAT_KIND_SUBSCRIPTION] = {
        .name = "subscription",
 
        .fixed_amount = false,
        .write_to_file = true,
        /* so pg_stat_subscription_stats entries can be seen in all databases */
        .accessed_across_databases = true,
 
        .shared_size = sizeof(PgStatShared_Subscription),
        .shared_data_off = offsetof(PgStatShared_Subscription, stats),
        .shared_data_len = sizeof(((PgStatShared_Subscription *) 0)->stats),
        .pending_size = sizeof(PgStat_BackendSubEntry),
 
        .flush_pending_cb = pgstat_subscription_flush_cb,
        .reset_timestamp_cb = pgstat_subscription_reset_timestamp_cb,
    },
 
    [PGSTAT_KIND_BACKEND] = {
        .name = "backend",
 
        .fixed_amount = false,
        .write_to_file = false,
 
        .accessed_across_databases = true,
 
        .shared_size = sizeof(PgStatShared_Backend),
        .shared_data_off = offsetof(PgStatShared_Backend, stats),
        .shared_data_len = sizeof(((PgStatShared_Backend *) 0)->stats),
 
        .flush_static_cb = pgstat_backend_flush_cb,
        .reset_timestamp_cb = pgstat_backend_reset_timestamp_cb,
    },
 
    /* stats for fixed-numbered (mostly 1) objects */
 
    [PGSTAT_KIND_ARCHIVER] = {
        .name = "archiver",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, archiver),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, archiver),
        .shared_data_off = offsetof(PgStatShared_Archiver, stats),
        .shared_data_len = sizeof(((PgStatShared_Archiver *) 0)->stats),
 
        .init_shmem_cb = pgstat_archiver_init_shmem_cb,
        .reset_all_cb = pgstat_archiver_reset_all_cb,
        .snapshot_cb = pgstat_archiver_snapshot_cb,
    },
 
    [PGSTAT_KIND_BGWRITER] = {
        .name = "bgwriter",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, bgwriter),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, bgwriter),
        .shared_data_off = offsetof(PgStatShared_BgWriter, stats),
        .shared_data_len = sizeof(((PgStatShared_BgWriter *) 0)->stats),
 
        .init_shmem_cb = pgstat_bgwriter_init_shmem_cb,
        .reset_all_cb = pgstat_bgwriter_reset_all_cb,
        .snapshot_cb = pgstat_bgwriter_snapshot_cb,
    },
 
    [PGSTAT_KIND_CHECKPOINTER] = {
        .name = "checkpointer",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, checkpointer),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, checkpointer),
        .shared_data_off = offsetof(PgStatShared_Checkpointer, stats),
        .shared_data_len = sizeof(((PgStatShared_Checkpointer *) 0)->stats),
 
        .init_shmem_cb = pgstat_checkpointer_init_shmem_cb,
        .reset_all_cb = pgstat_checkpointer_reset_all_cb,
        .snapshot_cb = pgstat_checkpointer_snapshot_cb,
    },
 
    [PGSTAT_KIND_IO] = {
        .name = "io",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, io),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, io),
        .shared_data_off = offsetof(PgStatShared_IO, stats),
        .shared_data_len = sizeof(((PgStatShared_IO *) 0)->stats),
 
        .flush_static_cb = pgstat_io_flush_cb,
        .init_shmem_cb = pgstat_io_init_shmem_cb,
        .reset_all_cb = pgstat_io_reset_all_cb,
        .snapshot_cb = pgstat_io_snapshot_cb,
    },
 
    [PGSTAT_KIND_LOCK] = {
        .name = "lock",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, lock),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, lock),
        .shared_data_off = offsetof(PgStatShared_Lock, stats),
        .shared_data_len = sizeof(((PgStatShared_Lock *) 0)->stats),
 
        .flush_static_cb = pgstat_lock_flush_cb,
        .init_shmem_cb = pgstat_lock_init_shmem_cb,
        .reset_all_cb = pgstat_lock_reset_all_cb,
        .snapshot_cb = pgstat_lock_snapshot_cb,
    },
 
    [PGSTAT_KIND_SLRU] = {
        .name = "slru",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, slru),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, slru),
        .shared_data_off = offsetof(PgStatShared_SLRU, stats),
        .shared_data_len = sizeof(((PgStatShared_SLRU *) 0)->stats),
 
        .flush_static_cb = pgstat_slru_flush_cb,
        .init_shmem_cb = pgstat_slru_init_shmem_cb,
        .reset_all_cb = pgstat_slru_reset_all_cb,
        .snapshot_cb = pgstat_slru_snapshot_cb,
    },
 
    [PGSTAT_KIND_WAL] = {
        .name = "wal",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, wal),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, wal),
        .shared_data_off = offsetof(PgStatShared_Wal, stats),
        .shared_data_len = sizeof(((PgStatShared_Wal *) 0)->stats),
 
        .init_backend_cb = pgstat_wal_init_backend_cb,
        .flush_static_cb = pgstat_wal_flush_cb,
        .init_shmem_cb = pgstat_wal_init_shmem_cb,
        .reset_all_cb = pgstat_wal_reset_all_cb,
        .snapshot_cb = pgstat_wal_snapshot_cb,
    },
};
 
/*
 * Information about custom statistics kinds.
 *
 * These are saved in a different array than the built-in kinds to save
 * in clarity with the initializations.
 *
 * Indexed by PGSTAT_KIND_CUSTOM_MIN, of size PGSTAT_KIND_CUSTOM_SIZE.
 */
static const PgStat_KindInfo **pgstat_kind_custom_infos = NULL;
 
/* ------------------------------------------------------------
 * Functions managing the state of the stats system for all backends.
 * ------------------------------------------------------------
 */
 
/*
 * Read on-disk stats into memory at server start.
 *
 * Should only be called by the startup process or in single user mode.
 */
void
pgstat_restore_stats(void)
{
    pgstat_read_statsfile();
}
 
/*
 * Remove the stats file.  This is currently used only if WAL recovery is
 * needed after a crash.
 *
 * Should only be called by the startup process or in single user mode.
 */
void
pgstat_discard_stats(void)
{
    int         ret;
 
    /* NB: this needs to be done even in single user mode */
 
    /* First, cleanup the main pgstats file */
    ret = unlink(PGSTAT_STAT_PERMANENT_FILENAME);
    if (ret != 0)
    {
        if (errno == ENOENT)
            elog(DEBUG2,
                 "didn't need to unlink permanent stats file \"%s\" - didn't exist",
                 PGSTAT_STAT_PERMANENT_FILENAME);
        else
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not unlink permanent statistics file \"%s\": %m",
                            PGSTAT_STAT_PERMANENT_FILENAME)));
    }
    else
    {
        ereport(DEBUG2,
                (errcode_for_file_access(),
                 errmsg_internal("unlinked permanent statistics file \"%s\"",
                                 PGSTAT_STAT_PERMANENT_FILENAME)));
    }
 
    /* Finish callbacks, if required */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info && kind_info->finish)
            kind_info->finish(STATS_DISCARD);
    }
 
    /*
     * Reset stats contents. This will set reset timestamps of fixed-numbered
     * stats to the current time (no variable stats exist).
     */
    pgstat_reset_after_failure();
}
 
/*
 * pgstat_before_server_shutdown() needs to be called by exactly one process
 * during regular server shutdowns. Otherwise all stats will be lost.
 *
 * We currently only write out stats for proc_exit(0). We might want to change
 * that at some point... But right now pgstat_discard_stats() would be called
 * during the start after a disorderly shutdown, anyway.
 */
void
pgstat_before_server_shutdown(int code, Datum arg)
{
    Assert(pgStatLocal.shmem != NULL);
    Assert(!pgStatLocal.shmem->is_shutdown);
 
    /*
     * Stats should only be reported after pgstat_initialize() and before
     * pgstat_shutdown(). This is a convenient point to catch most violations
     * of this rule.
     */
    Assert(pgstat_is_initialized && !pgstat_is_shutdown);
 
    /* flush out our own pending changes before writing out */
    pgstat_report_stat(true);
 
    /*
     * Only write out file during normal shutdown. Don't even signal that
     * we've shutdown during irregular shutdowns, because the shutdown
     * sequence isn't coordinated to ensure this backend shuts down last.
     */
    if (code == 0)
    {
        pgStatLocal.shmem->is_shutdown = true;
        pgstat_write_statsfile();
    }
}
 
 
/* ------------------------------------------------------------
 * Backend initialization / shutdown functions
 * ------------------------------------------------------------
 */
 
/*
 * Shut down a single backend's statistics reporting at process exit.
 *
 * Flush out any remaining statistics counts.  Without this, operations
 * triggered during backend exit (such as temp table deletions) won't be
 * counted.
 */
static void
pgstat_shutdown_hook(int code, Datum arg)
{
    Assert(!pgstat_is_shutdown);
    Assert(IsUnderPostmaster || !IsPostmasterEnvironment);
 
    /*
     * If we got as far as discovering our own database ID, we can flush out
     * what we did so far.  Otherwise, we'd be reporting an invalid database
     * ID, so forget it.  (This means that accesses to pg_database during
     * failed backend starts might never get counted.)
     */
    if (OidIsValid(MyDatabaseId))
        pgstat_report_disconnect(MyDatabaseId);
 
    pgstat_report_stat(true);
 
    /* there shouldn't be any pending changes left */
    Assert(dlist_is_empty(&pgStatPending));
    dlist_init(&pgStatPending);
 
    /* drop the backend stats entry */
    if (!pgstat_drop_entry(PGSTAT_KIND_BACKEND, InvalidOid, MyProcNumber, false))
        pgstat_request_entry_refs_gc();
 
    pgstat_detach_shmem();
 
#ifdef USE_ASSERT_CHECKING
    pgstat_is_shutdown = true;
#endif
}
 
/*
 * Initialize pgstats state, and set up our on-proc-exit hook. Called from
 * BaseInit().
 *
 * NOTE: MyDatabaseId isn't set yet; so the shutdown hook has to be careful.
 */
void
pgstat_initialize(void)
{
    Assert(!pgstat_is_initialized);
 
    pgstat_attach_shmem();
 
    pgstat_init_snapshot_fixed();
 
    /* Backend initialization callbacks */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info == NULL || kind_info->init_backend_cb == NULL)
            continue;
 
        kind_info->init_backend_cb();
    }
 
    /* Set up a process-exit hook to clean up */
    before_shmem_exit(pgstat_shutdown_hook, 0);
 
#ifdef USE_ASSERT_CHECKING
    pgstat_is_initialized = true;
#endif
}
 
 
/* ------------------------------------------------------------
 * Public functions used by backends follow
 * ------------------------------------------------------------
 */
 
/*
 * Must be called by processes that performs DML: tcop/postgres.c, logical
 * receiver processes, SPI worker, etc. to flush pending statistics updates to
 * shared memory.
 *
 * Unless called with 'force', pending stats updates are flushed happen once
 * per PGSTAT_MIN_INTERVAL (1000ms). When not forced, stats flushes do not
 * block on lock acquisition, except if stats updates have been pending for
 * longer than PGSTAT_MAX_INTERVAL (60000ms).
 *
 * Whenever pending stats updates remain at the end of pgstat_report_stat() a
 * suggested idle timeout is returned. Currently this is always
 * PGSTAT_IDLE_INTERVAL (10000ms). Callers can use the returned time to set up
 * a timeout after which to call pgstat_report_stat(true), but are not
 * required to do so.
 *
 * Note that this is called only when not within a transaction, so it is fair
 * to use transaction stop time as an approximation of current time.
 */
long
pgstat_report_stat(bool force)
{
    static TimestampTz pending_since = 0;
    static TimestampTz last_flush = 0;
    bool        partial_flush;
    TimestampTz now;
    bool        nowait;
 
    pgstat_assert_is_up();
    Assert(!IsTransactionOrTransactionBlock());
 
    /* "absorb" the forced flush even if there's nothing to flush */
    if (pgStatForceNextFlush)
    {
        force = true;
        pgStatForceNextFlush = false;
    }
 
    /* Don't expend a clock check if nothing to do */
    if (dlist_is_empty(&pgStatPending) &&
        !pgstat_report_fixed)
    {
        return 0;
    }
 
    /*
     * There should never be stats to report once stats are shut down. Can't
     * assert that before the checks above, as there is an unconditional
     * pgstat_report_stat() call in pgstat_shutdown_hook() - which at least
     * the process that ran pgstat_before_server_shutdown() will still call.
     */
    Assert(!pgStatLocal.shmem->is_shutdown);
 
    if (force)
    {
        /*
         * Stats reports are forced either when it's been too long since stats
         * have been reported or in processes that force stats reporting to
         * happen at specific points (including shutdown). In the former case
         * the transaction stop time might be quite old, in the latter it
         * would never get cleared.
         */
        now = GetCurrentTimestamp();
    }
    else
    {
        now = GetCurrentTransactionStopTimestamp();
 
        if (pending_since > 0 &&
            TimestampDifferenceExceeds(pending_since, now, PGSTAT_MAX_INTERVAL))
        {
            /* don't keep pending updates longer than PGSTAT_MAX_INTERVAL */
            force = true;
        }
        else if (last_flush > 0 &&
                 !TimestampDifferenceExceeds(last_flush, now, PGSTAT_MIN_INTERVAL))
        {
            /* don't flush too frequently */
            if (pending_since == 0)
                pending_since = now;
 
            return PGSTAT_IDLE_INTERVAL;
        }
    }
 
    pgstat_update_dbstats(now);
 
    /* don't wait for lock acquisition when !force */
    nowait = !force;
 
    partial_flush = false;
 
    /* flush of variable-numbered stats tracked in pending entries list */
    partial_flush |= pgstat_flush_pending_entries(nowait);
 
    /* flush of other stats kinds */
    if (pgstat_report_fixed)
    {
        for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
        {
            const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
            if (!kind_info)
                continue;
            if (!kind_info->flush_static_cb)
                continue;
 
            partial_flush |= kind_info->flush_static_cb(nowait);
        }
    }
 
    last_flush = now;
 
    /*
     * If some of the pending stats could not be flushed due to lock
     * contention, let the caller know when to retry.
     */
    if (partial_flush)
    {
        /* force should have prevented us from getting here */
        Assert(!force);
 
        /* remember since when stats have been pending */
        if (pending_since == 0)
            pending_since = now;
 
        return PGSTAT_IDLE_INTERVAL;
    }
 
    pending_since = 0;
    pgstat_report_fixed = false;
 
    return 0;
}
 
/*
 * Force locally pending stats to be flushed during the next
 * pgstat_report_stat() call. This is useful for writing tests.
 */
void
pgstat_force_next_flush(void)
{
    pgStatForceNextFlush = true;
}
 
/*
 * Only for use by pgstat_reset_counters()
 */
static bool
match_db_entries(PgStatShared_HashEntry *entry, Datum match_data)
{
    return entry->key.dboid == MyDatabaseId;
}
 
/*
 * Reset counters for our database.
 *
 * Permission checking for this function is managed through the normal
 * GRANT system.
 */
void
pgstat_reset_counters(void)
{
    TimestampTz ts = GetCurrentTimestamp();
 
    pgstat_reset_matching_entries(match_db_entries,
                                  ObjectIdGetDatum(MyDatabaseId),
                                  ts);
}
 
/*
 * Reset a single variable-numbered entry.
 *
 * If the stats kind is within a database, also reset the database's
 * stat_reset_timestamp.
 *
 * Permission checking for this function is managed through the normal
 * GRANT system.
 */
void
pgstat_reset(PgStat_Kind kind, Oid dboid, uint64 objid)
{
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
    TimestampTz ts = GetCurrentTimestamp();
 
    /* not needed atm, and doesn't make sense with the current signature */
    Assert(!pgstat_get_kind_info(kind)->fixed_amount);
 
    /* reset the "single counter" */
    pgstat_reset_entry(kind, dboid, objid, ts);
 
    if (!kind_info->accessed_across_databases)
        pgstat_reset_database_timestamp(dboid, ts);
}
 
/*
 * Reset stats for all entries of a kind.
 *
 * Permission checking for this function is managed through the normal
 * GRANT system.
 */
void
pgstat_reset_of_kind(PgStat_Kind kind)
{
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
    TimestampTz ts = GetCurrentTimestamp();
 
    if (kind_info->fixed_amount)
        kind_info->reset_all_cb(ts);
    else
        pgstat_reset_entries_of_kind(kind, ts);
}
 
 
/* ------------------------------------------------------------
 * Fetching of stats
 * ------------------------------------------------------------
 */
 
/*
 * Discard any data collected in the current transaction.  Any subsequent
 * request will cause new snapshots to be read.
 *
 * This is also invoked during transaction commit or abort to discard
 * the no-longer-wanted snapshot.  Updates of stats_fetch_consistency can
 * cause this routine to be called.
 */
void
pgstat_clear_snapshot(void)
{
    pgstat_assert_is_up();
 
    memset(&pgStatLocal.snapshot.fixed_valid, 0,
           sizeof(pgStatLocal.snapshot.fixed_valid));
    memset(&pgStatLocal.snapshot.custom_valid, 0,
           sizeof(pgStatLocal.snapshot.custom_valid));
    pgStatLocal.snapshot.stats = NULL;
    pgStatLocal.snapshot.mode = PGSTAT_FETCH_CONSISTENCY_NONE;
 
    /* Release memory, if any was allocated */
    if (pgStatLocal.snapshot.context)
    {
        MemoryContextDelete(pgStatLocal.snapshot.context);
 
        /* Reset variables */
        pgStatLocal.snapshot.context = NULL;
    }
 
    /*
     * Historically the backend_status.c facilities lived in this file, and
     * were reset with the same function. For now keep it that way, and
     * forward the reset request.
     */
    pgstat_clear_backend_activity_snapshot();
 
    /* Reset this flag, as it may be possible that a cleanup was forced. */
    force_stats_snapshot_clear = false;
}
 
void *
pgstat_fetch_entry(PgStat_Kind kind, Oid dboid, uint64 objid, bool *may_free)
{
    PgStat_HashKey key = {0};
    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);
 
    /*
     * Initialize *may_free to false.  We'll change it to true later if we end
     * up allocating the result in the caller's context and not caching it.
     */
    if (may_free)
        *may_free = false;
 
    pgstat_prep_snapshot();
 
    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);
 
        /*
         * Since we allocated the result in the caller's context and aren't
         * caching it, the caller can safely pfree() it.
         */
        if (may_free)
            *may_free = true;
    }
    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;
}
 
/*
 * If a stats snapshot has been taken, return the timestamp at which that was
 * done, and set *have_snapshot to true. Otherwise *have_snapshot is set to
 * false.
 */
TimestampTz
pgstat_get_stat_snapshot_timestamp(bool *have_snapshot)
{
    if (force_stats_snapshot_clear)
        pgstat_clear_snapshot();
 
    if (pgStatLocal.snapshot.mode == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT)
    {
        *have_snapshot = true;
        return pgStatLocal.snapshot.snapshot_timestamp;
    }
 
    *have_snapshot = false;
 
    return 0;
}
 
bool
pgstat_have_entry(PgStat_Kind kind, Oid dboid, uint64 objid)
{
    /* fixed-numbered stats always exist */
    if (pgstat_get_kind_info(kind)->fixed_amount)
        return true;
 
    return pgstat_get_entry_ref(kind, dboid, objid, false, NULL) != NULL;
}
 
/*
 * Ensure snapshot for fixed-numbered 'kind' exists.
 *
 * Typically used by the pgstat_fetch_* functions for a kind of stats, before
 * massaging the data into the desired format.
 */
void
pgstat_snapshot_fixed(PgStat_Kind kind)
{
    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]);
}
 
static void
pgstat_init_snapshot_fixed(void)
{
    /*
     * Initialize fixed-numbered statistics data in snapshots, only for custom
     * stats kinds.
     */
    for (PgStat_Kind kind = PGSTAT_KIND_CUSTOM_MIN; kind <= PGSTAT_KIND_CUSTOM_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (!kind_info || !kind_info->fixed_amount)
            continue;
 
        pgStatLocal.snapshot.custom_data[kind - PGSTAT_KIND_CUSTOM_MIN] =
            MemoryContextAlloc(TopMemoryContext, kind_info->shared_data_len);
    }
}
 
static void
pgstat_prep_snapshot(void)
{
    if (force_stats_snapshot_clear)
        pgstat_clear_snapshot();
 
    if (pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_NONE ||
        pgStatLocal.snapshot.stats != NULL)
        return;
 
    if (!pgStatLocal.snapshot.context)
        pgStatLocal.snapshot.context = AllocSetContextCreate(TopMemoryContext,
                                                             "PgStat Snapshot",
                                                             ALLOCSET_SMALL_SIZES);
 
    pgStatLocal.snapshot.stats =
        pgstat_snapshot_create(pgStatLocal.snapshot.context,
                               PGSTAT_SNAPSHOT_HASH_SIZE,
                               NULL);
}
 
static void
pgstat_build_snapshot(void)
{
    dshash_seq_status hstat;
    PgStatShared_HashEntry *p;
 
    /* should only be called when we need a snapshot */
    Assert(pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT);
 
    /* snapshot already built */
    if (pgStatLocal.snapshot.mode == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT)
        return;
 
    pgstat_prep_snapshot();
 
    Assert(pgStatLocal.snapshot.stats->members == 0);
 
    pgStatLocal.snapshot.snapshot_timestamp = GetCurrentTimestamp();
 
    /*
     * Snapshot all variable stats.
     */
    dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
    while ((p = dshash_seq_next(&hstat)) != NULL)
    {
        PgStat_Kind kind = p->key.kind;
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
        bool        found;
        PgStat_SnapshotEntry *entry;
        PgStatShared_Common *stats_data;
 
        /*
         * Check if the stats object should be included in the snapshot.
         * Unless the stats kind can be accessed from all databases (e.g.,
         * database stats themselves), we only include stats for the current
         * database or objects not associated with a database (e.g. shared
         * relations).
         */
        if (p->key.dboid != MyDatabaseId &&
            p->key.dboid != InvalidOid &&
            !kind_info->accessed_across_databases)
            continue;
 
        if (p->dropped)
            continue;
 
        Assert(pg_atomic_read_u32(&p->refcount) > 0);
 
        stats_data = dsa_get_address(pgStatLocal.dsa, p->body);
        Assert(stats_data);
 
        entry = pgstat_snapshot_insert(pgStatLocal.snapshot.stats, p->key, &found);
        Assert(!found);
 
        entry->data = MemoryContextAlloc(pgStatLocal.snapshot.context,
                                         pgstat_get_entry_len(kind));
 
        /*
         * Acquire the LWLock directly instead of using
         * pg_stat_lock_entry_shared() which requires a reference.
         */
        LWLockAcquire(&stats_data->lock, LW_SHARED);
        memcpy(entry->data,
               pgstat_get_entry_data(kind, stats_data),
               pgstat_get_entry_len(kind));
        LWLockRelease(&stats_data->lock);
    }
    dshash_seq_term(&hstat);
 
    /*
     * Build snapshot of all fixed-numbered stats.
     */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (!kind_info)
            continue;
        if (!kind_info->fixed_amount)
        {
            Assert(kind_info->snapshot_cb == NULL);
            continue;
        }
 
        pgstat_build_snapshot_fixed(kind);
    }
 
    pgStatLocal.snapshot.mode = PGSTAT_FETCH_CONSISTENCY_SNAPSHOT;
}
 
static void
pgstat_build_snapshot_fixed(PgStat_Kind kind)
{
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
    int         idx;
    bool       *valid;
 
    /* Position in fixed_valid or custom_valid */
    if (pgstat_is_kind_builtin(kind))
    {
        idx = kind;
        valid = pgStatLocal.snapshot.fixed_valid;
    }
    else
    {
        idx = kind - PGSTAT_KIND_CUSTOM_MIN;
        valid = pgStatLocal.snapshot.custom_valid;
    }
 
    Assert(kind_info->fixed_amount);
    Assert(kind_info->snapshot_cb != NULL);
 
    if (pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_NONE)
    {
        /* rebuild every time */
        valid[idx] = false;
    }
    else if (valid[idx])
    {
        /* in snapshot mode we shouldn't get called again */
        Assert(pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_CACHE);
        return;
    }
 
    Assert(!valid[idx]);
 
    kind_info->snapshot_cb();
 
    Assert(!valid[idx]);
    valid[idx] = true;
}
 
 
/* ------------------------------------------------------------
 * Backend-local pending stats infrastructure
 * ------------------------------------------------------------
 */
 
/*
 * Returns the appropriate PgStat_EntryRef, preparing it to receive pending
 * stats if not already done.
 *
 * If created_entry is non-NULL, it'll be set to true if the entry is newly
 * created, false otherwise.
 */
PgStat_EntryRef *
pgstat_prep_pending_entry(PgStat_Kind kind, Oid dboid, uint64 objid, bool *created_entry)
{
    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;
}
 
/*
 * Return an existing stats entry, or NULL.
 *
 * This should only be used for helper function for pgstatfuncs.c - outside of
 * that it shouldn't be needed.
 */
PgStat_EntryRef *
pgstat_fetch_pending_entry(PgStat_Kind kind, Oid dboid, uint64 objid)
{
    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;
}
 
void
pgstat_delete_pending_entry(PgStat_EntryRef *entry_ref)
{
    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);
}
 
/*
 * Flush out pending variable-numbered stats.
 */
static bool
pgstat_flush_pending_entries(bool nowait)
{
    bool        have_pending = false;
    dlist_node *cur = NULL;
 
    /*
     * Need to be a bit careful iterating over the list of pending entries.
     * Processing a pending entry may queue further pending entries to the end
     * of the list that we want to process, so a simple iteration won't do.
     * Further complicating matters is that we want to delete the current
     * entry in each iteration from the list if we flushed successfully.
     *
     * So we just keep track of the next pointer in each loop iteration.
     */
    if (!dlist_is_empty(&pgStatPending))
        cur = dlist_head_node(&pgStatPending);
 
    while (cur)
    {
        PgStat_EntryRef *entry_ref =
            dlist_container(PgStat_EntryRef, pending_node, cur);
        PgStat_HashKey key = entry_ref->shared_entry->key;
        PgStat_Kind kind = key.kind;
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
        bool        did_flush;
        dlist_node *next;
 
        Assert(!kind_info->fixed_amount);
        Assert(kind_info->flush_pending_cb != NULL);
 
        /* flush the stats, if possible */
        did_flush = kind_info->flush_pending_cb(entry_ref, nowait);
 
        Assert(did_flush || nowait);
 
        /* determine next entry, before deleting the pending entry */
        if (dlist_has_next(&pgStatPending, cur))
            next = dlist_next_node(&pgStatPending, cur);
        else
            next = NULL;
 
        /* if successfully flushed, remove entry */
        if (did_flush)
            pgstat_delete_pending_entry(entry_ref);
        else
            have_pending = true;
 
        cur = next;
    }
 
    Assert(dlist_is_empty(&pgStatPending) == !have_pending);
 
    return have_pending;
}
 
 
/* ------------------------------------------------------------
 * Helper / infrastructure functions
 * ------------------------------------------------------------
 */
 
PgStat_Kind
pgstat_get_kind_from_str(char *kind_str)
{
    for (PgStat_Kind kind = PGSTAT_KIND_BUILTIN_MIN; kind <= PGSTAT_KIND_BUILTIN_MAX; kind++)
    {
        if (pg_strcasecmp(kind_str, pgstat_kind_builtin_infos[kind].name) == 0)
            return kind;
    }
 
    /* Check the custom set of cumulative stats */
    if (pgstat_kind_custom_infos)
    {
        for (PgStat_Kind kind = PGSTAT_KIND_CUSTOM_MIN; kind <= PGSTAT_KIND_CUSTOM_MAX; kind++)
        {
            uint32      idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
            if (pgstat_kind_custom_infos[idx] &&
                pg_strcasecmp(kind_str, pgstat_kind_custom_infos[idx]->name) == 0)
                return kind;
        }
    }
 
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("invalid statistics kind: \"%s\"", kind_str)));
    return PGSTAT_KIND_INVALID; /* avoid compiler warnings */
}
 
static inline bool
pgstat_is_kind_valid(PgStat_Kind kind)
{
    return pgstat_is_kind_builtin(kind) || pgstat_is_kind_custom(kind);
}
 
const PgStat_KindInfo *
pgstat_get_kind_info(PgStat_Kind kind)
{
    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;
}
 
/*
 * Register a new stats kind.
 *
 * PgStat_Kinds must be globally unique across all extensions. Refer
 * to https://wiki.postgresql.org/wiki/CustomCumulativeStats to reserve a
 * unique ID for your extension, to avoid conflicts with other extension
 * developers. During development, use PGSTAT_KIND_EXPERIMENTAL to avoid
 * needlessly reserving a new ID.
 */
void
pgstat_register_kind(PgStat_Kind kind, const PgStat_KindInfo *kind_info)
{
    uint32      idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
    if (kind_info->name == NULL || strlen(kind_info->name) == 0)
        ereport(ERROR,
                (errmsg("failed to register custom cumulative statistics with ID %u", kind),
                 errhint("Provide a non-empty name for the custom cumulative statistics.")));
 
    if (!pgstat_is_kind_custom(kind))
        ereport(ERROR, (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, 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 \"%s\".",
                           "shared_preload_libraries")));
 
    /*
     * Check some data for fixed-numbered stats.
     */
    if (kind_info->fixed_amount)
    {
        if (kind_info->shared_size == 0)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a shared memory size for fixed-numbered objects.")));
        if (kind_info->init_shmem_cb == NULL)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a \"%s\" callback for fixed-numbered objects.",
                             "init_shmem_cb")));
        if (kind_info->reset_all_cb == NULL)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a \"%s\" callback for fixed-numbered objects.",
                             "reset_all_cb")));
        if (kind_info->snapshot_cb == NULL)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a \"%s\" callback for fixed-numbered objects.",
                             "snapshot_cb")));
        if (kind_info->track_entry_count)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics cannot use entry count tracking for fixed-numbered objects.")));
    }
    else
    {
        if (kind_info->pending_size > 0 && kind_info->flush_pending_cb == NULL)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a \"%s\" callback when pending size is set.",
                             "flush_pending_cb")));
    }
 
    /*
     * 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)));
}
 
/*
 * Stats should only be reported after pgstat_initialize() and before
 * pgstat_shutdown(). This check is put in a few central places to catch
 * violations of this rule more easily.
 */
#ifdef USE_ASSERT_CHECKING
void
pgstat_assert_is_up(void)
{
    Assert(pgstat_is_initialized && !pgstat_is_shutdown);
}
#endif
 
 
/* ------------------------------------------------------------
 * reading and writing of on-disk stats file
 * ------------------------------------------------------------
 */
 
#define write_chunk_s(fpout, ptr) write_chunk(fpout, ptr, sizeof(*ptr))
#define read_chunk_s(fpin, ptr) read_chunk(fpin, ptr, sizeof(*ptr))
 
/* helpers for pgstat_write_statsfile() */
static void
write_chunk(FILE *fpout, void *ptr, size_t len)
{
    int         rc;
 
    rc = fwrite(ptr, len, 1, fpout);
 
    /* we'll check for errors with ferror once at the end */
    (void) rc;
}
 
/*
 * This function is called in the last process that is accessing the shared
 * stats so locking is not required.
 */
static void
pgstat_write_statsfile(void)
{
    FILE       *fpout;
    int32       format_id;
    const char *tmpfile = PGSTAT_STAT_PERMANENT_TMPFILE;
    const char *statfile = PGSTAT_STAT_PERMANENT_FILENAME;
    dshash_seq_status hstat;
    PgStatShared_HashEntry *ps;
    PgStat_StatsFileOp status = STATS_WRITE;
 
    pgstat_assert_is_up();
 
    /* should be called only by the checkpointer or single user mode */
    Assert(!IsUnderPostmaster || MyBackendType == B_CHECKPOINTER);
 
    /* we're shutting down, so it's ok to just override this */
    pgstat_fetch_consistency = PGSTAT_FETCH_CONSISTENCY_NONE;
 
    elog(DEBUG2, "writing stats file \"%s\"", statfile);
 
    /*
     * Open the statistics temp file to write out the current values.
     */
    fpout = AllocateFile(tmpfile, PG_BINARY_W);
    if (fpout == NULL)
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not open temporary statistics file \"%s\": %m",
                        tmpfile)));
        return;
    }
 
    /*
     * Write the file header --- currently just a format ID.
     */
    format_id = PGSTAT_FILE_FORMAT_ID;
    write_chunk_s(fpout, &format_id);
 
    /* Write various stats structs for fixed number of objects */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        char       *ptr;
        const PgStat_KindInfo *info = pgstat_get_kind_info(kind);
 
        if (!info || !info->fixed_amount)
            continue;
 
        if (pgstat_is_kind_builtin(kind))
            Assert(info->snapshot_ctl_off != 0);
 
        /* skip if no need to write to file */
        if (!info->write_to_file)
            continue;
 
        pgstat_build_snapshot_fixed(kind);
        if (pgstat_is_kind_builtin(kind))
            ptr = ((char *) &pgStatLocal.snapshot) + info->snapshot_ctl_off;
        else
            ptr = pgStatLocal.snapshot.custom_data[kind - PGSTAT_KIND_CUSTOM_MIN];
 
        fputc(PGSTAT_FILE_ENTRY_FIXED, fpout);
        write_chunk_s(fpout, &kind);
        write_chunk(fpout, ptr, info->shared_data_len);
    }
 
    /*
     * Walk through the stats entries
     */
    dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
    while ((ps = dshash_seq_next(&hstat)) != NULL)
    {
        PgStatShared_Common *shstats;
        const PgStat_KindInfo *kind_info = NULL;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * We should not see any "dropped" entries when writing the stats
         * file, as all backends and auxiliary processes should have cleaned
         * up their references before they terminated.
         *
         * However, since we are already shutting down, it is not worth
         * crashing the server over any potential cleanup issues, so we simply
         * skip such entries if encountered.
         */
        Assert(!ps->dropped);
        if (ps->dropped)
            continue;
 
        /*
         * This discards data related to custom stats kinds that are unknown
         * to this process.
         */
        if (!pgstat_is_kind_valid(ps->key.kind))
        {
            elog(WARNING, "found unknown stats entry %u/%u/%" PRIu64,
                 ps->key.kind, ps->key.dboid,
                 ps->key.objid);
            continue;
        }
 
        shstats = (PgStatShared_Common *) dsa_get_address(pgStatLocal.dsa, ps->body);
 
        kind_info = pgstat_get_kind_info(ps->key.kind);
 
        /* if not dropped the valid-entry refcount should exist */
        Assert(pg_atomic_read_u32(&ps->refcount) > 0);
 
        /* skip if no need to write to file */
        if (!kind_info->write_to_file)
            continue;
 
        if (!kind_info->to_serialized_name)
        {
            /* normal stats entry, identified by PgStat_HashKey */
            fputc(PGSTAT_FILE_ENTRY_HASH, fpout);
            write_chunk_s(fpout, &ps->key);
        }
        else
        {
            /* stats entry identified by name on disk (e.g. slots) */
            NameData    name;
 
            kind_info->to_serialized_name(&ps->key, shstats, &name);
 
            fputc(PGSTAT_FILE_ENTRY_NAME, fpout);
            write_chunk_s(fpout, &ps->key.kind);
            write_chunk_s(fpout, &name);
        }
 
        /* Write except the header part of the entry */
        write_chunk(fpout,
                    pgstat_get_entry_data(ps->key.kind, shstats),
                    pgstat_get_entry_len(ps->key.kind));
 
        /* Write more data for the entry, if required */
        if (kind_info->to_serialized_data &&
            !kind_info->to_serialized_data(&ps->key, shstats, fpout))
        {
            status = STATS_DISCARD;
            break;
        }
    }
    dshash_seq_term(&hstat);
 
    /*
     * No more output to be done. Close the temp file and replace the old
     * pgstat.stat with it.  The ferror() check replaces testing for error
     * after each individual fputc or fwrite (in write_chunk()) above.
     */
    fputc(PGSTAT_FILE_ENTRY_END, fpout);
 
    if (status == STATS_DISCARD)
    {
        /*
         * A to_serialized_data callback failed.  DEBUG2 because the callback
         * already logged the reason.
         */
        elog(DEBUG2, "discarding temporary statistics file \"%s\"", tmpfile);
        FreeFile(fpout);
        unlink(tmpfile);
    }
    else if (ferror(fpout))
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not write temporary statistics file \"%s\": %m",
                        tmpfile)));
        FreeFile(fpout);
        unlink(tmpfile);
        status = STATS_DISCARD;
    }
    else if (FreeFile(fpout) < 0)
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not close temporary statistics file \"%s\": %m",
                        tmpfile)));
        unlink(tmpfile);
        status = STATS_DISCARD;
    }
    else if (durable_rename(tmpfile, statfile, LOG) < 0)
    {
        /* durable_rename already emitted log message */
        unlink(tmpfile);
        status = STATS_DISCARD;
    }
 
    /* Finish callbacks, if required */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info && kind_info->finish)
            kind_info->finish(status);
    }
}
 
/* helpers for pgstat_read_statsfile() */
static bool
read_chunk(FILE *fpin, void *ptr, size_t len)
{
    return fread(ptr, 1, len, fpin) == len;
}
 
/*
 * Reads in existing statistics file into memory.
 *
 * This function is called in the only process that is accessing the shared
 * stats so locking is not required.
 */
static void
pgstat_read_statsfile(void)
{
    FILE       *fpin;
    int32       format_id;
    bool        found;
    PgStat_StatsFileOp status = STATS_READ;
    const char *statfile = PGSTAT_STAT_PERMANENT_FILENAME;
    PgStat_ShmemControl *shmem = pgStatLocal.shmem;
 
    /* shouldn't be called from postmaster */
    Assert(IsUnderPostmaster || !IsPostmasterEnvironment);
 
    elog(DEBUG2, "reading stats file \"%s\"", statfile);
 
    /*
     * Try to open the stats file. If it doesn't exist, the backends simply
     * returns zero for anything and statistics simply starts from scratch
     * with empty counters.
     *
     * ENOENT is a possibility if stats collection was previously disabled or
     * has not yet written the stats file for the first time.  Any other
     * failure condition is suspicious.
     */
    if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
    {
        if (errno != ENOENT)
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not open statistics file \"%s\": %m",
                            statfile)));
        pgstat_reset_after_failure();
        status = STATS_DISCARD;
        goto finish;
    }
 
    /*
     * Verify it's of the expected format.
     */
    if (!read_chunk_s(fpin, &format_id))
    {
        elog(WARNING, "could not read format ID");
        goto error;
    }
 
    if (format_id != PGSTAT_FILE_FORMAT_ID)
    {
        elog(WARNING, "found incorrect format ID %d (expected %d)",
             format_id, PGSTAT_FILE_FORMAT_ID);
        goto error;
    }
 
    /*
     * We found an existing statistics file. Read it and put all the stats
     * data into place.
     */
    for (;;)
    {
        int         t = fgetc(fpin);
 
        switch (t)
        {
            case PGSTAT_FILE_ENTRY_FIXED:
                {
                    PgStat_Kind kind;
                    const PgStat_KindInfo *info;
                    char       *ptr;
 
                    /* entry for fixed-numbered stats */
                    if (!read_chunk_s(fpin, &kind))
                    {
                        elog(WARNING, "could not read stats kind for entry of type %c", t);
                        goto error;
                    }
 
                    if (!pgstat_is_kind_valid(kind))
                    {
                        elog(WARNING, "invalid stats kind %u for entry of type %c",
                             kind, t);
                        goto error;
                    }
 
                    info = pgstat_get_kind_info(kind);
                    if (!info)
                    {
                        elog(WARNING, "could not find information of kind %u for entry of type %c",
                             kind, t);
                        goto error;
                    }
 
                    if (!info->fixed_amount)
                    {
                        elog(WARNING, "invalid fixed_amount in stats kind %u for entry of type %c",
                             kind, t);
                        goto error;
                    }
 
                    /* Load back stats into shared memory */
                    if (pgstat_is_kind_builtin(kind))
                        ptr = ((char *) shmem) + info->shared_ctl_off +
                            info->shared_data_off;
                    else
                    {
                        int         idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
                        ptr = ((char *) shmem->custom_data[idx]) +
                            info->shared_data_off;
                    }
 
                    if (!read_chunk(fpin, ptr, info->shared_data_len))
                    {
                        elog(WARNING, "could not read data of stats kind %u for entry of type %c with size %u",
                             kind, t, info->shared_data_len);
                        goto error;
                    }
 
                    break;
                }
            case PGSTAT_FILE_ENTRY_HASH:
            case PGSTAT_FILE_ENTRY_NAME:
                {
                    PgStat_HashKey key;
                    PgStatShared_HashEntry *p;
                    PgStatShared_Common *header;
                    const PgStat_KindInfo *kind_info = NULL;
 
                    CHECK_FOR_INTERRUPTS();
 
                    if (t == PGSTAT_FILE_ENTRY_HASH)
                    {
                        /* normal stats entry, identified by PgStat_HashKey */
                        if (!read_chunk_s(fpin, &key))
                        {
                            elog(WARNING, "could not read key for entry of type %c", t);
                            goto error;
                        }
 
                        if (!pgstat_is_kind_valid(key.kind))
                        {
                            elog(WARNING, "invalid stats kind for entry %u/%u/%" PRIu64 " of type %c",
                                 key.kind, key.dboid,
                                 key.objid, t);
                            goto error;
                        }
 
                        kind_info = pgstat_get_kind_info(key.kind);
                        if (!kind_info)
                        {
                            elog(WARNING, "could not find information of kind for entry %u/%u/%" PRIu64 " of type %c",
                                 key.kind, key.dboid,
                                 key.objid, t);
                            goto error;
                        }
                    }
                    else
                    {
                        /* stats entry identified by name on disk (e.g. slots) */
                        PgStat_Kind kind;
                        NameData    name;
 
                        if (!read_chunk_s(fpin, &kind))
                        {
                            elog(WARNING, "could not read stats kind for entry of type %c", t);
                            goto error;
                        }
                        if (!read_chunk_s(fpin, &name))
                        {
                            elog(WARNING, "could not read name of stats kind %u for entry of type %c",
                                 kind, t);
                            goto error;
                        }
                        if (!pgstat_is_kind_valid(kind))
                        {
                            elog(WARNING, "invalid stats kind %u for entry of type %c",
                                 kind, t);
                            goto error;
                        }
 
                        kind_info = pgstat_get_kind_info(kind);
                        if (!kind_info)
                        {
                            elog(WARNING, "could not find information of kind %u for entry of type %c",
                                 kind, t);
                            goto error;
                        }
 
                        if (!kind_info->from_serialized_name)
                        {
                            elog(WARNING, "invalid from_serialized_name in stats kind %u for entry of type %c",
                                 kind, t);
                            goto error;
                        }
 
                        if (!kind_info->from_serialized_name(&name, &key))
                        {
                            /* skip over data for entry we don't care about */
                            if (fseek(fpin, pgstat_get_entry_len(kind), SEEK_CUR) != 0)
                            {
                                elog(WARNING, "could not seek \"%s\" of stats kind %u for entry of type %c",
                                     NameStr(name), kind, t);
                                goto error;
                            }
 
                            continue;
                        }
 
                        Assert(key.kind == kind);
                    }
 
                    /*
                     * This intentionally doesn't use pgstat_get_entry_ref() -
                     * putting all stats into checkpointer's
                     * pgStatEntryRefHash would be wasted effort and memory.
                     */
                    p = dshash_find_or_insert(pgStatLocal.shared_hash, &key, &found);
 
                    /* don't allow duplicate entries */
                    if (found)
                    {
                        dshash_release_lock(pgStatLocal.shared_hash, p);
                        elog(WARNING, "found duplicate stats entry %u/%u/%" PRIu64 " of type %c",
                             key.kind, key.dboid,
                             key.objid, t);
                        goto error;
                    }
 
                    header = pgstat_init_entry(key.kind, p);
                    dshash_release_lock(pgStatLocal.shared_hash, p);
                    if (header == NULL)
                    {
                        /*
                         * It would be tempting to switch this ERROR to a
                         * WARNING, but it would mean that all the statistics
                         * are discarded when the environment fails on OOM.
                         */
                        elog(ERROR, "could not allocate entry %u/%u/%" PRIu64 " of type %c",
                             key.kind, key.dboid,
                             key.objid, t);
                    }
 
                    if (!read_chunk(fpin,
                                    pgstat_get_entry_data(key.kind, header),
                                    pgstat_get_entry_len(key.kind)))
                    {
                        elog(WARNING, "could not read data for entry %u/%u/%" PRIu64 " of type %c",
                             key.kind, key.dboid,
                             key.objid, t);
                        goto error;
                    }
 
                    /* read more data for the entry, if required */
                    if (kind_info->from_serialized_data)
                    {
                        if (!kind_info->from_serialized_data(&key, header, fpin))
                        {
                            elog(WARNING, "could not read auxiliary data for entry %u/%u/%" PRIu64 " of type %c",
                                 key.kind, key.dboid,
                                 key.objid, t);
                            goto error;
                        }
                    }
 
                    break;
                }
            case PGSTAT_FILE_ENTRY_END:
 
                /*
                 * check that PGSTAT_FILE_ENTRY_END actually signals end of
                 * file
                 */
                if (fgetc(fpin) != EOF)
                {
                    elog(WARNING, "could not read end-of-file");
                    goto error;
                }
 
                goto done;
 
            default:
                elog(WARNING, "could not read entry of type %c", t);
                goto error;
        }
    }
 
done:
    /* First, cleanup the main stats file */
    FreeFile(fpin);
 
    elog(DEBUG2, "removing permanent stats file \"%s\"", statfile);
    unlink(statfile);
 
finish:
    /* Finish callbacks, if required */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info && kind_info->finish)
            kind_info->finish(status);
    }
 
    return;
 
error:
    ereport(LOG,
            (errmsg("corrupted statistics file \"%s\"", statfile)));
 
    pgstat_reset_after_failure();
    status = STATS_DISCARD;
 
    goto done;
}
 
/*
 * Helper to reset / drop stats after a crash or after restoring stats from
 * disk failed, potentially after already loading parts.
 */
static void
pgstat_reset_after_failure(void)
{
    TimestampTz ts = GetCurrentTimestamp();
 
    /* reset fixed-numbered stats */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (!kind_info || !kind_info->fixed_amount)
            continue;
 
        kind_info->reset_all_cb(ts);
    }
 
    /* and drop variable-numbered ones */
    pgstat_drop_all_entries();
}
 
/*
 * GUC assign_hook for stats_fetch_consistency.
 */
void
assign_stats_fetch_consistency(int newval, void *extra)
{
    /*
     * Changing this value in a transaction may cause snapshot state
     * inconsistencies, so force a clear of the current snapshot on the next
     * snapshot build attempt.
     */
    if (pgstat_fetch_consistency != newval)
        force_stats_snapshot_clear = true;
}

PGSTAT_FILE_ENTRY_NAME

#define PGSTAT_FILE_ENTRY_NAME   'N' /* stats entry identified by name */

Definition at line 146 of file pgstat.c.

PGSTAT_IDLE_INTERVAL

#define PGSTAT_IDLE_INTERVAL   10000

Definition at line 131 of file pgstat.c.

PGSTAT_MAX_INTERVAL

#define PGSTAT_MAX_INTERVAL   60000

Definition at line 129 of file pgstat.c.

PGSTAT_MIN_INTERVAL

#define PGSTAT_MIN_INTERVAL   1000

Definition at line 127 of file pgstat.c.

PGSTAT_SNAPSHOT_HASH_SIZE

#define PGSTAT_SNAPSHOT_HASH_SIZE   512

Definition at line 138 of file pgstat.c.

read_chunk_s

#define read_chunk_s	(		fpin,
			ptr
	)		read_chunk(fpin, ptr, sizeof(*ptr))

Definition at line 1622 of file pgstat.c.

SH_DECLARE

#define SH_DECLARE

Definition at line 174 of file pgstat.c.

SH_DEFINE

#define SH_DEFINE

Definition at line 173 of file pgstat.c.

SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE   PgStat_SnapshotEntry

Definition at line 165 of file pgstat.c.

SH_EQUAL

#define SH_EQUAL	(		tb,
			a,
			b
	)		pgstat_cmp_hash_key(&a, &b, sizeof(PgStat_HashKey), NULL) == 0

Definition at line 170 of file pgstat.c.

SH_HASH_KEY

#define SH_HASH_KEY	(		tb,
			key
	)		pgstat_hash_hash_key(&key, sizeof(PgStat_HashKey), NULL)

Definition at line 168 of file pgstat.c.

SH_KEY

#define SH_KEY   key

Definition at line 167 of file pgstat.c.

SH_KEY_TYPE

#define SH_KEY_TYPE   PgStat_HashKey

Definition at line 166 of file pgstat.c.

SH_PREFIX

#define SH_PREFIX   pgstat_snapshot

Definition at line 164 of file pgstat.c.

SH_SCOPE

#define SH_SCOPE   static inline

Definition at line 172 of file pgstat.c.

write_chunk_s

#define write_chunk_s	(		fpout,
			ptr
	)		write_chunk(fpout, ptr, sizeof(*ptr))

Definition at line 1621 of file pgstat.c.

Typedef Documentation

PgStat_SnapshotEntry

typedef struct PgStat_SnapshotEntry PgStat_SnapshotEntry

Function Documentation

assign_stats_fetch_consistency()

void assign_stats_fetch_consistency	(	int	newval,
		void *	extra
	)

Definition at line 2194 of file pgstat.c.

{
    /*
     * Changing this value in a transaction may cause snapshot state
     * inconsistencies, so force a clear of the current snapshot on the next
     * snapshot build attempt.
     */
    if (pgstat_fetch_consistency != newval)
        force_stats_snapshot_clear = true;

References force_stats_snapshot_clear, newval, and pgstat_fetch_consistency.

match_db_entries()

static bool match_db_entries ( PgStatShared_HashEntry *  entry, Datum  match_data  )

static

Definition at line 851 of file pgstat.c.

{
    return entry->key.dboid == MyDatabaseId;

References PgStat_HashKey::dboid, PgStatShared_HashEntry::key, and MyDatabaseId.

Referenced by pgstat_reset_counters().

pgstat_before_server_shutdown()

void pgstat_before_server_shutdown	(	int	code,
		Datum	arg
	)

Definition at line 590 of file pgstat.c.

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

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

Referenced by CheckpointerMain(), and InitPostgres().

pgstat_build_snapshot()

static void pgstat_build_snapshot ( void  )

static

Definition at line 1164 of file pgstat.c.

{
    dshash_seq_status hstat;
    PgStatShared_HashEntry *p;
 
    /* should only be called when we need a snapshot */
    Assert(pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT);
 
    /* snapshot already built */
    if (pgStatLocal.snapshot.mode == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT)
        return;
 
    pgstat_prep_snapshot();
 
    Assert(pgStatLocal.snapshot.stats->members == 0);
 
    pgStatLocal.snapshot.snapshot_timestamp = GetCurrentTimestamp();
 
    /*
     * Snapshot all variable stats.
     */
    dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
    while ((p = dshash_seq_next(&hstat)) != NULL)
    {
        PgStat_Kind kind = p->key.kind;
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
        bool        found;
        PgStat_SnapshotEntry *entry;
        PgStatShared_Common *stats_data;
 
        /*
         * Check if the stats object should be included in the snapshot.
         * Unless the stats kind can be accessed from all databases (e.g.,
         * database stats themselves), we only include stats for the current
         * database or objects not associated with a database (e.g. shared
         * relations).
         */
        if (p->key.dboid != MyDatabaseId &&
            p->key.dboid != InvalidOid &&
            !kind_info->accessed_across_databases)
            continue;
 
        if (p->dropped)
            continue;
 
        Assert(pg_atomic_read_u32(&p->refcount) > 0);
 
        stats_data = dsa_get_address(pgStatLocal.dsa, p->body);
        Assert(stats_data);
 
        entry = pgstat_snapshot_insert(pgStatLocal.snapshot.stats, p->key, &found);
        Assert(!found);
 
        entry->data = MemoryContextAlloc(pgStatLocal.snapshot.context,
                                         pgstat_get_entry_len(kind));
 
        /*
         * Acquire the LWLock directly instead of using
         * pg_stat_lock_entry_shared() which requires a reference.
         */
        LWLockAcquire(&stats_data->lock, LW_SHARED);
        memcpy(entry->data,
               pgstat_get_entry_data(kind, stats_data),
               pgstat_get_entry_len(kind));
        LWLockRelease(&stats_data->lock);
    }
    dshash_seq_term(&hstat);
 
    /*
     * Build snapshot of all fixed-numbered stats.
     */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (!kind_info)
            continue;
        if (!kind_info->fixed_amount)
        {
            Assert(kind_info->snapshot_cb == NULL);
            continue;
        }
 
        pgstat_build_snapshot_fixed(kind);
    }
 
    pgStatLocal.snapshot.mode = PGSTAT_FETCH_CONSISTENCY_SNAPSHOT;

References Assert, PgStatShared_HashEntry::body, PgStat_Snapshot::context, PgStat_SnapshotEntry::data, PgStat_HashKey::dboid, PgStatShared_HashEntry::dropped, PgStat_LocalState::dsa, dsa_get_address(), dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), fb(), GetCurrentTimestamp(), InvalidOid, PgStatShared_HashEntry::key, PgStat_HashKey::kind, LW_SHARED, LWLockAcquire(), LWLockRelease(), memcpy(), MemoryContextAlloc(), PgStat_Snapshot::mode, MyDatabaseId, pg_atomic_read_u32(), pgstat_build_snapshot_fixed(), pgstat_fetch_consistency, PGSTAT_FETCH_CONSISTENCY_SNAPSHOT, pgstat_get_entry_data(), pgstat_get_entry_len(), pgstat_get_kind_info(), PgStat_Kind, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, pgstat_prep_snapshot(), pgStatLocal, PgStatShared_HashEntry::refcount, PgStat_LocalState::shared_hash, PgStat_LocalState::snapshot, PgStat_Snapshot::snapshot_timestamp, and PgStat_Snapshot::stats.

Referenced by pgstat_fetch_entry(), and pgstat_snapshot_fixed().

pgstat_build_snapshot_fixed()

static void pgstat_build_snapshot_fixed ( PgStat_Kind  kind )

static

Definition at line 1254 of file pgstat.c.

{
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
    int         idx;
    bool       *valid;
 
    /* Position in fixed_valid or custom_valid */
    if (pgstat_is_kind_builtin(kind))
    {
        idx = kind;
        valid = pgStatLocal.snapshot.fixed_valid;
    }
    else
    {
        idx = kind - PGSTAT_KIND_CUSTOM_MIN;
        valid = pgStatLocal.snapshot.custom_valid;
    }
 
    Assert(kind_info->fixed_amount);
    Assert(kind_info->snapshot_cb != NULL);
 
    if (pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_NONE)
    {
        /* rebuild every time */
        valid[idx] = false;
    }
    else if (valid[idx])
    {
        /* in snapshot mode we shouldn't get called again */
        Assert(pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_CACHE);
        return;
    }
 
    Assert(!valid[idx]);
 
    kind_info->snapshot_cb();
 
    Assert(!valid[idx]);
    valid[idx] = true;

References Assert, PgStat_Snapshot::custom_valid, fb(), PgStat_Snapshot::fixed_valid, idx(), pgstat_fetch_consistency, PGSTAT_FETCH_CONSISTENCY_CACHE, PGSTAT_FETCH_CONSISTENCY_NONE, pgstat_get_kind_info(), pgstat_is_kind_builtin(), PGSTAT_KIND_CUSTOM_MIN, pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pgstat_build_snapshot(), pgstat_snapshot_fixed(), and pgstat_write_statsfile().

pgstat_clear_snapshot()

void pgstat_clear_snapshot

(

void

)

Definition at line 930 of file pgstat.c.

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

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

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

pgstat_delete_pending_entry()

void pgstat_delete_pending_entry

(

PgStat_EntryRef *

entry_ref

)

Definition at line 1360 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, dlist_delete(), fb(), 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_discard_stats()

void pgstat_discard_stats

(

void

)

Definition at line 537 of file pgstat.c.

{
    int         ret;
 
    /* NB: this needs to be done even in single user mode */
 
    /* First, cleanup the main pgstats file */
    ret = unlink(PGSTAT_STAT_PERMANENT_FILENAME);
    if (ret != 0)
    {
        if (errno == ENOENT)
            elog(DEBUG2,
                 "didn't need to unlink permanent stats file \"%s\" - didn't exist",
                 PGSTAT_STAT_PERMANENT_FILENAME);
        else
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not unlink permanent statistics file \"%s\": %m",
                            PGSTAT_STAT_PERMANENT_FILENAME)));
    }
    else
    {
        ereport(DEBUG2,
                (errcode_for_file_access(),
                 errmsg_internal("unlinked permanent statistics file \"%s\"",
                                 PGSTAT_STAT_PERMANENT_FILENAME)));
    }
 
    /* Finish callbacks, if required */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info && kind_info->finish)
            kind_info->finish(STATS_DISCARD);
    }
 
    /*
     * Reset stats contents. This will set reset timestamps of fixed-numbered
     * stats to the current time (no variable stats exist).
     */
    pgstat_reset_after_failure();

References DEBUG2, elog, ereport, errcode_for_file_access(), errmsg, errmsg_internal(), fb(), LOG, pgstat_get_kind_info(), PgStat_Kind, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, pgstat_reset_after_failure(), PGSTAT_STAT_PERMANENT_FILENAME, and STATS_DISCARD.

Referenced by StartupXLOG().

pgstat_fetch_entry()

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

Definition at line 962 of file pgstat.c.

{
    PgStat_HashKey key = {0};
    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);
 
    /*
     * Initialize *may_free to false.  We'll change it to true later if we end
     * up allocating the result in the caller's context and not caching it.
     */
    if (may_free)
        *may_free = false;
 
    pgstat_prep_snapshot();
 
    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);
 
        /*
         * Since we allocated the result in the caller's context and aren't
         * caching it, the caller can safely pfree() it.
         */
        if (may_free)
            *may_free = true;
    }
    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, fb(), IsPostmasterEnvironment, IsUnderPostmaster, memcpy(), 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_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_subscription(), pgstat_fetch_stat_tabentry_ext(), and test_custom_stats_var_fetch_entry().

pgstat_fetch_pending_entry()

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

Definition at line 1347 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 fb(), PgStat_EntryRef::pending, and pgstat_get_entry_ref().

Referenced by find_funcstat_entry(), and find_tabstat_entry().

pgstat_flush_pending_entries()

static bool pgstat_flush_pending_entries ( bool  nowait )

static

Definition at line 1383 of file pgstat.c.

{
    bool        have_pending = false;
    dlist_node *cur = NULL;
 
    /*
     * Need to be a bit careful iterating over the list of pending entries.
     * Processing a pending entry may queue further pending entries to the end
     * of the list that we want to process, so a simple iteration won't do.
     * Further complicating matters is that we want to delete the current
     * entry in each iteration from the list if we flushed successfully.
     *
     * So we just keep track of the next pointer in each loop iteration.
     */
    if (!dlist_is_empty(&pgStatPending))
        cur = dlist_head_node(&pgStatPending);
 
    while (cur)
    {
        PgStat_EntryRef *entry_ref =
            dlist_container(PgStat_EntryRef, pending_node, cur);
        PgStat_HashKey key = entry_ref->shared_entry->key;
        PgStat_Kind kind = key.kind;
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
        bool        did_flush;
        dlist_node *next;
 
        Assert(!kind_info->fixed_amount);
        Assert(kind_info->flush_pending_cb != NULL);
 
        /* flush the stats, if possible */
        did_flush = kind_info->flush_pending_cb(entry_ref, nowait);
 
        Assert(did_flush || nowait);
 
        /* determine next entry, before deleting the pending entry */
        if (dlist_has_next(&pgStatPending, cur))
            next = dlist_next_node(&pgStatPending, cur);
        else
            next = NULL;
 
        /* if successfully flushed, remove entry */
        if (did_flush)
            pgstat_delete_pending_entry(entry_ref);
        else
            have_pending = true;
 
        cur = next;
    }
 
    Assert(dlist_is_empty(&pgStatPending) == !have_pending);
 
    return have_pending;

References Assert, cur, dlist_container, dlist_has_next(), dlist_head_node(), dlist_is_empty(), dlist_next_node(), fb(), PgStatShared_HashEntry::key, next, pgstat_delete_pending_entry(), pgstat_get_kind_info(), PgStat_Kind, pgStatPending, and PgStat_EntryRef::shared_entry.

Referenced by pgstat_report_stat().

pgstat_force_next_flush()

void pgstat_force_next_flush

(

void

)

Definition at line 842 of file pgstat.c.

{
    pgStatForceNextFlush = true;

References pgStatForceNextFlush.

Referenced by pg_stat_force_next_flush().

pgstat_get_kind_from_str()

PgStat_Kind pgstat_get_kind_from_str

(

char *

kind_str

)

Definition at line 1445 of file pgstat.c.

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

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

Referenced by pg_stat_have_stats().

pgstat_get_kind_info()

const PgStat_KindInfo * pgstat_get_kind_info

(

PgStat_Kind

kind

)

Definition at line 1479 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 fb(), idx(), pgstat_is_kind_builtin(), pgstat_is_kind_custom(), pgstat_kind_builtin_infos, pgstat_kind_custom_infos, and PGSTAT_KIND_CUSTOM_MIN.

Referenced by pg_stat_get_kind_info(), pgstat_build_snapshot(), pgstat_build_snapshot_fixed(), pgstat_create_transactional(), pgstat_delete_pending_entry(), pgstat_discard_stats(), pgstat_drop_entry(), pgstat_fetch_entry(), pgstat_flush_pending_entries(), pgstat_free_entry(), pgstat_get_custom_shmem_data(), pgstat_get_custom_snapshot_data(), pgstat_get_entry_count(), 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_stat_snapshot_timestamp()

TimestampTz pgstat_get_stat_snapshot_timestamp

(

bool *

have_snapshot

)

Definition at line 1071 of file pgstat.c.

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

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

Referenced by pg_stat_get_snapshot_timestamp().

pgstat_have_entry()

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

Definition at line 1088 of file pgstat.c.

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

References fb(), pgstat_get_entry_ref(), and pgstat_get_kind_info().

Referenced by pg_stat_have_stats().

pgstat_init_snapshot_fixed()

static void pgstat_init_snapshot_fixed ( void  )

static

Definition at line 1124 of file pgstat.c.

{
    /*
     * Initialize fixed-numbered statistics data in snapshots, only for custom
     * stats kinds.
     */
    for (PgStat_Kind kind = PGSTAT_KIND_CUSTOM_MIN; kind <= PGSTAT_KIND_CUSTOM_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (!kind_info || !kind_info->fixed_amount)
            continue;
 
        pgStatLocal.snapshot.custom_data[kind - PGSTAT_KIND_CUSTOM_MIN] =
            MemoryContextAlloc(TopMemoryContext, kind_info->shared_data_len);
    }

References PgStat_Snapshot::custom_data, fb(), MemoryContextAlloc(), pgstat_get_kind_info(), PgStat_Kind, PGSTAT_KIND_CUSTOM_MAX, PGSTAT_KIND_CUSTOM_MIN, pgStatLocal, PgStat_LocalState::snapshot, and TopMemoryContext.

Referenced by pgstat_initialize().

pgstat_initialize()

void pgstat_initialize

(

void

)

Definition at line 669 of file pgstat.c.

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

References Assert, before_shmem_exit(), fb(), pgstat_attach_shmem(), pgstat_get_kind_info(), pgstat_init_snapshot_fixed(), PgStat_Kind, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, and pgstat_shutdown_hook().

Referenced by BaseInit().

pgstat_is_kind_valid()

static bool pgstat_is_kind_valid ( PgStat_Kind  kind )

inlinestatic

Definition at line 1473 of file pgstat.c.

{
    return pgstat_is_kind_builtin(kind) || pgstat_is_kind_custom(kind);

References pgstat_is_kind_builtin(), and pgstat_is_kind_custom().

Referenced by pgstat_read_statsfile(), pgstat_snapshot_fixed(), and pgstat_write_statsfile().

pgstat_prep_pending_entry()

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

Definition at line 1309 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(), fb(), 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_init_function_usage(), pgstat_prep_database_pending(), pgstat_prep_relation_pending(), pgstat_report_subscription_conflict(), pgstat_report_subscription_error(), and test_custom_stats_var_update().

pgstat_prep_snapshot()

static void pgstat_prep_snapshot ( void  )

static

Definition at line 1143 of file pgstat.c.

{
    if (force_stats_snapshot_clear)
        pgstat_clear_snapshot();
 
    if (pgstat_fetch_consistency == PGSTAT_FETCH_CONSISTENCY_NONE ||
        pgStatLocal.snapshot.stats != NULL)
        return;
 
    if (!pgStatLocal.snapshot.context)
        pgStatLocal.snapshot.context = AllocSetContextCreate(TopMemoryContext,
                                                             "PgStat Snapshot",
                                                             ALLOCSET_SMALL_SIZES);
 
    pgStatLocal.snapshot.stats =
        pgstat_snapshot_create(pgStatLocal.snapshot.context,
                               PGSTAT_SNAPSHOT_HASH_SIZE,
                               NULL);

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, PgStat_Snapshot::context, fb(), force_stats_snapshot_clear, pgstat_clear_snapshot(), pgstat_fetch_consistency, PGSTAT_FETCH_CONSISTENCY_NONE, PGSTAT_SNAPSHOT_HASH_SIZE, pgStatLocal, PgStat_LocalState::snapshot, PgStat_Snapshot::stats, and TopMemoryContext.

Referenced by pgstat_build_snapshot(), and pgstat_fetch_entry().

pgstat_read_statsfile()

static void pgstat_read_statsfile ( void  )

static

Definition at line 1854 of file pgstat.c.

{
    FILE       *fpin;
    int32       format_id;
    bool        found;
    PgStat_StatsFileOp status = STATS_READ;
    const char *statfile = PGSTAT_STAT_PERMANENT_FILENAME;
    PgStat_ShmemControl *shmem = pgStatLocal.shmem;
 
    /* shouldn't be called from postmaster */
    Assert(IsUnderPostmaster || !IsPostmasterEnvironment);
 
    elog(DEBUG2, "reading stats file \"%s\"", statfile);
 
    /*
     * Try to open the stats file. If it doesn't exist, the backends simply
     * returns zero for anything and statistics simply starts from scratch
     * with empty counters.
     *
     * ENOENT is a possibility if stats collection was previously disabled or
     * has not yet written the stats file for the first time.  Any other
     * failure condition is suspicious.
     */
    if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
    {
        if (errno != ENOENT)
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not open statistics file \"%s\": %m",
                            statfile)));
        pgstat_reset_after_failure();
        status = STATS_DISCARD;
        goto finish;
    }
 
    /*
     * Verify it's of the expected format.
     */
    if (!read_chunk_s(fpin, &format_id))
    {
        elog(WARNING, "could not read format ID");
        goto error;
    }
 
    if (format_id != PGSTAT_FILE_FORMAT_ID)
    {
        elog(WARNING, "found incorrect format ID %d (expected %d)",
             format_id, PGSTAT_FILE_FORMAT_ID);
        goto error;
    }
 
    /*
     * We found an existing statistics file. Read it and put all the stats
     * data into place.
     */
    for (;;)
    {
        int         t = fgetc(fpin);
 
        switch (t)
        {
            case PGSTAT_FILE_ENTRY_FIXED:
                {
                    PgStat_Kind kind;
                    const PgStat_KindInfo *info;
                    char       *ptr;
 
                    /* entry for fixed-numbered stats */
                    if (!read_chunk_s(fpin, &kind))
                    {
                        elog(WARNING, "could not read stats kind for entry of type %c", t);
                        goto error;
                    }
 
                    if (!pgstat_is_kind_valid(kind))
                    {
                        elog(WARNING, "invalid stats kind %u for entry of type %c",
                             kind, t);
                        goto error;
                    }
 
                    info = pgstat_get_kind_info(kind);
                    if (!info)
                    {
                        elog(WARNING, "could not find information of kind %u for entry of type %c",
                             kind, t);
                        goto error;
                    }
 
                    if (!info->fixed_amount)
                    {
                        elog(WARNING, "invalid fixed_amount in stats kind %u for entry of type %c",
                             kind, t);
                        goto error;
                    }
 
                    /* Load back stats into shared memory */
                    if (pgstat_is_kind_builtin(kind))
                        ptr = ((char *) shmem) + info->shared_ctl_off +
                            info->shared_data_off;
                    else
                    {
                        int         idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
                        ptr = ((char *) shmem->custom_data[idx]) +
                            info->shared_data_off;
                    }
 
                    if (!read_chunk(fpin, ptr, info->shared_data_len))
                    {
                        elog(WARNING, "could not read data of stats kind %u for entry of type %c with size %u",
                             kind, t, info->shared_data_len);
                        goto error;
                    }
 
                    break;
                }
            case PGSTAT_FILE_ENTRY_HASH:
            case PGSTAT_FILE_ENTRY_NAME:
                {
                    PgStat_HashKey key;
                    PgStatShared_HashEntry *p;
                    PgStatShared_Common *header;
                    const PgStat_KindInfo *kind_info = NULL;
 
                    CHECK_FOR_INTERRUPTS();
 
                    if (t == PGSTAT_FILE_ENTRY_HASH)
                    {
                        /* normal stats entry, identified by PgStat_HashKey */
                        if (!read_chunk_s(fpin, &key))
                        {
                            elog(WARNING, "could not read key for entry of type %c", t);
                            goto error;
                        }
 
                        if (!pgstat_is_kind_valid(key.kind))
                        {
                            elog(WARNING, "invalid stats kind for entry %u/%u/%" PRIu64 " of type %c",
                                 key.kind, key.dboid,
                                 key.objid, t);
                            goto error;
                        }
 
                        kind_info = pgstat_get_kind_info(key.kind);
                        if (!kind_info)
                        {
                            elog(WARNING, "could not find information of kind for entry %u/%u/%" PRIu64 " of type %c",
                                 key.kind, key.dboid,
                                 key.objid, t);
                            goto error;
                        }
                    }
                    else
                    {
                        /* stats entry identified by name on disk (e.g. slots) */
                        PgStat_Kind kind;
                        NameData    name;
 
                        if (!read_chunk_s(fpin, &kind))
                        {
                            elog(WARNING, "could not read stats kind for entry of type %c", t);
                            goto error;
                        }
                        if (!read_chunk_s(fpin, &name))
                        {
                            elog(WARNING, "could not read name of stats kind %u for entry of type %c",
                                 kind, t);
                            goto error;
                        }
                        if (!pgstat_is_kind_valid(kind))
                        {
                            elog(WARNING, "invalid stats kind %u for entry of type %c",
                                 kind, t);
                            goto error;
                        }
 
                        kind_info = pgstat_get_kind_info(kind);
                        if (!kind_info)
                        {
                            elog(WARNING, "could not find information of kind %u for entry of type %c",
                                 kind, t);
                            goto error;
                        }
 
                        if (!kind_info->from_serialized_name)
                        {
                            elog(WARNING, "invalid from_serialized_name in stats kind %u for entry of type %c",
                                 kind, t);
                            goto error;
                        }
 
                        if (!kind_info->from_serialized_name(&name, &key))
                        {
                            /* skip over data for entry we don't care about */
                            if (fseek(fpin, pgstat_get_entry_len(kind), SEEK_CUR) != 0)
                            {
                                elog(WARNING, "could not seek \"%s\" of stats kind %u for entry of type %c",
                                     NameStr(name), kind, t);
                                goto error;
                            }
 
                            continue;
                        }
 
                        Assert(key.kind == kind);
                    }
 
                    /*
                     * This intentionally doesn't use pgstat_get_entry_ref() -
                     * putting all stats into checkpointer's
                     * pgStatEntryRefHash would be wasted effort and memory.
                     */
                    p = dshash_find_or_insert(pgStatLocal.shared_hash, &key, &found);
 
                    /* don't allow duplicate entries */
                    if (found)
                    {
                        dshash_release_lock(pgStatLocal.shared_hash, p);
                        elog(WARNING, "found duplicate stats entry %u/%u/%" PRIu64 " of type %c",
                             key.kind, key.dboid,
                             key.objid, t);
                        goto error;
                    }
 
                    header = pgstat_init_entry(key.kind, p);
                    dshash_release_lock(pgStatLocal.shared_hash, p);
                    if (header == NULL)
                    {
                        /*
                         * It would be tempting to switch this ERROR to a
                         * WARNING, but it would mean that all the statistics
                         * are discarded when the environment fails on OOM.
                         */
                        elog(ERROR, "could not allocate entry %u/%u/%" PRIu64 " of type %c",
                             key.kind, key.dboid,
                             key.objid, t);
                    }
 
                    if (!read_chunk(fpin,
                                    pgstat_get_entry_data(key.kind, header),
                                    pgstat_get_entry_len(key.kind)))
                    {
                        elog(WARNING, "could not read data for entry %u/%u/%" PRIu64 " of type %c",
                             key.kind, key.dboid,
                             key.objid, t);
                        goto error;
                    }
 
                    /* read more data for the entry, if required */
                    if (kind_info->from_serialized_data)
                    {
                        if (!kind_info->from_serialized_data(&key, header, fpin))
                        {
                            elog(WARNING, "could not read auxiliary data for entry %u/%u/%" PRIu64 " of type %c",
                                 key.kind, key.dboid,
                                 key.objid, t);
                            goto error;
                        }
                    }
 
                    break;
                }
            case PGSTAT_FILE_ENTRY_END:
 
                /*
                 * check that PGSTAT_FILE_ENTRY_END actually signals end of
                 * file
                 */
                if (fgetc(fpin) != EOF)
                {
                    elog(WARNING, "could not read end-of-file");
                    goto error;
                }
 
                goto done;
 
            default:
                elog(WARNING, "could not read entry of type %c", t);
                goto error;
        }
    }
 
done:
    /* First, cleanup the main stats file */
    FreeFile(fpin);
 
    elog(DEBUG2, "removing permanent stats file \"%s\"", statfile);
    unlink(statfile);
 
finish:
    /* Finish callbacks, if required */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info && kind_info->finish)
            kind_info->finish(status);
    }
 
    return;
 
error:
    ereport(LOG,
            (errmsg("corrupted statistics file \"%s\"", statfile)));
 
    pgstat_reset_after_failure();
    status = STATS_DISCARD;
 
    goto done;

References AllocateFile(), Assert, CHECK_FOR_INTERRUPTS, PgStat_ShmemControl::custom_data, DEBUG2, dshash_find_or_insert, dshash_release_lock(), elog, ereport, errcode_for_file_access(), errmsg, ERROR, error(), fb(), PgStat_KindInfo::fixed_amount, FreeFile(), idx(), IsPostmasterEnvironment, IsUnderPostmaster, LOG, name, NameStr, PG_BINARY_R, PGSTAT_FILE_ENTRY_END, PGSTAT_FILE_ENTRY_FIXED, PGSTAT_FILE_ENTRY_HASH, PGSTAT_FILE_ENTRY_NAME, PGSTAT_FILE_FORMAT_ID, pgstat_get_entry_data(), pgstat_get_entry_len(), pgstat_get_kind_info(), pgstat_init_entry(), pgstat_is_kind_builtin(), pgstat_is_kind_valid(), PgStat_Kind, PGSTAT_KIND_CUSTOM_MIN, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, pgstat_reset_after_failure(), PGSTAT_STAT_PERMANENT_FILENAME, pgStatLocal, read_chunk, read_chunk_s, PgStat_KindInfo::shared_ctl_off, PgStat_KindInfo::shared_data_len, PgStat_KindInfo::shared_data_off, PgStat_LocalState::shared_hash, PgStat_LocalState::shmem, STATS_DISCARD, STATS_READ, and WARNING.

Referenced by pgstat_restore_stats().

pgstat_register_kind()

void pgstat_register_kind	(	PgStat_Kind	kind,
		const PgStat_KindInfo *	kind_info
	)

Definition at line 1507 of file pgstat.c.

{
    uint32      idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
    if (kind_info->name == NULL || strlen(kind_info->name) == 0)
        ereport(ERROR,
                (errmsg("failed to register custom cumulative statistics with ID %u", kind),
                 errhint("Provide a non-empty name for the custom cumulative statistics.")));
 
    if (!pgstat_is_kind_custom(kind))
        ereport(ERROR, (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, 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 \"%s\".",
                           "shared_preload_libraries")));
 
    /*
     * Check some data for fixed-numbered stats.
     */
    if (kind_info->fixed_amount)
    {
        if (kind_info->shared_size == 0)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a shared memory size for fixed-numbered objects.")));
        if (kind_info->init_shmem_cb == NULL)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a \"%s\" callback for fixed-numbered objects.",
                             "init_shmem_cb")));
        if (kind_info->reset_all_cb == NULL)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a \"%s\" callback for fixed-numbered objects.",
                             "reset_all_cb")));
        if (kind_info->snapshot_cb == NULL)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a \"%s\" callback for fixed-numbered objects.",
                             "snapshot_cb")));
        if (kind_info->track_entry_count)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics cannot use entry count tracking for fixed-numbered objects.")));
    }
    else
    {
        if (kind_info->pending_size > 0 && kind_info->flush_pending_cb == NULL)
            ereport(ERROR,
                    (errmsg("failed to register custom cumulative statistics \"%s\" with ID %u", kind_info->name, kind),
                     errhint("Custom cumulative statistics require a \"%s\" callback when pending size is set.",
                             "flush_pending_cb")));
    }
 
    /*
     * 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, fb(), 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, and TopMemoryContext.

Referenced by _PG_init().

pgstat_report_stat()

long pgstat_report_stat

(

bool

force

)

Definition at line 722 of file pgstat.c.

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

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

Referenced by AllTablesyncsReady(), apply_handle_commit_internal(), apply_handle_commit_prepared(), apply_handle_prepare(), apply_handle_rollback_prepared(), apply_handle_stream_prepare(), FinishSyncWorker(), HasSubscriptionTablesCached(), LogicalParallelApplyLoop(), LogicalRepApplyLoop(), LogicalRepSyncTableStart(), pgstat_before_server_shutdown(), pgstat_shutdown_hook(), PostgresMain(), ProcessInterrupts(), ProcessSequencesForSync(), ProcessSyncingTablesForApply(), ProcessSyncingTablesForSync(), standby_redo(), and worker_spi_main().

pgstat_reset()

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

Definition at line 882 of file pgstat.c.

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

References Assert, fb(), GetCurrentTimestamp(), pgstat_get_kind_info(), pgstat_reset_database_timestamp(), and pgstat_reset_entry().

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

pgstat_reset_after_failure()

static void pgstat_reset_after_failure ( void  )

static

Definition at line 2171 of file pgstat.c.

{
    TimestampTz ts = GetCurrentTimestamp();
 
    /* reset fixed-numbered stats */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (!kind_info || !kind_info->fixed_amount)
            continue;
 
        kind_info->reset_all_cb(ts);
    }
 
    /* and drop variable-numbered ones */
    pgstat_drop_all_entries();

References fb(), GetCurrentTimestamp(), pgstat_drop_all_entries(), pgstat_get_kind_info(), PgStat_Kind, PGSTAT_KIND_MAX, and PGSTAT_KIND_MIN.

Referenced by pgstat_discard_stats(), and pgstat_read_statsfile().

pgstat_reset_counters()

void pgstat_reset_counters

(

void

)

Definition at line 863 of file pgstat.c.

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

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

Referenced by pg_stat_reset().

pgstat_reset_of_kind()

void pgstat_reset_of_kind

(

PgStat_Kind

kind

)

Definition at line 904 of file pgstat.c.

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

References fb(), GetCurrentTimestamp(), pgstat_get_kind_info(), and pgstat_reset_entries_of_kind().

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

pgstat_restore_stats()

void pgstat_restore_stats

(

void

)

Definition at line 525 of file pgstat.c.

{
    pgstat_read_statsfile();

References pgstat_read_statsfile().

Referenced by StartupXLOG().

pgstat_shutdown_hook()

static void pgstat_shutdown_hook ( int  code, Datum  arg  )

static

Definition at line 631 of file pgstat.c.

{
    Assert(!pgstat_is_shutdown);
    Assert(IsUnderPostmaster || !IsPostmasterEnvironment);
 
    /*
     * If we got as far as discovering our own database ID, we can flush out
     * what we did so far.  Otherwise, we'd be reporting an invalid database
     * ID, so forget it.  (This means that accesses to pg_database during
     * failed backend starts might never get counted.)
     */
    if (OidIsValid(MyDatabaseId))
        pgstat_report_disconnect(MyDatabaseId);
 
    pgstat_report_stat(true);
 
    /* there shouldn't be any pending changes left */
    Assert(dlist_is_empty(&pgStatPending));
    dlist_init(&pgStatPending);
 
    /* drop the backend stats entry */
    if (!pgstat_drop_entry(PGSTAT_KIND_BACKEND, InvalidOid, MyProcNumber, false))
        pgstat_request_entry_refs_gc();
 
    pgstat_detach_shmem();
 
#ifdef USE_ASSERT_CHECKING
    pgstat_is_shutdown = true;
#endif

References Assert, dlist_init(), dlist_is_empty(), fb(), InvalidOid, IsPostmasterEnvironment, IsUnderPostmaster, MyDatabaseId, MyProcNumber, OidIsValid, pgstat_detach_shmem(), pgstat_drop_entry(), PGSTAT_KIND_BACKEND, pgstat_report_disconnect(), pgstat_report_stat(), pgstat_request_entry_refs_gc(), and pgStatPending.

Referenced by pgstat_initialize().

pgstat_snapshot_fixed()

void pgstat_snapshot_fixed

(

PgStat_Kind

kind

)

Definition at line 1104 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 pgstat_fetch_slru(), pgstat_fetch_stat_archiver(), pgstat_fetch_stat_bgwriter(), pgstat_fetch_stat_checkpointer(), pgstat_fetch_stat_io(), pgstat_fetch_stat_lock(), pgstat_fetch_stat_wal(), and test_custom_stats_fixed_report().

pgstat_write_statsfile()

static void pgstat_write_statsfile ( void  )

static

Definition at line 1641 of file pgstat.c.

{
    FILE       *fpout;
    int32       format_id;
    const char *tmpfile = PGSTAT_STAT_PERMANENT_TMPFILE;
    const char *statfile = PGSTAT_STAT_PERMANENT_FILENAME;
    dshash_seq_status hstat;
    PgStatShared_HashEntry *ps;
    PgStat_StatsFileOp status = STATS_WRITE;
 
    pgstat_assert_is_up();
 
    /* should be called only by the checkpointer or single user mode */
    Assert(!IsUnderPostmaster || MyBackendType == B_CHECKPOINTER);
 
    /* we're shutting down, so it's ok to just override this */
    pgstat_fetch_consistency = PGSTAT_FETCH_CONSISTENCY_NONE;
 
    elog(DEBUG2, "writing stats file \"%s\"", statfile);
 
    /*
     * Open the statistics temp file to write out the current values.
     */
    fpout = AllocateFile(tmpfile, PG_BINARY_W);
    if (fpout == NULL)
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not open temporary statistics file \"%s\": %m",
                        tmpfile)));
        return;
    }
 
    /*
     * Write the file header --- currently just a format ID.
     */
    format_id = PGSTAT_FILE_FORMAT_ID;
    write_chunk_s(fpout, &format_id);
 
    /* Write various stats structs for fixed number of objects */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        char       *ptr;
        const PgStat_KindInfo *info = pgstat_get_kind_info(kind);
 
        if (!info || !info->fixed_amount)
            continue;
 
        if (pgstat_is_kind_builtin(kind))
            Assert(info->snapshot_ctl_off != 0);
 
        /* skip if no need to write to file */
        if (!info->write_to_file)
            continue;
 
        pgstat_build_snapshot_fixed(kind);
        if (pgstat_is_kind_builtin(kind))
            ptr = ((char *) &pgStatLocal.snapshot) + info->snapshot_ctl_off;
        else
            ptr = pgStatLocal.snapshot.custom_data[kind - PGSTAT_KIND_CUSTOM_MIN];
 
        fputc(PGSTAT_FILE_ENTRY_FIXED, fpout);
        write_chunk_s(fpout, &kind);
        write_chunk(fpout, ptr, info->shared_data_len);
    }
 
    /*
     * Walk through the stats entries
     */
    dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
    while ((ps = dshash_seq_next(&hstat)) != NULL)
    {
        PgStatShared_Common *shstats;
        const PgStat_KindInfo *kind_info = NULL;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * We should not see any "dropped" entries when writing the stats
         * file, as all backends and auxiliary processes should have cleaned
         * up their references before they terminated.
         *
         * However, since we are already shutting down, it is not worth
         * crashing the server over any potential cleanup issues, so we simply
         * skip such entries if encountered.
         */
        Assert(!ps->dropped);
        if (ps->dropped)
            continue;
 
        /*
         * This discards data related to custom stats kinds that are unknown
         * to this process.
         */
        if (!pgstat_is_kind_valid(ps->key.kind))
        {
            elog(WARNING, "found unknown stats entry %u/%u/%" PRIu64,
                 ps->key.kind, ps->key.dboid,
                 ps->key.objid);
            continue;
        }
 
        shstats = (PgStatShared_Common *) dsa_get_address(pgStatLocal.dsa, ps->body);
 
        kind_info = pgstat_get_kind_info(ps->key.kind);
 
        /* if not dropped the valid-entry refcount should exist */
        Assert(pg_atomic_read_u32(&ps->refcount) > 0);
 
        /* skip if no need to write to file */
        if (!kind_info->write_to_file)
            continue;
 
        if (!kind_info->to_serialized_name)
        {
            /* normal stats entry, identified by PgStat_HashKey */
            fputc(PGSTAT_FILE_ENTRY_HASH, fpout);
            write_chunk_s(fpout, &ps->key);
        }
        else
        {
            /* stats entry identified by name on disk (e.g. slots) */
            NameData    name;
 
            kind_info->to_serialized_name(&ps->key, shstats, &name);
 
            fputc(PGSTAT_FILE_ENTRY_NAME, fpout);
            write_chunk_s(fpout, &ps->key.kind);
            write_chunk_s(fpout, &name);
        }
 
        /* Write except the header part of the entry */
        write_chunk(fpout,
                    pgstat_get_entry_data(ps->key.kind, shstats),
                    pgstat_get_entry_len(ps->key.kind));
 
        /* Write more data for the entry, if required */
        if (kind_info->to_serialized_data &&
            !kind_info->to_serialized_data(&ps->key, shstats, fpout))
        {
            status = STATS_DISCARD;
            break;
        }
    }
    dshash_seq_term(&hstat);
 
    /*
     * No more output to be done. Close the temp file and replace the old
     * pgstat.stat with it.  The ferror() check replaces testing for error
     * after each individual fputc or fwrite (in write_chunk()) above.
     */
    fputc(PGSTAT_FILE_ENTRY_END, fpout);
 
    if (status == STATS_DISCARD)
    {
        /*
         * A to_serialized_data callback failed.  DEBUG2 because the callback
         * already logged the reason.
         */
        elog(DEBUG2, "discarding temporary statistics file \"%s\"", tmpfile);
        FreeFile(fpout);
        unlink(tmpfile);
    }
    else if (ferror(fpout))
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not write temporary statistics file \"%s\": %m",
                        tmpfile)));
        FreeFile(fpout);
        unlink(tmpfile);
        status = STATS_DISCARD;
    }
    else if (FreeFile(fpout) < 0)
    {
        ereport(LOG,
                (errcode_for_file_access(),
                 errmsg("could not close temporary statistics file \"%s\": %m",
                        tmpfile)));
        unlink(tmpfile);
        status = STATS_DISCARD;
    }
    else if (durable_rename(tmpfile, statfile, LOG) < 0)
    {
        /* durable_rename already emitted log message */
        unlink(tmpfile);
        status = STATS_DISCARD;
    }
 
    /* Finish callbacks, if required */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info && kind_info->finish)
            kind_info->finish(status);
    }

References AllocateFile(), Assert, B_CHECKPOINTER, CHECK_FOR_INTERRUPTS, PgStat_Snapshot::custom_data, DEBUG2, PgStat_LocalState::dsa, dsa_get_address(), dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), durable_rename(), elog, ereport, errcode_for_file_access(), errmsg, fb(), PgStat_KindInfo::fixed_amount, FreeFile(), IsUnderPostmaster, LOG, MyBackendType, name, pg_atomic_read_u32(), PG_BINARY_W, pgstat_assert_is_up, pgstat_build_snapshot_fixed(), pgstat_fetch_consistency, PGSTAT_FETCH_CONSISTENCY_NONE, PGSTAT_FILE_ENTRY_END, PGSTAT_FILE_ENTRY_FIXED, PGSTAT_FILE_ENTRY_HASH, PGSTAT_FILE_ENTRY_NAME, PGSTAT_FILE_FORMAT_ID, pgstat_get_entry_data(), pgstat_get_entry_len(), pgstat_get_kind_info(), pgstat_is_kind_builtin(), pgstat_is_kind_valid(), PgStat_Kind, PGSTAT_KIND_CUSTOM_MIN, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, PGSTAT_STAT_PERMANENT_FILENAME, PGSTAT_STAT_PERMANENT_TMPFILE, pgStatLocal, ps, PgStat_KindInfo::shared_data_len, PgStat_LocalState::shared_hash, PgStat_LocalState::snapshot, PgStat_KindInfo::snapshot_ctl_off, STATS_DISCARD, STATS_WRITE, WARNING, write_chunk, write_chunk_s, and PgStat_KindInfo::write_to_file.

Referenced by pgstat_before_server_shutdown().

read_chunk()

static bool read_chunk ( FILE *  fpin, void *  ptr, size_t  len  )

static

Definition at line 1842 of file pgstat.c.

{
    return fread(ptr, 1, len, fpin) == len;

References fb(), and len.

write_chunk()

static void write_chunk ( FILE *  fpout, void *  ptr, size_t  len  )

static

Definition at line 1626 of file pgstat.c.

{
    int         rc;
 
    rc = fwrite(ptr, len, 1, fpout);
 
    /* we'll check for errors with ferror once at the end */
    (void) rc;

References fb(), and len.

Variable Documentation

force_stats_snapshot_clear

bool force_stats_snapshot_clear = false

static

Definition at line 256 of file pgstat.c.

Referenced by assign_stats_fetch_consistency(), pgstat_clear_snapshot(), pgstat_get_stat_snapshot_timestamp(), pgstat_prep_snapshot(), and pgstat_snapshot_fixed().

pgstat_fetch_consistency

int pgstat_fetch_consistency = PGSTAT_FETCH_CONSISTENCY_CACHE

Definition at line 205 of file pgstat.c.

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

pgstat_kind_builtin_infos

const PgStat_KindInfo pgstat_kind_builtin_infos[PGSTAT_KIND_BUILTIN_SIZE]

static

Definition at line 282 of file pgstat.c.

                                                                                   {
 
    /* stats kinds for variable-numbered objects */
 
    [PGSTAT_KIND_DATABASE] = {
        .name = "database",
 
        .fixed_amount = false,
        .write_to_file = true,
        /* so pg_stat_database entries can be seen in all databases */
        .accessed_across_databases = true,
 
        .shared_size = sizeof(PgStatShared_Database),
        .shared_data_off = offsetof(PgStatShared_Database, stats),
        .shared_data_len = sizeof(((PgStatShared_Database *) 0)->stats),
        .pending_size = sizeof(PgStat_StatDBEntry),
 
        .flush_pending_cb = pgstat_database_flush_cb,
        .reset_timestamp_cb = pgstat_database_reset_timestamp_cb,
    },
 
    [PGSTAT_KIND_RELATION] = {
        .name = "relation",
 
        .fixed_amount = false,
        .write_to_file = true,
 
        .shared_size = sizeof(PgStatShared_Relation),
        .shared_data_off = offsetof(PgStatShared_Relation, stats),
        .shared_data_len = sizeof(((PgStatShared_Relation *) 0)->stats),
        .pending_size = sizeof(PgStat_TableStatus),
 
        .flush_pending_cb = pgstat_relation_flush_cb,
        .delete_pending_cb = pgstat_relation_delete_pending_cb,
        .reset_timestamp_cb = pgstat_relation_reset_timestamp_cb,
    },
 
    [PGSTAT_KIND_FUNCTION] = {
        .name = "function",
 
        .fixed_amount = false,
        .write_to_file = true,
 
        .shared_size = sizeof(PgStatShared_Function),
        .shared_data_off = offsetof(PgStatShared_Function, stats),
        .shared_data_len = sizeof(((PgStatShared_Function *) 0)->stats),
        .pending_size = sizeof(PgStat_FunctionCounts),
 
        .flush_pending_cb = pgstat_function_flush_cb,
        .reset_timestamp_cb = pgstat_function_reset_timestamp_cb,
    },
 
    [PGSTAT_KIND_REPLSLOT] = {
        .name = "replslot",
 
        .fixed_amount = false,
        .write_to_file = true,
 
        .accessed_across_databases = true,
 
        .shared_size = sizeof(PgStatShared_ReplSlot),
        .shared_data_off = offsetof(PgStatShared_ReplSlot, stats),
        .shared_data_len = sizeof(((PgStatShared_ReplSlot *) 0)->stats),
 
        .reset_timestamp_cb = pgstat_replslot_reset_timestamp_cb,
        .to_serialized_name = pgstat_replslot_to_serialized_name_cb,
        .from_serialized_name = pgstat_replslot_from_serialized_name_cb,
    },
 
    [PGSTAT_KIND_SUBSCRIPTION] = {
        .name = "subscription",
 
        .fixed_amount = false,
        .write_to_file = true,
        /* so pg_stat_subscription_stats entries can be seen in all databases */
        .accessed_across_databases = true,
 
        .shared_size = sizeof(PgStatShared_Subscription),
        .shared_data_off = offsetof(PgStatShared_Subscription, stats),
        .shared_data_len = sizeof(((PgStatShared_Subscription *) 0)->stats),
        .pending_size = sizeof(PgStat_BackendSubEntry),
 
        .flush_pending_cb = pgstat_subscription_flush_cb,
        .reset_timestamp_cb = pgstat_subscription_reset_timestamp_cb,
    },
 
    [PGSTAT_KIND_BACKEND] = {
        .name = "backend",
 
        .fixed_amount = false,
        .write_to_file = false,
 
        .accessed_across_databases = true,
 
        .shared_size = sizeof(PgStatShared_Backend),
        .shared_data_off = offsetof(PgStatShared_Backend, stats),
        .shared_data_len = sizeof(((PgStatShared_Backend *) 0)->stats),
 
        .flush_static_cb = pgstat_backend_flush_cb,
        .reset_timestamp_cb = pgstat_backend_reset_timestamp_cb,
    },
 
    /* stats for fixed-numbered (mostly 1) objects */
 
    [PGSTAT_KIND_ARCHIVER] = {
        .name = "archiver",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, archiver),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, archiver),
        .shared_data_off = offsetof(PgStatShared_Archiver, stats),
        .shared_data_len = sizeof(((PgStatShared_Archiver *) 0)->stats),
 
        .init_shmem_cb = pgstat_archiver_init_shmem_cb,
        .reset_all_cb = pgstat_archiver_reset_all_cb,
        .snapshot_cb = pgstat_archiver_snapshot_cb,
    },
 
    [PGSTAT_KIND_BGWRITER] = {
        .name = "bgwriter",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, bgwriter),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, bgwriter),
        .shared_data_off = offsetof(PgStatShared_BgWriter, stats),
        .shared_data_len = sizeof(((PgStatShared_BgWriter *) 0)->stats),
 
        .init_shmem_cb = pgstat_bgwriter_init_shmem_cb,
        .reset_all_cb = pgstat_bgwriter_reset_all_cb,
        .snapshot_cb = pgstat_bgwriter_snapshot_cb,
    },
 
    [PGSTAT_KIND_CHECKPOINTER] = {
        .name = "checkpointer",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, checkpointer),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, checkpointer),
        .shared_data_off = offsetof(PgStatShared_Checkpointer, stats),
        .shared_data_len = sizeof(((PgStatShared_Checkpointer *) 0)->stats),
 
        .init_shmem_cb = pgstat_checkpointer_init_shmem_cb,
        .reset_all_cb = pgstat_checkpointer_reset_all_cb,
        .snapshot_cb = pgstat_checkpointer_snapshot_cb,
    },
 
    [PGSTAT_KIND_IO] = {
        .name = "io",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, io),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, io),
        .shared_data_off = offsetof(PgStatShared_IO, stats),
        .shared_data_len = sizeof(((PgStatShared_IO *) 0)->stats),
 
        .flush_static_cb = pgstat_io_flush_cb,
        .init_shmem_cb = pgstat_io_init_shmem_cb,
        .reset_all_cb = pgstat_io_reset_all_cb,
        .snapshot_cb = pgstat_io_snapshot_cb,
    },
 
    [PGSTAT_KIND_LOCK] = {
        .name = "lock",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, lock),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, lock),
        .shared_data_off = offsetof(PgStatShared_Lock, stats),
        .shared_data_len = sizeof(((PgStatShared_Lock *) 0)->stats),
 
        .flush_static_cb = pgstat_lock_flush_cb,
        .init_shmem_cb = pgstat_lock_init_shmem_cb,
        .reset_all_cb = pgstat_lock_reset_all_cb,
        .snapshot_cb = pgstat_lock_snapshot_cb,
    },
 
    [PGSTAT_KIND_SLRU] = {
        .name = "slru",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, slru),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, slru),
        .shared_data_off = offsetof(PgStatShared_SLRU, stats),
        .shared_data_len = sizeof(((PgStatShared_SLRU *) 0)->stats),
 
        .flush_static_cb = pgstat_slru_flush_cb,
        .init_shmem_cb = pgstat_slru_init_shmem_cb,
        .reset_all_cb = pgstat_slru_reset_all_cb,
        .snapshot_cb = pgstat_slru_snapshot_cb,
    },
 
    [PGSTAT_KIND_WAL] = {
        .name = "wal",
 
        .fixed_amount = true,
        .write_to_file = true,
 
        .snapshot_ctl_off = offsetof(PgStat_Snapshot, wal),
        .shared_ctl_off = offsetof(PgStat_ShmemControl, wal),
        .shared_data_off = offsetof(PgStatShared_Wal, stats),
        .shared_data_len = sizeof(((PgStatShared_Wal *) 0)->stats),
 
        .init_backend_cb = pgstat_wal_init_backend_cb,
        .flush_static_cb = pgstat_wal_flush_cb,
        .init_shmem_cb = pgstat_wal_init_shmem_cb,
        .reset_all_cb = pgstat_wal_reset_all_cb,
        .snapshot_cb = pgstat_wal_snapshot_cb,
    },

Referenced by pgstat_get_kind_from_str(), and pgstat_get_kind_info().

pgstat_kind_custom_infos

const PgStat_KindInfo** pgstat_kind_custom_infos = NULL

static

Definition at line 512 of file pgstat.c.

Referenced by pgstat_get_kind_from_str(), pgstat_get_kind_info(), and pgstat_register_kind().

pgstat_report_fixed

bool pgstat_report_fixed = false

Definition at line 219 of file pgstat.c.

Referenced by AdvanceXLInsertBuffer(), get_slru_entry(), pgstat_count_backend_io_op(), pgstat_count_backend_io_op_time(), pgstat_count_backend_lock_fastpath_exceeded(), pgstat_count_backend_lock_waits(), pgstat_count_io_op(), pgstat_count_lock_fastpath_exceeded(), pgstat_count_lock_waits(), pgstat_report_stat(), and XLogInsertRecord().

pgstat_track_counts

bool pgstat_track_counts = false

Definition at line 204 of file pgstat.c.

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

pgStatForceNextFlush

bool pgStatForceNextFlush = false

static

Definition at line 250 of file pgstat.c.

Referenced by pgstat_force_next_flush(), and pgstat_report_stat().

pgStatLocal

PgStat_LocalState pgStatLocal

Definition at line 213 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_lock(), pgstat_fetch_stat_wal(), pgstat_free_entry(), pgstat_gc_entry_refs(), pgstat_get_custom_shmem_data(), pgstat_get_custom_snapshot_data(), pgstat_get_entry_count(), 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_lock_flush_cb(), pgstat_lock_reset_all_cb(), pgstat_lock_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(), StatsShmemInit(), and StatsShmemRequest().

pgStatPending

dlist_head pgStatPending = DLIST_STATIC_INIT(pgStatPending)

static

Definition at line 243 of file pgstat.c.

Referenced by pgstat_flush_pending_entries(), pgstat_prep_pending_entry(), pgstat_report_stat(), and pgstat_shutdown_hook().

pgStatPendingContext

MemoryContext pgStatPendingContext = NULL

static

Definition at line 235 of file pgstat.c.

Referenced by pgstat_prep_pending_entry().