diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index 85459d0..6adaf40 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -632,10 +632,15 @@ 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 + - 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 state @@ -2030,10 +2035,16 @@ 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 + + - 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/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/pgstat.c b/src/backend/postmaster/pgstat.c index da768c6..28acbfa 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,83 @@ 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_INDIVIDUAL: + event_type = "LWLock"; + break; + case WAIT_LWLOCK_GROUP: + event_type = "LWLock"; + break; + case WAIT_LOCK: + event_type = "HWLock"; + 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_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..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 fef59a2..ddbd250 100644 --- a/src/backend/storage/lmgr/lock.c +++ b/src/backend/storage/lmgr/lock.c @@ -1661,7 +1661,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; @@ -1709,7 +1709,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); @@ -1724,7 +1724,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 d245857..af3b1e9 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,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. * @@ -1164,6 +1213,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 +1238,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 +1376,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 +1397,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 +1606,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 +1629,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 114fba0..f443b26 100644 --- a/src/backend/storage/lmgr/proc.c +++ b/src/backend/storage/lmgr/proc.c @@ -405,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 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..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 59c50d9..30571a7 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..af42773 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,10 @@ 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_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); 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 703eaf2..830515c 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 a9405ce..956abb4 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,