PostgreSQL Source Code  git master
pgstat.h File Reference
#include "datatype/timestamp.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
 
struct  PgStat_MsgChecksumFailure
 
union  PgStat_Msg
 
struct  PgStat_StatDBEntry
 
struct  PgStat_StatTabEntry
 
struct  PgStat_StatFuncEntry
 
struct  PgStat_ArchiverStats
 
struct  PgStat_GlobalStats
 
struct  PgBackendSSLStatus
 
struct  PgBackendGSSStatus
 
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   20
 
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
 
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
 
#define pgstat_begin_read_activity(beentry, before_changecount)
 
#define pgstat_end_read_activity(beentry, after_changecount)
 
#define pgstat_read_activity_complete(before_changecount, after_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 struct PgStat_MsgChecksumFailure PgStat_MsgChecksumFailure
 
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 PgBackendGSSStatus PgBackendGSSStatus
 
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, PGSTAT_MTYPE_CHECKSUMFAILURE
}
 
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,
  WAIT_EVENT_GSS_OPEN_SERVER
}
 
enum  WaitEventIPC {
  WAIT_EVENT_BGWORKER_SHUTDOWN = PG_WAIT_IPC, WAIT_EVENT_BGWORKER_STARTUP, WAIT_EVENT_BTREE_PAGE, WAIT_EVENT_CLOG_GROUP_UPDATE,
  WAIT_EVENT_CHECKPOINT_DONE, WAIT_EVENT_CHECKPOINT_START, 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, PROGRESS_COMMAND_CLUSTER, PROGRESS_COMMAND_CREATE_INDEX }
 

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_report_checksum_failures_in_db (Oid dboid, int failurecount)
 
void pgstat_report_checksum_failure (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 (struct FunctionCallInfoBaseData *fcinfo, PgStat_FunctionCallUsage *fcu)
 
void pgstat_end_function_usage (PgStat_FunctionCallUsage *fcu, bool finalize)
 
void AtEOXact_PgStat (bool isCommit, bool parallel)
 
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 33 of file pgstat.h.

◆ PG_WAIT_ACTIVITY

#define PG_WAIT_ACTIVITY   0x05000000U

Definition at line 757 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 758 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 762 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 760 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 761 of file pgstat.h.

Referenced by pgstat_get_wait_event(), and pgstat_get_wait_event_type().

◆ pgstat_begin_read_activity

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

Definition at line 1145 of file pgstat.h.

Referenced by pgstat_get_backend_current_activity(), and pgstat_read_current_status().

◆ PGSTAT_BEGIN_WRITE_ACTIVITY

#define PGSTAT_BEGIN_WRITE_ACTIVITY (   beentry)

◆ 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 1388 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 1383 of file pgstat.h.

Referenced by ReadBufferExtended().

◆ pgstat_count_buffer_read_time

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

Definition at line 1393 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 1395 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 1368 of file pgstat.h.

Referenced by heapam_scan_bitmap_next_tuple(), 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 1363 of file pgstat.h.

Referenced by heap_getnext(), heap_getnextslot(), and heapam_scan_sample_next_tuple().

◆ 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 1358 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 1373 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 1378 of file pgstat.h.

Referenced by index_getbitmap(), and index_getnext_tid().

◆ pgstat_end_read_activity

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

Definition at line 1151 of file pgstat.h.

Referenced by pgstat_get_backend_current_activity(), and pgstat_read_current_status().

◆ PGSTAT_END_WRITE_ACTIVITY

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

Definition at line 1137 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_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID   0x01A5BC9D

◆ 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   20

◆ 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_read_activity_complete

#define pgstat_read_activity_complete (   before_changecount,
  after_changecount 
)
Value:
((before_changecount) == (after_changecount) && \
((before_changecount) & 1) == 0)

Definition at line 1157 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 28 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 30 of file pgstat.h.

Referenced by pgstat_write_statsfiles().

Typedef Documentation

◆ BackendState

typedef enum BackendState BackendState

◆ BackendType

typedef enum BackendType BackendType

◆ LocalPgBackendStatus

◆ PgBackendGSSStatus

◆ PgBackendSSLStatus

◆ PgBackendStatus

◆ PgStat_ArchiverStats

◆ PgStat_BackendFunctionEntry

◆ PgStat_Counter

typedef int64 PgStat_Counter

Definition at line 74 of file pgstat.h.

◆ PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

◆ PgStat_FunctionEntry

◆ PgStat_GlobalStats

◆ PgStat_Msg

typedef union PgStat_Msg PgStat_Msg

◆ PgStat_MsgAnalyze

◆ PgStat_MsgArchiver

◆ PgStat_MsgAutovacStart

◆ PgStat_MsgBgWriter

◆ PgStat_MsgChecksumFailure

◆ PgStat_MsgDeadlock

◆ PgStat_MsgDropdb

◆ PgStat_MsgDummy

◆ PgStat_MsgFuncpurge

◆ PgStat_MsgFuncstat

◆ PgStat_MsgHdr

typedef struct PgStat_MsgHdr 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

typedef enum StatMsgType 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 738 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 719 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 
PROGRESS_COMMAND_CLUSTER 
PROGRESS_COMMAND_CREATE_INDEX 

Definition at line 954 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 
PGSTAT_MTYPE_CHECKSUMFAILURE 

Definition at line 47 of file pgstat.h.

48 {
68 } StatMsgType;
StatMsgType
Definition: pgstat.h:47

◆ TrackFunctionsLevel

Enumerator
TRACK_FUNC_OFF 
TRACK_FUNC_PL 
TRACK_FUNC_ALL 

Definition at line 36 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 772 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 
WAIT_EVENT_GSS_OPEN_SERVER 

Definition at line 798 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 878 of file pgstat.h.

879 {
948 } WaitEventIO;
#define PG_WAIT_IO
Definition: pgstat.h:762
WaitEventIO
Definition: pgstat.h:878

◆ WaitEventIPC

Enumerator
WAIT_EVENT_BGWORKER_SHUTDOWN 
WAIT_EVENT_BGWORKER_STARTUP 
WAIT_EVENT_BTREE_PAGE 
WAIT_EVENT_CLOG_GROUP_UPDATE 
WAIT_EVENT_CHECKPOINT_DONE 
WAIT_EVENT_CHECKPOINT_START 
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 818 of file pgstat.h.

819 {
857 } WaitEventIPC;
WaitEventIPC
Definition: pgstat.h:818
#define PG_WAIT_IPC
Definition: pgstat.h:760

◆ WaitEventTimeout

Enumerator
WAIT_EVENT_BASE_BACKUP_THROTTLE 
WAIT_EVENT_PG_SLEEP 
WAIT_EVENT_RECOVERY_APPLY_DELAY 

Definition at line 865 of file pgstat.h.

Function Documentation

◆ allow_immediate_pgstat_restart()

void allow_immediate_pgstat_restart ( void  )

Definition at line 789 of file pgstat.c.

References last_pgstat_start_time.

Referenced by HandleChildCrash().

790 {
792 }
static time_t last_pgstat_start_time
Definition: pgstat.c:151

◆ AtEOSubXact_PgStat()

void AtEOSubXact_PgStat ( bool  isCommit,
int  nestDepth 
)

Definition at line 2179 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().

2180 {
2181  PgStat_SubXactStatus *xact_state;
2182 
2183  /*
2184  * Transfer transactional insert/update counts into the next higher
2185  * subtransaction state.
2186  */
2187  xact_state = pgStatXactStack;
2188  if (xact_state != NULL &&
2189  xact_state->nest_level >= nestDepth)
2190  {
2192  PgStat_TableXactStatus *next_trans;
2193 
2194  /* delink xact_state from stack immediately to simplify reuse case */
2195  pgStatXactStack = xact_state->prev;
2196 
2197  for (trans = xact_state->first; trans != NULL; trans = next_trans)
2198  {
2199  PgStat_TableStatus *tabstat;
2200 
2201  next_trans = trans->next;
2202  Assert(trans->nest_level == nestDepth);
2203  tabstat = trans->parent;
2204  Assert(tabstat->trans == trans);
2205  if (isCommit)
2206  {
2207  if (trans->upper && trans->upper->nest_level == nestDepth - 1)
2208  {
2209  if (trans->truncated)
2210  {
2211  /* propagate the truncate status one level up */
2213  /* replace upper xact stats with ours */
2214  trans->upper->tuples_inserted = trans->tuples_inserted;
2215  trans->upper->tuples_updated = trans->tuples_updated;
2216  trans->upper->tuples_deleted = trans->tuples_deleted;
2217  }
2218  else
2219  {
2220  trans->upper->tuples_inserted += trans->tuples_inserted;
2221  trans->upper->tuples_updated += trans->tuples_updated;
2222  trans->upper->tuples_deleted += trans->tuples_deleted;
2223  }
2224  tabstat->trans = trans->upper;
2225  pfree(trans);
2226  }
2227  else
2228  {
2229  /*
2230  * When there isn't an immediate parent state, we can just
2231  * reuse the record instead of going through a
2232  * palloc/pfree pushup (this works since it's all in
2233  * TopTransactionContext anyway). We have to re-link it
2234  * into the parent level, though, and that might mean
2235  * pushing a new entry into the pgStatXactStack.
2236  */
2237  PgStat_SubXactStatus *upper_xact_state;
2238 
2239  upper_xact_state = get_tabstat_stack_level(nestDepth - 1);
2240  trans->next = upper_xact_state->first;
2241  upper_xact_state->first = trans;
2242  trans->nest_level = nestDepth - 1;
2243  }
2244  }
2245  else
2246  {
2247  /*
2248  * On abort, update top-level tabstat counts, then forget the
2249  * subtransaction
2250  */
2251 
2252  /* first restore values obliterated by truncate */
2254  /* count attempted actions regardless of commit/abort */
2255  tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
2256  tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
2257  tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
2258  /* inserted tuples are dead, deleted tuples are unaffected */
2259  tabstat->t_counts.t_delta_dead_tuples +=
2260  trans->tuples_inserted + trans->tuples_updated;
2261  tabstat->trans = trans->upper;
2262  pfree(trans);
2263  }
2264  }
2265  pfree(xact_state);
2266  }
2267 }
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:1897
void pfree(void *pointer)
Definition: mcxt.c:1056
PgStat_Counter t_tuples_updated
Definition: pgstat.h:105
static void pgstat_truncate_restore_counters(PgStat_TableXactStatus *trans)
Definition: pgstat.c:2033
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:213
#define Assert(condition)
Definition: c.h:739
static PgStat_SubXactStatus * pgStatXactStack
Definition: pgstat.c:217
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
static zic_t trans[TZ_MAX_LEAPS]
Definition: zic.c:396
PgStat_TableXactStatus * first
Definition: pgstat.c:214
static void pgstat_truncate_save_counters(PgStat_TableXactStatus *trans)
Definition: pgstat.c:2018
PgStat_Counter t_tuples_inserted
Definition: pgstat.h:104
PgStat_TableStatus * parent
Definition: pgstat.h:177

