PostgreSQL Source Code  git master
pgstat.c File Reference
#include "postgres.h"
#include <unistd.h>
#include <fcntl.h>
#include <sys/param.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/tableam.h"
#include "access/transam.h"
#include "access/twophase_rmgr.h"
#include "access/xact.h"
#include "catalog/pg_database.h"
#include "catalog/pg_proc.h"
#include "common/ip.h"
#include "libpq/libpq.h"
#include "libpq/pqsignal.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "postmaster/fork_process.h"
#include "postmaster/postmaster.h"
#include "replication/walsender.h"
#include "storage/backendid.h"
#include "storage/dsm.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/latch.h"
#include "storage/lmgr.h"
#include "storage/pg_shmem.h"
#include "storage/procsignal.h"
#include "storage/sinvaladt.h"
#include "utils/ascii.h"
#include "utils/guc.h"
#include "utils/memutils.h"
#include "utils/ps_status.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/timestamp.h"
Include dependency graph for pgstat.c:

Go to the source code of this file.

Data Structures

struct  TabStatusArray
 
struct  TabStatHashEntry
 
struct  PgStat_SubXactStatus
 
struct  TwoPhasePgStatRecord
 

Macros

#define PGSTAT_STAT_INTERVAL
 
#define PGSTAT_RETRY_DELAY
 
#define PGSTAT_MAX_WAIT_TIME
 
#define PGSTAT_INQ_INTERVAL
 
#define PGSTAT_RESTART_INTERVAL
 
#define PGSTAT_POLL_LOOP_COUNT   (PGSTAT_MAX_WAIT_TIME / PGSTAT_RETRY_DELAY)
 
#define PGSTAT_INQ_LOOP_COUNT   (PGSTAT_INQ_INTERVAL / PGSTAT_RETRY_DELAY)
 
#define PGSTAT_MIN_RCVBUF   (100 * 1024)
 
#define PGSTAT_DB_HASH_SIZE   16
 
#define PGSTAT_TAB_HASH_SIZE   512
 
#define PGSTAT_FUNCTION_HASH_SIZE   512
 
#define NumBackendStatSlots   (MaxBackends + NUM_AUXPROCTYPES)
 
#define TABSTAT_QUANTUM   100 /* we alloc this many at a time */
 
#define TESTBYTEVAL   ((char) 199)
 

Typedefs

typedef struct TabStatusArray TabStatusArray
 
typedef struct TabStatHashEntry TabStatHashEntry
 
typedef struct PgStat_SubXactStatus PgStat_SubXactStatus
 
typedef struct TwoPhasePgStatRecord TwoPhasePgStatRecord
 

Functions

NON_EXEC_STATIC void PgstatCollectorMain (int argc, char *argv[]) pg_attribute_noreturn()
 
static void pgstat_exit (SIGNAL_ARGS)
 
static void pgstat_beshutdown_hook (int code, Datum arg)
 
static void pgstat_sighup_handler (SIGNAL_ARGS)
 
static PgStat_StatDBEntrypgstat_get_db_entry (Oid databaseid, bool create)
 
static PgStat_StatTabEntrypgstat_get_tab_entry (PgStat_StatDBEntry *dbentry, Oid tableoid, bool create)
 
static void pgstat_write_statsfiles (bool permanent, bool allDbs)
 
static void pgstat_write_db_statsfile (PgStat_StatDBEntry *dbentry, bool permanent)
 
static HTABpgstat_read_statsfiles (Oid onlydb, bool permanent, bool deep)
 
static void pgstat_read_db_statsfile (Oid databaseid, HTAB *tabhash, HTAB *funchash, bool permanent)
 
static void backend_read_statsfile (void)
 
static void pgstat_read_current_status (void)
 
static bool pgstat_write_statsfile_needed (void)
 
static bool pgstat_db_requested (Oid databaseid)
 
static void pgstat_send_tabstat (PgStat_MsgTabstat *tsmsg)
 
static void pgstat_send_funcstats (void)
 
static HTABpgstat_collect_oids (Oid catalogid, AttrNumber anum_oid)
 
static PgStat_TableStatusget_tabstat_entry (Oid rel_id, bool isshared)
 
static void pgstat_setup_memcxt (void)
 
static const char * pgstat_get_wait_activity (WaitEventActivity w)
 
static const char * pgstat_get_wait_client (WaitEventClient w)
 
static const char * pgstat_get_wait_ipc (WaitEventIPC w)
 
static const char * pgstat_get_wait_timeout (WaitEventTimeout w)
 
static const char * pgstat_get_wait_io (WaitEventIO w)
 
static void pgstat_setheader (PgStat_MsgHdr *hdr, StatMsgType mtype)
 
static void pgstat_send (void *msg, int len)
 
static void pgstat_recv_inquiry (PgStat_MsgInquiry *msg, int len)
 
static void pgstat_recv_tabstat (PgStat_MsgTabstat *msg, int len)
 
static void pgstat_recv_tabpurge (PgStat_MsgTabpurge *msg, int len)
 
static void pgstat_recv_dropdb (PgStat_MsgDropdb *msg, int len)
 
static void pgstat_recv_resetcounter (PgStat_MsgResetcounter *msg, int len)
 
static void pgstat_recv_resetsharedcounter (PgStat_MsgResetsharedcounter *msg, int len)
 
static void pgstat_recv_resetsinglecounter (PgStat_MsgResetsinglecounter *msg, int len)
 
static void pgstat_recv_autovac (PgStat_MsgAutovacStart *msg, int len)
 
static void pgstat_recv_vacuum (PgStat_MsgVacuum *msg, int len)
 
static void pgstat_recv_analyze (PgStat_MsgAnalyze *msg, int len)
 
static void pgstat_recv_archiver (PgStat_MsgArchiver *msg, int len)
 
static void pgstat_recv_bgwriter (PgStat_MsgBgWriter *msg, int len)
 
static void pgstat_recv_funcstat (PgStat_MsgFuncstat *msg, int len)
 
static void pgstat_recv_funcpurge (PgStat_MsgFuncpurge *msg, int len)
 
static void pgstat_recv_recoveryconflict (PgStat_MsgRecoveryConflict *msg, int len)
 
static void pgstat_recv_deadlock (PgStat_MsgDeadlock *msg, int len)
 
static void pgstat_recv_checksum_failure (PgStat_MsgChecksumFailure *msg, int len)
 
static void pgstat_recv_tempfile (PgStat_MsgTempFile *msg, int len)
 
void pgstat_init (void)
 
static void pgstat_reset_remove_files (const char *directory)
 
void pgstat_reset_all (void)
 
int pgstat_start (void)
 
void allow_immediate_pgstat_restart (void)
 
void pgstat_report_stat (bool force)
 
void pgstat_vacuum_stat (void)
 
void pgstat_drop_database (Oid databaseid)
 
void pgstat_reset_counters (void)
 
void pgstat_reset_shared_counters (const char *target)
 
void pgstat_reset_single_counter (Oid objoid, 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_report_tempfile (size_t filesize)
 
void pgstat_ping (void)
 
static void pgstat_send_inquiry (TimestampTz clock_time, TimestampTz cutoff_time, Oid databaseid)
 
void pgstat_init_function_usage (FunctionCallInfo fcinfo, PgStat_FunctionCallUsage *fcu)
 
PgStat_BackendFunctionEntryfind_funcstat_entry (Oid func_id)
 
void pgstat_end_function_usage (PgStat_FunctionCallUsage *fcu, bool finalize)
 
void pgstat_initstats (Relation rel)
 
PgStat_TableStatusfind_tabstat_entry (Oid rel_id)
 
static PgStat_SubXactStatusget_tabstat_stack_level (int nest_level)
 
static void add_tabstat_xact_level (PgStat_TableStatus *pgstat_info, int nest_level)
 
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)
 
static void pgstat_truncate_save_counters (PgStat_TableXactStatus *trans)
 
static void pgstat_truncate_restore_counters (PgStat_TableXactStatus *trans)
 
void pgstat_count_truncate (Relation rel)
 
void pgstat_update_heap_dead_tuples (Relation rel, int delta)
 
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)
 
PgStat_StatDBEntrypgstat_fetch_stat_dbentry (Oid dbid)
 
PgStat_StatTabEntrypgstat_fetch_stat_tabentry (Oid relid)
 
PgStat_StatFuncEntrypgstat_fetch_stat_funcentry (Oid func_id)
 
PgBackendStatuspgstat_fetch_stat_beentry (int beid)
 
LocalPgBackendStatuspgstat_fetch_stat_local_beentry (int beid)
 
int pgstat_fetch_stat_numbackends (void)
 
PgStat_ArchiverStatspgstat_fetch_stat_archiver (void)
 
PgStat_GlobalStatspgstat_fetch_global (void)
 
Size BackendStatusShmemSize (void)
 
void CreateSharedBackendStatus (void)
 
void pgstat_initialize (void)
 
void pgstat_bestart (void)
 
void pgstat_report_activity (BackendState state, const char *cmd_str)
 
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)
 
void pgstat_report_appname (const char *appname)
 
void pgstat_report_xact_timestamp (TimestampTz tstamp)
 
const char * pgstat_get_wait_event_type (uint32 wait_event_info)
 
