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_PROC_SIGNAL_BARRIER,
  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_ANALYZE, 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 1147 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 1390 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 1385 of file pgstat.h.

Referenced by ReadBufferExtended().

◆ pgstat_count_buffer_read_time

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

Definition at line 1395 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 1397 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 1370 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 1365 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 1360 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 1375 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 1380 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 1153 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 1139 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 1159 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_ANALYZE 
PROGRESS_COMMAND_CLUSTER 
PROGRESS_COMMAND_CREATE_INDEX 

Definition at line 955 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_PROC_SIGNAL_BARRIER 
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 {
949 } 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 784 of file pgstat.c.

References last_pgstat_start_time.

Referenced by HandleChildCrash().

785 {
787 }
static time_t last_pgstat_start_time
Definition: pgstat.c:152

◆ AtEOSubXact_PgStat()

void AtEOSubXact_PgStat ( bool  isCommit,
int  nestDepth 
)

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

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

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

2274 {
2275  PgStat_SubXactStatus *xact_state;
2276 
2277  xact_state = pgStatXactStack;
2278  if (xact_state != NULL)
2279  {
2281 
2282  Assert(xact_state->nest_level == 1);
2283  Assert(xact_state->prev == NULL);
2284  for (trans = xact_state->first; trans != NULL; trans = trans->next)
2285  {
2286  PgStat_TableStatus *tabstat;
2287  TwoPhasePgStatRecord record;
2288 
2289  Assert(trans->nest_level == 1);
2290  Assert(trans->upper == NULL);
2291  tabstat = trans->parent;
2292  Assert(tabstat->trans == trans);
2293 
2294  record.tuples_inserted = trans->tuples_inserted;
2295  record.tuples_updated = trans->tuples_updated;
2296  record.tuples_deleted = trans->tuples_deleted;
2297  record.inserted_pre_trunc = trans->inserted_pre_trunc;
2298  record.updated_pre_trunc = trans->updated_pre_trunc;
2299  record.deleted_pre_trunc = trans->deleted_pre_trunc;
2300  record.t_id = tabstat->t_id;
2301  record.t_shared = tabstat->t_shared;
2302  record.t_truncated = trans->truncated;
2303 
2305  &record, sizeof(TwoPhasePgStatRecord));
2306  }
2307  }
2308 }
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:233
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:232
PgStat_Counter inserted_pre_trunc
Definition: pgstat.c:231
struct PgStat_TableXactStatus * upper
Definition: pgstat.h:176
PgStat_Counter tuples_updated
Definition: pgstat.c:229
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
struct PgStat_SubXactStatus * prev
Definition: pgstat.c:214
#define Assert(condition)
Definition: c.h:739
PgStat_Counter inserted_pre_trunc
Definition: pgstat.h:171
PgStat_Counter tuples_inserted
Definition: pgstat.c:228
static PgStat_SubXactStatus * pgStatXactStack
Definition: pgstat.c:218
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
PgStat_Counter tuples_deleted
Definition: pgstat.c:230
#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:215
PgStat_TableStatus * parent
Definition: pgstat.h:177

◆ BackendStatusShmemSize()

Size BackendStatusShmemSize ( void  )

Definition at line 2645 of file pgstat.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

