PostgreSQL Source Code  git master
pgstat.h File Reference
#include "datatype/timestamp.h"
#include "fmgr.h"
#include "libpq/pqcomm.h"
#include "port/atomics.h"
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
#include "storage/proc.h"
#include "utils/hsearch.h"
#include "utils/relcache.h"
Include dependency graph for pgstat.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  PgStat_TableCounts
 
struct  PgStat_TableStatus
 
struct  PgStat_TableXactStatus
 
struct  PgStat_MsgHdr
 
struct  PgStat_MsgDummy
 
struct  PgStat_MsgInquiry
 
struct  PgStat_TableEntry
 
struct  PgStat_MsgTabstat
 
struct  PgStat_MsgTabpurge
 
struct  PgStat_MsgDropdb
 
struct  PgStat_MsgResetcounter
 
struct  PgStat_MsgResetsharedcounter
 
struct  PgStat_MsgResetsinglecounter
 
struct  PgStat_MsgAutovacStart
 
struct  PgStat_MsgVacuum
 
struct  PgStat_MsgAnalyze
 
struct  PgStat_MsgArchiver
 
struct  PgStat_MsgBgWriter
 
struct  PgStat_MsgRecoveryConflict
 
struct  PgStat_MsgTempFile
 
struct  PgStat_FunctionCounts
 
struct  PgStat_BackendFunctionEntry
 
struct  PgStat_FunctionEntry
 
struct  PgStat_MsgFuncstat
 
struct  PgStat_MsgFuncpurge
 
struct  PgStat_MsgDeadlock
 
union  PgStat_Msg
 
struct  PgStat_StatDBEntry
 
struct  PgStat_StatTabEntry
 
struct  PgStat_StatFuncEntry
 
struct  PgStat_ArchiverStats
 
struct  PgStat_GlobalStats
 
struct  PgBackendSSLStatus
 
struct  PgBackendStatus
 
struct  LocalPgBackendStatus
 
struct  PgStat_FunctionCallUsage
 

Macros

#define PGSTAT_STAT_PERMANENT_DIRECTORY   "pg_stat"
 
#define PGSTAT_STAT_PERMANENT_FILENAME   "pg_stat/global.stat"
 
#define PGSTAT_STAT_PERMANENT_TMPFILE   "pg_stat/global.tmp"
 
#define PG_STAT_TMP_DIR   "pg_stat_tmp"
 
#define PGSTAT_MAX_MSG_SIZE   1000
 
#define PGSTAT_MSG_PAYLOAD   (PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr))
 
#define PGSTAT_NUM_TABENTRIES
 
#define PGSTAT_NUM_TABPURGE
 
#define PGSTAT_NUM_FUNCENTRIES
 
#define PGSTAT_NUM_FUNCPURGE
 
#define PGSTAT_FILE_FORMAT_ID   0x01A5BC9D
 
#define PG_WAIT_LWLOCK   0x01000000U
 
#define PG_WAIT_LOCK   0x03000000U
 
#define PG_WAIT_BUFFER_PIN   0x04000000U
 
#define PG_WAIT_ACTIVITY   0x05000000U
 
#define PG_WAIT_CLIENT   0x06000000U
 
#define PG_WAIT_EXTENSION   0x07000000U
 
#define PG_WAIT_IPC   0x08000000U
 
#define PG_WAIT_TIMEOUT   0x09000000U
 
#define PG_WAIT_IO   0x0A000000U
 
#define PGSTAT_NUM_PROGRESS_PARAM   10
 
#define pgstat_increment_changecount_before(beentry)
 
#define pgstat_increment_changecount_after(beentry)
 
#define pgstat_save_changecount_before(beentry, save_changecount)
 
#define pgstat_save_changecount_after(beentry, save_changecount)
 
#define pgstat_count_heap_scan(rel)
 
#define pgstat_count_heap_getnext(rel)
 
#define pgstat_count_heap_fetch(rel)
 
#define pgstat_count_index_scan(rel)
 
#define pgstat_count_index_tuples(rel, n)
 
#define pgstat_count_buffer_read(rel)
 
#define pgstat_count_buffer_hit(rel)
 
#define pgstat_count_buffer_read_time(n)   (pgStatBlockReadTime += (n))
 
#define pgstat_count_buffer_write_time(n)   (pgStatBlockWriteTime += (n))
 

Typedefs

typedef enum TrackFunctionsLevel TrackFunctionsLevel
 
typedef enum StatMsgType StatMsgType
 
typedef int64 PgStat_Counter
 
typedef struct PgStat_TableCounts PgStat_TableCounts
 
typedef enum PgStat_Shared_Reset_Target PgStat_Shared_Reset_Target
 
typedef enum PgStat_Single_Reset_Type PgStat_Single_Reset_Type
 
typedef struct PgStat_TableStatus PgStat_TableStatus
 
typedef struct PgStat_TableXactStatus PgStat_TableXactStatus
 
typedef struct PgStat_MsgHdr PgStat_MsgHdr
 
typedef struct PgStat_MsgDummy PgStat_MsgDummy
 
typedef struct PgStat_MsgInquiry PgStat_MsgInquiry
 
typedef struct PgStat_TableEntry PgStat_TableEntry
 
typedef struct PgStat_MsgTabstat PgStat_MsgTabstat
 
typedef struct PgStat_MsgTabpurge PgStat_MsgTabpurge
 
typedef struct PgStat_MsgDropdb PgStat_MsgDropdb
 
typedef struct PgStat_MsgResetcounter PgStat_MsgResetcounter
 
typedef struct PgStat_MsgResetsharedcounter PgStat_MsgResetsharedcounter
 
typedef struct PgStat_MsgResetsinglecounter PgStat_MsgResetsinglecounter
 
typedef struct PgStat_MsgAutovacStart PgStat_MsgAutovacStart
 
typedef struct PgStat_MsgVacuum PgStat_MsgVacuum
 
typedef struct PgStat_MsgAnalyze PgStat_MsgAnalyze
 
typedef struct PgStat_MsgArchiver PgStat_MsgArchiver
 
typedef struct PgStat_MsgBgWriter PgStat_MsgBgWriter
 
typedef struct PgStat_MsgRecoveryConflict PgStat_MsgRecoveryConflict
 
typedef struct PgStat_MsgTempFile PgStat_MsgTempFile
 
typedef struct PgStat_FunctionCounts PgStat_FunctionCounts
 
typedef struct PgStat_BackendFunctionEntry PgStat_BackendFunctionEntry
 
typedef struct PgStat_FunctionEntry PgStat_FunctionEntry
 
typedef struct PgStat_MsgFuncstat PgStat_MsgFuncstat
 
typedef struct PgStat_MsgFuncpurge PgStat_MsgFuncpurge
 
typedef struct PgStat_MsgDeadlock PgStat_MsgDeadlock
 
typedef union PgStat_Msg PgStat_Msg
 
typedef struct PgStat_StatDBEntry PgStat_StatDBEntry
 
typedef struct PgStat_StatTabEntry PgStat_StatTabEntry
 
typedef struct PgStat_StatFuncEntry PgStat_StatFuncEntry
 
typedef struct PgStat_ArchiverStats PgStat_ArchiverStats
 
typedef struct PgStat_GlobalStats PgStat_GlobalStats
 
typedef enum BackendType BackendType
 
typedef enum BackendState BackendState
 
typedef enum ProgressCommandType ProgressCommandType
 
typedef struct PgBackendSSLStatus PgBackendSSLStatus
 
typedef struct PgBackendStatus PgBackendStatus
 
typedef struct LocalPgBackendStatus LocalPgBackendStatus
 
typedef struct PgStat_FunctionCallUsage PgStat_FunctionCallUsage
 

Enumerations

enum  TrackFunctionsLevel { TRACK_FUNC_OFF, TRACK_FUNC_PL, TRACK_FUNC_ALL }
 
enum  StatMsgType {
  PGSTAT_MTYPE_DUMMY, PGSTAT_MTYPE_INQUIRY, PGSTAT_MTYPE_TABSTAT, PGSTAT_MTYPE_TABPURGE,
  PGSTAT_MTYPE_DROPDB, PGSTAT_MTYPE_RESETCOUNTER, PGSTAT_MTYPE_RESETSHAREDCOUNTER, PGSTAT_MTYPE_RESETSINGLECOUNTER,
  PGSTAT_MTYPE_AUTOVAC_START, PGSTAT_MTYPE_VACUUM, PGSTAT_MTYPE_ANALYZE, PGSTAT_MTYPE_ARCHIVER,
  PGSTAT_MTYPE_BGWRITER, PGSTAT_MTYPE_FUNCSTAT, PGSTAT_MTYPE_FUNCPURGE, PGSTAT_MTYPE_RECOVERYCONFLICT,
  PGSTAT_MTYPE_TEMPFILE, PGSTAT_MTYPE_DEADLOCK
}
 
enum  PgStat_Shared_Reset_Target { RESET_ARCHIVER, RESET_BGWRITER }
 
enum  PgStat_Single_Reset_Type { RESET_TABLE, RESET_FUNCTION }
 
enum  BackendType {
  B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER,
  B_BG_WRITER, B_CHECKPOINTER, B_STARTUP, B_WAL_RECEIVER,
  B_WAL_SENDER, B_WAL_WRITER
}
 
enum  BackendState {
  STATE_UNDEFINED, STATE_IDLE, STATE_RUNNING, STATE_IDLEINTRANSACTION,
  STATE_FASTPATH, STATE_IDLEINTRANSACTION_ABORTED, STATE_DISABLED
}
 
enum  WaitEventActivity {
  WAIT_EVENT_ARCHIVER_MAIN = PG_WAIT_ACTIVITY, WAIT_EVENT_AUTOVACUUM_MAIN, WAIT_EVENT_BGWRITER_HIBERNATE, WAIT_EVENT_BGWRITER_MAIN,
  WAIT_EVENT_CHECKPOINTER_MAIN, WAIT_EVENT_LOGICAL_APPLY_MAIN, WAIT_EVENT_LOGICAL_LAUNCHER_MAIN, WAIT_EVENT_PGSTAT_MAIN,
  WAIT_EVENT_RECOVERY_WAL_ALL, WAIT_EVENT_RECOVERY_WAL_STREAM, WAIT_EVENT_SYSLOGGER_MAIN, WAIT_EVENT_WAL_RECEIVER_MAIN,
  WAIT_EVENT_WAL_SENDER_MAIN, WAIT_EVENT_WAL_WRITER_MAIN
}
 
enum  WaitEventClient {
  WAIT_EVENT_CLIENT_READ = PG_WAIT_CLIENT, WAIT_EVENT_CLIENT_WRITE, WAIT_EVENT_LIBPQWALRECEIVER_CONNECT, WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE,
  WAIT_EVENT_SSL_OPEN_SERVER, WAIT_EVENT_WAL_RECEIVER_WAIT_START, WAIT_EVENT_WAL_SENDER_WAIT_WAL, WAIT_EVENT_WAL_SENDER_WRITE_DATA
}
 
enum  WaitEventIPC {
  WAIT_EVENT_BGWORKER_SHUTDOWN = PG_WAIT_IPC, WAIT_EVENT_BGWORKER_STARTUP, WAIT_EVENT_BTREE_PAGE, WAIT_EVENT_CLOG_GROUP_UPDATE,
  WAIT_EVENT_EXECUTE_GATHER, WAIT_EVENT_HASH_BATCH_ALLOCATING, WAIT_EVENT_HASH_BATCH_ELECTING, WAIT_EVENT_HASH_BATCH_LOADING,
  WAIT_EVENT_HASH_BUILD_ALLOCATING, WAIT_EVENT_HASH_BUILD_ELECTING, WAIT_EVENT_HASH_BUILD_HASHING_INNER, WAIT_EVENT_HASH_BUILD_HASHING_OUTER,
  WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATING, WAIT_EVENT_HASH_GROW_BATCHES_DECIDING, WAIT_EVENT_HASH_GROW_BATCHES_ELECTING, WAIT_EVENT_HASH_GROW_BATCHES_FINISHING,
  WAIT_EVENT_HASH_GROW_BATCHES_REPARTITIONING, WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATING, WAIT_EVENT_HASH_GROW_BUCKETS_ELECTING, WAIT_EVENT_HASH_GROW_BUCKETS_REINSERTING,
  WAIT_EVENT_LOGICAL_SYNC_DATA, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE, WAIT_EVENT_MQ_INTERNAL, WAIT_EVENT_MQ_PUT_MESSAGE,
  WAIT_EVENT_MQ_RECEIVE, WAIT_EVENT_MQ_SEND, WAIT_EVENT_PARALLEL_BITMAP_SCAN, WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN,
  WAIT_EVENT_PARALLEL_FINISH, WAIT_EVENT_PROCARRAY_GROUP_UPDATE, WAIT_EVENT_PROMOTE, WAIT_EVENT_REPLICATION_ORIGIN_DROP,
  WAIT_EVENT_REPLICATION_SLOT_DROP, WAIT_EVENT_SAFE_SNAPSHOT, WAIT_EVENT_SYNC_REP
}
 
enum  WaitEventTimeout { WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT, WAIT_EVENT_PG_SLEEP, WAIT_EVENT_RECOVERY_APPLY_DELAY }
 
enum  WaitEventIO {
  WAIT_EVENT_BUFFILE_READ = PG_WAIT_IO, WAIT_EVENT_BUFFILE_WRITE, WAIT_EVENT_CONTROL_FILE_READ, WAIT_EVENT_CONTROL_FILE_SYNC,
  WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE, WAIT_EVENT_CONTROL_FILE_WRITE, WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE, WAIT_EVENT_COPY_FILE_READ,
  WAIT_EVENT_COPY_FILE_WRITE, WAIT_EVENT_DATA_FILE_EXTEND, WAIT_EVENT_DATA_FILE_FLUSH, WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC,
  WAIT_EVENT_DATA_FILE_PREFETCH, WAIT_EVENT_DATA_FILE_READ, WAIT_EVENT_DATA_FILE_SYNC, WAIT_EVENT_DATA_FILE_TRUNCATE,
  WAIT_EVENT_DATA_FILE_WRITE, WAIT_EVENT_DSM_FILL_ZERO_WRITE, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC,
  WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE, WAIT_EVENT_LOCK_FILE_CREATE_READ, WAIT_EVENT_LOCK_FILE_CREATE_SYNC, WAIT_EVENT_LOCK_FILE_CREATE_WRITE,
  WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ, WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC, WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC, WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE,
  WAIT_EVENT_LOGICAL_REWRITE_SYNC, WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE, WAIT_EVENT_LOGICAL_REWRITE_WRITE, WAIT_EVENT_RELATION_MAP_READ,
  WAIT_EVENT_RELATION_MAP_SYNC, WAIT_EVENT_RELATION_MAP_WRITE, WAIT_EVENT_REORDER_BUFFER_READ, WAIT_EVENT_REORDER_BUFFER_WRITE,
  WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ, WAIT_EVENT_REPLICATION_SLOT_READ, WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC, WAIT_EVENT_REPLICATION_SLOT_SYNC,
  WAIT_EVENT_REPLICATION_SLOT_WRITE, WAIT_EVENT_SLRU_FLUSH_SYNC, WAIT_EVENT_SLRU_READ, WAIT_EVENT_SLRU_SYNC,
  WAIT_EVENT_SLRU_WRITE, WAIT_EVENT_SNAPBUILD_READ, WAIT_EVENT_SNAPBUILD_SYNC, WAIT_EVENT_SNAPBUILD_WRITE,
  WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC, WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE, WAIT_EVENT_TIMELINE_HISTORY_READ, WAIT_EVENT_TIMELINE_HISTORY_SYNC,
  WAIT_EVENT_TIMELINE_HISTORY_WRITE, WAIT_EVENT_TWOPHASE_FILE_READ, WAIT_EVENT_TWOPHASE_FILE_SYNC, WAIT_EVENT_TWOPHASE_FILE_WRITE,
  WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ, WAIT_EVENT_WAL_BOOTSTRAP_SYNC, WAIT_EVENT_WAL_BOOTSTRAP_WRITE, WAIT_EVENT_WAL_COPY_READ,
  WAIT_EVENT_WAL_COPY_SYNC, WAIT_EVENT_WAL_COPY_WRITE, WAIT_EVENT_WAL_INIT_SYNC, WAIT_EVENT_WAL_INIT_WRITE,
  WAIT_EVENT_WAL_READ, WAIT_EVENT_WAL_SYNC, WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN, WAIT_EVENT_WAL_WRITE
}
 
enum  ProgressCommandType { PROGRESS_COMMAND_INVALID, PROGRESS_COMMAND_VACUUM }
 

Functions

Size BackendStatusShmemSize (void)
 
void CreateSharedBackendStatus (void)
 
void pgstat_init (void)
 
int pgstat_start (void)
 
void pgstat_reset_all (void)
 
void allow_immediate_pgstat_restart (void)
 
void pgstat_ping (void)
 
void pgstat_report_stat (bool force)
 
void pgstat_vacuum_stat (void)
 
void pgstat_drop_database (Oid databaseid)
 
void pgstat_clear_snapshot (void)
 
void pgstat_reset_counters (void)
 
void pgstat_reset_shared_counters (const char *)
 
void pgstat_reset_single_counter (Oid objectid, PgStat_Single_Reset_Type type)
 
void pgstat_report_autovac (Oid dboid)
 
void pgstat_report_vacuum (Oid tableoid, bool shared, PgStat_Counter livetuples, PgStat_Counter deadtuples)
 
void pgstat_report_analyze (Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, bool resetcounter)
 
void pgstat_report_recovery_conflict (int reason)
 
void pgstat_report_deadlock (void)
 
void pgstat_initialize (void)
 
void pgstat_bestart (void)
 
void pgstat_report_activity (BackendState state, const char *cmd_str)
 
void pgstat_report_tempfile (size_t filesize)
 
void pgstat_report_appname (const char *appname)
 
void pgstat_report_xact_timestamp (TimestampTz tstamp)
 
const char * pgstat_get_wait_event (uint32 wait_event_info)
 
const char * pgstat_get_wait_event_type (uint32 wait_event_info)
 
const char * pgstat_get_backend_current_activity (int pid, bool checkUser)
 
const char * pgstat_get_crashed_backend_activity (int pid, char *buffer, int buflen)
 
const char * pgstat_get_backend_desc (BackendType backendType)
 
void pgstat_progress_start_command (ProgressCommandType cmdtype, Oid relid)
 
void pgstat_progress_update_param (int index, int64 val)
 
void pgstat_progress_update_multi_param (int nparam, const int *index, const int64 *val)
 
void pgstat_progress_end_command (void)
 
PgStat_TableStatusfind_tabstat_entry (Oid rel_id)
 
PgStat_BackendFunctionEntryfind_funcstat_entry (Oid func_id)
 
void pgstat_initstats (Relation rel)
 
char * pgstat_clip_activity (const char *raw_activity)
 
static void pgstat_report_wait_start (uint32 wait_event_info)
 
static void pgstat_report_wait_end (void)
 
void pgstat_count_heap_insert (Relation rel, PgStat_Counter n)
 
void pgstat_count_heap_update (Relation rel, bool hot)
 