const char * pgstat_get_wait_event (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_send_archiver (const char *xlog, bool failed)
 
void pgstat_send_bgwriter (void)
 
static void reset_dbentry_counters (PgStat_StatDBEntry *dbentry)
 
static void get_dbstat_filename (bool permanent, bool tempname, Oid databaseid, char *filename, int len)
 
static bool pgstat_read_db_statsfile_timestamp (Oid databaseid, bool permanent, TimestampTz *ts)
 
void pgstat_clear_snapshot (void)
 
char * pgstat_clip_activity (const char *raw_activity)
 

Variables

bool pgstat_track_activities = false
 
bool pgstat_track_counts = false
 
int pgstat_track_functions = TRACK_FUNC_OFF
 
int pgstat_track_activity_query_size = 1024
 
char * pgstat_stat_directory = NULL
 
char * pgstat_stat_filename = NULL
 
char * pgstat_stat_tmpname = NULL
 
PgStat_MsgBgWriter BgWriterStats
 
NON_EXEC_STATIC pgsocket pgStatSock = PGINVALID_SOCKET
 
static struct sockaddr_storage pgStatAddr
 
static time_t last_pgstat_start_time
 
static bool pgStatRunningInCollector = false
 
static TabStatusArraypgStatTabList = NULL
 
static HTABpgStatTabHash = NULL
 
static HTABpgStatFunctions = NULL
 
static bool have_function_stats = false
 
static PgStat_SubXactStatuspgStatXactStack = NULL
 
static int pgStatXactCommit = 0
 
static int pgStatXactRollback = 0
 
PgStat_Counter pgStatBlockReadTime = 0
 
PgStat_Counter pgStatBlockWriteTime = 0
 
static MemoryContext pgStatLocalContext = NULL
 
static HTABpgStatDBHash = NULL
 
static LocalPgBackendStatuslocalBackendStatusTable = NULL
 
static int localNumBackends = 0
 
static PgStat_ArchiverStats archiverStats
 
static PgStat_GlobalStats globalStats
 
static Listpending_write_requests = NIL
 
static volatile bool need_exit = false
 
static volatile bool got_SIGHUP = false
 
static instr_time total_func_time
 
static PgBackendStatusBackendStatusArray = NULL
 
static PgBackendStatusMyBEEntry = NULL
 
static char * BackendAppnameBuffer = NULL
 
static char * BackendClientHostnameBuffer = NULL
 
static char * BackendActivityBuffer = NULL
 
static Size BackendActivityBufferSize = 0
 

Macro Definition Documentation

◆ NumBackendStatSlots

#define NumBackendStatSlots   (MaxBackends + NUM_AUXPROCTYPES)

◆ PGSTAT_DB_HASH_SIZE

#define PGSTAT_DB_HASH_SIZE   16

Definition at line 102 of file pgstat.c.

Referenced by pgstat_read_statsfiles().

◆ PGSTAT_FUNCTION_HASH_SIZE

#define PGSTAT_FUNCTION_HASH_SIZE   512

◆ PGSTAT_INQ_INTERVAL

#define PGSTAT_INQ_INTERVAL
Value:
640 /* How often to ping the collector for a
* new file; in milliseconds. */

Definition at line 84 of file pgstat.c.

◆ PGSTAT_INQ_LOOP_COUNT

#define PGSTAT_INQ_LOOP_COUNT   (PGSTAT_INQ_INTERVAL / PGSTAT_RETRY_DELAY)

Definition at line 92 of file pgstat.c.

Referenced by backend_read_statsfile().

◆ PGSTAT_MAX_WAIT_TIME

#define PGSTAT_MAX_WAIT_TIME
Value:
10000 /* Maximum time to wait for a stats
* file update; in milliseconds. */

Definition at line 81 of file pgstat.c.

◆ PGSTAT_MIN_RCVBUF

#define PGSTAT_MIN_RCVBUF   (100 * 1024)

Definition at line 95 of file pgstat.c.

Referenced by pgstat_init().

◆ PGSTAT_POLL_LOOP_COUNT

#define PGSTAT_POLL_LOOP_COUNT   (PGSTAT_MAX_WAIT_TIME / PGSTAT_RETRY_DELAY)

Definition at line 91 of file pgstat.c.

Referenced by backend_read_statsfile().

◆ PGSTAT_RESTART_INTERVAL

#define PGSTAT_RESTART_INTERVAL
Value:
60 /* How often to attempt to restart a
* failed statistics collector; in
* seconds. */

Definition at line 87 of file pgstat.c.

Referenced by pgstat_start().

◆ PGSTAT_RETRY_DELAY

#define PGSTAT_RETRY_DELAY
Value:
10 /* How long to wait between checks for a
* new file; in milliseconds. */

Definition at line 78 of file pgstat.c.

Referenced by backend_read_statsfile().

◆ PGSTAT_STAT_INTERVAL

#define PGSTAT_STAT_INTERVAL
Value:
500 /* Minimum time between stats file
* updates; in milliseconds. */

Definition at line 75 of file pgstat.c.

Referenced by backend_read_statsfile(), and pgstat_report_stat().

◆ PGSTAT_TAB_HASH_SIZE

#define PGSTAT_TAB_HASH_SIZE   512

Definition at line 103 of file pgstat.c.

Referenced by pgstat_collect_oids(), pgstat_read_statsfiles(), and reset_dbentry_counters().

◆ TABSTAT_QUANTUM

#define TABSTAT_QUANTUM   100 /* we alloc this many at a time */

Definition at line 166 of file pgstat.c.

Referenced by get_tabstat_entry().

◆ TESTBYTEVAL

#define TESTBYTEVAL   ((char) 199)

Referenced by pgstat_init().

Typedef Documentation

◆ PgStat_SubXactStatus

◆ TabStatHashEntry

◆ TabStatusArray

◆ TwoPhasePgStatRecord

Function Documentation

◆ add_tabstat_xact_level()

static void add_tabstat_xact_level ( PgStat_TableStatus pgstat_info,
int  nest_level 
)
static

Definition at line 1919 of file pgstat.c.

References PgStat_SubXactStatus::first, get_tabstat_stack_level(), MemoryContextAllocZero(), PgStat_TableXactStatus::nest_level, PgStat_TableXactStatus::next, PgStat_TableXactStatus::parent, TopTransactionContext, PgStat_TableStatus::trans, trans, and PgStat_TableXactStatus::upper.

Referenced by pgstat_count_heap_delete(), pgstat_count_heap_insert(), pgstat_count_heap_update(), and pgstat_count_truncate().

1920 {
1921  PgStat_SubXactStatus *xact_state;
1923 
1924  /*
1925  * If this is the first rel to be modified at the current nest level, we
1926  * first have to push a transaction stack entry.
1927  */
1928  xact_state = get_tabstat_stack_level(nest_level);
1929 
1930  /* Now make a per-table stack entry */
1931  trans = (PgStat_TableXactStatus *)
1933  sizeof(PgStat_TableXactStatus));
1934  trans->nest_level = nest_level;
1935  trans->upper = pgstat_info->trans;
1936  trans->parent = pgstat_info;
1937  trans->next = xact_state->first;
1938  xact_state->first = trans;
1939  pgstat_info->trans = trans;
1940 }
MemoryContext TopTransactionContext
Definition: mcxt.c:49
struct PgStat_TableXactStatus * next
Definition: pgstat.h:179
static PgStat_SubXactStatus * get_tabstat_stack_level(int nest_level)
Definition: pgstat.c:1897
struct PgStat_TableXactStatus * upper
Definition: pgstat.h:176
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:839
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:157
static zic_t trans[TZ_MAX_LEAPS]
Definition: zic.c:396
PgStat_TableXactStatus * first
Definition: pgstat.c:214
PgStat_TableStatus * parent
Definition: pgstat.h:177

◆ allow_immediate_pgstat_restart()

void allow_immediate_pgstat_restart ( void  )

Definition at line 789 of file pgstat.c.

References last_pgstat_start_time.

Referenced by HandleChildCrash().

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

◆ AtEOSubXact_PgStat()

void AtEOSubXact_PgStat ( bool  isCommit,
int  nestDepth 
)

Definition at line 2179 of file pgstat.c.

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

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

◆ AtEOXact_PgStat()

void AtEOXact_PgStat ( bool  isCommit,
bool  parallel 
)

Definition at line 2092 of file pgstat.c.

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

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

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

◆ AtPrepare_PgStat()

void AtPrepare_PgStat ( void  )

Definition at line 2278 of file pgstat.c.

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

Referenced by PrepareTransaction().

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

◆ backend_read_statsfile()

static void backend_read_statsfile ( void  )
static

Definition at line 5640 of file pgstat.c.

References Assert, CHECK_FOR_INTERRUPTS, elog, ereport, errmsg(), GetCurrentTimestamp(), InvalidOid, IsAutoVacuumLauncherProcess(), IsAutoVacuumWorkerProcess(), LOG, MyDatabaseId, pfree(), pg_usleep(), PGSTAT_INQ_LOOP_COUNT, PGSTAT_POLL_LOOP_COUNT, pgstat_read_db_statsfile_timestamp(), pgstat_read_statsfiles(), PGSTAT_RETRY_DELAY, pgstat_send_inquiry(), PGSTAT_STAT_INTERVAL, pgStatRunningInCollector, pstrdup(), timestamptz_to_str(), and TimestampTzPlusMilliseconds.

Referenced by pgstat_fetch_global(), pgstat_fetch_stat_archiver(), pgstat_fetch_stat_dbentry(), pgstat_fetch_stat_funcentry(), pgstat_fetch_stat_tabentry(), and pgstat_vacuum_stat().

