diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index 85459d0..472dd82 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -633,9 +633,11 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser Time when the state was last changed - waiting - boolean - True if this backend is currently waiting on a lock + wait_event + text + Wait event name if backend is currently waiting, otherwise + process not waiting + state @@ -2031,9 +2033,11 @@ SELECT pg_stat_get_backend_pid(s.backendid) AS pid, - 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 + process not waiting + diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql index 923fe58..181f87f 100644 --- a/src/backend/catalog/system_views.sql +++ b/src/backend/catalog/system_views.sql @@ -630,7 +630,7 @@ CREATE VIEW pg_stat_activity AS S.xact_start, S.query_start, S.state_change, - S.waiting, + S.wait_event, S.state, S.backend_xid, s.backend_xmin, diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c index da768c6..37266b4 100644 --- a/src/backend/postmaster/pgstat.c +++ b/src/backend/postmaster/pgstat.c @@ -54,6 +54,7 @@ #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 +2724,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 +2803,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 +2815,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,30 +2907,63 @@ pgstat_report_xact_timestamp(TimestampTz tstamp) } /* ---------- - * pgstat_report_waiting() - + * pgstat_report_start_waiting() - * - * Called from lock manager to report beginning or end of a lock wait. + * 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 MyBEEntry has been + * NB: this *must* be able to survive being called before MyProc has been * initialized. * ---------- */ void -pgstat_report_waiting(bool waiting) +pgstat_report_start_waiting(uint8 classId, uint16 eventId) { - volatile PgBackendStatus *beentry = MyBEEntry; + volatile PGPROC *proc = MyProc; + uint32 wait_event_val; - if (!pgstat_track_activities || !beentry) + if (!pgstat_track_activities || !proc) return; + wait_event_val = classId; + wait_event_val <<= 24; + wait_event_val |= eventId; + /* - * 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. + * Since this is a four-byte field which is always read and written as + * four-bytes, updates are atomic. */ - beentry->st_waiting = waiting; + proc->wait_event_info = wait_event_val; } +/* ---------- + * pgstat_report_end_waiting() - + * + * Called to report end of a wait. + * + * NB: this *must* be able to survive being called before MyProc has been + * initialized. + * ---------- + */ +void +pgstat_report_end_waiting(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; +} /* ---------- * pgstat_read_current_status() - @@ -3045,6 +3080,45 @@ pgstat_read_current_status(void) localBackendStatusTable = localtable; } +/* ---------- + * 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 "process not waiting"; + + eventId = wait_event_info & ((1 << 24) - 1); + wait_event_info = wait_event_info >> 24; + classId = wait_event_info & 0XFF; + + switch (classId) + { + case WAIT_LWLOCK_INDIVIDUAL: + event_name = GetLWLockName(classId, eventId); + break; + case WAIT_LWLOCK_GROUP: + event_name = GetLWLockName(classId, eventId); + break; + case WAIT_LOCK: + event_name = GetLockNameFromTagType(eventId); + break; + default: + event_name = "unknown wait event"; + break; + } + + return event_name; +} /* ---------- * pgstat_get_backend_current_activity() - diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index 7141eb8..d7a2406 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_start_waiting(WAIT_LWLOCK_GROUP, (BufferDescriptorGetContentLock(bufHdr))->tranche); + /* Wait to be signaled by UnpinBuffer() */ if (InHotStandby) { @@ -3364,6 +3367,8 @@ LockBufferForCleanup(Buffer buffer) else ProcWaitForSignal(); + pgstat_report_end_waiting(); + /* * 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..b78c293 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; } } + +/* + * get_lockname_from_tagtype + * + * 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 9c2e49c..463635b 100644 --- a/src/backend/storage/lmgr/lock.c +++ b/src/backend/storage/lmgr/lock.c @@ -1592,7 +1592,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_start_waiting(WAIT_LOCK, locallock->tag.lock.locktag_type); awaitedLock = locallock; awaitedOwner = owner; @@ -1640,7 +1640,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_end_waiting(); if (update_process_title) { set_ps_display(new_status, false); @@ -1655,7 +1655,7 @@ WaitOnLock(LOCALLOCK *locallock, ResourceOwner owner) awaitedLock = NULL; /* Report change to non-waiting status */ - pgstat_report_waiting(false); + pgstat_report_end_waiting(); 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 ac61be2..bb98874 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" @@ -147,6 +148,9 @@ static LWLockHandle held_lwlocks[MAX_SIMUL_LWLOCKS]; static int lock_addin_request = 0; static bool lock_addin_request_allowed = true; +static inline void LWLockReportStartWait(LWLock *lock); +static inline void LWLockReportEndWait(); + #ifdef LWLOCK_STATS typedef struct lwlock_stats_key { @@ -573,6 +577,51 @@ 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 && lockId < NUM_INDIVIDUAL_LWLOCKS) + pgstat_report_start_waiting(WAIT_LWLOCK_INDIVIDUAL, (uint16) lockId); + else + pgstat_report_start_waiting(WAIT_LWLOCK_GROUP, lock->tranche); +} + +/* + * Report end of wait event for light-weight locks. + */ +static inline void +LWLockReportEndWait() +{ + pgstat_report_end_waiting(); +} + +/* + * 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_INDIVIDUAL) + lwlockName = MainLWLockNames[eventId]; + else if (classId == WAIT_LWLOCK_GROUP) + lwlockName = LWLockTrancheArray[eventId]->name; + else + lwlockName = "unknown lwlock"; + + return lwlockName; +} + +/* * Internal function that tries to atomically acquire the lwlock in the passed * in mode. * @@ -1023,6 +1072,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); @@ -1045,6 +1097,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. */ @@ -1181,6 +1235,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); @@ -1199,6 +1256,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 @@ -1406,6 +1465,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); @@ -1426,6 +1488,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 0d5e23a..bd1ca96 100644 --- a/src/backend/storage/lmgr/proc.c +++ b/src/backend/storage/lmgr/proc.c @@ -397,6 +397,9 @@ InitProcess(void) MyProc->backendLatestXid = InvalidTransactionId; pg_atomic_init_u32(&MyProc->nextClearXidElem, INVALID_PGPROCNO); + /* 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 diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c index 73c78e9..8bd6dfd 100644 --- a/src/backend/utils/adt/lockfuncs.c +++ b/src/backend/utils/adt/lockfuncs.c @@ -22,7 +22,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..fe0400c 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,7 @@ 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(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); @@ -573,6 +575,7 @@ pg_stat_get_activity(PG_FUNCTION_ARGS) bool nulls[PG_STAT_GET_ACTIVITY_COLS]; LocalPgBackendStatus *local_beentry; PgBackendStatus *beentry; + PGPROC *proc; MemSet(values, 0, sizeof(values)); MemSet(nulls, 0, sizeof(nulls)); @@ -672,7 +675,8 @@ pg_stat_get_activity(PG_FUNCTION_ARGS) } values[5] = CStringGetTextDatum(beentry->st_activity); - values[6] = BoolGetDatum(beentry->st_waiting); + proc = BackendPidGetProc(beentry->st_procpid); + values[6] = CStringGetTextDatum(pgstat_get_wait_event(proc->wait_event_info)); if (beentry->st_xact_start_timestamp != 0) values[7] = TimestampTzGetDatum(beentry->st_xact_start_timestamp); @@ -858,21 +862,24 @@ pg_stat_get_backend_activity(PG_FUNCTION_ARGS) Datum -pg_stat_get_backend_waiting(PG_FUNCTION_ARGS) +pg_stat_get_backend_wait_event(PG_FUNCTION_ARGS) { int32 beid = PG_GETARG_INT32(0); - bool result; PgBackendStatus *beentry; + PGPROC *proc; + const char *wait_event; if ((beentry = pgstat_fetch_stat_beentry(beid)) == NULL) - PG_RETURN_NULL(); - - if (!has_privs_of_role(GetUserId(), beentry->st_userid)) - PG_RETURN_NULL(); - - result = beentry->st_waiting; + 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); + } - 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 79e92ff..525813a 100644 --- a/src/include/catalog/pg_proc.h +++ b/src/include/catalog/pg_proc.h @@ -2700,7 +2700,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,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,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"); @@ -2716,8 +2716,8 @@ 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 = 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..8ceaab4 100644 --- a/src/include/pgstat.h +++ b/src/include/pgstat.h @@ -695,6 +695,20 @@ typedef enum BackendState STATE_DISABLED } BackendState; + +/* ---------- + * Wait Classes + * ---------- + */ +typedef enum WaitClass +{ + WAIT_UNDEFINED, + WAIT_LWLOCK_INDIVIDUAL, + WAIT_LWLOCK_GROUP, + WAIT_LOCK +} WaitClass; + + /* ---------- * Shared-memory data structures * ---------- @@ -765,9 +779,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 +942,9 @@ 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 void pgstat_report_start_waiting(uint8 classId, uint16 eventId); +extern void pgstat_report_end_waiting(void); +extern const char *pgstat_get_wait_event(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); 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 43eca86..6f70dc1 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 5e8825e..eaba2af 100644 --- a/src/include/storage/lwlock.h +++ b/src/include/storage/lwlock.h @@ -203,6 +203,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 38943a1..31c14b0 100644 --- a/src/include/storage/proc.h +++ b/src/include/storage/proc.h @@ -146,6 +146,8 @@ struct PGPROC pg_atomic_uint32 nextClearXidElem; TransactionId backendLatestXid; + uint32 wait_event_info; /* proc's wait information */ + /* Per-backend LWLock. Protects fields below. */ LWLock *backendLock; /* protects the fields below */ diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out index 28b061f..4a907ce 100644 --- a/src/test/regress/expected/rules.out +++ b/src/test/regress/expected/rules.out @@ -1647,13 +1647,13 @@ pg_stat_activity| SELECT s.datid, s.xact_start, s.query_start, s.state_change, - s.waiting, + 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, 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, @@ -1759,7 +1759,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, 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)); @@ -1770,7 +1770,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, 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,