void pgstat_count_heap_delete (Relation rel)
 
void pgstat_count_truncate (Relation rel)
 
void pgstat_update_heap_dead_tuples (Relation rel, int delta)
 
void pgstat_init_function_usage (FunctionCallInfoData *fcinfo, PgStat_FunctionCallUsage *fcu)
 
void pgstat_end_function_usage (PgStat_FunctionCallUsage *fcu, bool finalize)
 
void AtEOXact_PgStat (bool isCommit)
 
void AtEOSubXact_PgStat (bool isCommit, int nestDepth)
 
void AtPrepare_PgStat (void)
 
void PostPrepare_PgStat (void)
 
void pgstat_twophase_postcommit (TransactionId xid, uint16 info, void *recdata, uint32 len)
 
void pgstat_twophase_postabort (TransactionId xid, uint16 info, void *recdata, uint32 len)
 
void pgstat_send_archiver (const char *xlog, bool failed)
 
void pgstat_send_bgwriter (void)
 
PgStat_StatDBEntrypgstat_fetch_stat_dbentry (Oid dbid)
 
PgStat_StatTabEntrypgstat_fetch_stat_tabentry (Oid relid)
 
PgBackendStatuspgstat_fetch_stat_beentry (int beid)
 
LocalPgBackendStatuspgstat_fetch_stat_local_beentry (int beid)
 
PgStat_StatFuncEntrypgstat_fetch_stat_funcentry (Oid funcid)
 
int pgstat_fetch_stat_numbackends (void)
 
PgStat_ArchiverStatspgstat_fetch_stat_archiver (void)
 
PgStat_GlobalStatspgstat_fetch_global (void)
 

Variables

bool pgstat_track_activities
 
bool pgstat_track_counts
 
int pgstat_track_functions
 
PGDLLIMPORT int pgstat_track_activity_query_size
 
char * pgstat_stat_directory
 
char * pgstat_stat_tmpname
 
char * pgstat_stat_filename
 
PgStat_MsgBgWriter BgWriterStats
 
PgStat_Counter pgStatBlockReadTime
 
PgStat_Counter pgStatBlockWriteTime
 

Macro Definition Documentation

◆ PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR   "pg_stat_tmp"

Definition at line 34 of file pgstat.h.

◆ PG_WAIT_ACTIVITY

#define PG_WAIT_ACTIVITY   0x05000000U

Definition at line 740 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ PG_WAIT_BUFFER_PIN

#define PG_WAIT_BUFFER_PIN   0x04000000U

◆ PG_WAIT_CLIENT

#define PG_WAIT_CLIENT   0x06000000U

Definition at line 741 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ PG_WAIT_EXTENSION

◆ PG_WAIT_IO

#define PG_WAIT_IO   0x0A000000U

Definition at line 745 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ PG_WAIT_IPC

#define PG_WAIT_IPC   0x08000000U

Definition at line 743 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ PG_WAIT_LOCK

#define PG_WAIT_LOCK   0x03000000U

◆ PG_WAIT_LWLOCK

#define PG_WAIT_LWLOCK   0x01000000U

◆ PG_WAIT_TIMEOUT

#define PG_WAIT_TIMEOUT   0x09000000U

Definition at line 744 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ pgstat_count_buffer_hit

#define pgstat_count_buffer_hit (   rel)
Value:
do { \
if ((rel)->pgstat_info != NULL) \
(rel)->pgstat_info->t_counts.t_blocks_hit++; \
} while (0)

Definition at line 1308 of file pgstat.h.

Referenced by ReadBufferExtended().

◆ pgstat_count_buffer_read

#define pgstat_count_buffer_read (   rel)
Value:
do { \
if ((rel)->pgstat_info != NULL) \
(rel)->pgstat_info->t_counts.t_blocks_fetched++; \
} while (0)

Definition at line 1303 of file pgstat.h.

Referenced by ReadBufferExtended().

◆ pgstat_count_buffer_read_time

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

Definition at line 1313 of file pgstat.h.

Referenced by ReadBuffer_common().

◆ pgstat_count_buffer_write_time

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

Definition at line 1315 of file pgstat.h.

Referenced by FlushBuffer().

◆ pgstat_count_heap_fetch

#define pgstat_count_heap_fetch (   rel)
Value:
do { \
if ((rel)->pgstat_info != NULL) \
(rel)->pgstat_info->t_counts.t_tuples_fetched++; \
} while (0)

Definition at line 1288 of file pgstat.h.

Referenced by BitmapHeapNext(), heap_fetch(), and index_fetch_heap().

◆ pgstat_count_heap_getnext

#define pgstat_count_heap_getnext (   rel)
Value:
do { \
if ((rel)->pgstat_info != NULL) \
(rel)->pgstat_info->t_counts.t_tuples_returned++; \
} while (0)

Definition at line 1283 of file pgstat.h.

Referenced by heap_getnext(), and tablesample_getnext().

◆ pgstat_count_heap_scan

#define pgstat_count_heap_scan (   rel)
Value:
do { \
if ((rel)->pgstat_info != NULL) \
(rel)->pgstat_info->t_counts.t_numscans++; \
} while (0)

Definition at line 1278 of file pgstat.h.

Referenced by initscan().

◆ pgstat_count_index_scan

#define pgstat_count_index_scan (   rel)
Value:
do { \
if ((rel)->pgstat_info != NULL) \
(rel)->pgstat_info->t_counts.t_numscans++; \
} while (0)

Definition at line 1293 of file pgstat.h.

Referenced by _bt_first(), _hash_first(), bringetbitmap(), ginNewScanKey(), gistgetbitmap(), and gistgettuple().

◆ pgstat_count_index_tuples

#define pgstat_count_index_tuples (   rel,
 
)
Value:
do { \
if ((rel)->pgstat_info != NULL) \
(rel)->pgstat_info->t_counts.t_tuples_returned += (n); \
} while (0)

Definition at line 1298 of file pgstat.h.

Referenced by index_getbitmap(), and index_getnext_tid().

◆ PGSTAT_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID   0x01A5BC9D

◆ pgstat_increment_changecount_after

#define pgstat_increment_changecount_after (   beentry)
Value:
do { \
pg_write_barrier(); \
beentry->st_changecount++; \
Assert((beentry->st_changecount & 1) == 0); \
} while (0)

Definition at line 1065 of file pgstat.h.

Referenced by pgstat_beshutdown_hook(), pgstat_bestart(), pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_multi_param(), pgstat_progress_update_param(), pgstat_report_activity(), pgstat_report_appname(), and pgstat_report_xact_timestamp().

◆ pgstat_increment_changecount_before

#define pgstat_increment_changecount_before (   beentry)

◆ PGSTAT_MAX_MSG_SIZE

#define PGSTAT_MAX_MSG_SIZE   1000

Definition at line 206 of file pgstat.h.

Referenced by pgstat_init().

◆ PGSTAT_MSG_PAYLOAD

#define PGSTAT_MSG_PAYLOAD   (PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr))

Definition at line 207 of file pgstat.h.

◆ PGSTAT_NUM_FUNCENTRIES