5641 {
5642  TimestampTz min_ts = 0;
5643  TimestampTz ref_ts = 0;
5644  Oid inquiry_db;
5645  int count;
5646 
5647  /* already read it? */
5648  if (pgStatDBHash)
5649  return;
5651 
5652  /*
5653  * In a normal backend, we check staleness of the data for our own DB, and
5654  * so we send MyDatabaseId in inquiry messages. In the autovac launcher,
5655  * check staleness of the shared-catalog data, and send InvalidOid in
5656  * inquiry messages so as not to force writing unnecessary data.
5657  */
5659  inquiry_db = InvalidOid;
5660  else
5661  inquiry_db = MyDatabaseId;
5662 
5663  /*
5664  * Loop until fresh enough stats file is available or we ran out of time.
5665  * The stats inquiry message is sent repeatedly in case collector drops
5666  * it; but not every single time, as that just swamps the collector.
5667  */
5668  for (count = 0; count < PGSTAT_POLL_LOOP_COUNT; count++)
5669  {
5670  bool ok;
5671  TimestampTz file_ts = 0;
5672  TimestampTz cur_ts;
5673 
5675 
5676  ok = pgstat_read_db_statsfile_timestamp(inquiry_db, false, &file_ts);
5677 
5678  cur_ts = GetCurrentTimestamp();
5679  /* Calculate min acceptable timestamp, if we didn't already */
5680  if (count == 0 || cur_ts < ref_ts)
5681  {
5682  /*
5683  * We set the minimum acceptable timestamp to PGSTAT_STAT_INTERVAL
5684  * msec before now. This indirectly ensures that the collector
5685  * needn't write the file more often than PGSTAT_STAT_INTERVAL. In
5686  * an autovacuum worker, however, we want a lower delay to avoid
5687  * using stale data, so we use PGSTAT_RETRY_DELAY (since the
5688  * number of workers is low, this shouldn't be a problem).
5689  *
5690  * We don't recompute min_ts after sleeping, except in the
5691  * unlikely case that cur_ts went backwards. So we might end up
5692  * accepting a file a bit older than PGSTAT_STAT_INTERVAL. In
5693  * practice that shouldn't happen, though, as long as the sleep
5694  * time is less than PGSTAT_STAT_INTERVAL; and we don't want to
5695  * tell the collector that our cutoff time is less than what we'd
5696  * actually accept.
5697  */
5698  ref_ts = cur_ts;
5700  min_ts = TimestampTzPlusMilliseconds(ref_ts,
5702  else
5703  min_ts = TimestampTzPlusMilliseconds(ref_ts,
5705  }
5706 
5707  /*
5708  * If the file timestamp is actually newer than cur_ts, we must have
5709  * had a clock glitch (system time went backwards) or there is clock
5710  * skew between our processor and the stats collector's processor.
5711  * Accept the file, but send an inquiry message anyway to make
5712  * pgstat_recv_inquiry do a sanity check on the collector's time.
5713  */
5714  if (ok && file_ts > cur_ts)
5715  {
5716  /*
5717  * A small amount of clock skew between processors isn't terribly
5718  * surprising, but a large difference is worth logging. We
5719  * arbitrarily define "large" as 1000 msec.
5720  */
5721  if (file_ts >= TimestampTzPlusMilliseconds(cur_ts, 1000))
5722  {
5723  char *filetime;
5724  char *mytime;
5725 
5726  /* Copy because timestamptz_to_str returns a static buffer */
5727  filetime = pstrdup(timestamptz_to_str(file_ts));
5728  mytime = pstrdup(timestamptz_to_str(cur_ts));
5729  elog(LOG, "stats collector's time %s is later than backend local time %s",
5730  filetime, mytime);
5731  pfree(filetime);
5732  pfree(mytime);
5733  }
5734 
5735  pgstat_send_inquiry(cur_ts, min_ts, inquiry_db);
5736  break;
5737  }
5738 
5739  /* Normal acceptance case: file is not older than cutoff time */
5740  if (ok && file_ts >= min_ts)
5741  break;
5742 
5743  /* Not there or too old, so kick the collector and wait a bit */
5744  if ((count % PGSTAT_INQ_LOOP_COUNT) == 0)
5745  pgstat_send_inquiry(cur_ts, min_ts, inquiry_db);
5746 
5747  pg_usleep(PGSTAT_RETRY_DELAY * 1000L);
5748  }
5749 
5750  if (count >= PGSTAT_POLL_LOOP_COUNT)
5751  ereport(LOG,
5752  (errmsg("using stale statistics instead of current ones "
5753  "because stats collector is not responding")));
5754 
5755  /*
5756  * Autovacuum launcher wants stats about all databases, but a shallow read
5757  * is sufficient. Regular backends want a deep read for just the tables
5758  * they can see (MyDatabaseId + shared catalogs).
5759  */
5762  else
5764 }
#define PGSTAT_RETRY_DELAY
Definition: pgstat.c:78
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1583
int64 TimestampTz
Definition: timestamp.h:39
#define PGSTAT_INQ_LOOP_COUNT
Definition: pgstat.c:92
char * pstrdup(const char *in)
Definition: mcxt.c:1186
static bool pgStatRunningInCollector
Definition: pgstat.c:153
#define LOG
Definition: elog.h:26
unsigned int Oid
Definition: postgres_ext.h:31
#define PGSTAT_POLL_LOOP_COUNT
Definition: pgstat.c:91
void pg_usleep(long microsec)
Definition: signal.c:53
void pfree(void *pointer)
Definition: mcxt.c:1056
static void pgstat_send_inquiry(TimestampTz clock_time, TimestampTz cutoff_time, Oid databaseid)
Definition: pgstat.c:1603
#define PGSTAT_STAT_INTERVAL
Definition: pgstat.c:75
bool IsAutoVacuumWorkerProcess(void)
Definition: autovacuum.c:3281
#define ereport(elevel, rest)
Definition: elog.h:141
static HTAB * pgstat_read_statsfiles(Oid onlydb, bool permanent, bool deep)
Definition: pgstat.c:5127
Oid MyDatabaseId
Definition: globals.c:85
#define InvalidOid
Definition: postgres_ext.h:36
#define TimestampTzPlusMilliseconds(tz, ms)
Definition: timestamp.h:56
static bool pgstat_read_db_statsfile_timestamp(Oid databaseid, bool permanent, TimestampTz *ts)
Definition: pgstat.c:5521
bool IsAutoVacuumLauncherProcess(void)
Definition: autovacuum.c:3275
#define Assert(condition)
Definition: c.h:739
static HTAB * pgStatDBHash
Definition: pgstat.c:242
int errmsg(const char *fmt,...)
Definition: elog.c:822
#define elog(elevel,...)
Definition: elog.h:228
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
const char * timestamptz_to_str(TimestampTz t)
Definition: timestamp.c:1743

◆ BackendStatusShmemSize()

Size BackendStatusShmemSize ( void  )

Definition at line 2650 of file pgstat.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

2651 {
2652  Size size;
2653 
2654  /* BackendStatusArray: */
2655  size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2656  /* BackendAppnameBuffer: */
2657  size = add_size(size,
2659  /* BackendClientHostnameBuffer: */
2660  size = add_size(size,
2662  /* BackendActivityBuffer: */
2663  size = add_size(size,
2665 #ifdef USE_SSL
2666  /* BackendSslStatusBuffer: */
2667  size = add_size(size,
2669 #endif
2670  return size;
2671 }
#define NumBackendStatSlots
Definition: pgstat.c:116
#define NAMEDATALEN
int pgstat_track_activity_query_size
Definition: pgstat.c:126
Size mul_size(Size s1, Size s2)
Definition: shmem.c:492
Size add_size(Size s1, Size s2)
Definition: shmem.c:475
size_t Size
Definition: c.h:467

◆ CreateSharedBackendStatus()

void CreateSharedBackendStatus ( void  )

Definition at line 2678 of file pgstat.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

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

◆ find_funcstat_entry()

PgStat_BackendFunctionEntry* find_funcstat_entry ( Oid  func_id)

Definition at line 1672 of file pgstat.c.

References HASH_FIND, and hash_search().

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

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

◆ find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry ( Oid  rel_id)

Definition at line 1877 of file pgstat.c.

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

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

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

◆ get_dbstat_filename()

static void get_dbstat_filename ( bool  permanent,
bool  tempname,
Oid  databaseid,
char *  filename,
int  len 
)
static

Definition at line 4978 of file pgstat.c.

References elog, ERROR, pgstat_stat_directory, PGSTAT_STAT_PERMANENT_DIRECTORY, and snprintf.

Referenced by pgstat_read_db_statsfile(), pgstat_recv_dropdb(), and pgstat_write_db_statsfile().

4980 {
4981  int printed;
4982 
4983  /* NB -- pgstat_reset_remove_files knows about the pattern this uses */
4984  printed = snprintf(filename, len, "%s/db_%u.%s",
4985  permanent ? PGSTAT_STAT_PERMANENT_DIRECTORY :
4987  databaseid,
4988  tempname ? "tmp" : "stat");
4989  if (printed >= len)
4990  elog(ERROR, "overlength pgstat path");
4991 }
#define PGSTAT_STAT_PERMANENT_DIRECTORY
Definition: pgstat.h:28
#define ERROR
Definition: elog.h:43
char * pgstat_stat_directory
Definition: pgstat.c:132
static char * filename
Definition: pg_dumpall.c:90
#define elog(elevel,...)
Definition: elog.h:228
#define snprintf
Definition: port.h:192

◆ get_tabstat_entry()

static PgStat_TableStatus * get_tabstat_entry ( Oid  rel_id,
bool  isshared 
)
static

Definition at line 1788 of file pgstat.c.

References HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), HASHCTL::keysize, MemoryContextAllocZero(), pgStatTabList, PgStat_TableStatus::t_id, PgStat_TableStatus::t_shared, TABSTAT_QUANTUM, TopMemoryContext, TabStatusArray::tsa_entries, TabStatHashEntry::tsa_entry, TabStatusArray::tsa_next, and TabStatusArray::tsa_used.

Referenced by pgstat_initstats(), pgstat_twophase_postabort(), and pgstat_twophase_postcommit().

1789 {
1790  TabStatHashEntry *hash_entry;
1791  PgStat_TableStatus *entry;
1792  TabStatusArray *tsa;
1793  bool found;
1794 
1795  /*
1796  * Create hash table if we don't have it already.
1797  */
1798  if (pgStatTabHash == NULL)
1799  {
1800  HASHCTL ctl;
1801 
1802  memset(&ctl, 0, sizeof(ctl));
1803  ctl.keysize = sizeof(Oid);
1804  ctl.entrysize = sizeof(TabStatHashEntry);
1805 
1806  pgStatTabHash = hash_create("pgstat TabStatusArray lookup hash table",
1808  &ctl,
1809  HASH_ELEM | HASH_BLOBS);
1810  }
1811 
1812  /*
1813  * Find an entry or create a new one.
1814  */
1815  hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_ENTER, &found);
1816  if (!found)
1817  {
1818  /* initialize new entry with null pointer */
1819  hash_entry->tsa_entry = NULL;
1820  }
1821 
1822  /*
1823  * If entry is already valid, we're done.
1824  */
1825  if (hash_entry->tsa_entry)
1826  return hash_entry->tsa_entry;
1827 
1828  /*
1829  * Locate the first pgStatTabList entry with free space, making a new list
1830  * entry if needed. Note that we could get an OOM failure here, but if so
1831  * we have left the hashtable and the list in a consistent state.
1832  */
1833  if (pgStatTabList == NULL)
1834  {
1835  /* Set up first pgStatTabList entry */
1838  sizeof(TabStatusArray));
1839  }
1840 
1841  tsa = pgStatTabList;
1842  while (tsa->tsa_used >= TABSTAT_QUANTUM)
1843  {
1844  if (tsa->tsa_next == NULL)
1845  tsa->tsa_next = (TabStatusArray *)
1847  sizeof(TabStatusArray));
1848  tsa = tsa->tsa_next;
1849  }
1850 
1851  /*
1852  * Allocate a PgStat_TableStatus entry within this list entry. We assume
1853  * the entry was already zeroed, either at creation or after last use.
1854  */
1855  entry = &tsa->tsa_entries[tsa->tsa_used++];
1856  entry->t_id = rel_id;
1857  entry->t_shared = isshared;
1858 
1859  /*
1860  * Now we can fill the entry in pgStatTabHash.
1861  */
1862  hash_entry->tsa_entry = entry;
1863 
1864  return entry;
1865 }
int tsa_used
Definition: pgstat.c:171
#define HASH_ELEM
Definition: hsearch.h:87
Size entrysize
Definition: hsearch.h:73
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
struct TabStatusArray * tsa_next
Definition: pgstat.c:170
unsigned int Oid
Definition: postgres_ext.h:31
struct TabStatHashEntry TabStatHashEntry
static HTAB * pgStatTabHash
Definition: pgstat.c:189
PgStat_TableStatus tsa_entries[TABSTAT_QUANTUM]
Definition: pgstat.c:172
MemoryContext TopMemoryContext
Definition: mcxt.c:44
#define HASH_BLOBS
Definition: hsearch.h:88
PgStat_TableStatus * tsa_entry
Definition: pgstat.c:183
HTAB * hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
Definition: dynahash.c:316
Size keysize
Definition: hsearch.h:72
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:839
static TabStatusArray * pgStatTabList
Definition: pgstat.c:175
#define TABSTAT_QUANTUM
Definition: pgstat.c:166

◆ get_tabstat_stack_level()

static PgStat_SubXactStatus* get_tabstat_stack_level ( int  nest_level)
static

Definition at line 1897 of file pgstat.c.

References PgStat_SubXactStatus::first, MemoryContextAlloc(), PgStat_SubXactStatus::nest_level, pgStatXactStack, PgStat_SubXactStatus::prev, and TopTransactionContext.

Referenced by add_tabstat_xact_level(), and AtEOSubXact_PgStat().

1898 {
1899  PgStat_SubXactStatus *xact_state;
1900 
1901  xact_state = pgStatXactStack;
1902  if (xact_state == NULL || xact_state->nest_level != nest_level)
1903  {
1904  xact_state = (PgStat_SubXactStatus *)
1906  sizeof(PgStat_SubXactStatus));
1907  xact_state->nest_level = nest_level;
1908  xact_state->prev = pgStatXactStack;
1909  xact_state->first = NULL;
1910  pgStatXactStack = xact_state;
1911  }
1912  return xact_state;
1913 }
MemoryContext TopTransactionContext
Definition: mcxt.c:49
struct PgStat_SubXactStatus * prev
Definition: pgstat.c:213
static PgStat_SubXactStatus * pgStatXactStack
Definition: pgstat.c:217
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:796
PgStat_TableXactStatus * first
Definition: pgstat.c:214

◆ pgstat_beshutdown_hook()

static void pgstat_beshutdown_hook ( int  code,
Datum  arg 
)
static

Definition at line 3081 of file pgstat.c.

References MyBEEntry, MyDatabaseId, OidIsValid, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_report_stat(), and PgBackendStatus::st_procpid.

Referenced by pgstat_initialize().

3082 {
3083  volatile PgBackendStatus *beentry = MyBEEntry;
3084 
3085  /*
3086  * If we got as far as discovering our own database ID, we can report what
3087  * we did to the collector. Otherwise, we'd be sending an invalid
3088  * database ID, so forget it. (This means that accesses to pg_database
3089  * during failed backend starts might never get counted.)
3090  */
3091  if (OidIsValid(MyDatabaseId))
3092  pgstat_report_stat(true);
3093 
3094  /*
3095  * Clear my status entry, following the protocol of bumping st_changecount
3096  * before and after. We use a volatile pointer here to ensure the
3097  * compiler doesn't try to get cute.
3098  */
3099  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3100 
3101  beentry->st_procpid = 0; /* mark invalid */
3102 
3103  PGSTAT_END_WRITE_ACTIVITY(beentry);
3104 }
#define OidIsValid(objectId)
Definition: c.h:645
static PgBackendStatus * MyBEEntry
Definition: pgstat.c:2633
#define PGSTAT_END_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1137
Oid MyDatabaseId
Definition: globals.c:85
#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
Definition: pgstat.h:1130
void pgstat_report_stat(bool force)
Definition: pgstat.c:811

◆ pgstat_bestart()

void pgstat_bestart ( void  )

Definition at line 2855 of file pgstat.c.

References am_walsender, application_name, Assert, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, B_WAL_WRITER, be_gssapi_get_auth(), be_gssapi_get_enc(), be_gssapi_get_princ(), be_tls_get_cipher(), be_tls_get_cipher_bits(), be_tls_get_compression(), be_tls_get_peer_issuer_name(), be_tls_get_peer_serial(), be_tls_get_peer_subject_name(), be_tls_get_version(), BgWriterProcess, CheckpointerProcess, elog, FATAL, GetSessionUserId(), Port::gss, PgBackendGSSStatus::gss_auth, PgBackendGSSStatus::gss_enc, PgBackendGSSStatus::gss_princ, InvalidBackendId, InvalidOid, IsAutoVacuumLauncherProcess(), IsAutoVacuumWorkerProcess(), IsBackgroundWorker, MemSet, MyAuxProcType, MyBackendId, MyBEEntry, MyDatabaseId, MyProcPid, MyProcPort, MyStartTimestamp, NAMEDATALEN, NotAnAuxProcess, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_report_appname(), pgstat_track_activity_query_size, PROGRESS_COMMAND_INVALID, Port::raddr, Port::remote_hostname, PgBackendSSLStatus::ssl_bits, PgBackendSSLStatus::ssl_cipher, PgBackendSSLStatus::ssl_client_dn, PgBackendSSLStatus::ssl_client_serial, PgBackendSSLStatus::ssl_compression, PgBackendSSLStatus::ssl_issuer_dn, PgBackendSSLStatus::ssl_version, PgBackendStatus::st_activity_raw, PgBackendStatus::st_activity_start_timestamp, PgBackendStatus::st_appname, PgBackendStatus::st_backendType, PgBackendStatus::st_changecount, PgBackendStatus::st_clientaddr, PgBackendStatus::st_clienthostname, PgBackendStatus::st_databaseid, PgBackendStatus::st_gss, PgBackendStatus::st_gssstatus, PgBackendStatus::st_proc_start_timestamp, PgBackendStatus::st_procpid, PgBackendStatus::st_progress_command, PgBackendStatus::st_progress_command_target, PgBackendStatus::st_ssl, PgBackendStatus::st_sslstatus, PgBackendStatus::st_state, PgBackendStatus::st_state_start_timestamp, PgBackendStatus::st_userid, PgBackendStatus::st_xact_start_timestamp, StartupProcess, STATE_UNDEFINED, strlcpy(), unvolatize, WalReceiverProcess, and WalWriterProcess.

Referenced by AuxiliaryProcessMain(), and InitPostgres().

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

◆ pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void  )