◆ AtEOXact_PgStat()

void AtEOXact_PgStat ( bool  isCommit,
bool  parallel 
)

Definition at line 2092 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().

2093 {
2094  PgStat_SubXactStatus *xact_state;
2095 
2096  /* Don't count parallel worker transaction stats */
2097  if (!parallel)
2098  {
2099  /*
2100  * Count transaction commit or abort. (We use counters, not just
2101  * bools, in case the reporting message isn't sent right away.)
2102  */
2103  if (isCommit)
2104  pgStatXactCommit++;
2105  else
2107  }
2108 
2109  /*
2110  * Transfer transactional insert/update counts into the base tabstat
2111  * entries. We don't bother to free any of the transactional state, since
2112  * it's all in TopTransactionContext and will go away anyway.
2113  */
2114  xact_state = pgStatXactStack;
2115  if (xact_state != NULL)
2116  {
2118 
2119  Assert(xact_state->nest_level == 1);
2120  Assert(xact_state->prev == NULL);
2121  for (trans = xact_state->first; trans != NULL; trans = trans->next)
2122  {
2123  PgStat_TableStatus *tabstat;
2124 
2125  Assert(trans->nest_level == 1);
2126  Assert(trans->upper == NULL);
2127  tabstat = trans->parent;
2128  Assert(tabstat->trans == trans);
2129  /* restore pre-truncate stats (if any) in case of aborted xact */
2130  if (!isCommit)
2132  /* count attempted actions regardless of commit/abort */
2133  tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
2134  tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
2135  tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
2136  if (isCommit)
2137  {
2138  tabstat->t_counts.t_truncated = trans->truncated;
2139  if (trans->truncated)
2140  {
2141  /* forget live/dead stats seen by backend thus far */
2142  tabstat->t_counts.t_delta_live_tuples = 0;
2143  tabstat->t_counts.t_delta_dead_tuples = 0;
2144  }
2145  /* insert adds a live tuple, delete removes one */
2146  tabstat->t_counts.t_delta_live_tuples +=
2147  trans->tuples_inserted - trans->tuples_deleted;
2148  /* update and delete each create a dead tuple */
2149  tabstat->t_counts.t_delta_dead_tuples +=
2150  trans->tuples_updated + trans->tuples_deleted;
2151  /* insert, update, delete each count as one change event */
2152  tabstat->t_counts.t_changed_tuples +=
2153  trans->tuples_inserted + trans->tuples_updated +
2154  trans->tuples_deleted;
2155  }
2156  else
2157  {
2158  /* inserted tuples are dead, deleted tuples are unaffected */
2159  tabstat->t_counts.t_delta_dead_tuples +=
2160  trans->tuples_inserted + trans->tuples_updated;
2161  /* an aborted xact generates no changed_tuple events */
2162  }
2163  tabstat->trans = NULL;
2164  }
2165  }
2166  pgStatXactStack = NULL;
2167 
2168  /* Make sure any stats snapshot is thrown away */
2170 }
PgStat_Counter t_delta_live_tuples
Definition: pgstat.h:110
PgStat_Counter tuples_updated
Definition: pgstat.h:168
static int pgStatXactCommit
Definition: pgstat.c:219
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:2033
static int pgStatXactRollback
Definition: pgstat.c:220
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:213
PgStat_Counter t_changed_tuples
Definition: pgstat.h:112
#define Assert(condition)
Definition: c.h:739
void pgstat_clear_snapshot(void)
Definition: pgstat.c:5794
static PgStat_SubXactStatus * pgStatXactStack
Definition: pgstat.c:217
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
static zic_t trans[TZ_MAX_LEAPS]
Definition: zic.c:396
PgStat_TableXactStatus * first
Definition: pgstat.c:214
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 2278 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().

2279 {
2280  PgStat_SubXactStatus *xact_state;
2281 
2282  xact_state = pgStatXactStack;
2283  if (xact_state != NULL)
2284  {
2286 
2287  Assert(xact_state->nest_level == 1);
2288  Assert(xact_state->prev == NULL);
2289  for (trans = xact_state->first; trans != NULL; trans = trans->next)
2290  {
2291  PgStat_TableStatus *tabstat;
2292  TwoPhasePgStatRecord record;
2293 
2294  Assert(trans->nest_level == 1);
2295  Assert(trans->upper == NULL);
2296  tabstat = trans->parent;
2297  Assert(tabstat->trans == trans);
2298 
2299  record.tuples_inserted = trans->tuples_inserted;
2300  record.tuples_updated = trans->tuples_updated;
2301  record.tuples_deleted = trans->tuples_deleted;
2302  record.inserted_pre_trunc = trans->inserted_pre_trunc;
2303  record.updated_pre_trunc = trans->updated_pre_trunc;
2304  record.deleted_pre_trunc = trans->deleted_pre_trunc;
2305  record.t_id = tabstat->t_id;
2306  record.t_shared = tabstat->t_shared;
2307  record.t_truncated = trans->truncated;
2308 
2310  &record, sizeof(TwoPhasePgStatRecord));
2311  }
2312  }
2313 }
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:232
void RegisterTwoPhaseRecord(TwoPhaseRmgrId rmid, uint16 info, const void *data, uint32 len)
Definition: twophase.c:1187
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
PgStat_Counter updated_pre_trunc
Definition: pgstat.c:231
PgStat_Counter inserted_pre_trunc
Definition: pgstat.c:230
struct PgStat_TableXactStatus * upper
Definition: pgstat.h:176
PgStat_Counter tuples_updated
Definition: pgstat.c:228
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
struct PgStat_SubXactStatus * prev
Definition: pgstat.c:213
#define Assert(condition)
Definition: c.h:739
PgStat_Counter inserted_pre_trunc
Definition: pgstat.h:171
PgStat_Counter tuples_inserted
Definition: pgstat.c:227
static PgStat_SubXactStatus * pgStatXactStack
Definition: pgstat.c:217
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
PgStat_Counter tuples_deleted
Definition: pgstat.c:229
#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:396
PgStat_TableXactStatus * first
Definition: pgstat.c:214
PgStat_TableStatus * parent
Definition: pgstat.h:177

◆ BackendStatusShmemSize()

Size BackendStatusShmemSize ( void  )

Definition at line 2650 of file pgstat.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