#define PGSTAT_NUM_FUNCENTRIES
Value:
((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \
unsigned int Oid
Definition: postgres_ext.h:31
#define PGSTAT_MSG_PAYLOAD
Definition: pgstat.h:207

Definition at line 493 of file pgstat.h.

Referenced by pgstat_send_funcstats().

◆ PGSTAT_NUM_FUNCPURGE

#define PGSTAT_NUM_FUNCPURGE
Value:
((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \
/ sizeof(Oid))
unsigned int Oid
Definition: postgres_ext.h:31
#define PGSTAT_MSG_PAYLOAD
Definition: pgstat.h:207

Definition at line 510 of file pgstat.h.

Referenced by pgstat_vacuum_stat().

◆ PGSTAT_NUM_PROGRESS_PARAM

#define PGSTAT_NUM_PROGRESS_PARAM   10

◆ PGSTAT_NUM_TABENTRIES

#define PGSTAT_NUM_TABENTRIES
Value:
((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - 3 * sizeof(int) - 2 * sizeof(PgStat_Counter)) \
/ sizeof(PgStat_TableEntry))
int64 PgStat_Counter
Definition: pgstat.h:74
unsigned int Oid
Definition: postgres_ext.h:31
struct PgStat_TableEntry PgStat_TableEntry
#define PGSTAT_MSG_PAYLOAD
Definition: pgstat.h:207

Definition at line 263 of file pgstat.h.

Referenced by pgstat_report_stat().

◆ PGSTAT_NUM_TABPURGE

#define PGSTAT_NUM_TABPURGE
Value:
((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \
/ sizeof(Oid))
unsigned int Oid
Definition: postgres_ext.h:31
#define PGSTAT_MSG_PAYLOAD
Definition: pgstat.h:207

Definition at line 285 of file pgstat.h.

Referenced by pgstat_vacuum_stat().

◆ pgstat_save_changecount_after

#define pgstat_save_changecount_after (   beentry,
  save_changecount 
)
Value:
do { \
pg_read_barrier(); \
save_changecount = beentry->st_changecount; \
} while (0)

Definition at line 1078 of file pgstat.h.

Referenced by pgstat_get_backend_current_activity(), and pgstat_read_current_status().

◆ pgstat_save_changecount_before

#define pgstat_save_changecount_before (   beentry,
  save_changecount 
)
Value:
do { \
save_changecount = beentry->st_changecount; \
pg_read_barrier(); \
} while (0)

Definition at line 1072 of file pgstat.h.

Referenced by pgstat_get_backend_current_activity(), and pgstat_read_current_status().

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

#define PGSTAT_STAT_PERMANENT_DIRECTORY   "pg_stat"

Definition at line 29 of file pgstat.h.

Referenced by get_dbstat_filename(), and pgstat_reset_all().

◆ PGSTAT_STAT_PERMANENT_FILENAME

#define PGSTAT_STAT_PERMANENT_FILENAME   "pg_stat/global.stat"

◆ PGSTAT_STAT_PERMANENT_TMPFILE

#define PGSTAT_STAT_PERMANENT_TMPFILE   "pg_stat/global.tmp"

Definition at line 31 of file pgstat.h.

Referenced by pgstat_write_statsfiles().

Typedef Documentation

◆ BackendState

◆ BackendType

◆ LocalPgBackendStatus

◆ PgBackendSSLStatus

◆ PgBackendStatus

◆ PgStat_ArchiverStats

◆ PgStat_BackendFunctionEntry

◆ PgStat_Counter

Definition at line 74 of file pgstat.h.

◆ PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

◆ PgStat_FunctionEntry

◆ PgStat_GlobalStats

◆ PgStat_Msg

◆ PgStat_MsgAnalyze

◆ PgStat_MsgArchiver

◆ PgStat_MsgAutovacStart

◆ PgStat_MsgBgWriter

◆ PgStat_MsgDeadlock

◆ PgStat_MsgDropdb

◆ PgStat_MsgDummy

◆ PgStat_MsgFuncpurge

◆ PgStat_MsgFuncstat

◆ PgStat_MsgHdr

◆ PgStat_MsgInquiry

◆ PgStat_MsgRecoveryConflict

◆ PgStat_MsgResetcounter

◆ PgStat_MsgResetsharedcounter

◆ PgStat_MsgResetsinglecounter

◆ PgStat_MsgTabpurge

◆ PgStat_MsgTabstat

◆ PgStat_MsgTempFile

◆ PgStat_MsgVacuum

◆ PgStat_Shared_Reset_Target

◆ PgStat_Single_Reset_Type

◆ PgStat_StatDBEntry

◆ PgStat_StatFuncEntry

◆ PgStat_StatTabEntry

◆ PgStat_TableCounts

◆ PgStat_TableEntry

◆ PgStat_TableStatus

◆ PgStat_TableXactStatus

◆ ProgressCommandType

◆ StatMsgType

◆ TrackFunctionsLevel

Enumeration Type Documentation

◆ BackendState

Enumerator
STATE_UNDEFINED 
STATE_IDLE 
STATE_RUNNING 
STATE_IDLEINTRANSACTION 
STATE_FASTPATH 
STATE_IDLEINTRANSACTION_ABORTED 
STATE_DISABLED 

Definition at line 721 of file pgstat.h.

◆ BackendType

Enumerator
B_AUTOVAC_LAUNCHER 
B_AUTOVAC_WORKER 
B_BACKEND 
B_BG_WORKER 
B_BG_WRITER 
B_CHECKPOINTER 
B_STARTUP 
B_WAL_RECEIVER 
B_WAL_SENDER 
B_WAL_WRITER 

Definition at line 702 of file pgstat.h.

◆ PgStat_Shared_Reset_Target

Enumerator
RESET_ARCHIVER 
RESET_BGWRITER 

Definition at line 119 of file pgstat.h.

120 {
PgStat_Shared_Reset_Target
Definition: pgstat.h:119

◆ PgStat_Single_Reset_Type

Enumerator
RESET_TABLE 
RESET_FUNCTION 

Definition at line 126 of file pgstat.h.

127 {
128  RESET_TABLE,
PgStat_Single_Reset_Type
Definition: pgstat.h:126

◆ ProgressCommandType

Enumerator
PROGRESS_COMMAND_INVALID 
PROGRESS_COMMAND_VACUUM 

Definition at line 934 of file pgstat.h.

◆ StatMsgType

Enumerator
PGSTAT_MTYPE_DUMMY 
PGSTAT_MTYPE_INQUIRY 
PGSTAT_MTYPE_TABSTAT 
PGSTAT_MTYPE_TABPURGE 
PGSTAT_MTYPE_DROPDB 
PGSTAT_MTYPE_RESETCOUNTER 
PGSTAT_MTYPE_RESETSHAREDCOUNTER 
PGSTAT_MTYPE_RESETSINGLECOUNTER 
PGSTAT_MTYPE_AUTOVAC_START 
PGSTAT_MTYPE_VACUUM 
PGSTAT_MTYPE_ANALYZE 
PGSTAT_MTYPE_ARCHIVER 
PGSTAT_MTYPE_BGWRITER 
PGSTAT_MTYPE_FUNCSTAT 
PGSTAT_MTYPE_FUNCPURGE 
PGSTAT_MTYPE_RECOVERYCONFLICT 
PGSTAT_MTYPE_TEMPFILE 
PGSTAT_MTYPE_DEADLOCK 

Definition at line 48 of file pgstat.h.

◆ TrackFunctionsLevel

Enumerator
TRACK_FUNC_OFF 
TRACK_FUNC_PL 
TRACK_FUNC_ALL 

Definition at line 37 of file pgstat.h.

◆ WaitEventActivity

Enumerator
WAIT_EVENT_ARCHIVER_MAIN 
WAIT_EVENT_AUTOVACUUM_MAIN 
WAIT_EVENT_BGWRITER_HIBERNATE 
WAIT_EVENT_BGWRITER_MAIN 
WAIT_EVENT_CHECKPOINTER_MAIN 
WAIT_EVENT_LOGICAL_APPLY_MAIN 
WAIT_EVENT_LOGICAL_LAUNCHER_MAIN 
WAIT_EVENT_PGSTAT_MAIN 
WAIT_EVENT_RECOVERY_WAL_ALL 
WAIT_EVENT_RECOVERY_WAL_STREAM 
WAIT_EVENT_SYSLOGGER_MAIN 
WAIT_EVENT_WAL_RECEIVER_MAIN 
WAIT_EVENT_WAL_SENDER_MAIN 
WAIT_EVENT_WAL_WRITER_MAIN 

Definition at line 755 of file pgstat.h.

◆ WaitEventClient

Enumerator
WAIT_EVENT_CLIENT_READ 
WAIT_EVENT_CLIENT_WRITE 
WAIT_EVENT_LIBPQWALRECEIVER_CONNECT 
WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE 
WAIT_EVENT_SSL_OPEN_SERVER 
WAIT_EVENT_WAL_RECEIVER_WAIT_START 
WAIT_EVENT_WAL_SENDER_WAIT_WAL 
WAIT_EVENT_WAL_SENDER_WRITE_DATA 

Definition at line 781 of file pgstat.h.

◆ WaitEventIO

Enumerator
WAIT_EVENT_BUFFILE_READ 
WAIT_EVENT_BUFFILE_WRITE 
WAIT_EVENT_CONTROL_FILE_READ 
WAIT_EVENT_CONTROL_FILE_SYNC 
WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE 
WAIT_EVENT_CONTROL_FILE_WRITE 
WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE 
WAIT_EVENT_COPY_FILE_READ 
WAIT_EVENT_COPY_FILE_WRITE 
WAIT_EVENT_DATA_FILE_EXTEND 
WAIT_EVENT_DATA_FILE_FLUSH 
WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC 
WAIT_EVENT_DATA_FILE_PREFETCH 
WAIT_EVENT_DATA_FILE_READ 
WAIT_EVENT_DATA_FILE_SYNC 
WAIT_EVENT_DATA_FILE_TRUNCATE 
WAIT_EVENT_DATA_FILE_WRITE 
WAIT_EVENT_DSM_FILL_ZERO_WRITE 
WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ 
WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC 
WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE 
WAIT_EVENT_LOCK_FILE_CREATE_READ 
WAIT_EVENT_LOCK_FILE_CREATE_SYNC 
WAIT_EVENT_LOCK_FILE_CREATE_WRITE 
WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ 
WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC 
WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC 
WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE 
WAIT_EVENT_LOGICAL_REWRITE_SYNC 
WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE 
WAIT_EVENT_LOGICAL_REWRITE_WRITE 
WAIT_EVENT_RELATION_MAP_READ 
WAIT_EVENT_RELATION_MAP_SYNC 
WAIT_EVENT_RELATION_MAP_WRITE 
WAIT_EVENT_REORDER_BUFFER_READ 
WAIT_EVENT_REORDER_BUFFER_WRITE 
WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ 
WAIT_EVENT_REPLICATION_SLOT_READ 
WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC 
WAIT_EVENT_REPLICATION_SLOT_SYNC 
WAIT_EVENT_REPLICATION_SLOT_WRITE 
WAIT_EVENT_SLRU_FLUSH_SYNC 
WAIT_EVENT_SLRU_READ 
WAIT_EVENT_SLRU_SYNC 
WAIT_EVENT_SLRU_WRITE 
WAIT_EVENT_SNAPBUILD_READ 
WAIT_EVENT_SNAPBUILD_SYNC 
WAIT_EVENT_SNAPBUILD_WRITE 
WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC 
WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE 
WAIT_EVENT_TIMELINE_HISTORY_READ 
WAIT_EVENT_TIMELINE_HISTORY_SYNC 
WAIT_EVENT_TIMELINE_HISTORY_WRITE 
WAIT_EVENT_TWOPHASE_FILE_READ 
WAIT_EVENT_TWOPHASE_FILE_SYNC 
WAIT_EVENT_TWOPHASE_FILE_WRITE 
WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ 
WAIT_EVENT_WAL_BOOTSTRAP_SYNC 
WAIT_EVENT_WAL_BOOTSTRAP_WRITE 
WAIT_EVENT_WAL_COPY_READ 
WAIT_EVENT_WAL_COPY_SYNC 
WAIT_EVENT_WAL_COPY_WRITE 
WAIT_EVENT_WAL_INIT_SYNC 
WAIT_EVENT_WAL_INIT_WRITE 
WAIT_EVENT_WAL_READ 
WAIT_EVENT_WAL_SYNC 
WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN 
WAIT_EVENT_WAL_WRITE 

Definition at line 858 of file pgstat.h.

859 {
928 } WaitEventIO;
#define PG_WAIT_IO
Definition: pgstat.h:745
WaitEventIO
Definition: pgstat.h:858

◆ WaitEventIPC

Enumerator
WAIT_EVENT_BGWORKER_SHUTDOWN 
WAIT_EVENT_BGWORKER_STARTUP 
WAIT_EVENT_BTREE_PAGE 
WAIT_EVENT_CLOG_GROUP_UPDATE 
WAIT_EVENT_EXECUTE_GATHER 
WAIT_EVENT_HASH_BATCH_ALLOCATING 
WAIT_EVENT_HASH_BATCH_ELECTING 
WAIT_EVENT_HASH_BATCH_LOADING 
WAIT_EVENT_HASH_BUILD_ALLOCATING 
WAIT_EVENT_HASH_BUILD_ELECTING 
WAIT_EVENT_HASH_BUILD_HASHING_INNER 
WAIT_EVENT_HASH_BUILD_HASHING_OUTER 
WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATING 
WAIT_EVENT_HASH_GROW_BATCHES_DECIDING 
WAIT_EVENT_HASH_GROW_BATCHES_ELECTING 
WAIT_EVENT_HASH_GROW_BATCHES_FINISHING 
WAIT_EVENT_HASH_GROW_BATCHES_REPARTITIONING 
WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATING 
WAIT_EVENT_HASH_GROW_BUCKETS_ELECTING 
WAIT_EVENT_HASH_GROW_BUCKETS_REINSERTING 
WAIT_EVENT_LOGICAL_SYNC_DATA 
WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE 
WAIT_EVENT_MQ_INTERNAL 
WAIT_EVENT_MQ_PUT_MESSAGE 
WAIT_EVENT_MQ_RECEIVE 
WAIT_EVENT_MQ_SEND 
WAIT_EVENT_PARALLEL_BITMAP_SCAN 
WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN 
WAIT_EVENT_PARALLEL_FINISH 
WAIT_EVENT_PROCARRAY_GROUP_UPDATE 
WAIT_EVENT_PROMOTE 
WAIT_EVENT_REPLICATION_ORIGIN_DROP 
WAIT_EVENT_REPLICATION_SLOT_DROP 
WAIT_EVENT_SAFE_SNAPSHOT 
WAIT_EVENT_SYNC_REP 

Definition at line 800 of file pgstat.h.

801 {
837 } WaitEventIPC;
WaitEventIPC
Definition: pgstat.h:800
#define PG_WAIT_IPC
Definition: pgstat.h:743

◆ WaitEventTimeout

Enumerator
WAIT_EVENT_BASE_BACKUP_THROTTLE 
WAIT_EVENT_PG_SLEEP 
WAIT_EVENT_RECOVERY_APPLY_DELAY 

Definition at line 845 of file pgstat.h.

Function Documentation

◆ allow_immediate_pgstat_restart()

void allow_immediate_pgstat_restart ( void  )

Definition at line 790 of file pgstat.c.

References last_pgstat_start_time.

Referenced by HandleChildCrash().

791 {
793 }
static time_t last_pgstat_start_time
Definition: pgstat.c:153

◆ AtEOSubXact_PgStat()

void AtEOSubXact_PgStat ( bool  isCommit,
int  nestDepth 
)

Definition at line 2140 of file pgstat.c.

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

2141 {
2142  PgStat_SubXactStatus *xact_state;
2143 
2144  /*
2145  * Transfer transactional insert/update counts into the next higher
2146  * subtransaction state.
2147  */
2148  xact_state = pgStatXactStack;
2149  if (xact_state != NULL &&
2150  xact_state->nest_level >= nestDepth)
2151  {
2153  PgStat_TableXactStatus *next_trans;
2154 
2155  /* delink xact_state from stack immediately to simplify reuse case */
2156  pgStatXactStack = xact_state->prev;
2157 
2158  for (trans = xact_state->first; trans != NULL; trans = next_trans)
2159  {
2160  PgStat_TableStatus *tabstat;
2161 
2162  next_trans = trans->next;
2163  Assert(trans->nest_level == nestDepth);
2164  tabstat = trans->parent;
2165  Assert(tabstat->trans == trans);
2166  if (isCommit)
2167  {
2168  if (trans->upper && trans->upper->nest_level == nestDepth - 1)
2169  {
2170  if (trans->truncated)
2171  {
2172  /* propagate the truncate status one level up */
2174  /* replace upper xact stats with ours */
2175  trans->upper->tuples_inserted = trans->tuples_inserted;
2176  trans->upper->tuples_updated = trans->tuples_updated;
2177  trans->upper->tuples_deleted = trans->tuples_deleted;
2178  }
2179  else
2180  {
2181  trans->upper->tuples_inserted += trans->tuples_inserted;
2182  trans->upper->tuples_updated += trans->tuples_updated;
2183  trans->upper->tuples_deleted += trans->tuples_deleted;
2184  }
2185  tabstat->trans = trans->upper;
2186  pfree(trans);
2187  }
2188  else
2189  {
2190  /*
2191  * When there isn't an immediate parent state, we can just
2192  * reuse the record instead of going through a
2193  * palloc/pfree pushup (this works since it's all in
2194  * TopTransactionContext anyway). We have to re-link it
2195  * into the parent level, though, and that might mean
2196  * pushing a new entry into the pgStatXactStack.
2197  */
2198  PgStat_SubXactStatus *upper_xact_state;
2199 
2200  upper_xact_state = get_tabstat_stack_level(nestDepth - 1);
2201  trans->next = upper_xact_state->first;
2202  upper_xact_state->first = trans;
2203  trans->nest_level = nestDepth - 1;
2204  }
2205  }
2206  else
2207  {
2208  /*
2209  * On abort, update top-level tabstat counts, then forget the
2210  * subtransaction
2211  */
2212 
2213  /* first restore values obliterated by truncate */
2215  /* count attempted actions regardless of commit/abort */
2216  tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
2217  tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
2218  tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
2219  /* inserted tuples are dead, deleted tuples are unaffected */
2220  tabstat->t_counts.t_delta_dead_tuples +=
2221  trans->tuples_inserted + trans->tuples_updated;
2222  tabstat->trans = trans->upper;
2223  pfree(trans);
2224  }
2225  }
2226  pfree(xact_state);
2227  }
2228 }
PgStat_Counter tuples_updated
Definition: pgstat.h:168
struct PgStat_TableXactStatus * next
Definition: pgstat.h:179
PgStat_TableCounts t_counts
Definition: pgstat.h:158
static PgStat_SubXactStatus * get_tabstat_stack_level(int nest_level)
Definition: pgstat.c:1862
void pfree(void *pointer)
Definition: mcxt.c:1031
PgStat_Counter t_tuples_updated
Definition: pgstat.h:105
static void pgstat_truncate_restore_counters(PgStat_TableXactStatus *trans)
Definition: pgstat.c:1998
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
PgStat_Counter t_delta_dead_tuples
Definition: pgstat.h:111
struct PgStat_TableXactStatus * upper
Definition: pgstat.h:176
PgStat_Counter t_tuples_deleted
Definition: pgstat.h:106
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
struct PgStat_SubXactStatus * prev
Definition: pgstat.c:215
#define Assert(condition)
Definition: c.h:732
static PgStat_SubXactStatus * pgStatXactStack
Definition: pgstat.c:219
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
static zic_t trans[TZ_MAX_LEAPS]
Definition: zic.c:398
PgStat_TableXactStatus * first
Definition: pgstat.c:216
static void pgstat_truncate_save_counters(PgStat_TableXactStatus *trans)
Definition: pgstat.c:1983
PgStat_Counter t_tuples_inserted
Definition: pgstat.h:104
PgStat_TableStatus * parent
Definition: pgstat.h:177

◆ AtEOXact_PgStat()

void AtEOXact_PgStat ( bool  isCommit)

Definition at line 2057 of file pgstat.c.

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

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

2058 {
2059  PgStat_SubXactStatus *xact_state;
2060 
2061  /*
2062  * Count transaction commit or abort. (We use counters, not just bools,
2063  * in case the reporting message isn't sent right away.)
2064  */
2065  if (isCommit)
2066  pgStatXactCommit++;
2067  else
2069 
2070  /*
2071  * Transfer transactional insert/update counts into the base tabstat
2072  * entries. We don't bother to free any of the transactional state, since
2073  * it's all in TopTransactionContext and will go away anyway.
2074  */
2075  xact_state = pgStatXactStack;
2076  if (xact_state != NULL)
2077  {
2079 
2080  Assert(xact_state->nest_level == 1);
2081  Assert(xact_state->prev == NULL);
2082  for (trans = xact_state->first; trans != NULL; trans = trans->next)
2083  {
2084  PgStat_TableStatus *tabstat;
2085 
2086  Assert(trans->nest_level == 1);
2087  Assert(trans->upper == NULL);
2088  tabstat = trans->parent;
2089  Assert(tabstat->trans == trans);
2090  /* restore pre-truncate stats (if any) in case of aborted xact */
2091  if (!isCommit)
2093  /* count attempted actions regardless of commit/abort */
2094  tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
2095  tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
2096  tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
2097  if (isCommit)
2098  {
2099  tabstat->t_counts.t_truncated = trans->truncated;
2100  if (trans->truncated)
2101  {
2102  /* forget live/dead stats seen by backend thus far */
2103  tabstat->t_counts.t_delta_live_tuples = 0;
2104  tabstat->t_counts.t_delta_dead_tuples = 0;
2105  }
2106  /* insert adds a live tuple, delete removes one */
2107  tabstat->t_counts.t_delta_live_tuples +=
2108  trans->tuples_inserted - trans->tuples_deleted;
2109  /* update and delete each create a dead tuple */
2110  tabstat->t_counts.t_delta_dead_tuples +=
2111  trans->tuples_updated + trans->tuples_deleted;
2112  /* insert, update, delete each count as one change event */
2113  tabstat->t_counts.t_changed_tuples +=
2114  trans->tuples_inserted + trans->tuples_updated +
2115  trans->tuples_deleted;
2116  }
2117  else
2118  {
2119  /* inserted tuples are dead, deleted tuples are unaffected */
2120  tabstat->t_counts.t_delta_dead_tuples +=
2121  trans->tuples_inserted + trans->tuples_updated;
2122  /* an aborted xact generates no changed_tuple events */
2123  }
2124  tabstat->trans = NULL;
2125  }
2126  }
2127  pgStatXactStack = NULL;
2128 
2129  /* Make sure any stats snapshot is thrown away */
2131 }
PgStat_Counter t_delta_live_tuples
Definition: pgstat.h:110
PgStat_Counter tuples_updated
Definition: pgstat.h:168
static int pgStatXactCommit
Definition: pgstat.c:221
struct PgStat_TableXactStatus * next
Definition: pgstat.h:179
PgStat_TableCounts t_counts
Definition: pgstat.h:158
PgStat_Counter t_tuples_updated
Definition: pgstat.h:105
static void pgstat_truncate_restore_counters(PgStat_TableXactStatus *trans)
Definition: pgstat.c:1998
static int pgStatXactRollback
Definition: pgstat.c:222
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
PgStat_Counter t_delta_dead_tuples
Definition: pgstat.h:111
struct PgStat_TableXactStatus * upper
Definition: pgstat.h:176
PgStat_Counter t_tuples_deleted
Definition: pgstat.h:106
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
struct PgStat_SubXactStatus * prev
Definition: pgstat.c:215
PgStat_Counter t_changed_tuples
Definition: pgstat.h:112
#define Assert(condition)
Definition: c.h:732
void pgstat_clear_snapshot(void)
Definition: pgstat.c:5614
static PgStat_SubXactStatus * pgStatXactStack
Definition: pgstat.c:219
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
static zic_t trans[TZ_MAX_LEAPS]
Definition: zic.c:398
PgStat_TableXactStatus * first
Definition: pgstat.c:216
PgStat_Counter t_tuples_inserted
Definition: pgstat.h:104
PgStat_TableStatus * parent
Definition: pgstat.h:177

◆ AtPrepare_PgStat()

void AtPrepare_PgStat ( void  )

Definition at line 2239 of file pgstat.c.

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

Referenced by PrepareTransaction().

2240 {
2241  PgStat_SubXactStatus *xact_state;
2242 
2243  xact_state = pgStatXactStack;
2244  if (xact_state != NULL)
2245  {
2247 
2248  Assert(xact_state->nest_level == 1);
2249  Assert(xact_state->prev == NULL);
2250  for (trans = xact_state->first; trans != NULL; trans = trans->next)
2251  {
2252  PgStat_TableStatus *tabstat;
2253  TwoPhasePgStatRecord record;
2254 
2255  Assert(trans->nest_level == 1);
2256  Assert(trans->upper == NULL);
2257  tabstat = trans->parent;
2258  Assert(tabstat->trans == trans);
2259 
2260  record.tuples_inserted = trans->tuples_inserted;
2261  record.tuples_updated = trans->tuples_updated;
2262  record.tuples_deleted = trans->tuples_deleted;
2263  record.inserted_pre_trunc = trans->inserted_pre_trunc;
2264  record.updated_pre_trunc = trans->updated_pre_trunc;
2265  record.deleted_pre_trunc = trans->deleted_pre_trunc;
2266  record.t_id = tabstat->t_id;
2267  record.t_shared = tabstat->t_shared;
2268  record.t_truncated = trans->truncated;
2269 
2271  &record, sizeof(TwoPhasePgStatRecord));
2272  }
2273  }
2274 }
PgStat_Counter tuples_updated
Definition: pgstat.h:168
struct PgStat_TableXactStatus * next
Definition: pgstat.h:179
PgStat_Counter deleted_pre_trunc
Definition: pgstat.h:173
PgStat_Counter deleted_pre_trunc
Definition: pgstat.c:234
void RegisterTwoPhaseRecord(TwoPhaseRmgrId rmid, uint16 info, const void *data, uint32 len)
Definition: twophase.c:1192
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
PgStat_Counter updated_pre_trunc
Definition: pgstat.c:233
PgStat_Counter inserted_pre_trunc
Definition: pgstat.c:232
struct PgStat_TableXactStatus * upper
Definition: pgstat.h:176
PgStat_Counter tuples_updated
Definition: pgstat.c:230
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
struct PgStat_SubXactStatus * prev
Definition: pgstat.c:215
#define Assert(condition)
Definition: c.h:732
PgStat_Counter inserted_pre_trunc
Definition: pgstat.h:171
PgStat_Counter tuples_inserted
Definition: pgstat.c:229
static PgStat_SubXactStatus * pgStatXactStack
Definition: pgstat.c:219
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
PgStat_Counter tuples_deleted
Definition: pgstat.c:231
#define TWOPHASE_RM_PGSTAT_ID
Definition: twophase_rmgr.h:26
PgStat_Counter updated_pre_trunc
Definition: pgstat.h:172
static zic_t trans[TZ_MAX_LEAPS]
Definition: zic.c:398
PgStat_TableXactStatus * first
Definition: pgstat.c:216
PgStat_TableStatus * parent
Definition: pgstat.h:177

◆ BackendStatusShmemSize()

Size BackendStatusShmemSize ( void  )

Definition at line 2608 of file pgstat.c.

References add_size(), mul_size(), NAMEDATALEN, NumBackendStatSlots, and pgstat_track_activity_query_size.

Referenced by CreateSharedMemoryAndSemaphores().

2609 {
2610  Size size;
2611 
2612  /* BackendStatusArray: */
2613  size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2614  /* BackendAppnameBuffer: */
2615  size = add_size(size,
2617  /* BackendClientHostnameBuffer: */
2618  size = add_size(size,
2620  /* BackendActivityBuffer: */
2621  size = add_size(size,
2623 #ifdef USE_SSL
2624  /* BackendSslStatusBuffer: */
2625  size = add_size(size,
2627 #endif
2628  return size;
2629 }
#define NumBackendStatSlots
Definition: pgstat.c:118
#define NAMEDATALEN
int pgstat_track_activity_query_size
Definition: pgstat.c:128
Size mul_size(Size s1, Size s2)
Definition: shmem.c:492
Size add_size(Size s1, Size s2)
Definition: shmem.c:475
size_t Size
Definition: c.h:466

◆ CreateSharedBackendStatus()

void CreateSharedBackendStatus ( void  )

Definition at line 2636 of file pgstat.c.

References BackendActivityBuffer, BackendActivityBufferSize, BackendAppnameBuffer, BackendClientHostnameBuffer, i, MemSet, mul_size(), NAMEDATALEN, NumBackendStatSlots, pgstat_track_activity_query_size, ShmemInitStruct(), PgBackendStatus::st_activity_raw, PgBackendStatus::st_appname, PgBackendStatus::st_clienthostname, and PgBackendStatus::st_sslstatus.

Referenced by CreateSharedMemoryAndSemaphores().

2637 {
2638  Size size;
2639  bool found;
2640  int i;
2641  char *buffer;
2642 
2643  /* Create or attach to the shared array */
2644  size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2646  ShmemInitStruct("Backend Status Array", size, &found);
2647 
2648  if (!found)
2649  {
2650  /*
2651  * We're the first - initialize.
2652  */
2653  MemSet(BackendStatusArray, 0, size);
2654  }
2655 
2656  /* Create or attach to the shared appname buffer */
2658  BackendAppnameBuffer = (char *)
2659  ShmemInitStruct("Backend Application Name Buffer", size, &found);
2660 
2661  if (!found)
2662  {
2663  MemSet(BackendAppnameBuffer, 0, size);
2664 
2665  /* Initialize st_appname pointers. */
2666  buffer = BackendAppnameBuffer;
2667  for (i = 0; i < NumBackendStatSlots; i++)
2668  {
2669  BackendStatusArray[i].st_appname = buffer;
2670  buffer += NAMEDATALEN;
2671  }
2672  }
2673 
2674  /* Create or attach to the shared client hostname buffer */
2676  BackendClientHostnameBuffer = (char *)
2677  ShmemInitStruct("Backend Client Host Name Buffer", size, &found);
2678 
2679  if (!found)
2680  {
2682 
2683  /* Initialize st_clienthostname pointers. */
2684  buffer = BackendClientHostnameBuffer;
2685  for (i = 0; i < NumBackendStatSlots; i++)
2686  {
2688  buffer += NAMEDATALEN;
2689  }
2690  }
2691 
2692  /* Create or attach to the shared activity buffer */
2695  BackendActivityBuffer = (char *)
2696  ShmemInitStruct("Backend Activity Buffer",
2698  &found);
2699 
2700  if (!found)
2701  {
2703 
2704  /* Initialize st_activity pointers. */
2705  buffer = BackendActivityBuffer;
2706  for (i = 0; i < NumBackendStatSlots; i++)
2707  {
2710  }
2711  }
2712 
2713 #ifdef USE_SSL
2714  /* Create or attach to the shared SSL status buffer */
2716  BackendSslStatusBuffer = (PgBackendSSLStatus *)
2717  ShmemInitStruct("Backend SSL Status Buffer", size, &found);
2718 
2719  if (!found)
2720  {
2721  PgBackendSSLStatus *ptr;
2722 
2723  MemSet(BackendSslStatusBuffer, 0, size);
2724 
2725  /* Initialize st_sslstatus pointers. */
2726  ptr = BackendSslStatusBuffer;
2727  for (i = 0; i < NumBackendStatSlots; i++)
2728  {
2730  ptr++;
2731  }
2732  }
2733 #endif
2734 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2593
static char * BackendActivityBuffer
Definition: pgstat.c:2597
static Size BackendActivityBufferSize
Definition: pgstat.c:2598
#define MemSet(start, val, len)
Definition: c.h:941
#define NumBackendStatSlots
Definition: pgstat.c:118
char * st_clienthostname
Definition: pgstat.h:1012
#define NAMEDATALEN
static char * BackendAppnameBuffer
Definition: pgstat.c:2595
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:372
char * st_activity_raw
Definition: pgstat.h:1031
int pgstat_track_activity_query_size
Definition: pgstat.c:128
char * st_appname
Definition: pgstat.h:1022
Size mul_size(Size s1, Size s2)
Definition: shmem.c:492
size_t Size
Definition: c.h:466
int i
PgBackendSSLStatus * st_sslstatus
Definition: pgstat.h:1016
static char * BackendClientHostnameBuffer
Definition: pgstat.c:2596

◆ find_funcstat_entry()

PgStat_BackendFunctionEntry* find_funcstat_entry ( Oid  func_id)

Definition at line 1637 of file pgstat.c.

References HASH_FIND, and hash_search().

Referenced by pg_stat_get_xact_function_calls(), pg_stat_get_xact_function_self_time(), and pg_stat_get_xact_function_total_time().

1638 {
1639  if (pgStatFunctions == NULL)
1640  return NULL;
1641 
1643  (void *) &func_id,
1644  HASH_FIND, NULL);
1645 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
static HTAB * pgStatFunctions
Definition: pgstat.c:197

◆ find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry ( Oid  rel_id)

Definition at line 1842 of file pgstat.c.

References HASH_FIND, hash_search(), and TabStatHashEntry::tsa_entry.

Referenced by pg_stat_get_xact_blocks_fetched(), pg_stat_get_xact_blocks_hit(), pg_stat_get_xact_numscans(), pg_stat_get_xact_tuples_deleted(), pg_stat_get_xact_tuples_fetched(), pg_stat_get_xact_tuples_hot_updated(), pg_stat_get_xact_tuples_inserted(), pg_stat_get_xact_tuples_returned(), and pg_stat_get_xact_tuples_updated().

1843 {
1844  TabStatHashEntry *hash_entry;
1845 
1846  /* If hashtable doesn't exist, there are no entries at all */
1847  if (!pgStatTabHash)
1848  return NULL;
1849 
1850  hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_FIND, NULL);
1851  if (!hash_entry)
1852  return NULL;
1853 
1854  /* Note that this step could also return NULL, but that's correct */
1855  return hash_entry->tsa_entry;
1856 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
static HTAB * pgStatTabHash
Definition: pgstat.c:191
PgStat_TableStatus * tsa_entry
Definition: pgstat.c:185

◆ pgstat_bestart()

void pgstat_bestart ( void  )

Definition at line 2789 of file pgstat.c.

References am_walsender, application_name, Assert, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, B_WAL_WRITER, be_tls_get_cipher(), be_tls_get_cipher_bits(), be_tls_get_compression(), be_tls_get_peerdn_name(), be_tls_get_version(), BgWriterProcess, CheckpointerProcess, elog, FATAL, GetSessionUserId(), InvalidBackendId, InvalidOid, IsAutoVacuumLauncherProcess(), IsAutoVacuumWorkerProcess(), IsBackgroundWorker, MemSet, MyAuxProcType, MyBackendId, MyBEEntry, MyDatabaseId, MyProcPid, MyProcPort, MyStartTimestamp, NAMEDATALEN, NotAnAuxProcess, pgstat_increment_changecount_after, pgstat_increment_changecount_before, pgstat_report_appname(), pgstat_track_activity_query_size, proc_exit(), PROGRESS_COMMAND_INVALID, Port::raddr, Port::remote_hostname, PgBackendSSLStatus::ssl_bits, PgBackendSSLStatus::ssl_cipher, PgBackendSSLStatus::ssl_clientdn, PgBackendSSLStatus::ssl_compression, PgBackendSSLStatus::ssl_version, PgBackendStatus::st_activity_raw, PgBackendStatus::st_activity_start_timestamp, PgBackendStatus::st_appname, PgBackendStatus::st_backendType, PgBackendStatus::st_changecount, PgBackendStatus::st_clientaddr, PgBackendStatus::st_clienthostname, PgBackendStatus::st_databaseid, PgBackendStatus::st_proc_start_timestamp, PgBackendStatus::st_procpid, PgBackendStatus::st_progress_command, PgBackendStatus::st_progress_command_target, PgBackendStatus::st_ssl, PgBackendStatus::st_sslstatus, PgBackendStatus::st_state, PgBackendStatus::st_state_start_timestamp, PgBackendStatus::st_userid, PgBackendStatus::st_xact_start_timestamp, StartupProcess, STATE_UNDEFINED, strlcpy(), WalReceiverProcess, and WalWriterProcess.

Referenced by AuxiliaryProcessMain(), and InitPostgres().

2790 {
2791  SockAddr clientaddr;
2792  volatile PgBackendStatus *beentry;
2793 
2794  /*
2795  * To minimize the time spent modifying the PgBackendStatus entry, fetch
2796  * all the needed data first.
2797  */
2798 
2799  /*
2800  * We may not have a MyProcPort (eg, if this is the autovacuum process).
2801  * If so, use all-zeroes client address, which is dealt with specially in
2802  * pg_stat_get_backend_client_addr and pg_stat_get_backend_client_port.
2803  */
2804  if (MyProcPort)
2805  memcpy(&clientaddr, &MyProcPort->raddr, sizeof(clientaddr));
2806  else
2807  MemSet(&clientaddr, 0, sizeof(clientaddr));
2808 
2809  /*
2810  * Initialize my status entry, following the protocol of bumping
2811  * st_changecount before and after; and make sure it's even afterwards. We
2812  * use a volatile pointer here to ensure the compiler doesn't try to get
2813  * cute.
2814  */
2815  beentry = MyBEEntry;
2816 
2817  /* pgstats state must be initialized from pgstat_initialize() */
2818  Assert(beentry != NULL);
2819 
2821  {
2823  {
2824  /* Autovacuum Launcher */
2826  }
2827  else if (IsAutoVacuumWorkerProcess())
2828  {
2829  /* Autovacuum Worker */
2830  beentry->st_backendType = B_AUTOVAC_WORKER;
2831  }
2832  else if (am_walsender)
2833  {
2834  /* Wal sender */
2835  beentry->st_backendType = B_WAL_SENDER;
2836  }
2837  else if (IsBackgroundWorker)
2838  {
2839  /* bgworker */
2840  beentry->st_backendType = B_BG_WORKER;
2841  }
2842  else
2843  {
2844  /* client-backend */
2845  beentry->st_backendType = B_BACKEND;
2846  }
2847  }
2848  else
2849  {
2850  /* Must be an auxiliary process */
2852  switch (MyAuxProcType)
2853  {
2854  case StartupProcess:
2855  beentry->st_backendType = B_STARTUP;
2856  break;
2857  case BgWriterProcess:
2858  beentry->st_backendType = B_BG_WRITER;
2859  break;
2860  case CheckpointerProcess:
2861  beentry->st_backendType = B_CHECKPOINTER;
2862  break;
2863  case WalWriterProcess:
2864  beentry->st_backendType = B_WAL_WRITER;
2865  break;
2866  case WalReceiverProcess:
2867  beentry->st_backendType = B_WAL_RECEIVER;
2868  break;
2869  default:
2870  elog(FATAL, "unrecognized process type: %d",
2871  (int) MyAuxProcType);
2872  proc_exit(1);
2873  }
2874  }
2875 
2876  do
2877  {
2879  } while ((beentry->st_changecount & 1) == 0);
2880 
2881  beentry->st_procpid = MyProcPid;
2883  beentry->st_activity_start_timestamp = 0;
2884  beentry->st_state_start_timestamp = 0;
2885  beentry->st_xact_start_timestamp = 0;
2886  beentry->st_databaseid = MyDatabaseId;
2887 
2888  /* We have userid for client-backends, wal-sender and bgworker processes */
2889  if (beentry->st_backendType == B_BACKEND
2890  || beentry->st_backendType == B_WAL_SENDER
2891  || beentry->st_backendType == B_BG_WORKER)
2892  beentry->st_userid = GetSessionUserId();
2893  else
2894  beentry->st_userid = InvalidOid;
2895 
2896  beentry->st_clientaddr = clientaddr;
2899  NAMEDATALEN);
2900  else
2901  beentry->st_clienthostname[0] = '\0';
2902 #ifdef USE_SSL
2903  if (MyProcPort && MyProcPort->ssl != NULL)
2904  {
2905  beentry->st_ssl = true;
2911  }
2912  else
2913  {
2914  beentry->st_ssl = false;
2915  }
2916 #else
2917  beentry->st_ssl = false;
2918 #endif
2919  beentry->st_state = STATE_UNDEFINED;
2920  beentry->st_appname[0] = '\0';
2921  beentry->st_activity_raw[0] = '\0';
2922  /* Also make sure the last byte in each string area is always 0 */
2923  beentry->st_clienthostname[NAMEDATALEN - 1] = '\0';
2924  beentry->st_appname[NAMEDATALEN - 1] = '\0';
2928 
2929  /*
2930  * we don't zero st_progress_param here to save cycles; nobody should
2931  * examine it until st_progress_command has been set to something other
2932  * than PROGRESS_COMMAND_INVALID
2933  */
2934 
2936 
2937  /* Update app name to current GUC setting */
2938  if (application_name)
2940 }
bool ssl_compression
Definition: pgstat.h:958
char ssl_cipher[NAMEDATALEN]
Definition: pgstat.h:960
Oid st_progress_command_target
Definition: pgstat.h:1043
int MyProcPid
Definition: globals.c:40
BackendId MyBackendId
Definition: globals.c:81
struct Port * MyProcPort
Definition: globals.c:43
TimestampTz st_activity_start_timestamp
Definition: pgstat.h:1005
char ssl_version[NAMEDATALEN]
Definition: pgstat.h:959
SockAddr st_clientaddr
Definition: pgstat.h:1011
void proc_exit(int code)
Definition: ipc.c:104
#define MemSet(start, val, len)
Definition: c.h:941
ProgressCommandType st_progress_command
Definition: pgstat.h:1042
BackendState st_state
Definition: pgstat.h:1019
char * st_clienthostname
Definition: pgstat.h:1012
Oid GetSessionUserId(void)
Definition: miscinit.c:414
bool IsBackgroundWorker
Definition: globals.c:111
Oid st_databaseid
Definition: pgstat.h:1009
#define NAMEDATALEN
char * remote_hostname
Definition: libpq-be.h:124
SockAddr raddr
Definition: libpq-be.h:122
bool am_walsender
Definition: walsender.c:114
bool be_tls_get_compression(Port *port)
#define FATAL
Definition: elog.h:52
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2594
#define pgstat_increment_changecount_before(beentry)
Definition: pgstat.h:1059
char * st_activity_raw
Definition: pgstat.h:1031
int pgstat_track_activity_query_size
Definition: pgstat.c:128
TimestampTz st_state_start_timestamp
Definition: pgstat.h:1006
#define pgstat_increment_changecount_after(beentry)
Definition: pgstat.h:1065
bool IsAutoVacuumWorkerProcess(void)
Definition: autovacuum.c:3277
char * st_appname
Definition: pgstat.h:1022
#define InvalidBackendId
Definition: backendid.h:23
TimestampTz MyStartTimestamp
Definition: globals.c:42
int be_tls_get_cipher_bits(Port *port)
AuxProcType MyAuxProcType
Definition: bootstrap.c:70
Oid MyDatabaseId
Definition: globals.c:85
BackendType st_backendType
Definition: pgstat.h:1000
void pgstat_report_appname(const char *appname)
Definition: pgstat.c:3163
#define InvalidOid
Definition: postgres_ext.h:36
void be_tls_get_peerdn_name(Port *port, char *ptr, size_t len)
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
bool IsAutoVacuumLauncherProcess(void)
Definition: autovacuum.c:3271
#define Assert(condition)
Definition: c.h:732
const char * be_tls_get_version(Port *port)
int st_procpid
Definition: pgstat.h:997
char * application_name
Definition: guc.c:504
TimestampTz st_xact_start_timestamp
Definition: pgstat.h:1004
#define elog(elevel,...)
Definition: elog.h:226
int st_changecount
Definition: pgstat.h:994
const char * be_tls_get_cipher(Port *port)
TimestampTz st_proc_start_timestamp
Definition: pgstat.h:1003
PgBackendSSLStatus * st_sslstatus
Definition: pgstat.h:1016
char ssl_clientdn[NAMEDATALEN]
Definition: pgstat.h:961

◆ pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void  )

Definition at line 5614 of file pgstat.c.

References localNumBackends, and MemoryContextDelete().

Referenced by AtEOXact_PgStat(), autovac_refresh_stats(), AutoVacLauncherMain(), pg_stat_clear_snapshot(), and PostPrepare_PgStat().

5615 {
5616  /* Release memory, if any was allocated */
5617  if (pgStatLocalContext)
5619 
5620  /* Reset variables */
5621  pgStatLocalContext = NULL;
5622  pgStatDBHash = NULL;
5623  localBackendStatusTable = NULL;
5624  localNumBackends = 0;
5625 }
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:211
static LocalPgBackendStatus * localBackendStatusTable
Definition: pgstat.c:247
static HTAB * pgStatDBHash
Definition: pgstat.c:244
static int localNumBackends
Definition: pgstat.c:250
static MemoryContext pgStatLocalContext
Definition: pgstat.c:243

◆ pgstat_clip_activity()

char* pgstat_clip_activity ( const char *  raw_activity)

Definition at line 6345 of file pgstat.c.

References cliplen(), pg_mbcliplen(), pgstat_track_activity_query_size, and pnstrdup().

Referenced by pg_stat_get_activity(), pg_stat_get_backend_activity(), and pgstat_get_backend_current_activity().

6346 {
6347  char *activity;
6348  int rawlen;
6349  int cliplen;
6350 
6351  /*
6352  * Some callers, like pgstat_get_backend_current_activity(), do not
6353  * guarantee that the buffer isn't concurrently modified. We try to take
6354  * care that the buffer is always terminated by a NUL byte regardless, but
6355  * let's still be paranoid about the string's length. In those cases the
6356  * underlying buffer is guaranteed to be pgstat_track_activity_query_size
6357  * large.
6358  */
6359  activity = pnstrdup(raw_activity, pgstat_track_activity_query_size - 1);
6360 
6361  /* now double-guaranteed to be NUL terminated */
6362  rawlen = strlen(activity);
6363 
6364  /*
6365  * All supported server-encodings make it possible to determine the length
6366  * of a multi-byte character from its first byte (this is not the case for
6367  * client encodings, see GB18030). As st_activity is always stored using
6368  * server encoding, this allows us to perform multi-byte aware truncation,
6369  * even if the string earlier was truncated in the middle of a multi-byte
6370  * character.
6371  */
6372  cliplen = pg_mbcliplen(activity, rawlen,
6374 
6375  activity[cliplen] = '\0';
6376 
6377  return activity;
6378 }
char * pnstrdup(const char *in, Size len)
Definition: mcxt.c:1172
int pg_mbcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:820
int pgstat_track_activity_query_size
Definition: pgstat.c:128
static int cliplen(const char *str, int len, int limit)
Definition: mbutils.c:887

◆ pgstat_count_heap_delete()

void pgstat_count_heap_delete ( Relation  rel)

Definition at line 1957 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_deleted.

Referenced by heap_abort_speculative(), and heap_delete().

1958 {
1959  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1960 
1961  if (pgstat_info != NULL)
1962  {
1963  /* We have to log the effect at the proper transactional level */
1964  int nest_level = GetCurrentTransactionNestLevel();
1965 
1966  if (pgstat_info->trans == NULL ||
1967  pgstat_info->trans->nest_level != nest_level)
1968  add_tabstat_xact_level(pgstat_info, nest_level);
1969 
1970  pgstat_info->trans->tuples_deleted++;
1971  }
1972 }
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:757
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:189
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1884
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157

◆ pgstat_count_heap_insert()

void pgstat_count_heap_insert ( Relation  rel,
PgStat_Counter  n 
)

Definition at line 1911 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_inserted.

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

1912 {
1913  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1914 
1915  if (pgstat_info != NULL)
1916  {
1917  /* We have to log the effect at the proper transactional level */
1918  int nest_level = GetCurrentTransactionNestLevel();
1919 
1920  if (pgstat_info->trans == NULL ||
1921  pgstat_info->trans->nest_level != nest_level)
1922  add_tabstat_xact_level(pgstat_info, nest_level);
1923 
1924  pgstat_info->trans->tuples_inserted += n;
1925  }
1926 }
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:757
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:189
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1884
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157

◆ pgstat_count_heap_update()

void pgstat_count_heap_update ( Relation  rel,
bool  hot 
)

Definition at line 1932 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_tuples_hot_updated, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_updated.

Referenced by heap_update().

1933 {
1934  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1935 
1936  if (pgstat_info != NULL)
1937  {
1938  /* We have to log the effect at the proper transactional level */
1939  int nest_level = GetCurrentTransactionNestLevel();
1940 
1941  if (pgstat_info->trans == NULL ||
1942  pgstat_info->trans->nest_level != nest_level)
1943  add_tabstat_xact_level(pgstat_info, nest_level);
1944 
1945  pgstat_info->trans->tuples_updated++;
1946 
1947  /* t_tuples_hot_updated is nontransactional, so just advance it */
1948  if (hot)
1949  pgstat_info->t_counts.t_tuples_hot_updated++;
1950  }
1951 }
PgStat_Counter tuples_updated
Definition: pgstat.h:168
PgStat_Counter t_tuples_hot_updated
Definition: pgstat.h:107
PgStat_TableCounts t_counts
Definition: pgstat.h:158
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:757
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:189
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1884
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157

◆ pgstat_count_truncate()

void pgstat_count_truncate ( Relation  rel)

Definition at line 2012 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, pgstat_truncate_save_counters(), PgStat_TableStatus::trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, and PgStat_TableXactStatus::tuples_updated.

Referenced by ExecRefreshMatView(), and ExecuteTruncateGuts().

2013 {
2014  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
2015 
2016  if (pgstat_info != NULL)
2017  {
2018  /* We have to log the effect at the proper transactional level */
2019  int nest_level = GetCurrentTransactionNestLevel();
2020 
2021  if (pgstat_info->trans == NULL ||
2022  pgstat_info->trans->nest_level != nest_level)
2023  add_tabstat_xact_level(pgstat_info, nest_level);
2024 
2025  pgstat_truncate_save_counters(pgstat_info->trans);
2026  pgstat_info->trans->tuples_inserted = 0;
2027  pgstat_info->trans->tuples_updated = 0;
2028  pgstat_info->trans->tuples_deleted = 0;
2029  }
2030 }
PgStat_Counter tuples_updated
Definition: pgstat.h:168
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:757
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:189
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1884
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
static void pgstat_truncate_save_counters(PgStat_TableXactStatus *trans)
Definition: pgstat.c:1983

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid  databaseid)

Definition at line 1254 of file pgstat.c.

References PgStat_MsgTabpurge::m_databaseid, PgStat_MsgDropdb::m_databaseid, PgStat_MsgTabpurge::m_hdr, PgStat_MsgDropdb::m_hdr, PgStat_MsgTabpurge::m_nentries, PgStat_MsgTabpurge::m_tableid, MyDatabaseId, offsetof, PGINVALID_SOCKET, PGSTAT_MTYPE_DROPDB, PGSTAT_MTYPE_TABPURGE, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by dropdb(), and pgstat_vacuum_stat().

1255 {
1256  PgStat_MsgDropdb msg;
1257 
1259  return;
1260 
1262  msg.m_databaseid = databaseid;
1263  pgstat_send(&msg, sizeof(msg));
1264 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
Oid m_databaseid
Definition: pgstat.h:306
PgStat_MsgHdr m_hdr
Definition: pgstat.h:305
#define PGINVALID_SOCKET
Definition: port.h:33
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4155

◆ pgstat_end_function_usage()

void pgstat_end_function_usage ( PgStat_FunctionCallUsage fcu,
bool  finalize 
)

Definition at line 1657 of file pgstat.c.

References PgStat_FunctionCounts::f_numcalls, PgStat_FunctionCounts::f_self_time, PgStat_FunctionCallUsage::f_start, PgStat_FunctionCounts::f_total_time, PgStat_FunctionCallUsage::fs, have_function_stats, INSTR_TIME_ADD, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, PgStat_FunctionCallUsage::save_f_total_time, PgStat_FunctionCallUsage::save_total, and total_func_time.

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

1658 {
1659  PgStat_FunctionCounts *fs = fcu->fs;
1660  instr_time f_total;
1661  instr_time f_others;
1662  instr_time f_self;
1663 
1664  /* stats not wanted? */
1665  if (fs == NULL)
1666  return;
1667 
1668  /* total elapsed time in this function call */
1669  INSTR_TIME_SET_CURRENT(f_total);
1670  INSTR_TIME_SUBTRACT(f_total, fcu->f_start);
1671 
1672  /* self usage: elapsed minus anything already charged to other calls */
1673  f_others = total_func_time;
1674  INSTR_TIME_SUBTRACT(f_others, fcu->save_total);
1675  f_self = f_total;
1676  INSTR_TIME_SUBTRACT(f_self, f_others);
1677 
1678  /* update backend-wide total time */
1680 
1681  /*
1682  * Compute the new f_total_time as the total elapsed time added to the
1683  * pre-call value of f_total_time. This is necessary to avoid
1684  * double-counting any time taken by recursive calls of myself. (We do
1685  * not need any similar kluge for self time, since that already excludes
1686  * any recursive calls.)
1687  */
1688  INSTR_TIME_ADD(f_total, fcu->save_f_total_time);
1689 
1690  /* update counters in function stats table */
1691  if (finalize)
1692  fs->f_numcalls++;
1693  fs->f_total_time = f_total;
1694  INSTR_TIME_ADD(fs->f_self_time, f_self);
1695 
1696  /* indicate that we have something to send */
1697  have_function_stats = true;
1698 }
instr_time f_self_time
Definition: pgstat.h:463
instr_time save_total
Definition: pgstat.h:1123
struct timeval instr_time
Definition: instr_time.h:150
instr_time f_total_time
Definition: pgstat.h:462
PgStat_FunctionCounts * fs
Definition: pgstat.h:1119
PgStat_Counter f_numcalls
Definition: pgstat.h:461
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:170
#define INSTR_TIME_ADD(x, y)
Definition: instr_time.h:158
static instr_time total_func_time
Definition: pgstat.c:276
static bool have_function_stats
Definition: pgstat.c:203
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
instr_time save_f_total_time
Definition: pgstat.h:1121

◆ pgstat_fetch_global()

◆ pgstat_fetch_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver ( void  )

Definition at line 2563 of file pgstat.c.

References archiverStats, and backend_read_statsfile().

Referenced by pg_stat_get_archiver().

2564 {
2566 
2567  return &archiverStats;
2568 }
static void backend_read_statsfile(void)
Definition: pgstat.c:5460
static PgStat_ArchiverStats archiverStats
Definition: pgstat.c:257

◆ pgstat_fetch_stat_beentry()

◆ pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry* pgstat_fetch_stat_dbentry ( Oid  dbid)

Definition at line 2391 of file pgstat.c.

References backend_read_statsfile(), HASH_FIND, and hash_search().

Referenced by do_autovacuum(), do_start_worker(), pg_stat_get_db_blk_read_time(), pg_stat_get_db_blk_write_time(), pg_stat_get_db_blocks_fetched(), pg_stat_get_db_blocks_hit(), pg_stat_get_db_conflict_all(), pg_stat_get_db_conflict_bufferpin(), pg_stat_get_db_conflict_lock(), pg_stat_get_db_conflict_snapshot(), pg_stat_get_db_conflict_startup_deadlock(), pg_stat_get_db_conflict_tablespace(), pg_stat_get_db_deadlocks(), pg_stat_get_db_stat_reset_time(), pg_stat_get_db_temp_bytes(), pg_stat_get_db_temp_files(), pg_stat_get_db_tuples_deleted(), pg_stat_get_db_tuples_fetched(), pg_stat_get_db_tuples_inserted(), pg_stat_get_db_tuples_returned(), pg_stat_get_db_tuples_updated(), pg_stat_get_db_xact_commit(), pg_stat_get_db_xact_rollback(), pgstat_fetch_stat_funcentry(), rebuild_database_list(), and table_recheck_autovac().

2392 {
2393  /*
2394  * If not done for this transaction, read the statistics collector stats
2395  * file into some hash tables.
2396  */
2398 
2399  /*
2400  * Lookup the requested database; return NULL if not found
2401  */
2403  (void *) &dbid,
2404  HASH_FIND, NULL);
2405 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
static void backend_read_statsfile(void)
Definition: pgstat.c:5460
static HTAB * pgStatDBHash
Definition: pgstat.c:244

◆ pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry ( Oid  funcid)

Definition at line 2474 of file pgstat.c.

References backend_read_statsfile(), PgStat_StatDBEntry::functions, HASH_FIND, hash_search(), MyDatabaseId, and pgstat_fetch_stat_dbentry().

Referenced by pg_stat_get_function_calls(), pg_stat_get_function_self_time(), and pg_stat_get_function_total_time().

2475 {
2476  PgStat_StatDBEntry *dbentry;
2477  PgStat_StatFuncEntry *funcentry = NULL;
2478 
2479  /* load the stats file if needed */
2481 
2482  /* Lookup our database, then find the requested function. */
2484  if (dbentry != NULL && dbentry->functions != NULL)
2485  {
2486  funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,
2487  (void *) &func_id,
2488  HASH_FIND, NULL);
2489  }
2490 
2491  return funcentry;
2492 }
HTAB * functions
Definition: pgstat.h:607
PgStat_StatDBEntry * pgstat_fetch_stat_dbentry(Oid dbid)
Definition: pgstat.c:2391
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
static void backend_read_statsfile(void)
Definition: pgstat.c:5460
Oid MyDatabaseId
Definition: globals.c:85

◆ pgstat_fetch_stat_local_beentry()

LocalPgBackendStatus* pgstat_fetch_stat_local_beentry ( int  beid)

Definition at line 2528 of file pgstat.c.

References localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_activity(), and pg_stat_get_progress_info().

2529 {
2531 
2532  if (beid < 1 || beid > localNumBackends)
2533  return NULL;
2534 
2535  return &localBackendStatusTable[beid - 1];
2536 }
static void pgstat_read_current_status(void)
Definition: pgstat.c:3217
static LocalPgBackendStatus * localBackendStatusTable
Definition: pgstat.c:247
static int localNumBackends
Definition: pgstat.c:250

◆ pgstat_fetch_stat_numbackends()

int pgstat_fetch_stat_numbackends ( void  )

Definition at line 2547 of file pgstat.c.

References localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_activity(), pg_stat_get_backend_idset(), pg_stat_get_db_numbackends(), and pg_stat_get_progress_info().

2548 {
2550 
2551  return localNumBackends;
2552 }
static void pgstat_read_current_status(void)
Definition: pgstat.c:3217
static int localNumBackends
Definition: pgstat.c:250

◆ pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry ( Oid  relid)

Definition at line 2418 of file pgstat.c.

References backend_read_statsfile(), HASH_FIND, hash_search(), InvalidOid, MyDatabaseId, and PgStat_StatDBEntry::tables.

Referenced by pg_stat_get_analyze_count(), pg_stat_get_autoanalyze_count(), pg_stat_get_autovacuum_count(), pg_stat_get_blocks_fetched(), pg_stat_get_blocks_hit(), pg_stat_get_dead_tuples(), pg_stat_get_last_analyze_time(), pg_stat_get_last_autoanalyze_time(), pg_stat_get_last_autovacuum_time(), pg_stat_get_last_vacuum_time(), pg_stat_get_live_tuples(), pg_stat_get_mod_since_analyze(), pg_stat_get_numscans(), pg_stat_get_tuples_deleted(), pg_stat_get_tuples_fetched(), pg_stat_get_tuples_hot_updated(), pg_stat_get_tuples_inserted(), pg_stat_get_tuples_returned(), pg_stat_get_tuples_updated(), and pg_stat_get_vacuum_count().

2419 {
2420  Oid dbid;
2421  PgStat_StatDBEntry *dbentry;
2422  PgStat_StatTabEntry *tabentry;
2423 
2424  /*
2425  * If not done for this transaction, read the statistics collector stats
2426  * file into some hash tables.
2427  */
2429 
2430  /*
2431  * Lookup our database, then look in its table hash table.
2432  */
2433  dbid = MyDatabaseId;
2435  (void *) &dbid,
2436  HASH_FIND, NULL);
2437  if (dbentry != NULL && dbentry->tables != NULL)
2438  {
2439  tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
2440  (void *) &relid,
2441  HASH_FIND, NULL);
2442  if (tabentry)
2443  return tabentry;
2444  }
2445 
2446  /*
2447  * If we didn't find it, maybe it's a shared table.
2448  */
2449  dbid = InvalidOid;
2451  (void *) &dbid,
2452  HASH_FIND, NULL);
2453  if (dbentry != NULL && dbentry->tables != NULL)
2454  {
2455  tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
2456  (void *) &relid,
2457  HASH_FIND, NULL);
2458  if (tabentry)
2459  return tabentry;
2460  }
2461 
2462  return NULL;
2463 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
unsigned int Oid
Definition: postgres_ext.h:31
static void backend_read_statsfile(void)
Definition: pgstat.c:5460
Oid MyDatabaseId
Definition: globals.c:85
#define InvalidOid
Definition: postgres_ext.h:36
static HTAB * pgStatDBHash
Definition: pgstat.c:244

◆ pgstat_get_backend_current_activity()

const char* pgstat_get_backend_current_activity ( int  pid,
bool  checkUser 
)

Definition at line 3964 of file pgstat.c.

References BackendStatusArray, CHECK_FOR_INTERRUPTS, GetUserId(), i, MaxBackends, pgstat_clip_activity(), pgstat_save_changecount_after, pgstat_save_changecount_before, PgBackendStatus::st_activity_raw, PgBackendStatus::st_procpid, PgBackendStatus::st_userid, and superuser().

Referenced by DeadLockReport().

3965 {
3966  PgBackendStatus *beentry;
3967  int i;
3968 
3969  beentry = BackendStatusArray;
3970  for (i = 1; i <= MaxBackends; i++)
3971  {
3972  /*
3973  * Although we expect the target backend's entry to be stable, that
3974  * doesn't imply that anyone else's is. To avoid identifying the
3975  * wrong backend, while we check for a match to the desired PID we
3976  * must follow the protocol of retrying if st_changecount changes
3977  * while we examine the entry, or if it's odd. (This might be
3978  * unnecessary, since fetching or storing an int is almost certainly
3979  * atomic, but let's play it safe.) We use a volatile pointer here to
3980  * ensure the compiler doesn't try to get cute.
3981  */
3982  volatile PgBackendStatus *vbeentry = beentry;
3983  bool found;
3984 
3985  for (;;)
3986  {
3987  int before_changecount;
3988  int after_changecount;
3989 
3990  pgstat_save_changecount_before(vbeentry, before_changecount);
3991 
3992  found = (vbeentry->st_procpid == pid);
3993 
3994  pgstat_save_changecount_after(vbeentry, after_changecount);
3995 
3996  if (before_changecount == after_changecount &&
3997  (before_changecount & 1) == 0)
3998  break;
3999 
4000  /* Make sure we can break out of loop if stuck... */
4002  }
4003 
4004  if (found)
4005  {
4006  /* Now it is safe to use the non-volatile pointer */
4007  if (checkUser && !superuser() && beentry->st_userid != GetUserId())
4008  return "<insufficient privilege>";
4009  else if (*(beentry->st_activity_raw) == '\0')
4010  return "<command string not enabled>";
4011  else
4012  {
4013  /* this'll leak a bit of memory, but that seems acceptable */
4014  return pgstat_clip_activity(beentry->st_activity_raw);
4015  }
4016  }
4017 
4018  beentry++;
4019  }
4020 
4021  /* If we get here, caller is in error ... */
4022  return "<backend information not available>";
4023 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2593
Oid GetUserId(void)
Definition: miscinit.c:380
bool superuser(void)
Definition: superuser.c:47
int MaxBackends
Definition: globals.c:135
char * st_activity_raw
Definition: pgstat.h:1031
#define pgstat_save_changecount_before(beentry, save_changecount)
Definition: pgstat.h:1072
#define pgstat_save_changecount_after(beentry, save_changecount)
Definition: pgstat.h:1078
int st_procpid
Definition: pgstat.h:997
char * pgstat_clip_activity(const char *raw_activity)
Definition: pgstat.c:6345
int i
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99

◆ pgstat_get_backend_desc()

const char* pgstat_get_backend_desc ( BackendType  backendType)

Definition at line 4101 of file pgstat.c.

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

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

4102 {
4103  const char *backendDesc = "unknown process type";
4104 
4105  switch (backendType)
4106  {
4107  case B_AUTOVAC_LAUNCHER:
4108  backendDesc = "autovacuum launcher";
4109  break;
4110  case B_AUTOVAC_WORKER:
4111  backendDesc = "autovacuum worker";
4112  break;
4113  case B_BACKEND:
4114  backendDesc = "client backend";
4115  break;
4116  case B_BG_WORKER:
4117  backendDesc = "background worker";
4118  break;
4119  case B_BG_WRITER:
4120  backendDesc = "background writer";
4121  break;
4122  case B_CHECKPOINTER:
4123  backendDesc = "checkpointer";
4124  break;
4125  case B_STARTUP:
4126  backendDesc = "startup";
4127  break;
4128  case B_WAL_RECEIVER:
4129  backendDesc = "walreceiver";
4130  break;
4131  case B_WAL_SENDER:
4132  backendDesc = "walsender";
4133  break;
4134  case B_WAL_WRITER:
4135  backendDesc = "walwriter";
4136  break;
4137  }
4138 
4139  return backendDesc;
4140 }

◆ pgstat_get_crashed_backend_activity()

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

Definition at line 4042 of file pgstat.c.

References ascii_safe_strlcpy(), BackendActivityBuffer, BackendActivityBufferSize, BackendStatusArray, i, MaxBackends, Min, pgstat_track_activity_query_size, PgBackendStatus::st_activity_raw, and PgBackendStatus::st_procpid.

Referenced by LogChildExit().

4043 {
4044  volatile PgBackendStatus *beentry;
4045  int i;
4046 
4047  beentry = BackendStatusArray;
4048 
4049  /*
4050  * We probably shouldn't get here before shared memory has been set up,
4051  * but be safe.
4052  */
4053  if (beentry == NULL || BackendActivityBuffer == NULL)
4054  return NULL;
4055 
4056  for (i = 1; i <= MaxBackends; i++)
4057  {
4058  if (beentry->st_procpid == pid)
4059  {
4060  /* Read pointer just once, so it can't change after validation */
4061  const char *activity = beentry->st_activity_raw;
4062  const char *activity_last;
4063 
4064  /*
4065  * We mustn't access activity string before we verify that it
4066  * falls within the BackendActivityBuffer. To make sure that the
4067  * entire string including its ending is contained within the
4068  * buffer, subtract one activity length from the buffer size.
4069  */
4072 
4073  if (activity < BackendActivityBuffer ||
4074  activity > activity_last)
4075  return NULL;
4076 
4077  /* If no string available, no point in a report */
4078  if (activity[0] == '\0')
4079  return NULL;
4080 
4081  /*
4082  * Copy only ASCII-safe characters so we don't run into encoding
4083  * problems when reporting the message; and be sure not to run off
4084  * the end of memory. As only ASCII characters are reported, it
4085  * doesn't seem necessary to perform multibyte aware clipping.
4086  */
4087  ascii_safe_strlcpy(buffer, activity,
4088  Min(buflen, pgstat_track_activity_query_size));
4089 
4090  return buffer;
4091  }
4092 
4093  beentry++;
4094  }
4095 
4096  /* PID not found */
4097  return NULL;
4098 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2593
static char * BackendActivityBuffer
Definition: pgstat.c:2597
#define Min(x, y)
Definition: c.h:890
static Size BackendActivityBufferSize
Definition: pgstat.c:2598
void ascii_safe_strlcpy(char *dest, const char *src, size_t destsiz)
Definition: ascii.c:173
int MaxBackends
Definition: globals.c:135
char * st_activity_raw
Definition: pgstat.h:1031
int pgstat_track_activity_query_size
Definition: pgstat.c:128
int st_procpid
Definition: pgstat.h:997
int i

◆ pgstat_get_wait_event()

const char* pgstat_get_wait_event ( uint32  wait_event_info)

Definition at line 3393 of file pgstat.c.

References GetLockNameFromTagType(), GetLWLockIdentifier(), PG_WAIT_ACTIVITY, PG_WAIT_BUFFER_PIN, PG_WAIT_CLIENT, PG_WAIT_EXTENSION, PG_WAIT_IO, PG_WAIT_IPC, PG_WAIT_LOCK, PG_WAIT_LWLOCK, PG_WAIT_TIMEOUT, pgstat_get_wait_activity(), pgstat_get_wait_client(), pgstat_get_wait_io(), pgstat_get_wait_ipc(), and pgstat_get_wait_timeout().

Referenced by pg_stat_get_activity(), and pg_stat_get_backend_wait_event().

3394 {
3395  uint32 classId;
3396  uint16 eventId;
3397  const char *event_name;
3398 
3399  /* report process as not waiting. */
3400  if (wait_event_info == 0)
3401  return NULL;
3402 
3403  classId = wait_event_info & 0xFF000000;
3404  eventId = wait_event_info & 0x0000FFFF;
3405 
3406  switch (classId)
3407  {
3408  case PG_WAIT_LWLOCK:
3409  event_name = GetLWLockIdentifier(classId, eventId);
3410  break;
3411  case PG_WAIT_LOCK:
3412  event_name = GetLockNameFromTagType(eventId);
3413  break;
3414  case PG_WAIT_BUFFER_PIN:
3415  event_name = "BufferPin";
3416  break;
3417  case PG_WAIT_ACTIVITY:
3418  {
3419  WaitEventActivity w = (WaitEventActivity) wait_event_info;
3420 
3421  event_name = pgstat_get_wait_activity(w);
3422  break;
3423  }
3424  case PG_WAIT_CLIENT:
3425  {
3426  WaitEventClient w = (WaitEventClient) wait_event_info;
3427 
3428  event_name = pgstat_get_wait_client(w);
3429  break;
3430  }
3431  case PG_WAIT_EXTENSION:
3432  event_name = "Extension";
3433  break;
3434  case PG_WAIT_IPC:
3435  {
3436  WaitEventIPC w = (WaitEventIPC) wait_event_info;
3437 
3438  event_name = pgstat_get_wait_ipc(w);
3439  break;
3440  }
3441  case PG_WAIT_TIMEOUT:
3442  {
3443  WaitEventTimeout w = (WaitEventTimeout) wait_event_info;
3444 
3445  event_name = pgstat_get_wait_timeout(w);
3446  break;
3447  }
3448  case PG_WAIT_IO:
3449  {
3450  WaitEventIO w = (WaitEventIO) wait_event_info;
3451 
3452  event_name = pgstat_get_wait_io(w);
3453  break;
3454  }
3455  default:
3456  event_name = "unknown wait event";
3457  break;
3458  }
3459 
3460  return event_name;
3461 }
#define PG_WAIT_LOCK
Definition: pgstat.h:738
WaitEventIPC
Definition: pgstat.h:800
static const char * pgstat_get_wait_timeout(WaitEventTimeout w)
Definition: pgstat.c:3698
static const char * pgstat_get_wait_ipc(WaitEventIPC w)
Definition: pgstat.c:3574
#define PG_WAIT_ACTIVITY
Definition: pgstat.h:740
#define PG_WAIT_IO
Definition: pgstat.h:745
static const char * pgstat_get_wait_activity(WaitEventActivity w)
Definition: pgstat.c:3470
unsigned short uint16
Definition: c.h:357
#define PG_WAIT_CLIENT
Definition: pgstat.h:741
WaitEventClient
Definition: pgstat.h:781
static const char * pgstat_get_wait_client(WaitEventClient w)
Definition: pgstat.c:3531
unsigned int uint32
Definition: c.h:358
WaitEventTimeout
Definition: pgstat.h:845
#define PG_WAIT_EXTENSION
Definition: pgstat.h:742
#define PG_WAIT_BUFFER_PIN
Definition: pgstat.h:739
const char * GetLockNameFromTagType(uint16 locktag_type)
Definition: lmgr.c:1132
WaitEventIO
Definition: pgstat.h:858
#define PG_WAIT_TIMEOUT
Definition: pgstat.h:744
#define PG_WAIT_IPC
Definition: pgstat.h:743
const char * GetLWLockIdentifier(uint32 classId, uint16 eventId)
Definition: lwlock.c:713
static const char * pgstat_get_wait_io(WaitEventIO w)
Definition: pgstat.c:3726
#define PG_WAIT_LWLOCK
Definition: pgstat.h:737
WaitEventActivity
Definition: pgstat.h:755

◆ pgstat_get_wait_event_type()

const char* pgstat_get_wait_event_type ( uint32  wait_event_info)

Definition at line 3338 of file pgstat.c.

References PG_WAIT_ACTIVITY, PG_WAIT_BUFFER_PIN, PG_WAIT_CLIENT, PG_WAIT_EXTENSION, PG_WAIT_IO, PG_WAIT_IPC, PG_WAIT_LOCK, PG_WAIT_LWLOCK, and PG_WAIT_TIMEOUT.

Referenced by pg_stat_get_activity(), and pg_stat_get_backend_wait_event_type().

3339 {
3340  uint32 classId;
3341  const char *event_type;
3342 
3343  /* report process as not waiting. */
3344  if (wait_event_info == 0)
3345  return NULL;
3346 
3347  classId = wait_event_info & 0xFF000000;
3348 
3349  switch (classId)
3350  {
3351  case PG_WAIT_LWLOCK:
3352  event_type = "LWLock";
3353  break;
3354  case PG_WAIT_LOCK:
3355  event_type = "Lock";
3356  break;
3357  case PG_WAIT_BUFFER_PIN:
3358  event_type = "BufferPin";
3359  break;
3360  case PG_WAIT_ACTIVITY:
3361  event_type = "Activity";
3362  break;
3363  case PG_WAIT_CLIENT:
3364  event_type = "Client";
3365  break;
3366  case PG_WAIT_EXTENSION:
3367  event_type = "Extension";
3368  break;
3369  case PG_WAIT_IPC:
3370  event_type = "IPC";
3371  break;
3372  case PG_WAIT_TIMEOUT:
3373  event_type = "Timeout";
3374  break;
3375  case PG_WAIT_IO:
3376  event_type = "IO";
3377  break;
3378  default:
3379  event_type = "???";
3380  break;
3381  }
3382 
3383  return event_type;
3384 }
#define PG_WAIT_LOCK
Definition: pgstat.h:738
#define PG_WAIT_ACTIVITY
Definition: pgstat.h:740
#define PG_WAIT_IO
Definition: pgstat.h:745
#define PG_WAIT_CLIENT
Definition: pgstat.h:741
unsigned int uint32
Definition: c.h:358
#define PG_WAIT_EXTENSION
Definition: pgstat.h:742
#define PG_WAIT_BUFFER_PIN
Definition: pgstat.h:739
#define PG_WAIT_TIMEOUT
Definition: pgstat.h:744
#define PG_WAIT_IPC
Definition: pgstat.h:743
#define PG_WAIT_LWLOCK
Definition: pgstat.h:737

◆ pgstat_init()

void pgstat_init ( void  )

Definition at line 355 of file pgstat.c.

References addrinfo::ai_next, AI_PASSIVE, bind, closesocket, connect, EINTR, elog, ereport, errcode(), errcode_for_socket_access(), errmsg(), gai_strerror, LOG, pg_freeaddrinfo_all(), pg_getaddrinfo_all(), pg_set_noblock(), PGC_INTERNAL, PGC_S_OVERRIDE, PGINVALID_SOCKET, PGSTAT_MAX_MSG_SIZE, PGSTAT_MIN_RCVBUF, pgStatAddr, pgStatSock, recv, select, send, SetConfigOption(), socket, StaticAssertStmt, and TESTBYTEVAL.

Referenced by PostmasterMain().

356 {
357  ACCEPT_TYPE_ARG3 alen;
358  struct addrinfo *addrs = NULL,
359  *addr,
360  hints;
361  int ret;
362  fd_set rset;
363  struct timeval tv;
364  char test_byte;
365  int sel_res;
366  int tries = 0;
367 
368 #define TESTBYTEVAL ((char) 199)
369 
370  /*
371  * This static assertion verifies that we didn't mess up the calculations
372  * involved in selecting maximum payload sizes for our UDP messages.
373  * Because the only consequence of overrunning PGSTAT_MAX_MSG_SIZE would
374  * be silent performance loss from fragmentation, it seems worth having a
375  * compile-time cross-check that we didn't.
376  */
378  "maximum stats message size exceeds PGSTAT_MAX_MSG_SIZE");
379 
380  /*
381  * Create the UDP socket for sending and receiving statistic messages
382  */
383  hints.ai_flags = AI_PASSIVE;
384  hints.ai_family = AF_UNSPEC;
385  hints.ai_socktype = SOCK_DGRAM;
386  hints.ai_protocol = 0;
387  hints.ai_addrlen = 0;
388  hints.ai_addr = NULL;
389  hints.ai_canonname = NULL;
390  hints.ai_next = NULL;
391  ret = pg_getaddrinfo_all("localhost", NULL, &hints, &addrs);
392  if (ret || !addrs)
393  {
394  ereport(LOG,
395  (errmsg("could not resolve \"localhost\": %s",
396  gai_strerror(ret))));
397  goto startup_failed;
398  }
399 
400  /*
401  * On some platforms, pg_getaddrinfo_all() may return multiple addresses
402  * only one of which will actually work (eg, both IPv6 and IPv4 addresses
403  * when kernel will reject IPv6). Worse, the failure may occur at the
404  * bind() or perhaps even connect() stage. So we must loop through the
405  * results till we find a working combination. We will generate LOG
406  * messages, but no error, for bogus combinations.
407  */
408  for (addr = addrs; addr; addr = addr->ai_next)
409  {
410 #ifdef HAVE_UNIX_SOCKETS
411  /* Ignore AF_UNIX sockets, if any are returned. */
412  if (addr->ai_family == AF_UNIX)
413  continue;
414 #endif
415 
416  if (++tries > 1)
417  ereport(LOG,
418  (errmsg("trying another address for the statistics collector")));
419 
420  /*
421  * Create the socket.
422  */
423  if ((pgStatSock = socket(addr->ai_family, SOCK_DGRAM, 0)) == PGINVALID_SOCKET)
424  {
425  ereport(LOG,
427  errmsg("could not create socket for statistics collector: %m")));
428  continue;
429  }
430 
431  /*
432  * Bind it to a kernel assigned port on localhost and get the assigned
433  * port via getsockname().
434  */
435  if (bind(pgStatSock, addr->ai_addr, addr->ai_addrlen) < 0)
436  {
437  ereport(LOG,
439  errmsg("could not bind socket for statistics collector: %m")));
442  continue;
443  }
444 
445  alen = sizeof(pgStatAddr);
446  if (getsockname(pgStatSock, (struct sockaddr *) &pgStatAddr, &alen) < 0)
447  {
448  ereport(LOG,
450  errmsg("could not get address of socket for statistics collector: %m")));
453  continue;
454  }
455 
456  /*
457  * Connect the socket to its own address. This saves a few cycles by
458  * not having to respecify the target address on every send. This also
459  * provides a kernel-level check that only packets from this same
460  * address will be received.
461  */
462  if (connect(pgStatSock, (struct sockaddr *) &pgStatAddr, alen) < 0)
463  {
464  ereport(LOG,
466  errmsg("could not connect socket for statistics collector: %m")));
469  continue;
470  }
471 
472  /*
473  * Try to send and receive a one-byte test message on the socket. This
474  * is to catch situations where the socket can be created but will not
475  * actually pass data (for instance, because kernel packet filtering
476  * rules prevent it).
477  */
478  test_byte = TESTBYTEVAL;
479 
480 retry1:
481  if (send(pgStatSock, &test_byte, 1, 0) != 1)
482  {
483  if (errno == EINTR)
484  goto retry1; /* if interrupted, just retry */
485  ereport(LOG,
487  errmsg("could not send test message on socket for statistics collector: %m")));
490  continue;
491  }
492 
493  /*
494  * There could possibly be a little delay before the message can be
495  * received. We arbitrarily allow up to half a second before deciding
496  * it's broken.
497  */
498  for (;;) /* need a loop to handle EINTR */
499  {
500  FD_ZERO(&rset);
501  FD_SET(pgStatSock, &rset);
502 
503  tv.tv_sec = 0;
504  tv.tv_usec = 500000;
505  sel_res = select(pgStatSock + 1, &rset, NULL, NULL, &tv);
506  if (sel_res >= 0 || errno != EINTR)
507  break;
508  }
509  if (sel_res < 0)
510  {
511  ereport(LOG,
513  errmsg("select() failed in statistics collector: %m")));
516  continue;
517  }
518  if (sel_res == 0 || !FD_ISSET(pgStatSock, &rset))
519  {
520  /*
521  * This is the case we actually think is likely, so take pains to
522  * give a specific message for it.
523  *
524  * errno will not be set meaningfully here, so don't use it.
525  */
526  ereport(LOG,
527  (errcode(ERRCODE_CONNECTION_FAILURE),
528  errmsg("test message did not get through on socket for statistics collector")));
531  continue;
532  }
533 
534  test_byte++; /* just make sure variable is changed */
535 
536 retry2:
537  if (recv(pgStatSock, &test_byte, 1, 0) != 1)
538  {
539  if (errno == EINTR)
540  goto retry2; /* if interrupted, just retry */
541  ereport(LOG,
543  errmsg("could not receive test message on socket for statistics collector: %m")));
546  continue;
547  }
548 
549  if (test_byte != TESTBYTEVAL) /* strictly paranoia ... */
550  {
551  ereport(LOG,
552  (errcode(ERRCODE_INTERNAL_ERROR),
553  errmsg("incorrect test message transmission on socket for statistics collector")));
556  continue;
557  }
558 
559  /* If we get here, we have a working socket */
560  break;
561  }
562 
563  /* Did we find a working address? */
564  if (!addr || pgStatSock == PGINVALID_SOCKET)
565  goto startup_failed;
566 
567  /*
568  * Set the socket to non-blocking IO. This ensures that if the collector
569  * falls behind, statistics messages will be discarded; backends won't
570  * block waiting to send messages to the collector.
571  */
573  {
574  ereport(LOG,
576  errmsg("could not set statistics collector socket to nonblocking mode: %m")));
577  goto startup_failed;
578  }
579 
580  /*
581  * Try to ensure that the socket's receive buffer is at least
582  * PGSTAT_MIN_RCVBUF bytes, so that it won't easily overflow and lose
583  * data. Use of UDP protocol means that we are willing to lose data under
584  * heavy load, but we don't want it to happen just because of ridiculously
585  * small default buffer sizes (such as 8KB on older Windows versions).
586  */
587  {
588  int old_rcvbuf;
589  int new_rcvbuf;
590  ACCEPT_TYPE_ARG3 rcvbufsize = sizeof(old_rcvbuf);
591 
592  if (getsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
593  (char *) &old_rcvbuf, &rcvbufsize) < 0)
594  {
595  elog(LOG, "getsockopt(SO_RCVBUF) failed: %m");
596  /* if we can't get existing size, always try to set it */
597  old_rcvbuf = 0;
598  }
599 
600  new_rcvbuf = PGSTAT_MIN_RCVBUF;
601  if (old_rcvbuf < new_rcvbuf)
602  {
603  if (setsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
604  (char *) &new_rcvbuf, sizeof(new_rcvbuf)) < 0)
605  elog(LOG, "setsockopt(SO_RCVBUF) failed: %m");
606  }
607  }
608 
609  pg_freeaddrinfo_all(hints.ai_family, addrs);
610 
611  return;
612 
613 startup_failed:
614  ereport(LOG,
615  (errmsg("disabling statistics collector for lack of working socket")));
616 
617  if (addrs)
618  pg_freeaddrinfo_all(hints.ai_family, addrs);
619 
623 
624  /*
625  * Adjust GUC variables to suppress useless activity, and for debugging
626  * purposes (seeing track_counts off is a clue that we failed here). We
627  * use PGC_S_OVERRIDE because there is no point in trying to turn it back
628  * on from postgresql.conf without a restart.
629  */
630  SetConfigOption("track_counts", "off", PGC_INTERNAL, PGC_S_OVERRIDE);
631 }
void pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo *ai)
Definition: ip.c:88
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
#define closesocket
Definition: port.h:309
int errcode(int sqlerrcode)
Definition: elog.c:570
#define connect(s, name, namelen)
Definition: win32_port.h:444
#define LOG
Definition: elog.h:26
#define bind(s, addr, addrlen)
Definition: win32_port.h:441
#define recv(s, buf, len, flags)
Definition: win32_port.h:446
#define gai_strerror
Definition: getaddrinfo.h:146
int pg_getaddrinfo_all(const char *hostname, const char *servname, const struct addrinfo *hintp, struct addrinfo **result)
Definition: ip.c:57
#define StaticAssertStmt(condition, errmessage)
Definition: c.h:828
#define PGSTAT_MIN_RCVBUF
Definition: pgstat.c:97
#define TESTBYTEVAL
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:7170
#define AI_PASSIVE
Definition: getaddrinfo.h:62
#define select(n, r, w, e, timeout)
Definition: win32_port.h:445
#define ereport(elevel, rest)
Definition: elog.h:141
int errcode_for_socket_access(void)
Definition: elog.c:664
#define socket(af, type, protocol)
Definition: win32_port.h:440
#define PGSTAT_MAX_MSG_SIZE
Definition: pgstat.h:206
#define PGINVALID_SOCKET
Definition: port.h:33
static struct sockaddr_storage pgStatAddr
Definition: pgstat.c:151
bool pg_set_noblock(pgsocket sock)
Definition: noblock.c:25
struct addrinfo * ai_next
Definition: getaddrinfo.h:107
int errmsg(const char *fmt,...)
Definition: elog.c:784
#define elog(elevel,...)
Definition: elog.h:226
#define EINTR
Definition: win32_port.h:332
#define send(s, buf, len, flags)
Definition: win32_port.h:447