Definition at line 5794 of file pgstat.c.

References localNumBackends, and MemoryContextDelete().

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

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

◆ pgstat_clip_activity()

char* pgstat_clip_activity ( const char *  raw_activity)

Definition at line 6542 of file pgstat.c.

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

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

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

◆ pgstat_collect_oids()

static HTAB * pgstat_collect_oids ( Oid  catalogid,
AttrNumber  anum_oid 
)
static

Definition at line 1203 of file pgstat.c.

References AccessShareLock, Assert, CHECK_FOR_INTERRUPTS, CurrentMemoryContext, HASHCTL::entrysize, ForwardScanDirection, GetLatestSnapshot(), HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), HASHCTL::hcxt, heap_getattr, heap_getnext(), HASHCTL::keysize, PGSTAT_TAB_HASH_SIZE, RegisterSnapshot(), RelationGetDescr, table_beginscan(), table_close(), table_endscan(), table_open(), and UnregisterSnapshot().

Referenced by pgstat_vacuum_stat().

1204 {
1205  HTAB *htab;
1206  HASHCTL hash_ctl;
1207  Relation rel;
1208  TableScanDesc scan;
1209  HeapTuple tup;
1210  Snapshot snapshot;
1211 
1212  memset(&hash_ctl, 0, sizeof(hash_ctl));
1213  hash_ctl.keysize = sizeof(Oid);
1214  hash_ctl.entrysize = sizeof(Oid);
1215  hash_ctl.hcxt = CurrentMemoryContext;
1216  htab = hash_create("Temporary table of OIDs",
1218  &hash_ctl,
1220 
1221  rel = table_open(catalogid, AccessShareLock);
1222  snapshot = RegisterSnapshot(GetLatestSnapshot());
1223  scan = table_beginscan(rel, snapshot, 0, NULL);
1224  while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
1225  {
1226  Oid thisoid;
1227  bool isnull;
1228 
1229  thisoid = heap_getattr(tup, anum_oid, RelationGetDescr(rel), &isnull);
1230  Assert(!isnull);
1231 
1233 
1234  (void) hash_search(htab, (void *) &thisoid, HASH_ENTER, NULL);
1235  }
1236  table_endscan(scan);
1237  UnregisterSnapshot(snapshot);
1239 
1240  return htab;
1241 }
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:133
#define HASH_CONTEXT
Definition: hsearch.h:93
#define HASH_ELEM
Definition: hsearch.h:87
Snapshot RegisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:865
MemoryContext hcxt
Definition: hsearch.h:78
#define RelationGetDescr(relation)
Definition: rel.h:448
#define PGSTAT_TAB_HASH_SIZE
Definition: pgstat.c:103
#define AccessShareLock
Definition: lockdefs.h:36
Size entrysize
Definition: hsearch.h:73
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
unsigned int Oid
Definition: postgres_ext.h:31
Definition: dynahash.c:208
static TableScanDesc table_beginscan(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key)
Definition: tableam.h:736
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1290
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:907
#define heap_getattr(tup, attnum, tupleDesc, isnull)
Definition: htup_details.h:762
#define HASH_BLOBS
Definition: hsearch.h:88
HTAB * hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
Definition: dynahash.c:316
Size keysize
Definition: hsearch.h:72
#define Assert(condition)
Definition: c.h:739
Snapshot GetLatestSnapshot(void)
Definition: snapmgr.c:381
static void table_endscan(TableScanDesc scan)
Definition: tableam.h:831
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:39

◆ pgstat_count_heap_delete()

void pgstat_count_heap_delete ( Relation  rel)

Definition at line 1992 of file pgstat.c.

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

Referenced by heap_abort_speculative(), and heap_delete().

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

◆ pgstat_count_heap_insert()

void pgstat_count_heap_insert ( Relation  rel,
PgStat_Counter  n 
)

Definition at line 1946 of file pgstat.c.

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

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

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

◆ pgstat_count_heap_update()

void pgstat_count_heap_update ( Relation  rel,
bool  hot 
)

Definition at line 1967 of file pgstat.c.

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

Referenced by heap_update().

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

◆ pgstat_count_truncate()

void pgstat_count_truncate ( Relation  rel)

Definition at line 2047 of file pgstat.c.

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

Referenced by ExecRefreshMatView(), and ExecuteTruncateGuts().

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

◆ pgstat_db_requested()

static bool pgstat_db_requested ( Oid  databaseid)
static

Definition at line 6515 of file pgstat.c.

References InvalidOid, list_member_oid(), and NIL.

Referenced by pgstat_write_statsfiles().

6516 {
6517  /*
6518  * If any requests are outstanding at all, we should write the stats for
6519  * shared catalogs (the "database" with OID 0). This ensures that
6520  * backends will see up-to-date stats for shared catalogs, even though
6521  * they send inquiry messages mentioning only their own DB.
6522  */
6523  if (databaseid == InvalidOid && pending_write_requests != NIL)
6524  return true;
6525 
6526  /* Search to see if there's an open request to write this database. */
6527  if (list_member_oid(pending_write_requests, databaseid))
6528  return true;
6529 
6530  return false;
6531 }
#define NIL
Definition: pg_list.h:65
static List * pending_write_requests
Definition: pgstat.c:263
#define InvalidOid
Definition: postgres_ext.h:36
bool list_member_oid(const List *list, Oid datum)
Definition: list.c:675

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid  databaseid)

Definition at line 1253 of file pgstat.c.

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

Referenced by dropdb(), and pgstat_vacuum_stat().

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

◆ pgstat_end_function_usage()

void pgstat_end_function_usage ( PgStat_FunctionCallUsage fcu,
bool  finalize 
)

Definition at line 1692 of file pgstat.c.

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

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

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

◆ pgstat_exit()

static void pgstat_exit ( SIGNAL_ARGS  )
static

