diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index 85459d0..4c325bd 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -632,10 +632,47 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser timestamp with time zone Time when the state was last changed + + wait_event_type + text + Wait event type name if backend is currently waiting, otherwise NULL. + Possible values are: + + + + LWLockNamed: The backend is waiting for a specific named LWLock. + The wait_event name for this type of wait is the name of that + LWLock. + + + + + LWLockTranche: The backend is waiting for any one of a + group of locks with a similar function. The wait_event + name for this type of wait identifies the general purpose of locks + in that group. + + + + + Lock: The backend is waiting for a lock. + + + + + BufferPin: The server process is waiting for all other + processes to release the buffer pin. + + + + + - waiting - boolean - True if this backend is currently waiting on a lock + wait_event + text + Wait event name if backend is currently waiting, otherwise NULL. + See for details. + state @@ -712,15 +749,386 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser - The waiting and state columns are + The wait_event and state columns are independent. If a backend is in the active state, - it may or may not be waiting. If the state is - active and waiting is true, it means - that a query is being executed, but is being blocked by a lock - somewhere in the system. + it may or may not be waiting on some event. If the state + is active and wait_event is non-null, it + means that a query is being executed, but is being blocked somewhere + in the system. + + <structname>wait_event</structname> Description + + + + + Wait Event Name + Description + + + + + + ShmemIndexLock + A server process is waiting to find or allocate space in shared + memory. + + + OidGenLock + A server process is waiting to allocate or assign an OID. + + + XidGenLock + A server process is waiting to allocate or assign a transaction id. + + + ProcArrayLock + A server process is waiting to get a snapshot or clearing a + transaction id at transaction end. + + + SInvalReadLock + A server process is waiting to retrieve or remove messages + from shared invalidation queue. + + + SInvalWriteLock + A server process is waiting to add a message in shared + invalidation queue. + + + WALBufMappingLock + A server process is waiting to replace a page in WAL buffers. + + + WALWriteLock + A server process is waiting for WAL buffers to be written to + disk. + + + ControlFileLock + A server process is waiting to read or update the control file + or creation of a new WAL file. + + + CheckpointLock + A server process is waiting to perform checkpoint. + + + CLogControlLock + A server process is waiting to read or update the transaction + status. + + + SubtransControlLock + A server process is waiting to read or update the sub-transaction + file. + + + MultiXactGenLock + A server process is waiting to read or update the multixact + state. + + + MultiXactOffsetControlLock + A server process is waiting to read or update the multixact + status file. + + + MultiXactMemberControlLock + A server process is waiting to read or update the multixact + status file. + + + RelCacheInitLock + A server process is waiting to read or write to the relation cache + initialization file. + + + CheckpointerCommLock + A server process is waiting to process fsync requeusts by backends. + + + TwoPhaseStateLock + A server process is waiting to read or update the state of + prepared transactions. + + + TablespaceCreateLock + A server process is waiting to create or drop the tablespace. + + + BtreeVacuumLock + A server process is waiting to read or update vacuum-related + information for a Btree index. + + + AddinShmemInitLock + A server process is waiting on another process to allocate + space in shared memory. + + + AutovacuumLock + A server process which could be that an autovacuum worker or + autovacuum launcher is waiting to update or read the current state + of autovacuum workers. + + + AutovacuumScheduleLock + A server process is waiting on another process to ensure that + the table it has selected for a vacuum still needs vacuuming. + + + + SyncScanLock + A server process is waiting to get the start location of a scan + on a table for synchronized scans. + + + RelationMappingLock + A server process is waiting to update the relation map file + used to store catalog to filenode mapping. + + + + AsyncCtlLock + A server process is waiting to read or update notification + messages. + + + AsyncQueueLock + + A server process is waiting to read or update notification + messages. + + + SerializableXactHashLock + A server process is waiting to retrieve or store information + about serializable transactions. + + + SerializableFinishedListLock + A server process is waiting to access the list of finished + serializable transactions. + + + SerializablePredicateLockListLock + A server process is waiting to perform an operation on a list of + locks held by serializable transactions. + + + OldSerXidLock + A server process is waiting to read or record conflicting + serializable transactions. + + + SyncRepLock + A server process is waiting to read or update information of + synchronous replicas. + + + BackgroundWorkerLock + A server process is waiting to read or update information of + background workers. + + + DynamicSharedMemoryControlLock + A server process is waiting to update information of dynamic + shared memory. + + + AutoFileLock + A server process is waiting to update the postgresql.auto.conf + file. + + + ReplicationSlotAllocationLock + A server process is waiting to allocate or free a replication slot. + + + ReplicationSlotControlLock + A server process is waiting to read or update information of + replication slots. + + + CommitTsControlLock + A server process is waiting to read or update the transaction + timestamp. + + + CommitTsLock + A server process is waiting to read or update the last value + set for the transaction timestamp. + + + ReplicationOriginLock + A server process is waiting to setup, drop or use replication + origin. + + + MultiXactTruncationLock + A server process is waiting to read or truncate multixact information. + + + clog + A server process is waiting on any one of the clog buffer locks + to read or write the clog page in the pg_clog subdirectory. + + + commit_timestamp + A server process is waiting on any one of the commit_timestamp + buffer locks to read or write the commit_timestamp page in the + pg_commit_ts subdirectory. + + + subtrans + A server process is waiting on any one of the subtrans buffer + locks to read or write the subtrans page in the pg_subtrans subdirectory. + + + multixact_offset + A server process is waiting on any one of the multixact_offset + buffer locks to read or write the multixact_offset page in the pg_multixact + subdirectory. + + + multixact_member + A server process is waiting on any one of the multixact_member + buffer locks to read or write the multixact_offset page in the pg_multixact + subdirectory. + + + async + A server process is waiting on any one of the async buffer locks + to read or write the page in the pg_notify subdirectory. + + + oldserxid + A server process is waiting on any one of the oldserxid + buffer locks to read or write the page in pg_serial subdirectory. + + + wal_insert + A server process is waiting on any one of the wal_insert locks + to write data into wal buffers. + + + buffer_content + A server process is waiting on any one of the buffer_content + locks to read or write data into shared buffers. + + + buffer_io + A server process is waiting on any one of the buffer_io locks + to allow another process to complete the I/O on buffer. + + + replication_origin + A server process is waiting on any one of the replication_origin + locks to read or update the replication progress. + + + replication_slot_io + A server process is waiting on any one of the replication_slot_io + locks to update the replication slot information on disk. + + + proc + A server process is waiting on any one of the proc locks to + read or update the fast-path lock information. + + + buffer_mapping + A server process is waiting on any one of the buffer_mapping + locks to associate a data block with a buffer in the buffer pool. + + + lock_manager + A server process is waiting on any one of the lock_manager locks + to add or examine locks for backends or waiting on joining/exiting a + parallel group to perform a parallel query. + + + predicate_lock_manager + A server process is waiting on any one of the predicate_lock_manager + locks to add or examine predicate lock information. + + + + relation + A server process is waiting to acquire a lock on a relation. + + + extend + A server process is waiting to extend a relation. + + + page + A server process is waiting to acquire a lock on page of a relation. + + + tuple + A server process is waiting to acquire a lock on a tuple. + + + transactionid + A server process is waiting for a transaction to finish. + + + virtualxid + A server process is waiting to acquire a virtual xid lock. + + + speculative token + A server process is waiting to acquire a speculative insertion lock. + + + object + A server process is waiting to acquire a lock on a non-relation + database object. + + + userlock + A server process is waiting to acquire a userlock. + + + advisory + A server process is waiting to acquire an advisory user lock. + + + BufferPin + A server process is waiting to acquire a pin on a buffer. + + + +
+ + + + For tranches registered by extensions, the name is specified by extension + and this will be displayed as wait_event. It is quite + possible that user has registered the tranche in one of the backends (by + having allocation in dynamic shared memory) in which case other backends + won't have that information, so we display extension for such + cases. + + + + + Here is an example of how wait events can be viewed + + +SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event is NOT NULL; + pid | wait_event_type | wait_event +------+-----------------+--------------- + 2540 | Lock | relation + 6644 | LWLockNamed | ProcArrayLock +(2 rows) + + + <structname>pg_stat_replication</structname> View @@ -2030,10 +2438,18 @@ SELECT pg_stat_get_backend_pid(s.backendid) AS pid, OID of the user logged into this backend + + pg_stat_get_backend_wait_event_type(integer) + text + Wait event type name if backend is currently waiting, otherwise NULL. + See for details. + + + - pg_stat_get_backend_waiting(integer) - boolean - True if this backend is currently waiting on a lock + pg_stat_get_backend_wait_event(integer) + text + Wait event name if backend is currently waiting, otherwise NULL diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index b0d5440..7298a00 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -2589,6 +2589,9 @@ AbortTransaction(void) pgstat_report_xact_timestamp(0); } + /* Report wait end here, when there is no further possibility of wait */ + pgstat_report_wait_end(); + /* * State remains TRANS_ABORT until CleanupTransaction(). */ @@ -4649,6 +4652,9 @@ AbortSubTransaction(void) */ XactReadOnly = s->prevXactReadOnly; + /* Report wait end here, when there is no further possibility of wait */ + pgstat_report_wait_end(); + RESUME_INTERRUPTS(); } diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c index 6c75099..4b06a65 100644 --- a/src/backend/bootstrap/bootstrap.c +++ b/src/backend/bootstrap/bootstrap.c @@ -26,6 +26,7 @@ #include "miscadmin.h" #include "nodes/makefuncs.h" #include "pg_getopt.h" +#include "pgstat.h" #include "postmaster/bgwriter.h" #include "postmaster/startup.h" #include "postmaster/walwriter.h" @@ -534,6 +535,9 @@ static void ShutdownAuxiliaryProcess(int code, Datum arg) { LWLockReleaseAll(); + + /* Report wait end here, when there is no further possibility of wait */ + pgstat_report_wait_end(); } /* ---------------------------------------------------------------- diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql index abf9a70..84aa061 100644 --- a/src/backend/catalog/system_views.sql +++ b/src/backend/catalog/system_views.sql @@ -636,7 +636,8 @@ CREATE VIEW pg_stat_activity AS S.xact_start, S.query_start, S.state_change, - S.waiting, + S.wait_event_type, + S.wait_event, S.state, S.backend_xid, s.backend_xmin, diff --git a/src/backend/postmaster/bgwriter.c b/src/backend/postmaster/bgwriter.c index 4ff4caf..ad94816 100644 --- a/src/backend/postmaster/bgwriter.c +++ b/src/backend/postmaster/bgwriter.c @@ -224,6 +224,9 @@ BackgroundWriterMain(void) * It's not clear we need it elsewhere, but shouldn't hurt. */ smgrcloseall(); + + /* Report wait end here, when there is no further possibility of wait */ + pgstat_report_wait_end(); } /* We can now handle ereport(ERROR) */ diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c index aabb928..3e15cf1 100644 --- a/src/backend/postmaster/checkpointer.c +++ b/src/backend/postmaster/checkpointer.c @@ -322,6 +322,9 @@ CheckpointerMain(void) * It's not clear we need it elsewhere, but shouldn't hurt. */ smgrcloseall(); + + /* Report wait end here, when there is no further possibility of wait */ + pgstat_report_wait_end(); } /* We can now handle ereport(ERROR) */ diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c index da768c6..a060ac2 100644 --- a/src/backend/postmaster/pgstat.c +++ b/src/backend/postmaster/pgstat.c @@ -48,12 +48,12 @@ #include "postmaster/autovacuum.h" #include "postmaster/fork_process.h" #include "postmaster/postmaster.h" -#include "storage/proc.h" #include "storage/backendid.h" #include "storage/dsm.h" #include "storage/fd.h" #include "storage/ipc.h" #include "storage/latch.h" +#include "storage/lmgr.h" #include "storage/pg_shmem.h" #include "storage/procsignal.h" #include "storage/sinvaladt.h" @@ -2723,7 +2723,6 @@ pgstat_bestart(void) #else beentry->st_ssl = false; #endif - beentry->st_waiting = false; beentry->st_state = STATE_UNDEFINED; beentry->st_appname[0] = '\0'; beentry->st_activity[0] = '\0'; @@ -2803,6 +2802,8 @@ pgstat_report_activity(BackendState state, const char *cmd_str) { 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 @@ -2813,9 +2814,9 @@ pgstat_report_activity(BackendState state, const char *cmd_str) beentry->st_state_start_timestamp = 0; beentry->st_activity[0] = '\0'; beentry->st_activity_start_timestamp = 0; - /* st_xact_start_timestamp and st_waiting are also disabled */ + /* st_xact_start_timestamp and wait_event_info are also disabled */ beentry->st_xact_start_timestamp = 0; - beentry->st_waiting = false; + proc->wait_event_info = 0; pgstat_increment_changecount_after(beentry); } return; @@ -2905,32 +2906,6 @@ pgstat_report_xact_timestamp(TimestampTz tstamp) } /* ---------- - * pgstat_report_waiting() - - * - * Called from lock manager to report beginning or end of a lock wait. - * - * NB: this *must* be able to survive being called before MyBEEntry has been - * initialized. - * ---------- - */ -void -pgstat_report_waiting(bool waiting) -{ - volatile PgBackendStatus *beentry = MyBEEntry; - - if (!pgstat_track_activities || !beentry) - return; - - /* - * Since this is a single-byte field in a struct that only this process - * may modify, there seems no need to bother with the st_changecount - * protocol. The update must appear atomic in any case. - */ - beentry->st_waiting = waiting; -} - - -/* ---------- * pgstat_read_current_status() - * * Copy the current contents of the PgBackendStatus array to local memory, @@ -3045,6 +3020,89 @@ 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) +{ + uint8 classId; + const char *event_type; + + /* report process as not waiting. */ + if (wait_event_info == 0) + return NULL; + + wait_event_info = wait_event_info >> 24; + classId = wait_event_info & 0XFF; + + switch (classId) + { + case WAIT_LWLOCK_NAMED: + event_type = "LWLockNamed"; + break; + case WAIT_LWLOCK_TRANCHE: + event_type = "LWLockTranche"; + break; + case WAIT_LOCK: + event_type = "Lock"; + break; + case WAIT_BUFFER_PIN: + event_type = "BufferPin"; + break; + default: + event_type = "unknown wait 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) +{ + uint8 classId; + uint16 eventId; + const char *event_name; + + /* report process as not waiting. */ + if (wait_event_info == 0) + return NULL; + + eventId = wait_event_info & ((1 << 24) - 1); + wait_event_info = wait_event_info >> 24; + classId = wait_event_info & 0XFF; + + switch (classId) + { + case WAIT_LWLOCK_NAMED: + event_name = GetLWLockName(classId, eventId); + break; + case WAIT_LWLOCK_TRANCHE: + event_name = GetLWLockName(classId, eventId); + break; + case WAIT_LOCK: + event_name = GetLockNameFromTagType(eventId); + break; + case WAIT_BUFFER_PIN: + event_name = "BufferPin"; + break; + default: + event_name = "unknown wait event"; + break; + } + + return event_name; +} /* ---------- * pgstat_get_backend_current_activity() - diff --git a/src/backend/postmaster/walwriter.c b/src/backend/postmaster/walwriter.c index 9852fed..fb2d57e 100644 --- a/src/backend/postmaster/walwriter.c +++ b/src/backend/postmaster/walwriter.c @@ -47,6 +47,7 @@ #include "access/xlog.h" #include "libpq/pqsignal.h" #include "miscadmin.h" +#include "pgstat.h" #include "postmaster/walwriter.h" #include "storage/bufmgr.h" #include "storage/fd.h" @@ -206,6 +207,9 @@ WalWriterMain(void) * It's not clear we need it elsewhere, but shouldn't hurt. */ smgrcloseall(); + + /* Report wait end here, when there is no further possibility of wait */ + pgstat_report_wait_end(); } /* We can now handle ereport(ERROR) */ diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index c03e045..7613604 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -55,6 +55,7 @@ #include "libpq/pqformat.h" #include "miscadmin.h" #include "nodes/replnodes.h" +#include "pgstat.h" #include "replication/basebackup.h" #include "replication/decode.h" #include "replication/logical.h" @@ -268,6 +269,9 @@ WalSndErrorCleanup(void) /* Revert back to startup state */ WalSndSetState(WALSNDSTATE_STARTUP); + + /* Report wait end here, when there is no further possibility of wait */ + pgstat_report_wait_end(); } /* diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index 68cf5cc..e8e0825 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -3351,6 +3351,9 @@ LockBufferForCleanup(Buffer buffer) UnlockBufHdr(bufHdr); LockBuffer(buffer, BUFFER_LOCK_UNLOCK); + /* Report the wait */ + pgstat_report_wait_start(WAIT_BUFFER_PIN, 0); + /* Wait to be signaled by UnpinBuffer() */ if (InHotStandby) { @@ -3364,6 +3367,8 @@ LockBufferForCleanup(Buffer buffer) else ProcWaitForSignal(); + pgstat_report_wait_end(); + /* * Remove flag marking us as waiter. Normally this will not be set * anymore, but ProcWaitForSignal() can return for other signals as diff --git a/src/backend/storage/lmgr/lmgr.c b/src/backend/storage/lmgr/lmgr.c index 9d16afb..9d2663e 100644 --- a/src/backend/storage/lmgr/lmgr.c +++ b/src/backend/storage/lmgr/lmgr.c @@ -994,3 +994,26 @@ DescribeLockTag(StringInfo buf, const LOCKTAG *tag) break; } } + +/* + * GetLockNameFromTagType + * + * Given locktag type, return the corresponding lock name. + */ +const char * +GetLockNameFromTagType(uint16 locktag_type) +{ + const char *locktypename; + char tnbuf[32]; + + if (locktag_type <= LOCKTAG_LAST_TYPE) + locktypename = LockTagTypeNames[locktag_type]; + else + { + snprintf(tnbuf, sizeof(tnbuf), "unknown %d", + (int) locktag_type); + locktypename = tnbuf; + } + + return locktypename; +} diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c index a458c68..b30b7b1 100644 --- a/src/backend/storage/lmgr/lock.c +++ b/src/backend/storage/lmgr/lock.c @@ -1676,7 +1676,7 @@ WaitOnLock(LOCALLOCK *locallock, ResourceOwner owner) set_ps_display(new_status, false); new_status[len] = '\0'; /* truncate off " waiting" */ } - pgstat_report_waiting(true); + pgstat_report_wait_start(WAIT_LOCK, locallock->tag.lock.locktag_type); awaitedLock = locallock; awaitedOwner = owner; @@ -1724,7 +1724,7 @@ WaitOnLock(LOCALLOCK *locallock, ResourceOwner owner) /* In this path, awaitedLock remains set until LockErrorCleanup */ /* Report change to non-waiting status */ - pgstat_report_waiting(false); + pgstat_report_wait_end(); if (update_process_title) { set_ps_display(new_status, false); @@ -1739,7 +1739,7 @@ WaitOnLock(LOCALLOCK *locallock, ResourceOwner owner) awaitedLock = NULL; /* Report change to non-waiting status */ - pgstat_report_waiting(false); + pgstat_report_wait_end(); if (update_process_title) { set_ps_display(new_status, false); diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c index d245857..ccd1fd3 100644 --- a/src/backend/storage/lmgr/lwlock.c +++ b/src/backend/storage/lmgr/lwlock.c @@ -77,6 +77,7 @@ #include "postgres.h" #include "miscadmin.h" +#include "pgstat.h" #include "pg_trace.h" #include "postmaster/postmaster.h" #include "replication/slot.h" @@ -165,6 +166,9 @@ static bool lock_named_request_allowed = true; static void InitializeLWLocks(void); static void RegisterLWLockTranches(void); +static inline void LWLockReportStartWait(LWLock *lock); +static inline void LWLockReportEndWait(); + #ifdef LWLOCK_STATS typedef struct lwlock_stats_key { @@ -714,6 +718,66 @@ LWLockInitialize(LWLock *lock, int tranche_id) } /* + * Report start of wait event for light-weight locks. + * + * This function will be used by all the light-weight lock calls which + * needs to wait to acquire the lock. This function distinguishes wait + * event based on tranche and lock id. + */ +static inline void +LWLockReportStartWait(LWLock *lock) +{ + int lockId = T_ID(lock); + + if (lock->tranche == 0) + pgstat_report_wait_start(WAIT_LWLOCK_NAMED, (uint16) lockId); + else + pgstat_report_wait_start(WAIT_LWLOCK_TRANCHE, lock->tranche); +} + +/* + * Report end of wait event for light-weight locks. + */ +static inline void +LWLockReportEndWait() +{ + pgstat_report_wait_end(); +} + +/* + * Return LWLock name for individual locks and tranche name for others. + */ +const char * +GetLWLockName(uint8 classId, uint16 eventId) +{ + const char *lwlockName; + + if (classId == WAIT_LWLOCK_NAMED) + lwlockName = MainLWLockNames[eventId]; + else if (classId == WAIT_LWLOCK_TRANCHE) + { + int *LWLockCounter; + + LWLockCounter = (int *) ((char *) MainLWLockArray - sizeof(int)); + + /* + * It is quite possible that user has registered tranche in one of the + * backends (by having allocation in dynamic shared memory) in which + * case other backends won't have that information, so we display + * extension for such cases. + */ + if (eventId <= *LWLockCounter) + lwlockName = LWLockTrancheArray[eventId]->name; + else + lwlockName = "extension"; + } + else + lwlockName = "unknown lwlock"; + + return lwlockName; +} + +/* * Internal function that tries to atomically acquire the lwlock in the passed * in mode. * @@ -1164,6 +1228,9 @@ LWLockAcquire(LWLock *lock, LWLockMode mode) TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), T_ID(lock), mode); + /* Report the wait */ + LWLockReportStartWait(lock); + for (;;) { PGSemaphoreLock(&proc->sem); @@ -1186,6 +1253,8 @@ LWLockAcquire(LWLock *lock, LWLockMode mode) TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), T_ID(lock), mode); + LWLockReportEndWait(); + LOG_LWDEBUG("LWLockAcquire", lock, "awakened"); /* Now loop back and try to acquire lock again. */ @@ -1322,6 +1391,9 @@ LWLockAcquireOrWait(LWLock *lock, LWLockMode mode) #endif TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), T_ID(lock), mode); + /* Report the wait */ + LWLockReportStartWait(lock); + for (;;) { PGSemaphoreLock(&proc->sem); @@ -1340,6 +1412,8 @@ LWLockAcquireOrWait(LWLock *lock, LWLockMode mode) #endif TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), T_ID(lock), mode); + LWLockReportEndWait(); + LOG_LWDEBUG("LWLockAcquireOrWait", lock, "awakened"); } else @@ -1547,6 +1621,9 @@ LWLockWaitForVar(LWLock *lock, uint64 *valptr, uint64 oldval, uint64 *newval) TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), T_ID(lock), LW_EXCLUSIVE); + /* Report the wait */ + LWLockReportStartWait(lock); + for (;;) { PGSemaphoreLock(&proc->sem); @@ -1567,6 +1644,8 @@ LWLockWaitForVar(LWLock *lock, uint64 *valptr, uint64 oldval, uint64 *newval) TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), T_ID(lock), LW_EXCLUSIVE); + LWLockReportEndWait(); + LOG_LWDEBUG("LWLockWaitForVar", lock, "awakened"); /* Now loop back and check the status of the lock again. */ diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c index 6453b88..59283b2 100644 --- a/src/backend/storage/lmgr/proc.c +++ b/src/backend/storage/lmgr/proc.c @@ -39,6 +39,7 @@ #include "access/twophase.h" #include "access/xact.h" #include "miscadmin.h" +#include "pgstat.h" #include "postmaster/autovacuum.h" #include "replication/slot.h" #include "replication/syncrep.h" @@ -404,6 +405,9 @@ InitProcess(void) Assert(MyProc->lockGroupLeader == NULL); Assert(dlist_is_empty(&MyProc->lockGroupMembers)); + /* Initialize wait event information. */ + MyProc->wait_event_info = 0; + /* * Acquire ownership of the PGPROC's latch, so that we can use WaitLatch * on it. That allows us to repoint the process latch, which so far @@ -837,6 +841,9 @@ ProcKill(int code, Datum arg) LWLockRelease(leader_lwlock); } + /* Report wait end here, when there is no further possibility of wait */ + pgstat_report_wait_end(); + /* * Reset MyLatch to the process local one. This is so that signal * handlers et al can continue using the latch after the shared latch @@ -905,6 +912,9 @@ AuxiliaryProcKill(int code, Datum arg) /* Release any LW locks I am holding (see notes above) */ LWLockReleaseAll(); + /* Report wait end here, when there is no further possibility of wait */ + pgstat_report_wait_end(); + /* * Reset MyLatch to the process local one. This is so that signal * handlers et al can continue using the latch after the shared latch diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c index 6bcab81..2e55368 100644 --- a/src/backend/utils/adt/lockfuncs.c +++ b/src/backend/utils/adt/lockfuncs.c @@ -23,7 +23,7 @@ /* This must match enum LockTagType! */ -static const char *const LockTagTypeNames[] = { +const char *const LockTagTypeNames[] = { "relation", "extend", "page", diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c index 1b22fcc..a7bf57f 100644 --- a/src/backend/utils/adt/pgstatfuncs.c +++ b/src/backend/utils/adt/pgstatfuncs.c @@ -20,6 +20,8 @@ #include "libpq/ip.h" #include "miscadmin.h" #include "pgstat.h" +#include "storage/proc.h" +#include "storage/procarray.h" #include "utils/acl.h" #include "utils/builtins.h" #include "utils/inet.h" @@ -58,7 +60,8 @@ extern Datum pg_stat_get_backend_pid(PG_FUNCTION_ARGS); extern Datum pg_stat_get_backend_dbid(PG_FUNCTION_ARGS); extern Datum pg_stat_get_backend_userid(PG_FUNCTION_ARGS); extern Datum pg_stat_get_backend_activity(PG_FUNCTION_ARGS); -extern Datum pg_stat_get_backend_waiting(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_wait_event_type(PG_FUNCTION_ARGS); +extern Datum pg_stat_get_backend_wait_event(PG_FUNCTION_ARGS); extern Datum pg_stat_get_backend_activity_start(PG_FUNCTION_ARGS); extern Datum pg_stat_get_backend_xact_start(PG_FUNCTION_ARGS); extern Datum pg_stat_get_backend_start(PG_FUNCTION_ARGS); @@ -530,7 +533,7 @@ pg_stat_get_backend_idset(PG_FUNCTION_ARGS) Datum pg_stat_get_activity(PG_FUNCTION_ARGS) { -#define PG_STAT_GET_ACTIVITY_COLS 22 +#define PG_STAT_GET_ACTIVITY_COLS 23 int num_backends = pgstat_fetch_stat_numbackends(); int curr_backend; int pid = PG_ARGISNULL(0) ? -1 : PG_GETARG_INT32(0); @@ -573,6 +576,9 @@ pg_stat_get_activity(PG_FUNCTION_ARGS) bool nulls[PG_STAT_GET_ACTIVITY_COLS]; LocalPgBackendStatus *local_beentry; PgBackendStatus *beentry; + PGPROC *proc; + const char *wait_event_type; + const char *wait_event; MemSet(values, 0, sizeof(values)); MemSet(nulls, 0, sizeof(nulls)); @@ -617,28 +623,28 @@ pg_stat_get_activity(PG_FUNCTION_ARGS) nulls[3] = true; if (TransactionIdIsValid(local_beentry->backend_xid)) - values[14] = TransactionIdGetDatum(local_beentry->backend_xid); + values[15] = TransactionIdGetDatum(local_beentry->backend_xid); else - nulls[14] = true; + nulls[15] = true; if (TransactionIdIsValid(local_beentry->backend_xmin)) - values[15] = TransactionIdGetDatum(local_beentry->backend_xmin); + values[16] = TransactionIdGetDatum(local_beentry->backend_xmin); else - nulls[15] = true; + nulls[16] = true; if (beentry->st_ssl) { - values[16] = BoolGetDatum(true); /* ssl */ - values[17] = CStringGetTextDatum(beentry->st_sslstatus->ssl_version); - values[18] = CStringGetTextDatum(beentry->st_sslstatus->ssl_cipher); - values[19] = Int32GetDatum(beentry->st_sslstatus->ssl_bits); - values[20] = BoolGetDatum(beentry->st_sslstatus->ssl_compression); - values[21] = CStringGetTextDatum(beentry->st_sslstatus->ssl_clientdn); + values[17] = BoolGetDatum(true); /* ssl */ + values[18] = CStringGetTextDatum(beentry->st_sslstatus->ssl_version); + values[19] = CStringGetTextDatum(beentry->st_sslstatus->ssl_cipher); + values[20] = Int32GetDatum(beentry->st_sslstatus->ssl_bits); + values[21] = BoolGetDatum(beentry->st_sslstatus->ssl_compression); + values[22] = CStringGetTextDatum(beentry->st_sslstatus->ssl_clientdn); } else { - values[16] = BoolGetDatum(false); /* ssl */ - nulls[17] = nulls[18] = nulls[19] = nulls[20] = nulls[21] = true; + values[17] = BoolGetDatum(false); /* ssl */ + nulls[18] = nulls[19] = nulls[20] = nulls[21] = nulls[22] = true; } /* Values only available to role member */ @@ -672,36 +678,48 @@ pg_stat_get_activity(PG_FUNCTION_ARGS) } values[5] = CStringGetTextDatum(beentry->st_activity); - values[6] = BoolGetDatum(beentry->st_waiting); - if (beentry->st_xact_start_timestamp != 0) - values[7] = TimestampTzGetDatum(beentry->st_xact_start_timestamp); + proc = BackendPidGetProc(beentry->st_procpid); + wait_event_type = pgstat_get_wait_event_type(proc->wait_event_info); + if (wait_event_type) + values[6] = CStringGetTextDatum(wait_event_type); + else + nulls[6] = true; + + wait_event = pgstat_get_wait_event(proc->wait_event_info); + if (wait_event) + values[7] = CStringGetTextDatum(wait_event); else nulls[7] = true; - if (beentry->st_activity_start_timestamp != 0) - values[8] = TimestampTzGetDatum(beentry->st_activity_start_timestamp); + if (beentry->st_xact_start_timestamp != 0) + values[8] = TimestampTzGetDatum(beentry->st_xact_start_timestamp); else nulls[8] = true; - if (beentry->st_proc_start_timestamp != 0) - values[9] = TimestampTzGetDatum(beentry->st_proc_start_timestamp); + if (beentry->st_activity_start_timestamp != 0) + values[9] = TimestampTzGetDatum(beentry->st_activity_start_timestamp); else nulls[9] = true; - if (beentry->st_state_start_timestamp != 0) - values[10] = TimestampTzGetDatum(beentry->st_state_start_timestamp); + if (beentry->st_proc_start_timestamp != 0) + values[10] = TimestampTzGetDatum(beentry->st_proc_start_timestamp); else nulls[10] = true; + if (beentry->st_state_start_timestamp != 0) + values[11] = TimestampTzGetDatum(beentry->st_state_start_timestamp); + else + nulls[11] = true; + /* A zeroed client addr means we don't know */ memset(&zero_clientaddr, 0, sizeof(zero_clientaddr)); if (memcmp(&(beentry->st_clientaddr), &zero_clientaddr, sizeof(zero_clientaddr)) == 0) { - nulls[11] = true; nulls[12] = true; nulls[13] = true; + nulls[14] = true; } else { @@ -725,20 +743,20 @@ pg_stat_get_activity(PG_FUNCTION_ARGS) if (ret == 0) { clean_ipv6_addr(beentry->st_clientaddr.addr.ss_family, remote_host); - values[11] = DirectFunctionCall1(inet_in, + values[12] = DirectFunctionCall1(inet_in, CStringGetDatum(remote_host)); if (beentry->st_clienthostname && beentry->st_clienthostname[0]) - values[12] = CStringGetTextDatum(beentry->st_clienthostname); + values[13] = CStringGetTextDatum(beentry->st_clienthostname); else - nulls[12] = true; - values[13] = Int32GetDatum(atoi(remote_port)); + nulls[13] = true; + values[14] = Int32GetDatum(atoi(remote_port)); } else { - nulls[11] = true; nulls[12] = true; nulls[13] = true; + nulls[14] = true; } } else if (beentry->st_clientaddr.addr.ss_family == AF_UNIX) @@ -749,16 +767,16 @@ pg_stat_get_activity(PG_FUNCTION_ARGS) * connections we have no permissions to view, or with * errors. */ - nulls[11] = true; nulls[12] = true; - values[13] = DatumGetInt32(-1); + nulls[13] = true; + values[14] = DatumGetInt32(-1); } else { /* Unknown address type, should never happen */ - nulls[11] = true; nulls[12] = true; nulls[13] = true; + nulls[14] = true; } } } @@ -775,6 +793,7 @@ pg_stat_get_activity(PG_FUNCTION_ARGS) nulls[11] = true; nulls[12] = true; nulls[13] = true; + nulls[14] = true; } tuplestore_putvalues(tupstore, tupdesc, values, nulls); @@ -856,23 +875,52 @@ pg_stat_get_backend_activity(PG_FUNCTION_ARGS) PG_RETURN_TEXT_P(cstring_to_text(activity)); } - Datum -pg_stat_get_backend_waiting(PG_FUNCTION_ARGS) +pg_stat_get_backend_wait_event_type(PG_FUNCTION_ARGS) { int32 beid = PG_GETARG_INT32(0); - bool result; PgBackendStatus *beentry; + PGPROC *proc; + const char *wait_event_type; if ((beentry = pgstat_fetch_stat_beentry(beid)) == NULL) - PG_RETURN_NULL(); + wait_event_type = ""; + else if (!has_privs_of_role(GetUserId(), beentry->st_userid)) + wait_event_type = ""; + else + { + proc = BackendPidGetProc(beentry->st_procpid); + wait_event_type = pgstat_get_wait_event_type(proc->wait_event_info); + } - if (!has_privs_of_role(GetUserId(), beentry->st_userid)) + if (!wait_event_type) PG_RETURN_NULL(); - result = beentry->st_waiting; + PG_RETURN_TEXT_P(cstring_to_text(wait_event_type)); +} + +Datum +pg_stat_get_backend_wait_event(PG_FUNCTION_ARGS) +{ + int32 beid = PG_GETARG_INT32(0); + PgBackendStatus *beentry; + PGPROC *proc; + const char *wait_event; + + if ((beentry = pgstat_fetch_stat_beentry(beid)) == NULL) + wait_event = ""; + else if (!has_privs_of_role(GetUserId(), beentry->st_userid)) + wait_event = ""; + else + { + proc = BackendPidGetProc(beentry->st_procpid); + wait_event = pgstat_get_wait_event(proc->wait_event_info); + } + + if (!wait_event) + PG_RETURN_NULL(); - PG_RETURN_BOOL(result); + PG_RETURN_TEXT_P(cstring_to_text(wait_event)); } diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h index 62b9125..d5f5cd1 100644 --- a/src/include/catalog/pg_proc.h +++ b/src/include/catalog/pg_proc.h @@ -2708,7 +2708,7 @@ DATA(insert OID = 3057 ( pg_stat_get_autoanalyze_count PGNSP PGUID 12 1 0 0 0 f DESCR("statistics: number of auto analyzes for a table"); DATA(insert OID = 1936 ( pg_stat_get_backend_idset PGNSP PGUID 12 1 100 0 0 f f f f t t s r 0 0 23 "" _null_ _null_ _null_ _null_ _null_ pg_stat_get_backend_idset _null_ _null_ _null_ )); DESCR("statistics: currently active backend IDs"); -DATA(insert OID = 2022 ( pg_stat_get_activity PGNSP PGUID 12 1 100 0 0 f f f f f t s r 1 0 2249 "23" "{23,26,23,26,25,25,25,16,1184,1184,1184,1184,869,25,23,28,28,16,25,25,23,16,25}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,datid,pid,usesysid,application_name,state,query,waiting,xact_start,query_start,backend_start,state_change,client_addr,client_hostname,client_port,backend_xid,backend_xmin,ssl,sslversion,sslcipher,sslbits,sslcompression,sslclientdn}" _null_ _null_ pg_stat_get_activity _null_ _null_ _null_ )); +DATA(insert OID = 2022 ( pg_stat_get_activity PGNSP PGUID 12 1 100 0 0 f f f f f t s r 1 0 2249 "23" "{23,26,23,26,25,25,25,25,25,1184,1184,1184,1184,869,25,23,28,28,16,25,25,23,16,25}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,datid,pid,usesysid,application_name,state,query,wait_event_type,wait_event,xact_start,query_start,backend_start,state_change,client_addr,client_hostname,client_port,backend_xid,backend_xmin,ssl,sslversion,sslcipher,sslbits,sslcompression,sslclientdn}" _null_ _null_ pg_stat_get_activity _null_ _null_ _null_ )); DESCR("statistics: information about currently active backends"); DATA(insert OID = 3099 ( pg_stat_get_wal_senders PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ )); DESCR("statistics: information about currently active replication"); @@ -2724,8 +2724,10 @@ DATA(insert OID = 1939 ( pg_stat_get_backend_userid PGNSP PGUID 12 1 0 0 0 f f DESCR("statistics: user ID of backend"); DATA(insert OID = 1940 ( pg_stat_get_backend_activity PGNSP PGUID 12 1 0 0 0 f f f f t f s r 1 0 25 "23" _null_ _null_ _null_ _null_ _null_ pg_stat_get_backend_activity _null_ _null_ _null_ )); DESCR("statistics: current query of backend"); -DATA(insert OID = 2853 ( pg_stat_get_backend_waiting PGNSP PGUID 12 1 0 0 0 f f f f t f s r 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_stat_get_backend_waiting _null_ _null_ _null_ )); -DESCR("statistics: is backend currently waiting for a lock"); +DATA(insert OID = 2788 ( pg_stat_get_backend_wait_event_type PGNSP PGUID 12 1 0 0 0 f f f f t f s r 1 0 25 "23" _null_ _null_ _null_ _null_ _null_ pg_stat_get_backend_wait_event_type _null_ _null_ _null_ )); +DESCR("statistics: wait event type on which backend is currently waiting"); +DATA(insert OID = 2853 ( pg_stat_get_backend_wait_event PGNSP PGUID 12 1 0 0 0 f f f f t f s r 1 0 25 "23" _null_ _null_ _null_ _null_ _null_ pg_stat_get_backend_wait_event _null_ _null_ _null_ )); +DESCR("statistics: wait event on which backend is currently waiting"); DATA(insert OID = 2094 ( pg_stat_get_backend_activity_start PGNSP PGUID 12 1 0 0 0 f f f f t f s r 1 0 1184 "23" _null_ _null_ _null_ _null_ _null_ pg_stat_get_backend_activity_start _null_ _null_ _null_ )); DESCR("statistics: start time for current query of backend"); DATA(insert OID = 2857 ( pg_stat_get_backend_xact_start PGNSP PGUID 12 1 0 0 0 f f f f t f s r 1 0 1184 "23" _null_ _null_ _null_ _null_ _null_ pg_stat_get_backend_xact_start _null_ _null_ _null_ )); diff --git a/src/include/pgstat.h b/src/include/pgstat.h index 65e968e..75701c5 100644 --- a/src/include/pgstat.h +++ b/src/include/pgstat.h @@ -17,6 +17,7 @@ #include "portability/instr_time.h" #include "postmaster/pgarch.h" #include "storage/barrier.h" +#include "storage/proc.h" #include "utils/hsearch.h" #include "utils/relcache.h" @@ -695,6 +696,21 @@ typedef enum BackendState STATE_DISABLED } BackendState; + +/* ---------- + * Wait Classes + * ---------- + */ +typedef enum WaitClass +{ + WAIT_UNDEFINED, + WAIT_LWLOCK_NAMED, + WAIT_LWLOCK_TRANCHE, + WAIT_LOCK, + WAIT_BUFFER_PIN +} WaitClass; + + /* ---------- * Shared-memory data structures * ---------- @@ -765,9 +781,6 @@ typedef struct PgBackendStatus bool st_ssl; PgBackendSSLStatus *st_sslstatus; - /* Is backend currently waiting on an lmgr lock? */ - bool st_waiting; - /* current state */ BackendState st_state; @@ -931,7 +944,8 @@ 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 void pgstat_report_waiting(bool waiting); +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); @@ -941,6 +955,65 @@ extern PgStat_BackendFunctionEntry *find_funcstat_entry(Oid func_id); extern void pgstat_initstats(Relation rel); +/* ---------- + * 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 repersents the wait event class (type of + * wait, for different types of wait, refer WaitClass) and the next + * 3-bytes repersent 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(uint8 classId, uint16 eventId) +{ + volatile PGPROC *proc = MyProc; + uint32 wait_event_val; + + if (!pgstat_track_activities || !proc) + return; + + wait_event_val = classId; + wait_event_val <<= 24; + wait_event_val |= eventId; + + /* + * 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_val; +} + +/* ---------- + * 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/storage/lmgr.h b/src/include/storage/lmgr.h index e9d41bf..975b6f8 100644 --- a/src/include/storage/lmgr.h +++ b/src/include/storage/lmgr.h @@ -101,4 +101,6 @@ extern void UnlockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid /* Describe a locktag for error messages */ extern void DescribeLockTag(StringInfo buf, const LOCKTAG *tag); +extern const char *GetLockNameFromTagType(uint16 locktag_type); + #endif /* LMGR_H */ diff --git a/src/include/storage/lock.h b/src/include/storage/lock.h index 788d50a..b26427d 100644 --- a/src/include/storage/lock.h +++ b/src/include/storage/lock.h @@ -166,6 +166,8 @@ typedef enum LockTagType #define LOCKTAG_LAST_TYPE LOCKTAG_ADVISORY +extern const char *const LockTagTypeNames[]; + /* * The LOCKTAG struct is defined with malice aforethought to fit into 16 * bytes with no padding. Note that this would need adjustment if we were diff --git a/src/include/storage/lwlock.h b/src/include/storage/lwlock.h index de92d16..bef9996 100644 --- a/src/include/storage/lwlock.h +++ b/src/include/storage/lwlock.h @@ -213,6 +213,9 @@ extern int LWLockNewTrancheId(void); extern void LWLockRegisterTranche(int tranche_id, LWLockTranche *tranche); extern void LWLockInitialize(LWLock *lock, int tranche_id); +/* Retrieve lwlocak name. */ +extern const char *GetLWLockName(uint8 classId, uint16 eventId); + /* * We reserve a few predefined tranche IDs. A call to LWLockNewTrancheId * will never return a value less than LWTRANCHE_FIRST_USER_DEFINED. diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h index dbcdd3f..612fa05 100644 --- a/src/include/storage/proc.h +++ b/src/include/storage/proc.h @@ -152,6 +152,8 @@ struct PGPROC */ TransactionId procArrayGroupMemberXid; + uint32 wait_event_info; /* proc's wait information */ + /* Per-backend LWLock. Protects fields below (but not group fields). */ LWLock backendLock; diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out index 81bc5c9..22ea06c 100644 --- a/src/test/regress/expected/rules.out +++ b/src/test/regress/expected/rules.out @@ -1650,13 +1650,14 @@ pg_stat_activity| SELECT s.datid, s.xact_start, s.query_start, s.state_change, - s.waiting, + s.wait_event_type, + s.wait_event, s.state, s.backend_xid, s.backend_xmin, s.query FROM pg_database d, - pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, waiting, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn), + pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn), pg_authid u WHERE ((s.datid = d.oid) AND (s.usesysid = u.oid)); pg_stat_all_indexes| SELECT c.oid AS relid, @@ -1762,7 +1763,7 @@ pg_stat_replication| SELECT s.pid, w.replay_location, w.sync_priority, w.sync_state - FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, waiting, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn), + FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn), pg_authid u, pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) WHERE ((s.usesysid = u.oid) AND (s.pid = w.pid)); @@ -1773,7 +1774,7 @@ pg_stat_ssl| SELECT s.pid, s.sslbits AS bits, s.sslcompression AS compression, s.sslclientdn AS clientdn - FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, waiting, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn); + FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn); pg_stat_sys_indexes| SELECT pg_stat_all_indexes.relid, pg_stat_all_indexes.indexrelid, pg_stat_all_indexes.schemaname,