◆ pgstat_init_function_usage()

void pgstat_init_function_usage ( FunctionCallInfoData fcinfo,
PgStat_FunctionCallUsage fcu 
)

Definition at line 1585 of file pgstat.c.

References HASHCTL::entrysize, PgStat_BackendFunctionEntry::f_counts, PgStat_FunctionCallUsage::f_start, PgStat_FunctionCounts::f_total_time, FunctionCallInfoData::flinfo, FmgrInfo::fn_oid, PgStat_FunctionCallUsage::fs, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), INSTR_TIME_SET_CURRENT, HASHCTL::keysize, MemSet, PGSTAT_FUNCTION_HASH_SIZE, PgStat_FunctionCallUsage::save_f_total_time, PgStat_FunctionCallUsage::save_total, and total_func_time.

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

1587 {
1588  PgStat_BackendFunctionEntry *htabent;
1589  bool found;
1590 
1591  if (pgstat_track_functions <= fcinfo->flinfo->fn_stats)
1592  {
1593  /* stats not wanted */
1594  fcu->fs = NULL;
1595  return;
1596  }
1597 
1598  if (!pgStatFunctions)
1599  {
1600  /* First time through - initialize function stat table */
1601  HASHCTL hash_ctl;
1602 
1603  memset(&hash_ctl, 0, sizeof(hash_ctl));
1604  hash_ctl.keysize = sizeof(Oid);
1605  hash_ctl.entrysize = sizeof(PgStat_BackendFunctionEntry);
1606  pgStatFunctions = hash_create("Function stat entries",
1608  &hash_ctl,
1609  HASH_ELEM | HASH_BLOBS);
1610  }
1611 
1612  /* Get the stats entry for this function, create if necessary */
1613  htabent = hash_search(pgStatFunctions, &fcinfo->flinfo->fn_oid,
1614  HASH_ENTER, &found);
1615  if (!found)
1616  MemSet(&htabent->f_counts, 0, sizeof(PgStat_FunctionCounts));
1617 
1618  fcu->fs = &htabent->f_counts;
1619 
1620  /* save stats for this function, later used to compensate for recursion */
1621  fcu->save_f_total_time = htabent->f_counts.f_total_time;
1622 
1623  /* save current backend-wide total time */
1624  fcu->save_total = total_func_time;
1625 
1626  /* get clock time as of function start */
1628 }
#define HASH_ELEM
Definition: hsearch.h:87
instr_time save_total
Definition: pgstat.h:1123
Size entrysize
Definition: hsearch.h:73
#define MemSet(start, val, len)
Definition: c.h:941
instr_time f_total_time
Definition: pgstat.h:462
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
unsigned int Oid
Definition: postgres_ext.h:31
PgStat_FunctionCounts * fs
Definition: pgstat.h:1119
FmgrInfo * flinfo
Definition: fmgr.h:79
PgStat_FunctionCounts f_counts
Definition: pgstat.h:473
#define PGSTAT_FUNCTION_HASH_SIZE
Definition: pgstat.c:106
#define HASH_BLOBS
Definition: hsearch.h:88
HTAB * hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
Definition: dynahash.c:316
Size keysize
Definition: hsearch.h:72
Oid fn_oid
Definition: fmgr.h:59
static instr_time total_func_time
Definition: pgstat.c:276
static HTAB * pgStatFunctions
Definition: pgstat.c:197
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
instr_time save_f_total_time
Definition: pgstat.h:1121
struct PgStat_BackendFunctionEntry PgStat_BackendFunctionEntry