Definition at line 4684 of file pgstat.c.

References MyLatch, need_exit, and SetLatch().

Referenced by PgstatCollectorMain().

4685 {
4686  int save_errno = errno;
4687 
4688  need_exit = true;
4689  SetLatch(MyLatch);
4690 
4691  errno = save_errno;
4692 }
void SetLatch(Latch *latch)
Definition: latch.c:436
static volatile bool need_exit
Definition: pgstat.c:266
struct Latch * MyLatch
Definition: globals.c:54

◆ pgstat_fetch_global()

◆ pgstat_fetch_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver ( void  )

Definition at line 2602 of file pgstat.c.

References archiverStats, and backend_read_statsfile().

Referenced by pg_stat_get_archiver().

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

◆ pgstat_fetch_stat_beentry()

◆ pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry* pgstat_fetch_stat_dbentry ( Oid  dbid)

Definition at line 2430 of file pgstat.c.

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

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

2431 {
2432  /*
2433  * If not done for this transaction, read the statistics collector stats
2434  * file into some hash tables.
2435  */
2437 
2438  /*
2439  * Lookup the requested database; return NULL if not found
2440  */
2442  (void *) &dbid,
2443  HASH_FIND, NULL);
2444 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
static void backend_read_statsfile(void)
Definition: pgstat.c:5640
static HTAB * pgStatDBHash
Definition: pgstat.c:242

◆ pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry ( Oid  func_id)

Definition at line 2513 of file pgstat.c.

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

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

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

◆ pgstat_fetch_stat_local_beentry()

LocalPgBackendStatus* pgstat_fetch_stat_local_beentry ( int  beid)

Definition at line 2567 of file pgstat.c.

References localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_activity(), and pg_stat_get_progress_info().

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

◆ pgstat_fetch_stat_numbackends()

int pgstat_fetch_stat_numbackends ( void  )

Definition at line 2586 of file pgstat.c.

References localNumBackends, and pgstat_read_current_status().

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

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

◆ pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry ( Oid  relid)

Definition at line 2457 of file pgstat.c.

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

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

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

◆ pgstat_get_backend_current_activity()

const char* pgstat_get_backend_current_activity ( int  pid,
bool  checkUser 
)

Definition at line 4135 of file pgstat.c.

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

Referenced by DeadLockReport().

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

◆ pgstat_get_backend_desc()

const char* pgstat_get_backend_desc ( BackendType  backendType)

Definition at line 4272 of file pgstat.c.

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

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

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

◆ pgstat_get_crashed_backend_activity()

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

Definition at line 4213 of file pgstat.c.

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

Referenced by LogChildExit().

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

◆ pgstat_get_db_entry()

static PgStat_StatDBEntry * pgstat_get_db_entry ( Oid  databaseid,
bool  create 
)
static

Definition at line 4764 of file pgstat.c.

References generate_unaccent_rules::action, HASH_ENTER, HASH_FIND, hash_search(), and reset_dbentry_counters().

Referenced by pgstat_recv_analyze(), pgstat_recv_autovac(), pgstat_recv_checksum_failure(), pgstat_recv_deadlock(), pgstat_recv_dropdb(), pgstat_recv_funcpurge(), pgstat_recv_funcstat(), pgstat_recv_inquiry(), pgstat_recv_recoveryconflict(), pgstat_recv_resetcounter(), pgstat_recv_resetsinglecounter(), pgstat_recv_tabpurge(), pgstat_recv_tabstat(), pgstat_recv_tempfile(), and pgstat_recv_vacuum().

4765 {
4766  PgStat_StatDBEntry *result;
4767  bool found;
4768  HASHACTION action = (create ? HASH_ENTER : HASH_FIND);
4769 
4770  /* Lookup or create the hash table entry for this database */
4772  &databaseid,
4773  action, &found);
4774 
4775  if (!create && !found)
4776  return NULL;
4777 
4778  /*
4779  * If not found, initialize the new one. This creates empty hash tables
4780  * for tables and functions, too.
4781  */
4782  if (!found)
4783  reset_dbentry_counters(result);
4784 
4785  return result;
4786 }
static void reset_dbentry_counters(PgStat_StatDBEntry *dbentry)
Definition: pgstat.c:4712
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
static HTAB * pgStatDBHash
Definition: pgstat.c:242
HASHACTION
Definition: hsearch.h:103

◆ pgstat_get_tab_entry()

static PgStat_StatTabEntry * pgstat_get_tab_entry ( PgStat_StatDBEntry dbentry,
Oid  tableoid,
bool  create 
)
static

Definition at line 4795 of file pgstat.c.

References generate_unaccent_rules::action, PgStat_StatTabEntry::analyze_count, PgStat_StatTabEntry::analyze_timestamp, PgStat_StatTabEntry::autovac_analyze_count, PgStat_StatTabEntry::autovac_analyze_timestamp, PgStat_StatTabEntry::autovac_vacuum_count, PgStat_StatTabEntry::autovac_vacuum_timestamp, PgStat_StatTabEntry::blocks_fetched, PgStat_StatTabEntry::blocks_hit, PgStat_StatTabEntry::changes_since_analyze, HASH_ENTER, HASH_FIND, hash_search(), PgStat_StatTabEntry::n_dead_tuples, PgStat_StatTabEntry::n_live_tuples, PgStat_StatTabEntry::numscans, PgStat_StatDBEntry::tables, PgStat_StatTabEntry::tuples_deleted, PgStat_StatTabEntry::tuples_fetched, PgStat_StatTabEntry::tuples_hot_updated, PgStat_StatTabEntry::tuples_inserted, PgStat_StatTabEntry::tuples_returned, PgStat_StatTabEntry::tuples_updated, PgStat_StatTabEntry::vacuum_count, and PgStat_StatTabEntry::vacuum_timestamp.

Referenced by pgstat_recv_analyze(), and pgstat_recv_vacuum().

4796 {
4797  PgStat_StatTabEntry *result;
4798  bool found;
4799  HASHACTION action = (create ? HASH_ENTER : HASH_FIND);
4800 
4801  /* Lookup or create the hash table entry for this table */
4802  result = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
4803  &tableoid,
4804  action, &found);
4805 
4806  if (!create && !found)
4807  return NULL;
4808 
4809  /* If not found, initialize the new one. */
4810  if (!found)
4811  {
4812  result->numscans = 0;
4813  result->tuples_returned = 0;
4814  result->tuples_fetched = 0;
4815  result->tuples_inserted = 0;
4816  result->tuples_updated = 0;
4817  result->tuples_deleted = 0;
4818  result->tuples_hot_updated = 0;
4819  result->n_live_tuples = 0;
4820  result->n_dead_tuples = 0;
4821  result->changes_since_analyze = 0;
4822  result->blocks_fetched = 0;
4823  result->blocks_hit = 0;
4824  result->vacuum_timestamp = 0;
4825  result->vacuum_count = 0;
4826  result->autovac_vacuum_timestamp = 0;
4827  result->autovac_vacuum_count = 0;
4828  result->analyze_timestamp = 0;
4829  result->analyze_count = 0;
4830  result->autovac_analyze_timestamp = 0;
4831  result->autovac_analyze_count = 0;
4832  }
4833 
4834  return result;
4835 }
PgStat_Counter analyze_count
Definition: pgstat.h:658
PgStat_Counter tuples_returned
Definition: pgstat.h:638
TimestampTz autovac_analyze_timestamp
Definition: pgstat.h:659
PgStat_Counter vacuum_count
Definition: pgstat.h:654
PgStat_Counter numscans
Definition: pgstat.h:636
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
PgStat_Counter tuples_hot_updated
Definition: pgstat.h:644
PgStat_Counter tuples_inserted
Definition: pgstat.h:641
PgStat_Counter n_live_tuples
Definition: pgstat.h:646
TimestampTz vacuum_timestamp
Definition: pgstat.h:653
PgStat_Counter n_dead_tuples
Definition: pgstat.h:647
PgStat_Counter tuples_fetched
Definition: pgstat.h:639
PgStat_Counter blocks_hit
Definition: pgstat.h:651
TimestampTz analyze_timestamp
Definition: pgstat.h:657
PgStat_Counter changes_since_analyze
Definition: pgstat.h:648
PgStat_Counter tuples_deleted
Definition: pgstat.h:643
PgStat_Counter tuples_updated
Definition: pgstat.h:642
TimestampTz autovac_vacuum_timestamp
Definition: pgstat.h:655
PgStat_Counter autovac_analyze_count
Definition: pgstat.h:660
PgStat_Counter blocks_fetched
Definition: pgstat.h:650
HASHACTION
Definition: hsearch.h:103
PgStat_Counter autovac_vacuum_count
Definition: pgstat.h:656

◆ pgstat_get_wait_activity()

static const char * pgstat_get_wait_activity ( WaitEventActivity  w)
static

Definition at line 3632 of file pgstat.c.

References 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, and WAIT_EVENT_WAL_WRITER_MAIN.

Referenced by pgstat_get_wait_event().

3633 {
3634  const char *event_name = "unknown wait event";
3635 
3636  switch (w)
3637  {
3639  event_name = "ArchiverMain";
3640  break;
3642  event_name = "AutoVacuumMain";
3643  break;
3645  event_name = "BgWriterHibernate";
3646  break;
3648  event_name = "BgWriterMain";
3649  break;
3651  event_name = "CheckpointerMain";
3652  break;
3654  event_name = "LogicalApplyMain";
3655  break;
3657  event_name = "LogicalLauncherMain";
3658  break;
3660  event_name = "PgStatMain";
3661  break;
3663  event_name = "RecoveryWalAll";
3664  break;
3666  event_name = "RecoveryWalStream";
3667  break;
3669  event_name = "SysLoggerMain";
3670  break;
3672  event_name = "WalReceiverMain";
3673  break;
3675  event_name = "WalSenderMain";
3676  break;
3678  event_name = "WalWriterMain";
3679  break;
3680  /* no default case, so that compiler will warn */
3681  }
3682 
3683  return event_name;
3684 }

◆ pgstat_get_wait_client()

static const char * pgstat_get_wait_client ( WaitEventClient  w)
static

Definition at line 3693 of file pgstat.c.

References WAIT_EVENT_CLIENT_READ, WAIT_EVENT_CLIENT_WRITE, WAIT_EVENT_GSS_OPEN_SERVER, 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, and WAIT_EVENT_WAL_SENDER_WRITE_DATA.

Referenced by pgstat_get_wait_event().

3694 {
3695  const char *event_name = "unknown wait event";
3696 
3697  switch (w)
3698  {
3700  event_name = "ClientRead";
3701  break;
3703  event_name = "ClientWrite";
3704  break;
3706  event_name = "LibPQWalReceiverConnect";
3707  break;
3709  event_name = "LibPQWalReceiverReceive";
3710  break;
3712  event_name = "SSLOpenServer";
3713  break;
3715  event_name = "WalReceiverWaitStart";
3716  break;
3718  event_name = "WalSenderWaitForWAL";
3719  break;
3721  event_name = "WalSenderWriteData";
3722  break;
3724  event_name = "GSSOpenServer";
3725  break;
3726  /* no default case, so that compiler will warn */
3727  }
3728 
3729  return event_name;
3730 }

