From 3feb2f98433afb8150d44a0bf8ffad047f89c20b Mon Sep 17 00:00:00 2001 From: Alexey Kondratov Date: Thu, 4 Feb 2021 00:10:01 +0300 Subject: [PATCH 01/21] Add comment about considering of reverting e6f52a75 --- collector.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/collector.c b/collector.c index f3f141c..913166d 100644 --- a/collector.c +++ b/collector.c @@ -440,6 +440,12 @@ collector_main(Datum main_arg) LockAcquire(&tag, ExclusiveLock, false, false); collector_hdr->request = NO_REQUEST; + /* + * XXX: it is very likely that this TRY/CATCH is useless. If any + * error occurs, collector's bgworker will exit cancelling the lock. + * + * TODO: thus, consider reverting commit e6f52a7547a15. + */ PG_TRY(); { if (request == HISTORY_REQUEST || request == PROFILE_REQUEST) From 394f918f5fed02c6dca97086bcbdc66631ca8ab3 Mon Sep 17 00:00:00 2001 From: Roman Zharkov Date: Thu, 13 May 2021 16:27:26 +0600 Subject: [PATCH 02/21] [refer #PGPRO-4978] Update the .gitignore file. tags: pg_wait_sampling --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index be4254b..0636f19 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,4 @@ *pg_wait_sampling--1.1.sql .log Dockerfile +/log/ From 9ab0ec778b56d94666c5b65815b6019341562f3e Mon Sep 17 00:00:00 2001 From: Rustem Bapin Date: Mon, 26 Jul 2021 20:02:45 +0400 Subject: [PATCH 03/21] [refer #PGPRO-4791] Revert "Fix another issue with collector infinite loop." This reverts commit 9e56e69030afa9b5bd1a36383c1dd9097c74629a. --- collector.c | 86 ++++++++++++++++++++++------------------------------- 1 file changed, 35 insertions(+), 51 deletions(-) diff --git a/collector.c b/collector.c index 913166d..237061f 100644 --- a/collector.c +++ b/collector.c @@ -440,63 +440,47 @@ collector_main(Datum main_arg) LockAcquire(&tag, ExclusiveLock, false, false); collector_hdr->request = NO_REQUEST; - /* - * XXX: it is very likely that this TRY/CATCH is useless. If any - * error occurs, collector's bgworker will exit cancelling the lock. - * - * TODO: thus, consider reverting commit e6f52a7547a15. - */ - PG_TRY(); + if (request == HISTORY_REQUEST || request == PROFILE_REQUEST) { - if (request == HISTORY_REQUEST || request == PROFILE_REQUEST) - { - shm_mq_result mq_result; - - /* Send history or profile */ - shm_mq_set_sender(collector_mq, MyProc); - mqh = shm_mq_attach(collector_mq, NULL, NULL); - mq_result = shm_mq_wait_for_attach(mqh); - switch (mq_result) - { - case SHM_MQ_SUCCESS: - switch (request) - { - case HISTORY_REQUEST: - send_history(&observations, mqh); - break; - case PROFILE_REQUEST: - send_profile(profile_hash, mqh); - break; - default: - AssertState(false); - } - break; - case SHM_MQ_DETACHED: - ereport(WARNING, - (errmsg("pg_wait_sampling collector: " - "receiver of message queue has been " - "detached"))); - break; - default: - AssertState(false); - } - shm_mq_detach_compat(mqh, collector_mq); - } - else if (request == PROFILE_RESET) + shm_mq_result mq_result; + + /* Send history or profile */ + shm_mq_set_sender(collector_mq, MyProc); + mqh = shm_mq_attach(collector_mq, NULL, NULL); + mq_result = shm_mq_wait_for_attach(mqh); + switch (mq_result) { - /* Reset profile hash */ - hash_destroy(profile_hash); - profile_hash = make_profile_hash(); + case SHM_MQ_SUCCESS: + switch (request) + { + case HISTORY_REQUEST: + send_history(&observations, mqh); + break; + case PROFILE_REQUEST: + send_profile(profile_hash, mqh); + break; + default: + AssertState(false); + } + break; + case SHM_MQ_DETACHED: + ereport(WARNING, + (errmsg("pg_wait_sampling collector: " + "receiver of message queue have been " + "detached"))); + break; + default: + AssertState(false); } - - LockRelease(&tag, ExclusiveLock, false); + shm_mq_detach_compat(mqh, collector_mq); } - PG_CATCH(); + else if (request == PROFILE_RESET) { - LockRelease(&tag, ExclusiveLock, false); - PG_RE_THROW(); + /* Reset profile hash */ + hash_destroy(profile_hash); + profile_hash = make_profile_hash(); } - PG_END_TRY(); + LockRelease(&tag, ExclusiveLock, false); } } From a9109e6693d5c49115725ff8f2ad8c176ca5f11c Mon Sep 17 00:00:00 2001 From: Nikolay Samokhvalov Date: Tue, 28 Sep 2021 09:07:04 -0700 Subject: [PATCH 04/21] Fix the doc: profile_queries is "true" by default MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Noticed that `profile_queries` is `true` by default (and per https://github.com/postgrespro/pg_wait_sampling/blob/3feb2f98433afb8150d44a0bf8ffad047f89c20b/pg_wait_sampling.c#L193) – while README claims it's `false`. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0e47ad1..aa539d8 100644 --- a/README.md +++ b/README.md @@ -125,7 +125,7 @@ GUCs. | pg_wait_sampling.history_period | int4 | Period for history sampling in milliseconds | 10 | | pg_wait_sampling.profile_period | int4 | Period for profile sampling in milliseconds | 10 | | pg_wait_sampling.profile_pid | bool | Whether profile should be per pid | true | -| pg_wait_sampling.profile_queries | bool | Whether profile should be per query | false | +| pg_wait_sampling.profile_queries | bool | Whether profile should be per query | true | If `pg_wait_sampling.profile_pid` is set to false, sampling profile wouldn't be collected in per-process manner. In this case the value of pid could would From 77ba2cab55b217f0188270c0fa3c4a475b0f2bbd Mon Sep 17 00:00:00 2001 From: Julien Rouhaud Date: Sat, 23 Oct 2021 13:00:54 +0800 Subject: [PATCH 05/21] Fix compatibility with new shm_mq_send API introduced in pg15. Related upstream commit: 46846433a03dff4f2e08c8a161e54a842da360d6 --- collector.c | 12 +++++++----- compat.c | 11 +++++++++++ pg_wait_sampling.h | 3 +++ 3 files changed, 21 insertions(+), 5 deletions(-) diff --git a/collector.c b/collector.c index 237061f..2fa80c3 100644 --- a/collector.c +++ b/collector.c @@ -220,7 +220,7 @@ send_history(History *observations, shm_mq_handle *mqh) else count = observations->index; - mq_result = shm_mq_send(mqh, sizeof(count), &count, false); + mq_result = shm_mq_send_compat(mqh, sizeof(count), &count, false, true); if (mq_result == SHM_MQ_DETACHED) { ereport(WARNING, @@ -230,10 +230,11 @@ send_history(History *observations, shm_mq_handle *mqh) } for (i = 0; i < count; i++) { - mq_result = shm_mq_send(mqh, + mq_result = shm_mq_send_compat(mqh, sizeof(HistoryItem), &observations->items[i], - false); + false, + true); if (mq_result == SHM_MQ_DETACHED) { ereport(WARNING, @@ -255,7 +256,7 @@ send_profile(HTAB *profile_hash, shm_mq_handle *mqh) Size count = hash_get_num_entries(profile_hash); shm_mq_result mq_result; - mq_result = shm_mq_send(mqh, sizeof(count), &count, false); + mq_result = shm_mq_send_compat(mqh, sizeof(count), &count, false, true); if (mq_result == SHM_MQ_DETACHED) { ereport(WARNING, @@ -266,7 +267,8 @@ send_profile(HTAB *profile_hash, shm_mq_handle *mqh) hash_seq_init(&scan_status, profile_hash); while ((item = (ProfileItem *) hash_seq_search(&scan_status)) != NULL) { - mq_result = shm_mq_send(mqh, sizeof(ProfileItem), item, false); + mq_result = shm_mq_send_compat(mqh, sizeof(ProfileItem), item, false, + true); if (mq_result == SHM_MQ_DETACHED) { hash_seq_term(&scan_status); diff --git a/compat.c b/compat.c index 249a53a..7004d7e 100644 --- a/compat.c +++ b/compat.c @@ -13,6 +13,17 @@ shm_mq_detach_compat(shm_mq_handle *mqh, shm_mq *mq) #endif } +inline shm_mq_result +shm_mq_send_compat(shm_mq_handle *mqh, Size nbytes, const void *data, + bool nowait, bool force_flush) +{ +#if PG_VERSION_NUM >= 150000 + return shm_mq_send(mqh, nbytes, data, nowait, force_flush); +#else + return shm_mq_send(mqh, nbytes, data, nowait); +#endif +} + inline TupleDesc CreateTemplateTupleDescCompat(int nattrs, bool hasoid) { diff --git a/pg_wait_sampling.h b/pg_wait_sampling.h index 1001f6f..4c0ddac 100644 --- a/pg_wait_sampling.h +++ b/pg_wait_sampling.h @@ -84,6 +84,9 @@ extern void alloc_history(History *, int); extern void collector_main(Datum main_arg); extern void shm_mq_detach_compat(shm_mq_handle *mqh, shm_mq *mq); +extern shm_mq_result shm_mq_send_compat(shm_mq_handle *mqh, Size nbytes, + const void *data, bool nowait, + bool force_flush); extern TupleDesc CreateTemplateTupleDescCompat(int nattrs, bool hasoid); #endif From 277a4e5abcd94098b19999c8ad898694f0d0b8fc Mon Sep 17 00:00:00 2001 From: Julien Rouhaud Date: Fri, 25 Mar 2022 14:01:39 +0800 Subject: [PATCH 06/21] Fix shmem allocation size. MaxBackends is still 0 when _PG_init() is called, which means that we don't request enough memory in RequestAddinShmemSpace(), while the rest of the code sees (and allocate) a correct value. It's technically usually not a problem as postgres adds an extra 100kB of memory for small unaccounted memory usage, but it's better to avoid relying on it too much. Note that the value is still not guaranteed to be exact as other modules _PG_init() could later change the underlying GUCs, but there is not available API to handle that case accurately. --- pg_wait_sampling.c | 42 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 36 insertions(+), 6 deletions(-) diff --git a/pg_wait_sampling.c b/pg_wait_sampling.c index a90a981..8098e3a 100644 --- a/pg_wait_sampling.c +++ b/pg_wait_sampling.c @@ -17,6 +17,10 @@ #include "miscadmin.h" #include "optimizer/planner.h" #include "pgstat.h" +#include "postmaster/autovacuum.h" +#if PG_VERSION_NUM >= 120000 +#include "replication/walsender.h" +#endif #include "storage/ipc.h" #include "storage/pg_shmem.h" #include "storage/procarray.h" @@ -66,20 +70,46 @@ static void pgws_ExecutorEnd(QueryDesc *queryDesc); /* * Calculate max processes count. - * Look at InitProcGlobal (proc.c) and TotalProcs variable in it - * if something wrong here. + * + * The value has to be in sync with ProcGlobal->allProcCount, initialized in + * InitProcGlobal() (proc.c). + * + * We calculate the value here as it won't initialized when we need need + * it during _PG_init(). + * + * Note that the value returned during _PG_init() might be different from the + * value returned later if some third-party modules change one of the + * underlying GUC. This isn't ideal but can't lead to a crash, as the value + * returned during _PG_init() is only used to ask for additional shmem with + * RequestAddinShmemSpace(), and postgres has an extra 100kB of shmem to + * compensate some small unaccounted usage. So if the value later changes, we + * will allocate and initialize the new (and correct) memory size, which + * will either work thanks for the extra 100kB of shmem, of fail (and prevent + * postgres startup) due to an out of shared memory error. */ static int get_max_procs_count(void) { int count = 0; - /* MyProcs, including autovacuum workers and launcher */ - count += MaxBackends; + /* + * MaxBackends: bgworkers, autovacuum workers and launcher. + * This has to be in sync with the value computed in + * InitializeMaxBackends() (postinit.c) + */ + count += MaxConnections + autovacuum_max_workers + 1 + + max_worker_processes; + + /* + * Starting with pg12, wal senders aren't part of MaxConnections anymore + * and have to be accounted for. + */ +#if PG_VERSION_NUM >= 120000 + count += max_wal_senders; +#endif + /* AuxiliaryProcs */ count += NUM_AUXILIARY_PROCS; - /* Prepared xacts */ - count += max_prepared_xacts; return count; } From 452bdcb02db5c20aaee8c53231dd3abb155e659e Mon Sep 17 00:00:00 2001 From: Andrey Sokolov Date: Thu, 31 Mar 2022 16:14:21 +0300 Subject: [PATCH 07/21] Fix typo --- pg_wait_sampling.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pg_wait_sampling.c b/pg_wait_sampling.c index 8098e3a..d5a998e 100644 --- a/pg_wait_sampling.c +++ b/pg_wait_sampling.c @@ -74,8 +74,8 @@ static void pgws_ExecutorEnd(QueryDesc *queryDesc); * The value has to be in sync with ProcGlobal->allProcCount, initialized in * InitProcGlobal() (proc.c). * - * We calculate the value here as it won't initialized when we need need - * it during _PG_init(). + * We calculate the value here as it won't initialized when we need it during + * _PG_init(). * * Note that the value returned during _PG_init() might be different from the * value returned later if some third-party modules change one of the From f4a87c5897c519c4e52896a8b3a0ec3f06e88932 Mon Sep 17 00:00:00 2001 From: Andrey Sokolov Date: Fri, 1 Apr 2022 13:27:12 +0300 Subject: [PATCH 08/21] Fix annoying git fatal message --- Makefile | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index 65a54e3..ab90e59 100644 --- a/Makefile +++ b/Makefile @@ -28,11 +28,10 @@ $(EXTENSION)--$(EXTVERSION).sql: setup.sql cat $^ > $@ # Prepare the package for PGXN submission -DISTVERSION := $(shell git tag -l | tail -n 1 | cut -d 'v' -f 2) -package: dist dist/$(EXTENSION)-$(DISTVERSION).zip +package: dist .git + $(eval DISTVERSION := $(shell git tag -l | tail -n 1 | cut -d 'v' -f 2)) + $(info Generating zip file for version $(DISTVERSION)...) + git archive --format zip --prefix=$(EXTENSION)-${DISTVERSION}/ --output dist/$(EXTENSION)-${DISTVERSION}.zip HEAD dist: mkdir -p dist - -dist/$(EXTENSION)-$(DISTVERSION).zip: - git archive --format zip --prefix=$(EXTENSION)-$(DISTVERSION)/ --output $@ HEAD From 609975ac219d069552c7e574ce4bc500b25ed010 Mon Sep 17 00:00:00 2001 From: Julien Rouhaud Date: Sat, 14 May 2022 14:54:22 +0800 Subject: [PATCH 09/21] Remove _PG_fini(). Postgres hasn't called this function for more than a decade (even before extensions were introduced), and version 15 officially removed it so let's get rid of it too. --- pg_wait_sampling.c | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/pg_wait_sampling.c b/pg_wait_sampling.c index d5a998e..f42528f 100644 --- a/pg_wait_sampling.c +++ b/pg_wait_sampling.c @@ -39,7 +39,6 @@ PG_MODULE_MAGIC; void _PG_init(void); -void _PG_fini(void); /* Global variables */ bool shmem_initialized = false; @@ -359,22 +358,14 @@ _PG_init(void) */ prev_shmem_startup_hook = shmem_startup_hook; shmem_startup_hook = pgws_shmem_startup; + prev_shmem_startup_hook = shmem_startup_hook; + shmem_startup_hook = pgws_shmem_startup; planner_hook_next = planner_hook; planner_hook = pgws_planner_hook; prev_ExecutorEnd = ExecutorEnd_hook; ExecutorEnd_hook = pgws_ExecutorEnd; } -/* - * Module unload callback - */ -void -_PG_fini(void) -{ - /* Uninstall hooks. */ - shmem_startup_hook = prev_shmem_startup_hook; -} - /* * Find PGPROC entry responsible for given pid assuming ProcArrayLock was * already taken. From 47616672ebdec64292690e2e37632255ba34531d Mon Sep 17 00:00:00 2001 From: Julien Rouhaud Date: Sat, 14 May 2022 15:47:14 +0800 Subject: [PATCH 10/21] Wait 1 second before restarting the bgworker. If for some reason the bgworker keeps crashing, this will limit the amount of traces logged when restarting. --- collector.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/collector.c b/collector.c index 2fa80c3..a49f90c 100644 --- a/collector.c +++ b/collector.c @@ -44,7 +44,7 @@ register_wait_collector(void) memset(&worker, 0, sizeof(worker)); worker.bgw_flags = BGWORKER_SHMEM_ACCESS; worker.bgw_start_time = BgWorkerStart_ConsistentState; - worker.bgw_restart_time = 0; + worker.bgw_restart_time = 1; worker.bgw_notify_pid = 0; snprintf(worker.bgw_library_name, BGW_MAXLEN, "pg_wait_sampling"); snprintf(worker.bgw_function_name, BGW_MAXLEN, CppAsString(collector_main)); From 1a8aa648fb478499fdc02285aaba2f8a390833f6 Mon Sep 17 00:00:00 2001 From: Julien Rouhaud Date: Sat, 14 May 2022 15:55:28 +0800 Subject: [PATCH 11/21] Setup SIGUSR1 procsignal_sigusr1_handler handler. This is normally automatically done when a bgworker declares the BGWORKER_BACKEND_DATABASE_CONNECTION flag, but our bgworker doesn't connect to databases, even though it calls InitPostgres, which will still initialize a new bacckend and thus participate to the ProcSignal infrastructure. This wasn't a problem until recently, but now that DROP DATABASE relies on PROCSIG_BARRIER to work on Windows (see commit 4eb2176318d0561846c1f9fb3c68bede799d640f) we need to respond to ProcSignal notifications. --- collector.c | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/collector.c b/collector.c index a49f90c..bbf2741 100644 --- a/collector.c +++ b/collector.c @@ -339,8 +339,16 @@ collector_main(Datum main_arg) * any equivalent of the backend's command-read loop, where interrupts can * be processed immediately, so make sure ImmediateInterruptOK is turned * off. + * + * We also want to respond to the ProcSignal notifications. This is done + * in the upstream provided procsignal_sigusr1_handler, which is + * automatically used if a bgworker connects to a database. But since our + * worker doesn't connect to any database even though it calls + * InitPostgres, which will still initializze a new backend and thus + * partitipate to the ProcSignal infrastructure. */ pqsignal(SIGTERM, handle_sigterm); + pqsignal(SIGUSR1, procsignal_sigusr1_handler); BackgroundWorkerUnblockSignals(); #if PG_VERSION_NUM >= 110000 @@ -379,6 +387,9 @@ collector_main(Datum main_arg) bool write_history, write_profile; + /* We need an explicit call for at least ProcSignal notifications. */ + CHECK_FOR_INTERRUPTS(); + /* Wait calculate time to next sample for history or profile */ current_ts = GetCurrentTimestamp(); From 5b50e788951caa4cec6606b2b5f39897e983ea05 Mon Sep 17 00:00:00 2001 From: Julien Rouhaud Date: Sat, 14 May 2022 15:59:36 +0800 Subject: [PATCH 12/21] Fix compatibility with pg15 new shmem_request_hook. Hook added upstream in 4f2400cb3f10aa79f99fba680c198237da28dd38. --- pg_wait_sampling.c | 75 +++++++++++++++++++++++++++++++++++----------- 1 file changed, 58 insertions(+), 17 deletions(-) diff --git a/pg_wait_sampling.c b/pg_wait_sampling.c index f42528f..f27a5de 100644 --- a/pg_wait_sampling.c +++ b/pg_wait_sampling.c @@ -58,6 +58,9 @@ shm_mq *recv_mq = NULL; shm_mq_handle *recv_mqh = NULL; LOCKTAG queueTag; +#if PG_VERSION_NUM >= 150000 +static shmem_request_hook_type prev_shmem_request_hook = NULL; +#endif static shmem_startup_hook_type prev_shmem_startup_hook = NULL; static PGPROC * search_proc(int backendPid); static PlannedStmt *pgws_planner_hook(Query *parse, @@ -73,28 +76,40 @@ static void pgws_ExecutorEnd(QueryDesc *queryDesc); * The value has to be in sync with ProcGlobal->allProcCount, initialized in * InitProcGlobal() (proc.c). * - * We calculate the value here as it won't initialized when we need it during - * _PG_init(). - * - * Note that the value returned during _PG_init() might be different from the - * value returned later if some third-party modules change one of the - * underlying GUC. This isn't ideal but can't lead to a crash, as the value - * returned during _PG_init() is only used to ask for additional shmem with - * RequestAddinShmemSpace(), and postgres has an extra 100kB of shmem to - * compensate some small unaccounted usage. So if the value later changes, we - * will allocate and initialize the new (and correct) memory size, which - * will either work thanks for the extra 100kB of shmem, of fail (and prevent - * postgres startup) due to an out of shared memory error. */ static int get_max_procs_count(void) { int count = 0; + /* First, add the maximum number of backends (MaxBackends). */ +#if PG_VERSION_NUM >= 150000 + /* + * On pg15+, we can directly access the MaxBackends variable, as it will + * have already been initialized in shmem_request_hook. + */ + Assert(MaxBackends > 0); + count += MaxBackends; +#else /* - * MaxBackends: bgworkers, autovacuum workers and launcher. + * On older versions, we need to compute MaxBackends: bgworkers, autovacuum + * workers and launcher. * This has to be in sync with the value computed in * InitializeMaxBackends() (postinit.c) + * + * Note that we need to calculate the value as it won't initialized when we + * need it during _PG_init(). + * + * Note also that the value returned during _PG_init() might be different + * from the value returned later if some third-party modules change one of + * the underlying GUC. This isn't ideal but can't lead to a crash, as the + * value returned during _PG_init() is only used to ask for additional + * shmem with RequestAddinShmemSpace(), and postgres has an extra 100kB of + * shmem to compensate some small unaccounted usage. So if the value later + * changes, we will allocate and initialize the new (and correct) memory + * size, which will either work thanks for the extra 100kB of shmem, of + * fail (and prevent postgres startup) due to an out of shared memory + * error. */ count += MaxConnections + autovacuum_max_workers + 1 + max_worker_processes; @@ -105,9 +120,11 @@ get_max_procs_count(void) */ #if PG_VERSION_NUM >= 120000 count += max_wal_senders; -#endif +#endif /* pg 12+ */ +#endif /* pg 15- */ + /* End of MaxBackends calculation. */ - /* AuxiliaryProcs */ + /* Add AuxiliaryProcs */ count += NUM_AUXILIARY_PROCS; return count; @@ -265,6 +282,23 @@ setup_gucs() } } +#if PG_VERSION_NUM >= 150000 +/* + * shmem_request hook: request additional shared memory resources. + * + * If you change code here, don't forget to also report the modifications in + * _PG_init() for pg14 and below. + */ +static void +pgws_shmem_request(void) +{ + if (prev_shmem_request_hook) + prev_shmem_request_hook(); + + RequestAddinShmemSpace(pgws_shmem_size()); +} +#endif + /* * Distribute shared memory. */ @@ -344,20 +378,27 @@ _PG_init(void) if (!process_shared_preload_libraries_in_progress) return; +#if PG_VERSION_NUM < 150000 /* * Request additional shared resources. (These are no-ops if we're not in * the postmaster process.) We'll allocate or attach to the shared * resources in pgws_shmem_startup(). + * + * If you change code here, don't forget to also report the modifications + * in pgsp_shmem_request() for pg15 and later. */ RequestAddinShmemSpace(pgws_shmem_size()); +#endif register_wait_collector(); /* * Install hooks. */ - prev_shmem_startup_hook = shmem_startup_hook; - shmem_startup_hook = pgws_shmem_startup; +#if PG_VERSION_NUM >= 150000 + prev_shmem_request_hook = shmem_request_hook; + shmem_request_hook = pgws_shmem_request; +#endif prev_shmem_startup_hook = shmem_startup_hook; shmem_startup_hook = pgws_shmem_startup; planner_hook_next = planner_hook; From df1aa39780238219bb353a147794cba32ab28a8a Mon Sep 17 00:00:00 2001 From: "i.kartyshov" Date: Thu, 2 Jun 2022 13:29:23 +0300 Subject: [PATCH 13/21] [refer #PGPRO-6612] Count max procs tags: pg_wait_sampling --- pg_wait_sampling.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pg_wait_sampling.c b/pg_wait_sampling.c index f27a5de..8c45f10 100644 --- a/pg_wait_sampling.c +++ b/pg_wait_sampling.c @@ -114,6 +114,10 @@ get_max_procs_count(void) count += MaxConnections + autovacuum_max_workers + 1 + max_worker_processes; +#if PG_VERSION_NUM >= 140000 && defined(PGPRO_EE) + count += MaxATX; +#endif + /* * Starting with pg12, wal senders aren't part of MaxConnections anymore * and have to be accounted for. From 81c641ffdcbc7342aaba4e62cb0499ee49061416 Mon Sep 17 00:00:00 2001 From: Georgy Shelkovy Date: Wed, 27 Jul 2022 12:37:52 +0500 Subject: [PATCH 14/21] PostgreSQL 15 support. Pass extra argument to InitPostgres as per upstream commit 31ed3cf746a. --- collector.c | 7 +------ compat.c | 20 ++++++++++++++++++++ pg_wait_sampling.h | 5 +++++ 3 files changed, 26 insertions(+), 6 deletions(-) diff --git a/collector.c b/collector.c index bbf2741..9bb8cfb 100644 --- a/collector.c +++ b/collector.c @@ -350,12 +350,7 @@ collector_main(Datum main_arg) pqsignal(SIGTERM, handle_sigterm); pqsignal(SIGUSR1, procsignal_sigusr1_handler); BackgroundWorkerUnblockSignals(); - -#if PG_VERSION_NUM >= 110000 - InitPostgres(NULL, InvalidOid, NULL, InvalidOid, NULL, false); -#else - InitPostgres(NULL, InvalidOid, NULL, InvalidOid, NULL); -#endif + InitPostgresCompat(NULL, InvalidOid, NULL, InvalidOid, false, false, NULL); SetProcessingMode(NormalProcessing); /* Make pg_wait_sampling recognisable in pg_stat_activity */ diff --git a/compat.c b/compat.c index 7004d7e..f2a57ae 100644 --- a/compat.c +++ b/compat.c @@ -1,5 +1,7 @@ #include "postgres.h" + #include "access/tupdesc.h" +#include "miscadmin.h" #include "pg_wait_sampling.h" @@ -33,3 +35,21 @@ CreateTemplateTupleDescCompat(int nattrs, bool hasoid) return CreateTemplateTupleDesc(nattrs, hasoid); #endif } + +inline void +InitPostgresCompat(const char *in_dbname, Oid dboid, + const char *username, Oid useroid, + bool load_session_libraries, + bool override_allow_connections, + char *out_dbname) +{ +#if PG_VERSION_NUM >= 150000 + InitPostgres(in_dbname, dboid, username, useroid, load_session_libraries, + override_allow_connections, out_dbname); +#elif PG_VERSION_NUM >= 110000 + InitPostgres(in_dbname, dboid, username, useroid, out_dbname, + override_allow_connections); +#else + InitPostgres(in_dbname, dboid, username, useroid, out_dbname); +#endif +} diff --git a/pg_wait_sampling.h b/pg_wait_sampling.h index 4c0ddac..bb0e1d8 100644 --- a/pg_wait_sampling.h +++ b/pg_wait_sampling.h @@ -88,5 +88,10 @@ extern shm_mq_result shm_mq_send_compat(shm_mq_handle *mqh, Size nbytes, const void *data, bool nowait, bool force_flush); extern TupleDesc CreateTemplateTupleDescCompat(int nattrs, bool hasoid); +extern void InitPostgresCompat(const char *in_dbname, Oid dboid, + const char *username, Oid useroid, + bool load_session_libraries, + bool override_allow_connections, + char *out_dbname); #endif From 9dad24b502d3f8b5faff7dd06d38dcf0e34c9292 Mon Sep 17 00:00:00 2001 From: Maksim Milyutin Date: Thu, 11 Aug 2022 00:29:23 +0400 Subject: [PATCH 15/21] Add missing PGDLLEXPORT markings for collector_main function After commit 089480c07, it's necessary for background worker entry points to be marked PGDLLEXPORT, else they aren't findable by LookupBackgroundWorkerFunction(). --- pg_wait_sampling.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pg_wait_sampling.h b/pg_wait_sampling.h index bb0e1d8..0de8d7b 100644 --- a/pg_wait_sampling.h +++ b/pg_wait_sampling.h @@ -81,7 +81,7 @@ extern void init_lock_tag(LOCKTAG *tag, uint32 lock); /* collector.c */ extern void register_wait_collector(void); extern void alloc_history(History *, int); -extern void collector_main(Datum main_arg); +extern PGDLLEXPORT void collector_main(Datum main_arg); extern void shm_mq_detach_compat(shm_mq_handle *mqh, shm_mq *mq); extern shm_mq_result shm_mq_send_compat(shm_mq_handle *mqh, Size nbytes, From d36b971171eb9284dd8a659bca41e0557e4a13f4 Mon Sep 17 00:00:00 2001 From: Zharkov Roman Date: Mon, 15 Aug 2022 11:38:00 +0700 Subject: [PATCH 16/21] Simplify the Makefile to fix MSVC build. Mkvcbuild does not support variables expansion in makefiles, so the build failed on the Windows systems. --- .gitignore | 1 - Makefile | 8 +------- setup.sql => pg_wait_sampling--1.1.sql | 0 3 files changed, 1 insertion(+), 8 deletions(-) rename setup.sql => pg_wait_sampling--1.1.sql (100%) diff --git a/.gitignore b/.gitignore index 0636f19..1c13cb9 100644 --- a/.gitignore +++ b/.gitignore @@ -2,7 +2,6 @@ *.o *.so /results -*pg_wait_sampling--1.1.sql .log Dockerfile /log/ diff --git a/Makefile b/Makefile index ab90e59..e048136 100644 --- a/Makefile +++ b/Makefile @@ -4,14 +4,11 @@ MODULE_big = pg_wait_sampling OBJS = pg_wait_sampling.o collector.o compat.o EXTENSION = pg_wait_sampling -EXTVERSION = 1.1 -DATA_built = pg_wait_sampling--$(EXTVERSION).sql -DATA = pg_wait_sampling--1.0--1.1.sql +DATA = pg_wait_sampling--1.1.sql pg_wait_sampling--1.0--1.1.sql REGRESS = load queries EXTRA_REGRESS_OPTS=--temp-config=$(top_srcdir)/$(subdir)/conf.add -EXTRA_CLEAN = pg_wait_sampling--$(EXTVERSION).sql ifdef USE_PGXS PG_CONFIG = pg_config @@ -24,9 +21,6 @@ include $(top_builddir)/src/Makefile.global include $(top_srcdir)/contrib/contrib-global.mk endif -$(EXTENSION)--$(EXTVERSION).sql: setup.sql - cat $^ > $@ - # Prepare the package for PGXN submission package: dist .git $(eval DISTVERSION := $(shell git tag -l | tail -n 1 | cut -d 'v' -f 2)) diff --git a/setup.sql b/pg_wait_sampling--1.1.sql similarity index 100% rename from setup.sql rename to pg_wait_sampling--1.1.sql From 8ac2e6a86b65121d8c2d8f5cf0fd43fcf225abfe Mon Sep 17 00:00:00 2001 From: Maksim Milyutin Date: Wed, 17 Aug 2022 11:40:28 +0400 Subject: [PATCH 17/21] Move all inlined compatible wrappers into header file Previous implementation segregated compatible inline function wrappers into separate .c file that prevented inlining of these functions into caller points in other modules. In current patch all these fuctions with `static inline` specification have been moved to header file compat.h. This emulates behavior of macro expanding in case when compiler performs inlining. Resolve https://github.com/postgrespro/pg_wait_sampling/issues/45 --- Makefile | 2 +- collector.c | 1 + compat.c => compat.h | 41 +++++++++++++++++++++++++++-------------- pg_wait_sampling.c | 1 + pg_wait_sampling.h | 11 ----------- 5 files changed, 30 insertions(+), 26 deletions(-) rename compat.c => compat.h (76%) diff --git a/Makefile b/Makefile index ab90e59..9869ec9 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,7 @@ # contrib/pg_wait_sampling/Makefile MODULE_big = pg_wait_sampling -OBJS = pg_wait_sampling.o collector.o compat.o +OBJS = pg_wait_sampling.o collector.o EXTENSION = pg_wait_sampling EXTVERSION = 1.1 diff --git a/collector.c b/collector.c index 9bb8cfb..2bfe534 100644 --- a/collector.c +++ b/collector.c @@ -26,6 +26,7 @@ #include "utils/resowner.h" #include "pgstat.h" +#include "compat.h" #include "pg_wait_sampling.h" static volatile sig_atomic_t shutdown_requested = false; diff --git a/compat.c b/compat.h similarity index 76% rename from compat.c rename to compat.h index f2a57ae..3f471ce 100644 --- a/compat.c +++ b/compat.h @@ -1,11 +1,32 @@ +/* + * compat.h + * Definitions for function wrappers compatible between PG versions. + * + * Copyright (c) 2015-2022, Postgres Professional + * + * IDENTIFICATION + * contrib/pg_wait_sampling/compat.h + */ +#ifndef __COMPAT_H__ +#define __COMPAT_H__ + #include "postgres.h" #include "access/tupdesc.h" #include "miscadmin.h" +#include "storage/shm_mq.h" -#include "pg_wait_sampling.h" +static inline TupleDesc +CreateTemplateTupleDescCompat(int nattrs, bool hasoid) +{ +#if PG_VERSION_NUM >= 120000 + return CreateTemplateTupleDesc(nattrs); +#else + return CreateTemplateTupleDesc(nattrs, hasoid); +#endif +} -inline void +static inline void shm_mq_detach_compat(shm_mq_handle *mqh, shm_mq *mq) { #if PG_VERSION_NUM >= 100000 @@ -15,7 +36,7 @@ shm_mq_detach_compat(shm_mq_handle *mqh, shm_mq *mq) #endif } -inline shm_mq_result +static inline shm_mq_result shm_mq_send_compat(shm_mq_handle *mqh, Size nbytes, const void *data, bool nowait, bool force_flush) { @@ -26,17 +47,7 @@ shm_mq_send_compat(shm_mq_handle *mqh, Size nbytes, const void *data, #endif } -inline TupleDesc -CreateTemplateTupleDescCompat(int nattrs, bool hasoid) -{ -#if PG_VERSION_NUM >= 120000 - return CreateTemplateTupleDesc(nattrs); -#else - return CreateTemplateTupleDesc(nattrs, hasoid); -#endif -} - -inline void +static inline void InitPostgresCompat(const char *in_dbname, Oid dboid, const char *username, Oid useroid, bool load_session_libraries, @@ -53,3 +64,5 @@ InitPostgresCompat(const char *in_dbname, Oid dboid, InitPostgres(in_dbname, dboid, username, useroid, out_dbname); #endif } + +#endif diff --git a/pg_wait_sampling.c b/pg_wait_sampling.c index 8c45f10..deda26c 100644 --- a/pg_wait_sampling.c +++ b/pg_wait_sampling.c @@ -34,6 +34,7 @@ #include "utils/memutils.h" /* TopMemoryContext. Actually for PG 9.6 only, * but there should be no harm for others. */ +#include "compat.h" #include "pg_wait_sampling.h" PG_MODULE_MAGIC; diff --git a/pg_wait_sampling.h b/pg_wait_sampling.h index 0de8d7b..a33d707 100644 --- a/pg_wait_sampling.h +++ b/pg_wait_sampling.h @@ -83,15 +83,4 @@ extern void register_wait_collector(void); extern void alloc_history(History *, int); extern PGDLLEXPORT void collector_main(Datum main_arg); -extern void shm_mq_detach_compat(shm_mq_handle *mqh, shm_mq *mq); -extern shm_mq_result shm_mq_send_compat(shm_mq_handle *mqh, Size nbytes, - const void *data, bool nowait, - bool force_flush); -extern TupleDesc CreateTemplateTupleDescCompat(int nattrs, bool hasoid); -extern void InitPostgresCompat(const char *in_dbname, Oid dboid, - const char *username, Oid useroid, - bool load_session_libraries, - bool override_allow_connections, - char *out_dbname); - #endif From 2d38a7989ae2b7c58347cb88b8d23a66b6c559e8 Mon Sep 17 00:00:00 2001 From: Sergey Shinderuk Date: Wed, 31 Aug 2022 15:39:12 +0300 Subject: [PATCH 18/21] PGPRO-6599: Avoid race when accessing the request shared variable. Consider the following sequence of events: 1. Session 1 calls pg_wait_sampling_reset_profile and sets the request shared variable to PROFILE_RESET. 2. The collector reads request and saves PROFILE_RESET to a local variable. 3. Session 2 queries pg_wait_sampling_profile, which sets request to PROFILE_REQUEST and waits for the collector in shm_mq_receive. 4. The collector continues and clears shared request, thus dropping PROFILE_REQUEST from Session 2. 5. Session 2 waits indefinitely in shm_mq_receive. A similar example with query cancellation: 1. Session 1 queries pg_wait_sampling_history and sets request to HISTORY_REQUEST. 2. Session 1 cancels the query while waiting for the collector. 3. The collector reads request and saves HISTORY_REQUEST to a local variable. 4. Session 2 queries pg_wait_sampling_profile, sets request to PROFILE_REQUEST and waits for the collector. 5. The collector continues and responds to HISTORY_REQUEST. 6. Session 2 receives history data and renders them as profile data returning invalid counts. These interleavings are avoided by acquiring the collector lock before reading request from shared memory in the collector. But we also need to hold the collector lock when we set request in receive_array in a backend. Otherwise, the following interleaving is possible: 1. Session 1 calls pg_wait_sampling_reset_profile and sets request to PROFILE_RESET. 2. Session 2 queries pg_wait_sampling_profile, acquires and releases the collector lock. 3. The collector acquires the lock, reads request and saves PROFILE_RESET to a local variable. 4. Session 2 sets request to PROFILE_REQUEST. 5. The collector clears request, and PROFILE_REQUEST is lost. 6. Session 2 waits indefinitely in shm_mq_receive. Same for the second example above. This patch, however, doesn't prevent loosing PROFILE_RESET requests: 1. Session 1 calls pg_wait_sampling_reset_profile and sets request to PROFILE_RESET. 2. Session 2 queries pg_wait_sampling_profile before the collector reads request. 3. The collector reads PROFILE_REQUEST, while PROFILE_RESET is lost. To fix this, we could make pg_wait_sampling_reset_profile wait for the collector, but we decided not to, as loosing a PROFILE_RESET isn't critical. Resolves #48. Author: Roman Zharkov Reported-By: Alexander Lakhin Reviewed-By: Maksim Milyutin, Sergey Shinderuk --- collector.c | 3 ++- pg_wait_sampling.c | 6 ++---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/collector.c b/collector.c index 9bb8cfb..80a559a 100644 --- a/collector.c +++ b/collector.c @@ -441,11 +441,12 @@ collector_main(Datum main_arg) if (collector_hdr->request != NO_REQUEST) { LOCKTAG tag; - SHMRequest request = collector_hdr->request; + SHMRequest request; init_lock_tag(&tag, PGWS_COLLECTOR_LOCK); LockAcquire(&tag, ExclusiveLock, false, false); + request = collector_hdr->request; collector_hdr->request = NO_REQUEST; if (request == HISTORY_REQUEST || request == PROFILE_REQUEST) diff --git a/pg_wait_sampling.c b/pg_wait_sampling.c index 8c45f10..6877a12 100644 --- a/pg_wait_sampling.c +++ b/pg_wait_sampling.c @@ -594,13 +594,11 @@ receive_array(SHMRequest request, Size item_size, Size *count) init_lock_tag(&queueTag, PGWS_QUEUE_LOCK); LockAcquire(&queueTag, ExclusiveLock, false, false); - /* Ensure collector has processed previous request */ init_lock_tag(&collectorTag, PGWS_COLLECTOR_LOCK); LockAcquire(&collectorTag, ExclusiveLock, false, false); - LockRelease(&collectorTag, ExclusiveLock, false); - recv_mq = shm_mq_create(collector_mq, COLLECTOR_QUEUE_SIZE); collector_hdr->request = request; + LockRelease(&collectorTag, ExclusiveLock, false); if (!collector_hdr->latch) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), @@ -770,9 +768,9 @@ pg_wait_sampling_reset_profile(PG_FUNCTION_ARGS) init_lock_tag(&tagCollector, PGWS_COLLECTOR_LOCK); LockAcquire(&tagCollector, ExclusiveLock, false, false); + collector_hdr->request = PROFILE_RESET; LockRelease(&tagCollector, ExclusiveLock, false); - collector_hdr->request = PROFILE_RESET; SetLatch(collector_hdr->latch); LockRelease(&tag, ExclusiveLock, false); From 0f1b89a0d6bc161edbd9aa216e3bbfc8034e6b63 Mon Sep 17 00:00:00 2001 From: Sergey Shinderuk Date: Thu, 1 Sep 2022 14:46:11 +0300 Subject: [PATCH 19/21] PGPRO-6601: Add prefix to global variables and functions. This is necessary to avoid name collision with other modules. Where possible, make variables and functions static. --- collector.c | 40 +++++++------- pg_wait_sampling.c | 130 ++++++++++++++++++++++----------------------- pg_wait_sampling.h | 15 +++--- 3 files changed, 90 insertions(+), 95 deletions(-) diff --git a/collector.c b/collector.c index 23cb7f0..e1e00cf 100644 --- a/collector.c +++ b/collector.c @@ -37,7 +37,7 @@ static void handle_sigterm(SIGNAL_ARGS); * Register background worker for collecting waits history. */ void -register_wait_collector(void) +pgws_register_wait_collector(void) { BackgroundWorker worker; @@ -48,7 +48,7 @@ register_wait_collector(void) worker.bgw_restart_time = 1; worker.bgw_notify_pid = 0; snprintf(worker.bgw_library_name, BGW_MAXLEN, "pg_wait_sampling"); - snprintf(worker.bgw_function_name, BGW_MAXLEN, CppAsString(collector_main)); + snprintf(worker.bgw_function_name, BGW_MAXLEN, CppAsString(pgws_collector_main)); snprintf(worker.bgw_name, BGW_MAXLEN, "pg_wait_sampling collector"); worker.bgw_main_arg = (Datum) 0; RegisterBackgroundWorker(&worker); @@ -57,7 +57,7 @@ register_wait_collector(void) /* * Allocate memory for waits history. */ -void +static void alloc_history(History *observations, int count) { observations->items = (HistoryItem *) palloc0(sizeof(HistoryItem) * count); @@ -151,7 +151,7 @@ probe_waits(History *observations, HTAB *profile_hash, TimestampTz ts = GetCurrentTimestamp(); /* Realloc waits history if needed */ - newSize = collector_hdr->historySize; + newSize = pgws_collector_hdr->historySize; if (observations->count != newSize) realloc_history(observations, newSize); @@ -173,8 +173,8 @@ probe_waits(History *observations, HTAB *profile_hash, item.pid = proc->pid; item.wait_event_info = proc->wait_event_info; - if (collector_hdr->profileQueries) - item.queryId = proc_queryids[i]; + if (pgws_collector_hdr->profileQueries) + item.queryId = pgws_proc_queryids[i]; else item.queryId = 0; @@ -292,7 +292,7 @@ make_profile_hash() hash_ctl.hash = tag_hash; hash_ctl.hcxt = TopMemoryContext; - if (collector_hdr->profileQueries) + if (pgws_collector_hdr->profileQueries) hash_ctl.keysize = offsetof(ProfileItem, count); else hash_ctl.keysize = offsetof(ProfileItem, queryId); @@ -321,7 +321,7 @@ millisecs_diff(TimestampTz tz1, TimestampTz tz2) * Main routine of wait history collector. */ void -collector_main(Datum main_arg) +pgws_collector_main(Datum main_arg) { HTAB *profile_hash = NULL; History observations; @@ -358,13 +358,13 @@ collector_main(Datum main_arg) pgstat_report_appname("pg_wait_sampling collector"); profile_hash = make_profile_hash(); - collector_hdr->latch = &MyProc->procLatch; + pgws_collector_hdr->latch = &MyProc->procLatch; CurrentResourceOwner = ResourceOwnerCreate(NULL, "pg_wait_sampling collector"); collector_context = AllocSetContextCreate(TopMemoryContext, "pg_wait_sampling context", ALLOCSET_DEFAULT_SIZES); old_context = MemoryContextSwitchTo(collector_context); - alloc_history(&observations, collector_hdr->historySize); + alloc_history(&observations, pgws_collector_hdr->historySize); MemoryContextSwitchTo(old_context); ereport(LOG, (errmsg("pg_wait_sampling collector started"))); @@ -391,8 +391,8 @@ collector_main(Datum main_arg) history_diff = millisecs_diff(history_ts, current_ts); profile_diff = millisecs_diff(profile_ts, current_ts); - history_period = collector_hdr->historyPeriod; - profile_period = collector_hdr->profilePeriod; + history_period = pgws_collector_hdr->historyPeriod; + profile_period = pgws_collector_hdr->profilePeriod; write_history = (history_diff >= (int64)history_period); write_profile = (profile_diff >= (int64)profile_period); @@ -400,7 +400,7 @@ collector_main(Datum main_arg) if (write_history || write_profile) { probe_waits(&observations, profile_hash, - write_history, write_profile, collector_hdr->profilePid); + write_history, write_profile, pgws_collector_hdr->profilePid); if (write_history) { @@ -439,24 +439,24 @@ collector_main(Datum main_arg) ResetLatch(&MyProc->procLatch); /* Handle request if any */ - if (collector_hdr->request != NO_REQUEST) + if (pgws_collector_hdr->request != NO_REQUEST) { LOCKTAG tag; SHMRequest request; - init_lock_tag(&tag, PGWS_COLLECTOR_LOCK); + pgws_init_lock_tag(&tag, PGWS_COLLECTOR_LOCK); LockAcquire(&tag, ExclusiveLock, false, false); - request = collector_hdr->request; - collector_hdr->request = NO_REQUEST; + request = pgws_collector_hdr->request; + pgws_collector_hdr->request = NO_REQUEST; if (request == HISTORY_REQUEST || request == PROFILE_REQUEST) { shm_mq_result mq_result; /* Send history or profile */ - shm_mq_set_sender(collector_mq, MyProc); - mqh = shm_mq_attach(collector_mq, NULL, NULL); + shm_mq_set_sender(pgws_collector_mq, MyProc); + mqh = shm_mq_attach(pgws_collector_mq, NULL, NULL); mq_result = shm_mq_wait_for_attach(mqh); switch (mq_result) { @@ -482,7 +482,7 @@ collector_main(Datum main_arg) default: AssertState(false); } - shm_mq_detach_compat(mqh, collector_mq); + shm_mq_detach_compat(mqh, pgws_collector_mq); } else if (request == PROFILE_RESET) { diff --git a/pg_wait_sampling.c b/pg_wait_sampling.c index 22732dd..c77f980 100644 --- a/pg_wait_sampling.c +++ b/pg_wait_sampling.c @@ -41,23 +41,21 @@ PG_MODULE_MAGIC; void _PG_init(void); -/* Global variables */ -bool shmem_initialized = false; +static bool shmem_initialized = false; /* Hooks */ static ExecutorEnd_hook_type prev_ExecutorEnd = NULL; static planner_hook_type planner_hook_next = NULL; -/* Shared memory variables */ -shm_toc *toc = NULL; -shm_mq *collector_mq = NULL; -uint64 *proc_queryids = NULL; -CollectorShmqHeader *collector_hdr = NULL; +/* Pointers to shared memory objects */ +shm_mq *pgws_collector_mq = NULL; +uint64 *pgws_proc_queryids = NULL; +CollectorShmqHeader *pgws_collector_hdr = NULL; /* Receiver (backend) local shm_mq pointers and lock */ -shm_mq *recv_mq = NULL; -shm_mq_handle *recv_mqh = NULL; -LOCKTAG queueTag; +static shm_mq *recv_mq = NULL; +static shm_mq_handle *recv_mqh = NULL; +static LOCKTAG queueTag; #if PG_VERSION_NUM >= 150000 static shmem_request_hook_type prev_shmem_request_hook = NULL; @@ -218,63 +216,63 @@ setup_gucs() if (!strcmp(name, "pg_wait_sampling.history_size")) { history_size_found = true; - var->integer.variable = &collector_hdr->historySize; - collector_hdr->historySize = 5000; + var->integer.variable = &pgws_collector_hdr->historySize; + pgws_collector_hdr->historySize = 5000; } else if (!strcmp(name, "pg_wait_sampling.history_period")) { history_period_found = true; - var->integer.variable = &collector_hdr->historyPeriod; - collector_hdr->historyPeriod = 10; + var->integer.variable = &pgws_collector_hdr->historyPeriod; + pgws_collector_hdr->historyPeriod = 10; } else if (!strcmp(name, "pg_wait_sampling.profile_period")) { profile_period_found = true; - var->integer.variable = &collector_hdr->profilePeriod; - collector_hdr->profilePeriod = 10; + var->integer.variable = &pgws_collector_hdr->profilePeriod; + pgws_collector_hdr->profilePeriod = 10; } else if (!strcmp(name, "pg_wait_sampling.profile_pid")) { profile_pid_found = true; - var->_bool.variable = &collector_hdr->profilePid; - collector_hdr->profilePid = true; + var->_bool.variable = &pgws_collector_hdr->profilePid; + pgws_collector_hdr->profilePid = true; } else if (!strcmp(name, "pg_wait_sampling.profile_queries")) { profile_queries_found = true; - var->_bool.variable = &collector_hdr->profileQueries; - collector_hdr->profileQueries = true; + var->_bool.variable = &pgws_collector_hdr->profileQueries; + pgws_collector_hdr->profileQueries = true; } } if (!history_size_found) DefineCustomIntVariable("pg_wait_sampling.history_size", "Sets size of waits history.", NULL, - &collector_hdr->historySize, 5000, 100, INT_MAX, + &pgws_collector_hdr->historySize, 5000, 100, INT_MAX, PGC_SUSET, 0, shmem_int_guc_check_hook, NULL, NULL); if (!history_period_found) DefineCustomIntVariable("pg_wait_sampling.history_period", "Sets period of waits history sampling.", NULL, - &collector_hdr->historyPeriod, 10, 1, INT_MAX, + &pgws_collector_hdr->historyPeriod, 10, 1, INT_MAX, PGC_SUSET, 0, shmem_int_guc_check_hook, NULL, NULL); if (!profile_period_found) DefineCustomIntVariable("pg_wait_sampling.profile_period", "Sets period of waits profile sampling.", NULL, - &collector_hdr->profilePeriod, 10, 1, INT_MAX, + &pgws_collector_hdr->profilePeriod, 10, 1, INT_MAX, PGC_SUSET, 0, shmem_int_guc_check_hook, NULL, NULL); if (!profile_pid_found) DefineCustomBoolVariable("pg_wait_sampling.profile_pid", "Sets whether profile should be collected per pid.", NULL, - &collector_hdr->profilePid, true, + &pgws_collector_hdr->profilePid, true, PGC_SUSET, 0, shmem_bool_guc_check_hook, NULL, NULL); if (!profile_queries_found) DefineCustomBoolVariable("pg_wait_sampling.profile_queries", "Sets whether profile should be collected per query.", NULL, - &collector_hdr->profileQueries, true, + &pgws_collector_hdr->profileQueries, true, PGC_SUSET, 0, shmem_bool_guc_check_hook, NULL, NULL); if (history_size_found @@ -310,9 +308,10 @@ pgws_shmem_request(void) static void pgws_shmem_startup(void) { - bool found; - Size segsize = pgws_shmem_size(); - void *pgws; + bool found; + Size segsize = pgws_shmem_size(); + void *pgws; + shm_toc *toc; pgws = ShmemInitStruct("pg_wait_sampling", segsize, &found); @@ -320,14 +319,14 @@ pgws_shmem_startup(void) { toc = shm_toc_create(PG_WAIT_SAMPLING_MAGIC, pgws, segsize); - collector_hdr = shm_toc_allocate(toc, sizeof(CollectorShmqHeader)); - shm_toc_insert(toc, 0, collector_hdr); - collector_mq = shm_toc_allocate(toc, COLLECTOR_QUEUE_SIZE); - shm_toc_insert(toc, 1, collector_mq); - proc_queryids = shm_toc_allocate(toc, + pgws_collector_hdr = shm_toc_allocate(toc, sizeof(CollectorShmqHeader)); + shm_toc_insert(toc, 0, pgws_collector_hdr); + pgws_collector_mq = shm_toc_allocate(toc, COLLECTOR_QUEUE_SIZE); + shm_toc_insert(toc, 1, pgws_collector_mq); + pgws_proc_queryids = shm_toc_allocate(toc, sizeof(uint64) * get_max_procs_count()); - shm_toc_insert(toc, 2, proc_queryids); - MemSet(proc_queryids, 0, sizeof(uint64) * get_max_procs_count()); + shm_toc_insert(toc, 2, pgws_proc_queryids); + MemSet(pgws_proc_queryids, 0, sizeof(uint64) * get_max_procs_count()); /* Initialize GUC variables in shared memory */ setup_gucs(); @@ -337,13 +336,13 @@ pgws_shmem_startup(void) toc = shm_toc_attach(PG_WAIT_SAMPLING_MAGIC, pgws); #if PG_VERSION_NUM >= 100000 - collector_hdr = shm_toc_lookup(toc, 0, false); - collector_mq = shm_toc_lookup(toc, 1, false); - proc_queryids = shm_toc_lookup(toc, 2, false); + pgws_collector_hdr = shm_toc_lookup(toc, 0, false); + pgws_collector_mq = shm_toc_lookup(toc, 1, false); + pgws_proc_queryids = shm_toc_lookup(toc, 2, false); #else - collector_hdr = shm_toc_lookup(toc, 0); - collector_mq = shm_toc_lookup(toc, 1); - proc_queryids = shm_toc_lookup(toc, 2); + pgws_collector_hdr = shm_toc_lookup(toc, 0); + pgws_collector_mq = shm_toc_lookup(toc, 1); + pgws_proc_queryids = shm_toc_lookup(toc, 2); #endif } @@ -356,7 +355,7 @@ pgws_shmem_startup(void) /* * Check shared memory is initialized. Report an error otherwise. */ -void +static void check_shmem(void) { if (!shmem_initialized) @@ -395,7 +394,7 @@ _PG_init(void) RequestAddinShmemSpace(pgws_shmem_size()); #endif - register_wait_collector(); + pgws_register_wait_collector(); /* * Install hooks. @@ -490,7 +489,7 @@ pg_wait_sampling_get_current(PG_FUNCTION_ARGS) item = ¶ms->items[0]; item->pid = proc->pid; item->wait_event_info = proc->wait_event_info; - item->queryId = proc_queryids[proc - ProcGlobal->allProcs]; + item->queryId = pgws_proc_queryids[proc - ProcGlobal->allProcs]; funcctx->max_calls = 1; } else @@ -508,7 +507,7 @@ pg_wait_sampling_get_current(PG_FUNCTION_ARGS) { params->items[j].pid = proc->pid; params->items[j].wait_event_info = proc->wait_event_info; - params->items[j].queryId = proc_queryids[i]; + params->items[j].queryId = pgws_proc_queryids[i]; j++; } } @@ -569,7 +568,7 @@ typedef struct } Profile; void -init_lock_tag(LOCKTAG *tag, uint32 lock) +pgws_init_lock_tag(LOCKTAG *tag, uint32 lock) { tag->locktag_field1 = PG_WAIT_SAMPLING_MAGIC; tag->locktag_field2 = lock; @@ -592,20 +591,20 @@ receive_array(SHMRequest request, Size item_size, Size *count) MemoryContext oldctx; /* Ensure nobody else trying to send request to queue */ - init_lock_tag(&queueTag, PGWS_QUEUE_LOCK); + pgws_init_lock_tag(&queueTag, PGWS_QUEUE_LOCK); LockAcquire(&queueTag, ExclusiveLock, false, false); - init_lock_tag(&collectorTag, PGWS_COLLECTOR_LOCK); + pgws_init_lock_tag(&collectorTag, PGWS_COLLECTOR_LOCK); LockAcquire(&collectorTag, ExclusiveLock, false, false); - recv_mq = shm_mq_create(collector_mq, COLLECTOR_QUEUE_SIZE); - collector_hdr->request = request; + recv_mq = shm_mq_create(pgws_collector_mq, COLLECTOR_QUEUE_SIZE); + pgws_collector_hdr->request = request; LockRelease(&collectorTag, ExclusiveLock, false); - if (!collector_hdr->latch) + if (!pgws_collector_hdr->latch) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("pg_wait_sampling collector wasn't started"))); - SetLatch(collector_hdr->latch); + SetLatch(pgws_collector_hdr->latch); shm_mq_set_receiver(recv_mq, MyProc); @@ -736,7 +735,7 @@ pg_wait_sampling_get_profile(PG_FUNCTION_ARGS) else nulls[2] = true; - if (collector_hdr->profileQueries) + if (pgws_collector_hdr->profileQueries) values[3] = Int64GetDatumFast(item->queryId); else values[3] = (Datum) 0; @@ -758,23 +757,22 @@ PG_FUNCTION_INFO_V1(pg_wait_sampling_reset_profile); Datum pg_wait_sampling_reset_profile(PG_FUNCTION_ARGS) { - LOCKTAG tag; - LOCKTAG tagCollector; + LOCKTAG collectorTag; check_shmem(); - init_lock_tag(&tag, PGWS_QUEUE_LOCK); + pgws_init_lock_tag(&queueTag, PGWS_QUEUE_LOCK); - LockAcquire(&tag, ExclusiveLock, false, false); + LockAcquire(&queueTag, ExclusiveLock, false, false); - init_lock_tag(&tagCollector, PGWS_COLLECTOR_LOCK); - LockAcquire(&tagCollector, ExclusiveLock, false, false); - collector_hdr->request = PROFILE_RESET; - LockRelease(&tagCollector, ExclusiveLock, false); + pgws_init_lock_tag(&collectorTag, PGWS_COLLECTOR_LOCK); + LockAcquire(&collectorTag, ExclusiveLock, false, false); + pgws_collector_hdr->request = PROFILE_RESET; + LockRelease(&collectorTag, ExclusiveLock, false); - SetLatch(collector_hdr->latch); + SetLatch(pgws_collector_hdr->latch); - LockRelease(&tag, ExclusiveLock, false); + LockRelease(&queueTag, ExclusiveLock, false); PG_RETURN_VOID(); } @@ -894,8 +892,8 @@ pgws_planner_hook(Query *parse, StaticAssertExpr(sizeof(parse->queryId) == sizeof(uint32), "queryId size is not uint32"); #endif - if (!proc_queryids[i]) - proc_queryids[i] = parse->queryId; + if (!pgws_proc_queryids[i]) + pgws_proc_queryids[i] = parse->queryId; } @@ -921,7 +919,7 @@ static void pgws_ExecutorEnd(QueryDesc *queryDesc) { if (MyProc) - proc_queryids[MyProc - ProcGlobal->allProcs] = UINT64CONST(0); + pgws_proc_queryids[MyProc - ProcGlobal->allProcs] = UINT64CONST(0); if (prev_ExecutorEnd) prev_ExecutorEnd(queryDesc); diff --git a/pg_wait_sampling.h b/pg_wait_sampling.h index a33d707..29425fc 100644 --- a/pg_wait_sampling.h +++ b/pg_wait_sampling.h @@ -71,16 +71,13 @@ typedef struct } CollectorShmqHeader; /* pg_wait_sampling.c */ -extern void check_shmem(void); -extern CollectorShmqHeader *collector_hdr; -extern shm_mq *collector_mq; -extern uint64 *proc_queryids; -extern void read_current_wait(PGPROC *proc, HistoryItem *item); -extern void init_lock_tag(LOCKTAG *tag, uint32 lock); +extern CollectorShmqHeader *pgws_collector_hdr; +extern shm_mq *pgws_collector_mq; +extern uint64 *pgws_proc_queryids; +extern void pgws_init_lock_tag(LOCKTAG *tag, uint32 lock); /* collector.c */ -extern void register_wait_collector(void); -extern void alloc_history(History *, int); -extern PGDLLEXPORT void collector_main(Datum main_arg); +extern void pgws_register_wait_collector(void); +extern PGDLLEXPORT void pgws_collector_main(Datum main_arg); #endif From 8b05241a8cfc87b3ccc633a0bd3c020cc8c76150 Mon Sep 17 00:00:00 2001 From: Maksim Milyutin Date: Wed, 25 May 2022 22:39:50 +0400 Subject: [PATCH 20/21] Add building/testing with PG14 and PG15beta3 in Travis CI. Drop builds for PG9.6. --- .travis.yml | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/.travis.yml b/.travis.yml index 69c38e0..4ea7793 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,15 +17,16 @@ script: - docker-compose run tests env: - - PG_VERSION=9.6 CHECK_CODE=clang - - PG_VERSION=9.6 CHECK_CODE=cppcheck - - PG_VERSION=9.6 CHECK_CODE=false - - PG_VERSION=10 CHECK_CODE=clang - - PG_VERSION=10 CHECK_CODE=cppcheck - - PG_VERSION=10 CHECK_CODE=false - - PG_VERSION=11 CHECK_CODE=clang - - PG_VERSION=11 CHECK_CODE=false - - PG_VERSION=12 CHECK_CODE=clang - - PG_VERSION=12 CHECK_CODE=false - - PG_VERSION=13 CHECK_CODE=clang - - PG_VERSION=13 CHECK_CODE=false + - PG_VERSION=10 CHECK_CODE=clang + - PG_VERSION=10 CHECK_CODE=cppcheck + - PG_VERSION=10 CHECK_CODE=false + - PG_VERSION=11 CHECK_CODE=clang + - PG_VERSION=11 CHECK_CODE=false + - PG_VERSION=12 CHECK_CODE=clang + - PG_VERSION=12 CHECK_CODE=false + - PG_VERSION=13 CHECK_CODE=clang + - PG_VERSION=13 CHECK_CODE=false + - PG_VERSION=14 CHECK_CODE=clang + - PG_VERSION=14 CHECK_CODE=false + - PG_VERSION=15beta3 CHECK_CODE=clang + - PG_VERSION=15beta3 CHECK_CODE=false From 57c1ecfed6413a033fc66c1c612ee1cacd1ff836 Mon Sep 17 00:00:00 2001 From: Sergey Shinderuk Date: Fri, 30 Sep 2022 12:38:01 +0300 Subject: [PATCH 21/21] Bump PGXN version to 1.1.4 --- META.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/META.json b/META.json index f26554e..0f09ab0 100644 --- a/META.json +++ b/META.json @@ -2,7 +2,7 @@ "name": "pg_wait_sampling", "abstract": "Sampling based statistics of wait events", "description": "pg_wait_sampling provides functions for detailed per backend and per query statistics about PostgreSQL wait events", - "version": "1.1.3", + "version": "1.1.4", "maintainer": [ "Alexander Korotkov ", "Ildus Kurbangaliev " @@ -21,7 +21,7 @@ "pg_wait_sampling": { "file": "pg_wait_sampling--1.1.sql", "docfile": "README.md", - "version": "1.1.3", + "version": "1.1.4", "abstract": "Sampling based statistics of wait events" } },