PostgreSQL Source Code  git master
pgstat.c
Go to the documentation of this file.
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"
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  */
126 bool pgstat_track_counts = false;
129 
130 /* ----------
131  * Built from GUC parameter
132  * ----------
133  */
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  */
144 
145 /* ----------
146  * Local data
147  * ----------
148  */
150 
152 
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 */
176 
178 
179 /*
180  * pgStatTabHash entry: map from relation OID to PgStat_TableStatus pointer
181  */
182 typedef struct TabStatHashEntry
183 {
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 */
218 
220 
221 static int pgStatXactCommit = 0;
222 static int pgStatXactRollback = 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? */
239 
240 /*
241  * Info about current "snapshot" of stats file
242  */
244 static HTAB *pgStatDBHash = NULL;
245 
246 /* Status for backends including auxiliary */
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  */
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  */
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  */
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);
291 
292 static PgStat_StatDBEntry *pgstat_get_db_entry(Oid databaseid, bool create);
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);
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);
337 static void pgstat_recv_deadlock(PgStat_MsgDeadlock *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
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  */
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,
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,
440  errmsg("could not bind socket for statistics collector: %m")));
443  continue;
444  }
445 
446  alen = sizeof(pgStatAddr);
447  if (getsockname(pgStatSock, (struct sockaddr *) &pgStatAddr, &alen) < 0)
448  {
449  ereport(LOG,
451  errmsg("could not get address of socket for statistics collector: %m")));
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,
467  errmsg("could not connect socket for statistics collector: %m")));
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,
488  errmsg("could not send test message on socket for statistics collector: %m")));
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,
514  errmsg("select() failed in statistics collector: %m")));
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")));
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,
544  errmsg("could not receive test message on socket for statistics collector: %m")));
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")));
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  */
574  {
575  ereport(LOG,
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 
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
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
687 {
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
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  */
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 ... */
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();
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
792 {
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
814 {
815  /* we assume this inits to all zeroes: */
816  static const PgStat_TableCounts all_zeroes;
817  static TimestampTz last_report = 0;
818 
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 &&
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  */
836  if (!force &&
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 ||
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 */
914 }
915 
916 /*
917  * Subroutine for pgstat_report_stat: finish and send a tabstat message
918  */
919 static void
921 {
922  int n;
923  int len;
924 
925  /* It's unlikely we'd get here with no socket, but maybe not impossible */
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  {
939  pgStatXactCommit = 0;
940  pgStatXactRollback = 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 
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
965 {
966  /* we assume this inits to all zeroes: */
967  static const PgStat_FunctionCounts all_zeroes;
968 
969  PgStat_MsgFuncstat msg;
971  HASH_SEQ_STATUS fstat;
972 
973  if (pgStatFunctions == NULL)
974  return;
975 
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;
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
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 
1035  return;
1036 
1037  /*
1038  * If not done for this transaction, read the statistics collector stats
1039  * file into some hash tables.
1040  */
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 
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 
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 
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 
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 
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 
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",
1220  &hash_ctl,
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 
1235 
1236  (void) hash_search(htab, (void *) &thisoid, HASH_ENTER, NULL);
1237  }
1238  table_endscan(scan);
1239  UnregisterSnapshot(snapshot);
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
1256 {
1257  PgStat_MsgDropdb msg;
1258 
1260  return;
1261 
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 
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 
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
1312 {
1314 
1316  return;
1317 
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 {
1336 
1338  return;
1339 
1340  if (strcmp(target, "archiver") == 0)
1342  else if (strcmp(target, "bgwriter") == 0)
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 
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
1365 {
1367 
1369  return;
1370 
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
1389 {
1391 
1393  return;
1394 
1396  msg.m_databaseid = dboid;
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 
1416  return;
1417 
1419  msg.m_databaseid = shared ? InvalidOid : MyDatabaseId;
1420  msg.m_tableoid = tableoid;
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
1439  PgStat_Counter livetuples, PgStat_Counter deadtuples,
1440  bool resetcounter)
1441 {
1442  PgStat_MsgAnalyze msg;
1443 
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  {
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 
1474  msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
1475  msg.m_tableoid = RelationGetRelid(rel);
1477  msg.m_resetcounter = resetcounter;
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
1492 {
1494 
1496  return;
1497 
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
1512 {
1513  PgStat_MsgDeadlock msg;
1514 
1516  return;
1517 
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
1533 {
1535 
1537  return;
1538 
1540  msg.m_databaseid = dboid;
1541  msg.m_failurecount = failurecount;
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
1555 {
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 
1571  return;
1572 
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
1588 {
1589  PgStat_MsgDummy msg;
1590 
1592  return;
1593 
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 
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
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",
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 */
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  */
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
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 */
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
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 
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",
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 *)
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 *)
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  */
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 *
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 *)
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;
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 *)
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
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
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
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
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
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
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
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
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  {
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)
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 */
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  {
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 */
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 */
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
2281 {
2282  PgStat_SubXactStatus *xact_state;
2283 
2284  xact_state = pgStatXactStack;
2285  if (xact_state != NULL)
2286  {
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 
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
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  {
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 */
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
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
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  */
2433 {
2434  /*
2435  * If not done for this transaction, read the statistics collector stats
2436  * file into some hash tables.
2437  */
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  */
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  */
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  */
2516 {
2517  PgStat_StatDBEntry *dbentry;
2518  PgStat_StatFuncEntry *funcentry = NULL;
2519 
2520  /* load the stats file if needed */
2522 
2523  /* Lookup our database, then find the requested function. */
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  */
2548 {
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  */
2570 {
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
2589 {
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  */
2605 {
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  */
2622 {
2624 
2625  return &globalStats;
2626 }
2627 
2628 
2629 /* ------------------------------------------------------------
2630  * Functions for management of the shared-memory PgBackendStatus array
2631  * ------------------------------------------------------------
2632  */
2633 
2636 static char *BackendAppnameBuffer = NULL;
2637 static char *BackendClientHostnameBuffer = NULL;
2638 static char *BackendActivityBuffer = NULL;
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
2653 {
2654  Size size;
2655 
2656  /* BackendStatusArray: */
2657  size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
2658  /* BackendAppnameBuffer: */
2659  size = add_size(size,
2661  /* BackendClientHostnameBuffer: */
2662  size = add_size(size,
2664  /* BackendActivityBuffer: */
2665  size = add_size(size,
2667 #ifdef USE_SSL
2668  /* BackendSslStatusBuffer: */
2669  size = add_size(size,
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
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 */
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 */
2720  BackendClientHostnameBuffer = (char *)
2721  ShmemInitStruct("Backend Client Host Name Buffer", size, &found);
2722 
2723  if (!found)
2724  {
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 */
2739  BackendActivityBuffer = (char *)
2740  ShmemInitStruct("Backend Activity Buffer",
2742  &found);
2743 
2744  if (!found)
2745  {
2747 
2748  /* Initialize st_activity pointers. */
2749  buffer = BackendActivityBuffer;
2750  for (i = 0; i < NumBackendStatSlots; i++)
2751  {
2752  BackendStatusArray[i].st_activity_raw = buffer;
2754  }
2755  }
2756 
2757 #ifdef USE_SSL
2758  /* Create or attach to the shared SSL status buffer */
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 */
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
2816 {
2817  /* Initialize MyBEEntry */
2819  {
2821  MyBEEntry = &BackendStatusArray[MyBackendId - 1];
2822  }
2823  else
2824  {
2825  /* Must be an auxiliary process */
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 */
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
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 
2901  {
2903  {
2904  /* Autovacuum 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 */
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 
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;
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)
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;
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';
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';
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)
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
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
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 
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
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
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
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
3272 {
3273  volatile PgBackendStatus *beentry = MyBEEntry;
3274 
3275  if (!beentry)
3276  return;
3279  return;
3280 
3281  PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
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
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
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 
3367  if (localBackendStatusTable)
3368  return; /* already done */
3369 
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,
3383  localappname = (char *)
3384  MemoryContextAlloc(pgStatLocalContext,
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,
3396 #endif
3397 #ifdef ENABLE_GSS
3398  localgssstatus = (PgBackendGSSStatus *)
3399  MemoryContextAlloc(pgStatLocalContext,
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... */
3467  }
3468 
3469  beentry++;
3470  /* Only valid entries get included into the local array */
3471  if (localentry->backendStatus.st_procpid > 0)
3472  {
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 *
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 *
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 *
3635 {
3636  const char *event_name = "unknown wait event";
3637 
3638  switch (w)
3639  {
3641  event_name = "ArchiverMain";
3642  break;
3644  event_name = "AutoVacuumMain";
3645  break;
3647  event_name = "BgWriterHibernate";
3648  break;
3650  event_name = "BgWriterMain";
3651  break;
3653  event_name = "CheckpointerMain";
3654  break;
3656  event_name = "LogicalApplyMain";
3657  break;
3659  event_name = "LogicalLauncherMain";
3660  break;
3662  event_name = "PgStatMain";
3663  break;
3665  event_name = "RecoveryWalAll";
3666  break;
3668  event_name = "RecoveryWalStream";
3669  break;
3671  event_name = "SysLoggerMain";
3672  break;
3674  event_name = "WalReceiverMain";
3675  break;
3677  event_name = "WalSenderMain";
3678  break;
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 *
3696 {
3697  const char *event_name = "unknown wait event";
3698 
3699  switch (w)
3700  {
3702  event_name = "ClientRead";
3703  break;
3705  event_name = "ClientWrite";
3706  break;
3708  event_name = "LibPQWalReceiverConnect";
3709  break;
3711  event_name = "LibPQWalReceiverReceive";
3712  break;
3714  event_name = "SSLOpenServer";
3715  break;
3717  event_name = "WalReceiverWaitStart";
3718  break;
3720  event_name = "WalSenderWaitForWAL";
3721  break;
3723  event_name = "WalSenderWriteData";
3724  break;
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 *
3742 {
3743  const char *event_name = "unknown wait event";
3744 
3745  switch (w)
3746  {
3748  event_name = "BgWorkerShutdown";
3749  break;
3751  event_name = "BgWorkerStartup";
3752  break;
3753  case WAIT_EVENT_BTREE_PAGE:
3754  event_name = "BtreePage";
3755  break;
3757  event_name = "CheckpointDone";
3758  break;
3760  event_name = "CheckpointStart";
3761  break;
3763  event_name = "ClogGroupUpdate";
3764  break;
3766  event_name = "ExecuteGather";
3767  break;
3769  event_name = "Hash/Batch/Allocating";
3770  break;
3772  event_name = "Hash/Batch/Electing";
3773  break;
3775  event_name = "Hash/Batch/Loading";
3776  break;
3778  event_name = "Hash/Build/Allocating";
3779  break;
3781  event_name = "Hash/Build/Electing";
3782  break;
3784  event_name = "Hash/Build/HashingInner";
3785  break;
3787  event_name = "Hash/Build/HashingOuter";
3788  break;
3790  event_name = "Hash/GrowBatches/Allocating";
3791  break;
3793  event_name = "Hash/GrowBatches/Deciding";
3794  break;
3796  event_name = "Hash/GrowBatches/Electing";
3797  break;
3799  event_name = "Hash/GrowBatches/Finishing";
3800  break;
3802  event_name = "Hash/GrowBatches/Repartitioning";
3803  break;
3805  event_name = "Hash/GrowBuckets/Allocating";
3806  break;
3808  event_name = "Hash/GrowBuckets/Electing";
3809  break;
3811  event_name = "Hash/GrowBuckets/Reinserting";
3812  break;
3814  event_name = "LogicalSyncData";
3815  break;
3817  event_name = "LogicalSyncStateChange";
3818  break;
3820  event_name = "MessageQueueInternal";
3821  break;
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;
3832  event_name = "ParallelBitmapScan";
3833  break;
3835  event_name = "ParallelCreateIndexScan";
3836  break;
3838  event_name = "ParallelFinish";
3839  break;
3841  event_name = "ProcArrayGroupUpdate";
3842  break;
3843  case WAIT_EVENT_PROMOTE:
3844  event_name = "Promote";
3845  break;
3847  event_name = "ReplicationOriginDrop";
3848  break;
3850  event_name = "ReplicationSlotDrop";
3851  break;
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 *
3872 {
3873  const char *event_name = "unknown wait event";
3874 
3875  switch (w)
3876  {
3878  event_name = "BaseBackupThrottle";
3879  break;
3880  case WAIT_EVENT_PG_SLEEP:
3881  event_name = "PgSleep";
3882  break;
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 *
3900 {
3901  const char *event_name = "unknown wait event";
3902 
3903  switch (w)
3904  {
3906  event_name = "BufFileRead";
3907  break;
3909  event_name = "BufFileWrite";
3910  break;
3912  event_name = "ControlFileRead";
3913  break;
3915  event_name = "ControlFileSync";
3916  break;
3918  event_name = "ControlFileSyncUpdate";
3919  break;
3921  event_name = "ControlFileWrite";
3922  break;
3924  event_name = "ControlFileWriteUpdate";
3925  break;
3927  event_name = "CopyFileRead";
3928  break;
3930  event_name = "CopyFileWrite";
3931  break;
3933  event_name = "DataFileExtend";
3934  break;
3936  event_name = "DataFileFlush";
3937  break;
3939  event_name = "DataFileImmediateSync";
3940  break;
3942  event_name = "DataFilePrefetch";
3943  break;
3945  event_name = "DataFileRead";
3946  break;
3948  event_name = "DataFileSync";
3949  break;
3951  event_name = "DataFileTruncate";
3952  break;
3954  event_name = "DataFileWrite";
3955  break;
3957  event_name = "DSMFillZeroWrite";
3958  break;
3960  event_name = "LockFileAddToDataDirRead";
3961  break;
3963  event_name = "LockFileAddToDataDirSync";
3964  break;
3966  event_name = "LockFileAddToDataDirWrite";
3967  break;
3969  event_name = "LockFileCreateRead";
3970  break;
3972  event_name = "LockFileCreateSync";
3973  break;
3975  event_name = "LockFileCreateWrite";
3976  break;
3978  event_name = "LockFileReCheckDataDirRead";
3979  break;
3981  event_name = "LogicalRewriteCheckpointSync";
3982  break;
3984  event_name = "LogicalRewriteMappingSync";
3985  break;
3987  event_name = "LogicalRewriteMappingWrite";
3988  break;
3990  event_name = "LogicalRewriteSync";
3991  break;
3993  event_name = "LogicalRewriteTruncate";
3994  break;
3996  event_name = "LogicalRewriteWrite";
3997  break;
3999  event_name = "RelationMapRead";
4000  break;
4002  event_name = "RelationMapSync";
4003  break;
4005  event_name = "RelationMapWrite";
4006  break;
4008  event_name = "ReorderBufferRead";
4009  break;
4011  event_name = "ReorderBufferWrite";
4012  break;
4014  event_name = "ReorderLogicalMappingRead";
4015  break;
4017  event_name = "ReplicationSlotRead";
4018  break;
4020  event_name = "ReplicationSlotRestoreSync";
4021  break;
4023  event_name = "ReplicationSlotSync";
4024  break;
4026  event_name = "ReplicationSlotWrite";
4027  break;
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;
4041  event_name = "SnapbuildRead";
4042  break;
4044  event_name = "SnapbuildSync";
4045  break;
4047  event_name = "SnapbuildWrite";
4048  break;
4050  event_name = "TimelineHistoryFileSync";
4051  break;
4053  event_name = "TimelineHistoryFileWrite";
4054  break;
4056  event_name = "TimelineHistoryRead";
4057  break;
4059  event_name = "TimelineHistorySync";
4060  break;
4062  event_name = "TimelineHistoryWrite";
4063  break;
4065  event_name = "TwophaseFileRead";
4066  break;
4068  event_name = "TwophaseFileSync";
4069  break;
4071  event_name = "TwophaseFileWrite";
4072  break;
4074  event_name = "WALSenderTimelineHistoryRead";
4075  break;
4077  event_name = "WALBootstrapSync";
4078  break;
4080  event_name = "WALBootstrapWrite";
4081  break;
4083  event_name = "WALCopyRead";
4084  break;
4086  event_name = "WALCopySync";
4087  break;
4089  event_name = "WALCopyWrite";
4090  break;
4092  event_name = "WALInitSync";
4093  break;
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;
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... */
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  */
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 *
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
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 
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  */
4379  msg.m_failed = failed;
4380  StrNCpy(msg.m_xlog, xlog, sizeof(msg.m_xlog));
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
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  */
4440  pqsignal(SIGINT, SIG_IGN);
4441  pqsignal(SIGTERM, SIG_IGN);
4447  /* Reset some signals that are accepted by postmaster but not here */
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 */
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;
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  */
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,
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 
4574  pgstat_recv_resetcounter(&msg.msg_resetcounter, len);
4575  break;
4576 
4579  &msg.msg_resetsharedcounter,
4580  len);
4581  break;
4582 
4585  &msg.msg_resetsinglecounter,
4586  len);
4587  break;
4588 
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 
4614  pgstat_recv_funcpurge(&msg.msg_funcpurge, len);
4615  break;
4616 
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 
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
4646  pgStatSock, -1L,
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  */
4662  pgStatSock,
4663  2 * 1000L /* msec */ ,
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
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
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
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 
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",
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",
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,
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,
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,
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,
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 :
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
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,
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,
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,
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,
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  */
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,
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)
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  {
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  {
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  */
5218  globalStats.stats_timestamp = 0;
5219 
5220  /*
5221  * Read archiver stats struct
5222  */
5223  if (fread(&archiverStats, 1, sizeof(archiverStats), fpin) != sizeof(archiverStats))
5224  {
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  {
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  {
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  */
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",
5298  &hash_ctl,
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",
5306  &hash_ctl,
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)
5315  dbentry->tables,
5316  dbentry->functions,
5317  permanent);
5318 
5319  break;
5320 
5321  case 'E':
5322  goto done;
5323 
5324  default:
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)
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  {
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  {
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  {
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  {
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  {
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:
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)
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  {
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  {
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  {
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  {
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:
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
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;
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  */
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 
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;
5702  min_ts = TimestampTzPlusMilliseconds(ref_ts,
5704  else
5705  min_ts = TimestampTzPlusMilliseconds(ref_ts,
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  */
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
5777 {
5778  if (!pgStatLocalContext)
5779  pgStatLocalContext = AllocSetContextCreate(TopMemoryContext,
5780  "Statistics snapshot",
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
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
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
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  {
<