◆ pgstat_get_wait_event()

const char* pgstat_get_wait_event ( uint32  wait_event_info)

Definition at line 3555 of file pgstat.c.

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

Referenced by pg_stat_get_activity(), and pg_stat_get_backend_wait_event().

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

◆ pgstat_get_wait_event_type()

const char* pgstat_get_wait_event_type ( uint32  wait_event_info)

Definition at line 3500 of file pgstat.c.

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

Referenced by pg_stat_get_activity(), and pg_stat_get_backend_wait_event_type().

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

◆ pgstat_get_wait_io()

static const char * pgstat_get_wait_io ( WaitEventIO  w)
static

Definition at line 3897 of file pgstat.c.

References WAIT_EVENT_BUFFILE_READ, WAIT_EVENT_BUFFILE_WRITE, WAIT_EVENT_CONTROL_FILE_READ, WAIT_EVENT_CONTROL_FILE_SYNC, WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE, WAIT_EVENT_CONTROL_FILE_WRITE, WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE, WAIT_EVENT_COPY_FILE_READ, WAIT_EVENT_COPY_FILE_WRITE, WAIT_EVENT_DATA_FILE_EXTEND, WAIT_EVENT_DATA_FILE_FLUSH, WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC, WAIT_EVENT_DATA_FILE_PREFETCH, WAIT_EVENT_DATA_FILE_READ, WAIT_EVENT_DATA_FILE_SYNC, WAIT_EVENT_DATA_FILE_TRUNCATE, WAIT_EVENT_DATA_FILE_WRITE, WAIT_EVENT_DSM_FILL_ZERO_WRITE, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC, WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE, WAIT_EVENT_LOCK_FILE_CREATE_READ, WAIT_EVENT_LOCK_FILE_CREATE_SYNC, WAIT_EVENT_LOCK_FILE_CREATE_WRITE, WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ, WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC, WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC, WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE, WAIT_EVENT_LOGICAL_REWRITE_SYNC, WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE, WAIT_EVENT_LOGICAL_REWRITE_WRITE, WAIT_EVENT_RELATION_MAP_READ, WAIT_EVENT_RELATION_MAP_SYNC, WAIT_EVENT_RELATION_MAP_WRITE, WAIT_EVENT_REORDER_BUFFER_READ, WAIT_EVENT_REORDER_BUFFER_WRITE, WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ, WAIT_EVENT_REPLICATION_SLOT_READ, WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC, WAIT_EVENT_REPLICATION_SLOT_SYNC, WAIT_EVENT_REPLICATION_SLOT_WRITE, WAIT_EVENT_SLRU_FLUSH_SYNC, WAIT_EVENT_SLRU_READ, WAIT_EVENT_SLRU_SYNC, WAIT_EVENT_SLRU_WRITE, WAIT_EVENT_SNAPBUILD_READ, WAIT_EVENT_SNAPBUILD_SYNC, WAIT_EVENT_SNAPBUILD_WRITE, WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC, WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE, WAIT_EVENT_TIMELINE_HISTORY_READ, WAIT_EVENT_TIMELINE_HISTORY_SYNC, WAIT_EVENT_TIMELINE_HISTORY_WRITE, WAIT_EVENT_TWOPHASE_FILE_READ, WAIT_EVENT_TWOPHASE_FILE_SYNC, WAIT_EVENT_TWOPHASE_FILE_WRITE, WAIT_EVENT_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, and WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ.

Referenced by pgstat_get_wait_event().

3898 {
3899  const char *event_name = "unknown wait event";
3900 
3901  switch (w)
3902  {
3904  event_name = "BufFileRead";
3905  break;
3907  event_name = "BufFileWrite";
3908  break;
3910  event_name = "ControlFileRead";
3911  break;
3913  event_name = "ControlFileSync";
3914  break;
3916  event_name = "ControlFileSyncUpdate";
3917  break;
3919  event_name = "ControlFileWrite";
3920  break;
3922  event_name = "ControlFileWriteUpdate";
3923  break;
3925  event_name = "CopyFileRead";
3926  break;
3928  event_name = "CopyFileWrite";
3929  break;
3931  event_name = "DataFileExtend";
3932  break;
3934  event_name = "DataFileFlush";
3935  break;
3937  event_name = "DataFileImmediateSync";
3938  break;
3940  event_name = "DataFilePrefetch";
3941  break;
3943  event_name = "DataFileRead";
3944  break;
3946  event_name = "DataFileSync";
3947  break;
3949  event_name = "DataFileTruncate";
3950  break;
3952  event_name = "DataFileWrite";
3953  break;
3955  event_name = "DSMFillZeroWrite";
3956  break;
3958  event_name = "LockFileAddToDataDirRead";
3959  break;
3961  event_name = "LockFileAddToDataDirSync";
3962  break;
3964  event_name = "LockFileAddToDataDirWrite";
3965  break;
3967  event_name = "LockFileCreateRead";
3968  break;
3970  event_name = "LockFileCreateSync";
3971  break;
3973  event_name = "LockFileCreateWrite";
3974  break;
3976  event_name = "LockFileReCheckDataDirRead";
3977  break;
3979  event_name = "LogicalRewriteCheckpointSync";
3980  break;
3982  event_name = "LogicalRewriteMappingSync";
3983  break;
3985  event_name = "LogicalRewriteMappingWrite";
3986  break;
3988  event_name = "LogicalRewriteSync";
3989  break;
3991  event_name = "LogicalRewriteTruncate";
3992  break;
3994  event_name = "LogicalRewriteWrite";
3995  break;
3997  event_name = "RelationMapRead";
3998  break;
4000  event_name = "RelationMapSync";
4001  break;
4003  event_name = "RelationMapWrite";
4004  break;
4006  event_name = "ReorderBufferRead";
4007  break;
4009  event_name = "ReorderBufferWrite";
4010  break;
4012  event_name = "ReorderLogicalMappingRead";
4013  break;
4015  event_name = "ReplicationSlotRead";
4016  break;
4018  event_name = "ReplicationSlotRestoreSync";
4019  break;
4021  event_name = "ReplicationSlotSync";
4022  break;
4024  event_name = "ReplicationSlotWrite";
4025  break;
4027  event_name = "SLRUFlushSync";
4028  break;
4029  case WAIT_EVENT_SLRU_READ:
4030  event_name = "SLRURead";
4031  break;
4032  case WAIT_EVENT_SLRU_SYNC:
4033  event_name = "SLRUSync";
4034  break;
4035  case WAIT_EVENT_SLRU_WRITE:
4036  event_name = "SLRUWrite";
4037  break;
4039  event_name = "SnapbuildRead";
4040  break;
4042  event_name = "SnapbuildSync";
4043  break;
4045  event_name = "SnapbuildWrite";
4046  break;
4048  event_name = "TimelineHistoryFileSync";
4049  break;
4051  event_name = "TimelineHistoryFileWrite";
4052  break;
4054  event_name = "TimelineHistoryRead";
4055  break;
4057  event_name = "TimelineHistorySync";
4058  break;
4060  event_name = "TimelineHistoryWrite";
4061  break;
4063  event_name = "TwophaseFileRead";
4064  break;
4066  event_name = "TwophaseFileSync";
4067  break;
4069  event_name = "TwophaseFileWrite";
4070  break;
4072  event_name = "WALSenderTimelineHistoryRead";
4073  break;
4075  event_name = "WALBootstrapSync";
4076  break;
4078  event_name = "WALBootstrapWrite";
4079  break;
4081  event_name = "WALCopyRead";
4082  break;
4084  event_name = "WALCopySync";
4085  break;
4087  event_name = "WALCopyWrite";
4088  break;
4090  event_name = "WALInitSync";
4091  break;
4093  event_name = "WALInitWrite";
4094  break;
4095  case WAIT_EVENT_WAL_READ:
4096  event_name = "WALRead";
4097  break;
4098  case WAIT_EVENT_WAL_SYNC:
4099  event_name = "WALSync";
4100  break;
4102  event_name = "WALSyncMethodAssign";
4103  break;
4104  case WAIT_EVENT_WAL_WRITE:
4105  event_name = "WALWrite";
4106  break;
4107 
4108  /* no default case, so that compiler will warn */
4109  }
4110 
4111  return event_name;
4112 }

◆ pgstat_get_wait_ipc()

static const char * pgstat_get_wait_ipc ( WaitEventIPC  w)
static

Definition at line 3739 of file pgstat.c.

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

Referenced by pgstat_get_wait_event().

3740 {
3741  const char *event_name = "unknown wait event";
3742 
3743  switch (w)
3744  {
3746  event_name = "BgWorkerShutdown";
3747  break;
3749  event_name = "BgWorkerStartup";
3750  break;
3751  case WAIT_EVENT_BTREE_PAGE:
3752  event_name = "BtreePage";
3753  break;
3755  event_name = "CheckpointDone";
3756  break;
3758  event_name = "CheckpointStart";
3759  break;
3761  event_name = "ClogGroupUpdate";
3762  break;
3764  event_name = "ExecuteGather";
3765  break;
3767  event_name = "Hash/Batch/Allocating";
3768  break;
3770  event_name = "Hash/Batch/Electing";
3771  break;
3773  event_name = "Hash/Batch/Loading";
3774  break;
3776  event_name = "Hash/Build/Allocating";
3777  break;
3779  event_name = "Hash/Build/Electing";
3780  break;
3782  event_name = "Hash/Build/HashingInner";
3783  break;
3785  event_name = "Hash/Build/HashingOuter";
3786  break;
3788  event_name = "Hash/GrowBatches/Allocating";
3789  break;
3791  event_name = "Hash/GrowBatches/Deciding";
3792  break;
3794  event_name = "Hash/GrowBatches/Electing";
3795  break;
3797  event_name = "Hash/GrowBatches/Finishing";
3798  break;
3800  event_name = "Hash/GrowBatches/Repartitioning";
3801  break;
3803  event_name = "Hash/GrowBuckets/Allocating";
3804  break;
3806  event_name = "Hash/GrowBuckets/Electing";
3807  break;
3809  event_name = "Hash/GrowBuckets/Reinserting";
3810  break;
3812  event_name = "LogicalSyncData";
3813  break;
3815  event_name = "LogicalSyncStateChange";
3816  break;
3818  event_name = "MessageQueueInternal";
3819  break;
3821  event_name = "MessageQueuePutMessage";
3822  break;
3823  case WAIT_EVENT_MQ_RECEIVE:
3824  event_name = "MessageQueueReceive";
3825  break;
3826  case WAIT_EVENT_MQ_SEND:
3827  event_name = "MessageQueueSend";
3828  break;
3830  event_name = "ParallelBitmapScan";
3831  break;
3833  event_name = "ParallelCreateIndexScan";
3834  break;
3836  event_name = "ParallelFinish";
3837  break;
3839  event_name = "ProcArrayGroupUpdate";
3840  break;
3841  case WAIT_EVENT_PROMOTE:
3842  event_name = "Promote";
3843  break;
3845  event_name = "ReplicationOriginDrop";
3846  break;
3848  event_name = "ReplicationSlotDrop";
3849  break;
3851  event_name = "SafeSnapshot";
3852  break;
3853  case WAIT_EVENT_SYNC_REP:
3854  event_name = "SyncRep";
3855  break;
3856  /* no default case, so that compiler will warn */
3857  }
3858 
3859  return event_name;
3860 }