2646 {
2647  Size size;
2648 
2649  /* BackendStatusArray: */
2650  size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2651  /* BackendAppnameBuffer: */
2652  size = add_size(size,
2654  /* BackendClientHostnameBuffer: */
2655  size = add_size(size,
2657  /* BackendActivityBuffer: */
2658  size = add_size(size,
2660 #ifdef USE_SSL
2661  /* BackendSslStatusBuffer: */
2662  size = add_size(size,
2664 #endif
2665  return size;
2666 }
#define NumBackendStatSlots
Definition: pgstat.c:117
#define NAMEDATALEN
int pgstat_track_activity_query_size
Definition: pgstat.c:127
Size mul_size(Size s1, Size s2)
Definition: shmem.c:515
Size add_size(Size s1, Size s2)
Definition: shmem.c:498
size_t Size
Definition: c.h:467

◆ CreateSharedBackendStatus()

void CreateSharedBackendStatus ( void  )

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

2674 {
2675  Size size;
2676  bool found;
2677  int i;
2678  char *buffer;
2679 
2680  /* Create or attach to the shared array */
2681  size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2683  ShmemInitStruct("Backend Status Array", size, &found);
2684 
2685  if (!found)
2686  {
2687  /*
2688  * We're the first - initialize.
2689  */
2690  MemSet(BackendStatusArray, 0, size);
2691  }
2692 
2693  /* Create or attach to the shared appname buffer */
2695  BackendAppnameBuffer = (char *)
2696  ShmemInitStruct("Backend Application Name Buffer", size, &found);
2697 
2698  if (!found)
2699  {
2700  MemSet(BackendAppnameBuffer, 0, size);
2701 
2702  /* Initialize st_appname pointers. */
2703  buffer = BackendAppnameBuffer;
2704  for (i = 0; i < NumBackendStatSlots; i++)
2705  {
2706  BackendStatusArray[i].st_appname = buffer;
2707  buffer += NAMEDATALEN;
2708  }
2709  }
2710 
2711  /* Create or attach to the shared client hostname buffer */
2713  BackendClientHostnameBuffer = (char *)
2714  ShmemInitStruct("Backend Client Host Name Buffer", size, &found);
2715 
2716  if (!found)
2717  {
2719 
2720  /* Initialize st_clienthostname pointers. */
2721  buffer = BackendClientHostnameBuffer;
2722  for (i = 0; i < NumBackendStatSlots; i++)
2723  {
2725  buffer += NAMEDATALEN;
2726  }
2727  }
2728 
2729  /* Create or attach to the shared activity buffer */
2732  BackendActivityBuffer = (char *)
2733  ShmemInitStruct("Backend Activity Buffer",
2735  &found);
2736 
2737  if (!found)
2738  {
2740 
2741  /* Initialize st_activity pointers. */
2742  buffer = BackendActivityBuffer;
2743  for (i = 0; i < NumBackendStatSlots; i++)
2744  {
2747  }
2748  }
2749 
2750 #ifdef USE_SSL
2751  /* Create or attach to the shared SSL status buffer */
2753  BackendSslStatusBuffer = (PgBackendSSLStatus *)
2754  ShmemInitStruct("Backend SSL Status Buffer", size, &found);
2755 
2756  if (!found)
2757  {
2758  PgBackendSSLStatus *ptr;
2759 
2760  MemSet(BackendSslStatusBuffer, 0, size);
2761 
2762  /* Initialize st_sslstatus pointers. */
2763  ptr = BackendSslStatusBuffer;
2764  for (i = 0; i < NumBackendStatSlots; i++)
2765  {
2767  ptr++;
2768  }
2769  }
2770 #endif
2771 
2772 #ifdef ENABLE_GSS
2773  /* Create or attach to the shared GSSAPI status buffer */
2775  BackendGssStatusBuffer = (PgBackendGSSStatus *)
2776  ShmemInitStruct("Backend GSS Status Buffer", size, &found);
2777 
2778  if (!found)
2779  {
2780  PgBackendGSSStatus *ptr;
2781 
2782  MemSet(BackendGssStatusBuffer, 0, size);
2783 
2784  /* Initialize st_gssstatus pointers. */
2785  ptr = BackendGssStatusBuffer;
2786  for (i = 0; i < NumBackendStatSlots; i++)
2787  {
2789  ptr++;
2790  }
2791  }
2792 #endif
2793 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2627
static char * BackendActivityBuffer
Definition: pgstat.c:2631
static Size BackendActivityBufferSize
Definition: pgstat.c:2632
#define MemSet(start, val, len)
Definition: c.h:962
#define NumBackendStatSlots
Definition: pgstat.c:117
char * st_clienthostname
Definition: pgstat.h:1064
#define NAMEDATALEN
static char * BackendAppnameBuffer
Definition: pgstat.c:2629
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:392
char * st_activity_raw
Definition: pgstat.h:1087
int pgstat_track_activity_query_size
Definition: pgstat.c:127
char * st_appname
Definition: pgstat.h:1078
Size mul_size(Size s1, Size s2)
Definition: shmem.c:515
size_t Size
Definition: c.h:467
int i
PgBackendSSLStatus * st_sslstatus
Definition: pgstat.h:1068
PgBackendGSSStatus * st_gssstatus
Definition: pgstat.h:1072
static char * BackendClientHostnameBuffer
Definition: pgstat.c:2630

◆ find_funcstat_entry()

PgStat_BackendFunctionEntry* find_funcstat_entry ( Oid  func_id)

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

1668 {
1669  if (pgStatFunctions == NULL)
1670  return NULL;
1671 
1673  (void *) &func_id,
1674  HASH_FIND, NULL);
1675 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
static HTAB * pgStatFunctions
Definition: pgstat.c:196

◆ find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry ( Oid  rel_id)

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

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

◆ pgstat_bestart()

void pgstat_bestart ( void  )

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

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

◆ pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void  )

Definition at line 5767 of file pgstat.c.

References localNumBackends, and MemoryContextDelete().

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

5768 {
5769  /* Release memory, if any was allocated */
5770  if (pgStatLocalContext)
5772 
5773  /* Reset variables */
5774  pgStatLocalContext = NULL;
5775  pgStatDBHash = NULL;
5776  localBackendStatusTable = NULL;
5777  localNumBackends = 0;
5778 }
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:211
static LocalPgBackendStatus * localBackendStatusTable
Definition: pgstat.c:246
static HTAB * pgStatDBHash
Definition: pgstat.c:243
static int localNumBackends
Definition: pgstat.c:249
static MemoryContext pgStatLocalContext
Definition: pgstat.c:242

◆ pgstat_clip_activity()

char* pgstat_clip_activity ( const char *  raw_activity)

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

6516 {
6517  char *activity;
6518  int rawlen;
6519  int cliplen;
6520 
6521  /*
6522  * Some callers, like pgstat_get_backend_current_activity(), do not
6523  * guarantee that the buffer isn't concurrently modified. We try to take
6524  * care that the buffer is always terminated by a NUL byte regardless, but
6525  * let's still be paranoid about the string's length. In those cases the
6526  * underlying buffer is guaranteed to be pgstat_track_activity_query_size
6527  * large.
6528  */
6529  activity = pnstrdup(raw_activity, pgstat_track_activity_query_size - 1);
6530 
6531  /* now double-guaranteed to be NUL terminated */
6532  rawlen = strlen(activity);
6533 
6534  /*
6535  * All supported server-encodings make it possible to determine the length
6536  * of a multi-byte character from its first byte (this is not the case for
6537  * client encodings, see GB18030). As st_activity is always stored using
6538  * server encoding, this allows us to perform multi-byte aware truncation,
6539  * even if the string earlier was truncated in the middle of a multi-byte
6540  * character.
6541  */
6542  cliplen = pg_mbcliplen(activity, rawlen,
6544 
6545  activity[cliplen] = '\0';
6546 
6547  return activity;
6548 }
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:127
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 1987 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().

1988 {
1989  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1990 
1991  if (pgstat_info != NULL)
1992  {
1993  /* We have to log the effect at the proper transactional level */
1994  int nest_level = GetCurrentTransactionNestLevel();
1995 
1996  if (pgstat_info->trans == NULL ||
1997  pgstat_info->trans->nest_level != nest_level)
1998  add_tabstat_xact_level(pgstat_info, nest_level);
1999 
2000  pgstat_info->trans->tuples_deleted++;
2001  }
2002 }
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:841
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:210
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1914
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 1941 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().

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

◆ pgstat_count_heap_update()

void pgstat_count_heap_update ( Relation  rel,
bool  hot 
)

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

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

◆ pgstat_count_truncate()

void pgstat_count_truncate ( Relation  rel)

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

2043 {
2044  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
2045 
2046  if (pgstat_info != NULL)
2047  {
2048  /* We have to log the effect at the proper transactional level */
2049  int nest_level = GetCurrentTransactionNestLevel();
2050 
2051  if (pgstat_info->trans == NULL ||
2052  pgstat_info->trans->nest_level != nest_level)
2053  add_tabstat_xact_level(pgstat_info, nest_level);
2054 
2055  pgstat_truncate_save_counters(pgstat_info->trans);
2056  pgstat_info->trans->tuples_inserted = 0;
2057  pgstat_info->trans->tuples_updated = 0;
2058  pgstat_info->trans->tuples_deleted = 0;
2059  }
2060 }
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:210
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
Definition: pgstat.c:1914
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
static void pgstat_truncate_save_counters(PgStat_TableXactStatus *trans)
Definition: pgstat.c:2013

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid  databaseid)

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

1249 {
1250  PgStat_MsgDropdb msg;
1251 
1253  return;
1254 
1256  msg.m_databaseid = databaseid;
1257  pgstat_send(&msg, sizeof(msg));
1258 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4337
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:148
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:4324

◆ pgstat_end_function_usage()

void pgstat_end_function_usage ( PgStat_FunctionCallUsage fcu,
bool  finalize 
)

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

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

◆ pgstat_fetch_global()

◆ pgstat_fetch_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver ( void  )

Definition at line 2597 of file pgstat.c.

References archiverStats, and backend_read_statsfile().

Referenced by pg_stat_get_archiver().

2598 {
2600 
2601  return &archiverStats;
2602 }
static void backend_read_statsfile(void)
Definition: pgstat.c:5613
static PgStat_ArchiverStats archiverStats
Definition: pgstat.c:256

◆ pgstat_fetch_stat_beentry()

◆ pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry* pgstat_fetch_stat_dbentry ( Oid  dbid)

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

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

◆ pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry ( Oid  funcid)

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

2509 {
2510  PgStat_StatDBEntry *dbentry;
2511  PgStat_StatFuncEntry *funcentry = NULL;
2512 
2513  /* load the stats file if needed */
2515 
2516  /* Lookup our database, then find the requested function. */
2518  if (dbentry != NULL && dbentry->functions != NULL)
2519  {
2520  funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,
2521  (void *) &func_id,
2522  HASH_FIND, NULL);
2523  }
2524 
2525  return funcentry;
2526 }
HTAB * functions
Definition: pgstat.h:624
PgStat_StatDBEntry * pgstat_fetch_stat_dbentry(Oid dbid)
Definition: pgstat.c:2425
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:5613
Oid MyDatabaseId
Definition: globals.c:85

◆ pgstat_fetch_stat_local_beentry()

LocalPgBackendStatus* pgstat_fetch_stat_local_beentry ( int  beid)

Definition at line 2562 of file pgstat.c.

References localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_activity(), and pg_stat_get_progress_info().

2563 {
2565 
2566  if (beid < 1 || beid > localNumBackends)
2567  return NULL;
2568 
2569  return &localBackendStatusTable[beid - 1];
2570 }
static void pgstat_read_current_status(void)
Definition: pgstat.c:3343
static LocalPgBackendStatus * localBackendStatusTable
Definition: pgstat.c:246
static int localNumBackends
Definition: pgstat.c:249

◆ pgstat_fetch_stat_numbackends()

int pgstat_fetch_stat_numbackends ( void  )

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

2582 {
2584 
2585  return localNumBackends;
2586 }
static void pgstat_read_current_status(void)
Definition: pgstat.c:3343
static int localNumBackends
Definition: pgstat.c:249

◆ pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry ( Oid  relid)

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

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

◆ pgstat_get_backend_current_activity()

const char* pgstat_get_backend_current_activity ( int  pid,
bool  checkUser 
)

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

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

◆ pgstat_get_backend_desc()

const char* pgstat_get_backend_desc ( BackendType  backendType)

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

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

◆ pgstat_get_crashed_backend_activity()

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

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

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

◆ pgstat_get_wait_event()

const char* pgstat_get_wait_event ( uint32  wait_event_info)

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

3551 {
3552  uint32 classId;
3553  uint16 eventId;
3554  const char *event_name;
3555 
3556  /* report process as not waiting. */
3557  if (wait_event_info == 0)
3558  return NULL;
3559 
3560  classId = wait_event_info & 0xFF000000;
3561  eventId = wait_event_info & 0x0000FFFF;
3562 
3563  switch (classId)
3564  {
3565  case PG_WAIT_LWLOCK:
3566  event_name = GetLWLockIdentifier(classId, eventId);
3567  break;
3568  case PG_WAIT_LOCK:
3569  event_name = GetLockNameFromTagType(eventId);
3570  break;
3571  case PG_WAIT_BUFFER_PIN:
3572  event_name = "BufferPin";
3573  break;
3574  case PG_WAIT_ACTIVITY:
3575  {
3576  WaitEventActivity w = (WaitEventActivity) wait_event_info;
3577 
3578  event_name = pgstat_get_wait_activity(w);
3579  break;
3580  }
3581  case PG_WAIT_CLIENT:
3582  {
3583  WaitEventClient w = (WaitEventClient) wait_event_info;
3584 
3585  event_name = pgstat_get_wait_client(w);
3586  break;
3587  }
3588  case PG_WAIT_EXTENSION:
3589  event_name = "Extension";
3590  break;
3591  case PG_WAIT_IPC:
3592  {
3593  WaitEventIPC w = (WaitEventIPC) wait_event_info;
3594 
3595  event_name = pgstat_get_wait_ipc(w);
3596  break;
3597  }
3598  case PG_WAIT_TIMEOUT:
3599  {
3600  WaitEventTimeout w = (WaitEventTimeout) wait_event_info;
3601 
3602  event_name = pgstat_get_wait_timeout(w);
3603  break;
3604  }
3605  case PG_WAIT_IO:
3606  {
3607  WaitEventIO w = (WaitEventIO) wait_event_info;
3608 
3609  event_name = pgstat_get_wait_io(w);
3610  break;
3611  }
3612  default:
3613  event_name = "unknown wait event";
3614  break;
3615  }
3616 
3617  return event_name;
3618 }
#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:3864
static const char * pgstat_get_wait_ipc(WaitEventIPC w)
Definition: pgstat.c:3734
#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:3627
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:3688
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:3892
#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 3495 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().

3496 {
3497  uint32 classId;
3498  const char *event_type;
3499 
3500  /* report process as not waiting. */
3501  if (wait_event_info == 0)
3502  return NULL;
3503 
3504  classId = wait_event_info & 0xFF000000;
3505 
3506  switch (classId)
3507  {
3508  case PG_WAIT_LWLOCK:
3509  event_type = "LWLock";
3510  break;
3511  case PG_WAIT_LOCK:
3512  event_type = "Lock";
3513  break;
3514  case PG_WAIT_BUFFER_PIN:
3515  event_type = "BufferPin";
3516  break;
3517  case PG_WAIT_ACTIVITY:
3518  event_type = "Activity";
3519  break;
3520  case PG_WAIT_CLIENT:
3521  event_type = "Client";
3522  break;
3523  case PG_WAIT_EXTENSION:
3524  event_type = "Extension";
3525  break;
3526  case PG_WAIT_IPC:
3527  event_type = "IPC";
3528  break;
3529  case PG_WAIT_TIMEOUT:
3530  event_type = "Timeout";
3531  break;
3532  case PG_WAIT_IO:
3533  event_type = "IO";
3534  break;
3535  default:
3536  event_type = "???";
3537  break;
3538  }
3539 
3540  return event_type;
3541 }
#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 349 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().

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

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

Referenced by AuxiliaryProcessMain(), and InitPostgres().

2809 {
2810  /* Initialize MyBEEntry */
2812  {
2815  }
2816  else
2817  {
2818  /* Must be an auxiliary process */
2820 
2821  /*
2822  * Assign the MyBEEntry for an auxiliary process. Since it doesn't
2823  * have a BackendId, the slot is statically allocated based on the
2824  * auxiliary process type (MyAuxProcType). Backends use slots indexed
2825  * in the range from 1 to MaxBackends (inclusive), so we use
2826  * MaxBackends + AuxBackendType + 1 as the index of the slot for an
2827  * auxiliary process.
2828  */
2830  }
2831 
2832  /* Set up a process-exit hook to clean up */
2834 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2627
BackendId MyBackendId
Definition: globals.c:81
int MaxBackends
Definition: globals.c:135
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2628
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:3076
#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 1744 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().

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

◆ pgstat_ping()

void pgstat_ping ( void  )

Definition at line 1580 of file pgstat.c.

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

1581 {
1582  PgStat_MsgDummy msg;
1583 
1585  return;
1586 
1588  pgstat_send(&msg, sizeof(msg));
1589 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4337
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:148
#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:4324

◆ pgstat_progress_end_command()

void pgstat_progress_end_command ( void  )

Definition at line 3264 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(), analyze_rel(), cluster_rel(), DefineIndex(), heap_vacuum_rel(), reindex_index(), and ReindexRelationConcurrently().

3265 {
3266  volatile PgBackendStatus *beentry = MyBEEntry;
3267 
3268  if (!beentry || !pgstat_track_activities)
3269  return;
3270 
3272  return;
3273 
3274  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3277  PGSTAT_END_WRITE_ACTIVITY(beentry);
3278 }
Oid st_progress_command_target
Definition: pgstat.h:1099
ProgressCommandType st_progress_command
Definition: pgstat.h:1098
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2628
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1139
#define InvalidOid
Definition: postgres_ext.h:36
bool pgstat_track_activities
Definition: pgstat.c:124
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1132

◆ pgstat_progress_start_command()

void pgstat_progress_start_command ( ProgressCommandType  cmdtype,
Oid  relid 
)

Definition at line 3192 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 analyze_rel(), cluster_rel(), DefineIndex(), heap_vacuum_rel(), reindex_index(), and ReindexRelationConcurrently().

3193 {
3194  volatile PgBackendStatus *beentry = MyBEEntry;
3195 
3196  if (!beentry || !pgstat_track_activities)
3197  return;
3198 
3199  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3200  beentry->st_progress_command = cmdtype;
3201  beentry->st_progress_command_target = relid;
3202  MemSet(&beentry->st_progress_param, 0, sizeof(beentry->st_progress_param));
3203  PGSTAT_END_WRITE_ACTIVITY(beentry);
3204 }
Oid st_progress_command_target
Definition: pgstat.h:1099
#define MemSet(start, val, len)
Definition: c.h:962
ProgressCommandType st_progress_command
Definition: pgstat.h:1098
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2628
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1139
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition: pgstat.h:1100
bool pgstat_track_activities
Definition: pgstat.c:124
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1132

◆ pgstat_progress_update_multi_param()

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

Definition at line 3235 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(), BuildRelationExtStatistics(), heapam_relation_copy_for_cluster(), index_build(), lazy_scan_heap(), validate_index(), and WaitForLockersMultiple().

3237 {
3238  volatile PgBackendStatus *beentry = MyBEEntry;
3239  int i;
3240 
3241  if (!beentry || !pgstat_track_activities || nparam == 0)
3242  return;
3243 
3244  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3245 
3246  for (i = 0; i < nparam; ++i)
3247  {
3248  Assert(index[i] >= 0 && index[i] < PGSTAT_NUM_PROGRESS_PARAM);
3249 
3250  beentry->st_progress_param[index[i]] = val[i];
3251  }
3252 
3253  PGSTAT_END_WRITE_ACTIVITY(beentry);
3254 }
Definition: type.h:89
#define PGSTAT_NUM_PROGRESS_PARAM
Definition: pgstat.h:964
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2628
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1139
#define Assert(condition)
Definition: c.h:739
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition: pgstat.h:1100
bool pgstat_track_activities
Definition: pgstat.c:124
int i
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1132
long val
Definition: informix.c:664

◆ pgstat_progress_update_param()

void pgstat_progress_update_param ( int  index,
int64  val 
)

Definition at line 3213 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(), acquire_inherited_sample_rows(), acquire_sample_rows(), btvacuumscan(), BuildRelationExtStatistics(), cluster_rel(), DefineIndex(), do_analyze_rel(), 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_all_indexes(), lazy_vacuum_heap(), lazy_vacuum_page(), reindex_index(), reindex_relation(), ReindexRelationConcurrently(), validate_index(), WaitForLockersMultiple(), and WaitForOlderSnapshots().

3214 {
3215  volatile PgBackendStatus *beentry = MyBEEntry;
3216 
3218 
3219  if (!beentry || !pgstat_track_activities)
3220  return;
3221 
3222  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3223  beentry->st_progress_param[index] = val;
3224  PGSTAT_END_WRITE_ACTIVITY(beentry);
3225 }
Definition: type.h:89
#define PGSTAT_NUM_PROGRESS_PARAM
Definition: pgstat.h:964
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2628
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1139
#define Assert(condition)
Definition: c.h:739
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition: pgstat.h:1100
bool pgstat_track_activities
Definition: pgstat.c:124
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1132
long val
Definition: informix.c:664

◆ pgstat_report_activity()

void pgstat_report_activity ( BackendState  state,
const char *  cmd_str 
)

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

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

1434 {
1435  PgStat_MsgAnalyze msg;
1436 
1438  return;
1439 
1440  /*
1441  * Unlike VACUUM, ANALYZE might be running inside a transaction that has
1442  * already inserted and/or deleted rows in the target table. ANALYZE will
1443  * have counted such rows as live or dead respectively. Because we will
1444  * report our counts of such rows at transaction end, we should subtract
1445  * off these counts from what we send to the collector now, else they'll
1446  * be double-counted after commit. (This approach also ensures that the
1447  * collector ends up with the right numbers if we abort instead of
1448  * committing.)
1449  */
1450  if (rel->pgstat_info != NULL)
1451  {
1453 
1454  for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
1455  {
1456  livetuples -= trans->tuples_inserted - trans->tuples_deleted;
1457  deadtuples -= trans->tuples_updated + trans->tuples_deleted;
1458  }
1459  /* count stuff inserted by already-aborted subxacts, too */
1460  deadtuples -= rel->pgstat_info->t_counts.t_delta_dead_tuples;
1461  /* Since ANALYZE's counts are estimates, we could have underflowed */
1462  livetuples = Max(livetuples, 0);
1463  deadtuples = Max(deadtuples, 0);
1464  }
1465 
1467  msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
1468  msg.m_tableoid = RelationGetRelid(rel);
1470  msg.m_resetcounter = resetcounter;
1472  msg.m_live_tuples = livetuples;
1473  msg.m_dead_tuples = deadtuples;
1474  pgstat_send(&msg, sizeof(msg));
1475 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4337
PgStat_Counter tuples_updated
Definition: pgstat.h:168
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:148
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:84
bool m_resetcounter
Definition: pgstat.h:386
bool pgstat_track_counts
Definition: pgstat.c:125
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
PgStat_Counter t_delta_dead_tuples
Definition: pgstat.h:111
bool IsAutoVacuumWorkerProcess(void)
Definition: autovacuum.c:3276
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:4324
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:210
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:428

◆ pgstat_report_appname()

void pgstat_report_appname ( const char *  appname)

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

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

◆ pgstat_report_autovac()

void pgstat_report_autovac ( Oid  dboid)

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

1382 {
1384 
1386  return;
1387 
1389  msg.m_databaseid = dboid;
1391 
1392  pgstat_send(&msg, sizeof(msg));
1393 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4337
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:148
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:4324
TimestampTz m_start_time
Definition: pgstat.h:354

◆ pgstat_report_checksum_failure()

void pgstat_report_checksum_failure ( void  )

Definition at line 1547 of file pgstat.c.

References MyDatabaseId, and pgstat_report_checksum_failures_in_db().

Referenced by PageIsVerified().

1548 {
1550 }
void pgstat_report_checksum_failures_in_db(Oid dboid, int failurecount)
Definition: pgstat.c:1525
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 1525 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().

1526 {
1528 
1530  return;
1531 
1533  msg.m_databaseid = dboid;
1534  msg.m_failurecount = failurecount;
1536 
1537  pgstat_send(&msg, sizeof(msg));
1538 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4337
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:148
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1583
PgStat_MsgHdr m_hdr
Definition: pgstat.h:540
bool pgstat_track_counts
Definition: pgstat.c:125
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:4324

◆ pgstat_report_deadlock()

void pgstat_report_deadlock ( void  )

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

1505 {
1506  PgStat_MsgDeadlock msg;
1507 
1509  return;
1510 
1512  msg.m_databaseid = MyDatabaseId;
1513  pgstat_send(&msg, sizeof(msg));
1514 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4337
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:148
bool pgstat_track_counts
Definition: pgstat.c:125
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:4324

◆ pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int  reason)

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

1485 {
1487 
1489  return;
1490 
1492  msg.m_databaseid = MyDatabaseId;
1493  msg.m_reason = reason;
1494  pgstat_send(&msg, sizeof(msg));
1495 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4337
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:148
bool pgstat_track_counts
Definition: pgstat.c:125
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:4324

◆ pgstat_report_stat()

void pgstat_report_stat ( bool  force)

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

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

◆ pgstat_report_tempfile()

void pgstat_report_tempfile ( size_t  filesize)

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

1560 {
1561  PgStat_MsgTempFile msg;
1562 
1564  return;
1565 
1567  msg.m_databaseid = MyDatabaseId;
1568  msg.m_filesize = filesize;
1569  pgstat_send(&msg, sizeof(msg));
1570 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4337
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:148
PgStat_MsgHdr m_hdr
Definition: pgstat.h:443
size_t m_filesize
Definition: pgstat.h:446
bool pgstat_track_counts
Definition: pgstat.c:125
#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:4324

◆ pgstat_report_vacuum()

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

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

1405 {
1406  PgStat_MsgVacuum msg;
1407 
1409  return;
1410 
1412  msg.m_databaseid = shared ? InvalidOid : MyDatabaseId;
1413  msg.m_tableoid = tableoid;
1416  msg.m_live_tuples = livetuples;
1417  msg.m_dead_tuples = deadtuples;
1418  pgstat_send(&msg, sizeof(msg));
1419 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4337
PgStat_Counter m_dead_tuples
Definition: pgstat.h:371
TimestampTz m_vacuumtime
Definition: pgstat.h:369
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:148
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:125
bool IsAutoVacuumWorkerProcess(void)
Definition: autovacuum.c:3276
#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:4324
PgStat_MsgHdr m_hdr
Definition: pgstat.h:365

◆ pgstat_report_wait_end()

static void pgstat_report_wait_end ( void  )
inlinestatic

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

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

◆ pgstat_report_wait_start()