pgstat.c source code [PostgreSQL/src/backend/postmaster/pgstat.c]

1	/ ----------*
2	* pgstat.c
3	*
4	* All the statistics collector stuff hacked up in one big, ugly file.
5	*
6	* TODO: - Separate collector, postmaster and backend stuff
7	* into different files.
8	*
9	* - Add some automatic call for pgstat vacuuming.
10	*
11	* - Add a pgstat config column to pg_database, so this
12	* entire thing can be enabled/disabled on a per db basis.
13	*
14	* Copyright (c) 2001-2019, PostgreSQL Global Development Group
15	*
16	* src/backend/postmaster/pgstat.c
17	* ----------
18	*/
19	#include "postgres.h"
20
21	#include <unistd.h>
22	#include <fcntl.h>
23	#include <sys/param.h>
24	#include <sys/time.h>
25	#include <sys/socket.h>
26	#include <netdb.h>
27	#include <netinet/in.h>
28	#include <arpa/inet.h>
29	#include <signal.h>
30	#include <time.h>
31	#ifdef HAVE_SYS_SELECT_H
32	#include <sys/select.h>
33	#endif
34
35	#include "pgstat.h"
36
37	#include "access/heapam.h"
38	#include "access/htup_details.h"
39	#include "access/tableam.h"
40	#include "access/transam.h"
41	#include "access/twophase_rmgr.h"
42	#include "access/xact.h"
43	#include "catalog/pg_database.h"
44	#include "catalog/pg_proc.h"
45	#include "common/ip.h"
46	#include "libpq/libpq.h"
47	#include "libpq/pqsignal.h"
48	#include "mb/pg_wchar.h"
49	#include "miscadmin.h"
50	#include "pg_trace.h"
51	#include "postmaster/autovacuum.h"
52	#include "postmaster/fork_process.h"
53	#include "postmaster/postmaster.h"
54	#include "replication/walsender.h"
55	#include "storage/backendid.h"
56	#include "storage/dsm.h"
57	#include "storage/fd.h"
58	#include "storage/ipc.h"
59	#include "storage/latch.h"
60	#include "storage/lmgr.h"
61	#include "storage/pg_shmem.h"
62	#include "storage/procsignal.h"
63	#include "storage/sinvaladt.h"
64	#include "utils/ascii.h"
65	#include "utils/guc.h"
66	#include "utils/memutils.h"
67	#include "utils/ps_status.h"
68	#include "utils/rel.h"
69	#include "utils/snapmgr.h"
70	#include "utils/timestamp.h"
71
72
73	/ ----------*
74	* Timer definitions.
75	* ----------
76	*/
77	#define PGSTAT_STAT_INTERVAL 500 /* Minimum time between stats file
78	* updates; in milliseconds. */
79
80	#define PGSTAT_RETRY_DELAY 10 /* How long to wait between checks for a
81	* new file; in milliseconds. */
82
83	#define PGSTAT_MAX_WAIT_TIME 10000 /* Maximum time to wait for a stats
84	* file update; in milliseconds. */
85
86	#define PGSTAT_INQ_INTERVAL 640 /* How often to ping the collector for a
87	* new file; in milliseconds. */
88
89	#define PGSTAT_RESTART_INTERVAL 60 /* How often to attempt to restart a
90	* failed statistics collector; in
91	* seconds. */
92
93	#define PGSTAT_POLL_LOOP_COUNT (PGSTAT_MAX_WAIT_TIME / PGSTAT_RETRY_DELAY)
94	#define PGSTAT_INQ_LOOP_COUNT (PGSTAT_INQ_INTERVAL / PGSTAT_RETRY_DELAY)
95
96	/ Minimum receive buffer size for the collector's socket. /
97	#define PGSTAT_MIN_RCVBUF (100 * 1024)
98
99
100	/ ----------*
101	* The initial size hints for the hash tables used in the collector.
102	* ----------
103	*/
104	#define PGSTAT_DB_HASH_SIZE 16
105	#define PGSTAT_TAB_HASH_SIZE 512
106	#define PGSTAT_FUNCTION_HASH_SIZE 512
107
108
109	/ ----------*
110	* Total number of backends including auxiliary
111	*
112	* We reserve a slot for each possible BackendId, plus one for each
113	* possible auxiliary process type. (This scheme assumes there is not
114	* more than one of any auxiliary process type at a time.) MaxBackends
115	* includes autovacuum workers and background workers as well.
116	* ----------
117	*/
118	#define NumBackendStatSlots (MaxBackends + NUM_AUXPROCTYPES)
119
120
121	/ ----------*
122	* GUC parameters
123	* ----------
124	*/
125	bool pgstat_track_activities = false;
126	bool pgstat_track_counts = false;
127	int pgstat_track_functions = TRACK_FUNC_OFF;
128	int pgstat_track_activity_query_size = `1024`;
129
130	/ ----------*
131	* Built from GUC parameter
132	* ----------
133	*/
134	char *pgstat_stat_directory = NULL;
135	char *pgstat_stat_filename = NULL;
136	char *pgstat_stat_tmpname = NULL;
137
138	/*
139	* BgWriter global statistics counters (unused in other processes).
140	* Stored directly in a stats message structure so it can be sent
141	* without needing to copy things around. We assume this inits to zeroes.
142	*/
143	PgStat_MsgBgWriter BgWriterStats;
144
145	/ ----------*
146	* Local data
147	* ----------
148	*/
149	NON_EXEC_STATIC pgsocket pgStatSock = PGINVALID_SOCKET;
150
151	static struct sockaddr_storage pgStatAddr;
152
153	static time_t last_pgstat_start_time;
154
155	static bool pgStatRunningInCollector = false;
156
157	/*
158	* Structures in which backends store per-table info that's waiting to be
159	* sent to the collector.
160	*
161	* NOTE: once allocated, TabStatusArray structures are never moved or deleted
162	* for the life of the backend. Also, we zero out the t_id fields of the
163	* contained PgStat_TableStatus structs whenever they are not actively in use.
164	* This allows relcache pgstat_info pointers to be treated as long-lived data,
165	* avoiding repeated searches in pgstat_initstats() when a relation is
166	* repeatedly opened during a transaction.
167	*/
168	#define TABSTAT_QUANTUM 100 /* we alloc this many at a time */
169
170	typedef struct TabStatusArray
171	{
172	struct TabStatusArray tsa_next; /* link to next array, if any /
173	int tsa_used; / # entries currently used /
174	PgStat_TableStatus tsa_entries[TABSTAT_QUANTUM]; / per-table data /
175	} TabStatusArray;
176
177	static TabStatusArray *pgStatTabList = NULL;
178
179	/*
180	* pgStatTabHash entry: map from relation OID to PgStat_TableStatus pointer
181	*/
182	typedef struct TabStatHashEntry
183	{
184	Oid t_id;
185	PgStat_TableStatus *tsa_entry;
186	} TabStatHashEntry;
187
188	/*
189	* Hash table for O(1) t_id -> tsa_entry lookup
190	*/
191	static HTAB *pgStatTabHash = NULL;
192
193	/*
194	* Backends store per-function info that's waiting to be sent to the collector
195	* in this hash table (indexed by function OID).
196	*/
197	static HTAB *pgStatFunctions = NULL;
198
199	/*
200	* Indicates if backend has some function stats that it hasn't yet
201	* sent to the collector.
202	*/
203	static bool have_function_stats = false;
204
205	/*
206	* Tuple insertion/deletion counts for an open transaction can't be propagated
207	* into PgStat_TableStatus counters until we know if it is going to commit
208	* or abort. Hence, we keep these counts in per-subxact structs that live
209	* in TopTransactionContext. This data structure is designed on the assumption
210	* that subxacts won't usually modify very many tables.
211	*/
212	typedef struct PgStat_SubXactStatus
213	{
214	int nest_level; / subtransaction nest level /
215	struct PgStat_SubXactStatus prev; /* higher-level subxact if any /
216	PgStat_TableXactStatus first; /* head of list for this subxact /
217	} PgStat_SubXactStatus;
218
219	static PgStat_SubXactStatus *pgStatXactStack = NULL;
220
221	static int pgStatXactCommit = `0`;
222	static int pgStatXactRollback = `0`;
223	PgStat_Counter pgStatBlockReadTime = `0`;
224	PgStat_Counter pgStatBlockWriteTime = `0`;
225
226	/ Record that's written to 2PC state file when pgstat state is persisted /
227	typedef struct TwoPhasePgStatRecord
228	{
229	PgStat_Counter tuples_inserted; / tuples inserted in xact /
230	PgStat_Counter tuples_updated; / tuples updated in xact /
231	PgStat_Counter tuples_deleted; / tuples deleted in xact /
232	PgStat_Counter inserted_pre_trunc; / tuples inserted prior to truncate /
233	PgStat_Counter updated_pre_trunc; / tuples updated prior to truncate /
234	PgStat_Counter deleted_pre_trunc; / tuples deleted prior to truncate /
235	Oid t_id; / table's OID /
236	bool t_shared; / is it a shared catalog? /
237	bool t_truncated; / was the relation truncated? /
238	} TwoPhasePgStatRecord;
239
240	/*
241	* Info about current "snapshot" of stats file
242	*/
243	static MemoryContext pgStatLocalContext = NULL;
244	static HTAB *pgStatDBHash = NULL;
245
246	/ Status for backends including auxiliary /
247	static LocalPgBackendStatus *localBackendStatusTable = NULL;
248
249	/ Total number of backends including auxiliary /
250	static int localNumBackends = `0`;
251
252	/*
253	* Cluster wide statistics, kept in the stats collector.
254	* Contains statistics that are not collected per database
255	* or per table.
256	*/
257	static PgStat_ArchiverStats archiverStats;
258	static PgStat_GlobalStats globalStats;
259
260	/*
261	* List of OIDs of databases we need to write out. If an entry is InvalidOid,
262	* it means to write only the shared-catalog stats ("DB 0"); otherwise, we
263	* will write both that DB's data and the shared stats.
264	*/
265	static List *pending_write_requests = NIL;
266
267	/ Signal handler flags /
268	static volatile bool need_exit = false;
269	static volatile bool got_SIGHUP = false;
270
271	/*
272	* Total time charged to functions so far in the current backend.
273	* We use this to help separate "self" and "other" time charges.
274	* (We assume this initializes to zero.)
275	*/
276	static instr_time total_func_time;
277
278
279	/ ----------*
280	* Local function forward declarations
281	* ----------
282	*/
283	#ifdef EXEC_BACKEND
284	static pid_t pgstat_forkexec(void);
285	#endif
286
287	NON_EXEC_STATIC void PgstatCollectorMain(int argc, char *argv[]) pg_attribute_noreturn();
288	static void pgstat_exit(SIGNAL_ARGS);
289	static void pgstat_beshutdown_hook(int code, Datum arg);
290	static void pgstat_sighup_handler(SIGNAL_ARGS);
291
292	static PgStat_StatDBEntry *pgstat_get_db_entry(Oid databaseid, bool create);
293	static PgStat_StatTabEntry pgstat_get_tab_entry(PgStat_StatDBEntry dbentry,
294	Oid tableoid, bool create);
295	static void pgstat_write_statsfiles(bool permanent, bool allDbs);
296	static void pgstat_write_db_statsfile(PgStat_StatDBEntry *dbentry, bool permanent);
297	static HTAB *pgstat_read_statsfiles(Oid onlydb, bool permanent, bool deep);
298	static void pgstat_read_db_statsfile(Oid databaseid, HTAB tabhash, HTAB funchash, bool permanent);
299	static void backend_read_statsfile(void);
300	static void pgstat_read_current_status(void);
301
302	static bool pgstat_write_statsfile_needed(void);
303	static bool pgstat_db_requested(Oid databaseid);
304
305	static void pgstat_send_tabstat(PgStat_MsgTabstat *tsmsg);
306	static void pgstat_send_funcstats(void);
307	static HTAB *pgstat_collect_oids(Oid catalogid, AttrNumber anum_oid);
308
309	static PgStat_TableStatus *get_tabstat_entry(Oid rel_id, bool isshared);
310
311	static void pgstat_setup_memcxt(void);
312
313	static const char *pgstat_get_wait_activity(WaitEventActivity w);
314	static const char *pgstat_get_wait_client(WaitEventClient w);
315	static const char *pgstat_get_wait_ipc(WaitEventIPC w);
316	static const char *pgstat_get_wait_timeout(WaitEventTimeout w);
317	static const char *pgstat_get_wait_io(WaitEventIO w);
318
319	static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype);
320	static void pgstat_send(void msg, int* len);
321
322	static void pgstat_recv_inquiry(PgStat_MsgInquiry msg, int* len);
323	static void pgstat_recv_tabstat(PgStat_MsgTabstat msg, int* len);
324	static void pgstat_recv_tabpurge(PgStat_MsgTabpurge msg, int* len);
325	static void pgstat_recv_dropdb(PgStat_MsgDropdb msg, int* len);
326	static void pgstat_recv_resetcounter(PgStat_MsgResetcounter msg, int* len);
327	static void pgstat_recv_resetsharedcounter(PgStat_MsgResetsharedcounter msg, int* len);
328	static void pgstat_recv_resetsinglecounter(PgStat_MsgResetsinglecounter msg, int* len);
329	static void pgstat_recv_autovac(PgStat_MsgAutovacStart msg, int* len);
330	static void pgstat_recv_vacuum(PgStat_MsgVacuum msg, int* len);
331	static void pgstat_recv_analyze(PgStat_MsgAnalyze msg, int* len);
332	static void pgstat_recv_archiver(PgStat_MsgArchiver msg, int* len);
333	static void pgstat_recv_bgwriter(PgStat_MsgBgWriter msg, int* len);
334	static void pgstat_recv_funcstat(PgStat_MsgFuncstat msg, int* len);
335	static void pgstat_recv_funcpurge(PgStat_MsgFuncpurge msg, int* len);
336	static void pgstat_recv_recoveryconflict(PgStat_MsgRecoveryConflict msg, int* len);
337	static void pgstat_recv_deadlock(PgStat_MsgDeadlock msg, int* len);
338	static void pgstat_recv_checksum_failure(PgStat_MsgChecksumFailure msg, int* len);
339	static void pgstat_recv_tempfile(PgStat_MsgTempFile msg, int* len);
340
341	/ ------------------------------------------------------------*
342	* Public functions called from postmaster follow
343	* ------------------------------------------------------------
344	*/
345
346	/ ----------*
347	* pgstat_init() -
348	*
349	* Called from postmaster at startup. Create the resources required
350	* by the statistics collector process. If unable to do so, do not
351	* fail --- better to let the postmaster start with stats collection
352	* disabled.
353	* ----------
354	*/
355	void
356	pgstat_init(void)
357	{
358	ACCEPT_TYPE_ARG3 alen;
359	struct addrinfo *addrs = NULL,
360	*addr,
361	hints;
362	int ret;
363	fd_set rset;
364	struct timeval tv;
365	char test_byte;
366	int sel_res;
367	int tries = `0`;
368
369	#define TESTBYTEVAL ((char) 199)
370
371	/*
372	* This static assertion verifies that we didn't mess up the calculations
373	* involved in selecting maximum payload sizes for our UDP messages.
374	* Because the only consequence of overrunning PGSTAT_MAX_MSG_SIZE would
375	* be silent performance loss from fragmentation, it seems worth having a
376	* compile-time cross-check that we didn't.
377	*/
378	StaticAssertStmt(sizeof(PgStat_Msg) <= PGSTAT_MAX_MSG_SIZE,
379	"maximum stats message size exceeds PGSTAT_MAX_MSG_SIZE");
380
381	/*
382	* Create the UDP socket for sending and receiving statistic messages
383	*/
384	hints.ai_flags = AI_PASSIVE;
385	hints.ai_family = AF_UNSPEC;
386	hints.ai_socktype = SOCK_DGRAM;
387	hints.ai_protocol = `0`;
388	hints.ai_addrlen = `0`;
389	hints.ai_addr = NULL;
390	hints.ai_canonname = NULL;
391	hints.ai_next = NULL;
392	ret = pg_getaddrinfo_all("localhost", NULL, &hints, &addrs);
393	if (ret \|\| !addrs)
394	{
395	ereport(LOG,
396	(errmsg("could not resolve \"localhost\": %s",
397	gai_strerror(ret))));
398	goto startup_failed;
399	}
400
401	/*
402	* On some platforms, pg_getaddrinfo_all() may return multiple addresses
403	* only one of which will actually work (eg, both IPv6 and IPv4 addresses
404	* when kernel will reject IPv6). Worse, the failure may occur at the
405	* bind() or perhaps even connect() stage. So we must loop through the
406	* results till we find a working combination. We will generate LOG
407	* messages, but no error, for bogus combinations.
408	*/
409	for (addr = addrs; addr; addr = addr->ai_next)
410	{
411	#ifdef HAVE_UNIX_SOCKETS
412	/ Ignore AF_UNIX sockets, if any are returned. /
413	if (addr->ai_family == AF_UNIX)
414	continue;
415	#endif
416
417	if (++tries > `1`)
418	ereport(LOG,
419	(errmsg("trying another address for the statistics collector")));
420
421	/*
422	* Create the socket.
423	*/
424	if ((pgStatSock = socket(addr->ai_family, SOCK_DGRAM, `0`)) == PGINVALID_SOCKET)
425	{
426	ereport(LOG,
427	(errcode_for_socket_access(),
428	errmsg("could not create socket for statistics collector: %m")));
429	continue;
430	}
431
432	/*
433	* Bind it to a kernel assigned port on localhost and get the assigned
434	* port via getsockname().
435	*/
436	if (bind(pgStatSock, addr->ai_addr, addr->ai_addrlen) < `0`)
437	{
438	ereport(LOG,
439	(errcode_for_socket_access(),
440	errmsg("could not bind socket for statistics collector: %m")));
441	closesocket(pgStatSock);
442	pgStatSock = PGINVALID_SOCKET;
443	continue;
444	}
445
446	alen = sizeof(pgStatAddr);
447	if (getsockname(pgStatSock, (struct sockaddr *) &pgStatAddr, &alen) < `0`)
448	{
449	ereport(LOG,
450	(errcode_for_socket_access(),
451	errmsg("could not get address of socket for statistics collector: %m")));
452	closesocket(pgStatSock);
453	pgStatSock = PGINVALID_SOCKET;
454	continue;
455	}
456
457	/*
458	* Connect the socket to its own address. This saves a few cycles by
459	* not having to respecify the target address on every send. This also
460	* provides a kernel-level check that only packets from this same
461	* address will be received.
462	*/
463	if (connect(pgStatSock, (struct sockaddr *) &pgStatAddr, alen) < `0`)
464	{
465	ereport(LOG,
466	(errcode_for_socket_access(),
467	errmsg("could not connect socket for statistics collector: %m")));
468	closesocket(pgStatSock);
469	pgStatSock = PGINVALID_SOCKET;
470	continue;
471	}
472
473	/*
474	* Try to send and receive a one-byte test message on the socket. This
475	* is to catch situations where the socket can be created but will not
476	* actually pass data (for instance, because kernel packet filtering
477	* rules prevent it).
478	*/
479	test_byte = TESTBYTEVAL;
480
481	retry1:
482	if (send(pgStatSock, &test_byte, `1`, `0`) != `1`)
483	{
484	if (errno == EINTR)
485	goto retry1; / if interrupted, just retry /
486	ereport(LOG,
487	(errcode_for_socket_access(),
488	errmsg("could not send test message on socket for statistics collector: %m")));
489	closesocket(pgStatSock);
490	pgStatSock = PGINVALID_SOCKET;
491	continue;
492	}
493
494	/*
495	* There could possibly be a little delay before the message can be
496	* received. We arbitrarily allow up to half a second before deciding
497	* it's broken.
498	*/
499	for (;;) / need a loop to handle EINTR /
500	{
501	FD_ZERO(&rset);
502	FD_SET(pgStatSock, &rset);
503
504	tv.tv_sec = `0`;
505	tv.tv_usec = `500000`;
506	sel_res = select(pgStatSock + `1`, &rset, NULL, NULL, &tv);
507	if (sel_res >= `0` \|\| errno != EINTR)
508	break;
509	}
510	if (sel_res < `0`)
511	{
512	ereport(LOG,
513	(errcode_for_socket_access(),
514	errmsg("select() failed in statistics collector: %m")));
515	closesocket(pgStatSock);
516	pgStatSock = PGINVALID_SOCKET;
517	continue;
518	}
519	if (sel_res == `0` \|\| !FD_ISSET(pgStatSock, &rset))
520	{
521	/*
522	* This is the case we actually think is likely, so take pains to
523	* give a specific message for it.
524	*
525	* errno will not be set meaningfully here, so don't use it.
526	*/
527	ereport(LOG,
528	(errcode(ERRCODE_CONNECTION_FAILURE),
529	errmsg("test message did not get through on socket for statistics collector")));
530	closesocket(pgStatSock);
531	pgStatSock = PGINVALID_SOCKET;
532	continue;
533	}
534
535	test_byte++; / just make sure variable is changed /
536
537	retry2:
538	if (recv(pgStatSock, &test_byte, `1`, `0`) != `1`)
539	{
540	if (errno == EINTR)
541	goto retry2; / if interrupted, just retry /
542	ereport(LOG,
543	(errcode_for_socket_access(),
544	errmsg("could not receive test message on socket for statistics collector: %m")));
545	closesocket(pgStatSock);
546	pgStatSock = PGINVALID_SOCKET;
547	continue;
548	}
549
550	if (test_byte != TESTBYTEVAL) / strictly paranoia ... /
551	{
552	ereport(LOG,
553	(errcode(ERRCODE_INTERNAL_ERROR),
554	errmsg("incorrect test message transmission on socket for statistics collector")));
555	closesocket(pgStatSock);
556	pgStatSock = PGINVALID_SOCKET;
557	continue;
558	}
559
560	/ If we get here, we have a working socket /
561	break;
562	}
563
564	/ Did we find a working address? /
565	if (!addr \|\| pgStatSock == PGINVALID_SOCKET)
566	goto startup_failed;
567
568	/*
569	* Set the socket to non-blocking IO. This ensures that if the collector
570	* falls behind, statistics messages will be discarded; backends won't
571	* block waiting to send messages to the collector.
572	*/
573	if (!pg_set_noblock(pgStatSock))
574	{
575	ereport(LOG,
576	(errcode_for_socket_access(),
577	errmsg("could not set statistics collector socket to nonblocking mode: %m")));
578	goto startup_failed;
579	}
580
581	/*
582	* Try to ensure that the socket's receive buffer is at least
583	* PGSTAT_MIN_RCVBUF bytes, so that it won't easily overflow and lose
584	* data. Use of UDP protocol means that we are willing to lose data under
585	* heavy load, but we don't want it to happen just because of ridiculously
586	* small default buffer sizes (such as 8KB on older Windows versions).
587	*/
588	{
589	int old_rcvbuf;
590	int new_rcvbuf;
591	ACCEPT_TYPE_ARG3 rcvbufsize = sizeof(old_rcvbuf);
592
593	if (getsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
594	(char *) &old_rcvbuf, &rcvbufsize) < `0`)
595	{
596	elog(LOG, "getsockopt(SO_RCVBUF) failed: %m");
597	/ if we can't get existing size, always try to set it /
598	old_rcvbuf = `0`;
599	}
600
601	new_rcvbuf = PGSTAT_MIN_RCVBUF;
602	if (old_rcvbuf < new_rcvbuf)
603	{
604	if (setsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
605	(char ) &new_rcvbuf, sizeof*(new_rcvbuf)) < `0`)
606	elog(LOG, "setsockopt(SO_RCVBUF) failed: %m");
607	}
608	}
609
610	pg_freeaddrinfo_all(hints.ai_family, addrs);
611
612	return;
613
614	startup_failed:
615	ereport(LOG,
616	(errmsg("disabling statistics collector for lack of working socket")));
617
618	if (addrs)
619	pg_freeaddrinfo_all(hints.ai_family, addrs);
620
621	if (pgStatSock != PGINVALID_SOCKET)
622	closesocket(pgStatSock);
623	pgStatSock = PGINVALID_SOCKET;
624
625	/*
626	* Adjust GUC variables to suppress useless activity, and for debugging
627	* purposes (seeing track_counts off is a clue that we failed here). We
628	* use PGC_S_OVERRIDE because there is no point in trying to turn it back
629	* on from postgresql.conf without a restart.
630	*/
631	SetConfigOption("track_counts", "off", PGC_INTERNAL, PGC_S_OVERRIDE);
632	}
633
634	/*
635	* subroutine for pgstat_reset_all
636	*/
637	static void
638	pgstat_reset_remove_files(const char *directory)
639	{
640	DIR *dir;
641	struct dirent *entry;
642	char fname[MAXPGPATH * `2`];
643
644	dir = AllocateDir(directory);
645	while ((entry = ReadDir(dir, directory)) != NULL)
646	{
647	int nchars;
648	Oid tmp_oid;
649
650	/*
651	* Skip directory entries that don't match the file names we write.
652	* See get_dbstat_filename for the database-specific pattern.
653	*/
654	if (strncmp(entry->d_name, "global.", `7`) == `0`)
655	nchars = `7`;
656	else
657	{
658	nchars = `0`;
659	(void) sscanf(entry->d_name, "db_%u.%n",
660	&tmp_oid, &nchars);
661	if (nchars <= `0`)
662	continue;
663	/ %u allows leading whitespace, so reject that /
664	if (strchr("0123456789", entry->d_name[`3`]) == NULL)
665	continue;
666	}
667
668	if (strcmp(entry->d_name + nchars, "tmp") != `0` &&
669	strcmp(entry->d_name + nchars, "stat") != `0`)
670	continue;
671
672	snprintf(fname, sizeof(fname), "%s/%s", directory,
673	entry->d_name);
674	unlink(fname);
675	}
676	FreeDir(dir);
677	}
678
679	/*
680	* pgstat_reset_all() -
681	*
682	* Remove the stats files. This is currently used only if WAL
683	* recovery is needed after a crash.
684	*/
685	void
686	pgstat_reset_all(void)
687	{
688	pgstat_reset_remove_files(pgstat_stat_directory);
689	pgstat_reset_remove_files(PGSTAT_STAT_PERMANENT_DIRECTORY);
690	}
691
692	#ifdef EXEC_BACKEND
693
694	/*
695	* pgstat_forkexec() -
696	*
697	* Format up the arglist for, then fork and exec, statistics collector process
698	*/
699	static pid_t
700	pgstat_forkexec(void)
701	{
702	char *av[`10`];
703	int ac = `0`;
704
705	av[ac++] = "postgres";
706	av[ac++] = "--forkcol";
707	av[ac++] = NULL; / filled in by postmaster_forkexec /
708
709	av[ac] = NULL;
710	Assert(ac < lengthof(av));
711
712	return postmaster_forkexec(ac, av);
713	}
714	#endif /* EXEC_BACKEND */
715
716
717	/*
718	* pgstat_start() -
719	*
720	* Called from postmaster at startup or after an existing collector
721	* died. Attempt to fire up a fresh statistics collector.
722	*
723	* Returns PID of child process, or 0 if fail.
724	*
725	* Note: if fail, we will be called again from the postmaster main loop.
726	*/
727	int
728	pgstat_start(void)
729	{
730	time_t curtime;
731	pid_t pgStatPid;
732
733	/*
734	* Check that the socket is there, else pgstat_init failed and we can do
735	* nothing useful.
736	*/
737	if (pgStatSock == PGINVALID_SOCKET)
738	return `0`;
739
740	/*
741	* Do nothing if too soon since last collector start. This is a safety
742	* valve to protect against continuous respawn attempts if the collector
743	* is dying immediately at launch. Note that since we will be re-called
744	* from the postmaster main loop, we will get another chance later.
745	*/
746	curtime = time(NULL);
747	if ((unsigned int) (curtime - last_pgstat_start_time) <
748	(unsigned int) PGSTAT_RESTART_INTERVAL)
749	return `0`;
750	last_pgstat_start_time = curtime;
751
752	/*
753	* Okay, fork off the collector.
754	*/
755	#ifdef EXEC_BACKEND
756	switch ((pgStatPid = pgstat_forkexec()))
757	#else
758	switch ((pgStatPid = fork_process()))
759	#endif
760	{
761	case -`1`:
762	ereport(LOG,
763	(errmsg("could not fork statistics collector: %m")));
764	return `0`;
765
766	#ifndef EXEC_BACKEND
767	case `0`:
768	/ in postmaster child ... /
769	InitPostmasterChild();
770
771	/ Close the postmaster's sockets /
772	ClosePostmasterPorts(false);
773
774	/ Drop our connection to postmaster's shared memory, as well /
775	dsm_detach_all();
776	PGSharedMemoryDetach();
777
778	PgstatCollectorMain(`0`, NULL);
779	break;
780	#endif
781
782	default:
783	return (int) pgStatPid;
784	}
785
786	/ shouldn't get here /
787	return `0`;
788	}
789
790	void
791	allow_immediate_pgstat_restart(void)
792	{
793	last_pgstat_start_time = `0`;
794	}
795
796	/ ------------------------------------------------------------*
797	* Public functions used by backends follow
798	*------------------------------------------------------------
799	*/
800
801
802	/ ----------*
803	* pgstat_report_stat() -
804	*
805	* Must be called by processes that performs DML: tcop/postgres.c, logical
806	* receiver processes, SPI worker, etc. to send the so far collected
807	* per-table and function usage statistics to the collector. Note that this
808	* is called only when not within a transaction, so it is fair to use
809	* transaction stop time as an approximation of current time.
810	* ----------
811	*/
812	void
813	pgstat_report_stat(bool force)
814	{
815	/ we assume this inits to all zeroes: /
816	static const PgStat_TableCounts all_zeroes;
817	static TimestampTz last_report = `0`;
818
819	TimestampTz now;
820	PgStat_MsgTabstat regular_msg;
821	PgStat_MsgTabstat shared_msg;
822	TabStatusArray *tsa;
823	int i;
824
825	/ Don't expend a clock check if nothing to do /
826	if ((pgStatTabList == NULL \|\| pgStatTabList->tsa_used == `0`) &&
827	pgStatXactCommit == `0` && pgStatXactRollback == `0` &&
828	!have_function_stats)
829	return;
830
831	/*
832	* Don't send a message unless it's been at least PGSTAT_STAT_INTERVAL
833	* msec since we last sent one, or the caller wants to force stats out.
834	*/
835	now = GetCurrentTransactionStopTimestamp();
836	if (!force &&
837	!TimestampDifferenceExceeds(last_report, now, PGSTAT_STAT_INTERVAL))
838	return;
839	last_report = now;
840
841	/*
842	* Destroy pgStatTabHash before we start invalidating PgStat_TableEntry
843	* entries it points to. (Should we fail partway through the loop below,
844	* it's okay to have removed the hashtable already --- the only
845	* consequence is we'd get multiple entries for the same table in the
846	* pgStatTabList, and that's safe.)
847	*/
848	if (pgStatTabHash)
849	hash_destroy(pgStatTabHash);
850	pgStatTabHash = NULL;
851
852	/*
853	* Scan through the TabStatusArray struct(s) to find tables that actually
854	* have counts, and build messages to send. We have to separate shared
855	* relations from regular ones because the databaseid field in the message
856	* header has to depend on that.
857	*/
858	regular_msg.m_databaseid = MyDatabaseId;
859	shared_msg.m_databaseid = InvalidOid;
860	regular_msg.m_nentries = `0`;
861	shared_msg.m_nentries = `0`;
862
863	for (tsa = pgStatTabList; tsa != NULL; tsa = tsa->tsa_next)
864	{
865	for (i = `0`; i < tsa->tsa_used; i++)
866	{
867	PgStat_TableStatus *entry = &tsa->tsa_entries[i];
868	PgStat_MsgTabstat *this_msg;
869	PgStat_TableEntry *this_ent;
870
871	/ Shouldn't have any pending transaction-dependent counts /
872	Assert(entry->trans == NULL);
873
874	/*
875	* Ignore entries that didn't accumulate any actual counts, such
876	* as indexes that were opened by the planner but not used.
877	*/
878	if (memcmp(&entry->t_counts, &all_zeroes,
879	sizeof(PgStat_TableCounts)) == `0`)
880	continue;
881
882	/*
883	* OK, insert data into the appropriate message, and send if full.
884	*/
885	this_msg = entry->t_shared ? &shared_msg : &regular_msg;
886	this_ent = &this_msg->m_entry[this_msg->m_nentries];
887	this_ent->t_id = entry->t_id;
888	memcpy(&this_ent->t_counts, &entry->t_counts,
889	sizeof(PgStat_TableCounts));
890	if (++this_msg->m_nentries >= PGSTAT_NUM_TABENTRIES)
891	{
892	pgstat_send_tabstat(this_msg);
893	this_msg->m_nentries = `0`;
894	}
895	}
896	/ zero out TableStatus structs after use /
897	MemSet(tsa->tsa_entries, `0`,
898	tsa->tsa_used * sizeof(PgStat_TableStatus));
899	tsa->tsa_used = `0`;
900	}
901
902	/*
903	* Send partial messages. Make sure that any pending xact commit/abort
904	* gets counted, even if there are no table stats to send.
905	*/
906	if (regular_msg.m_nentries > `0` \|\|
907	pgStatXactCommit > `0` \|\| pgStatXactRollback > `0`)
908	pgstat_send_tabstat(&regular_msg);
909	if (shared_msg.m_nentries > `0`)
910	pgstat_send_tabstat(&shared_msg);
911
912	/ Now, send function statistics /
913	pgstat_send_funcstats();
914	}
915
916	/*
917	* Subroutine for pgstat_report_stat: finish and send a tabstat message
918	*/
919	static void
920	pgstat_send_tabstat(PgStat_MsgTabstat *tsmsg)
921	{
922	int n;
923	int len;
924
925	/ It's unlikely we'd get here with no socket, but maybe not impossible /
926	if (pgStatSock == PGINVALID_SOCKET)
927	return;
928
929	/*
930	* Report and reset accumulated xact commit/rollback and I/O timings
931	* whenever we send a normal tabstat message
932	*/
933	if (OidIsValid(tsmsg->m_databaseid))
934	{
935	tsmsg->m_xact_commit = pgStatXactCommit;
936	tsmsg->m_xact_rollback = pgStatXactRollback;
937	tsmsg->m_block_read_time = pgStatBlockReadTime;
938	tsmsg->m_block_write_time = pgStatBlockWriteTime;
939	pgStatXactCommit = `0`;
940	pgStatXactRollback = `0`;
941	pgStatBlockReadTime = `0`;
942	pgStatBlockWriteTime = `0`;
943	}
944	else
945	{
946	tsmsg->m_xact_commit = `0`;
947	tsmsg->m_xact_rollback = `0`;
948	tsmsg->m_block_read_time = `0`;
949	tsmsg->m_block_write_time = `0`;
950	}
951
952	n = tsmsg->m_nentries;
953	len = offsetof(PgStat_MsgTabstat, m_entry[`0`]) +
954	n * sizeof(PgStat_TableEntry);
955
956	pgstat_setheader(&tsmsg->m_hdr, PGSTAT_MTYPE_TABSTAT);
957	pgstat_send(tsmsg, len);
958	}
959
960	/*
961	* Subroutine for pgstat_report_stat: populate and send a function stat message
962	*/
963	static void
964	pgstat_send_funcstats(void)
965	{
966	/ we assume this inits to all zeroes: /
967	static const PgStat_FunctionCounts all_zeroes;
968
969	PgStat_MsgFuncstat msg;
970	PgStat_BackendFunctionEntry *entry;
971	HASH_SEQ_STATUS fstat;
972
973	if (pgStatFunctions == NULL)
974	return;
975
976	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_FUNCSTAT);
977	msg.m_databaseid = MyDatabaseId;
978	msg.m_nentries = `0`;
979
980	hash_seq_init(&fstat, pgStatFunctions);
981	while ((entry = (PgStat_BackendFunctionEntry *) hash_seq_search(&fstat)) != NULL)
982	{
983	PgStat_FunctionEntry *m_ent;
984
985	/ Skip it if no counts accumulated since last time /
986	if (memcmp(&entry->f_counts, &all_zeroes,
987	sizeof(PgStat_FunctionCounts)) == `0`)
988	continue;
989
990	/ need to convert format of time accumulators /
991	m_ent = &msg.m_entry[msg.m_nentries];
992	m_ent->f_id = entry->f_id;
993	m_ent->f_numcalls = entry->f_counts.f_numcalls;
994	m_ent->f_total_time = INSTR_TIME_GET_MICROSEC(entry->f_counts.f_total_time);
995	m_ent->f_self_time = INSTR_TIME_GET_MICROSEC(entry->f_counts.f_self_time);
996
997	if (++msg.m_nentries >= PGSTAT_NUM_FUNCENTRIES)
998	{
999	pgstat_send(&msg, offsetof(PgStat_MsgFuncstat, m_entry[`0`]) +
1000	msg.m_nentries * sizeof(PgStat_FunctionEntry));
1001	msg.m_nentries = `0`;
1002	}
1003
1004	/ reset the entry's counts /
1005	MemSet(&entry->f_counts, `0`, sizeof(PgStat_FunctionCounts));
1006	}
1007
1008	if (msg.m_nentries > `0`)
1009	pgstat_send(&msg, offsetof(PgStat_MsgFuncstat, m_entry[`0`]) +
1010	msg.m_nentries * sizeof(PgStat_FunctionEntry));
1011
1012	have_function_stats = false;
1013	}
1014
1015
1016	/ ----------*
1017	* pgstat_vacuum_stat() -
1018	*
1019	* Will tell the collector about objects he can get rid of.
1020	* ----------
1021	*/
1022	void
1023	pgstat_vacuum_stat(void)
1024	{
1025	HTAB *htab;
1026	PgStat_MsgTabpurge msg;
1027	PgStat_MsgFuncpurge f_msg;
1028	HASH_SEQ_STATUS hstat;
1029	PgStat_StatDBEntry *dbentry;
1030	PgStat_StatTabEntry *tabentry;
1031	PgStat_StatFuncEntry *funcentry;
1032	int len;
1033
1034	if (pgStatSock == PGINVALID_SOCKET)
1035	return;
1036
1037	/*
1038	* If not done for this transaction, read the statistics collector stats
1039	* file into some hash tables.
1040	*/
1041	backend_read_statsfile();
1042
1043	/*
1044	* Read pg_database and make a list of OIDs of all existing databases
1045	*/
1046	htab = pgstat_collect_oids(DatabaseRelationId, Anum_pg_database_oid);
1047
1048	/*
1049	* Search the database hash table for dead databases and tell the
1050	* collector to drop them.
1051	*/
1052	hash_seq_init(&hstat, pgStatDBHash);
1053	while ((dbentry = (PgStat_StatDBEntry *) hash_seq_search(&hstat)) != NULL)
1054	{
1055	Oid dbid = dbentry->databaseid;
1056
1057	CHECK_FOR_INTERRUPTS();
1058
1059	/ the DB entry for shared tables (with InvalidOid) is never dropped /
1060	if (OidIsValid(dbid) &&
1061	hash_search(htab, (void *) &dbid, HASH_FIND, NULL) == NULL)
1062	pgstat_drop_database(dbid);
1063	}
1064
1065	/ Clean up /
1066	hash_destroy(htab);
1067
1068	/*
1069	* Lookup our own database entry; if not found, nothing more to do.
1070	*/
1071	dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
1072	(void *) &MyDatabaseId,
1073	HASH_FIND, NULL);
1074	if (dbentry == NULL \|\| dbentry->tables == NULL)
1075	return;
1076
1077	/*
1078	* Similarly to above, make a list of all known relations in this DB.
1079	*/
1080	htab = pgstat_collect_oids(RelationRelationId, Anum_pg_class_oid);
1081
1082	/*
1083	* Initialize our messages table counter to zero
1084	*/
1085	msg.m_nentries = `0`;
1086
1087	/*
1088	* Check for all tables listed in stats hashtable if they still exist.
1089	*/
1090	hash_seq_init(&hstat, dbentry->tables);
1091	while ((tabentry = (PgStat_StatTabEntry *) hash_seq_search(&hstat)) != NULL)
1092	{
1093	Oid tabid = tabentry->tableid;
1094
1095	CHECK_FOR_INTERRUPTS();
1096
1097	if (hash_search(htab, (void *) &tabid, HASH_FIND, NULL) != NULL)
1098	continue;
1099
1100	/*
1101	* Not there, so add this table's Oid to the message
1102	*/
1103	msg.m_tableid[msg.m_nentries++] = tabid;
1104
1105	/*
1106	* If the message is full, send it out and reinitialize to empty
1107	*/
1108	if (msg.m_nentries >= PGSTAT_NUM_TABPURGE)
1109	{
1110	len = offsetof(PgStat_MsgTabpurge, m_tableid[`0`])
1111	+ msg.m_nentries * sizeof(Oid);
1112
1113	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
1114	msg.m_databaseid = MyDatabaseId;
1115	pgstat_send(&msg, len);
1116
1117	msg.m_nentries = `0`;
1118	}
1119	}
1120
1121	/*
1122	* Send the rest
1123	*/
1124	if (msg.m_nentries > `0`)
1125	{
1126	len = offsetof(PgStat_MsgTabpurge, m_tableid[`0`])
1127	+ msg.m_nentries * sizeof(Oid);
1128
1129	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
1130	msg.m_databaseid = MyDatabaseId;
1131	pgstat_send(&msg, len);
1132	}
1133
1134	/ Clean up /
1135	hash_destroy(htab);
1136
1137	/*
1138	* Now repeat the above steps for functions. However, we needn't bother
1139	* in the common case where no function stats are being collected.
1140	*/
1141	if (dbentry->functions != NULL &&
1142	hash_get_num_entries(dbentry->functions) > `0`)
1143	{
1144	htab = pgstat_collect_oids(ProcedureRelationId, Anum_pg_proc_oid);
1145
1146	pgstat_setheader(&f_msg.m_hdr, PGSTAT_MTYPE_FUNCPURGE);
1147	f_msg.m_databaseid = MyDatabaseId;
1148	f_msg.m_nentries = `0`;
1149
1150	hash_seq_init(&hstat, dbentry->functions);
1151	while ((funcentry = (PgStat_StatFuncEntry *) hash_seq_search(&hstat)) != NULL)
1152	{
1153	Oid funcid = funcentry->functionid;
1154
1155	CHECK_FOR_INTERRUPTS();
1156
1157	if (hash_search(htab, (void *) &funcid, HASH_FIND, NULL) != NULL)
1158	continue;
1159
1160	/*
1161	* Not there, so add this function's Oid to the message
1162	*/
1163	f_msg.m_functionid[f_msg.m_nentries++] = funcid;
1164
1165	/*
1166	* If the message is full, send it out and reinitialize to empty
1167	*/
1168	if (f_msg.m_nentries >= PGSTAT_NUM_FUNCPURGE)
1169	{
1170	len = offsetof(PgStat_MsgFuncpurge, m_functionid[`0`])
1171	+ f_msg.m_nentries * sizeof(Oid);
1172
1173	pgstat_send(&f_msg, len);
1174
1175	f_msg.m_nentries = `0`;
1176	}
1177	}
1178
1179	/*
1180	* Send the rest
1181	*/
1182	if (f_msg.m_nentries > `0`)
1183	{
1184	len = offsetof(PgStat_MsgFuncpurge, m_functionid[`0`])
1185	+ f_msg.m_nentries * sizeof(Oid);
1186
1187	pgstat_send(&f_msg, len);
1188	}
1189
1190	hash_destroy(htab);
1191	}
1192	}
1193
1194
1195	/ ----------*
1196	* pgstat_collect_oids() -
1197	*
1198	* Collect the OIDs of all objects listed in the specified system catalog
1199	* into a temporary hash table. Caller should hash_destroy the result
1200	* when done with it. (However, we make the table in CurrentMemoryContext
1201	* so that it will be freed properly in event of an error.)
1202	* ----------
1203	*/
1204	static HTAB *
1205	pgstat_collect_oids(Oid catalogid, AttrNumber anum_oid)
1206	{
1207	HTAB *htab;
1208	HASHCTL hash_ctl;
1209	Relation rel;
1210	TableScanDesc scan;
1211	HeapTuple tup;
1212	Snapshot snapshot;
1213
1214	memset(&hash_ctl, `0`, sizeof(hash_ctl));
1215	hash_ctl.keysize = sizeof(Oid);
1216	hash_ctl.entrysize = sizeof(Oid);
1217	hash_ctl.hcxt = CurrentMemoryContext;
1218	htab = hash_create("Temporary table of OIDs",
1219	PGSTAT_TAB_HASH_SIZE,
1220	&hash_ctl,
1221	HASH_ELEM \| HASH_BLOBS \| HASH_CONTEXT);
1222
1223	rel = table_open(catalogid, AccessShareLock);
1224	snapshot = RegisterSnapshot(GetLatestSnapshot());
1225	scan = table_beginscan(rel, snapshot, `0`, NULL);
1226	while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
1227	{
1228	Oid thisoid;
1229	bool isnull;
1230
1231	thisoid = heap_getattr(tup, anum_oid, RelationGetDescr(rel), &isnull);
1232	Assert(!isnull);
1233
1234	CHECK_FOR_INTERRUPTS();
1235
1236	(void) hash_search(htab, (void *) &thisoid, HASH_ENTER, NULL);
1237	}
1238	table_endscan(scan);
1239	UnregisterSnapshot(snapshot);
1240	table_close(rel, AccessShareLock);
1241
1242	return htab;
1243	}
1244
1245
1246	/ ----------*
1247	* pgstat_drop_database() -
1248	*
1249	* Tell the collector that we just dropped a database.
1250	* (If the message gets lost, we will still clean the dead DB eventually
1251	* via future invocations of pgstat_vacuum_stat().)
1252	* ----------
1253	*/
1254	void
1255	pgstat_drop_database(Oid databaseid)
1256	{
1257	PgStat_MsgDropdb msg;
1258
1259	if (pgStatSock == PGINVALID_SOCKET)
1260	return;
1261
1262	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DROPDB);
1263	msg.m_databaseid = databaseid;
1264	pgstat_send(&msg, sizeof(msg));
1265	}
1266
1267
1268	/ ----------*
1269	* pgstat_drop_relation() -
1270	*
1271	* Tell the collector that we just dropped a relation.
1272	* (If the message gets lost, we will still clean the dead entry eventually
1273	* via future invocations of pgstat_vacuum_stat().)
1274	*
1275	* Currently not used for lack of any good place to call it; we rely
1276	* entirely on pgstat_vacuum_stat() to clean out stats for dead rels.
1277	* ----------
1278	*/
1279	#ifdef NOT_USED
1280	void
1281	pgstat_drop_relation(Oid relid)
1282	{
1283	PgStat_MsgTabpurge msg;
1284	int len;
1285
1286	if (pgStatSock == PGINVALID_SOCKET)
1287	return;
1288
1289	msg.m_tableid[`0`] = relid;
1290	msg.m_nentries = `1`;
1291
1292	len = offsetof(PgStat_MsgTabpurge, m_tableid[`0`]) + sizeof(Oid);
1293
1294	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
1295	msg.m_databaseid = MyDatabaseId;
1296	pgstat_send(&msg, len);
1297	}
1298	#endif /* NOT_USED */
1299
1300
1301	/ ----------*
1302	* pgstat_reset_counters() -
1303	*
1304	* Tell the statistics collector to reset counters for our database.
1305	*
1306	* Permission checking for this function is managed through the normal
1307	* GRANT system.
1308	* ----------
1309	*/
1310	void
1311	pgstat_reset_counters(void)
1312	{
1313	PgStat_MsgResetcounter msg;
1314
1315	if (pgStatSock == PGINVALID_SOCKET)
1316	return;
1317
1318	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETCOUNTER);
1319	msg.m_databaseid = MyDatabaseId;
1320	pgstat_send(&msg, sizeof(msg));
1321	}
1322
1323	/ ----------*
1324	* pgstat_reset_shared_counters() -
1325	*
1326	* Tell the statistics collector to reset cluster-wide shared counters.
1327	*
1328	* Permission checking for this function is managed through the normal
1329	* GRANT system.
1330	* ----------
1331	*/
1332	void
1333	pgstat_reset_shared_counters(const char *target)
1334	{
1335	PgStat_MsgResetsharedcounter msg;
1336
1337	if (pgStatSock == PGINVALID_SOCKET)
1338	return;
1339
1340	if (strcmp(target, "archiver") == `0`)
1341	msg.m_resettarget = RESET_ARCHIVER;
1342	else if (strcmp(target, "bgwriter") == `0`)
1343	msg.m_resettarget = RESET_BGWRITER;
1344	else
1345	ereport(ERROR,
1346	(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1347	errmsg("unrecognized reset target: \"%s\"", target),
1348	errhint("Target must be \"archiver\" or \"bgwriter\".")));
1349
1350	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSHAREDCOUNTER);
1351	pgstat_send(&msg, sizeof(msg));
1352	}
1353
1354	/ ----------*
1355	* pgstat_reset_single_counter() -
1356	*
1357	* Tell the statistics collector to reset a single counter.
1358	*
1359	* Permission checking for this function is managed through the normal
1360	* GRANT system.
1361	* ----------
1362	*/
1363	void
1364	pgstat_reset_single_counter(Oid objoid, PgStat_Single_Reset_Type type)
1365	{
1366	PgStat_MsgResetsinglecounter msg;
1367
1368	if (pgStatSock == PGINVALID_SOCKET)
1369	return;
1370
1371	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSINGLECOUNTER);
1372	msg.m_databaseid = MyDatabaseId;
1373	msg.m_resettype = type;
1374	msg.m_objectid = objoid;
1375
1376	pgstat_send(&msg, sizeof(msg));
1377	}
1378
1379	/ ----------*
1380	* pgstat_report_autovac() -
1381	*
1382	* Called from autovacuum.c to report startup of an autovacuum process.
1383	* We are called before InitPostgres is done, so can't rely on MyDatabaseId;
1384	* the db OID must be passed in, instead.
1385	* ----------
1386	*/
1387	void
1388	pgstat_report_autovac(Oid dboid)
1389	{
1390	PgStat_MsgAutovacStart msg;
1391
1392	if (pgStatSock == PGINVALID_SOCKET)
1393	return;
1394
1395	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_AUTOVAC_START);
1396	msg.m_databaseid = dboid;
1397	msg.m_start_time = GetCurrentTimestamp();
1398
1399	pgstat_send(&msg, sizeof(msg));
1400	}
1401
1402
1403	/ ---------*
1404	* pgstat_report_vacuum() -
1405	*
1406	* Tell the collector about the table we just vacuumed.
1407	* ---------
1408	*/
1409	void
1410	pgstat_report_vacuum(Oid tableoid, bool shared,
1411	PgStat_Counter livetuples, PgStat_Counter deadtuples)
1412	{
1413	PgStat_MsgVacuum msg;
1414
1415	if (pgStatSock == PGINVALID_SOCKET \|\| !pgstat_track_counts)
1416	return;
1417
1418	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_VACUUM);
1419	msg.m_databaseid = shared ? InvalidOid : MyDatabaseId;
1420	msg.m_tableoid = tableoid;
1421	msg.m_autovacuum = IsAutoVacuumWorkerProcess();
1422	msg.m_vacuumtime = GetCurrentTimestamp();
1423	msg.m_live_tuples = livetuples;
1424	msg.m_dead_tuples = deadtuples;
1425	pgstat_send(&msg, sizeof(msg));
1426	}
1427
1428	/ --------*
1429	* pgstat_report_analyze() -
1430	*
1431	* Tell the collector about the table we just analyzed.
1432	*
1433	* Caller must provide new live- and dead-tuples estimates, as well as a
1434	* flag indicating whether to reset the changes_since_analyze counter.
1435	* --------
1436	*/
1437	void
1438	pgstat_report_analyze(Relation rel,
1439	PgStat_Counter livetuples, PgStat_Counter deadtuples,
1440	bool resetcounter)
1441	{
1442	PgStat_MsgAnalyze msg;
1443
1444	if (pgStatSock == PGINVALID_SOCKET \|\| !pgstat_track_counts)
1445	return;
1446
1447	/*
1448	* Unlike VACUUM, ANALYZE might be running inside a transaction that has
1449	* already inserted and/or deleted rows in the target table. ANALYZE will
1450	* have counted such rows as live or dead respectively. Because we will
1451	* report our counts of such rows at transaction end, we should subtract
1452	* off these counts from what we send to the collector now, else they'll
1453	* be double-counted after commit. (This approach also ensures that the
1454	* collector ends up with the right numbers if we abort instead of
1455	* committing.)
1456	*/
1457	if (rel->pgstat_info != NULL)
1458	{
1459	PgStat_TableXactStatus *trans;
1460
1461	for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
1462	{
1463	livetuples -= trans->tuples_inserted - trans->tuples_deleted;
1464	deadtuples -= trans->tuples_updated + trans->tuples_deleted;
1465	}
1466	/ count stuff inserted by already-aborted subxacts, too /
1467	deadtuples -= rel->pgstat_info->t_counts.t_delta_dead_tuples;
1468	/ Since ANALYZE's counts are estimates, we could have underflowed /
1469	livetuples = Max(livetuples, `0`);
1470	deadtuples = Max(deadtuples, `0`);
1471	}
1472
1473	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ANALYZE);
1474	msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
1475	msg.m_tableoid = RelationGetRelid(rel);
1476	msg.m_autovacuum = IsAutoVacuumWorkerProcess();
1477	msg.m_resetcounter = resetcounter;
1478	msg.m_analyzetime = GetCurrentTimestamp();
1479	msg.m_live_tuples = livetuples;
1480	msg.m_dead_tuples = deadtuples;
1481	pgstat_send(&msg, sizeof(msg));
1482	}
1483
1484	/ --------*
1485	* pgstat_report_recovery_conflict() -
1486	*
1487	* Tell the collector about a Hot Standby recovery conflict.
1488	* --------
1489	*/
1490	void
1491	pgstat_report_recovery_conflict(int reason)
1492	{
1493	PgStat_MsgRecoveryConflict msg;
1494
1495	if (pgStatSock == PGINVALID_SOCKET \|\| !pgstat_track_counts)
1496	return;
1497
1498	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RECOVERYCONFLICT);
1499	msg.m_databaseid = MyDatabaseId;
1500	msg.m_reason = reason;
1501	pgstat_send(&msg, sizeof(msg));
1502	}
1503
1504	/ --------*
1505	* pgstat_report_deadlock() -
1506	*
1507	* Tell the collector about a deadlock detected.
1508	* --------
1509	*/
1510	void
1511	pgstat_report_deadlock(void)
1512	{
1513	PgStat_MsgDeadlock msg;
1514
1515	if (pgStatSock == PGINVALID_SOCKET \|\| !pgstat_track_counts)
1516	return;
1517
1518	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DEADLOCK);
1519	msg.m_databaseid = MyDatabaseId;
1520	pgstat_send(&msg, sizeof(msg));
1521	}
1522
1523
1524
1525	/ --------*
1526	* pgstat_report_checksum_failures_in_db() -
1527	*
1528	* Tell the collector about one or more checksum failures.
1529	* --------
1530	*/
1531	void
1532	pgstat_report_checksum_failures_in_db(Oid dboid, int failurecount)
1533	{
1534	PgStat_MsgChecksumFailure msg;
1535
1536	if (pgStatSock == PGINVALID_SOCKET \|\| !pgstat_track_counts)
1537	return;
1538
1539	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_CHECKSUMFAILURE);
1540	msg.m_databaseid = dboid;
1541	msg.m_failurecount = failurecount;
1542	msg.m_failure_time = GetCurrentTimestamp();
1543
1544	pgstat_send(&msg, sizeof(msg));
1545	}
1546
1547	/ --------*
1548	* pgstat_report_checksum_failure() -
1549	*
1550	* Tell the collector about a checksum failure.
1551	* --------
1552	*/
1553	void
1554	pgstat_report_checksum_failure(void)
1555	{
1556	pgstat_report_checksum_failures_in_db(MyDatabaseId, `1`);
1557	}
1558
1559	/ --------*
1560	* pgstat_report_tempfile() -
1561	*
1562	* Tell the collector about a temporary file.
1563	* --------
1564	*/
1565	void
1566	pgstat_report_tempfile(size_t filesize)
1567	{
1568	PgStat_MsgTempFile msg;
1569
1570	if (pgStatSock == PGINVALID_SOCKET \|\| !pgstat_track_counts)
1571	return;
1572
1573	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TEMPFILE);
1574	msg.m_databaseid = MyDatabaseId;
1575	msg.m_filesize = filesize;
1576	pgstat_send(&msg, sizeof(msg));
1577	}
1578
1579
1580	/ ----------*
1581	* pgstat_ping() -
1582	*
1583	* Send some junk data to the collector to increase traffic.
1584	* ----------
1585	*/
1586	void
1587	pgstat_ping(void)
1588	{
1589	PgStat_MsgDummy msg;
1590
1591	if (pgStatSock == PGINVALID_SOCKET)
1592	return;
1593
1594	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DUMMY);
1595	pgstat_send(&msg, sizeof(msg));
1596	}
1597
1598	/ ----------*
1599	* pgstat_send_inquiry() -
1600	*
1601	* Notify collector that we need fresh data.
1602	* ----------
1603	*/
1604	static void
1605	pgstat_send_inquiry(TimestampTz clock_time, TimestampTz cutoff_time, Oid databaseid)
1606	{
1607	PgStat_MsgInquiry msg;
1608
1609	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_INQUIRY);
1610	msg.clock_time = clock_time;
1611	msg.cutoff_time = cutoff_time;
1612	msg.databaseid = databaseid;
1613	pgstat_send(&msg, sizeof(msg));
1614	}
1615
1616
1617	/*
1618	* Initialize function call usage data.
1619	* Called by the executor before invoking a function.
1620	*/
1621	void
1622	pgstat_init_function_usage(FunctionCallInfo fcinfo,
1623	PgStat_FunctionCallUsage *fcu)
1624	{
1625	PgStat_BackendFunctionEntry *htabent;
1626	bool found;
1627
1628	if (pgstat_track_functions <= fcinfo->flinfo->fn_stats)
1629	{
1630	/ stats not wanted /
1631	fcu->fs = NULL;
1632	return;
1633	}
1634
1635	if (!pgStatFunctions)
1636	{
1637	/ First time through - initialize function stat table /
1638	HASHCTL hash_ctl;
1639
1640	memset(&hash_ctl, `0`, sizeof(hash_ctl));
1641	hash_ctl.keysize = sizeof(Oid);
1642	hash_ctl.entrysize = sizeof(PgStat_BackendFunctionEntry);
1643	pgStatFunctions = hash_create("Function stat entries",
1644	PGSTAT_FUNCTION_HASH_SIZE,
1645	&hash_ctl,
1646	HASH_ELEM \| HASH_BLOBS);
1647	}
1648
1649	/ Get the stats entry for this function, create if necessary /
1650	htabent = hash_search(pgStatFunctions, &fcinfo->flinfo->fn_oid,
1651	HASH_ENTER, &found);
1652	if (!found)
1653	MemSet(&htabent->f_counts, `0`, sizeof(PgStat_FunctionCounts));
1654
1655	fcu->fs = &htabent->f_counts;
1656
1657	/ save stats for this function, later used to compensate for recursion /
1658	fcu->save_f_total_time = htabent->f_counts.f_total_time;
1659
1660	/ save current backend-wide total time /
1661	fcu->save_total = total_func_time;
1662
1663	/ get clock time as of function start /
1664	INSTR_TIME_SET_CURRENT(fcu->f_start);
1665	}
1666
1667	/*
1668	* find_funcstat_entry - find any existing PgStat_BackendFunctionEntry entry
1669	* for specified function
1670	*
1671	* If no entry, return NULL, don't create a new one
1672	*/
1673	PgStat_BackendFunctionEntry *
1674	find_funcstat_entry(Oid func_id)
1675	{
1676	if (pgStatFunctions == NULL)
1677	return NULL;
1678
1679	return (PgStat_BackendFunctionEntry *) hash_search(pgStatFunctions,
1680	(void *) &func_id,
1681	HASH_FIND, NULL);
1682	}
1683
1684	/*
1685	* Calculate function call usage and update stat counters.
1686	* Called by the executor after invoking a function.
1687	*
1688	* In the case of a set-returning function that runs in value-per-call mode,
1689	* we will see multiple pgstat_init_function_usage/pgstat_end_function_usage
1690	* calls for what the user considers a single call of the function. The
1691	* finalize flag should be TRUE on the last call.
1692	*/
1693	void
1694	pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
1695	{
1696	PgStat_FunctionCounts *fs = fcu->fs;
1697	instr_time f_total;
1698	instr_time f_others;
1699	instr_time f_self;
1700
1701	/ stats not wanted? /
1702	if (fs == NULL)
1703	return;
1704
1705	/ total elapsed time in this function call /
1706	INSTR_TIME_SET_CURRENT(f_total);
1707	INSTR_TIME_SUBTRACT(f_total, fcu->f_start);
1708
1709	/ self usage: elapsed minus anything already charged to other calls /
1710	f_others = total_func_time;
1711	INSTR_TIME_SUBTRACT(f_others, fcu->save_total);
1712	f_self = f_total;
1713	INSTR_TIME_SUBTRACT(f_self, f_others);
1714
1715	/ update backend-wide total time /
1716	INSTR_TIME_ADD(total_func_time, f_self);
1717
1718	/*
1719	* Compute the new f_total_time as the total elapsed time added to the
1720	* pre-call value of f_total_time. This is necessary to avoid
1721	* double-counting any time taken by recursive calls of myself. (We do
1722	* not need any similar kluge for self time, since that already excludes
1723	* any recursive calls.)
1724	*/
1725	INSTR_TIME_ADD(f_total, fcu->save_f_total_time);
1726
1727	/ update counters in function stats table /
1728	if (finalize)
1729	fs->f_numcalls++;
1730	fs->f_total_time = f_total;
1731	INSTR_TIME_ADD(fs->f_self_time, f_self);
1732
1733	/ indicate that we have something to send /
1734	have_function_stats = true;
1735	}
1736
1737
1738	/ ----------*
1739	* pgstat_initstats() -
1740	*
1741	* Initialize a relcache entry to count access statistics.
1742	* Called whenever a relation is opened.
1743	*
1744	* We assume that a relcache entry's pgstat_info field is zeroed by
1745	* relcache.c when the relcache entry is made; thereafter it is long-lived
1746	* data. We can avoid repeated searches of the TabStatus arrays when the
1747	* same relation is touched repeatedly within a transaction.
1748	* ----------
1749	*/
1750	void
1751	pgstat_initstats(Relation rel)
1752	{
1753	Oid rel_id = rel->rd_id;
1754	char relkind = rel->rd_rel->relkind;
1755
1756	/ We only count stats for things that have storage /
1757	if (!(relkind == RELKIND_RELATION \|\|
1758	relkind == RELKIND_MATVIEW \|\|
1759	relkind == RELKIND_INDEX \|\|
1760	relkind == RELKIND_TOASTVALUE \|\|
1761	relkind == RELKIND_SEQUENCE))
1762	{
1763	rel->pgstat_info = NULL;
1764	return;
1765	}
1766
1767	if (pgStatSock == PGINVALID_SOCKET \|\| !pgstat_track_counts)
1768	{
1769	/ We're not counting at all /
1770	rel->pgstat_info = NULL;
1771	return;
1772	}
1773
1774	/*
1775	* If we already set up this relation in the current transaction, nothing
1776	* to do.
1777	*/
1778	if (rel->pgstat_info != NULL &&
1779	rel->pgstat_info->t_id == rel_id)
1780	return;
1781
1782	/ Else find or make the PgStat_TableStatus entry, and update link /
1783	rel->pgstat_info = get_tabstat_entry(rel_id, rel->rd_rel->relisshared);
1784	}
1785
1786	/*
1787	* get_tabstat_entry - find or create a PgStat_TableStatus entry for rel
1788	*/
1789	static PgStat_TableStatus *
1790	get_tabstat_entry(Oid rel_id, bool isshared)
1791	{
1792	TabStatHashEntry *hash_entry;
1793	PgStat_TableStatus *entry;
1794	TabStatusArray *tsa;
1795	bool found;
1796
1797	/*
1798	* Create hash table if we don't have it already.
1799	*/
1800	if (pgStatTabHash == NULL)
1801	{
1802	HASHCTL ctl;
1803
1804	memset(&ctl, `0`, sizeof(ctl));
1805	ctl.keysize = sizeof(Oid);
1806	ctl.entrysize = sizeof(TabStatHashEntry);
1807
1808	pgStatTabHash = hash_create("pgstat TabStatusArray lookup hash table",
1809	TABSTAT_QUANTUM,
1810	&ctl,
1811	HASH_ELEM \| HASH_BLOBS);
1812	}
1813
1814	/*
1815	* Find an entry or create a new one.
1816	*/
1817	hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_ENTER, &found);
1818	if (!found)
1819	{
1820	/ initialize new entry with null pointer /
1821	hash_entry->tsa_entry = NULL;
1822	}
1823
1824	/*
1825	* If entry is already valid, we're done.
1826	*/
1827	if (hash_entry->tsa_entry)
1828	return hash_entry->tsa_entry;
1829
1830	/*
1831	* Locate the first pgStatTabList entry with free space, making a new list
1832	* entry if needed. Note that we could get an OOM failure here, but if so
1833	* we have left the hashtable and the list in a consistent state.
1834	*/
1835	if (pgStatTabList == NULL)
1836	{
1837	/ Set up first pgStatTabList entry /
1838	pgStatTabList = (TabStatusArray *)
1839	MemoryContextAllocZero(TopMemoryContext,
1840	sizeof(TabStatusArray));
1841	}
1842
1843	tsa = pgStatTabList;
1844	while (tsa->tsa_used >= TABSTAT_QUANTUM)
1845	{
1846	if (tsa->tsa_next == NULL)
1847	tsa->tsa_next = (TabStatusArray *)
1848	MemoryContextAllocZero(TopMemoryContext,
1849	sizeof(TabStatusArray));
1850	tsa = tsa->tsa_next;
1851	}
1852
1853	/*
1854	* Allocate a PgStat_TableStatus entry within this list entry. We assume
1855	* the entry was already zeroed, either at creation or after last use.
1856	*/
1857	entry = &tsa->tsa_entries[tsa->tsa_used++];
1858	entry->t_id = rel_id;
1859	entry->t_shared = isshared;
1860
1861	/*
1862	* Now we can fill the entry in pgStatTabHash.
1863	*/
1864	hash_entry->tsa_entry = entry;
1865
1866	return entry;
1867	}
1868
1869	/*
1870	* find_tabstat_entry - find any existing PgStat_TableStatus entry for rel
1871	*
1872	* If no entry, return NULL, don't create a new one
1873	*
1874	* Note: if we got an error in the most recent execution of pgstat_report_stat,
1875	* it's possible that an entry exists but there's no hashtable entry for it.
1876	* That's okay, we'll treat this case as "doesn't exist".
1877	*/
1878	PgStat_TableStatus *
1879	find_tabstat_entry(Oid rel_id)
1880	{
1881	TabStatHashEntry *hash_entry;
1882
1883	/ If hashtable doesn't exist, there are no entries at all /
1884	if (!pgStatTabHash)
1885	return NULL;
1886
1887	hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_FIND, NULL);
1888	if (!hash_entry)
1889	return NULL;
1890
1891	/ Note that this step could also return NULL, but that's correct /
1892	return hash_entry->tsa_entry;
1893	}
1894
1895	/*
1896	* get_tabstat_stack_level - add a new (sub)transaction stack entry if needed
1897	*/
1898	static PgStat_SubXactStatus *
1899	get_tabstat_stack_level(int nest_level)
1900	{
1901	PgStat_SubXactStatus *xact_state;
1902
1903	xact_state = pgStatXactStack;
1904	if (xact_state == NULL \|\| xact_state->nest_level != nest_level)
1905	{
1906	xact_state = (PgStat_SubXactStatus *)
1907	MemoryContextAlloc(TopTransactionContext,
1908	sizeof(PgStat_SubXactStatus));
1909	xact_state->nest_level = nest_level;
1910	xact_state->prev = pgStatXactStack;
1911	xact_state->first = NULL;
1912	pgStatXactStack = xact_state;
1913	}
1914	return xact_state;
1915	}
1916
1917	/*
1918	* add_tabstat_xact_level - add a new (sub)transaction state record
1919	*/
1920	static void
1921	add_tabstat_xact_level(PgStat_TableStatus pgstat_info, int* nest_level)
1922	{
1923	PgStat_SubXactStatus *xact_state;
1924	PgStat_TableXactStatus *trans;
1925
1926	/*
1927	* If this is the first rel to be modified at the current nest level, we
1928	* first have to push a transaction stack entry.
1929	*/
1930	xact_state = get_tabstat_stack_level(nest_level);
1931
1932	/ Now make a per-table stack entry /
1933	trans = (PgStat_TableXactStatus *)
1934	MemoryContextAllocZero(TopTransactionContext,
1935	sizeof(PgStat_TableXactStatus));
1936	trans->nest_level = nest_level;
1937	trans->upper = pgstat_info->trans;
1938	trans->parent = pgstat_info;
1939	trans->next = xact_state->first;
1940	xact_state->first = trans;
1941	pgstat_info->trans = trans;
1942	}
1943
1944	/*
1945	* pgstat_count_heap_insert - count a tuple insertion of n tuples
1946	*/
1947	void
1948	pgstat_count_heap_insert(Relation rel, PgStat_Counter n)
1949	{
1950	PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1951
1952	if (pgstat_info != NULL)
1953	{
1954	/ We have to log the effect at the proper transactional level /
1955	int nest_level = GetCurrentTransactionNestLevel();
1956
1957	if (pgstat_info->trans == NULL \|\|
1958	pgstat_info->trans->nest_level != nest_level)
1959	add_tabstat_xact_level(pgstat_info, nest_level);
1960
1961	pgstat_info->trans->tuples_inserted += n;
1962	}
1963	}
1964
1965	/*
1966	* pgstat_count_heap_update - count a tuple update
1967	*/
1968	void
1969	pgstat_count_heap_update(Relation rel, bool hot)
1970	{
1971	PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1972
1973	if (pgstat_info != NULL)
1974	{
1975	/ We have to log the effect at the proper transactional level /
1976	int nest_level = GetCurrentTransactionNestLevel();
1977
1978	if (pgstat_info->trans == NULL \|\|
1979	pgstat_info->trans->nest_level != nest_level)
1980	add_tabstat_xact_level(pgstat_info, nest_level);
1981
1982	pgstat_info->trans->tuples_updated++;
1983
1984	/ t_tuples_hot_updated is nontransactional, so just advance it /
1985	if (hot)
1986	pgstat_info->t_counts.t_tuples_hot_updated++;
1987	}
1988	}
1989
1990	/*
1991	* pgstat_count_heap_delete - count a tuple deletion
1992	*/
1993	void
1994	pgstat_count_heap_delete(Relation rel)
1995	{
1996	PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1997
1998	if (pgstat_info != NULL)
1999	{
2000	/ We have to log the effect at the proper transactional level /
2001	int nest_level = GetCurrentTransactionNestLevel();
2002
2003	if (pgstat_info->trans == NULL \|\|
2004	pgstat_info->trans->nest_level != nest_level)
2005	add_tabstat_xact_level(pgstat_info, nest_level);
2006
2007	pgstat_info->trans->tuples_deleted++;
2008	}
2009	}
2010
2011	/*
2012	* pgstat_truncate_save_counters
2013	*
2014	* Whenever a table is truncated, we save its i/u/d counters so that they can
2015	* be cleared, and if the (sub)xact that executed the truncate later aborts,
2016	* the counters can be restored to the saved (pre-truncate) values. Note we do
2017	* this on the first truncate in any particular subxact level only.
2018	*/
2019	static void
2020	pgstat_truncate_save_counters(PgStat_TableXactStatus *trans)
2021	{
2022	if (!trans->truncated)
2023	{
2024	trans->inserted_pre_trunc = trans->tuples_inserted;
2025	trans->updated_pre_trunc = trans->tuples_updated;
2026	trans->deleted_pre_trunc = trans->tuples_deleted;
2027	trans->truncated = true;
2028	}
2029	}
2030
2031	/*
2032	* pgstat_truncate_restore_counters - restore counters when a truncate aborts
2033	*/
2034	static void
2035	pgstat_truncate_restore_counters(PgStat_TableXactStatus *trans)
2036	{
2037	if (trans->truncated)
2038	{
2039	trans->tuples_inserted = trans->inserted_pre_trunc;
2040	trans->tuples_updated = trans->updated_pre_trunc;
2041	trans->tuples_deleted = trans->deleted_pre_trunc;
2042	}
2043	}
2044
2045	/*
2046	* pgstat_count_truncate - update tuple counters due to truncate
2047	*/
2048	void
2049	pgstat_count_truncate(Relation rel)
2050	{
2051	PgStat_TableStatus *pgstat_info = rel->pgstat_info;
2052
2053	if (pgstat_info != NULL)
2054	{
2055	/ We have to log the effect at the proper transactional level /
2056	int nest_level = GetCurrentTransactionNestLevel();
2057
2058	if (pgstat_info->trans == NULL \|\|
2059	pgstat_info->trans->nest_level != nest_level)
2060	add_tabstat_xact_level(pgstat_info, nest_level);
2061
2062	pgstat_truncate_save_counters(pgstat_info->trans);
2063	pgstat_info->trans->tuples_inserted = `0`;
2064	pgstat_info->trans->tuples_updated = `0`;
2065	pgstat_info->trans->tuples_deleted = `0`;
2066	}
2067	}
2068
2069	/*
2070	* pgstat_update_heap_dead_tuples - update dead-tuples count
2071	*
2072	* The semantics of this are that we are reporting the nontransactional
2073	* recovery of "delta" dead tuples; so t_delta_dead_tuples decreases
2074	* rather than increasing, and the change goes straight into the per-table
2075	* counter, not into transactional state.
2076	*/
2077	void
2078	pgstat_update_heap_dead_tuples(Relation rel, int delta)
2079	{
2080	PgStat_TableStatus *pgstat_info = rel->pgstat_info;
2081
2082	if (pgstat_info != NULL)
2083	pgstat_info->t_counts.t_delta_dead_tuples -= delta;
2084	}
2085
2086
2087	/ ----------*
2088	* AtEOXact_PgStat
2089	*
2090	* Called from access/transam/xact.c at top-level transaction commit/abort.
2091	* ----------
2092	*/
2093	void
2094	AtEOXact_PgStat(bool isCommit, bool parallel)
2095	{
2096	PgStat_SubXactStatus *xact_state;
2097
2098	/ Don't count parallel worker transaction stats /
2099	if (!parallel)
2100	{
2101	/*
2102	* Count transaction commit or abort. (We use counters, not just
2103	* bools, in case the reporting message isn't sent right away.)
2104	*/
2105	if (isCommit)
2106	pgStatXactCommit++;
2107	else
2108	pgStatXactRollback++;
2109	}
2110
2111	/*
2112	* Transfer transactional insert/update counts into the base tabstat
2113	* entries. We don't bother to free any of the transactional state, since
2114	* it's all in TopTransactionContext and will go away anyway.
2115	*/
2116	xact_state = pgStatXactStack;
2117	if (xact_state != NULL)
2118	{
2119	PgStat_TableXactStatus *trans;
2120
2121	Assert(xact_state->nest_level == `1`);
2122	Assert(xact_state->prev == NULL);
2123	for (trans = xact_state->first; trans != NULL; trans = trans->next)
2124	{
2125	PgStat_TableStatus *tabstat;
2126
2127	Assert(trans->nest_level == `1`);
2128	Assert(trans->upper == NULL);
2129	tabstat = trans->parent;
2130	Assert(tabstat->trans == trans);
2131	/ restore pre-truncate stats (if any) in case of aborted xact /
2132	if (!isCommit)
2133	pgstat_truncate_restore_counters(trans);
2134	/ count attempted actions regardless of commit/abort /
2135	tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
2136	tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
2137	tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
2138	if (isCommit)
2139	{
2140	tabstat->t_counts.t_truncated = trans->truncated;
2141	if (trans->truncated)
2142	{
2143	/ forget live/dead stats seen by backend thus far /
2144	tabstat->t_counts.t_delta_live_tuples = `0`;
2145	tabstat->t_counts.t_delta_dead_tuples = `0`;
2146	}
2147	/ insert adds a live tuple, delete removes one /
2148	tabstat->t_counts.t_delta_live_tuples +=
2149	trans->tuples_inserted - trans->tuples_deleted;
2150	/ update and delete each create a dead tuple /
2151	tabstat->t_counts.t_delta_dead_tuples +=
2152	trans->tuples_updated + trans->tuples_deleted;
2153	/ insert, update, delete each count as one change event /
2154	tabstat->t_counts.t_changed_tuples +=
2155	trans->tuples_inserted + trans->tuples_updated +
2156	trans->tuples_deleted;
2157	}
2158	else
2159	{
2160	/ inserted tuples are dead, deleted tuples are unaffected /
2161	tabstat->t_counts.t_delta_dead_tuples +=
2162	trans->tuples_inserted + trans->tuples_updated;
2163	/ an aborted xact generates no changed_tuple events /
2164	}
2165	tabstat->trans = NULL;
2166	}
2167	}
2168	pgStatXactStack = NULL;
2169
2170	/ Make sure any stats snapshot is thrown away /
2171	pgstat_clear_snapshot();
2172	}
2173
2174	/ ----------*
2175	* AtEOSubXact_PgStat
2176	*
2177	* Called from access/transam/xact.c at subtransaction commit/abort.
2178	* ----------
2179	*/
2180	void
2181	AtEOSubXact_PgStat(bool isCommit, int nestDepth)
2182	{
2183	PgStat_SubXactStatus *xact_state;
2184
2185	/*
2186	* Transfer transactional insert/update counts into the next higher
2187	* subtransaction state.
2188	*/
2189	xact_state = pgStatXactStack;
2190	if (xact_state != NULL &&
2191	xact_state->nest_level >= nestDepth)
2192	{
2193	PgStat_TableXactStatus *trans;
2194	PgStat_TableXactStatus *next_trans;
2195
2196	/ delink xact_state from stack immediately to simplify reuse case /
2197	pgStatXactStack = xact_state->prev;
2198
2199	for (trans = xact_state->first; trans != NULL; trans = next_trans)
2200	{
2201	PgStat_TableStatus *tabstat;
2202
2203	next_trans = trans->next;
2204	Assert(trans->nest_level == nestDepth);
2205	tabstat = trans->parent;
2206	Assert(tabstat->trans == trans);
2207	if (isCommit)
2208	{
2209	if (trans->upper && trans->upper->nest_level == nestDepth - `1`)
2210	{
2211	if (trans->truncated)
2212	{
2213	/ propagate the truncate status one level up /
2214	pgstat_truncate_save_counters(trans->upper);
2215	/ replace upper xact stats with ours /
2216	trans->upper->tuples_inserted = trans->tuples_inserted;
2217	trans->upper->tuples_updated = trans->tuples_updated;
2218	trans->upper->tuples_deleted = trans->tuples_deleted;
2219	}
2220	else
2221	{
2222	trans->upper->tuples_inserted += trans->tuples_inserted;
2223	trans->upper->tuples_updated += trans->tuples_updated;
2224	trans->upper->tuples_deleted += trans->tuples_deleted;
2225	}
2226	tabstat->trans = trans->upper;
2227	pfree(trans);
2228	}
2229	else
2230	{
2231	/*
2232	* When there isn't an immediate parent state, we can just
2233	* reuse the record instead of going through a
2234	* palloc/pfree pushup (this works since it's all in
2235	* TopTransactionContext anyway). We have to re-link it
2236	* into the parent level, though, and that might mean
2237	* pushing a new entry into the pgStatXactStack.
2238	*/
2239	PgStat_SubXactStatus *upper_xact_state;
2240
2241	upper_xact_state = get_tabstat_stack_level(nestDepth - `1`);
2242	trans->next = upper_xact_state->first;
2243	upper_xact_state->first = trans;
2244	trans->nest_level = nestDepth - `1`;
2245	}
2246	}
2247	else
2248	{
2249	/*
2250	* On abort, update top-level tabstat counts, then forget the
2251	* subtransaction
2252	*/
2253
2254	/ first restore values obliterated by truncate /
2255	pgstat_truncate_restore_counters(trans);
2256	/ count attempted actions regardless of commit/abort /
2257	tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
2258	tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
2259	tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
2260	/ inserted tuples are dead, deleted tuples are unaffected /
2261	tabstat->t_counts.t_delta_dead_tuples +=
2262	trans->tuples_inserted + trans->tuples_updated;
2263	tabstat->trans = trans->upper;
2264	pfree(trans);
2265	}
2266	}
2267	pfree(xact_state);
2268	}
2269	}
2270
2271
2272	/*
2273	* AtPrepare_PgStat
2274	* Save the transactional stats state at 2PC transaction prepare.
2275	*
2276	* In this phase we just generate 2PC records for all the pending
2277	* transaction-dependent stats work.
2278	*/
2279	void
2280	AtPrepare_PgStat(void)
2281	{
2282	PgStat_SubXactStatus *xact_state;
2283
2284	xact_state = pgStatXactStack;
2285	if (xact_state != NULL)
2286	{
2287	PgStat_TableXactStatus *trans;
2288
2289	Assert(xact_state->nest_level == `1`);
2290	Assert(xact_state->prev == NULL);
2291	for (trans = xact_state->first; trans != NULL; trans = trans->next)
2292	{
2293	PgStat_TableStatus *tabstat;
2294	TwoPhasePgStatRecord record;
2295
2296	Assert(trans->nest_level == `1`);
2297	Assert(trans->upper == NULL);
2298	tabstat = trans->parent;
2299	Assert(tabstat->trans == trans);
2300
2301	record.tuples_inserted = trans->tuples_inserted;
2302	record.tuples_updated = trans->tuples_updated;
2303	record.tuples_deleted = trans->tuples_deleted;
2304	record.inserted_pre_trunc = trans->inserted_pre_trunc;
2305	record.updated_pre_trunc = trans->updated_pre_trunc;
2306	record.deleted_pre_trunc = trans->deleted_pre_trunc;
2307	record.t_id = tabstat->t_id;
2308	record.t_shared = tabstat->t_shared;
2309	record.t_truncated = trans->truncated;
2310
2311	RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, `0`,
2312	&record, sizeof(TwoPhasePgStatRecord));
2313	}
2314	}
2315	}
2316
2317	/*
2318	* PostPrepare_PgStat
2319	* Clean up after successful PREPARE.
2320	*
2321	* All we need do here is unlink the transaction stats state from the
2322	* nontransactional state. The nontransactional action counts will be
2323	* reported to the stats collector immediately, while the effects on live
2324	* and dead tuple counts are preserved in the 2PC state file.
2325	*
2326	* Note: AtEOXact_PgStat is not called during PREPARE.
2327	*/
2328	void
2329	PostPrepare_PgStat(void)
2330	{
2331	PgStat_SubXactStatus *xact_state;
2332
2333	/*
2334	* We don't bother to free any of the transactional state, since it's all
2335	* in TopTransactionContext and will go away anyway.
2336	*/
2337	xact_state = pgStatXactStack;
2338	if (xact_state != NULL)
2339	{
2340	PgStat_TableXactStatus *trans;
2341
2342	for (trans = xact_state->first; trans != NULL; trans = trans->next)
2343	{
2344	PgStat_TableStatus *tabstat;
2345
2346	tabstat = trans->parent;
2347	tabstat->trans = NULL;
2348	}
2349	}
2350	pgStatXactStack = NULL;
2351
2352	/ Make sure any stats snapshot is thrown away /
2353	pgstat_clear_snapshot();
2354	}
2355
2356	/*
2357	* 2PC processing routine for COMMIT PREPARED case.
2358	*
2359	* Load the saved counts into our local pgstats state.
2360	*/
2361	void
2362	pgstat_twophase_postcommit(TransactionId xid, uint16 info,
2363	void *recdata, uint32 len)
2364	{
2365	TwoPhasePgStatRecord rec = (TwoPhasePgStatRecord ) recdata;
2366	PgStat_TableStatus *pgstat_info;
2367
2368	/ Find or create a tabstat entry for the rel /
2369	pgstat_info = get_tabstat_entry(rec->t_id, rec->t_shared);
2370
2371	/ Same math as in AtEOXact_PgStat, commit case /
2372	pgstat_info->t_counts.t_tuples_inserted += rec->tuples_inserted;
2373	pgstat_info->t_counts.t_tuples_updated += rec->tuples_updated;
2374	pgstat_info->t_counts.t_tuples_deleted += rec->tuples_deleted;
2375	pgstat_info->t_counts.t_truncated = rec->t_truncated;
2376	if (rec->t_truncated)
2377	{
2378	/ forget live/dead stats seen by backend thus far /
2379	pgstat_info->t_counts.t_delta_live_tuples = `0`;
2380	pgstat_info->t_counts.t_delta_dead_tuples = `0`;
2381	}
2382	pgstat_info->t_counts.t_delta_live_tuples +=
2383	rec->tuples_inserted - rec->tuples_deleted;
2384	pgstat_info->t_counts.t_delta_dead_tuples +=
2385	rec->tuples_updated + rec->tuples_deleted;
2386	pgstat_info->t_counts.t_changed_tuples +=
2387	rec->tuples_inserted + rec->tuples_updated +
2388	rec->tuples_deleted;
2389	}
2390
2391	/*
2392	* 2PC processing routine for ROLLBACK PREPARED case.
2393	*
2394	* Load the saved counts into our local pgstats state, but treat them
2395	* as aborted.
2396	*/
2397	void
2398	pgstat_twophase_postabort(TransactionId xid, uint16 info,
2399	void *recdata, uint32 len)
2400	{
2401	TwoPhasePgStatRecord rec = (TwoPhasePgStatRecord ) recdata;
2402	PgStat_TableStatus *pgstat_info;
2403
2404	/ Find or create a tabstat entry for the rel /
2405	pgstat_info = get_tabstat_entry(rec->t_id, rec->t_shared);
2406
2407	/ Same math as in AtEOXact_PgStat, abort case /
2408	if (rec->t_truncated)
2409	{
2410	rec->tuples_inserted = rec->inserted_pre_trunc;
2411	rec->tuples_updated = rec->updated_pre_trunc;
2412	rec->tuples_deleted = rec->deleted_pre_trunc;
2413	}
2414	pgstat_info->t_counts.t_tuples_inserted += rec->tuples_inserted;
2415	pgstat_info->t_counts.t_tuples_updated += rec->tuples_updated;
2416	pgstat_info->t_counts.t_tuples_deleted += rec->tuples_deleted;
2417	pgstat_info->t_counts.t_delta_dead_tuples +=
2418	rec->tuples_inserted + rec->tuples_updated;
2419	}
2420
2421
2422	/ ----------*
2423	* pgstat_fetch_stat_dbentry() -
2424	*
2425	* Support function for the SQL-callable pgstat* functions. Returns
2426	* the collected statistics for one database or NULL. NULL doesn't mean
2427	* that the database doesn't exist, it is just not yet known by the
2428	* collector, so the caller is better off to report ZERO instead.
2429	* ----------
2430	*/
2431	PgStat_StatDBEntry *
2432	pgstat_fetch_stat_dbentry(Oid dbid)
2433	{
2434	/*
2435	* If not done for this transaction, read the statistics collector stats
2436	* file into some hash tables.
2437	*/
2438	backend_read_statsfile();
2439
2440	/*
2441	* Lookup the requested database; return NULL if not found
2442	*/
2443	return (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
2444	(void *) &dbid,
2445	HASH_FIND, NULL);
2446	}
2447
2448
2449	/ ----------*
2450	* pgstat_fetch_stat_tabentry() -
2451	*
2452	* Support function for the SQL-callable pgstat* functions. Returns
2453	* the collected statistics for one table or NULL. NULL doesn't mean
2454	* that the table doesn't exist, it is just not yet known by the
2455	* collector, so the caller is better off to report ZERO instead.
2456	* ----------
2457	*/
2458	PgStat_StatTabEntry *
2459	pgstat_fetch_stat_tabentry(Oid relid)
2460	{
2461	Oid dbid;
2462	PgStat_StatDBEntry *dbentry;
2463	PgStat_StatTabEntry *tabentry;
2464
2465	/*
2466	* If not done for this transaction, read the statistics collector stats
2467	* file into some hash tables.
2468	*/
2469	backend_read_statsfile();
2470
2471	/*
2472	* Lookup our database, then look in its table hash table.
2473	*/
2474	dbid = MyDatabaseId;
2475	dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
2476	(void *) &dbid,
2477	HASH_FIND, NULL);
2478	if (dbentry != NULL && dbentry->tables != NULL)
2479	{
2480	tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
2481	(void *) &relid,
2482	HASH_FIND, NULL);
2483	if (tabentry)
2484	return tabentry;
2485	}
2486
2487	/*
2488	* If we didn't find it, maybe it's a shared table.
2489	*/
2490	dbid = InvalidOid;
2491	dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
2492	(void *) &dbid,
2493	HASH_FIND, NULL);
2494	if (dbentry != NULL && dbentry->tables != NULL)
2495	{
2496	tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
2497	(void *) &relid,
2498	HASH_FIND, NULL);
2499	if (tabentry)
2500	return tabentry;
2501	}
2502
2503	return NULL;
2504	}
2505
2506
2507	/ ----------*
2508	* pgstat_fetch_stat_funcentry() -
2509	*
2510	* Support function for the SQL-callable pgstat* functions. Returns
2511	* the collected statistics for one function or NULL.
2512	* ----------
2513	*/
2514	PgStat_StatFuncEntry *
2515	pgstat_fetch_stat_funcentry(Oid func_id)
2516	{
2517	PgStat_StatDBEntry *dbentry;
2518	PgStat_StatFuncEntry *funcentry = NULL;
2519
2520	/ load the stats file if needed /
2521	backend_read_statsfile();
2522
2523	/ Lookup our database, then find the requested function. /
2524	dbentry = pgstat_fetch_stat_dbentry(MyDatabaseId);
2525	if (dbentry != NULL && dbentry->functions != NULL)
2526	{
2527	funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,
2528	(void *) &func_id,
2529	HASH_FIND, NULL);
2530	}
2531
2532	return funcentry;
2533	}
2534
2535
2536	/ ----------*
2537	* pgstat_fetch_stat_beentry() -
2538	*
2539	* Support function for the SQL-callable pgstat* functions. Returns
2540	* our local copy of the current-activity entry for one backend.
2541	*
2542	* NB: caller is responsible for a check if the user is permitted to see
2543	* this info (especially the querystring).
2544	* ----------
2545	*/
2546	PgBackendStatus *
2547	pgstat_fetch_stat_beentry(int beid)
2548	{
2549	pgstat_read_current_status();
2550
2551	if (beid < `1` \|\| beid > localNumBackends)
2552	return NULL;
2553
2554	return &localBackendStatusTable[beid - `1`].backendStatus;
2555	}
2556
2557
2558	/ ----------*
2559	* pgstat_fetch_stat_local_beentry() -
2560	*
2561	* Like pgstat_fetch_stat_beentry() but with locally computed additions (like
2562	* xid and xmin values of the backend)
2563	*
2564	* NB: caller is responsible for a check if the user is permitted to see
2565	* this info (especially the querystring).
2566	* ----------
2567	*/
2568	LocalPgBackendStatus *
2569	pgstat_fetch_stat_local_beentry(int beid)
2570	{
2571	pgstat_read_current_status();
2572
2573	if (beid < `1` \|\| beid > localNumBackends)
2574	return NULL;
2575
2576	return &localBackendStatusTable[beid - `1`];
2577	}
2578
2579
2580	/ ----------*
2581	* pgstat_fetch_stat_numbackends() -
2582	*
2583	* Support function for the SQL-callable pgstat* functions. Returns
2584	* the maximum current backend id.
2585	* ----------
2586	*/
2587	int
2588	pgstat_fetch_stat_numbackends(void)
2589	{
2590	pgstat_read_current_status();
2591
2592	return localNumBackends;
2593	}
2594
2595	/*
2596	* ---------
2597	* pgstat_fetch_stat_archiver() -
2598	*
2599	* Support function for the SQL-callable pgstat* functions. Returns
2600	* a pointer to the archiver statistics struct.
2601	* ---------
2602	*/
2603	PgStat_ArchiverStats *
2604	pgstat_fetch_stat_archiver(void)
2605	{
2606	backend_read_statsfile();
2607
2608	return &archiverStats;
2609	}
2610
2611
2612	/*
2613	* ---------
2614	* pgstat_fetch_global() -
2615	*
2616	* Support function for the SQL-callable pgstat* functions. Returns
2617	* a pointer to the global statistics struct.
2618	* ---------
2619	*/
2620	PgStat_GlobalStats *
2621	pgstat_fetch_global(void)
2622	{
2623	backend_read_statsfile();
2624
2625	return &globalStats;
2626	}
2627
2628
2629	/ ------------------------------------------------------------*
2630	* Functions for management of the shared-memory PgBackendStatus array
2631	* ------------------------------------------------------------
2632	*/
2633
2634	static PgBackendStatus *BackendStatusArray = NULL;
2635	static PgBackendStatus *MyBEEntry = NULL;
2636	static char *BackendAppnameBuffer = NULL;
2637	static char *BackendClientHostnameBuffer = NULL;
2638	static char *BackendActivityBuffer = NULL;
2639	static Size BackendActivityBufferSize = `0`;
2640	#ifdef USE_SSL
2641	static PgBackendSSLStatus *BackendSslStatusBuffer = NULL;
2642	#endif
2643	#ifdef ENABLE_GSS
2644	static PgBackendGSSStatus *BackendGssStatusBuffer = NULL;
2645	#endif
2646
2647
2648	/*
2649	* Report shared-memory space needed by CreateSharedBackendStatus.
2650	*/
2651	Size
2652	BackendStatusShmemSize(void)
2653	{
2654	Size size;
2655
2656	/ BackendStatusArray: /
2657	size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2658	/ BackendAppnameBuffer: /
2659	size = add_size(size,
2660	mul_size(NAMEDATALEN, NumBackendStatSlots));
2661	/ BackendClientHostnameBuffer: /
2662	size = add_size(size,
2663	mul_size(NAMEDATALEN, NumBackendStatSlots));
2664	/ BackendActivityBuffer: /
2665	size = add_size(size,
2666	mul_size(pgstat_track_activity_query_size, NumBackendStatSlots));
2667	#ifdef USE_SSL
2668	/ BackendSslStatusBuffer: /
2669	size = add_size(size,
2670	mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots));
2671	#endif
2672	return size;
2673	}
2674
2675	/*
2676	* Initialize the shared status array and several string buffers
2677	* during postmaster startup.
2678	*/
2679	void
2680	CreateSharedBackendStatus(void)
2681	{
2682	Size size;
2683	bool found;
2684	int i;
2685	char *buffer;
2686
2687	/ Create or attach to the shared array /
2688	size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2689	BackendStatusArray = (PgBackendStatus *)
2690	ShmemInitStruct("Backend Status Array", size, &found);
2691
2692	if (!found)
2693	{
2694	/*
2695	* We're the first - initialize.
2696	*/
2697	MemSet(BackendStatusArray, `0`, size);
2698	}
2699
2700	/ Create or attach to the shared appname buffer /
2701	size = mul_size(NAMEDATALEN, NumBackendStatSlots);
2702	BackendAppnameBuffer = (char *)
2703	ShmemInitStruct("Backend Application Name Buffer", size, &found);
2704
2705	if (!found)
2706	{
2707	MemSet(BackendAppnameBuffer, `0`, size);
2708
2709	/ Initialize st_appname pointers. /
2710	buffer = BackendAppnameBuffer;
2711	for (i = `0`; i < NumBackendStatSlots; i++)
2712	{
2713	BackendStatusArray[i].st_appname = buffer;
2714	buffer += NAMEDATALEN;
2715	}
2716	}
2717
2718	/ Create or attach to the shared client hostname buffer /
2719	size = mul_size(NAMEDATALEN, NumBackendStatSlots);
2720	BackendClientHostnameBuffer = (char *)
2721	ShmemInitStruct("Backend Client Host Name Buffer", size, &found);
2722
2723	if (!found)
2724	{
2725	MemSet(BackendClientHostnameBuffer, `0`, size);
2726
2727	/ Initialize st_clienthostname pointers. /
2728	buffer = BackendClientHostnameBuffer;
2729	for (i = `0`; i < NumBackendStatSlots; i++)
2730	{
2731	BackendStatusArray[i].st_clienthostname = buffer;
2732	buffer += NAMEDATALEN;
2733	}
2734	}
2735
2736	/ Create or attach to the shared activity buffer /
2737	BackendActivityBufferSize = mul_size(pgstat_track_activity_query_size,
2738	NumBackendStatSlots);
2739	BackendActivityBuffer = (char *)
2740	ShmemInitStruct("Backend Activity Buffer",
2741	BackendActivityBufferSize,
2742	&found);
2743
2744	if (!found)
2745	{
2746	MemSet(BackendActivityBuffer, `0`, BackendActivityBufferSize);
2747
2748	/ Initialize st_activity pointers. /
2749	buffer = BackendActivityBuffer;
2750	for (i = `0`; i < NumBackendStatSlots; i++)
2751	{
2752	BackendStatusArray[i].st_activity_raw = buffer;
2753	buffer += pgstat_track_activity_query_size;
2754	}
2755	}
2756
2757	#ifdef USE_SSL
2758	/ Create or attach to the shared SSL status buffer /
2759	size = mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots);
2760	BackendSslStatusBuffer = (PgBackendSSLStatus *)
2761	ShmemInitStruct("Backend SSL Status Buffer", size, &found);
2762
2763	if (!found)
2764	{
2765	PgBackendSSLStatus *ptr;
2766
2767	MemSet(BackendSslStatusBuffer, `0`, size);
2768
2769	/ Initialize st_sslstatus pointers. /
2770	ptr = BackendSslStatusBuffer;
2771	for (i = `0`; i < NumBackendStatSlots; i++)
2772	{
2773	BackendStatusArray[i].st_sslstatus = ptr;
2774	ptr++;
2775	}
2776	}
2777	#endif
2778
2779	#ifdef ENABLE_GSS
2780	/ Create or attach to the shared GSSAPI status buffer /
2781	size = mul_size(sizeof(PgBackendGSSStatus), NumBackendStatSlots);
2782	BackendGssStatusBuffer = (PgBackendGSSStatus *)
2783	ShmemInitStruct("Backend GSS Status Buffer", size, &found);
2784
2785	if (!found)
2786	{
2787	PgBackendGSSStatus *ptr;
2788
2789	MemSet(BackendGssStatusBuffer, `0`, size);
2790
2791	/ Initialize st_gssstatus pointers. /
2792	ptr = BackendGssStatusBuffer;
2793	for (i = `0`; i < NumBackendStatSlots; i++)
2794	{
2795	BackendStatusArray[i].st_gssstatus = ptr;
2796	ptr++;
2797	}
2798	}
2799	#endif
2800	}
2801
2802
2803	/ ----------*
2804	* pgstat_initialize() -
2805	*
2806	* Initialize pgstats state, and set up our on-proc-exit hook.
2807	* Called from InitPostgres and AuxiliaryProcessMain. For auxiliary process,
2808	* MyBackendId is invalid. Otherwise, MyBackendId must be set,
2809	* but we must not have started any transaction yet (since the
2810	* exit hook must run after the last transaction exit).
2811	* NOTE: MyDatabaseId isn't set yet; so the shutdown hook has to be careful.
2812	* ----------
2813	*/
2814	void
2815	pgstat_initialize(void)
2816	{
2817	/ Initialize MyBEEntry /
2818	if (MyBackendId != InvalidBackendId)
2819	{
2820	Assert(MyBackendId >= `1` && MyBackendId <= MaxBackends);
2821	MyBEEntry = &BackendStatusArray[MyBackendId - `1`];
2822	}
2823	else
2824	{
2825	/ Must be an auxiliary process /
2826	Assert(MyAuxProcType != NotAnAuxProcess);
2827
2828	/*
2829	* Assign the MyBEEntry for an auxiliary process. Since it doesn't
2830	* have a BackendId, the slot is statically allocated based on the
2831	* auxiliary process type (MyAuxProcType). Backends use slots indexed
2832	* in the range from 1 to MaxBackends (inclusive), so we use
2833	* MaxBackends + AuxBackendType + 1 as the index of the slot for an
2834	* auxiliary process.
2835	*/
2836	MyBEEntry = &BackendStatusArray[MaxBackends + MyAuxProcType];
2837	}
2838
2839	/ Set up a process-exit hook to clean up /
2840	on_shmem_exit(pgstat_beshutdown_hook, `0`);
2841	}
2842
2843	/ ----------*
2844	* pgstat_bestart() -
2845	*
2846	* Initialize this backend's entry in the PgBackendStatus array.
2847	* Called from InitPostgres.
2848	*
2849	* Apart from auxiliary processes, MyBackendId, MyDatabaseId,
2850	* session userid, and application_name must be set for a
2851	* backend (hence, this cannot be combined with pgstat_initialize).
2852	* Note also that we must be inside a transaction if this isn't an aux
2853	* process, as we may need to do encoding conversion on some strings.
2854	* ----------
2855	*/
2856	void
2857	pgstat_bestart(void)
2858	{
2859	volatile PgBackendStatus *vbeentry = MyBEEntry;
2860	PgBackendStatus lbeentry;
2861	#ifdef USE_SSL
2862	PgBackendSSLStatus lsslstatus;
2863	#endif
2864	#ifdef ENABLE_GSS
2865	PgBackendGSSStatus lgssstatus;
2866	#endif
2867
2868	/ pgstats state must be initialized from pgstat_initialize() /
2869	Assert(vbeentry != NULL);
2870
2871	/*
2872	* To minimize the time spent modifying the PgBackendStatus entry, and
2873	* avoid risk of errors inside the critical section, we first copy the
2874	* shared-memory struct to a local variable, then modify the data in the
2875	* local variable, then copy the local variable back to shared memory.
2876	* Only the last step has to be inside the critical section.
2877	*
2878	* Most of the data we copy from shared memory is just going to be
2879	* overwritten, but the struct's not so large that it's worth the
2880	* maintenance hassle to copy only the needful fields.
2881	*/
2882	memcpy(&lbeentry,
2883	unvolatize(PgBackendStatus *, vbeentry),
2884	sizeof(PgBackendStatus));
2885
2886	/ These structs can just start from zeroes each time, though /
2887	#ifdef USE_SSL
2888	memset(&lsslstatus, `0`, sizeof(lsslstatus));
2889	#endif
2890	#ifdef ENABLE_GSS
2891	memset(&lgssstatus, `0`, sizeof(lgssstatus));
2892	#endif
2893
2894	/*
2895	* Now fill in all the fields of lbeentry, except for strings that are
2896	* out-of-line data. Those have to be handled separately, below.
2897	*/
2898	lbeentry.st_procpid = MyProcPid;
2899
2900	if (MyBackendId != InvalidBackendId)
2901	{
2902	if (IsAutoVacuumLauncherProcess())
2903	{
2904	/ Autovacuum Launcher /
2905	lbeentry.st_backendType = B_AUTOVAC_LAUNCHER;
2906	}
2907	else if (IsAutoVacuumWorkerProcess())
2908	{
2909	/ Autovacuum Worker /
2910	lbeentry.st_backendType = B_AUTOVAC_WORKER;
2911	}
2912	else if (am_walsender)
2913	{
2914	/ Wal sender /
2915	lbeentry.st_backendType = B_WAL_SENDER;
2916	}
2917	else if (IsBackgroundWorker)
2918	{
2919	/ bgworker /
2920	lbeentry.st_backendType = B_BG_WORKER;
2921	}
2922	else
2923	{
2924	/ client-backend /
2925	lbeentry.st_backendType = B_BACKEND;
2926	}
2927	}
2928	else
2929	{
2930	/ Must be an auxiliary process /
2931	Assert(MyAuxProcType != NotAnAuxProcess);
2932	switch (MyAuxProcType)
2933	{
2934	case StartupProcess:
2935	lbeentry.st_backendType = B_STARTUP;
2936	break;
2937	case BgWriterProcess:
2938	lbeentry.st_backendType = B_BG_WRITER;
2939	break;
2940	case CheckpointerProcess:
2941	lbeentry.st_backendType = B_CHECKPOINTER;
2942	break;
2943	case WalWriterProcess:
2944	lbeentry.st_backendType = B_WAL_WRITER;
2945	break;
2946	case WalReceiverProcess:
2947	lbeentry.st_backendType = B_WAL_RECEIVER;
2948	break;
2949	default:
2950	elog(FATAL, "unrecognized process type: %d",
2951	(int) MyAuxProcType);
2952	}
2953	}
2954
2955	lbeentry.st_proc_start_timestamp = MyStartTimestamp;
2956	lbeentry.st_activity_start_timestamp = `0`;
2957	lbeentry.st_state_start_timestamp = `0`;
2958	lbeentry.st_xact_start_timestamp = `0`;
2959	lbeentry.st_databaseid = MyDatabaseId;
2960
2961	/ We have userid for client-backends, wal-sender and bgworker processes /
2962	if (lbeentry.st_backendType == B_BACKEND
2963	\|\| lbeentry.st_backendType == B_WAL_SENDER
2964	\|\| lbeentry.st_backendType == B_BG_WORKER)
2965	lbeentry.st_userid = GetSessionUserId();
2966	else
2967	lbeentry.st_userid = InvalidOid;
2968
2969	/*
2970	* We may not have a MyProcPort (eg, if this is the autovacuum process).
2971	* If so, use all-zeroes client address, which is dealt with specially in
2972	* pg_stat_get_backend_client_addr and pg_stat_get_backend_client_port.
2973	*/
2974	if (MyProcPort)
2975	memcpy(&lbeentry.st_clientaddr, &MyProcPort->raddr,
2976	sizeof(lbeentry.st_clientaddr));
2977	else
2978	MemSet(&lbeentry.st_clientaddr, `0`, sizeof(lbeentry.st_clientaddr));
2979
2980	#ifdef USE_SSL
2981	if (MyProcPort && MyProcPort->ssl != NULL)
2982	{
2983	lbeentry.st_ssl = true;
2984	lsslstatus.ssl_bits = be_tls_get_cipher_bits(MyProcPort);
2985	lsslstatus.ssl_compression = be_tls_get_compression(MyProcPort);
2986	strlcpy(lsslstatus.ssl_version, be_tls_get_version(MyProcPort), NAMEDATALEN);
2987	strlcpy(lsslstatus.ssl_cipher, be_tls_get_cipher(MyProcPort), NAMEDATALEN);
2988	be_tls_get_peer_subject_name(MyProcPort, lsslstatus.ssl_client_dn, NAMEDATALEN);
2989	be_tls_get_peer_serial(MyProcPort, lsslstatus.ssl_client_serial, NAMEDATALEN);
2990	be_tls_get_peer_issuer_name(MyProcPort, lsslstatus.ssl_issuer_dn, NAMEDATALEN);
2991	}
2992	else
2993	{
2994	lbeentry.st_ssl = false;
2995	}
2996	#else
2997	lbeentry.st_ssl = false;
2998	#endif
2999
3000	#ifdef ENABLE_GSS
3001	if (MyProcPort && MyProcPort->gss != NULL)
3002	{
3003	lbeentry.st_gss = true;
3004	lgssstatus.gss_auth = be_gssapi_get_auth(MyProcPort);
3005	lgssstatus.gss_enc = be_gssapi_get_enc(MyProcPort);
3006
3007	if (lgssstatus.gss_auth)
3008	strlcpy(lgssstatus.gss_princ, be_gssapi_get_princ(MyProcPort), NAMEDATALEN);
3009	}
3010	else
3011	{
3012	lbeentry.st_gss = false;
3013	}
3014	#else
3015	lbeentry.st_gss = false;
3016	#endif
3017
3018	lbeentry.st_state = STATE_UNDEFINED;
3019	lbeentry.st_progress_command = PROGRESS_COMMAND_INVALID;
3020	lbeentry.st_progress_command_target = InvalidOid;
3021
3022	/*
3023	* we don't zero st_progress_param here to save cycles; nobody should
3024	* examine it until st_progress_command has been set to something other
3025	* than PROGRESS_COMMAND_INVALID
3026	*/
3027
3028	/*
3029	* We're ready to enter the critical section that fills the shared-memory
3030	* status entry. We follow the protocol of bumping st_changecount before
3031	* and after; and make sure it's even afterwards. We use a volatile
3032	* pointer here to ensure the compiler doesn't try to get cute.
3033	*/
3034	PGSTAT_BEGIN_WRITE_ACTIVITY(vbeentry);
3035
3036	/ make sure we'll memcpy the same st_changecount back /
3037	lbeentry.st_changecount = vbeentry->st_changecount;
3038
3039	memcpy(unvolatize(PgBackendStatus *, vbeentry),
3040	&lbeentry,
3041	sizeof(PgBackendStatus));
3042
3043	/*
3044	* We can write the out-of-line strings and structs using the pointers
3045	* that are in lbeentry; this saves some de-volatilizing messiness.
3046	*/
3047	lbeentry.st_appname[`0`] = `'\0'`;
3048	if (MyProcPort && MyProcPort->remote_hostname)
3049	strlcpy(lbeentry.st_clienthostname, MyProcPort->remote_hostname,
3050	NAMEDATALEN);
3051	else
3052	lbeentry.st_clienthostname[`0`] = `'\0'`;
3053	lbeentry.st_activity_raw[`0`] = `'\0'`;
3054	/ Also make sure the last byte in each string area is always 0 /
3055	lbeentry.st_appname[NAMEDATALEN - `1`] = `'\0'`;
3056	lbeentry.st_clienthostname[NAMEDATALEN - `1`] = `'\0'`;
3057	lbeentry.st_activity_raw[pgstat_track_activity_query_size - `1`] = `'\0'`;
3058
3059	#ifdef USE_SSL
3060	memcpy(lbeentry.st_sslstatus, &lsslstatus, sizeof(PgBackendSSLStatus));
3061	#endif
3062	#ifdef ENABLE_GSS
3063	memcpy(lbeentry.st_gssstatus, &lgssstatus, sizeof(PgBackendGSSStatus));
3064	#endif
3065
3066	PGSTAT_END_WRITE_ACTIVITY(vbeentry);
3067
3068	/ Update app name to current GUC setting /
3069	if (application_name)
3070	pgstat_report_appname(application_name);
3071	}
3072
3073	/*
3074	* Shut down a single backend's statistics reporting at process exit.
3075	*
3076	* Flush any remaining statistics counts out to the collector.
3077	* Without this, operations triggered during backend exit (such as
3078	* temp table deletions) won't be counted.
3079	*
3080	* Lastly, clear out our entry in the PgBackendStatus array.
3081	*/
3082	static void
3083	pgstat_beshutdown_hook(int code, Datum arg)
3084	{
3085	volatile PgBackendStatus *beentry = MyBEEntry;
3086
3087	/*
3088	* If we got as far as discovering our own database ID, we can report what
3089	* we did to the collector. Otherwise, we'd be sending an invalid
3090	* database ID, so forget it. (This means that accesses to pg_database
3091	* during failed backend starts might never get counted.)
3092	*/
3093	if (OidIsValid(MyDatabaseId))
3094	pgstat_report_stat(true);
3095
3096	/*
3097	* Clear my status entry, following the protocol of bumping st_changecount
3098	* before and after. We use a volatile pointer here to ensure the
3099	* compiler doesn't try to get cute.
3100	*/
3101	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3102
3103	beentry->st_procpid = `0`; / mark invalid /
3104
3105	PGSTAT_END_WRITE_ACTIVITY(beentry);
3106	}
3107
3108
3109	/ ----------*
3110	* pgstat_report_activity() -
3111	*
3112	* Called from tcop/postgres.c to report what the backend is actually doing
3113	* (but note cmd_str can be NULL for certain cases).
3114	*
3115	* All updates of the status entry follow the protocol of bumping
3116	* st_changecount before and after. We use a volatile pointer here to
3117	* ensure the compiler doesn't try to get cute.
3118	* ----------
3119	*/
3120	void
3121	pgstat_report_activity(BackendState state, const char *cmd_str)
3122	{
3123	volatile PgBackendStatus *beentry = MyBEEntry;
3124	TimestampTz start_timestamp;
3125	TimestampTz current_timestamp;
3126	int len = `0`;
3127
3128	TRACE_POSTGRESQL_STATEMENT_STATUS(cmd_str);
3129
3130	if (!beentry)
3131	return;
3132
3133	if (!pgstat_track_activities)
3134	{
3135	if (beentry->st_state != STATE_DISABLED)
3136	{
3137	volatile PGPROC *proc = MyProc;
3138
3139	/*
3140	* track_activities is disabled, but we last reported a
3141	* non-disabled state. As our final update, change the state and
3142	* clear fields we will not be updating anymore.
3143	*/
3144	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3145	beentry->st_state = STATE_DISABLED;
3146	beentry->st_state_start_timestamp = `0`;
3147	beentry->st_activity_raw[`0`] = `'\0'`;
3148	beentry->st_activity_start_timestamp = `0`;
3149	/ st_xact_start_timestamp and wait_event_info are also disabled /
3150	beentry->st_xact_start_timestamp = `0`;
3151	proc->wait_event_info = `0`;
3152	PGSTAT_END_WRITE_ACTIVITY(beentry);
3153	}
3154	return;
3155	}
3156
3157	/*
3158	* To minimize the time spent modifying the entry, and avoid risk of
3159	* errors inside the critical section, fetch all the needed data first.
3160	*/
3161	start_timestamp = GetCurrentStatementStartTimestamp();
3162	if (cmd_str != NULL)
3163	{
3164	/*
3165	* Compute length of to-be-stored string unaware of multi-byte
3166	* characters. For speed reasons that'll get corrected on read, rather
3167	* than computed every write.
3168	*/
3169	len = Min(strlen(cmd_str), pgstat_track_activity_query_size - `1`);
3170	}
3171	current_timestamp = GetCurrentTimestamp();
3172
3173	/*
3174	* Now update the status entry
3175	*/
3176	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3177
3178	beentry->st_state = state;
3179	beentry->st_state_start_timestamp = current_timestamp;
3180
3181	if (cmd_str != NULL)
3182	{
3183	memcpy((char *) beentry->st_activity_raw, cmd_str, len);
3184	beentry->st_activity_raw[len] = `'\0'`;
3185	beentry->st_activity_start_timestamp = start_timestamp;
3186	}
3187
3188	PGSTAT_END_WRITE_ACTIVITY(beentry);
3189	}
3190
3191	/-----------*
3192	* pgstat_progress_start_command() -
3193	*
3194	* Set st_progress_command (and st_progress_command_target) in own backend
3195	* entry. Also, zero-initialize st_progress_param array.
3196	*-----------
3197	*/
3198	void
3199	pgstat_progress_start_command(ProgressCommandType cmdtype, Oid relid)
3200	{
3201	volatile PgBackendStatus *beentry = MyBEEntry;
3202
3203	if (!beentry \|\| !pgstat_track_activities)
3204	return;
3205
3206	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3207	beentry->st_progress_command = cmdtype;
3208	beentry->st_progress_command_target = relid;
3209	MemSet(&beentry->st_progress_param, `0`, sizeof(beentry->st_progress_param));
3210	PGSTAT_END_WRITE_ACTIVITY(beentry);
3211	}
3212
3213	/-----------*
3214	* pgstat_progress_update_param() -
3215	*
3216	* Update index'th member in st_progress_param[] of own backend entry.
3217	*-----------
3218	*/
3219	void
3220	pgstat_progress_update_param(int index, int64 val)
3221	{
3222	volatile PgBackendStatus *beentry = MyBEEntry;
3223
3224	Assert(index >= `0` && index < PGSTAT_NUM_PROGRESS_PARAM);
3225
3226	if (!beentry \|\| !pgstat_track_activities)
3227	return;
3228
3229	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3230	beentry->st_progress_param[index] = val;
3231	PGSTAT_END_WRITE_ACTIVITY(beentry);
3232	}
3233
3234	/-----------*
3235	* pgstat_progress_update_multi_param() -
3236	*
3237	* Update multiple members in st_progress_param[] of own backend entry.
3238	* This is atomic; readers won't see intermediate states.
3239	*-----------
3240	*/
3241	void
3242	pgstat_progress_update_multi_param(int nparam, const int *index,
3243	const int64 *val)
3244	{
3245	volatile PgBackendStatus *beentry = MyBEEntry;
3246	int i;
3247
3248	if (!beentry \|\| !pgstat_track_activities \|\| nparam == `0`)
3249	return;
3250
3251	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3252
3253	for (i = `0`; i < nparam; ++i)
3254	{
3255	Assert(index[i] >= `0` && index[i] < PGSTAT_NUM_PROGRESS_PARAM);
3256
3257	beentry->st_progress_param[index[i]] = val[i];
3258	}
3259
3260	PGSTAT_END_WRITE_ACTIVITY(beentry);
3261	}
3262
3263	/-----------*
3264	* pgstat_progress_end_command() -
3265	*
3266	* Reset st_progress_command (and st_progress_command_target) in own backend
3267	* entry. This signals the end of the command.
3268	*-----------
3269	*/
3270	void
3271	pgstat_progress_end_command(void)
3272	{
3273	volatile PgBackendStatus *beentry = MyBEEntry;
3274
3275	if (!beentry \|\| !pgstat_track_activities)
3276	return;
3277
3278	if (beentry->st_progress_command == PROGRESS_COMMAND_INVALID)
3279	return;
3280
3281	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3282	beentry->st_progress_command = PROGRESS_COMMAND_INVALID;
3283	beentry->st_progress_command_target = InvalidOid;
3284	PGSTAT_END_WRITE_ACTIVITY(beentry);
3285	}
3286
3287	/ ----------*
3288	* pgstat_report_appname() -
3289	*
3290	* Called to update our application name.
3291	* ----------
3292	*/
3293	void
3294	pgstat_report_appname(const char *appname)
3295	{
3296	volatile PgBackendStatus *beentry = MyBEEntry;
3297	int len;
3298
3299	if (!beentry)
3300	return;
3301
3302	/ This should be unnecessary if GUC did its job, but be safe /
3303	len = pg_mbcliplen(appname, strlen(appname), NAMEDATALEN - `1`);
3304
3305	/*
3306	* Update my status entry, following the protocol of bumping
3307	* st_changecount before and after. We use a volatile pointer here to
3308	* ensure the compiler doesn't try to get cute.
3309	*/
3310	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3311
3312	memcpy((char *) beentry->st_appname, appname, len);
3313	beentry->st_appname[len] = `'\0'`;
3314
3315	PGSTAT_END_WRITE_ACTIVITY(beentry);
3316	}
3317
3318	/*
3319	* Report current transaction start timestamp as the specified value.
3320	* Zero means there is no active transaction.
3321	*/
3322	void
3323	pgstat_report_xact_timestamp(TimestampTz tstamp)
3324	{
3325	volatile PgBackendStatus *beentry = MyBEEntry;
3326
3327	if (!pgstat_track_activities \|\| !beentry)
3328	return;
3329
3330	/*
3331	* Update my status entry, following the protocol of bumping
3332	* st_changecount before and after. We use a volatile pointer here to
3333	* ensure the compiler doesn't try to get cute.
3334	*/
3335	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
3336
3337	beentry->st_xact_start_timestamp = tstamp;
3338
3339	PGSTAT_END_WRITE_ACTIVITY(beentry);
3340	}
3341
3342	/ ----------*
3343	* pgstat_read_current_status() -
3344	*
3345	* Copy the current contents of the PgBackendStatus array to local memory,
3346	* if not already done in this transaction.
3347	* ----------
3348	*/
3349	static void
3350	pgstat_read_current_status(void)
3351	{
3352	volatile PgBackendStatus *beentry;
3353	LocalPgBackendStatus *localtable;
3354	LocalPgBackendStatus *localentry;
3355	char *localappname,
3356	*localclienthostname,
3357	*localactivity;
3358	#ifdef USE_SSL
3359	PgBackendSSLStatus *localsslstatus;
3360	#endif
3361	#ifdef ENABLE_GSS
3362	PgBackendGSSStatus *localgssstatus;
3363	#endif
3364	int i;
3365
3366	Assert(!pgStatRunningInCollector);
3367	if (localBackendStatusTable)
3368	return; / already done /
3369
3370	pgstat_setup_memcxt();
3371
3372	/*
3373	* Allocate storage for local copy of state data. We can presume that
3374	* none of these requests overflow size_t, because we already calculated
3375	* the same values using mul_size during shmem setup. However, with
3376	* probably-silly values of pgstat_track_activity_query_size and
3377	* max_connections, the localactivity buffer could exceed 1GB, so use
3378	* "huge" allocation for that one.
3379	*/
3380	localtable = (LocalPgBackendStatus *)
3381	MemoryContextAlloc(pgStatLocalContext,
3382	sizeof(LocalPgBackendStatus) * NumBackendStatSlots);
3383	localappname = (char *)
3384	MemoryContextAlloc(pgStatLocalContext,
3385	NAMEDATALEN * NumBackendStatSlots);
3386	localclienthostname = (char *)
3387	MemoryContextAlloc(pgStatLocalContext,
3388	NAMEDATALEN * NumBackendStatSlots);
3389	localactivity = (char *)
3390	MemoryContextAllocHuge(pgStatLocalContext,
3391	pgstat_track_activity_query_size * NumBackendStatSlots);
3392	#ifdef USE_SSL
3393	localsslstatus = (PgBackendSSLStatus *)
3394	MemoryContextAlloc(pgStatLocalContext,
3395	sizeof(PgBackendSSLStatus) * NumBackendStatSlots);
3396	#endif
3397	#ifdef ENABLE_GSS
3398	localgssstatus = (PgBackendGSSStatus *)
3399	MemoryContextAlloc(pgStatLocalContext,
3400	sizeof(PgBackendGSSStatus) * NumBackendStatSlots);
3401	#endif
3402
3403	localNumBackends = `0`;
3404
3405	beentry = BackendStatusArray;
3406	localentry = localtable;
3407	for (i = `1`; i <= NumBackendStatSlots; i++)
3408	{
3409	/*
3410	* Follow the protocol of retrying if st_changecount changes while we
3411	* copy the entry, or if it's odd. (The check for odd is needed to
3412	* cover the case where we are able to completely copy the entry while
3413	* the source backend is between increment steps.) We use a volatile
3414	* pointer here to ensure the compiler doesn't try to get cute.
3415	*/
3416	for (;;)
3417	{
3418	int before_changecount;
3419	int after_changecount;
3420
3421	pgstat_begin_read_activity(beentry, before_changecount);
3422
3423	localentry->backendStatus.st_procpid = beentry->st_procpid;
3424	/ Skip all the data-copying work if entry is not in use /
3425	if (localentry->backendStatus.st_procpid > `0`)
3426	{
3427	memcpy(&localentry->backendStatus, unvolatize(PgBackendStatus , beentry), sizeof*(PgBackendStatus));
3428
3429	/*
3430	* For each PgBackendStatus field that is a pointer, copy the
3431	* pointed-to data, then adjust the local copy of the pointer
3432	* field to point at the local copy of the data.
3433	*
3434	* strcpy is safe even if the string is modified concurrently,
3435	* because there's always a \0 at the end of the buffer.
3436	*/
3437	strcpy(localappname, (char *) beentry->st_appname);
3438	localentry->backendStatus.st_appname = localappname;
3439	strcpy(localclienthostname, (char *) beentry->st_clienthostname);
3440	localentry->backendStatus.st_clienthostname = localclienthostname;
3441	strcpy(localactivity, (char *) beentry->st_activity_raw);
3442	localentry->backendStatus.st_activity_raw = localactivity;
3443	#ifdef USE_SSL
3444	if (beentry->st_ssl)
3445	{
3446	memcpy(localsslstatus, beentry->st_sslstatus, sizeof(PgBackendSSLStatus));
3447	localentry->backendStatus.st_sslstatus = localsslstatus;
3448	}
3449	#endif
3450	#ifdef ENABLE_GSS
3451	if (beentry->st_gss)
3452	{
3453	memcpy(localgssstatus, beentry->st_gssstatus, sizeof(PgBackendGSSStatus));
3454	localentry->backendStatus.st_gssstatus = localgssstatus;
3455	}
3456	#endif
3457	}
3458
3459	pgstat_end_read_activity(beentry, after_changecount);
3460
3461	if (pgstat_read_activity_complete(before_changecount,
3462	after_changecount))
3463	break;
3464
3465	/ Make sure we can break out of loop if stuck... /
3466	CHECK_FOR_INTERRUPTS();
3467	}
3468
3469	beentry++;
3470	/ Only valid entries get included into the local array /
3471	if (localentry->backendStatus.st_procpid > `0`)
3472	{
3473	BackendIdGetTransactionIds(i,
3474	&localentry->backend_xid,
3475	&localentry->backend_xmin);
3476
3477	localentry++;
3478	localappname += NAMEDATALEN;
3479	localclienthostname += NAMEDATALEN;
3480	localactivity += pgstat_track_activity_query_size;
3481	#ifdef USE_SSL
3482	localsslstatus++;
3483	#endif
3484	#ifdef ENABLE_GSS
3485	localgssstatus++;
3486	#endif
3487	localNumBackends++;
3488	}
3489	}
3490
3491	/ Set the pointer only after completion of a valid table /
3492	localBackendStatusTable = localtable;
3493	}
3494
3495	/ ----------*
3496	* pgstat_get_wait_event_type() -
3497	*
3498	* Return a string representing the current wait event type, backend is
3499	* waiting on.
3500	*/
3501	const char *
3502	pgstat_get_wait_event_type(uint32 wait_event_info)
3503	{
3504	uint32 classId;
3505	const char *event_type;
3506
3507	/ report process as not waiting. /
3508	if (wait_event_info == `0`)
3509	return NULL;
3510
3511	classId = wait_event_info & `0xFF000000`;
3512
3513	switch (classId)
3514	{
3515	case PG_WAIT_LWLOCK:
3516	event_type = "LWLock";
3517	break;
3518	case PG_WAIT_LOCK:
3519	event_type = "Lock";
3520	break;
3521	case PG_WAIT_BUFFER_PIN:
3522	event_type = "BufferPin";
3523	break;
3524	case PG_WAIT_ACTIVITY:
3525	event_type = "Activity";
3526	break;
3527	case PG_WAIT_CLIENT:
3528	event_type = "Client";
3529	break;
3530	case PG_WAIT_EXTENSION:
3531	event_type = "Extension";
3532	break;
3533	case PG_WAIT_IPC:
3534	event_type = "IPC";
3535	break;
3536	case PG_WAIT_TIMEOUT:
3537	event_type = "Timeout";
3538	break;
3539	case PG_WAIT_IO:
3540	event_type = "IO";
3541	break;
3542	default:
3543	event_type = "???";
3544	break;
3545	}
3546
3547	return event_type;
3548	}
3549
3550	/ ----------*
3551	* pgstat_get_wait_event() -
3552	*
3553	* Return a string representing the current wait event, backend is
3554	* waiting on.
3555	*/
3556	const char *
3557	pgstat_get_wait_event(uint32 wait_event_info)
3558	{
3559	uint32 classId;
3560	uint16 eventId;
3561	const char *event_name;
3562
3563	/ report process as not waiting. /
3564	if (wait_event_info == `0`)
3565	return NULL;
3566
3567	classId = wait_event_info & `0xFF000000`;
3568	eventId = wait_event_info & `0x0000FFFF`;
3569
3570	switch (classId)
3571	{
3572	case PG_WAIT_LWLOCK:
3573	event_name = GetLWLockIdentifier(classId, eventId);
3574	break;
3575	case PG_WAIT_LOCK:
3576	event_name = GetLockNameFromTagType(eventId);
3577	break;
3578	case PG_WAIT_BUFFER_PIN:
3579	event_name = "BufferPin";
3580	break;
3581	case PG_WAIT_ACTIVITY:
3582	{
3583	WaitEventActivity w = (WaitEventActivity) wait_event_info;
3584
3585	event_name = pgstat_get_wait_activity(w);
3586	break;
3587	}
3588	case PG_WAIT_CLIENT:
3589	{
3590	WaitEventClient w = (WaitEventClient) wait_event_info;
3591
3592	event_name = pgstat_get_wait_client(w);
3593	break;
3594	}
3595	case PG_WAIT_EXTENSION:
3596	event_name = "Extension";
3597	break;
3598	case PG_WAIT_IPC:
3599	{
3600	WaitEventIPC w = (WaitEventIPC) wait_event_info;
3601
3602	event_name = pgstat_get_wait_ipc(w);
3603	break;
3604	}
3605	case PG_WAIT_TIMEOUT:
3606	{
3607	WaitEventTimeout w = (WaitEventTimeout) wait_event_info;
3608
3609	event_name = pgstat_get_wait_timeout(w);
3610	break;
3611	}
3612	case PG_WAIT_IO:
3613	{
3614	WaitEventIO w = (WaitEventIO) wait_event_info;
3615
3616	event_name = pgstat_get_wait_io(w);
3617	break;
3618	}
3619	default:
3620	event_name = "unknown wait event";
3621	break;
3622	}
3623
3624	return event_name;
3625	}
3626
3627	/ ----------*
3628	* pgstat_get_wait_activity() -
3629	*
3630	* Convert WaitEventActivity to string.
3631	* ----------
3632	*/
3633	static const char *
3634	pgstat_get_wait_activity(WaitEventActivity w)
3635	{
3636	const char *event_name = "unknown wait event";
3637
3638	switch (w)
3639	{
3640	case WAIT_EVENT_ARCHIVER_MAIN:
3641	event_name = "ArchiverMain";
3642	break;
3643	case WAIT_EVENT_AUTOVACUUM_MAIN:
3644	event_name = "AutoVacuumMain";
3645	break;
3646	case WAIT_EVENT_BGWRITER_HIBERNATE:
3647	event_name = "BgWriterHibernate";
3648	break;
3649	case WAIT_EVENT_BGWRITER_MAIN:
3650	event_name = "BgWriterMain";
3651	break;
3652	case WAIT_EVENT_CHECKPOINTER_MAIN:
3653	event_name = "CheckpointerMain";
3654	break;
3655	case WAIT_EVENT_LOGICAL_APPLY_MAIN:
3656	event_name = "LogicalApplyMain";
3657	break;
3658	case WAIT_EVENT_LOGICAL_LAUNCHER_MAIN:
3659	event_name = "LogicalLauncherMain";
3660	break;
3661	case WAIT_EVENT_PGSTAT_MAIN:
3662	event_name = "PgStatMain";
3663	break;
3664	case WAIT_EVENT_RECOVERY_WAL_ALL:
3665	event_name = "RecoveryWalAll";
3666	break;
3667	case WAIT_EVENT_RECOVERY_WAL_STREAM:
3668	event_name = "RecoveryWalStream";
3669	break;
3670	case WAIT_EVENT_SYSLOGGER_MAIN:
3671	event_name = "SysLoggerMain";
3672	break;
3673	case WAIT_EVENT_WAL_RECEIVER_MAIN:
3674	event_name = "WalReceiverMain";
3675	break;
3676	case WAIT_EVENT_WAL_SENDER_MAIN:
3677	event_name = "WalSenderMain";
3678	break;
3679	case WAIT_EVENT_WAL_WRITER_MAIN:
3680	event_name = "WalWriterMain";
3681	break;
3682	/ no default case, so that compiler will warn /
3683	}
3684
3685	return event_name;
3686	}
3687
3688	/ ----------*
3689	* pgstat_get_wait_client() -
3690	*
3691	* Convert WaitEventClient to string.
3692	* ----------
3693	*/
3694	static const char *
3695	pgstat_get_wait_client(WaitEventClient w)
3696	{
3697	const char *event_name = "unknown wait event";
3698
3699	switch (w)
3700	{
3701	case WAIT_EVENT_CLIENT_READ:
3702	event_name = "ClientRead";
3703	break;
3704	case WAIT_EVENT_CLIENT_WRITE:
3705	event_name = "ClientWrite";
3706	break;
3707	case WAIT_EVENT_LIBPQWALRECEIVER_CONNECT:
3708	event_name = "LibPQWalReceiverConnect";
3709	break;
3710	case WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE:
3711	event_name = "LibPQWalReceiverReceive";
3712	break;
3713	case WAIT_EVENT_SSL_OPEN_SERVER:
3714	event_name = "SSLOpenServer";
3715	break;
3716	case WAIT_EVENT_WAL_RECEIVER_WAIT_START:
3717	event_name = "WalReceiverWaitStart";
3718	break;
3719	case WAIT_EVENT_WAL_SENDER_WAIT_WAL:
3720	event_name = "WalSenderWaitForWAL";
3721	break;
3722	case WAIT_EVENT_WAL_SENDER_WRITE_DATA:
3723	event_name = "WalSenderWriteData";
3724	break;
3725	case WAIT_EVENT_GSS_OPEN_SERVER:
3726	event_name = "GSSOpenServer";
3727	break;
3728	/ no default case, so that compiler will warn /
3729	}
3730
3731	return event_name;
3732	}
3733
3734	/ ----------*
3735	* pgstat_get_wait_ipc() -
3736	*
3737	* Convert WaitEventIPC to string.
3738	* ----------
3739	*/
3740	static const char *
3741	pgstat_get_wait_ipc(WaitEventIPC w)
3742	{
3743	const char *event_name = "unknown wait event";
3744
3745	switch (w)
3746	{
3747	case WAIT_EVENT_BGWORKER_SHUTDOWN:
3748	event_name = "BgWorkerShutdown";
3749	break;
3750	case WAIT_EVENT_BGWORKER_STARTUP:
3751	event_name = "BgWorkerStartup";
3752	break;
3753	case WAIT_EVENT_BTREE_PAGE:
3754	event_name = "BtreePage";
3755	break;
3756	case WAIT_EVENT_CHECKPOINT_DONE:
3757	event_name = "CheckpointDone";
3758	break;
3759	case WAIT_EVENT_CHECKPOINT_START:
3760	event_name = "CheckpointStart";
3761	break;
3762	case WAIT_EVENT_CLOG_GROUP_UPDATE:
3763	event_name = "ClogGroupUpdate";
3764	break;
3765	case WAIT_EVENT_EXECUTE_GATHER:
3766	event_name = "ExecuteGather";
3767	break;
3768	case WAIT_EVENT_HASH_BATCH_ALLOCATING:
3769	event_name = "Hash/Batch/Allocating";
3770	break;
3771	case WAIT_EVENT_HASH_BATCH_ELECTING:
3772	event_name = "Hash/Batch/Electing";
3773	break;
3774	case WAIT_EVENT_HASH_BATCH_LOADING:
3775	event_name = "Hash/Batch/Loading";
3776	break;
3777	case WAIT_EVENT_HASH_BUILD_ALLOCATING:
3778	event_name = "Hash/Build/Allocating";
3779	break;
3780	case WAIT_EVENT_HASH_BUILD_ELECTING:
3781	event_name = "Hash/Build/Electing";
3782	break;
3783	case WAIT_EVENT_HASH_BUILD_HASHING_INNER:
3784	event_name = "Hash/Build/HashingInner";
3785	break;
3786	case WAIT_EVENT_HASH_BUILD_HASHING_OUTER:
3787	event_name = "Hash/Build/HashingOuter";
3788	break;
3789	case WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATING:
3790	event_name = "Hash/GrowBatches/Allocating";
3791	break;
3792	case WAIT_EVENT_HASH_GROW_BATCHES_DECIDING:
3793	event_name = "Hash/GrowBatches/Deciding";
3794	break;
3795	case WAIT_EVENT_HASH_GROW_BATCHES_ELECTING:
3796	event_name = "Hash/GrowBatches/Electing";
3797	break;
3798	case WAIT_EVENT_HASH_GROW_BATCHES_FINISHING:
3799	event_name = "Hash/GrowBatches/Finishing";
3800	break;
3801	case WAIT_EVENT_HASH_GROW_BATCHES_REPARTITIONING:
3802	event_name = "Hash/GrowBatches/Repartitioning";
3803	break;
3804	case WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATING:
3805	event_name = "Hash/GrowBuckets/Allocating";
3806	break;
3807	case WAIT_EVENT_HASH_GROW_BUCKETS_ELECTING:
3808	event_name = "Hash/GrowBuckets/Electing";
3809	break;
3810	case WAIT_EVENT_HASH_GROW_BUCKETS_REINSERTING:
3811	event_name = "Hash/GrowBuckets/Reinserting";
3812	break;
3813	case WAIT_EVENT_LOGICAL_SYNC_DATA:
3814	event_name = "LogicalSyncData";
3815	break;
3816	case WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE:
3817	event_name = "LogicalSyncStateChange";
3818	break;
3819	case WAIT_EVENT_MQ_INTERNAL:
3820	event_name = "MessageQueueInternal";
3821	break;
3822	case WAIT_EVENT_MQ_PUT_MESSAGE:
3823	event_name = "MessageQueuePutMessage";
3824	break;
3825	case WAIT_EVENT_MQ_RECEIVE:
3826	event_name = "MessageQueueReceive";
3827	break;
3828	case WAIT_EVENT_MQ_SEND:
3829	event_name = "MessageQueueSend";
3830	break;
3831	case WAIT_EVENT_PARALLEL_BITMAP_SCAN:
3832	event_name = "ParallelBitmapScan";
3833	break;
3834	case WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN:
3835	event_name = "ParallelCreateIndexScan";
3836	break;
3837	case WAIT_EVENT_PARALLEL_FINISH:
3838	event_name = "ParallelFinish";
3839	break;
3840	case WAIT_EVENT_PROCARRAY_GROUP_UPDATE:
3841	event_name = "ProcArrayGroupUpdate";
3842	break;
3843	case WAIT_EVENT_PROMOTE:
3844	event_name = "Promote";
3845	break;
3846	case WAIT_EVENT_REPLICATION_ORIGIN_DROP:
3847	event_name = "ReplicationOriginDrop";
3848	break;
3849	case WAIT_EVENT_REPLICATION_SLOT_DROP:
3850	event_name = "ReplicationSlotDrop";
3851	break;
3852	case WAIT_EVENT_SAFE_SNAPSHOT:
3853	event_name = "SafeSnapshot";
3854	break;
3855	case WAIT_EVENT_SYNC_REP:
3856	event_name = "SyncRep";
3857	break;
3858	/ no default case, so that compiler will warn /
3859	}
3860
3861	return event_name;
3862	}
3863
3864	/ ----------*
3865	* pgstat_get_wait_timeout() -
3866	*
3867	* Convert WaitEventTimeout to string.
3868	* ----------
3869	*/
3870	static const char *
3871	pgstat_get_wait_timeout(WaitEventTimeout w)
3872	{
3873	const char *event_name = "unknown wait event";
3874
3875	switch (w)
3876	{
3877	case WAIT_EVENT_BASE_BACKUP_THROTTLE:
3878	event_name = "BaseBackupThrottle";
3879	break;
3880	case WAIT_EVENT_PG_SLEEP:
3881	event_name = "PgSleep";
3882	break;
3883	case WAIT_EVENT_RECOVERY_APPLY_DELAY:
3884	event_name = "RecoveryApplyDelay";
3885	break;
3886	/ no default case, so that compiler will warn /
3887	}
3888
3889	return event_name;
3890	}
3891
3892	/ ----------*
3893	* pgstat_get_wait_io() -
3894	*
3895	* Convert WaitEventIO to string.
3896	* ----------
3897	*/
3898	static const char *
3899	pgstat_get_wait_io(WaitEventIO w)
3900	{
3901	const char *event_name = "unknown wait event";
3902
3903	switch (w)
3904	{
3905	case WAIT_EVENT_BUFFILE_READ:
3906	event_name = "BufFileRead";
3907	break;
3908	case WAIT_EVENT_BUFFILE_WRITE:
3909	event_name = "BufFileWrite";
3910	break;
3911	case WAIT_EVENT_CONTROL_FILE_READ:
3912	event_name = "ControlFileRead";
3913	break;
3914	case WAIT_EVENT_CONTROL_FILE_SYNC:
3915	event_name = "ControlFileSync";
3916	break;
3917	case WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE:
3918	event_name = "ControlFileSyncUpdate";
3919	break;
3920	case WAIT_EVENT_CONTROL_FILE_WRITE:
3921	event_name = "ControlFileWrite";
3922	break;
3923	case WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE:
3924	event_name = "ControlFileWriteUpdate";
3925	break;
3926	case WAIT_EVENT_COPY_FILE_READ:
3927	event_name = "CopyFileRead";
3928	break;
3929	case WAIT_EVENT_COPY_FILE_WRITE:
3930	event_name = "CopyFileWrite";
3931	break;
3932	case WAIT_EVENT_DATA_FILE_EXTEND:
3933	event_name = "DataFileExtend";
3934	break;
3935	case WAIT_EVENT_DATA_FILE_FLUSH:
3936	event_name = "DataFileFlush";
3937	break;
3938	case WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC:
3939	event_name = "DataFileImmediateSync";
3940	break;
3941	case WAIT_EVENT_DATA_FILE_PREFETCH:
3942	event_name = "DataFilePrefetch";
3943	break;
3944	case WAIT_EVENT_DATA_FILE_READ:
3945	event_name = "DataFileRead";
3946	break;
3947	case WAIT_EVENT_DATA_FILE_SYNC:
3948	event_name = "DataFileSync";
3949	break;
3950	case WAIT_EVENT_DATA_FILE_TRUNCATE:
3951	event_name = "DataFileTruncate";
3952	break;
3953	case WAIT_EVENT_DATA_FILE_WRITE:
3954	event_name = "DataFileWrite";
3955	break;
3956	case WAIT_EVENT_DSM_FILL_ZERO_WRITE:
3957	event_name = "DSMFillZeroWrite";
3958	break;
3959	case WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ:
3960	event_name = "LockFileAddToDataDirRead";
3961	break;
3962	case WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC:
3963	event_name = "LockFileAddToDataDirSync";
3964	break;
3965	case WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE:
3966	event_name = "LockFileAddToDataDirWrite";
3967	break;
3968	case WAIT_EVENT_LOCK_FILE_CREATE_READ:
3969	event_name = "LockFileCreateRead";
3970	break;
3971	case WAIT_EVENT_LOCK_FILE_CREATE_SYNC:
3972	event_name = "LockFileCreateSync";
3973	break;
3974	case WAIT_EVENT_LOCK_FILE_CREATE_WRITE:
3975	event_name = "LockFileCreateWrite";
3976	break;
3977	case WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ:
3978	event_name = "LockFileReCheckDataDirRead";
3979	break;
3980	case WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC:
3981	event_name = "LogicalRewriteCheckpointSync";
3982	break;
3983	case WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC:
3984	event_name = "LogicalRewriteMappingSync";
3985	break;
3986	case WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE:
3987	event_name = "LogicalRewriteMappingWrite";
3988	break;
3989	case WAIT_EVENT_LOGICAL_REWRITE_SYNC:
3990	event_name = "LogicalRewriteSync";
3991	break;
3992	case WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE:
3993	event_name = "LogicalRewriteTruncate";
3994	break;
3995	case WAIT_EVENT_LOGICAL_REWRITE_WRITE:
3996	event_name = "LogicalRewriteWrite";
3997	break;
3998	case WAIT_EVENT_RELATION_MAP_READ:
3999	event_name = "RelationMapRead";
4000	break;
4001	case WAIT_EVENT_RELATION_MAP_SYNC:
4002	event_name = "RelationMapSync";
4003	break;
4004	case WAIT_EVENT_RELATION_MAP_WRITE:
4005	event_name = "RelationMapWrite";
4006	break;
4007	case WAIT_EVENT_REORDER_BUFFER_READ:
4008	event_name = "ReorderBufferRead";
4009	break;
4010	case WAIT_EVENT_REORDER_BUFFER_WRITE:
4011	event_name = "ReorderBufferWrite";
4012	break;
4013	case WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ:
4014	event_name = "ReorderLogicalMappingRead";
4015	break;
4016	case WAIT_EVENT_REPLICATION_SLOT_READ:
4017	event_name = "ReplicationSlotRead";
4018	break;
4019	case WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC:
4020	event_name = "ReplicationSlotRestoreSync";
4021	break;
4022	case WAIT_EVENT_REPLICATION_SLOT_SYNC:
4023	event_name = "ReplicationSlotSync";
4024	break;
4025	case WAIT_EVENT_REPLICATION_SLOT_WRITE:
4026	event_name = "ReplicationSlotWrite";
4027	break;
4028	case WAIT_EVENT_SLRU_FLUSH_SYNC:
4029	event_name = "SLRUFlushSync";
4030	break;
4031	case WAIT_EVENT_SLRU_READ:
4032	event_name = "SLRURead";
4033	break;
4034	case WAIT_EVENT_SLRU_SYNC:
4035	event_name = "SLRUSync";
4036	break;
4037	case WAIT_EVENT_SLRU_WRITE:
4038	event_name = "SLRUWrite";
4039	break;
4040	case WAIT_EVENT_SNAPBUILD_READ:
4041	event_name = "SnapbuildRead";
4042	break;
4043	case WAIT_EVENT_SNAPBUILD_SYNC:
4044	event_name = "SnapbuildSync";
4045	break;
4046	case WAIT_EVENT_SNAPBUILD_WRITE:
4047	event_name = "SnapbuildWrite";
4048	break;
4049	case WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC:
4050	event_name = "TimelineHistoryFileSync";
4051	break;
4052	case WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE:
4053	event_name = "TimelineHistoryFileWrite";
4054	break;
4055	case WAIT_EVENT_TIMELINE_HISTORY_READ:
4056	event_name = "TimelineHistoryRead";
4057	break;
4058	case WAIT_EVENT_TIMELINE_HISTORY_SYNC:
4059	event_name = "TimelineHistorySync";
4060	break;
4061	case WAIT_EVENT_TIMELINE_HISTORY_WRITE:
4062	event_name = "TimelineHistoryWrite";
4063	break;
4064	case WAIT_EVENT_TWOPHASE_FILE_READ:
4065	event_name = "TwophaseFileRead";
4066	break;
4067	case WAIT_EVENT_TWOPHASE_FILE_SYNC:
4068	event_name = "TwophaseFileSync";
4069	break;
4070	case WAIT_EVENT_TWOPHASE_FILE_WRITE:
4071	event_name = "TwophaseFileWrite";
4072	break;
4073	case WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ:
4074	event_name = "WALSenderTimelineHistoryRead";
4075	break;
4076	case WAIT_EVENT_WAL_BOOTSTRAP_SYNC:
4077	event_name = "WALBootstrapSync";
4078	break;
4079	case WAIT_EVENT_WAL_BOOTSTRAP_WRITE:
4080	event_name = "WALBootstrapWrite";
4081	break;
4082	case WAIT_EVENT_WAL_COPY_READ:
4083	event_name = "WALCopyRead";
4084	break;
4085	case WAIT_EVENT_WAL_COPY_SYNC:
4086	event_name = "WALCopySync";
4087	break;
4088	case WAIT_EVENT_WAL_COPY_WRITE:
4089	event_name = "WALCopyWrite";
4090	break;
4091	case WAIT_EVENT_WAL_INIT_SYNC:
4092	event_name = "WALInitSync";
4093	break;
4094	case WAIT_EVENT_WAL_INIT_WRITE:
4095	event_name = "WALInitWrite";
4096	break;
4097	case WAIT_EVENT_WAL_READ:
4098	event_name = "WALRead";
4099	break;
4100	case WAIT_EVENT_WAL_SYNC:
4101	event_name = "WALSync";
4102	break;
4103	case WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN:
4104	event_name = "WALSyncMethodAssign";
4105	break;
4106	case WAIT_EVENT_WAL_WRITE:
4107	event_name = "WALWrite";
4108	break;
4109
4110	/ no default case, so that compiler will warn /
4111	}
4112
4113	return event_name;
4114	}
4115
4116
4117	/ ----------*
4118	* pgstat_get_backend_current_activity() -
4119	*
4120	* Return a string representing the current activity of the backend with
4121	* the specified PID. This looks directly at the BackendStatusArray,
4122	* and so will provide current information regardless of the age of our
4123	* transaction's snapshot of the status array.
4124	*
4125	* It is the caller's responsibility to invoke this only for backends whose
4126	* state is expected to remain stable while the result is in use. The
4127	* only current use is in deadlock reporting, where we can expect that
4128	* the target backend is blocked on a lock. (There are corner cases
4129	* where the target's wait could get aborted while we are looking at it,
4130	* but the very worst consequence is to return a pointer to a string
4131	* that's been changed, so we won't worry too much.)
4132	*
4133	* Note: return strings for special cases match pg_stat_get_backend_activity.
4134	* ----------
4135	*/
4136	const char *
4137	pgstat_get_backend_current_activity(int pid, bool checkUser)
4138	{
4139	PgBackendStatus *beentry;
4140	int i;
4141
4142	beentry = BackendStatusArray;
4143	for (i = `1`; i <= MaxBackends; i++)
4144	{
4145	/*
4146	* Although we expect the target backend's entry to be stable, that
4147	* doesn't imply that anyone else's is. To avoid identifying the
4148	* wrong backend, while we check for a match to the desired PID we
4149	* must follow the protocol of retrying if st_changecount changes
4150	* while we examine the entry, or if it's odd. (This might be
4151	* unnecessary, since fetching or storing an int is almost certainly
4152	* atomic, but let's play it safe.) We use a volatile pointer here to
4153	* ensure the compiler doesn't try to get cute.
4154	*/
4155	volatile PgBackendStatus *vbeentry = beentry;
4156	bool found;
4157
4158	for (;;)
4159	{
4160	int before_changecount;
4161	int after_changecount;
4162
4163	pgstat_begin_read_activity(vbeentry, before_changecount);
4164
4165	found = (vbeentry->st_procpid == pid);
4166
4167	pgstat_end_read_activity(vbeentry, after_changecount);
4168
4169	if (pgstat_read_activity_complete(before_changecount,
4170	after_changecount))
4171	break;
4172
4173	/ Make sure we can break out of loop if stuck... /
4174	CHECK_FOR_INTERRUPTS();
4175	}
4176
4177	if (found)
4178	{
4179	/ Now it is safe to use the non-volatile pointer /
4180	if (checkUser && !superuser() && beentry->st_userid != GetUserId())
4181	return "<insufficient privilege>";
4182	else if (*(beentry->st_activity_raw) == `'\0'`)
4183	return "<command string not enabled>";
4184	else
4185	{
4186	/ this'll leak a bit of memory, but that seems acceptable /
4187	return pgstat_clip_activity(beentry->st_activity_raw);
4188	}
4189	}
4190
4191	beentry++;
4192	}
4193
4194	/ If we get here, caller is in error ... /
4195	return "<backend information not available>";
4196	}
4197
4198	/ ----------*
4199	* pgstat_get_crashed_backend_activity() -
4200	*
4201	* Return a string representing the current activity of the backend with
4202	* the specified PID. Like the function above, but reads shared memory with
4203	* the expectation that it may be corrupt. On success, copy the string
4204	* into the "buffer" argument and return that pointer. On failure,
4205	* return NULL.
4206	*
4207	* This function is only intended to be used by the postmaster to report the
4208	* query that crashed a backend. In particular, no attempt is made to
4209	* follow the correct concurrency protocol when accessing the
4210	* BackendStatusArray. But that's OK, in the worst case we'll return a
4211	* corrupted message. We also must take care not to trip on ereport(ERROR).
4212	* ----------
4213	*/
4214	const char *
4215	pgstat_get_crashed_backend_activity(int pid, char buffer, int* buflen)
4216	{
4217	volatile PgBackendStatus *beentry;
4218	int i;
4219
4220	beentry = BackendStatusArray;
4221
4222	/*
4223	* We probably shouldn't get here before shared memory has been set up,
4224	* but be safe.
4225	*/
4226	if (beentry == NULL \|\| BackendActivityBuffer == NULL)
4227	return NULL;
4228
4229	for (i = `1`; i <= MaxBackends; i++)
4230	{
4231	if (beentry->st_procpid == pid)
4232	{
4233	/ Read pointer just once, so it can't change after validation /
4234	const char *activity = beentry->st_activity_raw;
4235	const char *activity_last;
4236
4237	/*
4238	* We mustn't access activity string before we verify that it
4239	* falls within the BackendActivityBuffer. To make sure that the
4240	* entire string including its ending is contained within the
4241	* buffer, subtract one activity length from the buffer size.
4242	*/
4243	activity_last = BackendActivityBuffer + BackendActivityBufferSize
4244	- pgstat_track_activity_query_size;
4245
4246	if (activity < BackendActivityBuffer \|\|
4247	activity > activity_last)
4248	return NULL;
4249
4250	/ If no string available, no point in a report /
4251	if (activity[`0`] == `'\0'`)
4252	return NULL;
4253
4254	/*
4255	* Copy only ASCII-safe characters so we don't run into encoding
4256	* problems when reporting the message; and be sure not to run off
4257	* the end of memory. As only ASCII characters are reported, it
4258	* doesn't seem necessary to perform multibyte aware clipping.
4259	*/
4260	ascii_safe_strlcpy(buffer, activity,
4261	Min(buflen, pgstat_track_activity_query_size));
4262
4263	return buffer;
4264	}
4265
4266	beentry++;
4267	}
4268
4269	/ PID not found /
4270	return NULL;
4271	}
4272
4273	const char *
4274	pgstat_get_backend_desc(BackendType backendType)
4275	{
4276	const char *backendDesc = "unknown process type";
4277
4278	switch (backendType)
4279	{
4280	case B_AUTOVAC_LAUNCHER:
4281	backendDesc = "autovacuum launcher";
4282	break;
4283	case B_AUTOVAC_WORKER:
4284	backendDesc = "autovacuum worker";
4285	break;
4286	case B_BACKEND:
4287	backendDesc = "client backend";
4288	break;
4289	case B_BG_WORKER:
4290	backendDesc = "background worker";
4291	break;
4292	case B_BG_WRITER:
4293	backendDesc = "background writer";
4294	break;
4295	case B_CHECKPOINTER:
4296	backendDesc = "checkpointer";
4297	break;
4298	case B_STARTUP:
4299	backendDesc = "startup";
4300	break;
4301	case B_WAL_RECEIVER:
4302	backendDesc = "walreceiver";
4303	break;
4304	case B_WAL_SENDER:
4305	backendDesc = "walsender";
4306	break;
4307	case B_WAL_WRITER:
4308	backendDesc = "walwriter";
4309	break;
4310	}
4311
4312	return backendDesc;
4313	}
4314
4315	/ ------------------------------------------------------------*
4316	* Local support functions follow
4317	* ------------------------------------------------------------
4318	*/
4319
4320
4321	/ ----------*
4322	* pgstat_setheader() -
4323	*
4324	* Set common header fields in a statistics message
4325	* ----------
4326	*/
4327	static void
4328	pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
4329	{
4330	hdr->m_type = mtype;
4331	}
4332
4333
4334	/ ----------*
4335	* pgstat_send() -
4336	*
4337	* Send out one statistics message to the collector
4338	* ----------
4339	*/
4340	static void
4341	pgstat_send(void msg, int* len)
4342	{
4343	int rc;
4344
4345	if (pgStatSock == PGINVALID_SOCKET)
4346	return;
4347
4348	((PgStat_MsgHdr *) msg)->m_size = len;
4349
4350	/ We'll retry after EINTR, but ignore all other failures /
4351	do
4352	{
4353	rc = send(pgStatSock, msg, len, `0`);
4354	} while (rc < `0` && errno == EINTR);
4355
4356	#ifdef USE_ASSERT_CHECKING
4357	/ In debug builds, log send failures ... /
4358	if (rc < `0`)
4359	elog(LOG, "could not send to statistics collector: %m");
4360	#endif
4361	}
4362
4363	/ ----------*
4364	* pgstat_send_archiver() -
4365	*
4366	* Tell the collector about the WAL file that we successfully
4367	* archived or failed to archive.
4368	* ----------
4369	*/
4370	void
4371	pgstat_send_archiver(const char *xlog, bool failed)
4372	{
4373	PgStat_MsgArchiver msg;
4374
4375	/*
4376	* Prepare and send the message
4377	*/
4378	pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ARCHIVER);
4379	msg.m_failed = failed;
4380	StrNCpy(msg.m_xlog, xlog, sizeof(msg.m_xlog));
4381	msg.m_timestamp = GetCurrentTimestamp();
4382	pgstat_send(&msg, sizeof(msg));
4383	}
4384
4385	/ ----------*
4386	* pgstat_send_bgwriter() -
4387	*
4388	* Send bgwriter statistics to the collector
4389	* ----------
4390	*/
4391	void
4392	pgstat_send_bgwriter(void)
4393	{
4394	/ We assume this initializes to zeroes /
4395	static const PgStat_MsgBgWriter all_zeroes;
4396
4397	/*
4398	* This function can be called even if nothing at all has happened. In
4399	* this case, avoid sending a completely empty message to the stats
4400	* collector.
4401	*/
4402	if (memcmp(&BgWriterStats, &all_zeroes, sizeof(PgStat_MsgBgWriter)) == `0`)
4403	return;
4404
4405	/*
4406	* Prepare and send the message
4407	*/
4408	pgstat_setheader(&BgWriterStats.m_hdr, PGSTAT_MTYPE_BGWRITER);
4409	pgstat_send(&BgWriterStats, sizeof(BgWriterStats));
4410
4411	/*
4412	* Clear out the statistics buffer, so it can be re-used.
4413	*/
4414	MemSet(&BgWriterStats, `0`, sizeof(BgWriterStats));
4415	}
4416
4417
4418	/ ----------*
4419	* PgstatCollectorMain() -
4420	*
4421	* Start up the statistics collector process. This is the body of the
4422	* postmaster child process.
4423	*
4424	* The argc/argv parameters are valid only in EXEC_BACKEND case.
4425	* ----------
4426	*/
4427	NON_EXEC_STATIC void
4428	PgstatCollectorMain(int argc, char *argv[])
4429	{
4430	int len;
4431	PgStat_Msg msg;
4432	int wr;
4433
4434	/*
4435	* Ignore all signals usually bound to some action in the postmaster,
4436	* except SIGHUP and SIGQUIT. Note we don't need a SIGUSR1 handler to
4437	* support latch operations, because we only use a local latch.
4438	*/
4439	pqsignal(SIGHUP, pgstat_sighup_handler);
4440	pqsignal(SIGINT, SIG_IGN);
4441	pqsignal(SIGTERM, SIG_IGN);
4442	pqsignal(SIGQUIT, pgstat_exit);
4443	pqsignal(SIGALRM, SIG_IGN);
4444	pqsignal(SIGPIPE, SIG_IGN);
4445	pqsignal(SIGUSR1, SIG_IGN);
4446	pqsignal(SIGUSR2, SIG_IGN);
4447	/ Reset some signals that are accepted by postmaster but not here /
4448	pqsignal(SIGCHLD, SIG_DFL);
4449	PG_SETMASK(&UnBlockSig);
4450
4451	/*
4452	* Identify myself via ps
4453	*/
4454	init_ps_display("stats collector", "", "", "");
4455
4456	/*
4457	* Read in existing stats files or initialize the stats to zero.
4458	*/
4459	pgStatRunningInCollector = true;
4460	pgStatDBHash = pgstat_read_statsfiles(InvalidOid, true, true);
4461
4462	/*
4463	* Loop to process messages until we get SIGQUIT or detect ungraceful
4464	* death of our parent postmaster.
4465	*
4466	* For performance reasons, we don't want to do ResetLatch/WaitLatch after
4467	* every message; instead, do that only after a recv() fails to obtain a
4468	* message. (This effectively means that if backends are sending us stuff
4469	* like mad, we won't notice postmaster death until things slack off a
4470	* bit; which seems fine.) To do that, we have an inner loop that
4471	* iterates as long as recv() succeeds. We do recognize got_SIGHUP inside
4472	* the inner loop, which means that such interrupts will get serviced but
4473	* the latch won't get cleared until next time there is a break in the
4474	* action.
4475	*/
4476	for (;;)
4477	{
4478	/ Clear any already-pending wakeups /
4479	ResetLatch(MyLatch);
4480
4481	/*
4482	* Quit if we get SIGQUIT from the postmaster.
4483	*/
4484	if (need_exit)
4485	break;
4486
4487	/*
4488	* Inner loop iterates as long as we keep getting messages, or until
4489	* need_exit becomes set.
4490	*/
4491	while (!need_exit)
4492	{
4493	/*
4494	* Reload configuration if we got SIGHUP from the postmaster.
4495	*/
4496	if (got_SIGHUP)
4497	{
4498	got_SIGHUP = false;
4499	ProcessConfigFile(PGC_SIGHUP);
4500	}
4501
4502	/*
4503	* Write the stats file(s) if a new request has arrived that is
4504	* not satisfied by existing file(s).
4505	*/
4506	if (pgstat_write_statsfile_needed())
4507	pgstat_write_statsfiles(false, false);
4508
4509	/*
4510	* Try to receive and process a message. This will not block,
4511	* since the socket is set to non-blocking mode.
4512	*
4513	* XXX On Windows, we have to force pgwin32_recv to cooperate,
4514	* despite the previous use of pg_set_noblock() on the socket.
4515	* This is extremely broken and should be fixed someday.
4516	*/
4517	#ifdef WIN32
4518	pgwin32_noblock = `1`;
4519	#endif
4520
4521	len = recv(pgStatSock, (char *) &msg,
4522	sizeof(PgStat_Msg), `0`);
4523
4524	#ifdef WIN32
4525	pgwin32_noblock = `0`;
4526	#endif
4527
4528	if (len < `0`)
4529	{
4530	if (errno == EAGAIN \|\| errno == EWOULDBLOCK \|\| errno == EINTR)
4531	break; / out of inner loop /
4532	ereport(ERROR,
4533	(errcode_for_socket_access(),
4534	errmsg("could not read statistics message: %m")));
4535	}
4536
4537	/*
4538	* We ignore messages that are smaller than our common header
4539	*/
4540	if (len < sizeof(PgStat_MsgHdr))
4541	continue;
4542
4543	/*
4544	* The received length must match the length in the header
4545	*/
4546	if (msg.msg_hdr.m_size != len)
4547	continue;
4548
4549	/*
4550	* O.K. - we accept this message. Process it.
4551	*/
4552	switch (msg.msg_hdr.m_type)
4553	{
4554	case PGSTAT_MTYPE_DUMMY:
4555	break;
4556
4557	case PGSTAT_MTYPE_INQUIRY:
4558	pgstat_recv_inquiry(&msg.msg_inquiry, len);
4559	break;
4560
4561	case PGSTAT_MTYPE_TABSTAT:
4562	pgstat_recv_tabstat(&msg.msg_tabstat, len);
4563	break;
4564
4565	case PGSTAT_MTYPE_TABPURGE:
4566	pgstat_recv_tabpurge(&msg.msg_tabpurge, len);
4567	break;
4568
4569	case PGSTAT_MTYPE_DROPDB:
4570	pgstat_recv_dropdb(&msg.msg_dropdb, len);
4571	break;
4572
4573	case PGSTAT_MTYPE_RESETCOUNTER:
4574	pgstat_recv_resetcounter(&msg.msg_resetcounter, len);
4575	break;
4576
4577	case PGSTAT_MTYPE_RESETSHAREDCOUNTER:
4578	pgstat_recv_resetsharedcounter(
4579	&msg.msg_resetsharedcounter,
4580	len);
4581	break;
4582
4583	case PGSTAT_MTYPE_RESETSINGLECOUNTER:
4584	pgstat_recv_resetsinglecounter(
4585	&msg.msg_resetsinglecounter,
4586	len);
4587	break;
4588
4589	case PGSTAT_MTYPE_AUTOVAC_START:
4590	pgstat_recv_autovac(&msg.msg_autovacuum_start, len);
4591	break;
4592
4593	case PGSTAT_MTYPE_VACUUM:
4594	pgstat_recv_vacuum(&msg.msg_vacuum, len);
4595	break;
4596
4597	case PGSTAT_MTYPE_ANALYZE:
4598	pgstat_recv_analyze(&msg.msg_analyze, len);
4599	break;
4600
4601	case PGSTAT_MTYPE_ARCHIVER:
4602	pgstat_recv_archiver(&msg.msg_archiver, len);
4603	break;
4604
4605	case PGSTAT_MTYPE_BGWRITER:
4606	pgstat_recv_bgwriter(&msg.msg_bgwriter, len);
4607	break;
4608
4609	case PGSTAT_MTYPE_FUNCSTAT:
4610	pgstat_recv_funcstat(&msg.msg_funcstat, len);
4611	break;
4612
4613	case PGSTAT_MTYPE_FUNCPURGE:
4614	pgstat_recv_funcpurge(&msg.msg_funcpurge, len);
4615	break;
4616
4617	case PGSTAT_MTYPE_RECOVERYCONFLICT:
4618	pgstat_recv_recoveryconflict(
4619	&msg.msg_recoveryconflict,
4620	len);
4621	break;
4622
4623	case PGSTAT_MTYPE_DEADLOCK:
4624	pgstat_recv_deadlock(&msg.msg_deadlock, len);
4625	break;
4626
4627	case PGSTAT_MTYPE_TEMPFILE:
4628	pgstat_recv_tempfile(&msg.msg_tempfile, len);
4629	break;
4630
4631	case PGSTAT_MTYPE_CHECKSUMFAILURE:
4632	pgstat_recv_checksum_failure(
4633	&msg.msg_checksumfailure,
4634	len);
4635	break;
4636
4637	default:
4638	break;
4639	}
4640	} / end of inner message-processing loop /
4641
4642	/ Sleep until there's something to do /
4643	#ifndef WIN32
4644	wr = WaitLatchOrSocket(MyLatch,
4645	WL_LATCH_SET \| WL_POSTMASTER_DEATH \| WL_SOCKET_READABLE,
4646	pgStatSock, -`1L`,
4647	WAIT_EVENT_PGSTAT_MAIN);
4648	#else
4649
4650	/*
4651	* Windows, at least in its Windows Server 2003 R2 incarnation,
4652	* sometimes loses FD_READ events. Waking up and retrying the recv()
4653	* fixes that, so don't sleep indefinitely. This is a crock of the
4654	* first water, but until somebody wants to debug exactly what's
4655	* happening there, this is the best we can do. The two-second
4656	* timeout matches our pre-9.2 behavior, and needs to be short enough
4657	* to not provoke "using stale statistics" complaints from
4658	* backend_read_statsfile.
4659	*/
4660	wr = WaitLatchOrSocket(MyLatch,
4661	WL_LATCH_SET \| WL_POSTMASTER_DEATH \| WL_SOCKET_READABLE \| WL_TIMEOUT,
4662	pgStatSock,
4663	`2` * `1000L` / msec / ,
4664	WAIT_EVENT_PGSTAT_MAIN);
4665	#endif
4666
4667	/*
4668	* Emergency bailout if postmaster has died. This is to avoid the
4669	* necessity for manual cleanup of all postmaster children.
4670	*/
4671	if (wr & WL_POSTMASTER_DEATH)
4672	break;
4673	} / end of outer loop /
4674
4675	/*
4676	* Save the final stats to reuse at next startup.
4677	*/
4678	pgstat_write_statsfiles(true, true);
4679
4680	exit(`0`);
4681	}
4682
4683
4684	/ SIGQUIT signal handler for collector process /
4685	static void
4686	pgstat_exit(SIGNAL_ARGS)
4687	{
4688	int save_errno = errno;
4689
4690	need_exit = true;
4691	SetLatch(MyLatch);
4692
4693	errno = save_errno;
4694	}
4695
4696	/ SIGHUP handler for collector process /
4697	static void
4698	pgstat_sighup_handler(SIGNAL_ARGS)
4699	{
4700	int save_errno = errno;
4701
4702	got_SIGHUP = true;
4703	SetLatch(MyLatch);
4704
4705	errno = save_errno;
4706	}
4707
4708	/*
4709	* Subroutine to clear stats in a database entry
4710	*
4711	* Tables and functions hashes are initialized to empty.
4712	*/
4713	static void
4714	reset_dbentry_counters(PgStat_StatDBEntry *dbentry)
4715	{
4716	HASHCTL hash_ctl;
4717
4718	dbentry->n_xact_commit = `0`;
4719	dbentry->n_xact_rollback = `0`;
4720	dbentry->n_blocks_fetched = `0`;
4721	dbentry->n_blocks_hit = `0`;
4722	dbentry->n_tuples_returned = `0`;
4723	dbentry->n_tuples_fetched = `0`;
4724	dbentry->n_tuples_inserted = `0`;
4725	dbentry->n_tuples_updated = `0`;
4726	dbentry->n_tuples_deleted = `0`;
4727	dbentry->last_autovac_time = `0`;
4728	dbentry->n_conflict_tablespace = `0`;
4729	dbentry->n_conflict_lock = `0`;
4730	dbentry->n_conflict_snapshot = `0`;
4731	dbentry->n_conflict_bufferpin = `0`;
4732	dbentry->n_conflict_startup_deadlock = `0`;
4733	dbentry->n_temp_files = `0`;
4734	dbentry->n_temp_bytes = `0`;
4735	dbentry->n_deadlocks = `0`;
4736	dbentry->n_checksum_failures = `0`;
4737	dbentry->last_checksum_failure = `0`;
4738	dbentry->n_block_read_time = `0`;
4739	dbentry->n_block_write_time = `0`;
4740
4741	dbentry->stat_reset_timestamp = GetCurrentTimestamp();
4742	dbentry->stats_timestamp = `0`;
4743
4744	memset(&hash_ctl, `0`, sizeof(hash_ctl));
4745	hash_ctl.keysize = sizeof(Oid);
4746	hash_ctl.entrysize = sizeof(PgStat_StatTabEntry);
4747	dbentry->tables = hash_create("Per-database table",
4748	PGSTAT_TAB_HASH_SIZE,
4749	&hash_ctl,
4750	HASH_ELEM \| HASH_BLOBS);
4751
4752	hash_ctl.keysize = sizeof(Oid);
4753	hash_ctl.entrysize = sizeof(PgStat_StatFuncEntry);
4754	dbentry->functions = hash_create("Per-database function",
4755	PGSTAT_FUNCTION_HASH_SIZE,
4756	&hash_ctl,
4757	HASH_ELEM \| HASH_BLOBS);
4758	}
4759
4760	/*
4761	* Lookup the hash table entry for the specified database. If no hash
4762	* table entry exists, initialize it, if the create parameter is true.
4763	* Else, return NULL.
4764	*/
4765	static PgStat_StatDBEntry *
4766	pgstat_get_db_entry(Oid databaseid, bool create)
4767	{
4768	PgStat_StatDBEntry *result;
4769	bool found;
4770	HASHACTION action = (create ? HASH_ENTER : HASH_FIND);
4771
4772	/ Lookup or create the hash table entry for this database /
4773	result = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
4774	&databaseid,
4775	action, &found);
4776
4777	if (!create && !found)
4778	return NULL;
4779
4780	/*
4781	* If not found, initialize the new one. This creates empty hash tables
4782	* for tables and functions, too.
4783	*/
4784	if (!found)
4785	reset_dbentry_counters(result);
4786
4787	return result;
4788	}
4789
4790
4791	/*
4792	* Lookup the hash table entry for the specified table. If no hash
4793	* table entry exists, initialize it, if the create parameter is true.
4794	* Else, return NULL.
4795	*/
4796	static PgStat_StatTabEntry *
4797	pgstat_get_tab_entry(PgStat_StatDBEntry *dbentry, Oid tableoid, bool create)
4798	{
4799	PgStat_StatTabEntry *result;
4800	bool found;
4801	HASHACTION action = (create ? HASH_ENTER : HASH_FIND);
4802
4803	/ Lookup or create the hash table entry for this table /
4804	result = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
4805	&tableoid,
4806	action, &found);
4807
4808	if (!create && !found)
4809	return NULL;
4810
4811	/ If not found, initialize the new one. /
4812	if (!found)
4813	{
4814	result->numscans = `0`;
4815	result->tuples_returned = `0`;
4816	result->tuples_fetched = `0`;
4817	result->tuples_inserted = `0`;
4818	result->tuples_updated = `0`;
4819	result->tuples_deleted = `0`;
4820	result->tuples_hot_updated = `0`;
4821	result->n_live_tuples = `0`;
4822	result->n_dead_tuples = `0`;
4823	result->changes_since_analyze = `0`;
4824	result->blocks_fetched = `0`;
4825	result->blocks_hit = `0`;
4826	result->vacuum_timestamp = `0`;
4827	result->vacuum_count = `0`;
4828	result->autovac_vacuum_timestamp = `0`;
4829	result->autovac_vacuum_count = `0`;
4830	result->analyze_timestamp = `0`;
4831	result->analyze_count = `0`;
4832	result->autovac_analyze_timestamp = `0`;
4833	result->autovac_analyze_count = `0`;
4834	}
4835
4836	return result;
4837	}
4838
4839
4840	/ ----------*
4841	* pgstat_write_statsfiles() -
4842	* Write the global statistics file, as well as requested DB files.
4843	*
4844	* 'permanent' specifies writing to the permanent files not temporary ones.
4845	* When true (happens only when the collector is shutting down), also remove
4846	* the temporary files so that backends starting up under a new postmaster
4847	* can't read old data before the new collector is ready.
4848	*
4849	* When 'allDbs' is false, only the requested databases (listed in
4850	* pending_write_requests) will be written; otherwise, all databases
4851	* will be written.
4852	* ----------
4853	*/
4854	static void
4855	pgstat_write_statsfiles(bool permanent, bool allDbs)
4856	{
4857	HASH_SEQ_STATUS hstat;
4858	PgStat_StatDBEntry *dbentry;
4859	FILE *fpout;
4860	int32 format_id;
4861	const char *tmpfile = permanent ? PGSTAT_STAT_PERMANENT_TMPFILE : pgstat_stat_tmpname;
4862	const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
4863	int rc;
4864
4865	elog(DEBUG2, "writing stats file \"%s\"", statfile);
4866
4867	/*
4868	* Open the statistics temp file to write out the current values.
4869	*/
4870	fpout = AllocateFile(tmpfile, PG_BINARY_W);
4871	if (fpout == NULL)
4872	{
4873	ereport(LOG,
4874	(errcode_for_file_access(),
4875	errmsg("could not open temporary statistics file \"%s\": %m",
4876	tmpfile)));
4877	return;
4878	}
4879
4880	/*
4881	* Set the timestamp of the stats file.
4882	*/
4883	globalStats.stats_timestamp = GetCurrentTimestamp();
4884
4885	/*
4886	* Write the file header --- currently just a format ID.
4887	*/
4888	format_id = PGSTAT_FILE_FORMAT_ID;
4889	rc = fwrite(&format_id, sizeof(format_id), `1`, fpout);
4890	(void) rc; / we'll check for error with ferror /
4891
4892	/*
4893	* Write global stats struct
4894	*/
4895	rc = fwrite(&globalStats, sizeof(globalStats), `1`, fpout);
4896	(void) rc; / we'll check for error with ferror /
4897
4898	/*
4899	* Write archiver stats struct
4900	*/
4901	rc = fwrite(&archiverStats, sizeof(archiverStats), `1`, fpout);
4902	(void) rc; / we'll check for error with ferror /
4903
4904	/*
4905	* Walk through the database table.
4906	*/
4907	hash_seq_init(&hstat, pgStatDBHash);
4908	while ((dbentry = (PgStat_StatDBEntry *) hash_seq_search(&hstat)) != NULL)
4909	{
4910	/*
4911	* Write out the table and function stats for this DB into the
4912	* appropriate per-DB stat file, if required.
4913	*/
4914	if (allDbs \|\| pgstat_db_requested(dbentry->databaseid))
4915	{
4916	/ Make DB's timestamp consistent with the global stats /
4917	dbentry->stats_timestamp = globalStats.stats_timestamp;
4918
4919	pgstat_write_db_statsfile(dbentry, permanent);
4920	}
4921
4922	/*
4923	* Write out the DB entry. We don't write the tables or functions
4924	* pointers, since they're of no use to any other process.
4925	*/
4926	fputc(`'D'`, fpout);
4927	rc = fwrite(dbentry, offsetof(PgStat_StatDBEntry, tables), `1`, fpout);
4928	(void) rc; / we'll check for error with ferror /
4929	}
4930
4931	/*
4932	* No more output to be done. Close the temp file and replace the old
4933	* pgstat.stat with it. The ferror() check replaces testing for error
4934	* after each individual fputc or fwrite above.
4935	*/
4936	fputc(`'E'`, fpout);
4937
4938	if (ferror(fpout))
4939	{
4940	ereport(LOG,
4941	(errcode_for_file_access(),
4942	errmsg("could not write temporary statistics file \"%s\": %m",
4943	tmpfile)));
4944	FreeFile(fpout);
4945	unlink(tmpfile);
4946	}
4947	else if (FreeFile(fpout) < `0`)
4948	{
4949	ereport(LOG,
4950	(errcode_for_file_access(),
4951	errmsg("could not close temporary statistics file \"%s\": %m",
4952	tmpfile)));
4953	unlink(tmpfile);
4954	}
4955	else if (rename(tmpfile, statfile) < `0`)
4956	{
4957	ereport(LOG,
4958	(errcode_for_file_access(),
4959	errmsg("could not rename temporary statistics file \"%s\" to \"%s\": %m",
4960	tmpfile, statfile)));
4961	unlink(tmpfile);
4962	}
4963
4964	if (permanent)
4965	unlink(pgstat_stat_filename);
4966
4967	/*
4968	* Now throw away the list of requests. Note that requests sent after we
4969	* started the write are still waiting on the network socket.
4970	*/
4971	list_free(pending_write_requests);
4972	pending_write_requests = NIL;
4973	}
4974
4975	/*
4976	* return the filename for a DB stat file; filename is the output buffer,
4977	* of length len.
4978	*/
4979	static void
4980	get_dbstat_filename(bool permanent, bool tempname, Oid databaseid,
4981	char filename, int* len)
4982	{
4983	int printed;
4984
4985	/ NB -- pgstat_reset_remove_files knows about the pattern this uses /
4986	printed = snprintf(filename, len, "%s/db_%u.%s",
4987	permanent ? PGSTAT_STAT_PERMANENT_DIRECTORY :
4988	pgstat_stat_directory,
4989	databaseid,
4990	tempname ? "tmp" : "stat");
4991	if (printed >= len)
4992	elog(ERROR, "overlength pgstat path");
4993	}
4994
4995	/ ----------*
4996	* pgstat_write_db_statsfile() -
4997	* Write the stat file for a single database.
4998	*
4999	* If writing to the permanent file (happens when the collector is
5000	* shutting down only), remove the temporary file so that backends
5001	* starting up under a new postmaster can't read the old data before
5002	* the new collector is ready.
5003	* ----------
5004	*/
5005	static void
5006	pgstat_write_db_statsfile(PgStat_StatDBEntry *dbentry, bool permanent)
5007	{
5008	HASH_SEQ_STATUS tstat;
5009	HASH_SEQ_STATUS fstat;
5010	PgStat_StatTabEntry *tabentry;
5011	PgStat_StatFuncEntry *funcentry;
5012	FILE *fpout;
5013	int32 format_id;
5014	Oid dbid = dbentry->databaseid;
5015	int rc;
5016	char tmpfile[MAXPGPATH];
5017	char statfile[MAXPGPATH];
5018
5019	get_dbstat_filename(permanent, true, dbid, tmpfile, MAXPGPATH);
5020	get_dbstat_filename(permanent, false, dbid, statfile, MAXPGPATH);
5021
5022	elog(DEBUG2, "writing stats file \"%s\"", statfile);
5023
5024	/*
5025	* Open the statistics temp file to write out the current values.
5026	*/
5027	fpout = AllocateFile(tmpfile, PG_BINARY_W);
5028	if (fpout == NULL)
5029	{
5030	ereport(LOG,
5031	(errcode_for_file_access(),
5032	errmsg("could not open temporary statistics file \"%s\": %m",
5033	tmpfile)));
5034	return;
5035	}
5036
5037	/*
5038	* Write the file header --- currently just a format ID.
5039	*/
5040	format_id = PGSTAT_FILE_FORMAT_ID;
5041	rc = fwrite(&format_id, sizeof(format_id), `1`, fpout);
5042	(void) rc; / we'll check for error with ferror /
5043
5044	/*
5045	* Walk through the database's access stats per table.
5046	*/
5047	hash_seq_init(&tstat, dbentry->tables);
5048	while ((tabentry = (PgStat_StatTabEntry *) hash_seq_search(&tstat)) != NULL)
5049	{
5050	fputc(`'T'`, fpout);
5051	rc = fwrite(tabentry, sizeof(PgStat_StatTabEntry), `1`, fpout);
5052	(void) rc; / we'll check for error with ferror /
5053	}
5054
5055	/*
5056	* Walk through the database's function stats table.
5057	*/
5058	hash_seq_init(&fstat, dbentry->functions);
5059	while ((funcentry = (PgStat_StatFuncEntry *) hash_seq_search(&fstat)) != NULL)
5060	{
5061	fputc(`'F'`, fpout);
5062	rc = fwrite(funcentry, sizeof(PgStat_StatFuncEntry), `1`, fpout);
5063	(void) rc; / we'll check for error with ferror /
5064	}
5065
5066	/*
5067	* No more output to be done. Close the temp file and replace the old
5068	* pgstat.stat with it. The ferror() check replaces testing for error
5069	* after each individual fputc or fwrite above.
5070	*/
5071	fputc(`'E'`, fpout);
5072
5073	if (ferror(fpout))
5074	{
5075	ereport(LOG,
5076	(errcode_for_file_access(),
5077	errmsg("could not write temporary statistics file \"%s\": %m",
5078	tmpfile)));
5079	FreeFile(fpout);
5080	unlink(tmpfile);
5081	}
5082	else if (FreeFile(fpout) < `0`)
5083	{
5084	ereport(LOG,
5085	(errcode_for_file_access(),
5086	errmsg("could not close temporary statistics file \"%s\": %m",
5087	tmpfile)));
5088	unlink(tmpfile);
5089	}
5090	else if (rename(tmpfile, statfile) < `0`)
5091	{
5092	ereport(LOG,
5093	(errcode_for_file_access(),
5094	errmsg("could not rename temporary statistics file \"%s\" to \"%s\": %m",
5095	tmpfile, statfile)));
5096	unlink(tmpfile);
5097	}
5098
5099	if (permanent)
5100	{
5101	get_dbstat_filename(false, false, dbid, statfile, MAXPGPATH);
5102
5103	elog(DEBUG2, "removing temporary stats file \"%s\"", statfile);
5104	unlink(statfile);
5105	}
5106	}
5107
5108	/ ----------*
5109	* pgstat_read_statsfiles() -
5110	*
5111	* Reads in some existing statistics collector files and returns the
5112	* databases hash table that is the top level of the data.
5113	*
5114	* If 'onlydb' is not InvalidOid, it means we only want data for that DB
5115	* plus the shared catalogs ("DB 0"). We'll still populate the DB hash
5116	* table for all databases, but we don't bother even creating table/function
5117	* hash tables for other databases.
5118	*
5119	* 'permanent' specifies reading from the permanent files not temporary ones.
5120	* When true (happens only when the collector is starting up), remove the
5121	* files after reading; the in-memory status is now authoritative, and the
5122	* files would be out of date in case somebody else reads them.
5123	*
5124	* If a 'deep' read is requested, table/function stats are read, otherwise
5125	* the table/function hash tables remain empty.
5126	* ----------
5127	*/
5128	static HTAB *
5129	pgstat_read_statsfiles(Oid onlydb, bool permanent, bool deep)
5130	{
5131	PgStat_StatDBEntry *dbentry;
5132	PgStat_StatDBEntry dbbuf;
5133	HASHCTL hash_ctl;
5134	HTAB *dbhash;
5135	FILE *fpin;
5136	int32 format_id;
5137	bool found;
5138	const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
5139
5140	/*
5141	* The tables will live in pgStatLocalContext.
5142	*/
5143	pgstat_setup_memcxt();
5144
5145	/*
5146	* Create the DB hashtable
5147	*/
5148	memset(&hash_ctl, `0`, sizeof(hash_ctl));
5149	hash_ctl.keysize = sizeof(Oid);
5150	hash_ctl.entrysize = sizeof(PgStat_StatDBEntry);
5151	hash_ctl.hcxt = pgStatLocalContext;
5152	dbhash = hash_create("Databases hash", PGSTAT_DB_HASH_SIZE, &hash_ctl,
5153	HASH_ELEM \| HASH_BLOBS \| HASH_CONTEXT);
5154
5155	/*
5156	* Clear out global and archiver statistics so they start from zero in
5157	* case we can't load an existing statsfile.
5158	*/
5159	memset(&globalStats, `0`, sizeof(globalStats));
5160	memset(&archiverStats, `0`, sizeof(archiverStats));
5161
5162	/*
5163	* Set the current timestamp (will be kept only in case we can't load an
5164	* existing statsfile).
5165	*/
5166	globalStats.stat_reset_timestamp = GetCurrentTimestamp();
5167	archiverStats.stat_reset_timestamp = globalStats.stat_reset_timestamp;
5168
5169	/*
5170	* Try to open the stats file. If it doesn't exist, the backends simply
5171	* return zero for anything and the collector simply starts from scratch
5172	* with empty counters.
5173	*
5174	* ENOENT is a possibility if the stats collector is not running or has
5175	* not yet written the stats file the first time. Any other failure
5176	* condition is suspicious.
5177	*/
5178	if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
5179	{
5180	if (errno != ENOENT)
5181	ereport(pgStatRunningInCollector ? LOG : WARNING,
5182	(errcode_for_file_access(),
5183	errmsg("could not open statistics file \"%s\": %m",
5184	statfile)));
5185	return dbhash;
5186	}
5187
5188	/*
5189	* Verify it's of the expected format.
5190	*/
5191	if (fread(&format_id, `1`, sizeof(format_id), fpin) != sizeof(format_id) \|\|
5192	format_id != PGSTAT_FILE_FORMAT_ID)
5193	{
5194	ereport(pgStatRunningInCollector ? LOG : WARNING,
5195	(errmsg("corrupted statistics file \"%s\"", statfile)));
5196	goto done;
5197	}
5198
5199	/*
5200	* Read global stats struct
5201	*/
5202	if (fread(&globalStats, `1`, sizeof(globalStats), fpin) != sizeof(globalStats))
5203	{
5204	ereport(pgStatRunningInCollector ? LOG : WARNING,
5205	(errmsg("corrupted statistics file \"%s\"", statfile)));
5206	memset(&globalStats, `0`, sizeof(globalStats));
5207	goto done;
5208	}
5209
5210	/*
5211	* In the collector, disregard the timestamp we read from the permanent
5212	* stats file; we should be willing to write a temp stats file immediately
5213	* upon the first request from any backend. This only matters if the old
5214	* file's timestamp is less than PGSTAT_STAT_INTERVAL ago, but that's not
5215	* an unusual scenario.
5216	*/
5217	if (pgStatRunningInCollector)
5218	globalStats.stats_timestamp = `0`;
5219
5220	/*
5221	* Read archiver stats struct
5222	*/
5223	if (fread(&archiverStats, `1`, sizeof(archiverStats), fpin) != sizeof(archiverStats))
5224	{
5225	ereport(pgStatRunningInCollector ? LOG : WARNING,
5226	(errmsg("corrupted statistics file \"%s\"", statfile)));
5227	memset(&archiverStats, `0`, sizeof(archiverStats));
5228	goto done;
5229	}
5230
5231	/*
5232	* We found an existing collector stats file. Read it and put all the
5233	* hashtable entries into place.
5234	*/
5235	for (;;)
5236	{
5237	switch (fgetc(fpin))
5238	{
5239	/*
5240	* 'D' A PgStat_StatDBEntry struct describing a database
5241	* follows.
5242	*/
5243	case `'D'`:
5244	if (fread(&dbbuf, `1`, offsetof(PgStat_StatDBEntry, tables),
5245	fpin) != offsetof(PgStat_StatDBEntry, tables))
5246	{
5247	ereport(pgStatRunningInCollector ? LOG : WARNING,
5248	(errmsg("corrupted statistics file \"%s\"",
5249	statfile)));
5250	goto done;
5251	}
5252
5253	/*
5254	* Add to the DB hash
5255	*/
5256	dbentry = (PgStat_StatDBEntry *) hash_search(dbhash,
5257	(void *) &dbbuf.databaseid,
5258	HASH_ENTER,
5259	&found);
5260	if (found)
5261	{
5262	ereport(pgStatRunningInCollector ? LOG : WARNING,
5263	(errmsg("corrupted statistics file \"%s\"",
5264	statfile)));
5265	goto done;
5266	}
5267
5268	memcpy(dbentry, &dbbuf, sizeof(PgStat_StatDBEntry));
5269	dbentry->tables = NULL;
5270	dbentry->functions = NULL;
5271
5272	/*
5273	* In the collector, disregard the timestamp we read from the
5274	* permanent stats file; we should be willing to write a temp
5275	* stats file immediately upon the first request from any
5276	* backend.
5277	*/
5278	if (pgStatRunningInCollector)
5279	dbentry->stats_timestamp = `0`;
5280
5281	/*
5282	* Don't create tables/functions hashtables for uninteresting
5283	* databases.
5284	*/
5285	if (onlydb != InvalidOid)
5286	{
5287	if (dbbuf.databaseid != onlydb &&
5288	dbbuf.databaseid != InvalidOid)
5289	break;
5290	}
5291
5292	memset(&hash_ctl, `0`, sizeof(hash_ctl));
5293	hash_ctl.keysize = sizeof(Oid);
5294	hash_ctl.entrysize = sizeof(PgStat_StatTabEntry);
5295	hash_ctl.hcxt = pgStatLocalContext;
5296	dbentry->tables = hash_create("Per-database table",
5297	PGSTAT_TAB_HASH_SIZE,
5298	&hash_ctl,
5299	HASH_ELEM \| HASH_BLOBS \| HASH_CONTEXT);
5300
5301	hash_ctl.keysize = sizeof(Oid);
5302	hash_ctl.entrysize = sizeof(PgStat_StatFuncEntry);
5303	hash_ctl.hcxt = pgStatLocalContext;
5304	dbentry->functions = hash_create("Per-database function",
5305	PGSTAT_FUNCTION_HASH_SIZE,
5306	&hash_ctl,
5307	HASH_ELEM \| HASH_BLOBS \| HASH_CONTEXT);
5308
5309	/*
5310	* If requested, read the data from the database-specific
5311	* file. Otherwise we just leave the hashtables empty.
5312	*/
5313	if (deep)
5314	pgstat_read_db_statsfile(dbentry->databaseid,
5315	dbentry->tables,
5316	dbentry->functions,
5317	permanent);
5318
5319	break;
5320
5321	case `'E'`:
5322	goto done;
5323
5324	default:
5325	ereport(pgStatRunningInCollector ? LOG : WARNING,
5326	(errmsg("corrupted statistics file \"%s\"",
5327	statfile)));
5328	goto done;
5329	}
5330	}
5331
5332	done:
5333	FreeFile(fpin);
5334
5335	/ If requested to read the permanent file, also get rid of it. /
5336	if (permanent)
5337	{
5338	elog(DEBUG2, "removing permanent stats file \"%s\"", statfile);
5339	unlink(statfile);
5340	}
5341
5342	return dbhash;
5343	}
5344
5345
5346	/ ----------*
5347	* pgstat_read_db_statsfile() -
5348	*
5349	* Reads in the existing statistics collector file for the given database,
5350	* filling the passed-in tables and functions hash tables.
5351	*
5352	* As in pgstat_read_statsfiles, if the permanent file is requested, it is
5353	* removed after reading.
5354	*
5355	* Note: this code has the ability to skip storing per-table or per-function
5356	* data, if NULL is passed for the corresponding hashtable. That's not used
5357	* at the moment though.
5358	* ----------
5359	*/
5360	static void
5361	pgstat_read_db_statsfile(Oid databaseid, HTAB tabhash, HTAB funchash,
5362	bool permanent)
5363	{
5364	PgStat_StatTabEntry *tabentry;
5365	PgStat_StatTabEntry tabbuf;
5366	PgStat_StatFuncEntry funcbuf;
5367	PgStat_StatFuncEntry *funcentry;
5368	FILE *fpin;
5369	int32 format_id;
5370	bool found;
5371	char statfile[MAXPGPATH];
5372
5373	get_dbstat_filename(permanent, false, databaseid, statfile, MAXPGPATH);
5374
5375	/*
5376	* Try to open the stats file. If it doesn't exist, the backends simply
5377	* return zero for anything and the collector simply starts from scratch
5378	* with empty counters.
5379	*
5380	* ENOENT is a possibility if the stats collector is not running or has
5381	* not yet written the stats file the first time. Any other failure
5382	* condition is suspicious.
5383	*/
5384	if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
5385	{
5386	if (errno != ENOENT)
5387	ereport(pgStatRunningInCollector ? LOG : WARNING,
5388	(errcode_for_file_access(),
5389	errmsg("could not open statistics file \"%s\": %m",
5390	statfile)));
5391	return;
5392	}
5393
5394	/*
5395	* Verify it's of the expected format.
5396	*/
5397	if (fread(&format_id, `1`, sizeof(format_id), fpin) != sizeof(format_id) \|\|
5398	format_id != PGSTAT_FILE_FORMAT_ID)
5399	{
5400	ereport(pgStatRunningInCollector ? LOG : WARNING,
5401	(errmsg("corrupted statistics file \"%s\"", statfile)));
5402	goto done;
5403	}
5404
5405	/*
5406	* We found an existing collector stats file. Read it and put all the
5407	* hashtable entries into place.
5408	*/
5409	for (;;)
5410	{
5411	switch (fgetc(fpin))
5412	{
5413	/*
5414	* 'T' A PgStat_StatTabEntry follows.
5415	*/
5416	case `'T'`:
5417	if (fread(&tabbuf, `1`, sizeof(PgStat_StatTabEntry),
5418	fpin) != sizeof(PgStat_StatTabEntry))
5419	{
5420	ereport(pgStatRunningInCollector ? LOG : WARNING,
5421	(errmsg("corrupted statistics file \"%s\"",
5422	statfile)));
5423	goto done;
5424	}
5425
5426	/*
5427	* Skip if table data not wanted.
5428	*/
5429	if (tabhash == NULL)
5430	break;
5431
5432	tabentry = (PgStat_StatTabEntry *) hash_search(tabhash,
5433	(void *) &tabbuf.tableid,
5434	HASH_ENTER, &found);
5435
5436	if (found)
5437	{
5438	ereport(pgStatRunningInCollector ? LOG : WARNING,
5439	(errmsg("corrupted statistics file \"%s\"",
5440	statfile)));
5441	goto done;
5442	}
5443
5444	memcpy(tabentry, &tabbuf, sizeof(tabbuf));
5445	break;
5446
5447	/*
5448	* 'F' A PgStat_StatFuncEntry follows.
5449	*/
5450	case `'F'`:
5451	if (fread(&funcbuf, `1`, sizeof(PgStat_StatFuncEntry),
5452	fpin) != sizeof(PgStat_StatFuncEntry))
5453	{
5454	ereport(pgStatRunningInCollector ? LOG : WARNING,
5455	(errmsg("corrupted statistics file \"%s\"",
5456	statfile)));
5457	goto done;
5458	}
5459
5460	/*
5461	* Skip if function data not wanted.
5462	*/
5463	if (funchash == NULL)
5464	break;
5465
5466	funcentry = (PgStat_StatFuncEntry *) hash_search(funchash,
5467	(void *) &funcbuf.functionid,
5468	HASH_ENTER, &found);
5469
5470	if (found)
5471	{
5472	ereport(pgStatRunningInCollector ? LOG : WARNING,
5473	(errmsg("corrupted statistics file \"%s\"",
5474	statfile)));
5475	goto done;
5476	}
5477
5478	memcpy(funcentry, &funcbuf, sizeof(funcbuf));
5479	break;
5480
5481	/*
5482	* 'E' The EOF marker of a complete stats file.
5483	*/
5484	case `'E'`:
5485	goto done;
5486
5487	default:
5488	ereport(pgStatRunningInCollector ? LOG : WARNING,
5489	(errmsg("corrupted statistics file \"%s\"",
5490	statfile)));
5491	goto done;
5492	}
5493	}
5494
5495	done:
5496	FreeFile(fpin);
5497
5498	if (permanent)
5499	{
5500	elog(DEBUG2, "removing permanent stats file \"%s\"", statfile);
5501	unlink(statfile);
5502	}
5503	}
5504
5505	/ ----------*
5506	* pgstat_read_db_statsfile_timestamp() -
5507	*
5508	* Attempt to determine the timestamp of the last db statfile write.
5509	* Returns true if successful; the timestamp is stored in *ts.
5510	*
5511	* This needs to be careful about handling databases for which no stats file
5512	* exists, such as databases without a stat entry or those not yet written:
5513	*
5514	* - if there's a database entry in the global file, return the corresponding
5515	* stats_timestamp value.
5516	*
5517	* - if there's no db stat entry (e.g. for a new or inactive database),
5518	* there's no stats_timestamp value, but also nothing to write so we return
5519	* the timestamp of the global statfile.
5520	* ----------
5521	*/
5522	static bool
5523	pgstat_read_db_statsfile_timestamp(Oid databaseid, bool permanent,
5524	TimestampTz *ts)
5525	{
5526	PgStat_StatDBEntry dbentry;
5527	PgStat_GlobalStats myGlobalStats;
5528	PgStat_ArchiverStats myArchiverStats;
5529	FILE *fpin;
5530	int32 format_id;
5531	const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
5532
5533	/*
5534	* Try to open the stats file. As above, anything but ENOENT is worthy of
5535	* complaining about.
5536	*/
5537	if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
5538	{
5539	if (errno != ENOENT)
5540	ereport(pgStatRunningInCollector ? LOG : WARNING,
5541	(errcode_for_file_access(),
5542	errmsg("could not open statistics file \"%s\": %m",
5543	statfile)));
5544	return false;
5545	}
5546
5547	/*
5548	* Verify it's of the expected format.
5549	*/
5550	if (fread(&format_id, `1`, sizeof(format_id), fpin) != sizeof(format_id) \|\|
5551	format_id != PGSTAT_FILE_FORMAT_ID)
5552	{
5553	ereport(pgStatRunningInCollector ? LOG : WARNING,
5554	(errmsg("corrupted statistics file \"%s\"", statfile)));
5555	FreeFile(fpin);
5556	return false;
5557	}
5558
5559	/*
5560	* Read global stats struct
5561	*/
5562	if (fread(&myGlobalStats, `1`, sizeof(myGlobalStats),
5563	fpin) != sizeof(myGlobalStats))
5564	{
5565	ereport(pgStatRunningInCollector ? LOG : WARNING,
5566	(errmsg("corrupted statistics file \"%s\"", statfile)));
5567	FreeFile(fpin);
5568	return false;
5569	}
5570
5571	/*
5572	* Read archiver stats struct
5573	*/
5574	if (fread(&myArchiverStats, `1`, sizeof(myArchiverStats),
5575	fpin) != sizeof(myArchiverStats))
5576	{
5577	ereport(pgStatRunningInCollector ? LOG : WARNING,
5578	(errmsg("corrupted statistics file \"%s\"", statfile)));
5579	FreeFile(fpin);
5580	return false;
5581	}
5582
5583	/ By default, we're going to return the timestamp of the global file. /
5584	*ts = myGlobalStats.stats_timestamp;
5585
5586	/*
5587	* We found an existing collector stats file. Read it and look for a
5588	* record for the requested database. If found, use its timestamp.
5589	*/
5590	for (;;)
5591	{
5592	switch (fgetc(fpin))
5593	{
5594	/*
5595	* 'D' A PgStat_StatDBEntry struct describing a database
5596	* follows.
5597	*/
5598	case `'D'`:
5599	if (fread(&dbentry, `1`, offsetof(PgStat_StatDBEntry, tables),
5600	fpin) != offsetof(PgStat_StatDBEntry, tables))
5601	{
5602	ereport(pgStatRunningInCollector ? LOG : WARNING,
5603	(errmsg("corrupted statistics file \"%s\"",
5604	statfile)));
5605	goto done;
5606	}
5607
5608	/*
5609	* If this is the DB we're looking for, save its timestamp and
5610	* we're done.
5611	*/
5612	if (dbentry.databaseid == databaseid)
5613	{
5614	*ts = dbentry.stats_timestamp;
5615	goto done;
5616	}
5617
5618	break;
5619
5620	case `'E'`:
5621	goto done;
5622
5623	default:
5624	ereport(pgStatRunningInCollector ? LOG : WARNING,
5625	(errmsg("corrupted statistics file \"%s\"",
5626	statfile)));
5627	goto done;
5628	}
5629	}
5630
5631	done:
5632	FreeFile(fpin);
5633	return true;
5634	}
5635
5636	/*
5637	* If not already done, read the statistics collector stats file into
5638	* some hash tables. The results will be kept until pgstat_clear_snapshot()
5639	* is called (typically, at end of transaction).
5640	*/
5641	static void
5642	backend_read_statsfile(void)
5643	{
5644	TimestampTz min_ts = `0`;
5645	TimestampTz ref_ts = `0`;
5646	Oid inquiry_db;
5647	int count;
5648
5649	/ already read it? /
5650	if (pgStatDBHash)
5651	return;
5652	Assert(!pgStatRunningInCollector);
5653
5654	/*
5655	* In a normal backend, we check staleness of the data for our own DB, and
5656	* so we send MyDatabaseId in inquiry messages. In the autovac launcher,
5657	* check staleness of the shared-catalog data, and send InvalidOid in
5658	* inquiry messages so as not to force writing unnecessary data.
5659	*/
5660	if (IsAutoVacuumLauncherProcess())
5661	inquiry_db = InvalidOid;
5662	else
5663	inquiry_db = MyDatabaseId;
5664
5665	/*
5666	* Loop until fresh enough stats file is available or we ran out of time.
5667	* The stats inquiry message is sent repeatedly in case collector drops
5668	* it; but not every single time, as that just swamps the collector.
5669	*/
5670	for (count = `0`; count < PGSTAT_POLL_LOOP_COUNT; count++)
5671	{
5672	bool ok;
5673	TimestampTz file_ts = `0`;
5674	TimestampTz cur_ts;
5675
5676	CHECK_FOR_INTERRUPTS();
5677
5678	ok = pgstat_read_db_statsfile_timestamp(inquiry_db, false, &file_ts);
5679
5680	cur_ts = GetCurrentTimestamp();
5681	/ Calculate min acceptable timestamp, if we didn't already /
5682	if (count == `0` \|\| cur_ts < ref_ts)
5683	{
5684	/*
5685	* We set the minimum acceptable timestamp to PGSTAT_STAT_INTERVAL
5686	* msec before now. This indirectly ensures that the collector
5687	* needn't write the file more often than PGSTAT_STAT_INTERVAL. In
5688	* an autovacuum worker, however, we want a lower delay to avoid
5689	* using stale data, so we use PGSTAT_RETRY_DELAY (since the
5690	* number of workers is low, this shouldn't be a problem).
5691	*
5692	* We don't recompute min_ts after sleeping, except in the
5693	* unlikely case that cur_ts went backwards. So we might end up
5694	* accepting a file a bit older than PGSTAT_STAT_INTERVAL. In
5695	* practice that shouldn't happen, though, as long as the sleep
5696	* time is less than PGSTAT_STAT_INTERVAL; and we don't want to
5697	* tell the collector that our cutoff time is less than what we'd
5698	* actually accept.
5699	*/
5700	ref_ts = cur_ts;
5701	if (IsAutoVacuumWorkerProcess())
5702	min_ts = TimestampTzPlusMilliseconds(ref_ts,
5703	-PGSTAT_RETRY_DELAY);
5704	else
5705	min_ts = TimestampTzPlusMilliseconds(ref_ts,
5706	-PGSTAT_STAT_INTERVAL);
5707	}
5708
5709	/*
5710	* If the file timestamp is actually newer than cur_ts, we must have
5711	* had a clock glitch (system time went backwards) or there is clock
5712	* skew between our processor and the stats collector's processor.
5713	* Accept the file, but send an inquiry message anyway to make
5714	* pgstat_recv_inquiry do a sanity check on the collector's time.
5715	*/
5716	if (ok && file_ts > cur_ts)
5717	{
5718	/*
5719	* A small amount of clock skew between processors isn't terribly
5720	* surprising, but a large difference is worth logging. We
5721	* arbitrarily define "large" as 1000 msec.
5722	*/
5723	if (file_ts >= TimestampTzPlusMilliseconds(cur_ts, `1000`))
5724	{
5725	char *filetime;
5726	char *mytime;
5727
5728	/ Copy because timestamptz_to_str returns a static buffer /
5729	filetime = pstrdup(timestamptz_to_str(file_ts));
5730	mytime = pstrdup(timestamptz_to_str(cur_ts));
5731	elog(LOG, "stats collector's time %s is later than backend local time %s",
5732	filetime, mytime);
5733	pfree(filetime);
5734	pfree(mytime);
5735	}
5736
5737	pgstat_send_inquiry(cur_ts, min_ts, inquiry_db);
5738	break;
5739	}
5740
5741	/ Normal acceptance case: file is not older than cutoff time /
5742	if (ok && file_ts >= min_ts)
5743	break;
5744
5745	/ Not there or too old, so kick the collector and wait a bit /
5746	if ((count % PGSTAT_INQ_LOOP_COUNT) == `0`)
5747	pgstat_send_inquiry(cur_ts, min_ts, inquiry_db);
5748
5749	pg_usleep(PGSTAT_RETRY_DELAY * `1000L`);
5750	}
5751
5752	if (count >= PGSTAT_POLL_LOOP_COUNT)
5753	ereport(LOG,
5754	(errmsg("using stale statistics instead of current ones "
5755	"because stats collector is not responding")));
5756
5757	/*
5758	* Autovacuum launcher wants stats about all databases, but a shallow read
5759	* is sufficient. Regular backends want a deep read for just the tables
5760	* they can see (MyDatabaseId + shared catalogs).
5761	*/
5762	if (IsAutoVacuumLauncherProcess())
5763	pgStatDBHash = pgstat_read_statsfiles(InvalidOid, false, false);
5764	else
5765	pgStatDBHash = pgstat_read_statsfiles(MyDatabaseId, false, true);
5766	}
5767
5768
5769	/ ----------*
5770	* pgstat_setup_memcxt() -
5771	*
5772	* Create pgStatLocalContext, if not already done.
5773	* ----------
5774	*/
5775	static void
5776	pgstat_setup_memcxt(void)
5777	{
5778	if (!pgStatLocalContext)
5779	pgStatLocalContext = AllocSetContextCreate(TopMemoryContext,
5780	"Statistics snapshot",
5781	ALLOCSET_SMALL_SIZES);
5782	}
5783
5784
5785	/ ----------*
5786	* pgstat_clear_snapshot() -
5787	*
5788	* Discard any data collected in the current transaction. Any subsequent
5789	* request will cause new snapshots to be read.
5790	*
5791	* This is also invoked during transaction commit or abort to discard
5792	* the no-longer-wanted snapshot.
5793	* ----------
5794	*/
5795	void
5796	pgstat_clear_snapshot(void)
5797	{
5798	/ Release memory, if any was allocated /
5799	if (pgStatLocalContext)
5800	MemoryContextDelete(pgStatLocalContext);
5801
5802	/ Reset variables /
5803	pgStatLocalContext = NULL;
5804	pgStatDBHash = NULL;
5805	localBackendStatusTable = NULL;
5806	localNumBackends = `0`;
5807	}
5808
5809
5810	/ ----------*
5811	* pgstat_recv_inquiry() -
5812	*
5813	* Process stat inquiry requests.
5814	* ----------
5815	*/
5816	static void
5817	pgstat_recv_inquiry(PgStat_MsgInquiry msg, int* len)
5818	{
5819	PgStat_StatDBEntry *dbentry;
5820
5821	elog(DEBUG2, "received inquiry for database %u", msg->databaseid);
5822
5823	/*
5824	* If there's already a write request for this DB, there's nothing to do.
5825	*
5826	* Note that if a request is found, we return early and skip the below
5827	* check for clock skew. This is okay, since the only way for a DB
5828	* request to be present in the list is that we have been here since the
5829	* last write round. It seems sufficient to check for clock skew once per
5830	* write round.
5831	*/
5832	if (list_member_oid(pending_write_requests, msg->databaseid))
5833	return;
5834
5835	/*
5836	* Check to see if we last wrote this database at a time >= the requested
5837	* cutoff time. If so, this is a stale request that was generated before
5838	* we updated the DB file, and we don't need to do so again.
5839	*
5840	* If the requestor's local clock time is older than stats_timestamp, we
5841	* should suspect a clock glitch, ie system time going backwards; though
5842	* the more likely explanation is just delayed message receipt. It is
5843	* worth expending a GetCurrentTimestamp call to be sure, since a large
5844	* retreat in the system clock reading could otherwise cause us to neglect
5845	* to update the stats file for a long time.
5846	*/
5847	dbentry = pgstat_get_db_entry(msg->databaseid, false);
5848	if (dbentry == NULL)
5849	{
5850	/*
5851	* We have no data for this DB. Enter a write request anyway so that
5852	* the global stats will get updated. This is needed to prevent
5853	* backend_read_statsfile from waiting for data that we cannot supply,
5854	* in the case of a new DB that nobody has yet reported any stats for.
5855	* See the behavior of pgstat_read_db_statsfile_timestamp.
5856	*/
5857	}
5858	else if (msg->clock_time < dbentry->stats_timestamp)
5859	{
5860	TimestampTz cur_ts = GetCurrentTimestamp();
5861
5862	if (cur_ts < dbentry->stats_timestamp)
5863	{
5864	/*
5865	* Sure enough, time went backwards. Force a new stats file write
5866	* to get back in sync; but first, log a complaint.
5867	*/
5868	char *writetime;
5869	char *mytime;
5870
5871	/ Copy because timestamptz_to_str returns a static buffer /
5872	writetime = pstrdup(timestamptz_to_str(dbentry->stats_timestamp));
5873	mytime = pstrdup(timestamptz_to_str(cur_ts));
5874	elog(LOG,
5875	"stats_timestamp %s is later than collector's time %s for database %u",
5876	writetime, mytime, dbentry->databaseid);
5877	pfree(writetime);
5878	pfree(mytime);
5879	}
5880	else
5881	{
5882	/*
5883	* Nope, it's just an old request. Assuming msg's clock_time is
5884	* >= its cutoff_time, it must be stale, so we can ignore it.
5885	*/
5886	return;
5887	}
5888	}
5889	else if (msg->cutoff_time <= dbentry->stats_timestamp)
5890	{
5891	/ Stale request, ignore it /
5892	return;
5893	}
5894
5895	/*
5896	* We need to write this DB, so create a request.
5897	*/
5898	pending_write_requests = lappend_oid(pending_write_requests,
5899	msg->databaseid);
5900	}
5901
5902
5903	/ ----------*
5904	* pgstat_recv_tabstat() -
5905	*
5906	* Count what the backend has done.
5907	* ----------
5908	*/
5909	static void
5910	pgstat_recv_tabstat(PgStat_MsgTabstat msg, int* len)
5911	{
5912	PgStat_StatDBEntry *dbentry;
5913	PgStat_StatTabEntry *tabentry;
5914	int i;
5915	bool found;
5916
5917	dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
5918
5919	/*
5920	* Update database-wide stats.
5921	*/
5922	dbentry->n_xact_commit += (PgStat_Counter) (msg->m_xact_commit);
5923	dbentry->n_xact_rollback += (PgStat_Counter) (msg->m_xact_rollback);
5924	dbentry->n_block_read_time += msg->m_block_read_time;
5925	dbentry->n_block_write_time += msg->m_block_write_time;
5926
5927	/*
5928	* Process all table entries in the message.
5929	*/
5930	for (i = `0`; i < msg->m_nentries; i++)
5931	{
5932	PgStat_TableEntry *tabmsg = &(msg->m_entry[i]);
5933
5934	tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
5935	(void *) &(tabmsg->t_id),
5936	HASH_ENTER, &found);
5937
5938	if (!found)
5939	{
5940	/*
5941	* If it's a new table entry, initialize counters to the values we
5942	* just got.
5943	*/
5944	tabentry->numscans = tabmsg->t_counts.t_numscans;
5945	tabentry->tuples_returned = tabmsg->t_counts.t_tuples_returned;
5946	tabentry->tuples_fetched = tabmsg->t_counts.t_tuples_fetched;
5947	tabentry->tuples_inserted = tabmsg->t_counts.t_tuples_inserted;
5948	tabentry->tuples_updated = tabmsg->t_counts.t_tuples_updated;
5949	tabentry->tuples_deleted = tabmsg->t_counts.t_tuples_deleted;
5950	tabentry->tuples_hot_updated = tabmsg->t_counts.t_tuples_hot_updated;
5951	tabentry->n_live_tuples = tabmsg->t_counts.t_delta_live_tuples;
5952	tabentry->n_dead_tuples = tabmsg->t_counts.t_delta_dead_tuples;
5953	tabentry->changes_since_analyze = tabmsg->t_counts.t_changed_tuples;
5954	tabentry->blocks_fetched = tabmsg->t_counts.t_blocks_fetched;
5955	tabentry->blocks_hit = tabmsg->t_counts.t_blocks_hit;
5956
5957	tabentry->vacuum_timestamp = `0`;
5958	tabentry->vacuum_count = `0`;
5959	tabentry->autovac_vacuum_timestamp = `0`;
5960	tabentry->autovac_vacuum_count = `0`;
5961	tabentry->analyze_timestamp = `0`;
5962	tabentry->analyze_count = `0`;
5963	tabentry->autovac_analyze_timestamp = `0`;
5964	tabentry->autovac_analyze_count = `0`;
5965	}
5966	else
5967	{
5968	/*
5969	* Otherwise add the values to the existing entry.
5970	*/
5971	tabentry->numscans += tabmsg->t_counts.t_numscans;
5972	tabentry->tuples_returned += tabmsg->t_counts.t_tuples_returned;
5973	tabentry->tuples_fetched += tabmsg->t_counts.t_tuples_fetched;
5974	tabentry->tuples_inserted += tabmsg->t_counts.t_tuples_inserted;
5975	tabentry->tuples_updated += tabmsg->t_counts.t_tuples_updated;
5976	tabentry->tuples_deleted += tabmsg->t_counts.t_tuples_deleted;
5977	tabentry->tuples_hot_updated += tabmsg->t_counts.t_tuples_hot_updated;
5978	/ If table was truncated, first reset the live/dead counters /
5979	if (tabmsg->t_counts.t_truncated)
5980	{
5981	tabentry->n_live_tuples = `0`;
5982	tabentry->n_dead_tuples = `0`;
5983	}
5984	tabentry->n_live_tuples += tabmsg->t_counts.t_delta_live_tuples;
5985	tabentry->n_dead_tuples += tabmsg->t_counts.t_delta_dead_tuples;
5986	tabentry->changes_since_analyze += tabmsg->t_counts.t_changed_tuples;
5987	tabentry->blocks_fetched += tabmsg->t_counts.t_blocks_fetched;
5988	tabentry->blocks_hit += tabmsg->t_counts.t_blocks_hit;
5989	}
5990
5991	/ Clamp n_live_tuples in case of negative delta_live_tuples /
5992	tabentry->n_live_tuples = Max(tabentry->n_live_tuples, `0`);
5993	/ Likewise for n_dead_tuples /
5994	tabentry->n_dead_tuples = Max(tabentry->n_dead_tuples, `0`);
5995
5996	/*
5997	* Add per-table stats to the per-database entry, too.
5998	*/
5999	dbentry->n_tuples_returned += tabmsg->t_counts.t_tuples_returned;
6000	dbentry->n_tuples_fetched += tabmsg->t_counts.t_tuples_fetched;
6001	dbentry->n_tuples_inserted += tabmsg->t_counts.t_tuples_inserted;
6002	dbentry->n_tuples_updated += tabmsg->t_counts.t_tuples_updated;
6003	dbentry->n_tuples_deleted += tabmsg->t_counts.t_tuples_deleted;
6004	dbentry->n_blocks_fetched += tabmsg->t_counts.t_blocks_fetched;
6005	dbentry->n_blocks_hit += tabmsg->t_counts.t_blocks_hit;
6006	}
6007	}
6008
6009
6010	/ ----------*
6011	* pgstat_recv_tabpurge() -
6012	*
6013	* Arrange for dead table removal.
6014	* ----------
6015	*/
6016	static void
6017	pgstat_recv_tabpurge(PgStat_MsgTabpurge msg, int* len)
6018	{
6019	PgStat_StatDBEntry *dbentry;
6020	int i;
6021
6022	dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
6023
6024	/*
6025	* No need to purge if we don't even know the database.
6026	*/
6027	if (!dbentry \|\| !dbentry->tables)
6028	return;
6029
6030	/*
6031	* Process all table entries in the message.
6032	*/
6033	for (i = `0`; i < msg->m_nentries; i++)
6034	{
6035	/ Remove from hashtable if present; we don't care if it's not. /
6036	(void) hash_search(dbentry->tables,
6037	(void *) &(msg->m_tableid[i]),
6038	HASH_REMOVE, NULL);
6039	}
6040	}
6041
6042
6043	/ ----------*
6044	* pgstat_recv_dropdb() -
6045	*
6046	* Arrange for dead database removal
6047	* ----------
6048	*/
6049	static void
6050	pgstat_recv_dropdb(PgStat_MsgDropdb msg, int* len)
6051	{
6052	Oid dbid = msg->m_databaseid;
6053	PgStat_StatDBEntry *dbentry;
6054
6055	/*
6056	* Lookup the database in the hashtable.
6057	*/
6058	dbentry = pgstat_get_db_entry(dbid, false);
6059
6060	/*
6061	* If found, remove it (along with the db statfile).
6062	*/
6063	if (dbentry)
6064	{
6065	char statfile[MAXPGPATH];
6066
6067	get_dbstat_filename(false, false, dbid, statfile, MAXPGPATH);
6068
6069	elog(DEBUG2, "removing stats file \"%s\"", statfile);
6070	unlink(statfile);
6071
6072	if (dbentry->tables != NULL)
6073	hash_destroy(dbentry->tables);
6074	if (dbentry->functions != NULL)
6075	hash_destroy(dbentry->functions);
6076
6077	if (hash_search(pgStatDBHash,
6078	(void *) &dbid,
6079	HASH_REMOVE, NULL) == NULL)
6080	ereport(ERROR,
6081	(errmsg("database hash table corrupted during cleanup --- abort")));
6082	}
6083	}
6084
6085
6086	/ ----------*
6087	* pgstat_recv_resetcounter() -
6088	*
6089	* Reset the statistics for the specified database.
6090	* ----------
6091	*/
6092	static void
6093	pgstat_recv_resetcounter(PgStat_MsgResetcounter msg, int* len)
6094	{
6095	PgStat_StatDBEntry *dbentry;
6096
6097	/*
6098	* Lookup the database in the hashtable. Nothing to do if not there.
6099	*/
6100	dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
6101
6102	if (!dbentry)
6103	return;
6104
6105	/*
6106	* We simply throw away all the database's table entries by recreating a
6107	* new hash table for them.
6108	*/
6109	if (dbentry->tables != NULL)
6110	hash_destroy(dbentry->tables);
6111	if (dbentry->functions != NULL)
6112	hash_destroy(dbentry->functions);
6113
6114	dbentry->tables = NULL;
6115	dbentry->functions = NULL;
6116
6117	/*
6118	* Reset database-level stats, too. This creates empty hash tables for
6119	* tables and functions.
6120	*/
6121	reset_dbentry_counters(dbentry);
6122	}
6123
6124	/ ----------*
6125	* pgstat_recv_resetshared() -
6126	*
6127	* Reset some shared statistics of the cluster.
6128	* ----------
6129	*/
6130	static void
6131	pgstat_recv_resetsharedcounter(PgStat_MsgResetsharedcounter msg, int* len)
6132	{
6133	if (msg->m_resettarget == RESET_BGWRITER)
6134	{
6135	/ Reset the global background writer statistics for the cluster. /
6136	memset(&globalStats, `0`, sizeof(globalStats));
6137	globalStats.stat_reset_timestamp = GetCurrentTimestamp();
6138	}
6139	else if (msg->m_resettarget == RESET_ARCHIVER)
6140	{
6141	/ Reset the archiver statistics for the cluster. /
6142	memset(&archiverStats, `0`, sizeof(archiverStats));
6143	archiverStats.stat_reset_timestamp = GetCurrentTimestamp();
6144	}
6145
6146	/*
6147	* Presumably the sender of this message validated the target, don't
6148	* complain here if it's not valid
6149	*/
6150	}
6151
6152	/ ----------*
6153	* pgstat_recv_resetsinglecounter() -
6154	*
6155	* Reset a statistics for a single object
6156	* ----------
6157	*/
6158	static void
6159	pgstat_recv_resetsinglecounter(PgStat_MsgResetsinglecounter msg, int* len)
6160	{
6161	PgStat_StatDBEntry *dbentry;
6162
6163	dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
6164
6165	if (!dbentry)
6166	return;
6167
6168	/ Set the reset timestamp for the whole database /
6169	dbentry->stat_reset_timestamp = GetCurrentTimestamp();
6170
6171	/ Remove object if it exists, ignore it if not /
6172	if (msg->m_resettype == RESET_TABLE)
6173	(void) hash_search(dbentry->tables, (void *) &(msg->m_objectid),
6174	HASH_REMOVE, NULL);
6175	else if (msg->m_resettype == RESET_FUNCTION)
6176	(void) hash_search(dbentry->functions, (void *) &(msg->m_objectid),
6177	HASH_REMOVE, NULL);
6178	}
6179
6180	/ ----------*
6181	* pgstat_recv_autovac() -
6182	*
6183	* Process an autovacuum signalling message.
6184	* ----------
6185	*/
6186	static void
6187	pgstat_recv_autovac(PgStat_MsgAutovacStart msg, int* len)
6188	{
6189	PgStat_StatDBEntry *dbentry;
6190
6191	/*
6192	* Store the last autovacuum time in the database's hashtable entry.
6193	*/
6194	dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
6195
6196	dbentry->last_autovac_time = msg->m_start_time;
6197	}
6198
6199	/ ----------*
6200	* pgstat_recv_vacuum() -
6201	*
6202	* Process a VACUUM message.
6203	* ----------
6204	*/
6205	static void
6206	pgstat_recv_vacuum(PgStat_MsgVacuum msg, int* len)
6207	{
6208	PgStat_StatDBEntry *dbentry;
6209	PgStat_StatTabEntry *tabentry;
6210
6211	/*
6212	* Store the data in the table's hashtable entry.
6213	*/
6214	dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
6215
6216	tabentry = pgstat_get_tab_entry(dbentry, msg->m_tableoid, true);
6217
6218	tabentry->n_live_tuples = msg->m_live_tuples;
6219	tabentry->n_dead_tuples = msg->m_dead_tuples;
6220
6221	if (msg->m_autovacuum)
6222	{
6223	tabentry->autovac_vacuum_timestamp = msg->m_vacuumtime;
6224	tabentry->autovac_vacuum_count++;
6225	}
6226	else
6227	{
6228	tabentry->vacuum_timestamp = msg->m_vacuumtime;
6229	tabentry->vacuum_count++;
6230	}
6231	}
6232
6233	/ ----------*
6234	* pgstat_recv_analyze() -
6235	*
6236	* Process an ANALYZE message.
6237	* ----------
6238	*/
6239	static void
6240	pgstat_recv_analyze(PgStat_MsgAnalyze msg, int* len)
6241	{
6242	PgStat_StatDBEntry *dbentry;
6243	PgStat_StatTabEntry *tabentry;
6244
6245	/*
6246	* Store the data in the table's hashtable entry.
6247	*/
6248	dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
6249
6250	tabentry = pgstat_get_tab_entry(dbentry, msg->m_tableoid, true);
6251
6252	tabentry->n_live_tuples = msg->m_live_tuples;
6253	tabentry->n_dead_tuples = msg->m_dead_tuples;
6254
6255	/*
6256	* If commanded, reset changes_since_analyze to zero. This forgets any
6257	* changes that were committed while the ANALYZE was in progress, but we
6258	* have no good way to estimate how many of those there were.
6259	*/
6260	if (msg->m_resetcounter)
6261	tabentry->changes_since_analyze = `0`;
6262
6263	if (msg->m_autovacuum)
6264	{
6265	tabentry->autovac_analyze_timestamp = msg->m_analyzetime;
6266	tabentry->autovac_analyze_count++;
6267	}
6268	else
6269	{
6270	tabentry->analyze_timestamp = msg->m_analyzetime;
6271	tabentry->analyze_count++;
6272	}
6273	}
6274
6275
6276	/ ----------*
6277	* pgstat_recv_archiver() -
6278	*
6279	* Process a ARCHIVER message.
6280	* ----------
6281	*/
6282	static void
6283	pgstat_recv_archiver(PgStat_MsgArchiver msg, int* len)
6284	{
6285	if (msg->m_failed)
6286	{
6287	/ Failed archival attempt /
6288	++archiverStats.failed_count;
6289	memcpy(archiverStats.last_failed_wal, msg->m_xlog,
6290	sizeof(archiverStats.last_failed_wal));
6291	archiverStats.last_failed_timestamp = msg->m_timestamp;
6292	}
6293	else
6294	{
6295	/ Successful archival operation /
6296	++archiverStats.archived_count;
6297	memcpy(archiverStats.last_archived_wal, msg->m_xlog,
6298	sizeof(archiverStats.last_archived_wal));
6299	archiverStats.last_archived_timestamp = msg->m_timestamp;
6300	}
6301	}
6302
6303	/ ----------*
6304	* pgstat_recv_bgwriter() -
6305	*
6306	* Process a BGWRITER message.
6307	* ----------
6308	*/
6309	static void
6310	pgstat_recv_bgwriter(PgStat_MsgBgWriter msg, int* len)
6311	{
6312	globalStats.timed_checkpoints += msg->m_timed_checkpoints;
6313	globalStats.requested_checkpoints += msg->m_requested_checkpoints;
6314	globalStats.checkpoint_write_time += msg->m_checkpoint_write_time;
6315	globalStats.checkpoint_sync_time += msg->m_checkpoint_sync_time;
6316	globalStats.buf_written_checkpoints += msg->m_buf_written_checkpoints;
6317	globalStats.buf_written_clean += msg->m_buf_written_clean;
6318	globalStats.maxwritten_clean += msg->m_maxwritten_clean;
6319	globalStats.buf_written_backend += msg->m_buf_written_backend;
6320	globalStats.buf_fsync_backend += msg->m_buf_fsync_backend;
6321	globalStats.buf_alloc += msg->m_buf_alloc;
6322	}
6323
6324	/ ----------*
6325	* pgstat_recv_recoveryconflict() -
6326	*
6327	* Process a RECOVERYCONFLICT message.
6328	* ----------
6329	*/
6330	static void
6331	pgstat_recv_recoveryconflict(PgStat_MsgRecoveryConflict msg, int* len)
6332	{
6333	PgStat_StatDBEntry *dbentry;
6334
6335	dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
6336
6337	switch (msg->m_reason)
6338	{
6339	case PROCSIG_RECOVERY_CONFLICT_DATABASE:
6340
6341	/*
6342	* Since we drop the information about the database as soon as it
6343	* replicates, there is no point in counting these conflicts.
6344	*/
6345	break;
6346	case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
6347	dbentry->n_conflict_tablespace++;
6348	break;
6349	case PROCSIG_RECOVERY_CONFLICT_LOCK:
6350	dbentry->n_conflict_lock++;
6351	break;
6352	case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
6353	dbentry->n_conflict_snapshot++;
6354	break;
6355	case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
6356	dbentry->n_conflict_bufferpin++;
6357	break;
6358	case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
6359	dbentry->n_conflict_startup_deadlock++;
6360	break;
6361	}
6362	}
6363
6364	/ ----------*
6365	* pgstat_recv_deadlock() -
6366	*
6367	* Process a DEADLOCK message.
6368	* ----------
6369	*/
6370	static void
6371	pgstat_recv_deadlock(PgStat_MsgDeadlock msg, int* len)
6372	{
6373	PgStat_StatDBEntry *dbentry;
6374
6375	dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
6376
6377	dbentry->n_deadlocks++;
6378	}
6379
6380	/ ----------*
6381	* pgstat_recv_checksum_failure() -
6382	*
6383	* Process a CHECKSUMFAILURE message.
6384	* ----------
6385	*/
6386	static void
6387	pgstat_recv_checksum_failure(PgStat_MsgChecksumFailure msg, int* len)
6388	{
6389	PgStat_StatDBEntry *dbentry;
6390
6391	dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
6392
6393	dbentry->n_checksum_failures += msg->m_failurecount;
6394	dbentry->last_checksum_failure = msg->m_failure_time;
6395	}
6396
6397	/ ----------*
6398	* pgstat_recv_tempfile() -
6399	*
6400	* Process a TEMPFILE message.
6401	* ----------
6402	*/
6403	static void
6404	pgstat_recv_tempfile(PgStat_MsgTempFile msg, int* len)
6405	{
6406	PgStat_StatDBEntry *dbentry;
6407
6408	dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
6409
6410	dbentry->n_temp_bytes += msg->m_filesize;
6411	dbentry->n_temp_files += `1`;
6412	}
6413
6414	/ ----------*
6415	* pgstat_recv_funcstat() -
6416	*
6417	* Count what the backend has done.
6418	* ----------
6419	*/
6420	static void
6421	pgstat_recv_funcstat(PgStat_MsgFuncstat msg, int* len)
6422	{
6423	PgStat_FunctionEntry *funcmsg = &(msg->m_entry[`0`]);
6424	PgStat_StatDBEntry *dbentry;
6425	PgStat_StatFuncEntry *funcentry;
6426	int i;
6427	bool found;
6428
6429	dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
6430
6431	/*
6432	* Process all function entries in the message.
6433	*/
6434	for (i = `0`; i < msg->m_nentries; i++, funcmsg++)
6435	{
6436	funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,
6437	(void *) &(funcmsg->f_id),
6438	HASH_ENTER, &found);
6439
6440	if (!found)
6441	{
6442	/*
6443	* If it's a new function entry, initialize counters to the values
6444	* we just got.
6445	*/
6446	funcentry->f_numcalls = funcmsg->f_numcalls;
6447	funcentry->f_total_time = funcmsg->f_total_time;
6448	funcentry->f_self_time = funcmsg->f_self_time;
6449	}
6450	else
6451	{
6452	/*
6453	* Otherwise add the values to the existing entry.
6454	*/
6455	funcentry->f_numcalls += funcmsg->f_numcalls;
6456	funcentry->f_total_time += funcmsg->f_total_time;
6457	funcentry->f_self_time += funcmsg->f_self_time;
6458	}
6459	}
6460	}
6461
6462	/ ----------*
6463	* pgstat_recv_funcpurge() -
6464	*
6465	* Arrange for dead function removal.
6466	* ----------
6467	*/
6468	static void
6469	pgstat_recv_funcpurge(PgStat_MsgFuncpurge msg, int* len)
6470	{
6471	PgStat_StatDBEntry *dbentry;
6472	int i;
6473
6474	dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
6475
6476	/*
6477	* No need to purge if we don't even know the database.
6478	*/
6479	if (!dbentry \|\| !dbentry->functions)
6480	return;
6481
6482	/*
6483	* Process all function entries in the message.
6484	*/
6485	for (i = `0`; i < msg->m_nentries; i++)
6486	{
6487	/ Remove from hashtable if present; we don't care if it's not. /
6488	(void) hash_search(dbentry->functions,
6489	(void *) &(msg->m_functionid[i]),
6490	HASH_REMOVE, NULL);
6491	}
6492	}
6493
6494	/ ----------*
6495	* pgstat_write_statsfile_needed() -
6496	*
6497	* Do we need to write out any stats files?
6498	* ----------
6499	*/
6500	static bool
6501	pgstat_write_statsfile_needed(void)
6502	{
6503	if (pending_write_requests != NIL)
6504	return true;
6505
6506	/ Everything was written recently /
6507	return false;
6508	}
6509
6510	/ ----------*
6511	* pgstat_db_requested() -
6512	*
6513	* Checks whether stats for a particular DB need to be written to a file.
6514	* ----------
6515	*/
6516	static bool
6517	pgstat_db_requested(Oid databaseid)
6518	{
6519	/*
6520	* If any requests are outstanding at all, we should write the stats for
6521	* shared catalogs (the "database" with OID 0). This ensures that
6522	* backends will see up-to-date stats for shared catalogs, even though
6523	* they send inquiry messages mentioning only their own DB.
6524	*/
6525	if (databaseid == InvalidOid && pending_write_requests != NIL)
6526	return true;
6527
6528	/ Search to see if there's an open request to write this database. /
6529	if (list_member_oid(pending_write_requests, databaseid))
6530	return true;
6531
6532	return false;
6533	}
6534
6535	/*
6536	* Convert a potentially unsafely truncated activity string (see
6537	* PgBackendStatus.st_activity_raw's documentation) into a correctly truncated
6538	* one.
6539	*
6540	* The returned string is allocated in the caller's memory context and may be
6541	* freed.
6542	*/
6543	char *
6544	pgstat_clip_activity(const char *raw_activity)
6545	{
6546	char *activity;
6547	int rawlen;
6548	int cliplen;
6549
6550	/*
6551	* Some callers, like pgstat_get_backend_current_activity(), do not
6552	* guarantee that the buffer isn't concurrently modified. We try to take
6553	* care that the buffer is always terminated by a NUL byte regardless, but
6554	* let's still be paranoid about the string's length. In those cases the
6555	* underlying buffer is guaranteed to be pgstat_track_activity_query_size
6556	* large.
6557	*/
6558	activity = pnstrdup(raw_activity, pgstat_track_activity_query_size - `1`);
6559
6560	/ now double-guaranteed to be NUL terminated /
6561	rawlen = strlen(activity);
6562
6563	/*
6564	* All supported server-encodings make it possible to determine the length
6565	* of a multi-byte character from its first byte (this is not the case for
6566	* client encodings, see GB18030). As st_activity is always stored using
6567	* server encoding, this allows us to perform multi-byte aware truncation,
6568	* even if the string earlier was truncated in the middle of a multi-byte
6569	* character.
6570	*/
6571	cliplen = pg_mbcliplen(activity, rawlen,
6572	pgstat_track_activity_query_size - `1`);
6573
6574	activity[cliplen] = `'\0'`;
6575
6576	return activity;
6577	}
6578

Browse the source code of PostgreSQL/src/backend/postmaster/pgstat.c