◆ pgstat_get_wait_timeout()

static const char * pgstat_get_wait_timeout ( WaitEventTimeout  w)
static

Definition at line 3869 of file pgstat.c.

References WAIT_EVENT_BASE_BACKUP_THROTTLE, WAIT_EVENT_PG_SLEEP, and WAIT_EVENT_RECOVERY_APPLY_DELAY.

Referenced by pgstat_get_wait_event().

3870 {
3871  const char *event_name = "unknown wait event";
3872 
3873  switch (w)
3874  {
3876  event_name = "BaseBackupThrottle";
3877  break;
3878  case WAIT_EVENT_PG_SLEEP:
3879  event_name = "PgSleep";
3880  break;
3882  event_name = "RecoveryApplyDelay";
3883  break;
3884  /* no default case, so that compiler will warn */
3885  }
3886 
3887  return event_name;
3888 }

◆ pgstat_init()

void pgstat_init ( void  )

Definition at line 354 of file pgstat.c.

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

Referenced by PostmasterMain().

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

◆ pgstat_init_function_usage()

void pgstat_init_function_usage ( FunctionCallInfo  fcinfo,
PgStat_FunctionCallUsage fcu 
)

Definition at line 1620 of file pgstat.c.

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

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

1622 {
1623  PgStat_BackendFunctionEntry *htabent;
1624  bool found;
1625 
1626  if (pgstat_track_functions <= fcinfo->flinfo->fn_stats)
1627  {
1628  /* stats not wanted */
1629  fcu->fs = NULL;
1630  return;
1631  }
1632 
1633  if (!pgStatFunctions)
1634  {
1635  /* First time through - initialize function stat table */
1636  HASHCTL hash_ctl;
1637 
1638  memset(&hash_ctl, 0, sizeof(hash_ctl));
1639  hash_ctl.keysize = sizeof(Oid);
1640  hash_ctl.entrysize = sizeof(PgStat_BackendFunctionEntry);
1641  pgStatFunctions = hash_create("Function stat entries",
1643  &hash_ctl,
1644  HASH_ELEM | HASH_BLOBS);
1645  }
1646 
1647  /* Get the stats entry for this function, create if necessary */
1648  htabent = hash_search(pgStatFunctions, &fcinfo->flinfo->fn_oid,
1649  HASH_ENTER, &found);
1650  if (!found)
1651  MemSet(&htabent->f_counts, 0, sizeof(PgStat_FunctionCounts));
1652 
1653  fcu->fs = &htabent->f_counts;
1654 
1655  /* save stats for this function, later used to compensate for recursion */
1656  fcu->save_f_total_time = htabent->f_counts.f_total_time;
1657 
1658  /* save current backend-wide total time */
1659  fcu->save_total = total_func_time;
1660 
1661  /* get clock time as of function start */
1663 }
#define HASH_ELEM
Definition: hsearch.h:87
instr_time save_total
Definition: pgstat.h:1201
Size entrysize
Definition: hsearch.h:73
#define MemSet(start, val, len)
Definition: c.h:962
instr_time f_total_time
Definition: pgstat.h:462
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
unsigned int Oid
Definition: postgres_ext.h:31
PgStat_FunctionCounts * fs
Definition: pgstat.h:1197
PgStat_FunctionCounts f_counts
Definition: pgstat.h:473
#define PGSTAT_FUNCTION_HASH_SIZE
Definition: pgstat.c:104
#define HASH_BLOBS
Definition: hsearch.h:88
HTAB * hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
Definition: dynahash.c:316
FmgrInfo * flinfo
Definition: fmgr.h:87
Size keysize
Definition: hsearch.h:72
Oid fn_oid
Definition: fmgr.h:59
static instr_time total_func_time
Definition: pgstat.c:274
static HTAB * pgStatFunctions
Definition: pgstat.c:195
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
instr_time save_f_total_time
Definition: pgstat.h:1199
struct PgStat_BackendFunctionEntry PgStat_BackendFunctionEntry

◆ pgstat_initialize()

void pgstat_initialize ( void  )

Definition at line 2813 of file pgstat.c.

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

Referenced by AuxiliaryProcessMain(), and InitPostgres().

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

◆ pgstat_initstats()

void pgstat_initstats ( Relation  rel)

Definition at line 1749 of file pgstat.c.

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

Referenced by relation_open(), and try_relation_open().

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

◆ pgstat_ping()

void pgstat_ping ( void  )

Definition at line 1585 of file pgstat.c.

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

1586 {
1587  PgStat_MsgDummy msg;
1588 
1590  return;
1591 
1593  pgstat_send(&msg, sizeof(msg));
1594 }
static void pgstat_send(void *msg, int len)
Definition: pgstat.c:4339
NON_EXEC_STATIC pgsocket pgStatSock
Definition: pgstat.c:147
#define PGINVALID_SOCKET
Definition: port.h:33
PgStat_MsgHdr m_hdr
Definition: pgstat.h:216
static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
Definition: pgstat.c:4326

◆ pgstat_progress_end_command()

void pgstat_progress_end_command ( void  )

Definition at line 3269 of file pgstat.c.

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

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

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

◆ pgstat_progress_start_command()

void pgstat_progress_start_command ( ProgressCommandType  cmdtype,
Oid  relid 
)

Definition at line 3197 of file pgstat.c.

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

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

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

◆ pgstat_progress_update_multi_param()

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

Definition at line 3240 of file pgstat.c.

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

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

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

◆ pgstat_progress_update_param()

void pgstat_progress_update_param ( int  index,
int64  val 
)

Definition at line 3218 of file pgstat.c.

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

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

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

◆ pgstat_read_current_status()

static void pgstat_read_current_status ( void  )
static

Definition at line 3348 of file pgstat.c.

References Assert, LocalPgBackendStatus::backend_xid, LocalPgBackendStatus::backend_xmin, BackendIdGetTransactionIds(), LocalPgBackendStatus::backendStatus, BackendStatusArray, CHECK_FOR_INTERRUPTS, i, localNumBackends, MemoryContextAlloc(), MemoryContextAllocHuge(), NAMEDATALEN, NumBackendStatSlots, pgstat_begin_read_activity, pgstat_end_read_activity, pgstat_read_activity_complete, pgstat_setup_memcxt(), pgstat_track_activity_query_size, pgStatRunningInCollector, PgBackendStatus::st_activity_raw, PgBackendStatus::st_appname, PgBackendStatus::st_clienthostname, PgBackendStatus::st_gss, PgBackendStatus::st_gssstatus, PgBackendStatus::st_procpid, PgBackendStatus::st_ssl, PgBackendStatus::st_sslstatus, and unvolatize.

Referenced by pgstat_fetch_stat_beentry(), pgstat_fetch_stat_local_beentry(), and pgstat_fetch_stat_numbackends().

3349 {
3350  volatile PgBackendStatus *beentry;
3351  LocalPgBackendStatus *localtable;
3352  LocalPgBackendStatus *localentry;
3353  char *localappname,
3354  *localclienthostname,
3355  *localactivity;
3356 #ifdef USE_SSL
3357  PgBackendSSLStatus *localsslstatus;
3358 #endif
3359 #ifdef ENABLE_GSS
3360  PgBackendGSSStatus *localgssstatus;
3361 #endif
3362  int i;
3363 
3366  return; /* already done */
3367 
3369 
3370  /*
3371  * Allocate storage for local copy of state data. We can presume that
3372  * none of these requests overflow size_t, because we already calculated
3373  * the same values using mul_size during shmem setup. However, with
3374  * probably-silly values of pgstat_track_activity_query_size and
3375  * max_connections, the localactivity buffer could exceed 1GB, so use
3376  * "huge" allocation for that one.
3377  */
3378  localtable = (LocalPgBackendStatus *)
3381  localappname = (char *)
3384  localclienthostname = (char *)
3386  NAMEDATALEN * NumBackendStatSlots);
3387  localactivity = (char *)
3389  pgstat_track_activity_query_size * NumBackendStatSlots);
3390 #ifdef USE_SSL
3391  localsslstatus = (PgBackendSSLStatus *)
3394 #endif
3395 #ifdef ENABLE_GSS
3396  localgssstatus = (PgBackendGSSStatus *)
3399 #endif
3400 
3401  localNumBackends = 0;
3402 
3403  beentry = BackendStatusArray;
3404  localentry = localtable;
3405  for (i = 1; i <= NumBackendStatSlots; i++)
3406  {
3407  /*
3408  * Follow the protocol of retrying if st_changecount changes while we
3409  * copy the entry, or if it's odd. (The check for odd is needed to
3410  * cover the case where we are able to completely copy the entry while
3411  * the source backend is between increment steps.) We use a volatile
3412  * pointer here to ensure the compiler doesn't try to get cute.
3413  */
3414  for (;;)
3415  {
3416  int before_changecount;
3417  int after_changecount;
3418 
3419  pgstat_begin_read_activity(beentry, before_changecount);
3420 
3421  localentry->backendStatus.st_procpid = beentry->st_procpid;
3422  /* Skip all the data-copying work if entry is not in use */
3423  if (localentry->backendStatus.st_procpid > 0)
3424  {
3425  memcpy(&localentry->backendStatus, unvolatize(PgBackendStatus *, beentry), sizeof(PgBackendStatus));
3426 
3427  /*
3428  * For each PgBackendStatus field that is a pointer, copy the
3429  * pointed-to data, then adjust the local copy of the pointer
3430  * field to point at the local copy of the data.
3431  *
3432  * strcpy is safe even if the string is modified concurrently,
3433  * because there's always a \0 at the end of the buffer.
3434  */
3435  strcpy(localappname, (char *) beentry->st_appname);
3436  localentry->backendStatus.st_appname = localappname;
3437  strcpy(localclienthostname, (char *) beentry->st_clienthostname);
3438  localentry->backendStatus.st_clienthostname = localclienthostname;
3439  strcpy(localactivity, (char *) beentry->st_activity_raw);
3440  localentry->backendStatus.st_activity_raw = localactivity;
3441 #ifdef USE_SSL
3442  if (beentry->st_ssl)
3443  {
3444  memcpy(localsslstatus, beentry->st_sslstatus, sizeof(PgBackendSSLStatus));
3445  localentry->backendStatus.st_sslstatus = localsslstatus;
3446  }
3447 #endif
3448 #ifdef ENABLE_GSS
3449  if (beentry->st_gss)
3450  {
3451  memcpy(localgssstatus, beentry->st_gssstatus, sizeof(PgBackendGSSStatus));
3452  localentry->backendStatus.st_gssstatus = localgssstatus;
3453  }
3454 #endif
3455  }
3456 
3457  pgstat_end_read_activity(beentry, after_changecount);
3458 
3459  if (pgstat_read_activity_complete(before_changecount,
3460  after_changecount))
3461  break;
3462 
3463  /* Make sure we can break out of loop if stuck... */
3465  }
3466 
3467  beentry++;
3468  /* Only valid entries get included into the local array */
3469  if (localentry->backendStatus.st_procpid > 0)
3470  {
3472  &localentry->backend_xid,
3473  &localentry->backend_xmin);
3474 
3475  localentry++;
3476  localappname += NAMEDATALEN;
3477  localclienthostname += NAMEDATALEN;
3478  localactivity += pgstat_track_activity_query_size;
3479 #ifdef USE_SSL
3480  localsslstatus++;
3481 #endif
3482 #ifdef ENABLE_GSS
3483  localgssstatus++;
3484 #endif
3485  localNumBackends++;
3486  }
3487  }
3488 
3489  /* Set the pointer only after completion of a valid table */
3490  localBackendStatusTable = localtable;
3491 }
static PgBackendStatus * BackendStatusArray
Definition: pgstat.c:2632
static bool pgStatRunningInCollector
Definition: pgstat.c:153
TransactionId backend_xmin
Definition: pgstat.h:1187
#define NumBackendStatSlots
Definition: pgstat.c:116
char * st_clienthostname
Definition: pgstat.h:1062
#define NAMEDATALEN
TransactionId backend_xid
Definition: pgstat.h:1181
void * MemoryContextAllocHuge(MemoryContext context, Size size)
Definition: mcxt.c:1105
char * st_activity_raw
Definition: pgstat.h:1085
int pgstat_track_activity_query_size
Definition: pgstat.c:126
char * st_appname
Definition: pgstat.h:1076
#define pgstat_end_read_activity(beentry, after_changecount)
Definition: pgstat.h:1151
static void pgstat_setup_memcxt(void)
Definition: pgstat.c:5774
PgBackendStatus backendStatus
Definition: pgstat.h:1175
void BackendIdGetTransactionIds(int backendID, TransactionId *xid, TransactionId *xmin)
Definition: sinvaladt.c:403
#define Assert(condition)
Definition: c.h:739
static LocalPgBackendStatus * localBackendStatusTable
Definition: pgstat.c:245
#define pgstat_begin_read_activity(beentry, before_changecount)
Definition: pgstat.h:1145
static int localNumBackends
Definition: pgstat.c:248
#define unvolatize(underlying_type, expr)
Definition: c.h:1196
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:796
int i
static MemoryContext pgStatLocalContext
Definition: pgstat.c:241
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
PgBackendSSLStatus * st_sslstatus
Definition: pgstat.h:1066
PgBackendGSSStatus * st_gssstatus
Definition: pgstat.h:1070
#define pgstat_read_activity_complete(before_changecount, after_changecount)
Definition: pgstat.h:1157