◆ pgstat_initialize()

void pgstat_initialize ( void  )

Definition at line 2749 of file pgstat.c.

References Assert, InvalidBackendId, MaxBackends, MyAuxProcType, MyBackendId, NotAnAuxProcess, on_shmem_exit(), and pgstat_beshutdown_hook().

Referenced by AuxiliaryProcessMain(), and InitPostgres().

2750 {
2751  /* Initialize MyBEEntry */
2753  {
2756  }
2757  else
2758  {
2759  /* Must be an auxiliary process */
2761 
2762  /*
2763  * Assign the MyBEEntry for an auxiliary process. Since it doesn't
2764  * have a BackendId, the slot is statically allocated based on the
2765  * auxiliary process type (MyAuxProcType). Backends use slots indexed
2766  * in the range from 1 to MaxBackends (inclusive), so we use
2767  * MaxBackends + AuxBackendType + 1 as the index of the slot for an
2768  * auxiliary process.
2769  */
2771  }
2772 
2773  /* Set up a process-exit hook to clean up */
2775 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2593
BackendId MyBackendId
Definition: globals.c:81
int MaxBackends
Definition: globals.c:135
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2594
void on_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:361
static void pgstat_beshutdown_hook(int code, Datum arg)
Definition: pgstat.c:2952
#define InvalidBackendId
Definition: backendid.h:23
AuxProcType MyAuxProcType
Definition: bootstrap.c:70
#define Assert(condition)
Definition: c.h:732

◆ pgstat_initstats()

void pgstat_initstats ( Relation  rel)

Definition at line 1714 of file pgstat.c.

References get_tabstat_entry(), PGINVALID_SOCKET, RelationData::pgstat_info, pgstat_track_counts, pgStatSock, RelationData::rd_id, RelationData::rd_rel, relkind, and PgStat_TableStatus::t_id.

Referenced by relation_open(), and try_relation_open().

1715 {
1716  Oid rel_id = rel->rd_id;
1717  char relkind = rel->rd_rel->relkind;
1718 
1719  /* We only count stats for things that have storage */
1720  if (!(relkind == RELKIND_RELATION ||
1721  relkind == RELKIND_MATVIEW ||
1722  relkind == RELKIND_INDEX ||
1723  relkind == RELKIND_TOASTVALUE ||
1724  relkind == RELKIND_SEQUENCE))
1725  {
1726  rel->pgstat_info = NULL;
1727  return;
1728  }
1729 
1731  {
1732  /* We're not counting at all */
1733  rel->pgstat_info = NULL;
1734  return;
1735  }
1736 
1737  /*
1738  * If we already set up this relation in the current transaction, nothing
1739  * to do.
1740  */
1741  if (rel->pgstat_info != NULL &&
1742  rel->pgstat_info->t_id == rel_id)
1743  return;
1744 
1745  /* Else find or make the PgStat_TableStatus entry, and update link */
1746  rel->pgstat_info = get_tabstat_entry(rel_id, rel->rd_rel->relisshared);
1747 }
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
Form_pg_class rd_rel
Definition: rel.h:84
unsigned int Oid
Definition: postgres_ext.h:31
char relkind
Definition: pg_class.h:52
bool pgstat_track_counts
Definition: pgstat.c:126
Oid rd_id
Definition: rel.h:86
static PgStat_TableStatus * get_tabstat_entry(Oid rel_id, bool isshared)
Definition: pgstat.c:1753
#define PGINVALID_SOCKET
Definition: port.h:33
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:189

◆ pgstat_ping()

void pgstat_ping ( void  )

Definition at line 1550 of file pgstat.c.

References PgStat_MsgDummy::m_hdr, PGINVALID_SOCKET, PGSTAT_MTYPE_DUMMY, pgstat_send(), pgstat_setheader(), and pgStatSock.

1551 {
1552  PgStat_MsgDummy msg;
1553 
1555  return;
1556 
1558  pgstat_send(&msg, sizeof(msg));
1559 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
#define PGINVALID_SOCKET
Definition: port.h:33
PgStat_MsgHdr m_hdr
Definition: pgstat.h:216
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4155

◆ pgstat_progress_end_command()

void pgstat_progress_end_command ( void  )

Definition at line 3140 of file pgstat.c.

References InvalidOid, MyBEEntry, pgstat_increment_changecount_after, pgstat_increment_changecount_before, pgstat_track_activities, PROGRESS_COMMAND_INVALID, PgBackendStatus::st_progress_command, and PgBackendStatus::st_progress_command_target.

Referenced by AbortSubTransaction(), AbortTransaction(), and lazy_vacuum_rel().

3141 {
3142  volatile PgBackendStatus *beentry = MyBEEntry;
3143 
3144  if (!beentry)
3145  return;
3148  return;
3149 
3154 }
Oid st_progress_command_target
Definition: pgstat.h:1043
ProgressCommandType st_progress_command
Definition: pgstat.h:1042
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2594
#define pgstat_increment_changecount_before(beentry)
Definition: pgstat.h:1059
#define pgstat_increment_changecount_after(beentry)
Definition: pgstat.h:1065
#define InvalidOid
Definition: postgres_ext.h:36
bool pgstat_track_activities
Definition: pgstat.c:125

◆ pgstat_progress_start_command()

void pgstat_progress_start_command ( ProgressCommandType  cmdtype,
Oid  relid 
)

Definition at line 3068 of file pgstat.c.

References MemSet, MyBEEntry, pgstat_increment_changecount_after, pgstat_increment_changecount_before, pgstat_track_activities, PgBackendStatus::st_progress_command, PgBackendStatus::st_progress_command_target, and PgBackendStatus::st_progress_param.

Referenced by lazy_vacuum_rel().

3069 {
3070  volatile PgBackendStatus *beentry = MyBEEntry;
3071 
3072  if (!beentry || !pgstat_track_activities)
3073  return;
3074 
3076  beentry->st_progress_command = cmdtype;
3077  beentry->st_progress_command_target = relid;
3078  MemSet(&beentry->st_progress_param, 0, sizeof(beentry->st_progress_param));
3080 }
Oid st_progress_command_target
Definition: pgstat.h:1043
#define MemSet(start, val, len)
Definition: c.h:941
ProgressCommandType st_progress_command
Definition: pgstat.h:1042
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2594
#define pgstat_increment_changecount_before(beentry)
Definition: pgstat.h:1059
#define pgstat_increment_changecount_after(beentry)
Definition: pgstat.h:1065
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition: pgstat.h:1044
bool pgstat_track_activities
Definition: pgstat.c:125

◆ pgstat_progress_update_multi_param()

void pgstat_progress_update_multi_param ( int  nparam,
const int *  index,
const int64 *  val 
)

Definition at line 3111 of file pgstat.c.

References Assert, i, MyBEEntry, pgstat_increment_changecount_after, pgstat_increment_changecount_before, PGSTAT_NUM_PROGRESS_PARAM, pgstat_track_activities, and PgBackendStatus::st_progress_param.

Referenced by lazy_scan_heap().

3113 {
3114  volatile PgBackendStatus *beentry = MyBEEntry;
3115  int i;
3116 
3117  if (!beentry || !pgstat_track_activities || nparam == 0)
3118  return;
3119 
3121 
3122  for (i = 0; i < nparam; ++i)
3123  {
3124  Assert(index[i] >= 0 && index[i] < PGSTAT_NUM_PROGRESS_PARAM);
3125 
3126  beentry->st_progress_param[index[i]] = val[i];
3127  }
3128 
3130 }
Definition: type.h:89
#define PGSTAT_NUM_PROGRESS_PARAM
Definition: pgstat.h:940
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2594
#define pgstat_increment_changecount_before(beentry)
Definition: pgstat.h:1059
#define pgstat_increment_changecount_after(beentry)
Definition: pgstat.h:1065
#define Assert(condition)
Definition: c.h:732
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition: pgstat.h:1044
bool pgstat_track_activities
Definition: pgstat.c:125
int i
long val
Definition: informix.c:689

◆ pgstat_progress_update_param()

void pgstat_progress_update_param ( int  index,
int64  val 
)

Definition at line 3089 of file pgstat.c.

References Assert, MyBEEntry, pgstat_increment_changecount_after, pgstat_increment_changecount_before, PGSTAT_NUM_PROGRESS_PARAM, pgstat_track_activities, PgBackendStatus::st_progress_param, and val.

Referenced by lazy_record_dead_tuple(), lazy_scan_heap(), lazy_truncate_heap(), lazy_vacuum_page(), and lazy_vacuum_rel().

3090 {
3091  volatile PgBackendStatus *beentry = MyBEEntry;
3092 
3094 
3095  if (!beentry || !pgstat_track_activities)
3096  return;
3097 
3099  beentry->st_progress_param[index] = val;
3101 }
Definition: type.h:89
#define PGSTAT_NUM_PROGRESS_PARAM
Definition: pgstat.h:940
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2594
#define pgstat_increment_changecount_before(beentry)
Definition: pgstat.h:1059
#define pgstat_increment_changecount_after(beentry)
Definition: pgstat.h:1065
#define Assert(condition)
Definition: c.h:732
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition: pgstat.h:1044
bool pgstat_track_activities
Definition: pgstat.c:125
long val
Definition: informix.c:689

◆ pgstat_report_activity()

void pgstat_report_activity ( BackendState  state,
const char *  cmd_str 
)

Definition at line 2990 of file pgstat.c.

References GetCurrentStatementStartTimestamp(), GetCurrentTimestamp(), Min, MyBEEntry, MyProc, pgstat_increment_changecount_after, pgstat_increment_changecount_before, pgstat_track_activities, pgstat_track_activity_query_size, PgBackendStatus::st_activity_raw, PgBackendStatus::st_activity_start_timestamp, PgBackendStatus::st_state, PgBackendStatus::st_state_start_timestamp, PgBackendStatus::st_xact_start_timestamp, STATE_DISABLED, and PGPROC::wait_event_info.

Referenced by _bt_parallel_build_main(), apply_handle_begin(), apply_handle_commit(), autovac_report_activity(), autovac_report_workitem(), exec_bind_message(), exec_execute_message(), exec_parse_message(), exec_replication_command(), exec_simple_query(), initialize_worker_spi(), LogicalRepApplyLoop(), ParallelQueryMain(), and PostgresMain().

2991 {
2992  volatile PgBackendStatus *beentry = MyBEEntry;
2993  TimestampTz start_timestamp;
2994  TimestampTz current_timestamp;
2995  int len = 0;
2996 
2997  TRACE_POSTGRESQL_STATEMENT_STATUS(cmd_str);
2998 
2999  if (!beentry)
3000  return;
3001 
3003  {
3004  if (beentry->st_state != STATE_DISABLED)
3005  {
3006  volatile PGPROC *proc = MyProc;
3007 
3008  /*
3009  * track_activities is disabled, but we last reported a
3010  * non-disabled state. As our final update, change the state and
3011  * clear fields we will not be updating anymore.
3012  */
3014  beentry->st_state = STATE_DISABLED;
3015  beentry->st_state_start_timestamp = 0;
3016  beentry->st_activity_raw[0] = '\0';
3017  beentry->st_activity_start_timestamp = 0;
3018  /* st_xact_start_timestamp and wait_event_info are also disabled */
3019  beentry->st_xact_start_timestamp = 0;
3020  proc->wait_event_info = 0;
3022  }
3023  return;
3024  }
3025 
3026  /*
3027  * To minimize the time spent modifying the entry, fetch all the needed
3028  * data first.
3029  */
3030  start_timestamp = GetCurrentStatementStartTimestamp();
3031  if (cmd_str != NULL)
3032  {
3033  /*
3034  * Compute length of to-be-stored string unaware of multi-byte
3035  * characters. For speed reasons that'll get corrected on read, rather
3036  * than computed every write.
3037  */
3038  len = Min(strlen(cmd_str), pgstat_track_activity_query_size - 1);
3039  }
3040  current_timestamp = GetCurrentTimestamp();
3041 
3042  /*
3043  * Now update the status entry
3044  */
3046 
3047  beentry->st_state = state;
3048  beentry->st_state_start_timestamp = current_timestamp;
3049 
3050  if (cmd_str != NULL)
3051  {
3052  memcpy((char *) beentry->st_activity_raw, cmd_str, len);
3053  beentry->st_activity_raw[len] = '\0';
3054  beentry->st_activity_start_timestamp = start_timestamp;
3055  }
3056 
3058 }
uint32 wait_event_info
Definition: proc.h:176
TimestampTz st_activity_start_timestamp
Definition: pgstat.h:1005
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1570
PGPROC * MyProc
Definition: proc.c:67
int64 TimestampTz
Definition: timestamp.h:39
#define Min(x, y)
Definition: c.h:890
BackendState st_state
Definition: pgstat.h:1019
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2594
#define pgstat_increment_changecount_before(beentry)
Definition: pgstat.h:1059
char * st_activity_raw
Definition: pgstat.h:1031
int pgstat_track_activity_query_size
Definition: pgstat.c:128
TimestampTz st_state_start_timestamp
Definition: pgstat.h:1006
#define pgstat_increment_changecount_after(beentry)
Definition: pgstat.h:1065
Definition: regguts.h:298
TimestampTz st_xact_start_timestamp
Definition: pgstat.h:1004
bool pgstat_track_activities
Definition: pgstat.c:125
Definition: proc.h:95
TimestampTz GetCurrentStatementStartTimestamp(void)
Definition: xact.c:707

◆ pgstat_report_analyze()

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

Definition at line 1437 of file pgstat.c.

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

Referenced by do_analyze_rel().

1440 {
1441  PgStat_MsgAnalyze msg;
1442 
1444  return;
1445 
1446  /*
1447  * Unlike VACUUM, ANALYZE might be running inside a transaction that has
1448  * already inserted and/or deleted rows in the target table. ANALYZE will
1449  * have counted such rows as live or dead respectively. Because we will
1450  * report our counts of such rows at transaction end, we should subtract
1451  * off these counts from what we send to the collector now, else they'll
1452  * be double-counted after commit. (This approach also ensures that the
1453  * collector ends up with the right numbers if we abort instead of
1454  * committing.)
1455  */
1456  if (rel->pgstat_info != NULL)
1457  {
1459 
1460  for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
1461  {
1462  livetuples -= trans->tuples_inserted - trans->tuples_deleted;
1463  deadtuples -= trans->tuples_updated + trans->tuples_deleted;
1464  }
1465  /* count stuff inserted by already-aborted subxacts, too */
1466  deadtuples -= rel->pgstat_info->t_counts.t_delta_dead_tuples;
1467  /* Since ANALYZE's counts are estimates, we could have underflowed */
1468  livetuples = Max(livetuples, 0);
1469  deadtuples = Max(deadtuples, 0);
1470  }
1471 
1473  msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
1474  msg.m_tableoid = RelationGetRelid(rel);
1476  msg.m_resetcounter = resetcounter;
1478  msg.m_live_tuples = livetuples;
1479  msg.m_dead_tuples = deadtuples;
1480  pgstat_send(&msg, sizeof(msg));
1481 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
PgStat_Counter tuples_updated
Definition: pgstat.h:168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1570
TimestampTz m_analyzetime
Definition: pgstat.h:387
PgStat_TableCounts t_counts
Definition: pgstat.h:158
Form_pg_class rd_rel
Definition: rel.h:84
bool m_resetcounter
Definition: pgstat.h:386
bool pgstat_track_counts
Definition: pgstat.c:126
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
PgStat_Counter t_delta_dead_tuples
Definition: pgstat.h:111
bool IsAutoVacuumWorkerProcess(void)
Definition: autovacuum.c:3277
struct PgStat_TableXactStatus * upper
Definition: pgstat.h:176
PgStat_Counter m_live_tuples
Definition: pgstat.h:388
bool m_autovacuum
Definition: pgstat.h:385
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
#define PGINVALID_SOCKET
Definition: port.h:33
Oid MyDatabaseId
Definition: globals.c:85
#define InvalidOid
Definition: postgres_ext.h:36
#define Max(x, y)
Definition: c.h:884
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4155
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:189
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
PgStat_MsgHdr m_hdr
Definition: pgstat.h:382
static zic_t trans[TZ_MAX_LEAPS]
Definition: zic.c:398
PgStat_Counter m_dead_tuples
Definition: pgstat.h:389
#define RelationGetRelid(relation)
Definition: rel.h:407

◆ pgstat_report_appname()

void pgstat_report_appname ( const char *  appname)

Definition at line 3163 of file pgstat.c.

References MyBEEntry, NAMEDATALEN, pg_mbcliplen(), pgstat_increment_changecount_after, pgstat_increment_changecount_before, and PgBackendStatus::st_appname.

Referenced by assign_application_name(), and pgstat_bestart().

3164 {
3165  volatile PgBackendStatus *beentry = MyBEEntry;
3166  int len;
3167 
3168  if (!beentry)
3169  return;
3170 
3171  /* This should be unnecessary if GUC did its job, but be safe */
3172  len = pg_mbcliplen(appname, strlen(appname), NAMEDATALEN - 1);
3173 
3174  /*
3175  * Update my status entry, following the protocol of bumping
3176  * st_changecount before and after. We use a volatile pointer here to
3177  * ensure the compiler doesn't try to get cute.
3178  */
3180 
3181  memcpy((char *) beentry->st_appname, appname, len);
3182  beentry->st_appname[len] = '\0';
3183 
3185 }
#define NAMEDATALEN
int pg_mbcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:820
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2594
#define pgstat_increment_changecount_before(beentry)
Definition: pgstat.h:1059
#define pgstat_increment_changecount_after(beentry)
Definition: pgstat.h:1065
char * st_appname
Definition: pgstat.h:1022

◆ pgstat_report_autovac()

void pgstat_report_autovac ( Oid  dboid)

Definition at line 1387 of file pgstat.c.

References GetCurrentTimestamp(), PgStat_MsgAutovacStart::m_databaseid, PgStat_MsgAutovacStart::m_hdr, PgStat_MsgAutovacStart::m_start_time, PGINVALID_SOCKET, PGSTAT_MTYPE_AUTOVAC_START, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by AutoVacWorkerMain().

1388 {
1390 
1392  return;
1393 
1395  msg.m_databaseid = dboid;
1397 
1398  pgstat_send(&msg, sizeof(msg));
1399 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1570
PgStat_MsgHdr m_hdr
Definition: pgstat.h:352
#define PGINVALID_SOCKET
Definition: port.h:33
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4155
TimestampTz m_start_time
Definition: pgstat.h:354

◆ pgstat_report_deadlock()

void pgstat_report_deadlock ( void  )

Definition at line 1510 of file pgstat.c.

References PgStat_MsgDeadlock::m_databaseid, PgStat_MsgDeadlock::m_hdr, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_DEADLOCK, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by DeadLockReport().

1511 {
1512  PgStat_MsgDeadlock msg;
1513 
1515  return;
1516 
1518  msg.m_databaseid = MyDatabaseId;
1519  pgstat_send(&msg, sizeof(msg));
1520 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
bool pgstat_track_counts
Definition: pgstat.c:126
PgStat_MsgHdr m_hdr
Definition: pgstat.h:529
#define PGINVALID_SOCKET
Definition: port.h:33
Oid MyDatabaseId
Definition: globals.c:85
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4155

◆ pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int  reason)

Definition at line 1490 of file pgstat.c.

References PgStat_MsgRecoveryConflict::m_databaseid, PgStat_MsgRecoveryConflict::m_hdr, PgStat_MsgRecoveryConflict::m_reason, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_RECOVERYCONFLICT, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by ProcessInterrupts().

1491 {
1493 
1495  return;
1496 
1498  msg.m_databaseid = MyDatabaseId;
1499  msg.m_reason = reason;
1500  pgstat_send(&msg, sizeof(msg));
1501 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
bool pgstat_track_counts
Definition: pgstat.c:126
PgStat_MsgHdr m_hdr
Definition: pgstat.h:431
#define PGINVALID_SOCKET
Definition: port.h:33
Oid MyDatabaseId
Definition: globals.c:85
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4155

◆ pgstat_report_stat()

void pgstat_report_stat ( bool  force)

Definition at line 812 of file pgstat.c.

References Assert, GetCurrentTransactionStopTimestamp(), hash_destroy(), have_function_stats, i, InvalidOid, PgStat_MsgTabstat::m_databaseid, PgStat_MsgTabstat::m_entry, PgStat_MsgTabstat::m_nentries, MemSet, MyDatabaseId, now(), PGSTAT_NUM_TABENTRIES, pgstat_send_funcstats(), pgstat_send_tabstat(), PGSTAT_STAT_INTERVAL, pgStatXactCommit, pgStatXactRollback, PgStat_TableStatus::t_counts, PgStat_TableEntry::t_counts, PgStat_TableStatus::t_id, PgStat_TableEntry::t_id, PgStat_TableStatus::t_shared, TimestampDifferenceExceeds(), PgStat_TableStatus::trans, TabStatusArray::tsa_entries, TabStatusArray::tsa_next, and TabStatusArray::tsa_used.

Referenced by apply_handle_commit(), initialize_worker_spi(), LogicalRepSyncTableStart(), pg_attribute_noreturn(), pgstat_beshutdown_hook(), PostgresMain(), and process_syncing_tables_for_apply().

813 {
814  /* we assume this inits to all zeroes: */
815  static const PgStat_TableCounts all_zeroes;
816  static TimestampTz last_report = 0;
817 
819  PgStat_MsgTabstat regular_msg;
820  PgStat_MsgTabstat shared_msg;
821  TabStatusArray *tsa;
822  int i;
823 
824  /* Don't expend a clock check if nothing to do */
825  if ((pgStatTabList == NULL || pgStatTabList->tsa_used == 0) &&
826  pgStatXactCommit == 0 && pgStatXactRollback == 0 &&
828  return;
829 
830  /*
831  * Don't send a message unless it's been at least PGSTAT_STAT_INTERVAL
832  * msec since we last sent one, or the caller wants to force stats out.
833  */
835  if (!force &&
837  return;
838  last_report = now;
839 
840  /*
841  * Destroy pgStatTabHash before we start invalidating PgStat_TableEntry
842  * entries it points to. (Should we fail partway through the loop below,
843  * it's okay to have removed the hashtable already --- the only
844  * consequence is we'd get multiple entries for the same table in the
845  * pgStatTabList, and that's safe.)
846  */
847  if (pgStatTabHash)
849  pgStatTabHash = NULL;
850 
851  /*
852  * Scan through the TabStatusArray struct(s) to find tables that actually
853  * have counts, and build messages to send. We have to separate shared
854  * relations from regular ones because the databaseid field in the message
855  * header has to depend on that.
856  */
857  regular_msg.m_databaseid = MyDatabaseId;
858  shared_msg.m_databaseid = InvalidOid;
859  regular_msg.m_nentries = 0;
860  shared_msg.m_nentries = 0;
861 
862  for (tsa = pgStatTabList; tsa != NULL; tsa = tsa->tsa_next)
863  {
864  for (i = 0; i < tsa->tsa_used; i++)
865  {
866  PgStat_TableStatus *entry = &tsa->tsa_entries[i];
867  PgStat_MsgTabstat *this_msg;
868  PgStat_TableEntry *this_ent;
869 
870  /* Shouldn't have any pending transaction-dependent counts */
871  Assert(entry->trans == NULL);
872 
873  /*
874  * Ignore entries that didn't accumulate any actual counts, such
875  * as indexes that were opened by the planner but not used.
876  */
877  if (memcmp(&entry->t_counts, &all_zeroes,
878  sizeof(PgStat_TableCounts)) == 0)
879  continue;
880 
881  /*
882  * OK, insert data into the appropriate message, and send if full.
883  */
884  this_msg = entry->t_shared ? &shared_msg : &regular_msg;
885  this_ent = &this_msg->m_entry[this_msg->m_nentries];
886  this_ent->t_id = entry->t_id;
887  memcpy(&this_ent->t_counts, &entry->t_counts,
888  sizeof(PgStat_TableCounts));
889  if (++this_msg->m_nentries >= PGSTAT_NUM_TABENTRIES)
890  {
891  pgstat_send_tabstat(this_msg);
892  this_msg->m_nentries = 0;
893  }
894  }
895  /* zero out TableStatus structs after use */
896  MemSet(tsa->tsa_entries, 0,
897  tsa->tsa_used * sizeof(PgStat_TableStatus));
898  tsa->tsa_used = 0;
899  }
900 
901  /*
902  * Send partial messages. Make sure that any pending xact commit/abort
903  * gets counted, even if there are no table stats to send.
904  */
905  if (regular_msg.m_nentries > 0 ||
907  pgstat_send_tabstat(&regular_msg);
908  if (shared_msg.m_nentries > 0)
909  pgstat_send_tabstat(&shared_msg);
910 
911  /* Now, send function statistics */
913 }
void hash_destroy(HTAB *hashp)
Definition: dynahash.c:814
int tsa_used
Definition: pgstat.c:173
static int pgStatXactCommit
Definition: pgstat.c:221
int64 TimestampTz
Definition: timestamp.h:39
#define MemSet(start, val, len)
Definition: c.h:941
struct TabStatusArray * tsa_next
Definition: pgstat.c:172
PgStat_TableCounts t_counts
Definition: pgstat.h:158
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
Definition: timestamp.c:1669
static void pgstat_send_tabstat(PgStat_MsgTabstat *tsmsg)
Definition: pgstat.c:919
static HTAB * pgStatTabHash
Definition: pgstat.c:191
static int pgStatXactRollback
Definition: pgstat.c:222
#define PGSTAT_STAT_INTERVAL
Definition: pgstat.c:77
PgStat_TableStatus tsa_entries[TABSTAT_QUANTUM]
Definition: pgstat.c:174
#define PGSTAT_NUM_TABENTRIES
Definition: pgstat.h:263
Oid MyDatabaseId
Definition: globals.c:85
static TabStatusArray * pgStatTabList
Definition: pgstat.c:177
#define InvalidOid
Definition: postgres_ext.h:36
static bool have_function_stats
Definition: pgstat.c:203
TimestampTz GetCurrentTransactionStopTimestamp(void)
Definition: xact.c:719
#define Assert(condition)
Definition: c.h:732
PgStat_TableCounts t_counts
Definition: pgstat.h:255
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
PgStat_TableEntry m_entry[PGSTAT_NUM_TABENTRIES]
Definition: pgstat.h:276
int i
static void pgstat_send_funcstats(void)
Definition: pgstat.c:963
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1534

◆ pgstat_report_tempfile()

void pgstat_report_tempfile ( size_t  filesize)

Definition at line 1529 of file pgstat.c.

References PgStat_MsgTempFile::m_databaseid, PgStat_MsgTempFile::m_filesize, PgStat_MsgTempFile::m_hdr, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_TEMPFILE, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by ReportTemporaryFileUsage().

1530 {
1531  PgStat_MsgTempFile msg;
1532 
1534  return;
1535 
1537  msg.m_databaseid = MyDatabaseId;
1538  msg.m_filesize = filesize;
1539  pgstat_send(&msg, sizeof(msg));
1540 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
PgStat_MsgHdr m_hdr
Definition: pgstat.h:443
size_t m_filesize
Definition: pgstat.h:446
bool pgstat_track_counts
Definition: pgstat.c:126
#define PGINVALID_SOCKET
Definition: port.h:33
Oid MyDatabaseId
Definition: globals.c:85
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4155

◆ pgstat_report_vacuum()

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

Definition at line 1409 of file pgstat.c.

References GetCurrentTimestamp(), InvalidOid, IsAutoVacuumWorkerProcess(), PgStat_MsgVacuum::m_autovacuum, PgStat_MsgVacuum::m_databaseid, PgStat_MsgVacuum::m_dead_tuples, PgStat_MsgVacuum::m_hdr, PgStat_MsgVacuum::m_live_tuples, PgStat_MsgVacuum::m_tableoid, PgStat_MsgVacuum::m_vacuumtime, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_VACUUM, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by lazy_vacuum_rel().

1411 {
1412  PgStat_MsgVacuum msg;
1413 
1415  return;
1416 
1418  msg.m_databaseid = shared ? InvalidOid : MyDatabaseId;
1419  msg.m_tableoid = tableoid;
1422  msg.m_live_tuples = livetuples;
1423  msg.m_dead_tuples = deadtuples;
1424  pgstat_send(&msg, sizeof(msg));
1425 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
PgStat_Counter m_dead_tuples
Definition: pgstat.h:371
TimestampTz m_vacuumtime
Definition: pgstat.h:369
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
PgStat_Counter m_live_tuples
Definition: pgstat.h:370
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1570
Oid m_databaseid
Definition: pgstat.h:366
bool m_autovacuum
Definition: pgstat.h:368
bool pgstat_track_counts
Definition: pgstat.c:126
bool IsAutoVacuumWorkerProcess(void)
Definition: autovacuum.c:3277
#define PGINVALID_SOCKET
Definition: port.h:33
Oid MyDatabaseId
Definition: globals.c:85
#define InvalidOid
Definition: postgres_ext.h:36
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4155
PgStat_MsgHdr m_hdr
Definition: pgstat.h:365

◆ pgstat_report_wait_end()

static void pgstat_report_wait_end ( void  )
inlinestatic

Definition at line 1262 of file pgstat.h.

References MyProc, pgstat_track_activities, and PGPROC::wait_event_info.

Referenced by AbortSubTransaction(), AbortTransaction(), AddToDataDirLockFile(), ApplyLogicalMappingFile(), assign_xlog_sync_method(), AutoVacLauncherMain(), BackgroundWriterMain(), BootStrapXLOG(), CheckpointerMain(), CheckPointLogicalRewriteHeap(), copy_file(), CreateLockFile(), dsm_impl_mmap(), FilePrefetch(), FileRead(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), heap_xlog_logical_rewrite(), issue_xlog_fsync(), load_relmap_file(), LWLockReportWaitEnd(), ProcArrayGroupClearXid(), ReadControlFile(), ReadTwoPhaseFile(), RecheckDataDirLockFile(), RecreateTwoPhaseFile(), ReorderBufferRestoreChanges(), ReorderBufferSerializeChange(), RestoreSlotFromDisk(), SaveSlotToPath(), SendTimeLineHistory(), ShutdownAuxiliaryProcess(), SimpleLruFlush(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SnapBuildRestore(), SnapBuildSerialize(), TransactionGroupUpdateXidStatus(), UpdateControlFile(), WaitEventSetWait(), WalSndErrorCleanup(), WalWriterMain(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), XLogFileCopy(), XLogFileInit(), XLogPageRead(), XLogRead(), and XLogWrite().

1263 {
1264  volatile PGPROC *proc = MyProc;
1265 
1266  if (!pgstat_track_activities || !proc)
1267  return;
1268 
1269  /*
1270  * Since this is a four-byte field which is always read and written as
1271  * four-bytes, updates are atomic.
1272  */
1273  proc->wait_event_info = 0;
1274 }
uint32 wait_event_info
Definition: proc.h:176
PGPROC * MyProc
Definition: proc.c:67
bool pgstat_track_activities
Definition: pgstat.c:125
Definition: proc.h:95

◆ pgstat_report_wait_start()

static void pgstat_report_wait_start ( uint32  wait_event_info)
inlinestatic

Definition at line 1238 of file pgstat.h.

References MyProc, pgstat_track_activities, and PGPROC::wait_event_info.

Referenced by AddToDataDirLockFile(), ApplyLogicalMappingFile(), assign_xlog_sync_method(), BootStrapXLOG(), CheckPointLogicalRewriteHeap(), copy_file(), CreateLockFile(), dsm_impl_mmap(), FilePrefetch(), FileRead(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), heap_xlog_logical_rewrite(), issue_xlog_fsync(), load_relmap_file(), LWLockReportWaitStart(), ProcArrayGroupClearXid(), ReadControlFile(), ReadTwoPhaseFile(), RecheckDataDirLockFile(), RecreateTwoPhaseFile(), ReorderBufferRestoreChanges(), ReorderBufferSerializeChange(), RestoreSlotFromDisk(), SaveSlotToPath(), SendTimeLineHistory(), SimpleLruFlush(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SnapBuildRestore(), SnapBuildSerialize(), TransactionGroupUpdateXidStatus(), UpdateControlFile(), WaitEventSetWait(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), XLogFileCopy(), XLogFileInit(), XLogPageRead(), XLogRead(), and XLogWrite().

1239 {
1240  volatile PGPROC *proc = MyProc;
1241 
1242  if (!pgstat_track_activities || !proc)
1243  return;
1244 
1245  /*
1246  * Since this is a four-byte field which is always read and written as
1247  * four-bytes, updates are atomic.
1248  */
1249  proc->wait_event_info = wait_event_info;
1250 }
uint32 wait_event_info
Definition: proc.h:176
PGPROC * MyProc
Definition: proc.c:67
bool pgstat_track_activities
Definition: pgstat.c:125
Definition: proc.h:95

◆ pgstat_report_xact_timestamp()

void pgstat_report_xact_timestamp ( TimestampTz  tstamp)

Definition at line 3192 of file pgstat.c.

References MyBEEntry, pgstat_increment_changecount_after, pgstat_increment_changecount_before, pgstat_track_activities, and PgBackendStatus::st_xact_start_timestamp.

Referenced by AbortTransaction(), CommitTransaction(), PrepareTransaction(), and StartTransaction().

3193 {
3194  volatile PgBackendStatus *beentry = MyBEEntry;
3195 
3196  if (!pgstat_track_activities || !beentry)
3197  return;
3198 
3199  /*
3200  * Update my status entry, following the protocol of bumping
3201  * st_changecount before and after. We use a volatile pointer here to
3202  * ensure the compiler doesn't try to get cute.
3203  */
3205  beentry->st_xact_start_timestamp = tstamp;
3207 }
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2594
#define pgstat_increment_changecount_before(beentry)
Definition: pgstat.h:1059
#define pgstat_increment_changecount_after(beentry)
Definition: pgstat.h:1065
TimestampTz st_xact_start_timestamp
Definition: pgstat.h:1004
bool pgstat_track_activities
Definition: pgstat.c:125

◆ pgstat_reset_all()

void pgstat_reset_all ( void  )

Definition at line 685 of file pgstat.c.

References Assert, av, lengthof, pgstat_reset_remove_files(), pgstat_stat_directory, and PGSTAT_STAT_PERMANENT_DIRECTORY.

Referenced by StartupXLOG().

686 {
689 }
#define PGSTAT_STAT_PERMANENT_DIRECTORY
Definition: pgstat.h:29
char * pgstat_stat_directory
Definition: pgstat.c:134
static void pgstat_reset_remove_files(const char *directory)
Definition: pgstat.c:637

◆ pgstat_reset_counters()

void pgstat_reset_counters ( void  )

Definition at line 1310 of file pgstat.c.

References PgStat_MsgResetcounter::m_databaseid, PgStat_MsgResetcounter::m_hdr, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_RESETCOUNTER, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by pg_stat_reset().

1311 {
1313 
1315  return;
1316 
1318  msg.m_databaseid = MyDatabaseId;
1319  pgstat_send(&msg, sizeof(msg));
1320 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
PgStat_MsgHdr m_hdr
Definition: pgstat.h:317
#define PGINVALID_SOCKET
Definition: port.h:33
Oid MyDatabaseId
Definition: globals.c:85
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4155

◆ pgstat_reset_shared_counters()

void pgstat_reset_shared_counters ( const char *  )

Definition at line 1332 of file pgstat.c.

References ereport, errcode(), errhint(), errmsg(), ERROR, PgStat_MsgResetsharedcounter::m_hdr, PgStat_MsgResetsharedcounter::m_resettarget, PGINVALID_SOCKET, PGSTAT_MTYPE_RESETSHAREDCOUNTER, pgstat_send(), pgstat_setheader(), pgStatSock, RESET_ARCHIVER, and RESET_BGWRITER.

Referenced by pg_stat_reset_shared().

1333 {
1335 
1337  return;
1338 
1339  if (strcmp(target, "archiver") == 0)
1341  else if (strcmp(target, "bgwriter") == 0)
1343  else
1344  ereport(ERROR,
1345  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1346  errmsg("unrecognized reset target: \"%s\"", target),
1347  errhint("Target must be \"archiver\" or \"bgwriter\".")));
1348 
1350  pgstat_send(&msg, sizeof(msg));
1351 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4168
int errhint(const char *fmt,...)
Definition: elog.c:974
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:149
int errcode(int sqlerrcode)
Definition: elog.c:570