2651 {
2652  Size size;
2653 
2654  /* BackendStatusArray: */
2655  size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2656  /* BackendAppnameBuffer: */
2657  size = add_size(size,
2659  /* BackendClientHostnameBuffer: */
2660  size = add_size(size,
2662  /* BackendActivityBuffer: */
2663  size = add_size(size,
2665 #ifdef USE_SSL
2666  /* BackendSslStatusBuffer: */
2667  size = add_size(size,
2669 #endif
2670  return size;
2671 }
#define NumBackendStatSlots
Definition: pgstat.c:116
#define NAMEDATALEN
int pgstat_track_activity_query_size
Definition: pgstat.c:126
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:467

◆ CreateSharedBackendStatus()

void CreateSharedBackendStatus ( void  )

Definition at line 2678 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, PgBackendStatus::st_gssstatus, and PgBackendStatus::st_sslstatus.

Referenced by CreateSharedMemoryAndSemaphores().

2679 {
2680  Size size;
2681  bool found;
2682  int i;
2683  char *buffer;
2684 
2685  /* Create or attach to the shared array */
2686  size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2688  ShmemInitStruct("Backend Status Array", size, &found);
2689 
2690  if (!found)
2691  {
2692  /*
2693  * We're the first - initialize.
2694  */
2695  MemSet(BackendStatusArray, 0, size);
2696  }
2697 
2698  /* Create or attach to the shared appname buffer */
2700  BackendAppnameBuffer = (char *)
2701  ShmemInitStruct("Backend Application Name Buffer", size, &found);
2702 
2703  if (!found)
2704  {
2705  MemSet(BackendAppnameBuffer, 0, size);
2706 
2707  /* Initialize st_appname pointers. */
2708  buffer = BackendAppnameBuffer;
2709  for (i = 0; i < NumBackendStatSlots; i++)
2710  {
2711  BackendStatusArray[i].st_appname = buffer;
2712  buffer += NAMEDATALEN;
2713  }
2714  }
2715 
2716  /* Create or attach to the shared client hostname buffer */
2718  BackendClientHostnameBuffer = (char *)
2719  ShmemInitStruct("Backend Client Host Name Buffer", size, &found);
2720 
2721  if (!found)
2722  {
2724 
2725  /* Initialize st_clienthostname pointers. */
2726  buffer = BackendClientHostnameBuffer;
2727  for (i = 0; i < NumBackendStatSlots; i++)
2728  {
2730  buffer += NAMEDATALEN;
2731  }
2732  }
2733 
2734  /* Create or attach to the shared activity buffer */
2737  BackendActivityBuffer = (char *)
2738  ShmemInitStruct("Backend Activity Buffer",
2740  &found);
2741 
2742  if (!found)
2743  {
2745 
2746  /* Initialize st_activity pointers. */
2747  buffer = BackendActivityBuffer;
2748  for (i = 0; i < NumBackendStatSlots; i++)
2749  {
2752  }
2753  }
2754 
2755 #ifdef USE_SSL
2756  /* Create or attach to the shared SSL status buffer */
2758  BackendSslStatusBuffer = (PgBackendSSLStatus *)
2759  ShmemInitStruct("Backend SSL Status Buffer", size, &found);
2760 
2761  if (!found)
2762  {
2763  PgBackendSSLStatus *ptr;
2764 
2765  MemSet(BackendSslStatusBuffer, 0, size);
2766 
2767  /* Initialize st_sslstatus pointers. */
2768  ptr = BackendSslStatusBuffer;
2769  for (i = 0; i < NumBackendStatSlots; i++)
2770  {
2772  ptr++;
2773  }
2774  }
2775 #endif
2776 
2777 #ifdef ENABLE_GSS
2778  /* Create or attach to the shared GSSAPI status buffer */
2780  BackendGssStatusBuffer = (PgBackendGSSStatus *)
2781  ShmemInitStruct("Backend GSS Status Buffer", size, &found);
2782 
2783  if (!found)
2784  {
2785  PgBackendGSSStatus *ptr;
2786 
2787  MemSet(BackendGssStatusBuffer, 0, size);
2788 
2789  /* Initialize st_gssstatus pointers. */
2790  ptr = BackendGssStatusBuffer;
2791  for (i = 0; i < NumBackendStatSlots; i++)
2792  {
2794  ptr++;
2795  }
2796  }
2797 #endif
2798 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2632
static char * BackendActivityBuffer
Definition: pgstat.c:2636
static Size BackendActivityBufferSize
Definition: pgstat.c:2637
#define MemSet(start, val, len)
Definition: c.h:962
#define NumBackendStatSlots
Definition: pgstat.c:116
char * st_clienthostname
Definition: pgstat.h:1062
#define NAMEDATALEN
static char * BackendAppnameBuffer
Definition: pgstat.c:2634
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:372
char * st_activity_raw
Definition: pgstat.h:1085
int pgstat_track_activity_query_size
Definition: pgstat.c:126
char * st_appname
Definition: pgstat.h:1076
Size mul_size(Size s1, Size s2)
Definition: shmem.c:492
size_t Size
Definition: c.h:467
int i
PgBackendSSLStatus * st_sslstatus
Definition: pgstat.h:1066
PgBackendGSSStatus * st_gssstatus
Definition: pgstat.h:1070
static char * BackendClientHostnameBuffer
Definition: pgstat.c:2635

◆ find_funcstat_entry()

PgStat_BackendFunctionEntry* find_funcstat_entry ( Oid  func_id)

Definition at line 1672 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().

1673 {
1674  if (pgStatFunctions == NULL)
1675  return NULL;
1676 
1678  (void *) &func_id,
1679  HASH_FIND, NULL);
1680 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
static HTAB * pgStatFunctions
Definition: pgstat.c:195

◆ find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry ( Oid  rel_id)

Definition at line 1877 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().

1878 {
1879  TabStatHashEntry *hash_entry;
1880 
1881  /* If hashtable doesn't exist, there are no entries at all */
1882  if (!pgStatTabHash)
1883  return NULL;
1884 
1885  hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_FIND, NULL);
1886  if (!hash_entry)
1887  return NULL;
1888 
1889  /* Note that this step could also return NULL, but that's correct */
1890  return hash_entry->tsa_entry;
1891 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
static HTAB * pgStatTabHash
Definition: pgstat.c:189
PgStat_TableStatus * tsa_entry
Definition: pgstat.c:183

◆ pgstat_bestart()

void pgstat_bestart ( void  )

Definition at line 2855 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_gssapi_get_auth(), be_gssapi_get_enc(), be_gssapi_get_princ(), be_tls_get_cipher(), be_tls_get_cipher_bits(), be_tls_get_compression(), be_tls_get_peer_issuer_name(), be_tls_get_peer_serial(), be_tls_get_peer_subject_name(), be_tls_get_version(), BgWriterProcess, CheckpointerProcess, elog, FATAL, GetSessionUserId(), Port::gss, PgBackendGSSStatus::gss_auth, PgBackendGSSStatus::gss_enc, PgBackendGSSStatus::gss_princ, InvalidBackendId, InvalidOid, IsAutoVacuumLauncherProcess(), IsAutoVacuumWorkerProcess(), IsBackgroundWorker, MemSet, MyAuxProcType, MyBackendId, MyBEEntry, MyDatabaseId, MyProcPid, MyProcPort, MyStartTimestamp, NAMEDATALEN, NotAnAuxProcess, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_report_appname(), pgstat_track_activity_query_size, PROGRESS_COMMAND_INVALID, Port::raddr, Port::remote_hostname, PgBackendSSLStatus::ssl_bits, PgBackendSSLStatus::ssl_cipher, PgBackendSSLStatus::ssl_client_dn, PgBackendSSLStatus::ssl_client_serial, PgBackendSSLStatus::ssl_compression, PgBackendSSLStatus::ssl_issuer_dn, 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_gss, PgBackendStatus::st_gssstatus, 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(), unvolatize, WalReceiverProcess, and WalWriterProcess.

Referenced by AuxiliaryProcessMain(), and InitPostgres().

2856 {
2857  volatile PgBackendStatus *vbeentry = MyBEEntry;
2858  PgBackendStatus lbeentry;
2859 #ifdef USE_SSL
2860  PgBackendSSLStatus lsslstatus;
2861 #endif
2862 #ifdef ENABLE_GSS
2863  PgBackendGSSStatus lgssstatus;
2864 #endif
2865 
2866  /* pgstats state must be initialized from pgstat_initialize() */
2867  Assert(vbeentry != NULL);
2868 
2869  /*
2870  * To minimize the time spent modifying the PgBackendStatus entry, and
2871  * avoid risk of errors inside the critical section, we first copy the
2872  * shared-memory struct to a local variable, then modify the data in the
2873  * local variable, then copy the local variable back to shared memory.
2874  * Only the last step has to be inside the critical section.
2875  *
2876  * Most of the data we copy from shared memory is just going to be
2877  * overwritten, but the struct's not so large that it's worth the
2878  * maintenance hassle to copy only the needful fields.
2879  */
2880  memcpy(&lbeentry,
2881  unvolatize(PgBackendStatus *, vbeentry),
2882  sizeof(PgBackendStatus));
2883 
2884  /* These structs can just start from zeroes each time, though */
2885 #ifdef USE_SSL
2886  memset(&lsslstatus, 0, sizeof(lsslstatus));
2887 #endif
2888 #ifdef ENABLE_GSS
2889  memset(&lgssstatus, 0, sizeof(lgssstatus));
2890 #endif
2891 
2892  /*
2893  * Now fill in all the fields of lbeentry, except for strings that are
2894  * out-of-line data. Those have to be handled separately, below.
2895  */
2896  lbeentry.st_procpid = MyProcPid;
2897 
2899  {
2901  {
2902  /* Autovacuum Launcher */
2904  }
2905  else if (IsAutoVacuumWorkerProcess())
2906  {
2907  /* Autovacuum Worker */
2908  lbeentry.st_backendType = B_AUTOVAC_WORKER;
2909  }
2910  else if (am_walsender)
2911  {
2912  /* Wal sender */
2913  lbeentry.st_backendType = B_WAL_SENDER;
2914  }
2915  else if (IsBackgroundWorker)
2916  {
2917  /* bgworker */
2918  lbeentry.st_backendType = B_BG_WORKER;
2919  }
2920  else
2921  {
2922  /* client-backend */
2923  lbeentry.st_backendType = B_BACKEND;
2924  }
2925  }
2926  else
2927  {
2928  /* Must be an auxiliary process */
2930  switch (MyAuxProcType)
2931  {
2932  case StartupProcess:
2933  lbeentry.st_backendType = B_STARTUP;
2934  break;
2935  case BgWriterProcess:
2936  lbeentry.st_backendType = B_BG_WRITER;
2937  break;
2938  case CheckpointerProcess:
2939  lbeentry.st_backendType = B_CHECKPOINTER;
2940  break;
2941  case WalWriterProcess:
2942  lbeentry.st_backendType = B_WAL_WRITER;
2943  break;
2944  case WalReceiverProcess:
2945  lbeentry.st_backendType = B_WAL_RECEIVER;
2946  break;
2947  default:
2948  elog(FATAL, "unrecognized process type: %d",
2949  (int) MyAuxProcType);
2950  }
2951  }
2952 
2954  lbeentry.st_activity_start_timestamp = 0;
2955  lbeentry.st_state_start_timestamp = 0;
2956  lbeentry.st_xact_start_timestamp = 0;
2957  lbeentry.st_databaseid = MyDatabaseId;
2958 
2959  /* We have userid for client-backends, wal-sender and bgworker processes */
2960  if (lbeentry.st_backendType == B_BACKEND
2961  || lbeentry.st_backendType == B_WAL_SENDER
2962  || lbeentry.st_backendType == B_BG_WORKER)
2963  lbeentry.st_userid = GetSessionUserId();
2964  else
2965  lbeentry.st_userid = InvalidOid;
2966 
2967  /*
2968  * We may not have a MyProcPort (eg, if this is the autovacuum process).
2969  * If so, use all-zeroes client address, which is dealt with specially in
2970  * pg_stat_get_backend_client_addr and pg_stat_get_backend_client_port.
2971  */
2972  if (MyProcPort)
2973  memcpy(&lbeentry.st_clientaddr, &MyProcPort->raddr,
2974  sizeof(lbeentry.st_clientaddr));
2975  else
2976  MemSet(&lbeentry.st_clientaddr, 0, sizeof(lbeentry.st_clientaddr));
2977 
2978 #ifdef USE_SSL
2979  if (MyProcPort && MyProcPort->ssl != NULL)
2980  {
2981  lbeentry.st_ssl = true;
2989  }
2990  else
2991  {
2992  lbeentry.st_ssl = false;
2993  }
2994 #else
2995  lbeentry.st_ssl = false;
2996 #endif
2997 
2998 #ifdef ENABLE_GSS
2999  if (MyProcPort && MyProcPort->gss != NULL)
3000  {
3001  lbeentry.st_gss = true;
3002  lgssstatus.gss_auth = be_gssapi_get_auth(MyProcPort);
3003  lgssstatus.gss_enc = be_gssapi_get_enc(MyProcPort);
3004 
3005  if (lgssstatus.gss_auth)
3007  }
3008  else
3009  {
3010  lbeentry.st_gss = false;
3011  }
3012 #else
3013  lbeentry.st_gss = false;
3014 #endif
3015 
3016  lbeentry.st_state = STATE_UNDEFINED;
3019 
3020  /*
3021  * we don't zero st_progress_param here to save cycles; nobody should
3022  * examine it until st_progress_command has been set to something other
3023  * than PROGRESS_COMMAND_INVALID
3024  */
3025 
3026  /*
3027  * We're ready to enter the critical section that fills the shared-memory
3028  * status entry. We follow the protocol of bumping st_changecount before
3029  * and after; and make sure it's even afterwards. We use a volatile
3030  * pointer here to ensure the compiler doesn't try to get cute.
3031  */
3032  PGSTAT_BEGIN_WRITE_ACTIVITY(vbeentry);
3033 
3034  /* make sure we'll memcpy the same st_changecount back */
3035  lbeentry.st_changecount = vbeentry->st_changecount;
3036 
3037  memcpy(unvolatize(PgBackendStatus *, vbeentry),
3038  &lbeentry,
3039  sizeof(PgBackendStatus));
3040 
3041  /*
3042  * We can write the out-of-line strings and structs using the pointers
3043  * that are in lbeentry; this saves some de-volatilizing messiness.
3044  */
3045  lbeentry.st_appname[0] = '\0';
3048  NAMEDATALEN);
3049  else
3050  lbeentry.st_clienthostname[0] = '\0';
3051  lbeentry.st_activity_raw[0] = '\0';
3052  /* Also make sure the last byte in each string area is always 0 */
3053  lbeentry.st_appname[NAMEDATALEN - 1] = '\0';
3054  lbeentry.st_clienthostname[NAMEDATALEN - 1] = '\0';
3056 
3057 #ifdef USE_SSL
3058  memcpy(lbeentry.st_sslstatus, &lsslstatus, sizeof(PgBackendSSLStatus));
3059 #endif
3060 #ifdef ENABLE_GSS
3061  memcpy(lbeentry.st_gssstatus, &lgssstatus, sizeof(PgBackendGSSStatus));
3062 #endif
3063 
3064  PGSTAT_END_WRITE_ACTIVITY(vbeentry);
3065 
3066  /* Update app name to current GUC setting */
3067  if (application_name)
3069 }
char ssl_issuer_dn[NAMEDATALEN]
Definition: pgstat.h:993
char gss_princ[NAMEDATALEN]
Definition: pgstat.h:1007
bool ssl_compression
Definition: pgstat.h:982
char ssl_cipher[NAMEDATALEN]
Definition: pgstat.h:984
Oid st_progress_command_target
Definition: pgstat.h:1097
int MyProcPid
Definition: globals.c:40
BackendId MyBackendId
Definition: globals.c:81
struct Port * MyProcPort
Definition: globals.c:43
const char * be_gssapi_get_princ(Port *port)
TimestampTz st_activity_start_timestamp
Definition: pgstat.h:1055
char ssl_client_dn[NAMEDATALEN]
Definition: pgstat.h:985
char ssl_version[NAMEDATALEN]
Definition: pgstat.h:983
SockAddr st_clientaddr
Definition: pgstat.h:1061
#define MemSet(start, val, len)
Definition: c.h:962
ProgressCommandType st_progress_command
Definition: pgstat.h:1096
char ssl_client_serial[NAMEDATALEN]
Definition: pgstat.h:991
BackendState st_state
Definition: pgstat.h:1073
char * st_clienthostname
Definition: pgstat.h:1062
Oid GetSessionUserId(void)
Definition: miscinit.c:414
bool IsBackgroundWorker
Definition: globals.c:111
Oid st_databaseid
Definition: pgstat.h:1059
#define NAMEDATALEN
char * remote_hostname
Definition: libpq-be.h:128
SockAddr raddr
Definition: libpq-be.h:126
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:2633
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1137
char * st_activity_raw
Definition: pgstat.h:1085
int pgstat_track_activity_query_size
Definition: pgstat.c:126
TimestampTz st_state_start_timestamp
Definition: pgstat.h:1056
bool IsAutoVacuumWorkerProcess(void)
Definition: autovacuum.c:3281
char * st_appname
Definition: pgstat.h:1076
bool be_gssapi_get_enc(Port *port)
#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:72
Oid MyDatabaseId
Definition: globals.c:85
BackendType st_backendType
Definition: pgstat.h:1050
void pgstat_report_appname(const char *appname)
Definition: pgstat.c:3292
#define InvalidOid
Definition: postgres_ext.h:36
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
bool IsAutoVacuumLauncherProcess(void)
Definition: autovacuum.c:3275
#define Assert(condition)
Definition: c.h:739
const char * be_tls_get_version(Port *port)
void be_tls_get_peer_issuer_name(Port *port, char *ptr, size_t len)
char * application_name
Definition: guc.c:537
void be_tls_get_peer_subject_name(Port *port, char *ptr, size_t len)
void * gss
Definition: libpq-be.h:184
#define unvolatize(underlying_type, expr)
Definition: c.h:1196
void be_tls_get_peer_serial(Port *port, char *ptr, size_t len)
TimestampTz st_xact_start_timestamp
Definition: pgstat.h:1054
#define elog(elevel,...)
Definition: elog.h:228
int st_changecount
Definition: pgstat.h:1044
const char * be_tls_get_cipher(Port *port)
TimestampTz st_proc_start_timestamp
Definition: pgstat.h:1053
PgBackendSSLStatus * st_sslstatus
Definition: pgstat.h:1066
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1130
PgBackendGSSStatus * st_gssstatus
Definition: pgstat.h:1070
bool be_gssapi_get_auth(Port *port)

◆ pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void  )

Definition at line 5794 of file pgstat.c.

References localNumBackends, and MemoryContextDelete().

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

5795 {
5796  /* Release memory, if any was allocated */
5797  if (pgStatLocalContext)
5799 
5800  /* Reset variables */
5801  pgStatLocalContext = NULL;
5802  pgStatDBHash = NULL;
5803  localBackendStatusTable = NULL;
5804  localNumBackends = 0;
5805 }
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:211
static LocalPgBackendStatus * localBackendStatusTable
Definition: pgstat.c:245
static HTAB * pgStatDBHash
Definition: pgstat.c:242
static int localNumBackends
Definition: pgstat.c:248
static MemoryContext pgStatLocalContext
Definition: pgstat.c:241

◆ pgstat_clip_activity()

char* pgstat_clip_activity ( const char *  raw_activity)

Definition at line 6542 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().

6543 {
6544  char *activity;
6545  int rawlen;
6546  int cliplen;
6547 
6548  /*
6549  * Some callers, like pgstat_get_backend_current_activity(), do not
6550  * guarantee that the buffer isn't concurrently modified. We try to take
6551  * care that the buffer is always terminated by a NUL byte regardless, but
6552  * let's still be paranoid about the string's length. In those cases the
6553  * underlying buffer is guaranteed to be pgstat_track_activity_query_size
6554  * large.
6555  */
6556  activity = pnstrdup(raw_activity, pgstat_track_activity_query_size - 1);
6557 
6558  /* now double-guaranteed to be NUL terminated */
6559  rawlen = strlen(activity);
6560 
6561  /*
6562  * All supported server-encodings make it possible to determine the length
6563  * of a multi-byte character from its first byte (this is not the case for
6564  * client encodings, see GB18030). As st_activity is always stored using
6565  * server encoding, this allows us to perform multi-byte aware truncation,
6566  * even if the string earlier was truncated in the middle of a multi-byte
6567  * character.
6568  */
6569  cliplen = pg_mbcliplen(activity, rawlen,
6571 
6572  activity[cliplen] = '\0';
6573 
6574  return activity;
6575 }
char * pnstrdup(const char *in, Size len)
Definition: mcxt.c:1197
int pg_mbcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:862
int pgstat_track_activity_query_size
Definition: pgstat.c:126
static int cliplen(const char *str, int len, int limit)
Definition: mbutils.c:929

◆ pgstat_count_heap_delete()

void pgstat_count_heap_delete ( Relation  rel)

Definition at line 1992 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().

1993 {
1994  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1995 
1996  if (pgstat_info != NULL)
1997  {
1998  /* We have to log the effect at the proper transactional level */
1999  int nest_level = GetCurrentTransactionNestLevel();
2000 
2001  if (pgstat_info->trans == NULL ||
2002  pgstat_info->trans->nest_level != nest_level)
2003  add_tabstat_xact_level(pgstat_info, nest_level);
2004 
2005  pgstat_info->trans->tuples_deleted++;
2006  }
2007 }
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:841
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:204
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1919
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 1946 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().

1947 {
1948  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1949 
1950  if (pgstat_info != NULL)
1951  {
1952  /* We have to log the effect at the proper transactional level */
1953  int nest_level = GetCurrentTransactionNestLevel();
1954 
1955  if (pgstat_info->trans == NULL ||
1956  pgstat_info->trans->nest_level != nest_level)
1957  add_tabstat_xact_level(pgstat_info, nest_level);
1958 
1959  pgstat_info->trans->tuples_inserted += n;
1960  }
1961 }
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:841
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:204
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1919
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157

◆ pgstat_count_heap_update()

void pgstat_count_heap_update ( Relation  rel,
bool  hot 
)

Definition at line 1967 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().

1968 {
1969  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1970 
1971  if (pgstat_info != NULL)
1972  {
1973  /* We have to log the effect at the proper transactional level */
1974  int nest_level = GetCurrentTransactionNestLevel();
1975 
1976  if (pgstat_info->trans == NULL ||
1977  pgstat_info->trans->nest_level != nest_level)
1978  add_tabstat_xact_level(pgstat_info, nest_level);
1979 
1980  pgstat_info->trans->tuples_updated++;
1981 
1982  /* t_tuples_hot_updated is nontransactional, so just advance it */
1983  if (hot)
1984  pgstat_info->t_counts.t_tuples_hot_updated++;
1985  }
1986 }
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:841
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:204
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1919
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157

◆ pgstat_count_truncate()

void pgstat_count_truncate ( Relation  rel)

Definition at line 2047 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().

2048 {
2049  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
2050 
2051  if (pgstat_info != NULL)
2052  {
2053  /* We have to log the effect at the proper transactional level */
2054  int nest_level = GetCurrentTransactionNestLevel();
2055 
2056  if (pgstat_info->trans == NULL ||
2057  pgstat_info->trans->nest_level != nest_level)
2058  add_tabstat_xact_level(pgstat_info, nest_level);
2059 
2060  pgstat_truncate_save_counters(pgstat_info->trans);
2061  pgstat_info->trans->tuples_inserted = 0;
2062  pgstat_info->trans->tuples_updated = 0;
2063  pgstat_info->trans->tuples_deleted = 0;
2064  }
2065 }
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:841
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:204
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1919
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
static void pgstat_truncate_save_counters(PgStat_TableXactStatus *trans)
Definition: pgstat.c:2018

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid  databaseid)

Definition at line 1253 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().

1254 {
1255  PgStat_MsgDropdb msg;
1256 
1258  return;
1259 
1261  msg.m_databaseid = databaseid;
1262  pgstat_send(&msg, sizeof(msg));
1263 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
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:4326

◆ pgstat_end_function_usage()

void pgstat_end_function_usage ( PgStat_FunctionCallUsage fcu,
bool  finalize 
)

Definition at line 1692 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().

1693 {
1694  PgStat_FunctionCounts *fs = fcu->fs;
1695  instr_time f_total;
1696  instr_time f_others;
1697  instr_time f_self;
1698 
1699  /* stats not wanted? */
1700  if (fs == NULL)
1701  return;
1702 
1703  /* total elapsed time in this function call */
1704  INSTR_TIME_SET_CURRENT(f_total);
1705  INSTR_TIME_SUBTRACT(f_total, fcu->f_start);
1706 
1707  /* self usage: elapsed minus anything already charged to other calls */
1708  f_others = total_func_time;
1709  INSTR_TIME_SUBTRACT(f_others, fcu->save_total);
1710  f_self = f_total;
1711  INSTR_TIME_SUBTRACT(f_self, f_others);
1712 
1713  /* update backend-wide total time */
1715 
1716  /*
1717  * Compute the new f_total_time as the total elapsed time added to the
1718  * pre-call value of f_total_time. This is necessary to avoid
1719  * double-counting any time taken by recursive calls of myself. (We do
1720  * not need any similar kluge for self time, since that already excludes
1721  * any recursive calls.)
1722  */
1723  INSTR_TIME_ADD(f_total, fcu->save_f_total_time);
1724 
1725  /* update counters in function stats table */
1726  if (finalize)
1727  fs->f_numcalls++;
1728  fs->f_total_time = f_total;
1729  INSTR_TIME_ADD(fs->f_self_time, f_self);
1730 
1731  /* indicate that we have something to send */
1732  have_function_stats = true;
1733 }
instr_time f_self_time
Definition: pgstat.h:463
instr_time save_total
Definition: pgstat.h:1201
struct timeval instr_time
Definition: instr_time.h:150
instr_time f_total_time
Definition: pgstat.h:462
PgStat_FunctionCounts * fs
Definition: pgstat.h:1197
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:274
static bool have_function_stats
Definition: pgstat.c:201
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
instr_time save_f_total_time
Definition: pgstat.h:1199

◆ pgstat_fetch_global()

◆ pgstat_fetch_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver ( void  )

Definition at line 2602 of file pgstat.c.

References archiverStats, and backend_read_statsfile().

Referenced by pg_stat_get_archiver().

2603 {
2605 
2606  return &archiverStats;
2607 }
static void backend_read_statsfile(void)
Definition: pgstat.c:5640
static PgStat_ArchiverStats archiverStats
Definition: pgstat.c:255

◆ pgstat_fetch_stat_beentry()

◆ pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry* pgstat_fetch_stat_dbentry ( Oid  dbid)

Definition at line 2430 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_checksum_failures(), pg_stat_get_db_checksum_last_failure(), 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().

2431 {
2432  /*
2433  * If not done for this transaction, read the statistics collector stats
2434  * file into some hash tables.
2435  */
2437 
2438  /*
2439  * Lookup the requested database; return NULL if not found
2440  */
2442  (void *) &dbid,
2443  HASH_FIND, NULL);
2444 }
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:5640
static HTAB * pgStatDBHash
Definition: pgstat.c:242

◆ pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry ( Oid  funcid)

Definition at line 2513 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().

2514 {
2515  PgStat_StatDBEntry *dbentry;
2516  PgStat_StatFuncEntry *funcentry = NULL;
2517 
2518  /* load the stats file if needed */
2520 
2521  /* Lookup our database, then find the requested function. */
2523  if (dbentry != NULL && dbentry->functions != NULL)
2524  {
2525  funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,
2526  (void *) &func_id,
2527  HASH_FIND, NULL);
2528  }
2529 
2530  return funcentry;
2531 }
HTAB * functions
Definition: pgstat.h:624
PgStat_StatDBEntry * pgstat_fetch_stat_dbentry(Oid dbid)
Definition: pgstat.c:2430
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:5640
Oid MyDatabaseId
Definition: globals.c:85

◆ pgstat_fetch_stat_local_beentry()

LocalPgBackendStatus* pgstat_fetch_stat_local_beentry ( int  beid)

Definition at line 2567 of file pgstat.c.

References localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_activity(), and pg_stat_get_progress_info().

2568 {
2570 
2571  if (beid < 1 || beid > localNumBackends)
2572  return NULL;
2573 
2574  return &localBackendStatusTable[beid - 1];
2575 }
static void pgstat_read_current_status(void)
Definition: pgstat.c:3348
static LocalPgBackendStatus * localBackendStatusTable
Definition: pgstat.c:245
static int localNumBackends
Definition: pgstat.c:248

◆ pgstat_fetch_stat_numbackends()

int pgstat_fetch_stat_numbackends ( void  )

Definition at line 2586 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().

2587 {
2589 
2590  return localNumBackends;
2591 }
static void pgstat_read_current_status(void)
Definition: pgstat.c:3348
static int localNumBackends
Definition: pgstat.c:248

◆ pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry ( Oid  relid)

Definition at line 2457 of file pgstat.c.

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

Referenced by index_concurrently_swap(), 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().

2458 {
2459  Oid dbid;
2460  PgStat_StatDBEntry *dbentry;
2461  PgStat_StatTabEntry *tabentry;
2462 
2463  /*
2464  * If not done for this transaction, read the statistics collector stats
2465  * file into some hash tables.
2466  */
2468 
2469  /*
2470  * Lookup our database, then look in its table hash table.
2471  */
2472  dbid = MyDatabaseId;
2474  (void *) &dbid,
2475  HASH_FIND, NULL);
2476  if (dbentry != NULL && dbentry->tables != NULL)
2477  {
2478  tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
2479  (void *) &relid,
2480  HASH_FIND, NULL);
2481  if (tabentry)
2482  return tabentry;
2483  }
2484 
2485  /*
2486  * If we didn't find it, maybe it's a shared table.
2487  */
2488  dbid = InvalidOid;
2490  (void *) &dbid,
2491  HASH_FIND, NULL);
2492  if (dbentry != NULL && dbentry->tables != NULL)
2493  {
2494  tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
2495  (void *) &relid,
2496  HASH_FIND, NULL);
2497  if (tabentry)
2498  return tabentry;
2499  }
2500 
2501  return NULL;
2502 }
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:5640
Oid MyDatabaseId
Definition: globals.c:85
#define InvalidOid
Definition: postgres_ext.h:36
static HTAB * pgStatDBHash
Definition: pgstat.c:242