◆ pgstat_read_db_statsfile()

static void pgstat_read_db_statsfile ( Oid  databaseid,
HTAB tabhash,
HTAB funchash,
bool  permanent 
)
static

Definition at line 5359 of file pgstat.c.

References AllocateFile(), DEBUG2, elog, ereport, errcode_for_file_access(), errmsg(), FreeFile(), PgStat_StatFuncEntry::functionid, get_dbstat_filename(), HASH_ENTER, hash_search(), LOG, MAXPGPATH, PG_BINARY_R, PGSTAT_FILE_FORMAT_ID, pgStatRunningInCollector, PgStat_StatTabEntry::tableid, and WARNING.

Referenced by pgstat_read_statsfiles().

5361 {
5362  PgStat_StatTabEntry *tabentry;
5363  PgStat_StatTabEntry tabbuf;
5364  PgStat_StatFuncEntry funcbuf;
5365  PgStat_StatFuncEntry *funcentry;
5366  FILE *fpin;
5367  int32 format_id;
5368  bool found;
5369  char statfile[MAXPGPATH];
5370 
5371  get_dbstat_filename(permanent, false, databaseid, statfile, MAXPGPATH);
5372 
5373  /*
5374  * Try to open the stats file. If it doesn't exist, the backends simply
5375  * return zero for anything and the collector simply starts from scratch
5376  * with empty counters.
5377  *
5378  * ENOENT is a possibility if the stats collector is not running or has
5379  * not yet written the stats file the first time. Any other failure
5380  * condition is suspicious.
5381  */
5382  if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
5383  {
5384  if (errno != ENOENT)
5387  errmsg("could not open statistics file \"%s\": %m",
5388  statfile)));
5389  return;
5390  }
5391 
5392  /*
5393  * Verify it's of the expected format.
5394  */
5395  if (fread(&format_id, 1, sizeof(format_id), fpin) != sizeof(format_id) ||
5396  format_id != PGSTAT_FILE_FORMAT_ID)
5397  {
5398  ereport(pgStatRunningInCollector ? LOG : WARNING,
5399  (errmsg("corrupted statistics file \"%s\"", statfile)));
5400  goto done;
5401  }
5402 
5403  /*
5404  * We found an existing collector stats file. Read it and put all the
5405  * hashtable entries into place.
5406  */
5407  for (;;)
5408  {
5409  switch (fgetc(fpin))
5410  {
5411  /*
5412  * 'T' A PgStat_StatTabEntry follows.
5413  */
5414  case 'T':
5415  if (fread(&tabbuf, 1, sizeof(PgStat_StatTabEntry),
5416  fpin) != sizeof(PgStat_StatTabEntry))
5417  {
5418  ereport(pgStatRunningInCollector ? LOG : WARNING,
5419  (errmsg("corrupted statistics file \"%s\"",
5420  statfile)));
5421  goto done;
5422  }
5423 
5424  /*
5425  * Skip if table data not wanted.
5426  */
5427  if (tabhash == NULL)
5428  break;
5429 
5430  tabentry = (PgStat_StatTabEntry *) hash_search(tabhash,
5431  (void *) &tabbuf.tableid,
5432  HASH_ENTER, &found);
5433 
5434  if (found)
5435  {
5436  ereport(pgStatRunningInCollector ? LOG : WARNING,
5437  (errmsg("corrupted statistics file \"%s\"",
5438  statfile)));
5439  goto done;
5440  }
5441 
5442  memcpy(tabentry, &tabbuf, sizeof(tabbuf));
5443  break;
5444 
5445  /*
5446  * 'F' A PgStat_StatFuncEntry follows.
5447  */
5448  case 'F':
5449  if (fread(&funcbuf, 1, sizeof(PgStat_StatFuncEntry),
5450  fpin) != sizeof(PgStat_StatFuncEntry))
5451  {
5452  ereport(pgStatRunningInCollector ? LOG : WARNING,
5453  (errmsg("corrupted statistics file \"%s\"",
5454  statfile)));
5455  goto done;
5456  }
5457 
5458  /*
5459  * Skip if function data not wanted.
5460  */
5461  if (funchash == NULL)
5462  break;
5463 
5464  funcentry = (PgStat_StatFuncEntry *) hash_search(funchash,
5465  (void *) &funcbuf.functionid,
5466  HASH_ENTER, &found);
5467 
5468  if (found)
5469  {
5470  ereport(pgStatRunningInCollector ? LOG : WARNING,
5471  (errmsg("corrupted statistics file \"%s\"",
5472  statfile)));
5473  goto done;
5474  }
5475 
5476  memcpy(funcentry, &funcbuf, sizeof(funcbuf));
5477  break;
5478 
5479  /*
5480  * 'E' The EOF marker of a complete stats file.
5481  */
5482  case 'E':
5483  goto done;
5484 
5485  default:
5486  ereport(pgStatRunningInCollector ? LOG : WARNING,
5487  (errmsg("corrupted statistics file \"%s\"",
5488  statfile)));
5489  goto done;
5490  }
5491  }
5492 
5493 done:
5494  FreeFile(fpin);
5495 
5496  if (permanent)
5497  {
5498  elog(DEBUG2, "removing permanent stats file \"%s\"", statfile);
5499  unlink(statfile);
5500  }
5501 }
static bool pgStatRunningInCollector
Definition: pgstat.c:153
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
#define LOG
Definition: elog.h:26
#define PG_BINARY_R
Definition: c.h:1224
signed int int32
Definition: c.h:347
#define MAXPGPATH
#define DEBUG2
Definition: elog.h:24
int errcode_for_file_access(void)
Definition: elog.c:631
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2242
#define ereport(elevel, rest)
Definition: elog.h:141
#define WARNING
Definition: elog.h:40
int FreeFile(FILE *file)
Definition: fd.c:2441
#define PGSTAT_FILE_FORMAT_ID
Definition: pgstat.h:584
int errmsg(const char *fmt,...)
Definition: elog.c:822
#define elog(elevel,...)
Definition: elog.h:228
static void get_dbstat_filename(bool permanent, bool tempname, Oid databaseid, char *filename, int len)
Definition: pgstat.c:4978

◆ pgstat_read_db_statsfile_timestamp()

static bool pgstat_read_db_statsfile_timestamp ( Oid  databaseid,
bool  permanent,
TimestampTz ts 
)
static

Definition at line 5521 of file pgstat.c.

References AllocateFile(), PgStat_StatDBEntry::databaseid, ereport, errcode_for_file_access(), errmsg(), FreeFile(), LOG, offsetof, PG_BINARY_R, PGSTAT_FILE_FORMAT_ID, pgstat_stat_filename, PGSTAT_STAT_PERMANENT_FILENAME, pgStatRunningInCollector, PgStat_StatDBEntry::stats_timestamp, PgStat_GlobalStats::stats_timestamp, and WARNING.

Referenced by backend_read_statsfile().

5523 {
5524  PgStat_StatDBEntry dbentry;
5525  PgStat_GlobalStats myGlobalStats;
5526  PgStat_ArchiverStats myArchiverStats;
5527  FILE *fpin;
5528  int32 format_id;
5529  const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
5530 
5531  /*
5532  * Try to open the stats file. As above, anything but ENOENT is worthy of
5533  * complaining about.
5534  */
5535  if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
5536  {
5537  if (errno != ENOENT)
5540  errmsg("could not open statistics file \"%s\": %m",
5541  statfile)));
5542  return false;
5543  }
5544 
5545  /*
5546  * Verify it's of the expected format.
5547  */
5548  if (fread(&format_id, 1, sizeof(format_id), fpin) != sizeof(format_id) ||
5549  format_id !=