From: Andres Freund <andres@anarazel.de>
To: Magnus Hagander <magnus@hagander.net>
Cc: Kyotaro Horiguchi <horikyota.ntt@gmail.com>
Cc: Fujii Masao <masao.fujii@oss.nttdata.com>
Cc: Georgios <gkokolatos@protonmail.com>
Cc: PostgreSQL Developers <pgsql-hackers@lists.postgresql.org>
Subject: Re: shared-memory based stats collector
Date: Mon, 15 Mar 2021 19:55:41 -0700
Message-ID: <20210316025541.rjddr2djzfekga4d@alap3.anarazel.de> (raw)
In-Reply-To: <20210316020429.rkv3tchhqwozqm7k@alap3.anarazel.de>
References: <894e5991-f7b5-43b5-aece-7175221e60ca@oss.nttdata.com>
<20210310.121039.688166089593842711.horikyota.ntt@gmail.com>
<b36a7e0f-f4c7-51f5-497c-02e14213553e@oss.nttdata.com>
<20210310.175137.77410390117009989.horikyota.ntt@gmail.com>
<20210311042656.ofxeibs7z2btdcgx@alap3.anarazel.de>
<20210312032257.zf2rdoruthxgnpwv@alap3.anarazel.de>
<20210313062040.sbw7yzvgftu6za5t@alap3.anarazel.de>
<CABUevEw49ESGX0gf1xqBqJgt76OkiVuZRQD0G1Cy58Nhv=txUA@mail.gmail.com>
<20210313180521.djybq456f3tpbc2r@alap3.anarazel.de>
<20210316020429.rkv3tchhqwozqm7k@alap3.anarazel.de>
Hi,
On 2021-03-15 19:04:29 -0700, Andres Freund wrote:
> On 2021-03-13 10:05:21 -0800, Andres Freund wrote:
> > Cool. I'll give it a try.
Ooops, I was intending to write a bit about my attempt at that:
I did roughly the first steps of the split as I had outlined. I moved:
1) wait event related functions into utils/activity/wait_event.c /
wait_event.h
2) "backend status" functionality (PgBackendStatus stuff) into
utils/activity/backend_status.c
3) "progress" related functionality into
utils/activity/backend_progress.c
I think 1 and 2 are good (albeit in need of further polish). I'm a bit
less sure about 3:
- There's dependency from backend_status.h to backend_progress.h,
because it PGSTAT_NUM_PROGRESS_PARAM etc.
- it's a fairly small amount of code
- there's potential for confusion, because there's also
include/commands/progress.h
On balance I think 3) is probably worth it, but I'm far from confident.
Happy to bikeshed about the names for a moment...
Questions / Points:
- I'm inclined to leave pgstat_report_{activity, tmpfile, appname,
timestamp, ..} alone naming-wise, but to rename pgstat_bestart() to
something like pgbestat_start()?
- I've not gone through all the files that could now remove pgstat.h,
replacing it with wait_event.h - I'm thinking it might be worth
waiting till just after code freeze with that (there'll new additions,
and it's likely to cause conflicts)?
- backend_status.h needs miscadmin.h, due to BackendType. Imo that's a
header we should try to avoid exposing in headers if possible. But
right now there's no good place to move BackendType to. So I'd let
this slide for now.
On 2021-03-15 19:04:29 -0700, Andres Freund wrote:
> I have a few questions about the patch:
> - Why was collect_oids() changed to a different hashtable as part of
> this change? Seems fairly independent?
>
> - What's the point of all those cached_* stuff? There's not a single
> comment explaining it as far as I can tell...
>
> Several of them are never used as a cache! E.g. cached_archiverstats,
> cached_bgwriterstats, ...
>
> - What is the idea behind pgstat_reset_shared_counters() using
> pgstat_copy_global_stats() to reset, using StatsShmem->*_reset_offset?
> But then still taking a lock in pgstat_fetch_stat_*? Again, no
> comments explaining what the goal is.
>
> It kinda looks like you tried to make both read and write paths not
> use the lock, but then ended up using a lock?
>
>
> Do you have some benchmarks that you used to verify performance?
>
>
> I think I'm going to try to split the storage of fixed-size stats in
> StatsShmemStruct into a separate patch. That's already a pretty large
> change, and it's pretty much unrelated to the rest.
Some more:
- pgstat_vacuum_stat() talks about using three phases, one with only a
shared lock. That doesn't seem to exist (anymore)?
- WAIT_EVENT_PGSTAT_MAIN was renamed to WAIT_EVENT_READING_STATS_FILE. I
assume that was intended to be used in pgstat_read_statsfile(),
pgstat_write_statsfile()? Not sure there's much point in adding it,
because at that stage nobody can observe wait events anyway...
- There are a lot of diffs like
@@ -1267,7 +1264,7 @@ pg_stat_get_db_xact_commit(PG_FUNCTION_ARGS)
if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)
result = 0;
else
- result = (int64) (dbentry->n_xact_commit);
+ result = (int64) (dbentry->counts.n_xact_commit);
PG_RETURN_INT64(result);
}
I wonder if we should instead just return *entry->counts from
pgstat_fetch_stat_* (adjusting the names). There's as far as I can
tell never a reason for pgstatfuncs.c (and others if there are) to
need the remaining members? That'd could the patch down a lot I
think?
What's especially nice is that afterwards PgStat_StatEntryHeader
wouldn't need to be exposed anymore, and in turn, atomic.h wouldn't
need to be included anymore.
- pgstat.h had dshash_table_handle members in PgStat_StatDBEntry, I
assume those were leftovers from an older version, not something you
forsee needing?
- There's a pretty weird change in relcache.c:
+ /* break mutual link with stats entry */
+ pgstat_delinkstats(relation);
+
+ if (relation->rd_rel)
did you add that if intentionally?
- Is there any reason to treat PgStat_ReplSlot as something of a dynamic
number, instead of just having a fixed number of slots in
StatsShmemStruct? The GUC can't change without a restart...
Greetings,
Andres Freund
Attachments:download all (3 files, .tar.gz)v1-0001-pgstat.h-doesn-t-need-hsearch.h.patch (text/x-diff, 623B) download
From 6ca129106d0fd949672d0d7de1f92b879bf535d1 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Mon, 15 Mar 2021 14:49:08 -0700
Subject: [PATCH v1 01/21] pgstat.h doesn't need hsearch.h
---
src/include/pgstat.h | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/include/pgstat.h b/src/include/pgstat.hindex be43c048028..5ce86ba9ae8 100644--- a/src/include/pgstat.h+++ b/src/include/pgstat.h@@ -18,7 +18,6 @@
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
#include "storage/proc.h"
-#include "utils/hsearch.h"
#include "utils/relcache.h"
--
2.29.2.540.g3cf59784d4
v1-0002-WIP-Split-wait-event-reporting-into-its-own-heade.patch (text/x-diff, 55.2K) download
From 51f089a033cc772f995f06370b38b59f93456bd7 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Mon, 15 Mar 2021 14:49:35 -0700
Subject: [PATCH v1 02/21] WIP: Split wait event reporting into its own header.
---
src/include/pgstat.h | 273 +---------
src/include/utils/wait_event.h | 301 +++++++++++
src/backend/postmaster/pgstat.c | 669 -----------------------
src/backend/utils/Makefile | 15 +-
src/backend/utils/activity/Makefile | 19 +
src/backend/utils/activity/wait_event.c | 685 ++++++++++++++++++++++++
6 files changed, 1020 insertions(+), 942 deletions(-)
create mode 100644 src/include/utils/wait_event.h
create mode 100644 src/backend/utils/activity/Makefile
create mode 100644 src/backend/utils/activity/wait_event.c
diff --git a/src/include/pgstat.h b/src/include/pgstat.hindex 5ce86ba9ae8..c2b18c6b08d 100644--- a/src/include/pgstat.h+++ b/src/include/pgstat.h@@ -17,8 +17,8 @@
#include "port/atomics.h"
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
-#include "storage/proc.h"
#include "utils/relcache.h"
+#include "utils/wait_event.h" /* for backward compatibility */
/* ----------
@@ -896,221 +896,6 @@ typedef enum BackendState
STATE_DISABLED
} BackendState;
--/* ----------- * Wait Classes- * ----------- */-#define PG_WAIT_LWLOCK 0x01000000U-#define PG_WAIT_LOCK 0x03000000U-#define PG_WAIT_BUFFER_PIN 0x04000000U-#define PG_WAIT_ACTIVITY 0x05000000U-#define PG_WAIT_CLIENT 0x06000000U-#define PG_WAIT_EXTENSION 0x07000000U-#define PG_WAIT_IPC 0x08000000U-#define PG_WAIT_TIMEOUT 0x09000000U-#define PG_WAIT_IO 0x0A000000U--/* ----------- * Wait Events - Activity- *- * Use this category when a process is waiting because it has no work to do,- * unless the "Client" or "Timeout" category describes the situation better.- * Typically, this should only be used for background processes.- * ----------- */-typedef enum-{- WAIT_EVENT_ARCHIVER_MAIN = PG_WAIT_ACTIVITY,- WAIT_EVENT_AUTOVACUUM_MAIN,- WAIT_EVENT_BGWRITER_HIBERNATE,- WAIT_EVENT_BGWRITER_MAIN,- WAIT_EVENT_CHECKPOINTER_MAIN,- WAIT_EVENT_LOGICAL_APPLY_MAIN,- WAIT_EVENT_LOGICAL_LAUNCHER_MAIN,- WAIT_EVENT_PGSTAT_MAIN,- WAIT_EVENT_RECOVERY_WAL_STREAM,- WAIT_EVENT_SYSLOGGER_MAIN,- WAIT_EVENT_WAL_RECEIVER_MAIN,- WAIT_EVENT_WAL_SENDER_MAIN,- WAIT_EVENT_WAL_WRITER_MAIN-} WaitEventActivity;--/* ----------- * Wait Events - Client- *- * Use this category when a process is waiting to send data to or receive data- * from the frontend process to which it is connected. This is never used for- * a background process, which has no client connection.- * ----------- */-typedef enum-{- WAIT_EVENT_CLIENT_READ = PG_WAIT_CLIENT,- 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,- WAIT_EVENT_WAL_SENDER_WRITE_DATA,-} WaitEventClient;--/* ----------- * Wait Events - IPC- *- * Use this category when a process cannot complete the work it is doing because- * it is waiting for a notification from another process.- * ----------- */-typedef enum-{- WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE = PG_WAIT_IPC,- WAIT_EVENT_BGWORKER_SHUTDOWN,- WAIT_EVENT_BGWORKER_STARTUP,- WAIT_EVENT_BTREE_PAGE,- WAIT_EVENT_BUFFER_IO,- WAIT_EVENT_CHECKPOINT_DONE,- WAIT_EVENT_CHECKPOINT_START,- WAIT_EVENT_EXECUTE_GATHER,- WAIT_EVENT_HASH_BATCH_ALLOCATE,- WAIT_EVENT_HASH_BATCH_ELECT,- WAIT_EVENT_HASH_BATCH_LOAD,- WAIT_EVENT_HASH_BUILD_ALLOCATE,- WAIT_EVENT_HASH_BUILD_ELECT,- WAIT_EVENT_HASH_BUILD_HASH_INNER,- WAIT_EVENT_HASH_BUILD_HASH_OUTER,- WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATE,- WAIT_EVENT_HASH_GROW_BATCHES_DECIDE,- WAIT_EVENT_HASH_GROW_BATCHES_ELECT,- WAIT_EVENT_HASH_GROW_BATCHES_FINISH,- WAIT_EVENT_HASH_GROW_BATCHES_REPARTITION,- WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATE,- WAIT_EVENT_HASH_GROW_BUCKETS_ELECT,- WAIT_EVENT_HASH_GROW_BUCKETS_REINSERT,- 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_PROC_SIGNAL_BARRIER,- WAIT_EVENT_PROMOTE,- WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT,- WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE,- WAIT_EVENT_RECOVERY_PAUSE,- WAIT_EVENT_REPLICATION_ORIGIN_DROP,- WAIT_EVENT_REPLICATION_SLOT_DROP,- WAIT_EVENT_SAFE_SNAPSHOT,- WAIT_EVENT_SYNC_REP,- WAIT_EVENT_WALRCV_EXIT,- WAIT_EVENT_XACT_GROUP_UPDATE-} WaitEventIPC;--/* ----------- * Wait Events - Timeout- *- * Use this category when a process is waiting for a timeout to expire.- * ----------- */-typedef enum-{- WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT,- WAIT_EVENT_PG_SLEEP,- WAIT_EVENT_RECOVERY_APPLY_DELAY,- WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL,- WAIT_EVENT_VACUUM_DELAY-} WaitEventTimeout;--/* ----------- * Wait Events - IO- *- * Use this category when a process is waiting for a IO.- * ----------- */-typedef enum-{- WAIT_EVENT_BASEBACKUP_READ = PG_WAIT_IO,- WAIT_EVENT_BUFFILE_READ,- WAIT_EVENT_BUFFILE_WRITE,- WAIT_EVENT_BUFFILE_TRUNCATE,- WAIT_EVENT_CONTROL_FILE_READ,- WAIT_EVENT_CONTROL_FILE_SYNC,- WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE,- WAIT_EVENT_CONTROL_FILE_WRITE,- WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE,- WAIT_EVENT_COPY_FILE_READ,- WAIT_EVENT_COPY_FILE_WRITE,- WAIT_EVENT_DATA_FILE_EXTEND,- WAIT_EVENT_DATA_FILE_FLUSH,- WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC,- WAIT_EVENT_DATA_FILE_PREFETCH,- WAIT_EVENT_DATA_FILE_READ,- WAIT_EVENT_DATA_FILE_SYNC,- WAIT_EVENT_DATA_FILE_TRUNCATE,- WAIT_EVENT_DATA_FILE_WRITE,- WAIT_EVENT_DSM_FILL_ZERO_WRITE,- WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ,- WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC,- WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE,- WAIT_EVENT_LOCK_FILE_CREATE_READ,- WAIT_EVENT_LOCK_FILE_CREATE_SYNC,- WAIT_EVENT_LOCK_FILE_CREATE_WRITE,- WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ,- WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC,- WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC,- WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE,- WAIT_EVENT_LOGICAL_REWRITE_SYNC,- WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE,- WAIT_EVENT_LOGICAL_REWRITE_WRITE,- WAIT_EVENT_RELATION_MAP_READ,- WAIT_EVENT_RELATION_MAP_SYNC,- WAIT_EVENT_RELATION_MAP_WRITE,- WAIT_EVENT_REORDER_BUFFER_READ,- WAIT_EVENT_REORDER_BUFFER_WRITE,- WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ,- WAIT_EVENT_REPLICATION_SLOT_READ,- WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC,- WAIT_EVENT_REPLICATION_SLOT_SYNC,- WAIT_EVENT_REPLICATION_SLOT_WRITE,- WAIT_EVENT_SLRU_FLUSH_SYNC,- WAIT_EVENT_SLRU_READ,- WAIT_EVENT_SLRU_SYNC,- WAIT_EVENT_SLRU_WRITE,- WAIT_EVENT_SNAPBUILD_READ,- WAIT_EVENT_SNAPBUILD_SYNC,- WAIT_EVENT_SNAPBUILD_WRITE,- WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC,- WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE,- WAIT_EVENT_TIMELINE_HISTORY_READ,- WAIT_EVENT_TIMELINE_HISTORY_SYNC,- WAIT_EVENT_TIMELINE_HISTORY_WRITE,- WAIT_EVENT_TWOPHASE_FILE_READ,- WAIT_EVENT_TWOPHASE_FILE_SYNC,- WAIT_EVENT_TWOPHASE_FILE_WRITE,- WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ,- WAIT_EVENT_WAL_BOOTSTRAP_SYNC,- WAIT_EVENT_WAL_BOOTSTRAP_WRITE,- WAIT_EVENT_WAL_COPY_READ,- WAIT_EVENT_WAL_COPY_SYNC,- WAIT_EVENT_WAL_COPY_WRITE,- WAIT_EVENT_WAL_INIT_SYNC,- WAIT_EVENT_WAL_INIT_WRITE,- WAIT_EVENT_WAL_READ,- WAIT_EVENT_WAL_SYNC,- WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN,- WAIT_EVENT_WAL_WRITE,- WAIT_EVENT_LOGICAL_CHANGES_READ,- WAIT_EVENT_LOGICAL_CHANGES_WRITE,- WAIT_EVENT_LOGICAL_SUBXACT_READ,- WAIT_EVENT_LOGICAL_SUBXACT_WRITE-} WaitEventIO;-
/* ----------
* Command type for progress reporting purposes
* ----------
@@ -1459,8 +1244,6 @@ extern void pgstat_report_activity(BackendState state, const char *cmd_str);
extern void pgstat_report_tempfile(size_t filesize);
extern void pgstat_report_appname(const char *appname);
extern void pgstat_report_xact_timestamp(TimestampTz tstamp);
-extern const char *pgstat_get_wait_event(uint32 wait_event_info);-extern const char *pgstat_get_wait_event_type(uint32 wait_event_info);
extern const char *pgstat_get_backend_current_activity(int pid, bool checkUser);
extern const char *pgstat_get_crashed_backend_activity(int pid, char *buffer,
int buflen);
@@ -1479,60 +1262,6 @@ extern void pgstat_initstats(Relation rel);
extern char *pgstat_clip_activity(const char *raw_activity);
-/* ----------- * pgstat_report_wait_start() -- *- * Called from places where server process needs to wait. This is called- * to report wait event information. The wait information is stored- * as 4-bytes where first byte represents the wait event class (type of- * wait, for different types of wait, refer WaitClass) and the next- * 3-bytes represent the actual wait event. Currently 2-bytes are used- * for wait event which is sufficient for current usage, 1-byte is- * reserved for future usage.- *- * NB: this *must* be able to survive being called before MyProc has been- * initialized.- * ----------- */-static inline void-pgstat_report_wait_start(uint32 wait_event_info)-{- volatile PGPROC *proc = MyProc;-- if (!pgstat_track_activities || !proc)- return;-- /*- * Since this is a four-byte field which is always read and written as- * four-bytes, updates are atomic.- */- proc->wait_event_info = wait_event_info;-}--/* ----------- * pgstat_report_wait_end() -- *- * Called to report end of a wait.- *- * NB: this *must* be able to survive being called before MyProc has been- * initialized.- * ----------- */-static inline void-pgstat_report_wait_end(void)-{- volatile PGPROC *proc = MyProc;-- if (!pgstat_track_activities || !proc)- return;-- /*- * Since this is a four-byte field which is always read and written as- * four-bytes, updates are atomic.- */- proc->wait_event_info = 0;-}-
/* nontransactional event counts are simple enough to inline */
#define pgstat_count_heap_scan(rel) \
diff --git a/src/include/utils/wait_event.h b/src/include/utils/wait_event.hnew file mode 100644index 00000000000..1bff882b756--- /dev/null+++ b/src/include/utils/wait_event.h@@ -0,0 +1,301 @@+/* ----------+ * wait_event.h+ *+ * Definitions related to postgres wait event reporting+ *+ * Copyright (c) 2001-2021, PostgreSQL Global Development Group+ *+ * src/include/utils/wait_event.h+ * ----------+ */+#ifndef WAIT_EVENT_H+#define WAIT_EVENT_H+++#include "storage/proc.h" /* for MyProc */+++/* ----------+ * Wait Classes+ * ----------+ */+#define PG_WAIT_LWLOCK 0x01000000U+#define PG_WAIT_LOCK 0x03000000U+#define PG_WAIT_BUFFER_PIN 0x04000000U+#define PG_WAIT_ACTIVITY 0x05000000U+#define PG_WAIT_CLIENT 0x06000000U+#define PG_WAIT_EXTENSION 0x07000000U+#define PG_WAIT_IPC 0x08000000U+#define PG_WAIT_TIMEOUT 0x09000000U+#define PG_WAIT_IO 0x0A000000U++/* ----------+ * Wait Events - Activity+ *+ * Use this category when a process is waiting because it has no work to do,+ * unless the "Client" or "Timeout" category describes the situation better.+ * Typically, this should only be used for background processes.+ * ----------+ */+typedef enum+{+ WAIT_EVENT_ARCHIVER_MAIN = PG_WAIT_ACTIVITY,+ WAIT_EVENT_AUTOVACUUM_MAIN,+ WAIT_EVENT_BGWRITER_HIBERNATE,+ WAIT_EVENT_BGWRITER_MAIN,+ WAIT_EVENT_CHECKPOINTER_MAIN,+ WAIT_EVENT_LOGICAL_APPLY_MAIN,+ WAIT_EVENT_LOGICAL_LAUNCHER_MAIN,+ WAIT_EVENT_PGSTAT_MAIN,+ WAIT_EVENT_RECOVERY_WAL_STREAM,+ WAIT_EVENT_SYSLOGGER_MAIN,+ WAIT_EVENT_WAL_RECEIVER_MAIN,+ WAIT_EVENT_WAL_SENDER_MAIN,+ WAIT_EVENT_WAL_WRITER_MAIN+} WaitEventActivity;++/* ----------+ * Wait Events - Client+ *+ * Use this category when a process is waiting to send data to or receive data+ * from the frontend process to which it is connected. This is never used for+ * a background process, which has no client connection.+ * ----------+ */+typedef enum+{+ WAIT_EVENT_CLIENT_READ = PG_WAIT_CLIENT,+ 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,+ WAIT_EVENT_WAL_SENDER_WRITE_DATA,+} WaitEventClient;++/* ----------+ * Wait Events - IPC+ *+ * Use this category when a process cannot complete the work it is doing because+ * it is waiting for a notification from another process.+ * ----------+ */+typedef enum+{+ WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE = PG_WAIT_IPC,+ WAIT_EVENT_BGWORKER_SHUTDOWN,+ WAIT_EVENT_BGWORKER_STARTUP,+ WAIT_EVENT_BTREE_PAGE,+ WAIT_EVENT_BUFFER_IO,+ WAIT_EVENT_CHECKPOINT_DONE,+ WAIT_EVENT_CHECKPOINT_START,+ WAIT_EVENT_EXECUTE_GATHER,+ WAIT_EVENT_HASH_BATCH_ALLOCATE,+ WAIT_EVENT_HASH_BATCH_ELECT,+ WAIT_EVENT_HASH_BATCH_LOAD,+ WAIT_EVENT_HASH_BUILD_ALLOCATE,+ WAIT_EVENT_HASH_BUILD_ELECT,+ WAIT_EVENT_HASH_BUILD_HASH_INNER,+ WAIT_EVENT_HASH_BUILD_HASH_OUTER,+ WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATE,+ WAIT_EVENT_HASH_GROW_BATCHES_DECIDE,+ WAIT_EVENT_HASH_GROW_BATCHES_ELECT,+ WAIT_EVENT_HASH_GROW_BATCHES_FINISH,+ WAIT_EVENT_HASH_GROW_BATCHES_REPARTITION,+ WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATE,+ WAIT_EVENT_HASH_GROW_BUCKETS_ELECT,+ WAIT_EVENT_HASH_GROW_BUCKETS_REINSERT,+ 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_PROC_SIGNAL_BARRIER,+ WAIT_EVENT_PROMOTE,+ WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT,+ WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE,+ WAIT_EVENT_RECOVERY_PAUSE,+ WAIT_EVENT_REPLICATION_ORIGIN_DROP,+ WAIT_EVENT_REPLICATION_SLOT_DROP,+ WAIT_EVENT_SAFE_SNAPSHOT,+ WAIT_EVENT_SYNC_REP,+ WAIT_EVENT_WALRCV_EXIT,+ WAIT_EVENT_XACT_GROUP_UPDATE+} WaitEventIPC;++/* ----------+ * Wait Events - Timeout+ *+ * Use this category when a process is waiting for a timeout to expire.+ * ----------+ */+typedef enum+{+ WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT,+ WAIT_EVENT_PG_SLEEP,+ WAIT_EVENT_RECOVERY_APPLY_DELAY,+ WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL,+ WAIT_EVENT_VACUUM_DELAY+} WaitEventTimeout;++/* ----------+ * Wait Events - IO+ *+ * Use this category when a process is waiting for a IO.+ * ----------+ */+typedef enum+{+ WAIT_EVENT_BASEBACKUP_READ = PG_WAIT_IO,+ WAIT_EVENT_BUFFILE_READ,+ WAIT_EVENT_BUFFILE_WRITE,+ WAIT_EVENT_BUFFILE_TRUNCATE,+ WAIT_EVENT_CONTROL_FILE_READ,+ WAIT_EVENT_CONTROL_FILE_SYNC,+ WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE,+ WAIT_EVENT_CONTROL_FILE_WRITE,+ WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE,+ WAIT_EVENT_COPY_FILE_READ,+ WAIT_EVENT_COPY_FILE_WRITE,+ WAIT_EVENT_DATA_FILE_EXTEND,+ WAIT_EVENT_DATA_FILE_FLUSH,+ WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC,+ WAIT_EVENT_DATA_FILE_PREFETCH,+ WAIT_EVENT_DATA_FILE_READ,+ WAIT_EVENT_DATA_FILE_SYNC,+ WAIT_EVENT_DATA_FILE_TRUNCATE,+ WAIT_EVENT_DATA_FILE_WRITE,+ WAIT_EVENT_DSM_FILL_ZERO_WRITE,+ WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ,+ WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC,+ WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE,+ WAIT_EVENT_LOCK_FILE_CREATE_READ,+ WAIT_EVENT_LOCK_FILE_CREATE_SYNC,+ WAIT_EVENT_LOCK_FILE_CREATE_WRITE,+ WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ,+ WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC,+ WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC,+ WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE,+ WAIT_EVENT_LOGICAL_REWRITE_SYNC,+ WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE,+ WAIT_EVENT_LOGICAL_REWRITE_WRITE,+ WAIT_EVENT_RELATION_MAP_READ,+ WAIT_EVENT_RELATION_MAP_SYNC,+ WAIT_EVENT_RELATION_MAP_WRITE,+ WAIT_EVENT_REORDER_BUFFER_READ,+ WAIT_EVENT_REORDER_BUFFER_WRITE,+ WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ,+ WAIT_EVENT_REPLICATION_SLOT_READ,+ WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC,+ WAIT_EVENT_REPLICATION_SLOT_SYNC,+ WAIT_EVENT_REPLICATION_SLOT_WRITE,+ WAIT_EVENT_SLRU_FLUSH_SYNC,+ WAIT_EVENT_SLRU_READ,+ WAIT_EVENT_SLRU_SYNC,+ WAIT_EVENT_SLRU_WRITE,+ WAIT_EVENT_SNAPBUILD_READ,+ WAIT_EVENT_SNAPBUILD_SYNC,+ WAIT_EVENT_SNAPBUILD_WRITE,+ WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC,+ WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE,+ WAIT_EVENT_TIMELINE_HISTORY_READ,+ WAIT_EVENT_TIMELINE_HISTORY_SYNC,+ WAIT_EVENT_TIMELINE_HISTORY_WRITE,+ WAIT_EVENT_TWOPHASE_FILE_READ,+ WAIT_EVENT_TWOPHASE_FILE_SYNC,+ WAIT_EVENT_TWOPHASE_FILE_WRITE,+ WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ,+ WAIT_EVENT_WAL_BOOTSTRAP_SYNC,+ WAIT_EVENT_WAL_BOOTSTRAP_WRITE,+ WAIT_EVENT_WAL_COPY_READ,+ WAIT_EVENT_WAL_COPY_SYNC,+ WAIT_EVENT_WAL_COPY_WRITE,+ WAIT_EVENT_WAL_INIT_SYNC,+ WAIT_EVENT_WAL_INIT_WRITE,+ WAIT_EVENT_WAL_READ,+ WAIT_EVENT_WAL_SYNC,+ WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN,+ WAIT_EVENT_WAL_WRITE,+ WAIT_EVENT_LOGICAL_CHANGES_READ,+ WAIT_EVENT_LOGICAL_CHANGES_WRITE,+ WAIT_EVENT_LOGICAL_SUBXACT_READ,+ WAIT_EVENT_LOGICAL_SUBXACT_WRITE+} WaitEventIO;+++extern const char *pgstat_get_wait_event(uint32 wait_event_info);+extern const char *pgstat_get_wait_event_type(uint32 wait_event_info);+static inline void pgstat_report_wait_start(uint32 wait_event_info);+static inline void pgstat_report_wait_end(void);+++/*+ * Repeated here for the inline functions because it is declared in pgstat.h,+ * which includes this header.+ */+extern PGDLLIMPORT bool pgstat_track_activities;+++/* ----------+ * pgstat_report_wait_start() -+ *+ * Called from places where server process needs to wait. This is called+ * to report wait event information. The wait information is stored+ * as 4-bytes where first byte represents the wait event class (type of+ * wait, for different types of wait, refer WaitClass) and the next+ * 3-bytes represent the actual wait event. Currently 2-bytes are used+ * for wait event which is sufficient for current usage, 1-byte is+ * reserved for future usage.+ *+ * NB: this *must* be able to survive being called before MyProc has been+ * initialized.+ * ----------+ */+static inline void+pgstat_report_wait_start(uint32 wait_event_info)+{+ volatile PGPROC *proc = MyProc;++ if (!pgstat_track_activities || !proc)+ return;++ /*+ * Since this is a four-byte field which is always read and written as+ * four-bytes, updates are atomic.+ */+ proc->wait_event_info = wait_event_info;+}++/* ----------+ * pgstat_report_wait_end() -+ *+ * Called to report end of a wait.+ *+ * NB: this *must* be able to survive being called before MyProc has been+ * initialized.+ * ----------+ */+static inline void+pgstat_report_wait_end(void)+{+ volatile PGPROC *proc = MyProc;++ if (!pgstat_track_activities || !proc)+ return;++ /*+ * Since this is a four-byte field which is always read and written as+ * four-bytes, updates are atomic.+ */+ proc->wait_event_info = 0;+}+++#endif /* WAIT_EVENT_H */diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.cindex b1e2d94951d..b2e03b92432 100644--- a/src/backend/postmaster/pgstat.c+++ b/src/backend/postmaster/pgstat.c@@ -352,12 +352,6 @@ static PgStat_TableStatus *get_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);
@@ -3749,669 +3743,6 @@ pgstat_read_current_status(void)
localBackendStatusTable = localtable;
}
-/* ----------- * pgstat_get_wait_event_type() -- *- * Return a string representing the current wait event type, backend is- * waiting on.- */-const char *-pgstat_get_wait_event_type(uint32 wait_event_info)-{- uint32 classId;- const char *event_type;-- /* report process as not waiting. */- if (wait_event_info == 0)- return NULL;-- classId = wait_event_info & 0xFF000000;-- switch (classId)- {- case PG_WAIT_LWLOCK:- event_type = "LWLock";- break;- case PG_WAIT_LOCK:- event_type = "Lock";- break;- case PG_WAIT_BUFFER_PIN:- event_type = "BufferPin";- break;- case PG_WAIT_ACTIVITY:- event_type = "Activity";- break;- case PG_WAIT_CLIENT:- event_type = "Client";- break;- case PG_WAIT_EXTENSION:- event_type = "Extension";- break;- case PG_WAIT_IPC:- event_type = "IPC";- break;- case PG_WAIT_TIMEOUT:- event_type = "Timeout";- break;- case PG_WAIT_IO:- event_type = "IO";- break;- default:- event_type = "???";- break;- }-- return event_type;-}--/* ----------- * pgstat_get_wait_event() -- *- * Return a string representing the current wait event, backend is- * waiting on.- */-const char *-pgstat_get_wait_event(uint32 wait_event_info)-{- uint32 classId;- uint16 eventId;- const char *event_name;-- /* report process as not waiting. */- if (wait_event_info == 0)- return NULL;-- classId = wait_event_info & 0xFF000000;- eventId = wait_event_info & 0x0000FFFF;-- switch (classId)- {- case PG_WAIT_LWLOCK:- event_name = GetLWLockIdentifier(classId, eventId);- break;- case PG_WAIT_LOCK:- event_name = GetLockNameFromTagType(eventId);- break;- case PG_WAIT_BUFFER_PIN:- event_name = "BufferPin";- break;- case PG_WAIT_ACTIVITY:- {- WaitEventActivity w = (WaitEventActivity) wait_event_info;-- event_name = pgstat_get_wait_activity(w);- break;- }- case PG_WAIT_CLIENT:- {- WaitEventClient w = (WaitEventClient) wait_event_info;-- event_name = pgstat_get_wait_client(w);- break;- }- case PG_WAIT_EXTENSION:- event_name = "Extension";- break;- case PG_WAIT_IPC:- {- WaitEventIPC w = (WaitEventIPC) wait_event_info;-- event_name = pgstat_get_wait_ipc(w);- break;- }- case PG_WAIT_TIMEOUT:- {- WaitEventTimeout w = (WaitEventTimeout) wait_event_info;-- event_name = pgstat_get_wait_timeout(w);- break;- }- case PG_WAIT_IO:- {- WaitEventIO w = (WaitEventIO) wait_event_info;-- event_name = pgstat_get_wait_io(w);- break;- }- default:- event_name = "unknown wait event";- break;- }-- return event_name;-}--/* ----------- * pgstat_get_wait_activity() -- *- * Convert WaitEventActivity to string.- * ----------- */-static const char *-pgstat_get_wait_activity(WaitEventActivity w)-{- const char *event_name = "unknown wait event";-- switch (w)- {- case WAIT_EVENT_ARCHIVER_MAIN:- event_name = "ArchiverMain";- break;- case WAIT_EVENT_AUTOVACUUM_MAIN:- event_name = "AutoVacuumMain";- break;- case WAIT_EVENT_BGWRITER_HIBERNATE:- event_name = "BgWriterHibernate";- break;- case WAIT_EVENT_BGWRITER_MAIN:- event_name = "BgWriterMain";- break;- case WAIT_EVENT_CHECKPOINTER_MAIN:- event_name = "CheckpointerMain";- break;- case WAIT_EVENT_LOGICAL_APPLY_MAIN:- event_name = "LogicalApplyMain";- break;- case WAIT_EVENT_LOGICAL_LAUNCHER_MAIN:- event_name = "LogicalLauncherMain";- break;- case WAIT_EVENT_PGSTAT_MAIN:- event_name = "PgStatMain";- break;- case WAIT_EVENT_RECOVERY_WAL_STREAM:- event_name = "RecoveryWalStream";- break;- case WAIT_EVENT_SYSLOGGER_MAIN:- event_name = "SysLoggerMain";- break;- case WAIT_EVENT_WAL_RECEIVER_MAIN:- event_name = "WalReceiverMain";- break;- case WAIT_EVENT_WAL_SENDER_MAIN:- event_name = "WalSenderMain";- break;- case WAIT_EVENT_WAL_WRITER_MAIN:- event_name = "WalWriterMain";- break;- /* no default case, so that compiler will warn */- }-- return event_name;-}--/* ----------- * pgstat_get_wait_client() -- *- * Convert WaitEventClient to string.- * ----------- */-static const char *-pgstat_get_wait_client(WaitEventClient w)-{- const char *event_name = "unknown wait event";-- switch (w)- {- case WAIT_EVENT_CLIENT_READ:- event_name = "ClientRead";- break;- case WAIT_EVENT_CLIENT_WRITE:- event_name = "ClientWrite";- break;- case WAIT_EVENT_GSS_OPEN_SERVER:- event_name = "GSSOpenServer";- break;- case WAIT_EVENT_LIBPQWALRECEIVER_CONNECT:- event_name = "LibPQWalReceiverConnect";- break;- case WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE:- event_name = "LibPQWalReceiverReceive";- break;- case WAIT_EVENT_SSL_OPEN_SERVER:- event_name = "SSLOpenServer";- break;- case WAIT_EVENT_WAL_RECEIVER_WAIT_START:- event_name = "WalReceiverWaitStart";- break;- case WAIT_EVENT_WAL_SENDER_WAIT_WAL:- event_name = "WalSenderWaitForWAL";- break;- case WAIT_EVENT_WAL_SENDER_WRITE_DATA:- event_name = "WalSenderWriteData";- break;- /* no default case, so that compiler will warn */- }-- return event_name;-}--/* ----------- * pgstat_get_wait_ipc() -- *- * Convert WaitEventIPC to string.- * ----------- */-static const char *-pgstat_get_wait_ipc(WaitEventIPC w)-{- const char *event_name = "unknown wait event";-- switch (w)- {- case WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE:- event_name = "BackupWaitWalArchive";- break;- case WAIT_EVENT_BGWORKER_SHUTDOWN:- event_name = "BgWorkerShutdown";- break;- case WAIT_EVENT_BGWORKER_STARTUP:- event_name = "BgWorkerStartup";- break;- case WAIT_EVENT_BTREE_PAGE:- event_name = "BtreePage";- break;- case WAIT_EVENT_BUFFER_IO:- event_name = "BufferIO";- break;- case WAIT_EVENT_CHECKPOINT_DONE:- event_name = "CheckpointDone";- break;- case WAIT_EVENT_CHECKPOINT_START:- event_name = "CheckpointStart";- break;- case WAIT_EVENT_EXECUTE_GATHER:- event_name = "ExecuteGather";- break;- case WAIT_EVENT_HASH_BATCH_ALLOCATE:- event_name = "HashBatchAllocate";- break;- case WAIT_EVENT_HASH_BATCH_ELECT:- event_name = "HashBatchElect";- break;- case WAIT_EVENT_HASH_BATCH_LOAD:- event_name = "HashBatchLoad";- break;- case WAIT_EVENT_HASH_BUILD_ALLOCATE:- event_name = "HashBuildAllocate";- break;- case WAIT_EVENT_HASH_BUILD_ELECT:- event_name = "HashBuildElect";- break;- case WAIT_EVENT_HASH_BUILD_HASH_INNER:- event_name = "HashBuildHashInner";- break;- case WAIT_EVENT_HASH_BUILD_HASH_OUTER:- event_name = "HashBuildHashOuter";- break;- case WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATE:- event_name = "HashGrowBatchesAllocate";- break;- case WAIT_EVENT_HASH_GROW_BATCHES_DECIDE:- event_name = "HashGrowBatchesDecide";- break;- case WAIT_EVENT_HASH_GROW_BATCHES_ELECT:- event_name = "HashGrowBatchesElect";- break;- case WAIT_EVENT_HASH_GROW_BATCHES_FINISH:- event_name = "HashGrowBatchesFinish";- break;- case WAIT_EVENT_HASH_GROW_BATCHES_REPARTITION:- event_name = "HashGrowBatchesRepartition";- break;- case WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATE:- event_name = "HashGrowBucketsAllocate";- break;- case WAIT_EVENT_HASH_GROW_BUCKETS_ELECT:- event_name = "HashGrowBucketsElect";- break;- case WAIT_EVENT_HASH_GROW_BUCKETS_REINSERT:- event_name = "HashGrowBucketsReinsert";- break;- case WAIT_EVENT_LOGICAL_SYNC_DATA:- event_name = "LogicalSyncData";- break;- case WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE:- event_name = "LogicalSyncStateChange";- break;- case WAIT_EVENT_MQ_INTERNAL:- event_name = "MessageQueueInternal";- break;- case WAIT_EVENT_MQ_PUT_MESSAGE:- event_name = "MessageQueuePutMessage";- break;- case WAIT_EVENT_MQ_RECEIVE:- event_name = "MessageQueueReceive";- break;- case WAIT_EVENT_MQ_SEND:- event_name = "MessageQueueSend";- break;- case WAIT_EVENT_PARALLEL_BITMAP_SCAN:- event_name = "ParallelBitmapScan";- break;- case WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN:- event_name = "ParallelCreateIndexScan";- break;- case WAIT_EVENT_PARALLEL_FINISH:- event_name = "ParallelFinish";- break;- case WAIT_EVENT_PROCARRAY_GROUP_UPDATE:- event_name = "ProcArrayGroupUpdate";- break;- case WAIT_EVENT_PROC_SIGNAL_BARRIER:- event_name = "ProcSignalBarrier";- break;- case WAIT_EVENT_PROMOTE:- event_name = "Promote";- break;- case WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT:- event_name = "RecoveryConflictSnapshot";- break;- case WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE:- event_name = "RecoveryConflictTablespace";- break;- case WAIT_EVENT_RECOVERY_PAUSE:- event_name = "RecoveryPause";- break;- case WAIT_EVENT_REPLICATION_ORIGIN_DROP:- event_name = "ReplicationOriginDrop";- break;- case WAIT_EVENT_REPLICATION_SLOT_DROP:- event_name = "ReplicationSlotDrop";- break;- case WAIT_EVENT_SAFE_SNAPSHOT:- event_name = "SafeSnapshot";- break;- case WAIT_EVENT_SYNC_REP:- event_name = "SyncRep";- break;- case WAIT_EVENT_WALRCV_EXIT:- event_name = "WalrcvExit";- break;- case WAIT_EVENT_XACT_GROUP_UPDATE:- event_name = "XactGroupUpdate";- break;- /* no default case, so that compiler will warn */- }-- return event_name;-}--/* ----------- * pgstat_get_wait_timeout() -- *- * Convert WaitEventTimeout to string.- * ----------- */-static const char *-pgstat_get_wait_timeout(WaitEventTimeout w)-{- const char *event_name = "unknown wait event";-- switch (w)- {- case WAIT_EVENT_BASE_BACKUP_THROTTLE:- event_name = "BaseBackupThrottle";- break;- case WAIT_EVENT_PG_SLEEP:- event_name = "PgSleep";- break;- case WAIT_EVENT_RECOVERY_APPLY_DELAY:- event_name = "RecoveryApplyDelay";- break;- case WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL:- event_name = "RecoveryRetrieveRetryInterval";- break;- case WAIT_EVENT_VACUUM_DELAY:- event_name = "VacuumDelay";- break;- /* no default case, so that compiler will warn */- }-- return event_name;-}--/* ----------- * pgstat_get_wait_io() -- *- * Convert WaitEventIO to string.- * ----------- */-static const char *-pgstat_get_wait_io(WaitEventIO w)-{- const char *event_name = "unknown wait event";-- switch (w)- {- case WAIT_EVENT_BASEBACKUP_READ:- event_name = "BaseBackupRead";- break;- case WAIT_EVENT_BUFFILE_READ:- event_name = "BufFileRead";- break;- case WAIT_EVENT_BUFFILE_WRITE:- event_name = "BufFileWrite";- break;- case WAIT_EVENT_BUFFILE_TRUNCATE:- event_name = "BufFileTruncate";- break;- case WAIT_EVENT_CONTROL_FILE_READ:- event_name = "ControlFileRead";- break;- case WAIT_EVENT_CONTROL_FILE_SYNC:- event_name = "ControlFileSync";- break;- case WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE:- event_name = "ControlFileSyncUpdate";- break;- case WAIT_EVENT_CONTROL_FILE_WRITE:- event_name = "ControlFileWrite";- break;- case WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE:- event_name = "ControlFileWriteUpdate";- break;- case WAIT_EVENT_COPY_FILE_READ:- event_name = "CopyFileRead";- break;- case WAIT_EVENT_COPY_FILE_WRITE:- event_name = "CopyFileWrite";- break;- case WAIT_EVENT_DATA_FILE_EXTEND:- event_name = "DataFileExtend";- break;- case WAIT_EVENT_DATA_FILE_FLUSH:- event_name = "DataFileFlush";- break;- case WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC:- event_name = "DataFileImmediateSync";- break;- case WAIT_EVENT_DATA_FILE_PREFETCH:- event_name = "DataFilePrefetch";- break;- case WAIT_EVENT_DATA_FILE_READ:- event_name = "DataFileRead";- break;- case WAIT_EVENT_DATA_FILE_SYNC:- event_name = "DataFileSync";- break;- case WAIT_EVENT_DATA_FILE_TRUNCATE:- event_name = "DataFileTruncate";- break;- case WAIT_EVENT_DATA_FILE_WRITE:- event_name = "DataFileWrite";- break;- case WAIT_EVENT_DSM_FILL_ZERO_WRITE:- event_name = "DSMFillZeroWrite";- break;- case WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ:- event_name = "LockFileAddToDataDirRead";- break;- case WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC:- event_name = "LockFileAddToDataDirSync";- break;- case WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE:- event_name = "LockFileAddToDataDirWrite";- break;- case WAIT_EVENT_LOCK_FILE_CREATE_READ:- event_name = "LockFileCreateRead";- break;- case WAIT_EVENT_LOCK_FILE_CREATE_SYNC:- event_name = "LockFileCreateSync";- break;- case WAIT_EVENT_LOCK_FILE_CREATE_WRITE:- event_name = "LockFileCreateWrite";- break;- case WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ:- event_name = "LockFileReCheckDataDirRead";- break;- case WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC:- event_name = "LogicalRewriteCheckpointSync";- break;- case WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC:- event_name = "LogicalRewriteMappingSync";- break;- case WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE:- event_name = "LogicalRewriteMappingWrite";- break;- case WAIT_EVENT_LOGICAL_REWRITE_SYNC:- event_name = "LogicalRewriteSync";- break;- case WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE:- event_name = "LogicalRewriteTruncate";- break;- case WAIT_EVENT_LOGICAL_REWRITE_WRITE:- event_name = "LogicalRewriteWrite";- break;- case WAIT_EVENT_RELATION_MAP_READ:- event_name = "RelationMapRead";- break;- case WAIT_EVENT_RELATION_MAP_SYNC:- event_name = "RelationMapSync";- break;- case WAIT_EVENT_RELATION_MAP_WRITE:- event_name = "RelationMapWrite";- break;- case WAIT_EVENT_REORDER_BUFFER_READ:- event_name = "ReorderBufferRead";- break;- case WAIT_EVENT_REORDER_BUFFER_WRITE:- event_name = "ReorderBufferWrite";- break;- case WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ:- event_name = "ReorderLogicalMappingRead";- break;- case WAIT_EVENT_REPLICATION_SLOT_READ:- event_name = "ReplicationSlotRead";- break;- case WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC:- event_name = "ReplicationSlotRestoreSync";- break;- case WAIT_EVENT_REPLICATION_SLOT_SYNC:- event_name = "ReplicationSlotSync";- break;- case WAIT_EVENT_REPLICATION_SLOT_WRITE:- event_name = "ReplicationSlotWrite";- break;- case WAIT_EVENT_SLRU_FLUSH_SYNC:- event_name = "SLRUFlushSync";- break;- case WAIT_EVENT_SLRU_READ:- event_name = "SLRURead";- break;- case WAIT_EVENT_SLRU_SYNC:- event_name = "SLRUSync";- break;- case WAIT_EVENT_SLRU_WRITE:- event_name = "SLRUWrite";- break;- case WAIT_EVENT_SNAPBUILD_READ:- event_name = "SnapbuildRead";- break;- case WAIT_EVENT_SNAPBUILD_SYNC:- event_name = "SnapbuildSync";- break;- case WAIT_EVENT_SNAPBUILD_WRITE:- event_name = "SnapbuildWrite";- break;- case WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC:- event_name = "TimelineHistoryFileSync";- break;- case WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE:- event_name = "TimelineHistoryFileWrite";- break;- case WAIT_EVENT_TIMELINE_HISTORY_READ:- event_name = "TimelineHistoryRead";- break;- case WAIT_EVENT_TIMELINE_HISTORY_SYNC:- event_name = "TimelineHistorySync";- break;- case WAIT_EVENT_TIMELINE_HISTORY_WRITE:- event_name = "TimelineHistoryWrite";- break;- case WAIT_EVENT_TWOPHASE_FILE_READ:- event_name = "TwophaseFileRead";- break;- case WAIT_EVENT_TWOPHASE_FILE_SYNC:- event_name = "TwophaseFileSync";- break;- case WAIT_EVENT_TWOPHASE_FILE_WRITE:- event_name = "TwophaseFileWrite";- break;- case WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ:- event_name = "WALSenderTimelineHistoryRead";- break;- case WAIT_EVENT_WAL_BOOTSTRAP_SYNC:- event_name = "WALBootstrapSync";- break;- case WAIT_EVENT_WAL_BOOTSTRAP_WRITE:- event_name = "WALBootstrapWrite";- break;- case WAIT_EVENT_WAL_COPY_READ:- event_name = "WALCopyRead";- break;- case WAIT_EVENT_WAL_COPY_SYNC:- event_name = "WALCopySync";- break;- case WAIT_EVENT_WAL_COPY_WRITE:- event_name = "WALCopyWrite";- break;- case WAIT_EVENT_WAL_INIT_SYNC:- event_name = "WALInitSync";- break;- case WAIT_EVENT_WAL_INIT_WRITE:- event_name = "WALInitWrite";- break;- case WAIT_EVENT_WAL_READ:- event_name = "WALRead";- break;- case WAIT_EVENT_WAL_SYNC:- event_name = "WALSync";- break;- case WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN:- event_name = "WALSyncMethodAssign";- break;- case WAIT_EVENT_WAL_WRITE:- event_name = "WALWrite";- break;- case WAIT_EVENT_LOGICAL_CHANGES_READ:- event_name = "LogicalChangesRead";- break;- case WAIT_EVENT_LOGICAL_CHANGES_WRITE:- event_name = "LogicalChangesWrite";- break;- case WAIT_EVENT_LOGICAL_SUBXACT_READ:- event_name = "LogicalSubxactRead";- break;- case WAIT_EVENT_LOGICAL_SUBXACT_WRITE:- event_name = "LogicalSubxactWrite";- break;-- /* no default case, so that compiler will warn */- }-- return event_name;-}-
/* ----------
* pgstat_get_backend_current_activity() -
diff --git a/src/backend/utils/Makefile b/src/backend/utils/Makefileindex 26e07100a5d..59b22552606 100644--- a/src/backend/utils/Makefile+++ b/src/backend/utils/Makefile@@ -14,7 +14,20 @@ top_builddir = ../../..
include $(top_builddir)/src/Makefile.global
OBJS = fmgrtab.o
-SUBDIRS = adt cache error fmgr hash init mb misc mmgr resowner sort time+SUBDIRS = \+ activity \+ adt \+ cache \+ error \+ fmgr \+ hash \+ init \+ mb \+ misc \+ mmgr \+ resowner \+ sort \+ time
# location of Catalog.pm
catalogdir = $(top_srcdir)/src/backend/catalog
diff --git a/src/backend/utils/activity/Makefile b/src/backend/utils/activity/Makefilenew file mode 100644index 00000000000..7cbe0cdbe81--- /dev/null+++ b/src/backend/utils/activity/Makefile@@ -0,0 +1,19 @@+#-------------------------------------------------------------------------+#+# Makefile for backend/utils/activity+#+# Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group+# Portions Copyright (c) 1994, Regents of the University of California+#+# src/backend/utils/activity/Makefile+#+#-------------------------------------------------------------------------++subdir = src/backend/utils/activity+top_builddir = ../../../..+include $(top_builddir)/src/Makefile.global++OBJS = \+ wait_event.o++include $(top_srcdir)/src/backend/common.mkdiff --git a/src/backend/utils/activity/wait_event.c b/src/backend/utils/activity/wait_event.cnew file mode 100644index 00000000000..226959efbb0--- /dev/null+++ b/src/backend/utils/activity/wait_event.c@@ -0,0 +1,685 @@+/* ----------+ * wait_event.c+ *+ * Wait event reporting infrastructure.+ *+ * Copyright (c) 2001-2021, PostgreSQL Global Development Group+ *+ * src/backend/postmaster/wait_event.c+ * ----------+ */+#include "postgres.h"++#include "pgstat.h"+#include "storage/lmgr.h"+++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);+++/* ----------+ * pgstat_get_wait_event_type() -+ *+ * Return a string representing the current wait event type, backend is+ * waiting on.+ */+const char *+pgstat_get_wait_event_type(uint32 wait_event_info)+{+ uint32 classId;+ const char *event_type;++ /* report process as not waiting. */+ if (wait_event_info == 0)+ return NULL;++ classId = wait_event_info & 0xFF000000;++ switch (classId)+ {+ case PG_WAIT_LWLOCK:+ event_type = "LWLock";+ break;+ case PG_WAIT_LOCK:+ event_type = "Lock";+ break;+ case PG_WAIT_BUFFER_PIN:+ event_type = "BufferPin";+ break;+ case PG_WAIT_ACTIVITY:+ event_type = "Activity";+ break;+ case PG_WAIT_CLIENT:+ event_type = "Client";+ break;+ case PG_WAIT_EXTENSION:+ event_type = "Extension";+ break;+ case PG_WAIT_IPC:+ event_type = "IPC";+ break;+ case PG_WAIT_TIMEOUT:+ event_type = "Timeout";+ break;+ case PG_WAIT_IO:+ event_type = "IO";+ break;+ default:+ event_type = "???";+ break;+ }++ return event_type;+}++/* ----------+ * pgstat_get_wait_event() -+ *+ * Return a string representing the current wait event, backend is+ * waiting on.+ */+const char *+pgstat_get_wait_event(uint32 wait_event_info)+{+ uint32 classId;+ uint16 eventId;+ const char *event_name;++ /* report process as not waiting. */+ if (wait_event_info == 0)+ return NULL;++ classId = wait_event_info & 0xFF000000;+ eventId = wait_event_info & 0x0000FFFF;++ switch (classId)+ {+ case PG_WAIT_LWLOCK:+ event_name = GetLWLockIdentifier(classId, eventId);+ break;+ case PG_WAIT_LOCK:+ event_name = GetLockNameFromTagType(eventId);+ break;+ case PG_WAIT_BUFFER_PIN:+ event_name = "BufferPin";+ break;+ case PG_WAIT_ACTIVITY:+ {+ WaitEventActivity w = (WaitEventActivity) wait_event_info;++ event_name = pgstat_get_wait_activity(w);+ break;+ }+ case PG_WAIT_CLIENT:+ {+ WaitEventClient w = (WaitEventClient) wait_event_info;++ event_name = pgstat_get_wait_client(w);+ break;+ }+ case PG_WAIT_EXTENSION:+ event_name = "Extension";+ break;+ case PG_WAIT_IPC:+ {+ WaitEventIPC w = (WaitEventIPC) wait_event_info;++ event_name = pgstat_get_wait_ipc(w);+ break;+ }+ case PG_WAIT_TIMEOUT:+ {+ WaitEventTimeout w = (WaitEventTimeout) wait_event_info;++ event_name = pgstat_get_wait_timeout(w);+ break;+ }+ case PG_WAIT_IO:+ {+ WaitEventIO w = (WaitEventIO) wait_event_info;++ event_name = pgstat_get_wait_io(w);+ break;+ }+ default:+ event_name = "unknown wait event";+ break;+ }++ return event_name;+}++/* ----------+ * pgstat_get_wait_activity() -+ *+ * Convert WaitEventActivity to string.+ * ----------+ */+static const char *+pgstat_get_wait_activity(WaitEventActivity w)+{+ const char *event_name = "unknown wait event";++ switch (w)+ {+ case WAIT_EVENT_ARCHIVER_MAIN:+ event_name = "ArchiverMain";+ break;+ case WAIT_EVENT_AUTOVACUUM_MAIN:+ event_name = "AutoVacuumMain";+ break;+ case WAIT_EVENT_BGWRITER_HIBERNATE:+ event_name = "BgWriterHibernate";+ break;+ case WAIT_EVENT_BGWRITER_MAIN:+ event_name = "BgWriterMain";+ break;+ case WAIT_EVENT_CHECKPOINTER_MAIN:+ event_name = "CheckpointerMain";+ break;+ case WAIT_EVENT_LOGICAL_APPLY_MAIN:+ event_name = "LogicalApplyMain";+ break;+ case WAIT_EVENT_LOGICAL_LAUNCHER_MAIN:+ event_name = "LogicalLauncherMain";+ break;+ case WAIT_EVENT_PGSTAT_MAIN:+ event_name = "PgStatMain";+ break;+ case WAIT_EVENT_RECOVERY_WAL_STREAM:+ event_name = "RecoveryWalStream";+ break;+ case WAIT_EVENT_SYSLOGGER_MAIN:+ event_name = "SysLoggerMain";+ break;+ case WAIT_EVENT_WAL_RECEIVER_MAIN:+ event_name = "WalReceiverMain";+ break;+ case WAIT_EVENT_WAL_SENDER_MAIN:+ event_name = "WalSenderMain";+ break;+ case WAIT_EVENT_WAL_WRITER_MAIN:+ event_name = "WalWriterMain";+ break;+ /* no default case, so that compiler will warn */+ }++ return event_name;+}++/* ----------+ * pgstat_get_wait_client() -+ *+ * Convert WaitEventClient to string.+ * ----------+ */+static const char *+pgstat_get_wait_client(WaitEventClient w)+{+ const char *event_name = "unknown wait event";++ switch (w)+ {+ case WAIT_EVENT_CLIENT_READ:+ event_name = "ClientRead";+ break;+ case WAIT_EVENT_CLIENT_WRITE:+ event_name = "ClientWrite";+ break;+ case WAIT_EVENT_GSS_OPEN_SERVER:+ event_name = "GSSOpenServer";+ break;+ case WAIT_EVENT_LIBPQWALRECEIVER_CONNECT:+ event_name = "LibPQWalReceiverConnect";+ break;+ case WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE:+ event_name = "LibPQWalReceiverReceive";+ break;+ case WAIT_EVENT_SSL_OPEN_SERVER:+ event_name = "SSLOpenServer";+ break;+ case WAIT_EVENT_WAL_RECEIVER_WAIT_START:+ event_name = "WalReceiverWaitStart";+ break;+ case WAIT_EVENT_WAL_SENDER_WAIT_WAL:+ event_name = "WalSenderWaitForWAL";+ break;+ case WAIT_EVENT_WAL_SENDER_WRITE_DATA:+ event_name = "WalSenderWriteData";+ break;+ /* no default case, so that compiler will warn */+ }++ return event_name;+}++/* ----------+ * pgstat_get_wait_ipc() -+ *+ * Convert WaitEventIPC to string.+ * ----------+ */+static const char *+pgstat_get_wait_ipc(WaitEventIPC w)+{+ const char *event_name = "unknown wait event";++ switch (w)+ {+ case WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE:+ event_name = "BackupWaitWalArchive";+ break;+ case WAIT_EVENT_BGWORKER_SHUTDOWN:+ event_name = "BgWorkerShutdown";+ break;+ case WAIT_EVENT_BGWORKER_STARTUP:+ event_name = "BgWorkerStartup";+ break;+ case WAIT_EVENT_BTREE_PAGE:+ event_name = "BtreePage";+ break;+ case WAIT_EVENT_BUFFER_IO:+ event_name = "BufferIO";+ break;+ case WAIT_EVENT_CHECKPOINT_DONE:+ event_name = "CheckpointDone";+ break;+ case WAIT_EVENT_CHECKPOINT_START:+ event_name = "CheckpointStart";+ break;+ case WAIT_EVENT_EXECUTE_GATHER:+ event_name = "ExecuteGather";+ break;+ case WAIT_EVENT_HASH_BATCH_ALLOCATE:+ event_name = "HashBatchAllocate";+ break;+ case WAIT_EVENT_HASH_BATCH_ELECT:+ event_name = "HashBatchElect";+ break;+ case WAIT_EVENT_HASH_BATCH_LOAD:+ event_name = "HashBatchLoad";+ break;+ case WAIT_EVENT_HASH_BUILD_ALLOCATE:+ event_name = "HashBuildAllocate";+ break;+ case WAIT_EVENT_HASH_BUILD_ELECT:+ event_name = "HashBuildElect";+ break;+ case WAIT_EVENT_HASH_BUILD_HASH_INNER:+ event_name = "HashBuildHashInner";+ break;+ case WAIT_EVENT_HASH_BUILD_HASH_OUTER:+ event_name = "HashBuildHashOuter";+ break;+ case WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATE:+ event_name = "HashGrowBatchesAllocate";+ break;+ case WAIT_EVENT_HASH_GROW_BATCHES_DECIDE:+ event_name = "HashGrowBatchesDecide";+ break;+ case WAIT_EVENT_HASH_GROW_BATCHES_ELECT:+ event_name = "HashGrowBatchesElect";+ break;+ case WAIT_EVENT_HASH_GROW_BATCHES_FINISH:+ event_name = "HashGrowBatchesFinish";+ break;+ case WAIT_EVENT_HASH_GROW_BATCHES_REPARTITION:+ event_name = "HashGrowBatchesRepartition";+ break;+ case WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATE:+ event_name = "HashGrowBucketsAllocate";+ break;+ case WAIT_EVENT_HASH_GROW_BUCKETS_ELECT:+ event_name = "HashGrowBucketsElect";+ break;+ case WAIT_EVENT_HASH_GROW_BUCKETS_REINSERT:+ event_name = "HashGrowBucketsReinsert";+ break;+ case WAIT_EVENT_LOGICAL_SYNC_DATA:+ event_name = "LogicalSyncData";+ break;+ case WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE:+ event_name = "LogicalSyncStateChange";+ break;+ case WAIT_EVENT_MQ_INTERNAL:+ event_name = "MessageQueueInternal";+ break;+ case WAIT_EVENT_MQ_PUT_MESSAGE:+ event_name = "MessageQueuePutMessage";+ break;+ case WAIT_EVENT_MQ_RECEIVE:+ event_name = "MessageQueueReceive";+ break;+ case WAIT_EVENT_MQ_SEND:+ event_name = "MessageQueueSend";+ break;+ case WAIT_EVENT_PARALLEL_BITMAP_SCAN:+ event_name = "ParallelBitmapScan";+ break;+ case WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN:+ event_name = "ParallelCreateIndexScan";+ break;+ case WAIT_EVENT_PARALLEL_FINISH:+ event_name = "ParallelFinish";+ break;+ case WAIT_EVENT_PROCARRAY_GROUP_UPDATE:+ event_name = "ProcArrayGroupUpdate";+ break;+ case WAIT_EVENT_PROC_SIGNAL_BARRIER:+ event_name = "ProcSignalBarrier";+ break;+ case WAIT_EVENT_PROMOTE:+ event_name = "Promote";+ break;+ case WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT:+ event_name = "RecoveryConflictSnapshot";+ break;+ case WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE:+ event_name = "RecoveryConflictTablespace";+ break;+ case WAIT_EVENT_RECOVERY_PAUSE:+ event_name = "RecoveryPause";+ break;+ case WAIT_EVENT_REPLICATION_ORIGIN_DROP:+ event_name = "ReplicationOriginDrop";+ break;+ case WAIT_EVENT_REPLICATION_SLOT_DROP:+ event_name = "ReplicationSlotDrop";+ break;+ case WAIT_EVENT_SAFE_SNAPSHOT:+ event_name = "SafeSnapshot";+ break;+ case WAIT_EVENT_SYNC_REP:+ event_name = "SyncRep";+ break;+ case WAIT_EVENT_WALRCV_EXIT:+ event_name = "WalrcvExit";+ break;+ case WAIT_EVENT_XACT_GROUP_UPDATE:+ event_name = "XactGroupUpdate";+ break;+ /* no default case, so that compiler will warn */+ }++ return event_name;+}++/* ----------+ * pgstat_get_wait_timeout() -+ *+ * Convert WaitEventTimeout to string.+ * ----------+ */+static const char *+pgstat_get_wait_timeout(WaitEventTimeout w)+{+ const char *event_name = "unknown wait event";++ switch (w)+ {+ case WAIT_EVENT_BASE_BACKUP_THROTTLE:+ event_name = "BaseBackupThrottle";+ break;+ case WAIT_EVENT_PG_SLEEP:+ event_name = "PgSleep";+ break;+ case WAIT_EVENT_RECOVERY_APPLY_DELAY:+ event_name = "RecoveryApplyDelay";+ break;+ case WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL:+ event_name = "RecoveryRetrieveRetryInterval";+ break;+ case WAIT_EVENT_VACUUM_DELAY:+ event_name = "VacuumDelay";+ break;+ /* no default case, so that compiler will warn */+ }++ return event_name;+}++/* ----------+ * pgstat_get_wait_io() -+ *+ * Convert WaitEventIO to string.+ * ----------+ */+static const char *+pgstat_get_wait_io(WaitEventIO w)+{+ const char *event_name = "unknown wait event";++ switch (w)+ {+ case WAIT_EVENT_BASEBACKUP_READ:+ event_name = "BaseBackupRead";+ break;+ case WAIT_EVENT_BUFFILE_READ:+ event_name = "BufFileRead";+ break;+ case WAIT_EVENT_BUFFILE_WRITE:+ event_name = "BufFileWrite";+ break;+ case WAIT_EVENT_BUFFILE_TRUNCATE:+ event_name = "BufFileTruncate";+ break;+ case WAIT_EVENT_CONTROL_FILE_READ:+ event_name = "ControlFileRead";+ break;+ case WAIT_EVENT_CONTROL_FILE_SYNC:+ event_name = "ControlFileSync";+ break;+ case WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE:+ event_name = "ControlFileSyncUpdate";+ break;+ case WAIT_EVENT_CONTROL_FILE_WRITE:+ event_name = "ControlFileWrite";+ break;+ case WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE:+ event_name = "ControlFileWriteUpdate";+ break;+ case WAIT_EVENT_COPY_FILE_READ:+ event_name = "CopyFileRead";+ break;+ case WAIT_EVENT_COPY_FILE_WRITE:+ event_name = "CopyFileWrite";+ break;+ case WAIT_EVENT_DATA_FILE_EXTEND:+ event_name = "DataFileExtend";+ break;+ case WAIT_EVENT_DATA_FILE_FLUSH:+ event_name = "DataFileFlush";+ break;+ case WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC:+ event_name = "DataFileImmediateSync";+ break;+ case WAIT_EVENT_DATA_FILE_PREFETCH:+ event_name = "DataFilePrefetch";+ break;+ case WAIT_EVENT_DATA_FILE_READ:+ event_name = "DataFileRead";+ break;+ case WAIT_EVENT_DATA_FILE_SYNC:+ event_name = "DataFileSync";+ break;+ case WAIT_EVENT_DATA_FILE_TRUNCATE:+ event_name = "DataFileTruncate";+ break;+ case WAIT_EVENT_DATA_FILE_WRITE:+ event_name = "DataFileWrite";+ break;+ case WAIT_EVENT_DSM_FILL_ZERO_WRITE:+ event_name = "DSMFillZeroWrite";+ break;+ case WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ:+ event_name = "LockFileAddToDataDirRead";+ break;+ case WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC:+ event_name = "LockFileAddToDataDirSync";+ break;+ case WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE:+ event_name = "LockFileAddToDataDirWrite";+ break;+ case WAIT_EVENT_LOCK_FILE_CREATE_READ:+ event_name = "LockFileCreateRead";+ break;+ case WAIT_EVENT_LOCK_FILE_CREATE_SYNC:+ event_name = "LockFileCreateSync";+ break;+ case WAIT_EVENT_LOCK_FILE_CREATE_WRITE:+ event_name = "LockFileCreateWrite";+ break;+ case WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ:+ event_name = "LockFileReCheckDataDirRead";+ break;+ case WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC:+ event_name = "LogicalRewriteCheckpointSync";+ break;+ case WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC:+ event_name = "LogicalRewriteMappingSync";+ break;+ case WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE:+ event_name = "LogicalRewriteMappingWrite";+ break;+ case WAIT_EVENT_LOGICAL_REWRITE_SYNC:+ event_name = "LogicalRewriteSync";+ break;+ case WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE:+ event_name = "LogicalRewriteTruncate";+ break;+ case WAIT_EVENT_LOGICAL_REWRITE_WRITE:+ event_name = "LogicalRewriteWrite";+ break;+ case WAIT_EVENT_RELATION_MAP_READ:+ event_name = "RelationMapRead";+ break;+ case WAIT_EVENT_RELATION_MAP_SYNC:+ event_name = "RelationMapSync";+ break;+ case WAIT_EVENT_RELATION_MAP_WRITE:+ event_name = "RelationMapWrite";+ break;+ case WAIT_EVENT_REORDER_BUFFER_READ:+ event_name = "ReorderBufferRead";+ break;+ case WAIT_EVENT_REORDER_BUFFER_WRITE:+ event_name = "ReorderBufferWrite";+ break;+ case WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ:+ event_name = "ReorderLogicalMappingRead";+ break;+ case WAIT_EVENT_REPLICATION_SLOT_READ:+ event_name = "ReplicationSlotRead";+ break;+ case WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC:+ event_name = "ReplicationSlotRestoreSync";+ break;+ case WAIT_EVENT_REPLICATION_SLOT_SYNC:+ event_name = "ReplicationSlotSync";+ break;+ case WAIT_EVENT_REPLICATION_SLOT_WRITE:+ event_name = "ReplicationSlotWrite";+ break;+ case WAIT_EVENT_SLRU_FLUSH_SYNC:+ event_name = "SLRUFlushSync";+ break;+ case WAIT_EVENT_SLRU_READ:+ event_name = "SLRURead";+ break;+ case WAIT_EVENT_SLRU_SYNC:+ event_name = "SLRUSync";+ break;+ case WAIT_EVENT_SLRU_WRITE:+ event_name = "SLRUWrite";+ break;+ case WAIT_EVENT_SNAPBUILD_READ:+ event_name = "SnapbuildRead";+ break;+ case WAIT_EVENT_SNAPBUILD_SYNC:+ event_name = "SnapbuildSync";+ break;+ case WAIT_EVENT_SNAPBUILD_WRITE:+ event_name = "SnapbuildWrite";+ break;+ case WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC:+ event_name = "TimelineHistoryFileSync";+ break;+ case WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE:+ event_name = "TimelineHistoryFileWrite";+ break;+ case WAIT_EVENT_TIMELINE_HISTORY_READ:+ event_name = "TimelineHistoryRead";+ break;+ case WAIT_EVENT_TIMELINE_HISTORY_SYNC:+ event_name = "TimelineHistorySync";+ break;+ case WAIT_EVENT_TIMELINE_HISTORY_WRITE:+ event_name = "TimelineHistoryWrite";+ break;+ case WAIT_EVENT_TWOPHASE_FILE_READ:+ event_name = "TwophaseFileRead";+ break;+ case WAIT_EVENT_TWOPHASE_FILE_SYNC:+ event_name = "TwophaseFileSync";+ break;+ case WAIT_EVENT_TWOPHASE_FILE_WRITE:+ event_name = "TwophaseFileWrite";+ break;+ case WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ:+ event_name = "WALSenderTimelineHistoryRead";+ break;+ case WAIT_EVENT_WAL_BOOTSTRAP_SYNC:+ event_name = "WALBootstrapSync";+ break;+ case WAIT_EVENT_WAL_BOOTSTRAP_WRITE:+ event_name = "WALBootstrapWrite";+ break;+ case WAIT_EVENT_WAL_COPY_READ:+ event_name = "WALCopyRead";+ break;+ case WAIT_EVENT_WAL_COPY_SYNC:+ event_name = "WALCopySync";+ break;+ case WAIT_EVENT_WAL_COPY_WRITE:+ event_name = "WALCopyWrite";+ break;+ case WAIT_EVENT_WAL_INIT_SYNC:+ event_name = "WALInitSync";+ break;+ case WAIT_EVENT_WAL_INIT_WRITE:+ event_name = "WALInitWrite";+ break;+ case WAIT_EVENT_WAL_READ:+ event_name = "WALRead";+ break;+ case WAIT_EVENT_WAL_SYNC:+ event_name = "WALSync";+ break;+ case WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN:+ event_name = "WALSyncMethodAssign";+ break;+ case WAIT_EVENT_WAL_WRITE:+ event_name = "WALWrite";+ break;+ case WAIT_EVENT_LOGICAL_CHANGES_READ:+ event_name = "LogicalChangesRead";+ break;+ case WAIT_EVENT_LOGICAL_CHANGES_WRITE:+ event_name = "LogicalChangesWrite";+ break;+ case WAIT_EVENT_LOGICAL_SUBXACT_READ:+ event_name = "LogicalSubxactRead";+ break;+ case WAIT_EVENT_LOGICAL_SUBXACT_WRITE:+ event_name = "LogicalSubxactWrite";+ break;++ /* no default case, so that compiler will warn */+ }++ return event_name;+}--
2.29.2.540.g3cf59784d4
v1-0003-WIP-Split-backend-status-related-functionality-ou.patch (text/x-diff, 95.1K) download
From fcf2b0092153215b28faccde6bb0f21c4a73c8bb Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Mon, 15 Mar 2021 19:23:59 -0700
Subject: [PATCH v1 03/21] WIP: Split backend status related functionality out
of pgstat.c.
---
src/include/pgstat.h | 294 +----
src/include/utils/backend_progress.h | 41 +
src/include/utils/backend_status.h | 326 +++++
src/backend/postmaster/pgstat.c | 1118 +----------------
src/backend/utils/activity/Makefile | 2 +
src/backend/utils/activity/backend_progress.c | 111 ++
src/backend/utils/activity/backend_status.c | 1079 ++++++++++++++++
7 files changed, 1597 insertions(+), 1374 deletions(-)
create mode 100644 src/include/utils/backend_progress.h
create mode 100644 src/include/utils/backend_status.h
create mode 100644 src/backend/utils/activity/backend_progress.c
create mode 100644 src/backend/utils/activity/backend_status.c
diff --git a/src/include/pgstat.h b/src/include/pgstat.hindex c2b18c6b08d..d80d096eb08 100644--- a/src/include/pgstat.h+++ b/src/include/pgstat.h@@ -12,11 +12,10 @@
#define PGSTAT_H
#include "datatype/timestamp.h"
-#include "libpq/pqcomm.h"-#include "miscadmin.h"-#include "port/atomics.h"
#include "portability/instr_time.h"
-#include "postmaster/pgarch.h"+#include "postmaster/pgarch.h" /* for MAX_XFN_CHARS */+#include "utils/backend_status.h" /* for backward compatibility */+#include "utils/backend_progress.h" /* for backward compatibility */
#include "utils/relcache.h"
#include "utils/wait_event.h" /* for backward compatibility */
@@ -881,263 +880,12 @@ typedef struct PgStat_ReplSlotStats
TimestampTz stat_reset_timestamp;
} PgStat_ReplSlotStats;
-/* ----------- * Backend states- * ----------- */-typedef enum BackendState-{- STATE_UNDEFINED,- STATE_IDLE,- STATE_RUNNING,- STATE_IDLEINTRANSACTION,- STATE_FASTPATH,- STATE_IDLEINTRANSACTION_ABORTED,- STATE_DISABLED-} BackendState;--/* ----------- * Command type for progress reporting purposes- * ----------- */-typedef enum ProgressCommandType-{- PROGRESS_COMMAND_INVALID,- PROGRESS_COMMAND_VACUUM,- PROGRESS_COMMAND_ANALYZE,- PROGRESS_COMMAND_CLUSTER,- PROGRESS_COMMAND_CREATE_INDEX,- PROGRESS_COMMAND_BASEBACKUP,- PROGRESS_COMMAND_COPY-} ProgressCommandType;--#define PGSTAT_NUM_PROGRESS_PARAM 20-
/* ----------
* Shared-memory data structures
* ----------
*/
-/*- * PgBackendSSLStatus- *- * For each backend, we keep the SSL status in a separate struct, that- * is only filled in if SSL is enabled.- *- * All char arrays must be null-terminated.- */-typedef struct PgBackendSSLStatus-{- /* Information about SSL connection */- int ssl_bits;- char ssl_version[NAMEDATALEN];- char ssl_cipher[NAMEDATALEN];- char ssl_client_dn[NAMEDATALEN];-- /*- * serial number is max "20 octets" per RFC 5280, so this size should be- * fine- */- char ssl_client_serial[NAMEDATALEN];-- char ssl_issuer_dn[NAMEDATALEN];-} PgBackendSSLStatus;--/*- * PgBackendGSSStatus- *- * For each backend, we keep the GSS status in a separate struct, that- * is only filled in if GSS is enabled.- *- * All char arrays must be null-terminated.- */-typedef struct PgBackendGSSStatus-{- /* Information about GSSAPI connection */- char gss_princ[NAMEDATALEN]; /* GSSAPI Principal used to auth */- bool gss_auth; /* If GSSAPI authentication was used */- bool gss_enc; /* If encryption is being used */--} PgBackendGSSStatus;---/* ----------- * PgBackendStatus- *- * Each live backend maintains a PgBackendStatus struct in shared memory- * showing its current activity. (The structs are allocated according to- * BackendId, but that is not critical.) Note that the collector process- * has no involvement in, or even access to, these structs.- *- * Each auxiliary process also maintains a PgBackendStatus struct in shared- * memory.- * ----------- */-typedef struct PgBackendStatus-{- /*- * To avoid locking overhead, we use the following protocol: a backend- * increments st_changecount before modifying its entry, and again after- * finishing a modification. A would-be reader should note the value of- * st_changecount, copy the entry into private memory, then check- * st_changecount again. If the value hasn't changed, and if it's even,- * the copy is valid; otherwise start over. This makes updates cheap- * while reads are potentially expensive, but that's the tradeoff we want.- *- * The above protocol needs memory barriers to ensure that the apparent- * order of execution is as it desires. Otherwise, for example, the CPU- * might rearrange the code so that st_changecount is incremented twice- * before the modification on a machine with weak memory ordering. Hence,- * use the macros defined below for manipulating st_changecount, rather- * than touching it directly.- */- int st_changecount;-- /* The entry is valid iff st_procpid > 0, unused if st_procpid == 0 */- int st_procpid;-- /* Type of backends */- BackendType st_backendType;-- /* Times when current backend, transaction, and activity started */- TimestampTz st_proc_start_timestamp;- TimestampTz st_xact_start_timestamp;- TimestampTz st_activity_start_timestamp;- TimestampTz st_state_start_timestamp;-- /* Database OID, owning user's OID, connection client address */- Oid st_databaseid;- Oid st_userid;- SockAddr st_clientaddr;- char *st_clienthostname; /* MUST be null-terminated */-- /* Information about SSL connection */- bool st_ssl;- PgBackendSSLStatus *st_sslstatus;-- /* Information about GSSAPI connection */- bool st_gss;- PgBackendGSSStatus *st_gssstatus;-- /* current state */- BackendState st_state;-- /* application name; MUST be null-terminated */- char *st_appname;-- /*- * Current command string; MUST be null-terminated. Note that this string- * possibly is truncated in the middle of a multi-byte character. As- * activity strings are stored more frequently than read, that allows to- * move the cost of correct truncation to the display side. Use- * pgstat_clip_activity() to truncate correctly.- */- char *st_activity_raw;-- /*- * Command progress reporting. Any command which wishes can advertise- * that it is running by setting st_progress_command,- * st_progress_command_target, and st_progress_param[].- * st_progress_command_target should be the OID of the relation which the- * command targets (we assume there's just one, as this is meant for- * utility commands), but the meaning of each element in the- * st_progress_param array is command-specific.- */- ProgressCommandType st_progress_command;- Oid st_progress_command_target;- int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM];-} PgBackendStatus;--/*- * Macros to load and store st_changecount with appropriate memory barriers.- *- * Use PGSTAT_BEGIN_WRITE_ACTIVITY() before, and PGSTAT_END_WRITE_ACTIVITY()- * after, modifying the current process's PgBackendStatus data. Note that,- * since there is no mechanism for cleaning up st_changecount after an error,- * THESE MACROS FORM A CRITICAL SECTION. Any error between them will be- * promoted to PANIC, causing a database restart to clean up shared memory!- * Hence, keep the critical section as short and straight-line as possible.- * Aside from being safer, that minimizes the window in which readers will- * have to loop.- *- * Reader logic should follow this sketch:- *- * for (;;)- * {- * int before_ct, after_ct;- *- * pgstat_begin_read_activity(beentry, before_ct);- * ... copy beentry data to local memory ...- * pgstat_end_read_activity(beentry, after_ct);- * if (pgstat_read_activity_complete(before_ct, after_ct))- * break;- * CHECK_FOR_INTERRUPTS();- * }- *- * For extra safety, we generally use volatile beentry pointers, although- * the memory barriers should theoretically be sufficient.- */-#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry) \- do { \- START_CRIT_SECTION(); \- (beentry)->st_changecount++; \- pg_write_barrier(); \- } while (0)--#define PGSTAT_END_WRITE_ACTIVITY(beentry) \- do { \- pg_write_barrier(); \- (beentry)->st_changecount++; \- Assert(((beentry)->st_changecount & 1) == 0); \- END_CRIT_SECTION(); \- } while (0)--#define pgstat_begin_read_activity(beentry, before_changecount) \- do { \- (before_changecount) = (beentry)->st_changecount; \- pg_read_barrier(); \- } while (0)--#define pgstat_end_read_activity(beentry, after_changecount) \- do { \- pg_read_barrier(); \- (after_changecount) = (beentry)->st_changecount; \- } while (0)--#define pgstat_read_activity_complete(before_changecount, after_changecount) \- ((before_changecount) == (after_changecount) && \- ((before_changecount) & 1) == 0)---/* ----------- * LocalPgBackendStatus- *- * When we build the backend status array, we use LocalPgBackendStatus to be- * able to add new values to the struct when needed without adding new fields- * to the shared memory. It contains the backend status as a first member.- * ----------- */-typedef struct LocalPgBackendStatus-{- /*- * Local version of the backend status entry.- */- PgBackendStatus backendStatus;-- /*- * The xid of the current transaction if available, InvalidTransactionId- * if not.- */- TransactionId backend_xid;-- /*- * The xmin of the current session if available, InvalidTransactionId if- * not.- */- TransactionId backend_xmin;-} LocalPgBackendStatus;-
/*
* Working state needed to accumulate per-function-call timing statistics.
*/
@@ -1159,10 +907,8 @@ typedef struct PgStat_FunctionCallUsage
* GUC parameters
* ----------
*/
-extern PGDLLIMPORT bool pgstat_track_activities;
extern PGDLLIMPORT bool pgstat_track_counts;
extern PGDLLIMPORT int pgstat_track_functions;
-extern PGDLLIMPORT int pgstat_track_activity_query_size;
extern char *pgstat_stat_directory;
extern char *pgstat_stat_tmpname;
extern char *pgstat_stat_filename;
@@ -1183,6 +929,14 @@ extern PgStat_MsgWal WalStats;
extern PgStat_Counter pgStatBlockReadTime;
extern PgStat_Counter pgStatBlockWriteTime;
+/*+ * Updated by pgstat_count_conn_*_time macros, called by+ * pgstat_report_activity().+ */+extern PgStat_Counter pgStatActiveTime;+extern PgStat_Counter pgStatTransactionIdleTime;++
/*
* Updated by the traffic cop and in errfinish()
*/
@@ -1192,9 +946,6 @@ extern SessionEndType pgStatSessionEndCause;
* Functions called from postmaster
* ----------
*/
-extern Size BackendStatusShmemSize(void);-extern void CreateSharedBackendStatus(void);-
extern void pgstat_init(void);
extern int pgstat_start(void);
extern void pgstat_reset_all(void);
@@ -1238,29 +989,13 @@ extern void pgstat_report_replslot(const char *slotname, int spilltxns, int spil
extern void pgstat_report_replslot_drop(const char *slotname);
extern void pgstat_initialize(void);
-extern void pgstat_bestart(void);-extern void pgstat_report_activity(BackendState state, const char *cmd_str);-extern void pgstat_report_tempfile(size_t filesize);-extern void pgstat_report_appname(const char *appname);-extern void pgstat_report_xact_timestamp(TimestampTz tstamp);-extern const char *pgstat_get_backend_current_activity(int pid, bool checkUser);-extern const char *pgstat_get_crashed_backend_activity(int pid, char *buffer,- int buflen);--extern void pgstat_progress_start_command(ProgressCommandType cmdtype,- Oid relid);-extern void pgstat_progress_update_param(int index, int64 val);-extern void pgstat_progress_update_multi_param(int nparam, const int *index,- const int64 *val);-extern void pgstat_progress_end_command(void);
extern PgStat_TableStatus *find_tabstat_entry(Oid rel_id);
extern PgStat_BackendFunctionEntry *find_funcstat_entry(Oid func_id);
extern void pgstat_initstats(Relation rel);
-extern char *pgstat_clip_activity(const char *raw_activity);
/* nontransactional event counts are simple enough to inline */
@@ -1303,6 +1038,10 @@ extern char *pgstat_clip_activity(const char *raw_activity);
(pgStatBlockReadTime += (n))
#define pgstat_count_buffer_write_time(n) \
(pgStatBlockWriteTime += (n))
+#define pgstat_count_conn_active_time(n) \+ (pgStatActiveTime += (n))+#define pgstat_count_conn_txn_idle_time(n) \+ (pgStatTransactionIdleTime += (n))
extern void pgstat_count_heap_insert(Relation rel, PgStat_Counter n);
extern void pgstat_count_heap_update(Relation rel, bool hot);
@@ -1339,10 +1078,7 @@ extern bool pgstat_send_wal(bool force);
*/
extern PgStat_StatDBEntry *pgstat_fetch_stat_dbentry(Oid dbid);
extern PgStat_StatTabEntry *pgstat_fetch_stat_tabentry(Oid relid);
-extern PgBackendStatus *pgstat_fetch_stat_beentry(int beid);-extern LocalPgBackendStatus *pgstat_fetch_stat_local_beentry(int beid);
extern PgStat_StatFuncEntry *pgstat_fetch_stat_funcentry(Oid funcid);
-extern int pgstat_fetch_stat_numbackends(void);
extern PgStat_ArchiverStats *pgstat_fetch_stat_archiver(void);
extern PgStat_GlobalStats *pgstat_fetch_global(void);
extern PgStat_WalStats *pgstat_fetch_stat_wal(void);
diff --git a/src/include/utils/backend_progress.h b/src/include/utils/backend_progress.hnew file mode 100644index 00000000000..8bfea476d52--- /dev/null+++ b/src/include/utils/backend_progress.h@@ -0,0 +1,41 @@+/* ----------+ * backend_progress.h+ *+ * Command progress reporting infrastructure.+ *+ * Copyright (c) 2001-2021, PostgreSQL Global Development Group+ *+ * src/include/utils/backend_progress.h+ * ----------+ */+#ifndef BACKEND_PROGRESS_H+#define BACKEND_PROGRESS_H+++/* ----------+ * Command type for progress reporting purposes+ * ----------+ */+typedef enum ProgressCommandType+{+ PROGRESS_COMMAND_INVALID,+ PROGRESS_COMMAND_VACUUM,+ PROGRESS_COMMAND_ANALYZE,+ PROGRESS_COMMAND_CLUSTER,+ PROGRESS_COMMAND_CREATE_INDEX,+ PROGRESS_COMMAND_BASEBACKUP,+ PROGRESS_COMMAND_COPY+} ProgressCommandType;++#define PGSTAT_NUM_PROGRESS_PARAM 20+++extern void pgstat_progress_start_command(ProgressCommandType cmdtype,+ Oid relid);+extern void pgstat_progress_update_param(int index, int64 val);+extern void pgstat_progress_update_multi_param(int nparam, const int *index,+ const int64 *val);+extern void pgstat_progress_end_command(void);+++#endif /* BACKEND_PROGRESS_H */diff --git a/src/include/utils/backend_status.h b/src/include/utils/backend_status.hnew file mode 100644index 00000000000..37640d975e9--- /dev/null+++ b/src/include/utils/backend_status.h@@ -0,0 +1,326 @@+/* ----------+ * backend_status.h+ *+ * Definitions related to backend status reporting+ *+ * Copyright (c) 2001-2021, PostgreSQL Global Development Group+ *+ * src/include/utils/backend_status.h+ * ----------+ */+#ifndef BACKEND_STATUS_H+#define BACKEND_STATUS_H++#include "miscadmin.h" /* for BackendType */+#include "port/atomics.h" /* for memory barriers */+#include "datatype/timestamp.h"+#include "libpq/pqcomm.h"+#include "utils/backend_progress.h"+++/* ----------+ * Backend states+ * ----------+ */+typedef enum BackendState+{+ STATE_UNDEFINED,+ STATE_IDLE,+ STATE_RUNNING,+ STATE_IDLEINTRANSACTION,+ STATE_FASTPATH,+ STATE_IDLEINTRANSACTION_ABORTED,+ STATE_DISABLED+} BackendState;+++/* ----------+ * Shared-memory data structures+ * ----------+ */+++/*+ * PgBackendSSLStatus+ *+ * For each backend, we keep the SSL status in a separate struct, that+ * is only filled in if SSL is enabled.+ *+ * All char arrays must be null-terminated.+ */+typedef struct PgBackendSSLStatus+{+ /* Information about SSL connection */+ int ssl_bits;+ char ssl_version[NAMEDATALEN];+ char ssl_cipher[NAMEDATALEN];+ char ssl_client_dn[NAMEDATALEN];++ /*+ * serial number is max "20 octets" per RFC 5280, so this size should be+ * fine+ */+ char ssl_client_serial[NAMEDATALEN];++ char ssl_issuer_dn[NAMEDATALEN];+} PgBackendSSLStatus;++/*+ * PgBackendGSSStatus+ *+ * For each backend, we keep the GSS status in a separate struct, that+ * is only filled in if GSS is enabled.+ *+ * All char arrays must be null-terminated.+ */+typedef struct PgBackendGSSStatus+{+ /* Information about GSSAPI connection */+ char gss_princ[NAMEDATALEN]; /* GSSAPI Principal used to auth */+ bool gss_auth; /* If GSSAPI authentication was used */+ bool gss_enc; /* If encryption is being used */++} PgBackendGSSStatus;+++/* ----------+ * PgBackendStatus+ *+ * Each live backend maintains a PgBackendStatus struct in shared memory+ * showing its current activity. (The structs are allocated according to+ * BackendId, but that is not critical.) Note that the collector process+ * has no involvement in, or even access to, these structs.+ *+ * Each auxiliary process also maintains a PgBackendStatus struct in shared+ * memory.+ * ----------+ */+typedef struct PgBackendStatus+{+ /*+ * To avoid locking overhead, we use the following protocol: a backend+ * increments st_changecount before modifying its entry, and again after+ * finishing a modification. A would-be reader should note the value of+ * st_changecount, copy the entry into private memory, then check+ * st_changecount again. If the value hasn't changed, and if it's even,+ * the copy is valid; otherwise start over. This makes updates cheap+ * while reads are potentially expensive, but that's the tradeoff we want.+ *+ * The above protocol needs memory barriers to ensure that the apparent+ * order of execution is as it desires. Otherwise, for example, the CPU+ * might rearrange the code so that st_changecount is incremented twice+ * before the modification on a machine with weak memory ordering. Hence,+ * use the macros defined below for manipulating st_changecount, rather+ * than touching it directly.+ */+ int st_changecount;++ /* The entry is valid iff st_procpid > 0, unused if st_procpid == 0 */+ int st_procpid;++ /* Type of backends */+ BackendType st_backendType;++ /* Times when current backend, transaction, and activity started */+ TimestampTz st_proc_start_timestamp;+ TimestampTz st_xact_start_timestamp;+ TimestampTz st_activity_start_timestamp;+ TimestampTz st_state_start_timestamp;++ /* Database OID, owning user's OID, connection client address */+ Oid st_databaseid;+ Oid st_userid;+ SockAddr st_clientaddr;+ char *st_clienthostname; /* MUST be null-terminated */++ /* Information about SSL connection */+ bool st_ssl;+ PgBackendSSLStatus *st_sslstatus;++ /* Information about GSSAPI connection */+ bool st_gss;+ PgBackendGSSStatus *st_gssstatus;++ /* current state */+ BackendState st_state;++ /* application name; MUST be null-terminated */+ char *st_appname;++ /*+ * Current command string; MUST be null-terminated. Note that this string+ * possibly is truncated in the middle of a multi-byte character. As+ * activity strings are stored more frequently than read, that allows to+ * move the cost of correct truncation to the display side. Use+ * pgstat_clip_activity() to truncate correctly.+ */+ char *st_activity_raw;++ /*+ * Command progress reporting. Any command which wishes can advertise+ * that it is running by setting st_progress_command,+ * st_progress_command_target, and st_progress_param[].+ * st_progress_command_target should be the OID of the relation which the+ * command targets (we assume there's just one, as this is meant for+ * utility commands), but the meaning of each element in the+ * st_progress_param array is command-specific.+ */+ ProgressCommandType st_progress_command;+ Oid st_progress_command_target;+ int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM];+} PgBackendStatus;+++/*+ * Macros to load and store st_changecount with appropriate memory barriers.+ *+ * Use PGSTAT_BEGIN_WRITE_ACTIVITY() before, and PGSTAT_END_WRITE_ACTIVITY()+ * after, modifying the current process's PgBackendStatus data. Note that,+ * since there is no mechanism for cleaning up st_changecount after an error,+ * THESE MACROS FORM A CRITICAL SECTION. Any error between them will be+ * promoted to PANIC, causing a database restart to clean up shared memory!+ * Hence, keep the critical section as short and straight-line as possible.+ * Aside from being safer, that minimizes the window in which readers will+ * have to loop.+ *+ * Reader logic should follow this sketch:+ *+ * for (;;)+ * {+ * int before_ct, after_ct;+ *+ * pgstat_begin_read_activity(beentry, before_ct);+ * ... copy beentry data to local memory ...+ * pgstat_end_read_activity(beentry, after_ct);+ * if (pgstat_read_activity_complete(before_ct, after_ct))+ * break;+ * CHECK_FOR_INTERRUPTS();+ * }+ *+ * For extra safety, we generally use volatile beentry pointers, although+ * the memory barriers should theoretically be sufficient.+ */+#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry) \+ do { \+ START_CRIT_SECTION(); \+ (beentry)->st_changecount++; \+ pg_write_barrier(); \+ } while (0)++#define PGSTAT_END_WRITE_ACTIVITY(beentry) \+ do { \+ pg_write_barrier(); \+ (beentry)->st_changecount++; \+ Assert(((beentry)->st_changecount & 1) == 0); \+ END_CRIT_SECTION(); \+ } while (0)++#define pgstat_begin_read_activity(beentry, before_changecount) \+ do { \+ (before_changecount) = (beentry)->st_changecount; \+ pg_read_barrier(); \+ } while (0)++#define pgstat_end_read_activity(beentry, after_changecount) \+ do { \+ pg_read_barrier(); \+ (after_changecount) = (beentry)->st_changecount; \+ } while (0)++#define pgstat_read_activity_complete(before_changecount, after_changecount) \+ ((before_changecount) == (after_changecount) && \+ ((before_changecount) & 1) == 0)+++/* ----------+ * LocalPgBackendStatus+ *+ * When we build the backend status array, we use LocalPgBackendStatus to be+ * able to add new values to the struct when needed without adding new fields+ * to the shared memory. It contains the backend status as a first member.+ * ----------+ */+typedef struct LocalPgBackendStatus+{+ /*+ * Local version of the backend status entry.+ */+ PgBackendStatus backendStatus;++ /*+ * The xid of the current transaction if available, InvalidTransactionId+ * if not.+ */+ TransactionId backend_xid;++ /*+ * The xmin of the current session if available, InvalidTransactionId if+ * not.+ */+ TransactionId backend_xmin;+} LocalPgBackendStatus;+++/* ----------+ * GUC parameters+ * ----------+ */+extern PGDLLIMPORT bool pgstat_track_activities;+extern PGDLLIMPORT int pgstat_track_activity_query_size;+++/* ----------+ * Other global variables+ * ----------+ */+extern PGDLLIMPORT PgBackendStatus *MyBEEntry;+++/* ----------+ * Functions called from postmaster+ * ----------+ */+extern Size BackendStatusShmemSize(void);+extern void CreateSharedBackendStatus(void);++++/* ----------+ * Functions called from the rest of the stats system+ * ----------+ */++extern void pgstat_bestart(void);+++/* ----------+ * Functions called from backends+ * ----------+ */++/* Initialization functions */+extern void pgbestat_backend_initialize(void);+extern void pgbestat_clear_snapshot(void);++/* Activity reporting functions */+extern void pgstat_report_activity(BackendState state, const char *cmd_str);+extern void pgstat_report_tempfile(size_t filesize);+extern void pgstat_report_appname(const char *appname);+extern void pgstat_report_xact_timestamp(TimestampTz tstamp);+extern const char *pgstat_get_backend_current_activity(int pid, bool checkUser);+extern const char *pgstat_get_crashed_backend_activity(int pid, char *buffer,+ int buflen);+++/* ----------+ * Support functions for the SQL-callable functions to+ * generate the pgstat* views.+ * ----------+ */+extern int pgstat_fetch_stat_numbackends(void);+extern PgBackendStatus *pgstat_fetch_stat_beentry(int beid);+extern LocalPgBackendStatus *pgstat_fetch_stat_local_beentry(int beid);+extern char *pgstat_clip_activity(const char *raw_activity);+++#endif /* BACKEND_STATUS_H */diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.cindex b2e03b92432..48d7e5f5269 100644--- a/src/backend/postmaster/pgstat.c+++ b/src/backend/postmaster/pgstat.c@@ -46,7 +46,6 @@
#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"
@@ -62,8 +61,6 @@
#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"
@@ -123,10 +120,8 @@
* GUC parameters
* ----------
*/
-bool pgstat_track_activities = false;
bool pgstat_track_counts = false;
int pgstat_track_functions = TRACK_FUNC_OFF;
-int pgstat_track_activity_query_size = 1024;
/* ----------
* Built from GUC parameter
@@ -258,8 +253,8 @@ static int pgStatXactCommit = 0;
static int pgStatXactRollback = 0;
PgStat_Counter pgStatBlockReadTime = 0;
PgStat_Counter pgStatBlockWriteTime = 0;
-static PgStat_Counter pgStatActiveTime = 0;-static PgStat_Counter pgStatTransactionIdleTime = 0;+PgStat_Counter pgStatActiveTime = 0;+PgStat_Counter pgStatTransactionIdleTime = 0;
SessionEndType pgStatSessionEndCause = DISCONNECT_NORMAL;
/* Record that's written to 2PC state file when pgstat state is persisted */
@@ -282,12 +277,6 @@ typedef struct TwoPhasePgStatRecord
static MemoryContext pgStatLocalContext = NULL;
static HTAB *pgStatDBHash = NULL;
-/* Status for backends including auxiliary */-static LocalPgBackendStatus *localBackendStatusTable = NULL;--/* Total number of backends including auxiliary */-static int localNumBackends = 0;-
/*
* Cluster wide statistics, kept in the stats collector.
* Contains statistics that are not collected per database
@@ -324,7 +313,6 @@ static pid_t pgstat_forkexec(void);
#endif
NON_EXEC_STATIC void PgstatCollectorMain(int argc, char *argv[]) pg_attribute_noreturn();
-static void pgstat_beshutdown_hook(int code, Datum arg);
static PgStat_StatDBEntry *pgstat_get_db_entry(Oid databaseid, bool create);
static PgStat_StatTabEntry *pgstat_get_tab_entry(PgStat_StatDBEntry *dbentry,
@@ -334,7 +322,6 @@ static void pgstat_write_db_statsfile(PgStat_StatDBEntry *dbentry, bool permanen
static HTAB *pgstat_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);
@@ -2754,65 +2741,6 @@ pgstat_fetch_stat_funcentry(Oid func_id)
}
-/* ----------- * pgstat_fetch_stat_beentry() -- *- * Support function for the SQL-callable pgstat* functions. Returns- * our local copy of the current-activity entry for one backend.- *- * NB: caller is responsible for a check if the user is permitted to see- * this info (especially the querystring).- * ----------- */-PgBackendStatus *-pgstat_fetch_stat_beentry(int beid)-{- pgstat_read_current_status();-- if (beid < 1 || beid > localNumBackends)- return NULL;-- return &localBackendStatusTable[beid - 1].backendStatus;-}---/* ----------- * pgstat_fetch_stat_local_beentry() -- *- * Like pgstat_fetch_stat_beentry() but with locally computed additions (like- * xid and xmin values of the backend)- *- * NB: caller is responsible for a check if the user is permitted to see- * this info (especially the querystring).- * ----------- */-LocalPgBackendStatus *-pgstat_fetch_stat_local_beentry(int beid)-{- pgstat_read_current_status();-- if (beid < 1 || beid > localNumBackends)- return NULL;-- return &localBackendStatusTable[beid - 1];-}---/* ----------- * pgstat_fetch_stat_numbackends() -- *- * Support function for the SQL-callable pgstat* functions. Returns- * the maximum current backend id.- * ----------- */-int-pgstat_fetch_stat_numbackends(void)-{- pgstat_read_current_status();-- return localNumBackends;-}-
/*
* ---------
* pgstat_fetch_stat_archiver() -
@@ -2896,185 +2824,26 @@ pgstat_fetch_replslot(int *nslots_p)
return replSlotStats;
}
-/* ------------------------------------------------------------- * Functions for management of the shared-memory PgBackendStatus array- * ------------------------------------------------------------- */--static PgBackendStatus *BackendStatusArray = NULL;-static PgBackendStatus *MyBEEntry = NULL;-static char *BackendAppnameBuffer = NULL;-static char *BackendClientHostnameBuffer = NULL;-static char *BackendActivityBuffer = NULL;-static Size BackendActivityBufferSize = 0;-#ifdef USE_SSL-static PgBackendSSLStatus *BackendSslStatusBuffer = NULL;-#endif-#ifdef ENABLE_GSS-static PgBackendGSSStatus *BackendGssStatusBuffer = NULL;-#endif--
/*
- * Report shared-memory space needed by CreateSharedBackendStatus.+ * Shut down a single backend's statistics reporting at process exit.+ *+ * Flush any remaining statistics counts out to the collector.+ * Without this, operations triggered during backend exit (such as+ * temp table deletions) won't be counted.
*/
-Size-BackendStatusShmemSize(void)+static void+pgstat_shutdown_hook(int code, Datum arg)
{
- Size size;-- /* BackendStatusArray: */- size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);- /* BackendAppnameBuffer: */- size = add_size(size,- mul_size(NAMEDATALEN, NumBackendStatSlots));- /* BackendClientHostnameBuffer: */- size = add_size(size,- mul_size(NAMEDATALEN, NumBackendStatSlots));- /* BackendActivityBuffer: */- size = add_size(size,- mul_size(pgstat_track_activity_query_size, NumBackendStatSlots));-#ifdef USE_SSL- /* BackendSslStatusBuffer: */- size = add_size(size,- mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots));-#endif-#ifdef ENABLE_GSS- /* BackendGssStatusBuffer: */- size = add_size(size,- mul_size(sizeof(PgBackendGSSStatus), NumBackendStatSlots));-#endif- return size;+ /*+ * If we got as far as discovering our own database ID, we can report what+ * we did to the collector. Otherwise, we'd be sending an invalid+ * database ID, so forget it. (This means that accesses to pg_database+ * during failed backend starts might never get counted.)+ */+ if (OidIsValid(MyDatabaseId))+ pgstat_report_stat(true);
}
-/*- * Initialize the shared status array and several string buffers- * during postmaster startup.- */-void-CreateSharedBackendStatus(void)-{- Size size;- bool found;- int i;- char *buffer;-- /* Create or attach to the shared array */- size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);- BackendStatusArray = (PgBackendStatus *)- ShmemInitStruct("Backend Status Array", size, &found);-- if (!found)- {- /*- * We're the first - initialize.- */- MemSet(BackendStatusArray, 0, size);- }-- /* Create or attach to the shared appname buffer */- size = mul_size(NAMEDATALEN, NumBackendStatSlots);- BackendAppnameBuffer = (char *)- ShmemInitStruct("Backend Application Name Buffer", size, &found);-- if (!found)- {- MemSet(BackendAppnameBuffer, 0, size);-- /* Initialize st_appname pointers. */- buffer = BackendAppnameBuffer;- for (i = 0; i < NumBackendStatSlots; i++)- {- BackendStatusArray[i].st_appname = buffer;- buffer += NAMEDATALEN;- }- }-- /* Create or attach to the shared client hostname buffer */- size = mul_size(NAMEDATALEN, NumBackendStatSlots);- BackendClientHostnameBuffer = (char *)- ShmemInitStruct("Backend Client Host Name Buffer", size, &found);-- if (!found)- {- MemSet(BackendClientHostnameBuffer, 0, size);-- /* Initialize st_clienthostname pointers. */- buffer = BackendClientHostnameBuffer;- for (i = 0; i < NumBackendStatSlots; i++)- {- BackendStatusArray[i].st_clienthostname = buffer;- buffer += NAMEDATALEN;- }- }-- /* Create or attach to the shared activity buffer */- BackendActivityBufferSize = mul_size(pgstat_track_activity_query_size,- NumBackendStatSlots);- BackendActivityBuffer = (char *)- ShmemInitStruct("Backend Activity Buffer",- BackendActivityBufferSize,- &found);-- if (!found)- {- MemSet(BackendActivityBuffer, 0, BackendActivityBufferSize);-- /* Initialize st_activity pointers. */- buffer = BackendActivityBuffer;- for (i = 0; i < NumBackendStatSlots; i++)- {- BackendStatusArray[i].st_activity_raw = buffer;- buffer += pgstat_track_activity_query_size;- }- }--#ifdef USE_SSL- /* Create or attach to the shared SSL status buffer */- size = mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots);- BackendSslStatusBuffer = (PgBackendSSLStatus *)- ShmemInitStruct("Backend SSL Status Buffer", size, &found);-- if (!found)- {- PgBackendSSLStatus *ptr;-- MemSet(BackendSslStatusBuffer, 0, size);-- /* Initialize st_sslstatus pointers. */- ptr = BackendSslStatusBuffer;- for (i = 0; i < NumBackendStatSlots; i++)- {- BackendStatusArray[i].st_sslstatus = ptr;- ptr++;- }- }-#endif--#ifdef ENABLE_GSS- /* Create or attach to the shared GSSAPI status buffer */- size = mul_size(sizeof(PgBackendGSSStatus), NumBackendStatSlots);- BackendGssStatusBuffer = (PgBackendGSSStatus *)- ShmemInitStruct("Backend GSS Status Buffer", size, &found);-- if (!found)- {- PgBackendGSSStatus *ptr;-- MemSet(BackendGssStatusBuffer, 0, size);-- /* Initialize st_gssstatus pointers. */- ptr = BackendGssStatusBuffer;- for (i = 0; i < NumBackendStatSlots; i++)- {- BackendStatusArray[i].st_gssstatus = ptr;- ptr++;- }- }-#endif-}--
/* ----------
* pgstat_initialize() -
*
@@ -3089,28 +2858,6 @@ CreateSharedBackendStatus(void)
void
pgstat_initialize(void)
{
- /* Initialize MyBEEntry */- if (MyBackendId != InvalidBackendId)- {- Assert(MyBackendId >= 1 && MyBackendId <= MaxBackends);- MyBEEntry = &BackendStatusArray[MyBackendId - 1];- }- else- {- /* Must be an auxiliary process */- Assert(MyAuxProcType != NotAnAuxProcess);-- /*- * Assign the MyBEEntry for an auxiliary process. Since it doesn't- * have a BackendId, the slot is statically allocated based on the- * auxiliary process type (MyAuxProcType). Backends use slots indexed- * in the range from 1 to MaxBackends (inclusive), so we use- * MaxBackends + AuxBackendType + 1 as the index of the slot for an- * auxiliary process.- */- MyBEEntry = &BackendStatusArray[MaxBackends + MyAuxProcType];- }-
/*
* Initialize prevWalUsage with pgWalUsage so that pgstat_report_wal() can
* calculate how much pgWalUsage counters are increased by substracting
@@ -3118,786 +2865,10 @@ pgstat_initialize(void)
*/
prevWalUsage = pgWalUsage;
+ pgbestat_backend_initialize();+
/* Set up a process-exit hook to clean up */
- on_shmem_exit(pgstat_beshutdown_hook, 0);-}--/* ----------- * pgstat_bestart() -- *- * Initialize this backend's entry in the PgBackendStatus array.- * Called from InitPostgres.- *- * Apart from auxiliary processes, MyBackendId, MyDatabaseId,- * session userid, and application_name must be set for a- * backend (hence, this cannot be combined with pgstat_initialize).- * Note also that we must be inside a transaction if this isn't an aux- * process, as we may need to do encoding conversion on some strings.- * ----------- */-void-pgstat_bestart(void)-{- volatile PgBackendStatus *vbeentry = MyBEEntry;- PgBackendStatus lbeentry;-#ifdef USE_SSL- PgBackendSSLStatus lsslstatus;-#endif-#ifdef ENABLE_GSS- PgBackendGSSStatus lgssstatus;-#endif-- /* pgstats state must be initialized from pgstat_initialize() */- Assert(vbeentry != NULL);-- /*- * To minimize the time spent modifying the PgBackendStatus entry, and- * avoid risk of errors inside the critical section, we first copy the- * shared-memory struct to a local variable, then modify the data in the- * local variable, then copy the local variable back to shared memory.- * Only the last step has to be inside the critical section.- *- * Most of the data we copy from shared memory is just going to be- * overwritten, but the struct's not so large that it's worth the- * maintenance hassle to copy only the needful fields.- */- memcpy(&lbeentry,- unvolatize(PgBackendStatus *, vbeentry),- sizeof(PgBackendStatus));-- /* These structs can just start from zeroes each time, though */-#ifdef USE_SSL- memset(&lsslstatus, 0, sizeof(lsslstatus));-#endif-#ifdef ENABLE_GSS- memset(&lgssstatus, 0, sizeof(lgssstatus));-#endif-- /*- * Now fill in all the fields of lbeentry, except for strings that are- * out-of-line data. Those have to be handled separately, below.- */- lbeentry.st_procpid = MyProcPid;- lbeentry.st_backendType = MyBackendType;- lbeentry.st_proc_start_timestamp = MyStartTimestamp;- lbeentry.st_activity_start_timestamp = 0;- lbeentry.st_state_start_timestamp = 0;- lbeentry.st_xact_start_timestamp = 0;- lbeentry.st_databaseid = MyDatabaseId;-- /* We have userid for client-backends, wal-sender and bgworker processes */- if (lbeentry.st_backendType == B_BACKEND- || lbeentry.st_backendType == B_WAL_SENDER- || lbeentry.st_backendType == B_BG_WORKER)- lbeentry.st_userid = GetSessionUserId();- else- lbeentry.st_userid = InvalidOid;-- /*- * We may not have a MyProcPort (eg, if this is the autovacuum process).- * If so, use all-zeroes client address, which is dealt with specially in- * pg_stat_get_backend_client_addr and pg_stat_get_backend_client_port.- */- if (MyProcPort)- memcpy(&lbeentry.st_clientaddr, &MyProcPort->raddr,- sizeof(lbeentry.st_clientaddr));- else- MemSet(&lbeentry.st_clientaddr, 0, sizeof(lbeentry.st_clientaddr));--#ifdef USE_SSL- if (MyProcPort && MyProcPort->ssl_in_use)- {- lbeentry.st_ssl = true;- lsslstatus.ssl_bits = be_tls_get_cipher_bits(MyProcPort);- strlcpy(lsslstatus.ssl_version, be_tls_get_version(MyProcPort), NAMEDATALEN);- strlcpy(lsslstatus.ssl_cipher, be_tls_get_cipher(MyProcPort), NAMEDATALEN);- be_tls_get_peer_subject_name(MyProcPort, lsslstatus.ssl_client_dn, NAMEDATALEN);- be_tls_get_peer_serial(MyProcPort, lsslstatus.ssl_client_serial, NAMEDATALEN);- be_tls_get_peer_issuer_name(MyProcPort, lsslstatus.ssl_issuer_dn, NAMEDATALEN);- }- else- {- lbeentry.st_ssl = false;- }-#else- lbeentry.st_ssl = false;-#endif--#ifdef ENABLE_GSS- if (MyProcPort && MyProcPort->gss != NULL)- {- const char *princ = be_gssapi_get_princ(MyProcPort);-- lbeentry.st_gss = true;- lgssstatus.gss_auth = be_gssapi_get_auth(MyProcPort);- lgssstatus.gss_enc = be_gssapi_get_enc(MyProcPort);- if (princ)- strlcpy(lgssstatus.gss_princ, princ, NAMEDATALEN);- }- else- {- lbeentry.st_gss = false;- }-#else- lbeentry.st_gss = false;-#endif-- lbeentry.st_state = STATE_UNDEFINED;- lbeentry.st_progress_command = PROGRESS_COMMAND_INVALID;- lbeentry.st_progress_command_target = InvalidOid;-- /*- * we don't zero st_progress_param here to save cycles; nobody should- * examine it until st_progress_command has been set to something other- * than PROGRESS_COMMAND_INVALID- */-- /*- * We're ready to enter the critical section that fills the shared-memory- * status entry. We follow the protocol of bumping st_changecount before- * and after; and make sure it's even afterwards. We use a volatile- * pointer here to ensure the compiler doesn't try to get cute.- */- PGSTAT_BEGIN_WRITE_ACTIVITY(vbeentry);-- /* make sure we'll memcpy the same st_changecount back */- lbeentry.st_changecount = vbeentry->st_changecount;-- memcpy(unvolatize(PgBackendStatus *, vbeentry),- &lbeentry,- sizeof(PgBackendStatus));-- /*- * We can write the out-of-line strings and structs using the pointers- * that are in lbeentry; this saves some de-volatilizing messiness.- */- lbeentry.st_appname[0] = '\0';- if (MyProcPort && MyProcPort->remote_hostname)- strlcpy(lbeentry.st_clienthostname, MyProcPort->remote_hostname,- NAMEDATALEN);- else- lbeentry.st_clienthostname[0] = '\0';- lbeentry.st_activity_raw[0] = '\0';- /* Also make sure the last byte in each string area is always 0 */- lbeentry.st_appname[NAMEDATALEN - 1] = '\0';- lbeentry.st_clienthostname[NAMEDATALEN - 1] = '\0';- lbeentry.st_activity_raw[pgstat_track_activity_query_size - 1] = '\0';--#ifdef USE_SSL- memcpy(lbeentry.st_sslstatus, &lsslstatus, sizeof(PgBackendSSLStatus));-#endif-#ifdef ENABLE_GSS- memcpy(lbeentry.st_gssstatus, &lgssstatus, sizeof(PgBackendGSSStatus));-#endif-- PGSTAT_END_WRITE_ACTIVITY(vbeentry);-- /* Update app name to current GUC setting */- if (application_name)- pgstat_report_appname(application_name);-}--/*- * Shut down a single backend's statistics reporting at process exit.- *- * Flush any remaining statistics counts out to the collector.- * Without this, operations triggered during backend exit (such as- * temp table deletions) won't be counted.- *- * Lastly, clear out our entry in the PgBackendStatus array.- */-static void-pgstat_beshutdown_hook(int code, Datum arg)-{- volatile PgBackendStatus *beentry = MyBEEntry;-- /*- * If we got as far as discovering our own database ID, we can report what- * we did to the collector. Otherwise, we'd be sending an invalid- * database ID, so forget it. (This means that accesses to pg_database- * during failed backend starts might never get counted.)- */- if (OidIsValid(MyDatabaseId))- pgstat_report_stat(true);-- /*- * Clear my status entry, following the protocol of bumping st_changecount- * before and after. We use a volatile pointer here to ensure the- * compiler doesn't try to get cute.- */- PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);-- beentry->st_procpid = 0; /* mark invalid */-- PGSTAT_END_WRITE_ACTIVITY(beentry);-}---/* ----------- * pgstat_report_activity() -- *- * Called from tcop/postgres.c to report what the backend is actually doing- * (but note cmd_str can be NULL for certain cases).- *- * All updates of the status entry follow the protocol of bumping- * st_changecount before and after. We use a volatile pointer here to- * ensure the compiler doesn't try to get cute.- * ----------- */-void-pgstat_report_activity(BackendState state, const char *cmd_str)-{- volatile PgBackendStatus *beentry = MyBEEntry;- TimestampTz start_timestamp;- TimestampTz current_timestamp;- int len = 0;-- TRACE_POSTGRESQL_STATEMENT_STATUS(cmd_str);-- if (!beentry)- return;-- if (!pgstat_track_activities)- {- if (beentry->st_state != STATE_DISABLED)- {- volatile PGPROC *proc = MyProc;-- /*- * track_activities is disabled, but we last reported a- * non-disabled state. As our final update, change the state and- * clear fields we will not be updating anymore.- */- PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);- beentry->st_state = STATE_DISABLED;- beentry->st_state_start_timestamp = 0;- beentry->st_activity_raw[0] = '\0';- beentry->st_activity_start_timestamp = 0;- /* st_xact_start_timestamp and wait_event_info are also disabled */- beentry->st_xact_start_timestamp = 0;- proc->wait_event_info = 0;- PGSTAT_END_WRITE_ACTIVITY(beentry);- }- return;- }-- /*- * To minimize the time spent modifying the entry, and avoid risk of- * errors inside the critical section, fetch all the needed data first.- */- start_timestamp = GetCurrentStatementStartTimestamp();- if (cmd_str != NULL)- {- /*- * Compute length of to-be-stored string unaware of multi-byte- * characters. For speed reasons that'll get corrected on read, rather- * than computed every write.- */- len = Min(strlen(cmd_str), pgstat_track_activity_query_size - 1);- }- current_timestamp = GetCurrentTimestamp();-- /*- * If the state has changed from "active" or "idle in transaction",- * calculate the duration.- */- if ((beentry->st_state == STATE_RUNNING ||- beentry->st_state == STATE_FASTPATH ||- beentry->st_state == STATE_IDLEINTRANSACTION ||- beentry->st_state == STATE_IDLEINTRANSACTION_ABORTED) &&- state != beentry->st_state)- {- long secs;- int usecs;-- TimestampDifference(beentry->st_state_start_timestamp,- current_timestamp,- &secs, &usecs);-- if (beentry->st_state == STATE_RUNNING ||- beentry->st_state == STATE_FASTPATH)- pgStatActiveTime += secs * 1000000 + usecs;- else- pgStatTransactionIdleTime += secs * 1000000 + usecs;- }-- /*- * Now update the status entry- */- PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);-- beentry->st_state = state;- beentry->st_state_start_timestamp = current_timestamp;-- if (cmd_str != NULL)- {- memcpy((char *) beentry->st_activity_raw, cmd_str, len);- beentry->st_activity_raw[len] = '\0';- beentry->st_activity_start_timestamp = start_timestamp;- }-- PGSTAT_END_WRITE_ACTIVITY(beentry);-}--/*------------ * pgstat_progress_start_command() -- *- * Set st_progress_command (and st_progress_command_target) in own backend- * entry. Also, zero-initialize st_progress_param array.- *------------ */-void-pgstat_progress_start_command(ProgressCommandType cmdtype, Oid relid)-{- volatile PgBackendStatus *beentry = MyBEEntry;-- if (!beentry || !pgstat_track_activities)- return;-- PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);- beentry->st_progress_command = cmdtype;- beentry->st_progress_command_target = relid;- MemSet(&beentry->st_progress_param, 0, sizeof(beentry->st_progress_param));- PGSTAT_END_WRITE_ACTIVITY(beentry);-}--/*------------ * pgstat_progress_update_param() -- *- * Update index'th member in st_progress_param[] of own backend entry.- *------------ */-void-pgstat_progress_update_param(int index, int64 val)-{- volatile PgBackendStatus *beentry = MyBEEntry;-- Assert(index >= 0 && index < PGSTAT_NUM_PROGRESS_PARAM);-- if (!beentry || !pgstat_track_activities)- return;-- PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);- beentry->st_progress_param[index] = val;- PGSTAT_END_WRITE_ACTIVITY(beentry);-}--/*------------ * pgstat_progress_update_multi_param() -- *- * Update multiple members in st_progress_param[] of own backend entry.- * This is atomic; readers won't see intermediate states.- *------------ */-void-pgstat_progress_update_multi_param(int nparam, const int *index,- const int64 *val)-{- volatile PgBackendStatus *beentry = MyBEEntry;- int i;-- if (!beentry || !pgstat_track_activities || nparam == 0)- return;-- PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);-- for (i = 0; i < nparam; ++i)- {- Assert(index[i] >= 0 && index[i] < PGSTAT_NUM_PROGRESS_PARAM);-- beentry->st_progress_param[index[i]] = val[i];- }-- PGSTAT_END_WRITE_ACTIVITY(beentry);-}--/*------------ * pgstat_progress_end_command() -- *- * Reset st_progress_command (and st_progress_command_target) in own backend- * entry. This signals the end of the command.- *------------ */-void-pgstat_progress_end_command(void)-{- volatile PgBackendStatus *beentry = MyBEEntry;-- if (!beentry || !pgstat_track_activities)- return;-- if (beentry->st_progress_command == PROGRESS_COMMAND_INVALID)- return;-- PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);- beentry->st_progress_command = PROGRESS_COMMAND_INVALID;- beentry->st_progress_command_target = InvalidOid;- PGSTAT_END_WRITE_ACTIVITY(beentry);-}--/* ----------- * pgstat_report_appname() -- *- * Called to update our application name.- * ----------- */-void-pgstat_report_appname(const char *appname)-{- volatile PgBackendStatus *beentry = MyBEEntry;- int len;-- if (!beentry)- return;-- /* This should be unnecessary if GUC did its job, but be safe */- len = pg_mbcliplen(appname, strlen(appname), NAMEDATALEN - 1);-- /*- * Update my status entry, following the protocol of bumping- * st_changecount before and after. We use a volatile pointer here to- * ensure the compiler doesn't try to get cute.- */- PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);-- memcpy((char *) beentry->st_appname, appname, len);- beentry->st_appname[len] = '\0';-- PGSTAT_END_WRITE_ACTIVITY(beentry);-}--/*- * Report current transaction start timestamp as the specified value.- * Zero means there is no active transaction.- */-void-pgstat_report_xact_timestamp(TimestampTz tstamp)-{- volatile PgBackendStatus *beentry = MyBEEntry;-- if (!pgstat_track_activities || !beentry)- return;-- /*- * Update my status entry, following the protocol of bumping- * st_changecount before and after. We use a volatile pointer here to- * ensure the compiler doesn't try to get cute.- */- PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);-- beentry->st_xact_start_timestamp = tstamp;-- PGSTAT_END_WRITE_ACTIVITY(beentry);-}--/* ----------- * pgstat_read_current_status() -- *- * Copy the current contents of the PgBackendStatus array to local memory,- * if not already done in this transaction.- * ----------- */-static void-pgstat_read_current_status(void)-{- volatile PgBackendStatus *beentry;- LocalPgBackendStatus *localtable;- LocalPgBackendStatus *localentry;- char *localappname,- *localclienthostname,- *localactivity;-#ifdef USE_SSL- PgBackendSSLStatus *localsslstatus;-#endif-#ifdef ENABLE_GSS- PgBackendGSSStatus *localgssstatus;-#endif- int i;-- Assert(!pgStatRunningInCollector);- if (localBackendStatusTable)- return; /* already done */-- pgstat_setup_memcxt();-- /*- * Allocate storage for local copy of state data. We can presume that- * none of these requests overflow size_t, because we already calculated- * the same values using mul_size during shmem setup. However, with- * probably-silly values of pgstat_track_activity_query_size and- * max_connections, the localactivity buffer could exceed 1GB, so use- * "huge" allocation for that one.- */- localtable = (LocalPgBackendStatus *)- MemoryContextAlloc(pgStatLocalContext,- sizeof(LocalPgBackendStatus) * NumBackendStatSlots);- localappname = (char *)- MemoryContextAlloc(pgStatLocalContext,- NAMEDATALEN * NumBackendStatSlots);- localclienthostname = (char *)- MemoryContextAlloc(pgStatLocalContext,- NAMEDATALEN * NumBackendStatSlots);- localactivity = (char *)- MemoryContextAllocHuge(pgStatLocalContext,- pgstat_track_activity_query_size * NumBackendStatSlots);-#ifdef USE_SSL- localsslstatus = (PgBackendSSLStatus *)- MemoryContextAlloc(pgStatLocalContext,- sizeof(PgBackendSSLStatus) * NumBackendStatSlots);-#endif-#ifdef ENABLE_GSS- localgssstatus = (PgBackendGSSStatus *)- MemoryContextAlloc(pgStatLocalContext,- sizeof(PgBackendGSSStatus) * NumBackendStatSlots);-#endif-- localNumBackends = 0;-- beentry = BackendStatusArray;- localentry = localtable;- for (i = 1; i <= NumBackendStatSlots; i++)- {- /*- * Follow the protocol of retrying if st_changecount changes while we- * copy the entry, or if it's odd. (The check for odd is needed to- * cover the case where we are able to completely copy the entry while- * the source backend is between increment steps.) We use a volatile- * pointer here to ensure the compiler doesn't try to get cute.- */- for (;;)- {- int before_changecount;- int after_changecount;-- pgstat_begin_read_activity(beentry, before_changecount);-- localentry->backendStatus.st_procpid = beentry->st_procpid;- /* Skip all the data-copying work if entry is not in use */- if (localentry->backendStatus.st_procpid > 0)- {- memcpy(&localentry->backendStatus, unvolatize(PgBackendStatus *, beentry), sizeof(PgBackendStatus));-- /*- * For each PgBackendStatus field that is a pointer, copy the- * pointed-to data, then adjust the local copy of the pointer- * field to point at the local copy of the data.- *- * strcpy is safe even if the string is modified concurrently,- * because there's always a \0 at the end of the buffer.- */- strcpy(localappname, (char *) beentry->st_appname);- localentry->backendStatus.st_appname = localappname;- strcpy(localclienthostname, (char *) beentry->st_clienthostname);- localentry->backendStatus.st_clienthostname = localclienthostname;- strcpy(localactivity, (char *) beentry->st_activity_raw);- localentry->backendStatus.st_activity_raw = localactivity;-#ifdef USE_SSL- if (beentry->st_ssl)- {- memcpy(localsslstatus, beentry->st_sslstatus, sizeof(PgBackendSSLStatus));- localentry->backendStatus.st_sslstatus = localsslstatus;- }-#endif-#ifdef ENABLE_GSS- if (beentry->st_gss)- {- memcpy(localgssstatus, beentry->st_gssstatus, sizeof(PgBackendGSSStatus));- localentry->backendStatus.st_gssstatus = localgssstatus;- }-#endif- }-- pgstat_end_read_activity(beentry, after_changecount);-- if (pgstat_read_activity_complete(before_changecount,- after_changecount))- break;-- /* Make sure we can break out of loop if stuck... */- CHECK_FOR_INTERRUPTS();- }-- beentry++;- /* Only valid entries get included into the local array */- if (localentry->backendStatus.st_procpid > 0)- {- BackendIdGetTransactionIds(i,- &localentry->backend_xid,- &localentry->backend_xmin);-- localentry++;- localappname += NAMEDATALEN;- localclienthostname += NAMEDATALEN;- localactivity += pgstat_track_activity_query_size;-#ifdef USE_SSL- localsslstatus++;-#endif-#ifdef ENABLE_GSS- localgssstatus++;-#endif- localNumBackends++;- }- }-- /* Set the pointer only after completion of a valid table */- localBackendStatusTable = localtable;-}---/* ----------- * pgstat_get_backend_current_activity() -- *- * Return a string representing the current activity of the backend with- * the specified PID. This looks directly at the BackendStatusArray,- * and so will provide current information regardless of the age of our- * transaction's snapshot of the status array.- *- * It is the caller's responsibility to invoke this only for backends whose- * state is expected to remain stable while the result is in use. The- * only current use is in deadlock reporting, where we can expect that- * the target backend is blocked on a lock. (There are corner cases- * where the target's wait could get aborted while we are looking at it,- * but the very worst consequence is to return a pointer to a string- * that's been changed, so we won't worry too much.)- *- * Note: return strings for special cases match pg_stat_get_backend_activity.- * ----------- */-const char *-pgstat_get_backend_current_activity(int pid, bool checkUser)-{- PgBackendStatus *beentry;- int i;-- beentry = BackendStatusArray;- for (i = 1; i <= MaxBackends; i++)- {- /*- * Although we expect the target backend's entry to be stable, that- * doesn't imply that anyone else's is. To avoid identifying the- * wrong backend, while we check for a match to the desired PID we- * must follow the protocol of retrying if st_changecount changes- * while we examine the entry, or if it's odd. (This might be- * unnecessary, since fetching or storing an int is almost certainly- * atomic, but let's play it safe.) We use a volatile pointer here to- * ensure the compiler doesn't try to get cute.- */- volatile PgBackendStatus *vbeentry = beentry;- bool found;-- for (;;)- {- int before_changecount;- int after_changecount;-- pgstat_begin_read_activity(vbeentry, before_changecount);-- found = (vbeentry->st_procpid == pid);-- pgstat_end_read_activity(vbeentry, after_changecount);-- if (pgstat_read_activity_complete(before_changecount,- after_changecount))- break;-- /* Make sure we can break out of loop if stuck... */- CHECK_FOR_INTERRUPTS();- }-- if (found)- {- /* Now it is safe to use the non-volatile pointer */- if (checkUser && !superuser() && beentry->st_userid != GetUserId())- return "<insufficient privilege>";- else if (*(beentry->st_activity_raw) == '\0')- return "<command string not enabled>";- else- {- /* this'll leak a bit of memory, but that seems acceptable */- return pgstat_clip_activity(beentry->st_activity_raw);- }- }-- beentry++;- }-- /* If we get here, caller is in error ... */- return "<backend information not available>";-}--/* ----------- * pgstat_get_crashed_backend_activity() -- *- * Return a string representing the current activity of the backend with- * the specified PID. Like the function above, but reads shared memory with- * the expectation that it may be corrupt. On success, copy the string- * into the "buffer" argument and return that pointer. On failure,- * return NULL.- *- * This function is only intended to be used by the postmaster to report the- * query that crashed a backend. In particular, no attempt is made to- * follow the correct concurrency protocol when accessing the- * BackendStatusArray. But that's OK, in the worst case we'll return a- * corrupted message. We also must take care not to trip on ereport(ERROR).- * ----------- */-const char *-pgstat_get_crashed_backend_activity(int pid, char *buffer, int buflen)-{- volatile PgBackendStatus *beentry;- int i;-- beentry = BackendStatusArray;-- /*- * We probably shouldn't get here before shared memory has been set up,- * but be safe.- */- if (beentry == NULL || BackendActivityBuffer == NULL)- return NULL;-- for (i = 1; i <= MaxBackends; i++)- {- if (beentry->st_procpid == pid)- {- /* Read pointer just once, so it can't change after validation */- const char *activity = beentry->st_activity_raw;- const char *activity_last;-- /*- * We mustn't access activity string before we verify that it- * falls within the BackendActivityBuffer. To make sure that the- * entire string including its ending is contained within the- * buffer, subtract one activity length from the buffer size.- */- activity_last = BackendActivityBuffer + BackendActivityBufferSize- - pgstat_track_activity_query_size;-- if (activity < BackendActivityBuffer ||- activity > activity_last)- return NULL;-- /* If no string available, no point in a report */- if (activity[0] == '\0')- return NULL;-- /*- * Copy only ASCII-safe characters so we don't run into encoding- * problems when reporting the message; and be sure not to run off- * the end of memory. As only ASCII characters are reported, it- * doesn't seem necessary to perform multibyte aware clipping.- */- ascii_safe_strlcpy(buffer, activity,- Min(buflen, pgstat_track_activity_query_size));-- return buffer;- }-- beentry++;- }-- /* PID not found */- return NULL;+ on_shmem_exit(pgstat_shutdown_hook, 0);
}
/* ------------------------------------------------------------
@@ -5652,8 +4623,9 @@ pgstat_clear_snapshot(void)
/* Reset variables */
pgStatLocalContext = NULL;
pgStatDBHash = NULL;
- localBackendStatusTable = NULL;- localNumBackends = 0;++ /* forward to stats sub-subsystems */+ pgbestat_clear_snapshot();
}
@@ -6588,50 +5560,6 @@ pgstat_db_requested(Oid databaseid)
return false;
}
-/*- * Convert a potentially unsafely truncated activity string (see- * PgBackendStatus.st_activity_raw's documentation) into a correctly truncated- * one.- *- * The returned string is allocated in the caller's memory context and may be- * freed.- */-char *-pgstat_clip_activity(const char *raw_activity)-{- char *activity;- int rawlen;- int cliplen;-- /*- * Some callers, like pgstat_get_backend_current_activity(), do not- * guarantee that the buffer isn't concurrently modified. We try to take- * care that the buffer is always terminated by a NUL byte regardless, but- * let's still be paranoid about the string's length. In those cases the- * underlying buffer is guaranteed to be pgstat_track_activity_query_size- * large.- */- activity = pnstrdup(raw_activity, pgstat_track_activity_query_size - 1);-- /* now double-guaranteed to be NUL terminated */- rawlen = strlen(activity);-- /*- * All supported server-encodings make it possible to determine the length- * of a multi-byte character from its first byte (this is not the case for- * client encodings, see GB18030). As st_activity is always stored using- * server encoding, this allows us to perform multi-byte aware truncation,- * even if the string earlier was truncated in the middle of a multi-byte- * character.- */- cliplen = pg_mbcliplen(activity, rawlen,- pgstat_track_activity_query_size - 1);-- activity[cliplen] = '\0';-- return activity;-}-
/* ----------
* pgstat_replslot_index
*
diff --git a/src/backend/utils/activity/Makefile b/src/backend/utils/activity/Makefileindex 7cbe0cdbe81..59196f278d8 100644--- a/src/backend/utils/activity/Makefile+++ b/src/backend/utils/activity/Makefile@@ -14,6 +14,8 @@ top_builddir = ../../../..
include $(top_builddir)/src/Makefile.global
OBJS = \
+ backend_progress.o \+ backend_status.o \
wait_event.o
include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/utils/activity/backend_progress.c b/src/backend/utils/activity/backend_progress.cnew file mode 100644index 00000000000..3f31de8de02--- /dev/null+++ b/src/backend/utils/activity/backend_progress.c@@ -0,0 +1,111 @@+/* ----------+ * progress.c+ *+ * Command progress reporting infrastructure.+ *+ * Copyright (c) 2001-2021, PostgreSQL Global Development Group+ *+ * src/backend/postmaster/progress.c+ * ----------+ */+#include "postgres.h"++#include "utils/backend_progress.h"+#include "utils/backend_status.h"+++/*-----------+ * pgstat_progress_start_command() -+ *+ * Set st_progress_command (and st_progress_command_target) in own backend+ * entry. Also, zero-initialize st_progress_param array.+ *-----------+ */+void+pgstat_progress_start_command(ProgressCommandType cmdtype, Oid relid)+{+ volatile PgBackendStatus *beentry = MyBEEntry;++ if (!beentry || !pgstat_track_activities)+ return;++ PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);+ beentry->st_progress_command = cmdtype;+ beentry->st_progress_command_target = relid;+ MemSet(&beentry->st_progress_param, 0, sizeof(beentry->st_progress_param));+ PGSTAT_END_WRITE_ACTIVITY(beentry);+}++/*-----------+ * pgstat_progress_update_param() -+ *+ * Update index'th member in st_progress_param[] of own backend entry.+ *-----------+ */+void+pgstat_progress_update_param(int index, int64 val)+{+ volatile PgBackendStatus *beentry = MyBEEntry;++ Assert(index >= 0 && index < PGSTAT_NUM_PROGRESS_PARAM);++ if (!beentry || !pgstat_track_activities)+ return;++ PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);+ beentry->st_progress_param[index] = val;+ PGSTAT_END_WRITE_ACTIVITY(beentry);+}++/*-----------+ * pgstat_progress_update_multi_param() -+ *+ * Update multiple members in st_progress_param[] of own backend entry.+ * This is atomic; readers won't see intermediate states.+ *-----------+ */+void+pgstat_progress_update_multi_param(int nparam, const int *index,+ const int64 *val)+{+ volatile PgBackendStatus *beentry = MyBEEntry;+ int i;++ if (!beentry || !pgstat_track_activities || nparam == 0)+ return;++ PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);++ for (i = 0; i < nparam; ++i)+ {+ Assert(index[i] >= 0 && index[i] < PGSTAT_NUM_PROGRESS_PARAM);++ beentry->st_progress_param[index[i]] = val[i];+ }++ PGSTAT_END_WRITE_ACTIVITY(beentry);+}++/*-----------+ * pgstat_progress_end_command() -+ *+ * Reset st_progress_command (and st_progress_command_target) in own backend+ * entry. This signals the end of the command.+ *-----------+ */+void+pgstat_progress_end_command(void)+{+ volatile PgBackendStatus *beentry = MyBEEntry;++ if (!beentry || !pgstat_track_activities)+ return;++ if (beentry->st_progress_command == PROGRESS_COMMAND_INVALID)+ return;++ PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);+ beentry->st_progress_command = PROGRESS_COMMAND_INVALID;+ beentry->st_progress_command_target = InvalidOid;+ PGSTAT_END_WRITE_ACTIVITY(beentry);+}diff --git a/src/backend/utils/activity/backend_status.c b/src/backend/utils/activity/backend_status.cnew file mode 100644index 00000000000..a37d5f54159--- /dev/null+++ b/src/backend/utils/activity/backend_status.c@@ -0,0 +1,1079 @@+/* ----------+ * backend_status.c+ *+ * Backend activity reporting infrastructure.+ *+ * Copyright (c) 2001-2021, PostgreSQL Global Development Group+ *+ * src/backend/postmaster/backend_status.c+ * ----------+ */+#include "postgres.h"++#include "utils/backend_status.h"++#include "access/xact.h"+#include "libpq/libpq.h"+#include "miscadmin.h"+#include "pg_trace.h"+#include "pgstat.h"+#include "storage/ipc.h"+#include "storage/proc.h" /* for MyProc */+#include "storage/sinvaladt.h"+#include "utils/ascii.h"+#include "utils/guc.h" /* for application_name */+#include "utils/memutils.h"+++/* ----------+ * Total number of backends including auxiliary+ *+ * We reserve a slot for each possible BackendId, plus one for each+ * possible auxiliary process type. (This scheme assumes there is not+ * more than one of any auxiliary process type at a time.) MaxBackends+ * includes autovacuum workers and background workers as well.+ * ----------+ */+#define NumBackendStatSlots (MaxBackends + NUM_AUXPROCTYPES)+++/* ----------+ * GUC parameters+ * ----------+ */+bool pgstat_track_activities = false;+int pgstat_track_activity_query_size = 1024;+++/* exposed so that progress.c can access it */+PgBackendStatus *MyBEEntry = NULL;+++static PgBackendStatus *BackendStatusArray = NULL;+static char *BackendAppnameBuffer = NULL;+static char *BackendClientHostnameBuffer = NULL;+static char *BackendActivityBuffer = NULL;+static Size BackendActivityBufferSize = 0;+#ifdef USE_SSL+static PgBackendSSLStatus *BackendSslStatusBuffer = NULL;+#endif+#ifdef ENABLE_GSS+static PgBackendGSSStatus *BackendGssStatusBuffer = NULL;+#endif+++/* Status for backends including auxiliary */+static LocalPgBackendStatus *localBackendStatusTable = NULL;++/* Total number of backends including auxiliary */+static int localNumBackends = 0;++static MemoryContext pgBeStatLocalContext;+++static void pgstat_beshutdown_hook(int code, Datum arg);+static void pgstat_read_current_status(void);+static void pgbestat_setup_memcxt(void);+++/*+ * Report shared-memory space needed by CreateSharedBackendStatus.+ */+Size+BackendStatusShmemSize(void)+{+ Size size;++ /* BackendStatusArray: */+ size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);+ /* BackendAppnameBuffer: */+ size = add_size(size,+ mul_size(NAMEDATALEN, NumBackendStatSlots));+ /* BackendClientHostnameBuffer: */+ size = add_size(size,+ mul_size(NAMEDATALEN, NumBackendStatSlots));+ /* BackendActivityBuffer: */+ size = add_size(size,+ mul_size(pgstat_track_activity_query_size, NumBackendStatSlots));+#ifdef USE_SSL+ /* BackendSslStatusBuffer: */+ size = add_size(size,+ mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots));+#endif+#ifdef ENABLE_GSS+ /* BackendGssStatusBuffer: */+ size = add_size(size,+ mul_size(sizeof(PgBackendGSSStatus), NumBackendStatSlots));+#endif+ return size;+}++/*+ * Initialize the shared status array and several string buffers+ * during postmaster startup.+ */+void+CreateSharedBackendStatus(void)+{+ Size size;+ bool found;+ int i;+ char *buffer;++ /* Create or attach to the shared array */+ size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);+ BackendStatusArray = (PgBackendStatus *)+ ShmemInitStruct("Backend Status Array", size, &found);++ if (!found)+ {+ /*+ * We're the first - initialize.+ */+ MemSet(BackendStatusArray, 0, size);+ }++ /* Create or attach to the shared appname buffer */+ size = mul_size(NAMEDATALEN, NumBackendStatSlots);+ BackendAppnameBuffer = (char *)+ ShmemInitStruct("Backend Application Name Buffer", size, &found);++ if (!found)+ {+ MemSet(BackendAppnameBuffer, 0, size);++ /* Initialize st_appname pointers. */+ buffer = BackendAppnameBuffer;+ for (i = 0; i < NumBackendStatSlots; i++)+ {+ BackendStatusArray[i].st_appname = buffer;+ buffer += NAMEDATALEN;+ }+ }++ /* Create or attach to the shared client hostname buffer */+ size = mul_size(NAMEDATALEN, NumBackendStatSlots);+ BackendClientHostnameBuffer = (char *)+ ShmemInitStruct("Backend Client Host Name Buffer", size, &found);++ if (!found)+ {+ MemSet(BackendClientHostnameBuffer, 0, size);++ /* Initialize st_clienthostname pointers. */+ buffer = BackendClientHostnameBuffer;+ for (i = 0; i < NumBackendStatSlots; i++)+ {+ BackendStatusArray[i].st_clienthostname = buffer;+ buffer += NAMEDATALEN;+ }+ }++ /* Create or attach to the shared activity buffer */+ BackendActivityBufferSize = mul_size(pgstat_track_activity_query_size,+ NumBackendStatSlots);+ BackendActivityBuffer = (char *)+ ShmemInitStruct("Backend Activity Buffer",+ BackendActivityBufferSize,+ &found);++ if (!found)+ {+ MemSet(BackendActivityBuffer, 0, BackendActivityBufferSize);++ /* Initialize st_activity pointers. */+ buffer = BackendActivityBuffer;+ for (i = 0; i < NumBackendStatSlots; i++)+ {+ BackendStatusArray[i].st_activity_raw = buffer;+ buffer += pgstat_track_activity_query_size;+ }+ }++#ifdef USE_SSL+ /* Create or attach to the shared SSL status buffer */+ size = mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots);+ BackendSslStatusBuffer = (PgBackendSSLStatus *)+ ShmemInitStruct("Backend SSL Status Buffer", size, &found);++ if (!found)+ {+ PgBackendSSLStatus *ptr;++ MemSet(BackendSslStatusBuffer, 0, size);++ /* Initialize st_sslstatus pointers. */+ ptr = BackendSslStatusBuffer;+ for (i = 0; i < NumBackendStatSlots; i++)+ {+ BackendStatusArray[i].st_sslstatus = ptr;+ ptr++;+ }+ }+#endif++#ifdef ENABLE_GSS+ /* Create or attach to the shared GSSAPI status buffer */+ size = mul_size(sizeof(PgBackendGSSStatus), NumBackendStatSlots);+ BackendGssStatusBuffer = (PgBackendGSSStatus *)+ ShmemInitStruct("Backend GSS Status Buffer", size, &found);++ if (!found)+ {+ PgBackendGSSStatus *ptr;++ MemSet(BackendGssStatusBuffer, 0, size);++ /* Initialize st_gssstatus pointers. */+ ptr = BackendGssStatusBuffer;+ for (i = 0; i < NumBackendStatSlots; i++)+ {+ BackendStatusArray[i].st_gssstatus = ptr;+ ptr++;+ }+ }+#endif+}++/*+ * Initialize pgstats backend activity state, and set up our on-proc-exit+ * hook. Called from InitPostgres and AuxiliaryProcessMain. For auxiliary+ * process, MyBackendId is invalid. Otherwise, MyBackendId must be set, but+ * we must not have started any transaction yet (since the exit hook must run+ * after the last transaction exit). NOTE: MyDatabaseId isn't set yet; so+ * the shutdown hook has to be careful.+ */+void+pgbestat_backend_initialize(void)+{+ /* Initialize MyBEEntry */+ if (MyBackendId != InvalidBackendId)+ {+ Assert(MyBackendId >= 1 && MyBackendId <= MaxBackends);+ MyBEEntry = &BackendStatusArray[MyBackendId - 1];+ }+ else+ {+ /* Must be an auxiliary process */+ Assert(MyAuxProcType != NotAnAuxProcess);++ /*+ * Assign the MyBEEntry for an auxiliary process. Since it doesn't+ * have a BackendId, the slot is statically allocated based on the+ * auxiliary process type (MyAuxProcType). Backends use slots indexed+ * in the range from 1 to MaxBackends (inclusive), so we use+ * MaxBackends + AuxBackendType + 1 as the index of the slot for an+ * auxiliary process.+ */+ MyBEEntry = &BackendStatusArray[MaxBackends + MyAuxProcType];+ }++ /* Set up a process-exit hook to clean up */+ on_shmem_exit(pgstat_beshutdown_hook, 0);+}+++/* ----------+ * pgstat_bestart() -+ *+ * Initialize this backend's entry in the PgBackendStatus array.+ * Called from InitPostgres.+ *+ * Apart from auxiliary processes, MyBackendId, MyDatabaseId,+ * session userid, and application_name must be set for a+ * backend (hence, this cannot be combined with pgstat_initialize).+ * Note also that we must be inside a transaction if this isn't an aux+ * process, as we may need to do encoding conversion on some strings.+ * ----------+ */+void+pgstat_bestart(void)+{+ volatile PgBackendStatus *vbeentry = MyBEEntry;+ PgBackendStatus lbeentry;+#ifdef USE_SSL+ PgBackendSSLStatus lsslstatus;+#endif+#ifdef ENABLE_GSS+ PgBackendGSSStatus lgssstatus;+#endif++ /* pgstats state must be initialized from pgstat_initialize() */+ Assert(vbeentry != NULL);++ /*+ * To minimize the time spent modifying the PgBackendStatus entry, and+ * avoid risk of errors inside the critical section, we first copy the+ * shared-memory struct to a local variable, then modify the data in the+ * local variable, then copy the local variable back to shared memory.+ * Only the last step has to be inside the critical section.+ *+ * Most of the data we copy from shared memory is just going to be+ * overwritten, but the struct's not so large that it's worth the+ * maintenance hassle to copy only the needful fields.+ */+ memcpy(&lbeentry,+ unvolatize(PgBackendStatus *, vbeentry),+ sizeof(PgBackendStatus));++ /* These structs can just start from zeroes each time, though */+#ifdef USE_SSL+ memset(&lsslstatus, 0, sizeof(lsslstatus));+#endif+#ifdef ENABLE_GSS+ memset(&lgssstatus, 0, sizeof(lgssstatus));+#endif++ /*+ * Now fill in all the fields of lbeentry, except for strings that are+ * out-of-line data. Those have to be handled separately, below.+ */+ lbeentry.st_procpid = MyProcPid;+ lbeentry.st_backendType = MyBackendType;+ lbeentry.st_proc_start_timestamp = MyStartTimestamp;+ lbeentry.st_activity_start_timestamp = 0;+ lbeentry.st_state_start_timestamp = 0;+ lbeentry.st_xact_start_timestamp = 0;+ lbeentry.st_databaseid = MyDatabaseId;++ /* We have userid for client-backends, wal-sender and bgworker processes */+ if (lbeentry.st_backendType == B_BACKEND+ || lbeentry.st_backendType == B_WAL_SENDER+ || lbeentry.st_backendType == B_BG_WORKER)+ lbeentry.st_userid = GetSessionUserId();+ else+ lbeentry.st_userid = InvalidOid;++ /*+ * We may not have a MyProcPort (eg, if this is the autovacuum process).+ * If so, use all-zeroes client address, which is dealt with specially in+ * pg_stat_get_backend_client_addr and pg_stat_get_backend_client_port.+ */+ if (MyProcPort)+ memcpy(&lbeentry.st_clientaddr, &MyProcPort->raddr,+ sizeof(lbeentry.st_clientaddr));+ else+ MemSet(&lbeentry.st_clientaddr, 0, sizeof(lbeentry.st_clientaddr));++#ifdef USE_SSL+ if (MyProcPort && MyProcPort->ssl_in_use)+ {+ lbeentry.st_ssl = true;+ lsslstatus.ssl_bits = be_tls_get_cipher_bits(MyProcPort);+ strlcpy(lsslstatus.ssl_version, be_tls_get_version(MyProcPort), NAMEDATALEN);+ strlcpy(lsslstatus.ssl_cipher, be_tls_get_cipher(MyProcPort), NAMEDATALEN);+ be_tls_get_peer_subject_name(MyProcPort, lsslstatus.ssl_client_dn, NAMEDATALEN);+ be_tls_get_peer_serial(MyProcPort, lsslstatus.ssl_client_serial, NAMEDATALEN);+ be_tls_get_peer_issuer_name(MyProcPort, lsslstatus.ssl_issuer_dn, NAMEDATALEN);+ }+ else+ {+ lbeentry.st_ssl = false;+ }+#else+ lbeentry.st_ssl = false;+#endif++#ifdef ENABLE_GSS+ if (MyProcPort && MyProcPort->gss != NULL)+ {+ const char *princ = be_gssapi_get_princ(MyProcPort);++ lbeentry.st_gss = true;+ lgssstatus.gss_auth = be_gssapi_get_auth(MyProcPort);+ lgssstatus.gss_enc = be_gssapi_get_enc(MyProcPort);+ if (princ)+ strlcpy(lgssstatus.gss_princ, princ, NAMEDATALEN);+ }+ else+ {+ lbeentry.st_gss = false;+ }+#else+ lbeentry.st_gss = false;+#endif++ lbeentry.st_state = STATE_UNDEFINED;+ lbeentry.st_progress_command = PROGRESS_COMMAND_INVALID;+ lbeentry.st_progress_command_target = InvalidOid;++ /*+ * we don't zero st_progress_param here to save cycles; nobody should+ * examine it until st_progress_command has been set to something other+ * than PROGRESS_COMMAND_INVALID+ */++ /*+ * We're ready to enter the critical section that fills the shared-memory+ * status entry. We follow the protocol of bumping st_changecount before+ * and after; and make sure it's even afterwards. We use a volatile+ * pointer here to ensure the compiler doesn't try to get cute.+ */+ PGSTAT_BEGIN_WRITE_ACTIVITY(vbeentry);++ /* make sure we'll memcpy the same st_changecount back */+ lbeentry.st_changecount = vbeentry->st_changecount;++ memcpy(unvolatize(PgBackendStatus *, vbeentry),+ &lbeentry,+ sizeof(PgBackendStatus));++ /*+ * We can write the out-of-line strings and structs using the pointers+ * that are in lbeentry; this saves some de-volatilizing messiness.+ */+ lbeentry.st_appname[0] = '\0';+ if (MyProcPort && MyProcPort->remote_hostname)+ strlcpy(lbeentry.st_clienthostname, MyProcPort->remote_hostname,+ NAMEDATALEN);+ else+ lbeentry.st_clienthostname[0] = '\0';+ lbeentry.st_activity_raw[0] = '\0';+ /* Also make sure the last byte in each string area is always 0 */+ lbeentry.st_appname[NAMEDATALEN - 1] = '\0';+ lbeentry.st_clienthostname[NAMEDATALEN - 1] = '\0';+ lbeentry.st_activity_raw[pgstat_track_activity_query_size - 1] = '\0';++#ifdef USE_SSL+ memcpy(lbeentry.st_sslstatus, &lsslstatus, sizeof(PgBackendSSLStatus));+#endif+#ifdef ENABLE_GSS+ memcpy(lbeentry.st_gssstatus, &lgssstatus, sizeof(PgBackendGSSStatus));+#endif++ PGSTAT_END_WRITE_ACTIVITY(vbeentry);++ /* Update app name to current GUC setting */+ if (application_name)+ pgstat_report_appname(application_name);+}++/*+ * Clear out our entry in the PgBackendStatus array.+ */+static void+pgstat_beshutdown_hook(int code, Datum arg)+{+ volatile PgBackendStatus *beentry = MyBEEntry;++ /*+ * Clear my status entry, following the protocol of bumping st_changecount+ * before and after. We use a volatile pointer here to ensure the+ * compiler doesn't try to get cute.+ */+ PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);++ beentry->st_procpid = 0; /* mark invalid */++ PGSTAT_END_WRITE_ACTIVITY(beentry);+}++/* ----------+ * pgstat_clear_snapshot() -+ *+ * Discard any data collected in the current transaction. Any subsequent+ * request will cause new snapshots to be read.+ *+ * This is also invoked during transaction commit or abort to discard+ * the no-longer-wanted snapshot.+ * ----------+ */+void+pgbestat_clear_snapshot(void)+{+ /* Release memory, if any was allocated */+ if (pgBeStatLocalContext)+ {+ MemoryContextDelete(pgBeStatLocalContext);+ pgBeStatLocalContext = NULL;+ }++ /* Reset variables */+ localBackendStatusTable = NULL;+ localNumBackends = 0;+}++static void+pgbestat_setup_memcxt(void)+{+ if (!pgBeStatLocalContext)+ pgBeStatLocalContext = AllocSetContextCreate(TopMemoryContext,+ "Activity snapshot",+ ALLOCSET_SMALL_SIZES);+}+++/* ----------+ * pgstat_report_activity() -+ *+ * Called from tcop/postgres.c to report what the backend is actually doing+ * (but note cmd_str can be NULL for certain cases).+ *+ * All updates of the status entry follow the protocol of bumping+ * st_changecount before and after. We use a volatile pointer here to+ * ensure the compiler doesn't try to get cute.+ * ----------+ */+void+pgstat_report_activity(BackendState state, const char *cmd_str)+{+ volatile PgBackendStatus *beentry = MyBEEntry;+ TimestampTz start_timestamp;+ TimestampTz current_timestamp;+ int len = 0;++ TRACE_POSTGRESQL_STATEMENT_STATUS(cmd_str);++ if (!beentry)+ return;++ if (!pgstat_track_activities)+ {+ if (beentry->st_state != STATE_DISABLED)+ {+ volatile PGPROC *proc = MyProc;++ /*+ * track_activities is disabled, but we last reported a+ * non-disabled state. As our final update, change the state and+ * clear fields we will not be updating anymore.+ */+ PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);+ beentry->st_state = STATE_DISABLED;+ beentry->st_state_start_timestamp = 0;+ beentry->st_activity_raw[0] = '\0';+ beentry->st_activity_start_timestamp = 0;+ /* st_xact_start_timestamp and wait_event_info are also disabled */+ beentry->st_xact_start_timestamp = 0;+ proc->wait_event_info = 0;+ PGSTAT_END_WRITE_ACTIVITY(beentry);+ }+ return;+ }++ /*+ * To minimize the time spent modifying the entry, and avoid risk of+ * errors inside the critical section, fetch all the needed data first.+ */+ start_timestamp = GetCurrentStatementStartTimestamp();+ if (cmd_str != NULL)+ {+ /*+ * Compute length of to-be-stored string unaware of multi-byte+ * characters. For speed reasons that'll get corrected on read, rather+ * than computed every write.+ */+ len = Min(strlen(cmd_str), pgstat_track_activity_query_size - 1);+ }+ current_timestamp = GetCurrentTimestamp();++ /*+ * If the state has changed from "active" or "idle in transaction",+ * calculate the duration.+ */+ if ((beentry->st_state == STATE_RUNNING ||+ beentry->st_state == STATE_FASTPATH ||+ beentry->st_state == STATE_IDLEINTRANSACTION ||+ beentry->st_state == STATE_IDLEINTRANSACTION_ABORTED) &&+ state != beentry->st_state)+ {+ long secs;+ int usecs;++ TimestampDifference(beentry->st_state_start_timestamp,+ current_timestamp,+ &secs, &usecs);++ if (beentry->st_state == STATE_RUNNING ||+ beentry->st_state == STATE_FASTPATH)+ pgstat_count_conn_active_time(secs * 1000000 + usecs);+ else+ pgstat_count_conn_txn_idle_time(secs * 1000000 + usecs);+ }++ /*+ * Now update the status entry+ */+ PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);++ beentry->st_state = state;+ beentry->st_state_start_timestamp = current_timestamp;++ if (cmd_str != NULL)+ {+ memcpy((char *) beentry->st_activity_raw, cmd_str, len);+ beentry->st_activity_raw[len] = '\0';+ beentry->st_activity_start_timestamp = start_timestamp;+ }++ PGSTAT_END_WRITE_ACTIVITY(beentry);+}++/* ----------+ * pgstat_report_appname() -+ *+ * Called to update our application name.+ * ----------+ */+void+pgstat_report_appname(const char *appname)+{+ volatile PgBackendStatus *beentry = MyBEEntry;+ int len;++ if (!beentry)+ return;++ /* This should be unnecessary if GUC did its job, but be safe */+ len = pg_mbcliplen(appname, strlen(appname), NAMEDATALEN - 1);++ /*+ * Update my status entry, following the protocol of bumping+ * st_changecount before and after. We use a volatile pointer here to+ * ensure the compiler doesn't try to get cute.+ */+ PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);++ memcpy((char *) beentry->st_appname, appname, len);+ beentry->st_appname[len] = '\0';++ PGSTAT_END_WRITE_ACTIVITY(beentry);+}++/*+ * Report current transaction start timestamp as the specified value.+ * Zero means there is no active transaction.+ */+void+pgstat_report_xact_timestamp(TimestampTz tstamp)+{+ volatile PgBackendStatus *beentry = MyBEEntry;++ if (!pgstat_track_activities || !beentry)+ return;++ /*+ * Update my status entry, following the protocol of bumping+ * st_changecount before and after. We use a volatile pointer here to+ * ensure the compiler doesn't try to get cute.+ */+ PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);++ beentry->st_xact_start_timestamp = tstamp;++ PGSTAT_END_WRITE_ACTIVITY(beentry);+}++/* ----------+ * pgstat_read_current_status() -+ *+ * Copy the current contents of the PgBackendStatus array to local memory,+ * if not already done in this transaction.+ * ----------+ */+static void+pgstat_read_current_status(void)+{+ volatile PgBackendStatus *beentry;+ LocalPgBackendStatus *localtable;+ LocalPgBackendStatus *localentry;+ char *localappname,+ *localclienthostname,+ *localactivity;+#ifdef USE_SSL+ PgBackendSSLStatus *localsslstatus;+#endif+#ifdef ENABLE_GSS+ PgBackendGSSStatus *localgssstatus;+#endif+ int i;++ Assert(IsUnderPostmaster); // XXX?+ if (localBackendStatusTable)+ return; /* already done */++ pgbestat_setup_memcxt();++ /*+ * Allocate storage for local copy of state data. We can presume that+ * none of these requests overflow size_t, because we already calculated+ * the same values using mul_size during shmem setup. However, with+ * probably-silly values of pgstat_track_activity_query_size and+ * max_connections, the localactivity buffer could exceed 1GB, so use+ * "huge" allocation for that one.+ */+ localtable = (LocalPgBackendStatus *)+ MemoryContextAlloc(pgBeStatLocalContext,+ sizeof(LocalPgBackendStatus) * NumBackendStatSlots);+ localappname = (char *)+ MemoryContextAlloc(pgBeStatLocalContext,+ NAMEDATALEN * NumBackendStatSlots);+ localclienthostname = (char *)+ MemoryContextAlloc(pgBeStatLocalContext,+ NAMEDATALEN * NumBackendStatSlots);+ localactivity = (char *)+ MemoryContextAllocHuge(pgBeStatLocalContext,+ pgstat_track_activity_query_size * NumBackendStatSlots);+#ifdef USE_SSL+ localsslstatus = (PgBackendSSLStatus *)+ MemoryContextAlloc(pgBeStatLocalContext,+ sizeof(PgBackendSSLStatus) * NumBackendStatSlots);+#endif+#ifdef ENABLE_GSS+ localgssstatus = (PgBackendGSSStatus *)+ MemoryContextAlloc(pgBeStatLocalContext,+ sizeof(PgBackendGSSStatus) * NumBackendStatSlots);+#endif++ localNumBackends = 0;++ beentry = BackendStatusArray;+ localentry = localtable;+ for (i = 1; i <= NumBackendStatSlots; i++)+ {+ /*+ * Follow the protocol of retrying if st_changecount changes while we+ * copy the entry, or if it's odd. (The check for odd is needed to+ * cover the case where we are able to completely copy the entry while+ * the source backend is between increment steps.) We use a volatile+ * pointer here to ensure the compiler doesn't try to get cute.+ */+ for (;;)+ {+ int before_changecount;+ int after_changecount;++ pgstat_begin_read_activity(beentry, before_changecount);++ localentry->backendStatus.st_procpid = beentry->st_procpid;+ /* Skip all the data-copying work if entry is not in use */+ if (localentry->backendStatus.st_procpid > 0)+ {+ memcpy(&localentry->backendStatus, unvolatize(PgBackendStatus *, beentry), sizeof(PgBackendStatus));++ /*+ * For each PgBackendStatus field that is a pointer, copy the+ * pointed-to data, then adjust the local copy of the pointer+ * field to point at the local copy of the data.+ *+ * strcpy is safe even if the string is modified concurrently,+ * because there's always a \0 at the end of the buffer.+ */+ strcpy(localappname, (char *) beentry->st_appname);+ localentry->backendStatus.st_appname = localappname;+ strcpy(localclienthostname, (char *) beentry->st_clienthostname);+ localentry->backendStatus.st_clienthostname = localclienthostname;+ strcpy(localactivity, (char *) beentry->st_activity_raw);+ localentry->backendStatus.st_activity_raw = localactivity;+#ifdef USE_SSL+ if (beentry->st_ssl)+ {+ memcpy(localsslstatus, beentry->st_sslstatus, sizeof(PgBackendSSLStatus));+ localentry->backendStatus.st_sslstatus = localsslstatus;+ }+#endif+#ifdef ENABLE_GSS+ if (beentry->st_gss)+ {+ memcpy(localgssstatus, beentry->st_gssstatus, sizeof(PgBackendGSSStatus));+ localentry->backendStatus.st_gssstatus = localgssstatus;+ }+#endif+ }++ pgstat_end_read_activity(beentry, after_changecount);++ if (pgstat_read_activity_complete(before_changecount,+ after_changecount))+ break;++ /* Make sure we can break out of loop if stuck... */+ CHECK_FOR_INTERRUPTS();+ }++ beentry++;+ /* Only valid entries get included into the local array */+ if (localentry->backendStatus.st_procpid > 0)+ {+ BackendIdGetTransactionIds(i,+ &localentry->backend_xid,+ &localentry->backend_xmin);++ localentry++;+ localappname += NAMEDATALEN;+ localclienthostname += NAMEDATALEN;+ localactivity += pgstat_track_activity_query_size;+#ifdef USE_SSL+ localsslstatus++;+#endif+#ifdef ENABLE_GSS+ localgssstatus++;+#endif+ localNumBackends++;+ }+ }++ /* Set the pointer only after completion of a valid table */+ localBackendStatusTable = localtable;+}+++/* ----------+ * pgstat_get_backend_current_activity() -+ *+ * Return a string representing the current activity of the backend with+ * the specified PID. This looks directly at the BackendStatusArray,+ * and so will provide current information regardless of the age of our+ * transaction's snapshot of the status array.+ *+ * It is the caller's responsibility to invoke this only for backends whose+ * state is expected to remain stable while the result is in use. The+ * only current use is in deadlock reporting, where we can expect that+ * the target backend is blocked on a lock. (There are corner cases+ * where the target's wait could get aborted while we are looking at it,+ * but the very worst consequence is to return a pointer to a string+ * that's been changed, so we won't worry too much.)+ *+ * Note: return strings for special cases match pg_stat_get_backend_activity.+ * ----------+ */+const char *+pgstat_get_backend_current_activity(int pid, bool checkUser)+{+ PgBackendStatus *beentry;+ int i;++ beentry = BackendStatusArray;+ for (i = 1; i <= MaxBackends; i++)+ {+ /*+ * Although we expect the target backend's entry to be stable, that+ * doesn't imply that anyone else's is. To avoid identifying the+ * wrong backend, while we check for a match to the desired PID we+ * must follow the protocol of retrying if st_changecount changes+ * while we examine the entry, or if it's odd. (This might be+ * unnecessary, since fetching or storing an int is almost certainly+ * atomic, but let's play it safe.) We use a volatile pointer here to+ * ensure the compiler doesn't try to get cute.+ */+ volatile PgBackendStatus *vbeentry = beentry;+ bool found;++ for (;;)+ {+ int before_changecount;+ int after_changecount;++ pgstat_begin_read_activity(vbeentry, before_changecount);++ found = (vbeentry->st_procpid == pid);++ pgstat_end_read_activity(vbeentry, after_changecount);++ if (pgstat_read_activity_complete(before_changecount,+ after_changecount))+ break;++ /* Make sure we can break out of loop if stuck... */+ CHECK_FOR_INTERRUPTS();+ }++ if (found)+ {+ /* Now it is safe to use the non-volatile pointer */+ if (checkUser && !superuser() && beentry->st_userid != GetUserId())+ return "<insufficient privilege>";+ else if (*(beentry->st_activity_raw) == '\0')+ return "<command string not enabled>";+ else+ {+ /* this'll leak a bit of memory, but that seems acceptable */+ return pgstat_clip_activity(beentry->st_activity_raw);+ }+ }++ beentry++;+ }++ /* If we get here, caller is in error ... */+ return "<backend information not available>";+}++/* ----------+ * pgstat_get_crashed_backend_activity() -+ *+ * Return a string representing the current activity of the backend with+ * the specified PID. Like the function above, but reads shared memory with+ * the expectation that it may be corrupt. On success, copy the string+ * into the "buffer" argument and return that pointer. On failure,+ * return NULL.+ *+ * This function is only intended to be used by the postmaster to report the+ * query that crashed a backend. In particular, no attempt is made to+ * follow the correct concurrency protocol when accessing the+ * BackendStatusArray. But that's OK, in the worst case we'll return a+ * corrupted message. We also must take care not to trip on ereport(ERROR).+ * ----------+ */+const char *+pgstat_get_crashed_backend_activity(int pid, char *buffer, int buflen)+{+ volatile PgBackendStatus *beentry;+ int i;++ beentry = BackendStatusArray;++ /*+ * We probably shouldn't get here before shared memory has been set up,+ * but be safe.+ */+ if (beentry == NULL || BackendActivityBuffer == NULL)+ return NULL;++ for (i = 1; i <= MaxBackends; i++)+ {+ if (beentry->st_procpid == pid)+ {+ /* Read pointer just once, so it can't change after validation */+ const char *activity = beentry->st_activity_raw;+ const char *activity_last;++ /*+ * We mustn't access activity string before we verify that it+ * falls within the BackendActivityBuffer. To make sure that the+ * entire string including its ending is contained within the+ * buffer, subtract one activity length from the buffer size.+ */+ activity_last = BackendActivityBuffer + BackendActivityBufferSize+ - pgstat_track_activity_query_size;++ if (activity < BackendActivityBuffer ||+ activity > activity_last)+ return NULL;++ /* If no string available, no point in a report */+ if (activity[0] == '\0')+ return NULL;++ /*+ * Copy only ASCII-safe characters so we don't run into encoding+ * problems when reporting the message; and be sure not to run off+ * the end of memory. As only ASCII characters are reported, it+ * doesn't seem necessary to perform multibyte aware clipping.+ */+ ascii_safe_strlcpy(buffer, activity,+ Min(buflen, pgstat_track_activity_query_size));++ return buffer;+ }++ beentry++;+ }++ /* PID not found */+ return NULL;+}+++/* ----------+ * pgstat_fetch_stat_beentry() -+ *+ * Support function for the SQL-callable pgstat* functions. Returns+ * our local copy of the current-activity entry for one backend.+ *+ * NB: caller is responsible for a check if the user is permitted to see+ * this info (especially the querystring).+ * ----------+ */+PgBackendStatus *+pgstat_fetch_stat_beentry(int beid)+{+ pgstat_read_current_status();++ if (beid < 1 || beid > localNumBackends)+ return NULL;++ return &localBackendStatusTable[beid - 1].backendStatus;+}+++/* ----------+ * pgstat_fetch_stat_local_beentry() -+ *+ * Like pgstat_fetch_stat_beentry() but with locally computed additions (like+ * xid and xmin values of the backend)+ *+ * NB: caller is responsible for a check if the user is permitted to see+ * this info (especially the querystring).+ * ----------+ */+LocalPgBackendStatus *+pgstat_fetch_stat_local_beentry(int beid)+{+ pgstat_read_current_status();++ if (beid < 1 || beid > localNumBackends)+ return NULL;++ return &localBackendStatusTable[beid - 1];+}+++/* ----------+ * pgstat_fetch_stat_numbackends() -+ *+ * Support function for the SQL-callable pgstat* functions. Returns+ * the maximum current backend id.+ * ----------+ */+int+pgstat_fetch_stat_numbackends(void)+{+ pgstat_read_current_status();++ return localNumBackends;+}++/*+ * Convert a potentially unsafely truncated activity string (see+ * PgBackendStatus.st_activity_raw's documentation) into a correctly truncated+ * one.+ *+ * The returned string is allocated in the caller's memory context and may be+ * freed.+ */+char *+pgstat_clip_activity(const char *raw_activity)+{+ char *activity;+ int rawlen;+ int cliplen;++ /*+ * Some callers, like pgstat_get_backend_current_activity(), do not+ * guarantee that the buffer isn't concurrently modified. We try to take+ * care that the buffer is always terminated by a NUL byte regardless, but+ * let's still be paranoid about the string's length. In those cases the+ * underlying buffer is guaranteed to be pgstat_track_activity_query_size+ * large.+ */+ activity = pnstrdup(raw_activity, pgstat_track_activity_query_size - 1);++ /* now double-guaranteed to be NUL terminated */+ rawlen = strlen(activity);++ /*+ * All supported server-encodings make it possible to determine the length+ * of a multi-byte character from its first byte (this is not the case for+ * client encodings, see GB18030). As st_activity is always stored using+ * server encoding, this allows us to perform multi-byte aware truncation,+ * even if the string earlier was truncated in the middle of a multi-byte+ * character.+ */+ cliplen = pg_mbcliplen(activity, rawlen,+ pgstat_track_activity_query_size - 1);++ activity[cliplen] = '\0';++ return activity;+}--
2.29.2.540.g3cf59784d4
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Reply to all the recipients using the --to and --cc options:
reply via email
To: pgsql-hackers@postgresql.org
Cc: andres@anarazel.de, magnus@hagander.net, horikyota.ntt@gmail.com, masao.fujii@oss.nttdata.com, gkokolatos@protonmail.com, pgsql-hackers@lists.postgresql.org
Subject: Re: shared-memory based stats collector
In-Reply-To: <20210316025541.rjddr2djzfekga4d@alap3.anarazel.de>
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
This inbox is served by DDX for PostgreSQL; see mirroring instructions
for how to clone and mirror all data and code used for this inbox