◆ pgstat_get_backend_current_activity()

const char* pgstat_get_backend_current_activity ( int  pid,
bool  checkUser 
)

Definition at line 4135 of file pgstat.c.

References BackendStatusArray, CHECK_FOR_INTERRUPTS, GetUserId(), i, MaxBackends, pgstat_begin_read_activity, pgstat_clip_activity(), pgstat_end_read_activity, pgstat_read_activity_complete, PgBackendStatus::st_activity_raw, PgBackendStatus::st_procpid, PgBackendStatus::st_userid, and superuser().

Referenced by DeadLockReport().

4136 {
4137  PgBackendStatus *beentry;
4138  int i;
4139 
4140  beentry = BackendStatusArray;
4141  for (i = 1; i <= MaxBackends; i++)
4142  {
4143  /*
4144  * Although we expect the target backend's entry to be stable, that
4145  * doesn't imply that anyone else's is. To avoid identifying the
4146  * wrong backend, while we check for a match to the desired PID we
4147  * must follow the protocol of retrying if st_changecount changes
4148  * while we examine the entry, or if it's odd. (This might be
4149  * unnecessary, since fetching or storing an int is almost certainly
4150  * atomic, but let's play it safe.) We use a volatile pointer here to
4151  * ensure the compiler doesn't try to get cute.
4152  */
4153  volatile PgBackendStatus *vbeentry = beentry;
4154  bool found;
4155 
4156  for (;;)
4157  {
4158  int before_changecount;
4159  int after_changecount;
4160 
4161  pgstat_begin_read_activity(vbeentry, before_changecount);
4162 
4163  found = (vbeentry->st_procpid == pid);
4164 
4165  pgstat_end_read_activity(vbeentry, after_changecount);
4166 
4167  if (pgstat_read_activity_complete(before_changecount,
4168  after_changecount))
4169  break;
4170 
4171  /* Make sure we can break out of loop if stuck... */
4173  }
4174 
4175  if (found)
4176  {
4177  /* Now it is safe to use the non-volatile pointer */
4178  if (checkUser && !superuser() && beentry->st_userid != GetUserId())
4179  return "<insufficient privilege>";
4180  else if (*(beentry->st_activity_raw) == '\0')
4181  return "<command string not enabled>";
4182  else
4183  {
4184  /* this'll leak a bit of memory, but that seems acceptable */
4185  return pgstat_clip_activity(beentry->st_activity_raw);
4186  }
4187  }
4188 
4189  beentry++;
4190  }
4191 
4192  /* If we get here, caller is in error ... */
4193  return "<backend information not available>";
4194 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2632
Oid GetUserId(void)
Definition: miscinit.c:380
bool superuser(void)
Definition: superuser.c:46
int MaxBackends
Definition: globals.c:135
char * st_activity_raw
Definition: pgstat.h:1085
#define pgstat_end_read_activity(beentry, after_changecount)
Definition: pgstat.h:1151
#define pgstat_begin_read_activity(beentry, before_changecount)
Definition: pgstat.h:1145
char * pgstat_clip_activity(const char *raw_activity)
Definition: pgstat.c:6542
int i
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
#define pgstat_read_activity_complete(before_changecount, after_changecount)
Definition: pgstat.h:1157

◆ pgstat_get_backend_desc()

const char* pgstat_get_backend_desc ( BackendType  backendType)

Definition at line 4272 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().

4273 {
4274  const char *backendDesc = "unknown process type";
4275 
4276  switch (backendType)
4277  {
4278  case B_AUTOVAC_LAUNCHER:
4279  backendDesc = "autovacuum launcher";
4280  break;
4281  case B_AUTOVAC_WORKER:
4282  backendDesc = "autovacuum worker";
4283  break;
4284  case B_BACKEND:
4285  backendDesc = "client backend";
4286  break;
4287  case B_BG_WORKER:
4288  backendDesc = "background worker";
4289  break;
4290  case B_BG_WRITER:
4291  backendDesc = "background writer";
4292  break;
4293  case B_CHECKPOINTER:
4294  backendDesc = "checkpointer";
4295  break;
4296  case B_STARTUP:
4297  backendDesc = "startup";
4298  break;
4299  case B_WAL_RECEIVER:
4300  backendDesc = "walreceiver";
4301  break;
4302  case B_WAL_SENDER:
4303  backendDesc = "walsender";
4304  break;
4305  case B_WAL_WRITER:
4306  backendDesc = "walwriter";
4307  break;
4308  }
4309 
4310  return backendDesc;
4311 }

◆ pgstat_get_crashed_backend_activity()

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

Definition at line 4213 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().

4214 {
4215  volatile PgBackendStatus *beentry;
4216  int i;
4217 
4218  beentry = BackendStatusArray;
4219 
4220  /*
4221  * We probably shouldn't get here before shared memory has been set up,
4222  * but be safe.
4223  */
4224  if (beentry == NULL || BackendActivityBuffer == NULL)
4225  return NULL;
4226 
4227  for (i = 1; i <= MaxBackends; i++)
4228  {
4229  if (beentry->st_procpid == pid)
4230  {
4231  /* Read pointer just once, so it can't change after validation */
4232  const char *activity = beentry->st_activity_raw;
4233  const char *activity_last;
4234 
4235  /*
4236  * We mustn't access activity string before we verify that it
4237  * falls within the BackendActivityBuffer. To make sure that the
4238  * entire string including its ending is contained within the
4239  * buffer, subtract one activity length from the buffer size.
4240  */
4243 
4244  if (activity < BackendActivityBuffer ||
4245  activity > activity_last)
4246  return NULL;
4247 
4248  /* If no string available, no point in a report */
4249  if (activity[0] == '\0')
4250  return NULL;
4251 
4252  /*
4253  * Copy only ASCII-safe characters so we don't run into encoding
4254  * problems when reporting the message; and be sure not to run off
4255  * the end of memory. As only ASCII characters are reported, it
4256  * doesn't seem necessary to perform multibyte aware clipping.
4257  */
4258  ascii_safe_strlcpy(buffer, activity,
4259  Min(buflen, pgstat_track_activity_query_size));
4260 
4261  return buffer;
4262  }
4263 
4264  beentry++;
4265  }
4266 
4267  /* PID not found */
4268  return NULL;
4269 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2632
static char * BackendActivityBuffer
Definition: pgstat.c:2636
#define Min(x, y)
Definition: c.h:911
static Size BackendActivityBufferSize
Definition: pgstat.c:2637
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:1085
int pgstat_track_activity_query_size
Definition: pgstat.c:126
int i

◆ pgstat_get_wait_event()

const char* pgstat_get_wait_event ( uint32  wait_event_info)

Definition at line 3555 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().

3556 {
3557  uint32 classId;
3558  uint16 eventId;
3559  const char *event_name;
3560 
3561  /* report process as not waiting. */
3562  if (wait_event_info == 0)
3563  return NULL;
3564 
3565  classId = wait_event_info & 0xFF000000;
3566  eventId = wait_event_info & 0x0000FFFF;
3567 
3568  switch (classId)
3569  {
3570  case PG_WAIT_LWLOCK:
3571  event_name = GetLWLockIdentifier(classId, eventId);
3572  break;
3573  case PG_WAIT_LOCK:
3574  event_name = GetLockNameFromTagType(eventId);
3575  break;
3576  case PG_WAIT_BUFFER_PIN:
3577  event_name = "BufferPin";
3578  break;
3579  case PG_WAIT_ACTIVITY:
3580  {
3581  WaitEventActivity w = (WaitEventActivity) wait_event_info;
3582 
3583  event_name = pgstat_get_wait_activity(w);
3584  break;
3585  }
3586  case PG_WAIT_CLIENT:
3587  {
3588  WaitEventClient w = (WaitEventClient) wait_event_info;
3589 
3590  event_name = pgstat_get_wait_client(w);
3591  break;
3592  }
3593  case PG_WAIT_EXTENSION:
3594  event_name = "Extension";
3595  break;
3596  case PG_WAIT_IPC:
3597  {
3598  WaitEventIPC w = (WaitEventIPC) wait_event_info;
3599 
3600  event_name = pgstat_get_wait_ipc(w);
3601  break;
3602  }
3603  case PG_WAIT_TIMEOUT:
3604  {
3605  WaitEventTimeout w = (WaitEventTimeout) wait_event_info;
3606 
3607  event_name = pgstat_get_wait_timeout(w);
3608  break;
3609  }
3610  case PG_WAIT_IO:
3611  {
3612  WaitEventIO w = (WaitEventIO) wait_event_info;
3613 
3614  event_name = pgstat_get_wait_io(w);
3615  break;
3616  }
3617  default:
3618  event_name = "unknown wait event";
3619  break;
3620  }
3621 
3622  return event_name;
3623 }
#define PG_WAIT_LOCK
Definition: pgstat.h:755
WaitEventIPC
Definition: pgstat.h:818
static const char * pgstat_get_wait_timeout(WaitEventTimeout w)
Definition: pgstat.c:3869
static const char * pgstat_get_wait_ipc(WaitEventIPC w)
Definition: pgstat.c:3739
#define PG_WAIT_ACTIVITY
Definition: pgstat.h:757
#define PG_WAIT_IO
Definition: pgstat.h:762
static const char * pgstat_get_wait_activity(WaitEventActivity w)
Definition: pgstat.c:3632
unsigned short uint16
Definition: c.h:358
#define PG_WAIT_CLIENT
Definition: pgstat.h:758
WaitEventClient
Definition: pgstat.h:798
static const char * pgstat_get_wait_client(WaitEventClient w)
Definition: pgstat.c:3693
unsigned int uint32
Definition: c.h:359
WaitEventTimeout
Definition: pgstat.h:865
#define PG_WAIT_EXTENSION
Definition: pgstat.h:759
#define PG_WAIT_BUFFER_PIN
Definition: pgstat.h:756
const char * GetLockNameFromTagType(uint16 locktag_type)
Definition: lmgr.c:1170
WaitEventIO
Definition: pgstat.h:878
#define PG_WAIT_TIMEOUT
Definition: pgstat.h:761
#define PG_WAIT_IPC
Definition: pgstat.h:760
const char * GetLWLockIdentifier(uint32 classId, uint16 eventId)
Definition: lwlock.c:714
static const char * pgstat_get_wait_io(WaitEventIO w)
Definition: pgstat.c:3897
#define PG_WAIT_LWLOCK
Definition: pgstat.h:754
WaitEventActivity
Definition: pgstat.h:772

◆ pgstat_get_wait_event_type()

const char* pgstat_get_wait_event_type ( uint32  wait_event_info)

Definition at line 3500 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().

3501 {
3502  uint32 classId;
3503  const char *event_type;
3504 
3505  /* report process as not waiting. */
3506  if (wait_event_info == 0)
3507  return NULL;
3508 
3509  classId = wait_event_info & 0xFF000000;
3510 
3511  switch (classId)
3512  {
3513  case PG_WAIT_LWLOCK:
3514  event_type = "LWLock";
3515  break;
3516  case PG_WAIT_LOCK:
3517  event_type = "Lock";
3518  break;
3519  case PG_WAIT_BUFFER_PIN:
3520  event_type = "BufferPin";
3521  break;
3522  case PG_WAIT_ACTIVITY:
3523  event_type = "Activity";
3524  break;
3525  case PG_WAIT_CLIENT:
3526  event_type = "Client";
3527  break;
3528  case PG_WAIT_EXTENSION:
3529  event_type = "Extension";
3530  break;
3531  case PG_WAIT_IPC:
3532  event_type = "IPC";
3533  break;
3534  case PG_WAIT_TIMEOUT:
3535  event_type = "Timeout";
3536  break;
3537  case PG_WAIT_IO:
3538  event_type = "IO";
3539  break;
3540  default:
3541  event_type = "???";
3542  break;
3543  }
3544 
3545  return event_type;
3546 }
#define PG_WAIT_LOCK
Definition: pgstat.h:755
#define PG_WAIT_ACTIVITY
Definition: pgstat.h:757
#define PG_WAIT_IO
Definition: pgstat.h:762
#define PG_WAIT_CLIENT
Definition: pgstat.h:758
unsigned int uint32
Definition: c.h:359
#define PG_WAIT_EXTENSION
Definition: pgstat.h:759
#define PG_WAIT_BUFFER_PIN
Definition: pgstat.h:756
#define PG_WAIT_TIMEOUT
Definition: pgstat.h:761
#define PG_WAIT_IPC
Definition: pgstat.h:760
#define PG_WAIT_LWLOCK
Definition: pgstat.h:754

◆ pgstat_init()

void pgstat_init ( void  )

Definition at line 354 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().

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

◆ pgstat_init_function_usage()

void pgstat_init_function_usage ( struct FunctionCallInfoBaseData fcinfo,
PgStat_FunctionCallUsage fcu 
)

◆ pgstat_initialize()

void pgstat_initialize ( void  )

Definition at line 2813 of file pgstat.c.

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

Referenced by AuxiliaryProcessMain(), and InitPostgres().

2814 {
2815  /* Initialize MyBEEntry */
2817  {
2820  }
2821  else
2822  {
2823  /* Must be an auxiliary process */
2825 
2826  /*
2827  * Assign the MyBEEntry for an auxiliary process. Since it doesn't
2828  * have a BackendId, the slot is statically allocated based on the
2829  * auxiliary process type (MyAuxProcType). Backends use slots indexed
2830  * in the range from 1 to MaxBackends (inclusive), so we use
2831  * MaxBackends + AuxBackendType + 1 as the index of the slot for an
2832  * auxiliary process.
2833  */
2835  }
2836 
2837  /* Set up a process-exit hook to clean up */
2839 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2632
BackendId MyBackendId
Definition: globals.c:81
int MaxBackends
Definition: globals.c:135
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2633
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:3081
#define InvalidBackendId
Definition: backendid.h:23
AuxProcType MyAuxProcType
Definition: bootstrap.c:72
#define Assert(condition)
Definition: c.h:739

◆ pgstat_initstats()

void pgstat_initstats ( Relation  rel)

Definition at line 1749 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().

1750 {
1751  Oid rel_id = rel->rd_id;
1752  char relkind = rel->rd_rel->relkind;
1753 
1754  /* We only count stats for things that have storage */
1755  if (!(relkind == RELKIND_RELATION ||
1756  relkind == RELKIND_MATVIEW ||
1757  relkind == RELKIND_INDEX ||
1758  relkind == RELKIND_TOASTVALUE ||
1759  relkind == RELKIND_SEQUENCE))
1760  {
1761  rel->pgstat_info = NULL;
1762  return;
1763  }
1764 
1766  {
1767  /* We're not counting at all */
1768  rel->pgstat_info = NULL;
1769  return;
1770  }
1771 
1772  /*
1773  * If we already set up this relation in the current transaction, nothing
1774  * to do.
1775  */
1776  if (rel->pgstat_info != NULL &&
1777  rel->pgstat_info->t_id == rel_id)
1778  return;
1779 
1780  /* Else find or make the PgStat_TableStatus entry, and update link */
1781  rel->pgstat_info = get_tabstat_entry(rel_id, rel->rd_rel->relisshared);
1782 }
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
Form_pg_class rd_rel
Definition: rel.h:83
unsigned int Oid
Definition: postgres_ext.h:31
char relkind
Definition: pg_class.h:81
bool pgstat_track_counts
Definition: pgstat.c:124
Oid rd_id
Definition: rel.h:85
static PgStat_TableStatus * get_tabstat_entry(Oid rel_id, bool isshared)
Definition: pgstat.c:1788
#define PGINVALID_SOCKET
Definition: port.h:33
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:204

◆ pgstat_ping()

void pgstat_ping ( void  )

Definition at line 1585 of file pgstat.c.

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

1586 {
1587  PgStat_MsgDummy msg;
1588 
1590  return;
1591 
1593  pgstat_send(&msg, sizeof(msg));
1594 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
#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:4326

◆ pgstat_progress_end_command()

void pgstat_progress_end_command ( void  )

Definition at line 3269 of file pgstat.c.

References InvalidOid, MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activities, PROGRESS_COMMAND_INVALID, PgBackendStatus::st_progress_command, and PgBackendStatus::st_progress_command_target.

Referenced by AbortSubTransaction(), AbortTransaction(), cluster_rel(), DefineIndex(), heap_vacuum_rel(), reindex_index(), and ReindexRelationConcurrently().

3270 {
3271  volatile PgBackendStatus *beentry = MyBEEntry;
3272 
3273  if (!beentry || !pgstat_track_activities)
3274  return;
3275 
3277  return;
3278 
3279  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3282  PGSTAT_END_WRITE_ACTIVITY(beentry);
3283 }
Oid st_progress_command_target
Definition: pgstat.h:1097
ProgressCommandType st_progress_command
Definition: pgstat.h:1096
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2633
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1137
#define InvalidOid
Definition: postgres_ext.h:36
bool pgstat_track_activities
Definition: pgstat.c:123
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1130

◆ pgstat_progress_start_command()

void pgstat_progress_start_command ( ProgressCommandType  cmdtype,
Oid  relid 
)

Definition at line 3197 of file pgstat.c.

References MemSet, MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activities, PgBackendStatus::st_progress_command, PgBackendStatus::st_progress_command_target, and PgBackendStatus::st_progress_param.

Referenced by cluster_rel(), DefineIndex(), heap_vacuum_rel(), reindex_index(), and ReindexRelationConcurrently().

3198 {
3199  volatile PgBackendStatus *beentry = MyBEEntry;
3200 
3201  if (!beentry || !pgstat_track_activities)
3202  return;
3203 
3204  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3205  beentry->st_progress_command = cmdtype;
3206  beentry->st_progress_command_target = relid;
3207  MemSet(&beentry->st_progress_param, 0, sizeof(beentry->st_progress_param));
3208  PGSTAT_END_WRITE_ACTIVITY(beentry);
3209 }
Oid st_progress_command_target
Definition: pgstat.h:1097
#define MemSet(start, val, len)
Definition: c.h:962
ProgressCommandType st_progress_command
Definition: pgstat.h:1096
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2633
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1137
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition: pgstat.h:1098
bool pgstat_track_activities
Definition: pgstat.c:123
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1130

◆ pgstat_progress_update_multi_param()

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

Definition at line 3240 of file pgstat.c.

References Assert, i, MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, PGSTAT_NUM_PROGRESS_PARAM, pgstat_track_activities, and PgBackendStatus::st_progress_param.

Referenced by _bt_spools_heapscan(), heapam_relation_copy_for_cluster(), index_build(), lazy_scan_heap(), validate_index(), and WaitForLockersMultiple().

3242 {
3243  volatile PgBackendStatus *beentry = MyBEEntry;
3244  int i;
3245 
3246  if (!beentry || !pgstat_track_activities || nparam == 0)
3247  return;
3248 
3249  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3250 
3251  for (i = 0; i < nparam; ++i)
3252  {
3253  Assert(index[i] >= 0 && index[i] < PGSTAT_NUM_PROGRESS_PARAM);
3254 
3255  beentry->st_progress_param[index[i]] = val[i];
3256  }
3257 
3258  PGSTAT_END_WRITE_ACTIVITY(beentry);
3259 }
Definition: type.h:89
#define PGSTAT_NUM_PROGRESS_PARAM
Definition: pgstat.h:962
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2633
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1137
#define Assert(condition)
Definition: c.h:739
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition: pgstat.h:1098
bool pgstat_track_activities
Definition: pgstat.c:123
int i
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1130
long val
Definition: informix.c:664

◆ pgstat_progress_update_param()

void pgstat_progress_update_param ( int  index,
int64  val 
)

Definition at line 3218 of file pgstat.c.

References Assert, MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, PGSTAT_NUM_PROGRESS_PARAM, pgstat_track_activities, PgBackendStatus::st_progress_param, and val.

Referenced by _bt_leafbuild(), _bt_load(), _bt_spools_heapscan(), _h_indexbuild(), btvacuumscan(), cluster_rel(), DefineIndex(), finish_heap_swap(), hashbuild(), heap_vacuum_rel(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), lazy_record_dead_tuple(), lazy_scan_heap(), lazy_truncate_heap(), lazy_vacuum_page(), reindex_index(), reindex_relation(), ReindexRelationConcurrently(), validate_index(), WaitForLockersMultiple(), and WaitForOlderSnapshots().

3219 {
3220  volatile PgBackendStatus *beentry = MyBEEntry;
3221 
3223 
3224  if (!beentry || !pgstat_track_activities)
3225  return;
3226 
3227  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3228  beentry->st_progress_param[index] = val;
3229  PGSTAT_END_WRITE_ACTIVITY(beentry);
3230 }
Definition: type.h:89
#define PGSTAT_NUM_PROGRESS_PARAM
Definition: pgstat.h:962
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2633
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1137
#define Assert(condition)
Definition: c.h:739
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition: pgstat.h:1098
bool pgstat_track_activities
Definition: pgstat.c:123
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1130
long val
Definition: informix.c:664

◆ pgstat_report_activity()

void pgstat_report_activity ( BackendState  state,
const char *  cmd_str 
)

Definition at line 3119 of file pgstat.c.

References GetCurrentStatementStartTimestamp(), GetCurrentTimestamp(), Min, MyBEEntry, MyProc, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, 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().

3120 {
3121  volatile PgBackendStatus *beentry = MyBEEntry;
3122  TimestampTz start_timestamp;
3123  TimestampTz current_timestamp;
3124  int len = 0;
3125 
3126  TRACE_POSTGRESQL_STATEMENT_STATUS(cmd_str);
3127 
3128  if (!beentry)
3129  return;
3130 
3132  {
3133  if (beentry->st_state != STATE_DISABLED)
3134  {
3135  volatile PGPROC *proc = MyProc;
3136 
3137  /*
3138  * track_activities is disabled, but we last reported a
3139  * non-disabled state. As our final update, change the state and
3140  * clear fields we will not be updating anymore.
3141  */
3142  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3143  beentry->st_state = STATE_DISABLED;
3144  beentry->st_state_start_timestamp = 0;
3145  beentry->st_activity_raw[0] = '\0';
3146  beentry->st_activity_start_timestamp = 0;
3147  /* st_xact_start_timestamp and wait_event_info are also disabled */
3148  beentry->st_xact_start_timestamp = 0;
3149  proc->wait_event_info = 0;
3150  PGSTAT_END_WRITE_ACTIVITY(beentry);
3151  }
3152  return;
3153  }
3154 
3155  /*
3156  * To minimize the time spent modifying the entry, and avoid risk of
3157  * errors inside the critical section, fetch all the needed data first.
3158  */
3159  start_timestamp = GetCurrentStatementStartTimestamp();
3160  if (cmd_str != NULL)
3161  {
3162  /*
3163  * Compute length of to-be-stored string unaware of multi-byte
3164  * characters. For speed reasons that'll get corrected on read, rather
3165  * than computed every write.
3166  */
3167  len = Min(strlen(cmd_str), pgstat_track_activity_query_size - 1);
3168  }
3169  current_timestamp = GetCurrentTimestamp();
3170 
3171  /*
3172  * Now update the status entry
3173  */
3174  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3175 
3176  beentry->st_state = state;
3177  beentry->st_state_start_timestamp = current_timestamp;
3178 
3179  if (cmd_str != NULL)
3180  {
3181  memcpy((char *) beentry->st_activity_raw, cmd_str, len);
3182  beentry->st_activity_raw[len] = '\0';
3183  beentry->st_activity_start_timestamp = start_timestamp;
3184  }
3185 
3186  PGSTAT_END_WRITE_ACTIVITY(beentry);
3187 }
uint32 wait_event_info
Definition: proc.h:176
TimestampTz st_activity_start_timestamp
Definition: pgstat.h:1055
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1583
PGPROC * MyProc
Definition: proc.c:67
int64 TimestampTz
Definition: timestamp.h:39
#define Min(x, y)
Definition: c.h:911
BackendState st_state
Definition: pgstat.h:1073
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2633
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1137
char * st_activity_raw
Definition: pgstat.h:1085
int pgstat_track_activity_query_size
Definition: pgstat.c:126
TimestampTz st_state_start_timestamp
Definition: pgstat.h:1056
Definition: regguts.h:298
TimestampTz st_xact_start_timestamp
Definition: pgstat.h:1054
bool pgstat_track_activities
Definition: pgstat.c:123
Definition: proc.h:95
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1130
TimestampTz GetCurrentStatementStartTimestamp(void)
Definition: xact.c:791

◆ pgstat_report_analyze()

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

Definition at line 1436 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().

1439 {
1440  PgStat_MsgAnalyze msg;
1441 
1443  return;
1444 
1445  /*
1446  * Unlike VACUUM, ANALYZE might be running inside a transaction that has
1447  * already inserted and/or deleted rows in the target table. ANALYZE will
1448  * have counted such rows as live or dead respectively. Because we will
1449  * report our counts of such rows at transaction end, we should subtract
1450  * off these counts from what we send to the collector now, else they'll
1451  * be double-counted after commit. (This approach also ensures that the
1452  * collector ends up with the right numbers if we abort instead of
1453  * committing.)
1454  */
1455  if (rel->pgstat_info != NULL)
1456  {
1458 
1459  for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
1460  {
1461  livetuples -= trans->tuples_inserted - trans->tuples_deleted;
1462  deadtuples -= trans->tuples_updated + trans->tuples_deleted;
1463  }
1464  /* count stuff inserted by already-aborted subxacts, too */
1465  deadtuples -= rel->pgstat_info->t_counts.t_delta_dead_tuples;
1466  /* Since ANALYZE's counts are estimates, we could have underflowed */
1467  livetuples = Max(livetuples, 0);
1468  deadtuples = Max(deadtuples, 0);
1469  }
1470 
1472  msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
1473  msg.m_tableoid = RelationGetRelid(rel);
1475  msg.m_resetcounter = resetcounter;
1477  msg.m_live_tuples = livetuples;
1478  msg.m_dead_tuples = deadtuples;
1479  pgstat_send(&msg, sizeof(msg));
1480 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
PgStat_Counter tuples_updated
Definition: pgstat.h:168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1583
TimestampTz m_analyzetime
Definition: pgstat.h:387
PgStat_TableCounts t_counts
Definition: pgstat.h:158
Form_pg_class rd_rel
Definition: rel.h:83
bool m_resetcounter
Definition: pgstat.h:386
bool pgstat_track_counts
Definition: pgstat.c:124
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
PgStat_Counter t_delta_dead_tuples
Definition: pgstat.h:111
bool IsAutoVacuumWorkerProcess(void)
Definition: autovacuum.c:3281
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:905
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4326
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:204
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:396
PgStat_Counter m_dead_tuples
Definition: pgstat.h:389
#define RelationGetRelid(relation)
Definition: rel.h:422

◆ pgstat_report_appname()

void pgstat_report_appname ( const char *  appname)

Definition at line 3292 of file pgstat.c.

References MyBEEntry, NAMEDATALEN, pg_mbcliplen(), PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, and PgBackendStatus::st_appname.

Referenced by assign_application_name(), and pgstat_bestart().

3293 {
3294  volatile PgBackendStatus *beentry = MyBEEntry;
3295  int len;
3296 
3297  if (!beentry)
3298  return;
3299 
3300  /* This should be unnecessary if GUC did its job, but be safe */
3301  len = pg_mbcliplen(appname, strlen(appname), NAMEDATALEN - 1);
3302 
3303  /*
3304  * Update my status entry, following the protocol of bumping
3305  * st_changecount before and after. We use a volatile pointer here to
3306  * ensure the compiler doesn't try to get cute.
3307  */
3308  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3309 
3310  memcpy((char *) beentry->st_appname, appname, len);
3311  beentry->st_appname[len] = '\0';
3312 
3313  PGSTAT_END_WRITE_ACTIVITY(beentry);
3314 }
#define NAMEDATALEN
int pg_mbcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:862
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2633
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1137
char * st_appname
Definition: pgstat.h:1076
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1130

◆ pgstat_report_autovac()

void pgstat_report_autovac ( Oid  dboid)

Definition at line 1386 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().

1387 {
1389 
1391  return;
1392 
1394  msg.m_databaseid = dboid;
1396 
1397  pgstat_send(&msg, sizeof(msg));
1398 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1583
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:4326
TimestampTz m_start_time
Definition: pgstat.h:354

◆ pgstat_report_checksum_failure()

void pgstat_report_checksum_failure ( void  )

Definition at line 1552 of file pgstat.c.

References MyDatabaseId, and pgstat_report_checksum_failures_in_db().

Referenced by PageIsVerified().

1553 {
1555 }
void pgstat_report_checksum_failures_in_db(Oid dboid, int failurecount)
Definition: pgstat.c:1530
Oid MyDatabaseId
Definition: globals.c:85

◆ pgstat_report_checksum_failures_in_db()

void pgstat_report_checksum_failures_in_db ( Oid  dboid,
int  failurecount 
)

Definition at line 1530 of file pgstat.c.

References GetCurrentTimestamp(), PgStat_MsgChecksumFailure::m_databaseid, PgStat_MsgChecksumFailure::m_failure_time, PgStat_MsgChecksumFailure::m_failurecount, PgStat_MsgChecksumFailure::m_hdr, PGINVALID_SOCKET, PGSTAT_MTYPE_CHECKSUMFAILURE, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by pgstat_report_checksum_failure(), and sendFile().

1531 {
1533 
1535  return;
1536 
1538  msg.m_databaseid = dboid;
1539  msg.m_failurecount = failurecount;
1541 
1542  pgstat_send(&msg, sizeof(msg));
1543 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1583
PgStat_MsgHdr m_hdr
Definition: pgstat.h:540
bool pgstat_track_counts
Definition: pgstat.c:124
TimestampTz m_failure_time
Definition: pgstat.h:543
#define PGINVALID_SOCKET
Definition: port.h:33
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4326

◆ pgstat_report_deadlock()

void pgstat_report_deadlock ( void  )

Definition at line 1509 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().

1510 {
1511  PgStat_MsgDeadlock msg;
1512 
1514  return;
1515 
1517  msg.m_databaseid = MyDatabaseId;
1518  pgstat_send(&msg, sizeof(msg));
1519 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
bool pgstat_track_counts
Definition: pgstat.c:124
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:4326

◆ pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int  reason)

Definition at line 1489 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().

1490 {
1492 
1494  return;
1495 
1497  msg.m_databaseid = MyDatabaseId;
1498  msg.m_reason = reason;
1499  pgstat_send(&msg, sizeof(msg));
1500 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
bool pgstat_track_counts
Definition: pgstat.c:124
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:4326

◆ pgstat_report_stat()

void pgstat_report_stat ( bool  force)

Definition at line 811 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().

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

◆ pgstat_report_tempfile()

void pgstat_report_tempfile ( size_t  filesize)

Definition at line 1564 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().

1565 {
1566  PgStat_MsgTempFile msg;
1567 
1569  return;
1570 
1572  msg.m_databaseid = MyDatabaseId;
1573  msg.m_filesize = filesize;
1574  pgstat_send(&msg, sizeof(msg));
1575 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
PgStat_MsgHdr m_hdr
Definition: pgstat.h:443
size_t m_filesize
Definition: pgstat.h:446
bool pgstat_track_counts
Definition: pgstat.c:124
#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:4326

◆ pgstat_report_vacuum()

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

Definition at line 1408 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 heap_vacuum_rel().

1410 {
1411  PgStat_MsgVacuum msg;
1412 
1414  return;
1415 
1417  msg.m_databaseid = shared ? InvalidOid : MyDatabaseId;
1418  msg.m_tableoid = tableoid;
1421  msg.m_live_tuples = livetuples;
1422  msg.m_dead_tuples = deadtuples;
1423  pgstat_send(&msg, sizeof(msg));
1424 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
PgStat_Counter m_dead_tuples
Definition: pgstat.h:371
TimestampTz m_vacuumtime
Definition: pgstat.h:369
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
PgStat_Counter m_live_tuples
Definition: pgstat.h:370
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1583
Oid m_databaseid
Definition: pgstat.h:366
bool m_autovacuum
Definition: pgstat.h:368
bool pgstat_track_counts
Definition: pgstat.c:124
bool IsAutoVacuumWorkerProcess(void)
Definition: autovacuum.c:3281
#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:4326
PgStat_MsgHdr m_hdr
Definition: pgstat.h:365

◆ pgstat_report_wait_end()

static void pgstat_report_wait_end ( void  )
inlinestatic

Definition at line 1342 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(), update_controlfile(), WaitEventSetWait(), WALRead(), WalSndErrorCleanup(), WalWriterMain(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), XLogFileCopy(), XLogFileInit(), XLogPageRead(), and XLogWrite().

1343 {
1344  volatile PGPROC *proc = MyProc;
1345 
1346  if (!pgstat_track_activities || !proc)
1347  return;
1348 
1349  /*
1350  * Since this is a four-byte field which is always read and written as
1351  * four-bytes, updates are atomic.
1352  */
1353  proc->wait_event_info = 0;
1354 }
uint32 wait_event_info
Definition: proc.h:176
PGPROC * MyProc
Definition: proc.c:67
bool pgstat_track_activities
Definition: pgstat.c:123
Definition: proc.h:95

◆ pgstat_report_wait_start()

static void pgstat_report_wait_start ( uint32  wait_event_info)
inlinestatic

Definition at line 1318 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(), update_controlfile(), WaitEventSetWait(), WALRead(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), XLogFileCopy(), XLogFileInit(), XLogPageRead(), and XLogWrite().

1319 {
1320  volatile PGPROC *proc = MyProc;
1321 
1322  if (!pgstat_track_activities || !proc)
1323  return;
1324 
1325  /*
1326  * Since this is a four-byte field which is always read and written as
1327  * four-bytes, updates are atomic.
1328  */
1329  proc->wait_event_info = wait_event_info;
1330 }
uint32 wait_event_info
Definition: proc.h:176
PGPROC * MyProc
Definition: proc.c:67