PostgreSQL Source Code  git master
pgstat.c
Go to the documentation of this file.
1 /* ----------
2  * pgstat.c
3  * Infrastructure for the cumulative statistics system.
4  *
5  * The cumulative statistics system accumulates statistics for different kinds
6  * of objects. Some kinds of statistics are collected for a fixed number of
7  * objects (most commonly 1), e.g., checkpointer statistics. Other kinds of
8  * statistics are collected for a varying number of objects
9  * (e.g. relations). See PgStat_KindInfo for a list of currently handled
10  * statistics.
11  *
12  * Statistics are loaded from the filesystem during startup (by the startup
13  * process), unless preceded by a crash, in which case all stats are
14  * discarded. They are written out by the checkpointer process just before
15  * shutting down, except when shutting down in immediate mode.
16  *
17  * Fixed-numbered stats are stored in plain (non-dynamic) shared memory.
18  *
19  * Statistics for variable-numbered objects are stored in dynamic shared
20  * memory and can be found via a dshash hashtable. The statistics counters are
21  * not part of the dshash entry (PgStatShared_HashEntry) directly, but are
22  * separately allocated (PgStatShared_HashEntry->body). The separate
23  * allocation allows different kinds of statistics to be stored in the same
24  * hashtable without wasting space in PgStatShared_HashEntry.
25  *
26  * Variable-numbered stats are addressed by PgStat_HashKey while running. It
27  * is not possible to have statistics for an object that cannot be addressed
28  * that way at runtime. A wider identifier can be used when serializing to
29  * disk (used for replication slot stats).
30  *
31  * To avoid contention on the shared hashtable, each backend has a
32  * backend-local hashtable (pgStatEntryRefHash) in front of the shared
33  * hashtable, containing references (PgStat_EntryRef) to shared hashtable
34  * entries. The shared hashtable only needs to be accessed when no prior
35  * reference is found in the local hashtable. Besides pointing to the
36  * shared hashtable entry (PgStatShared_HashEntry) PgStat_EntryRef also
37  * contains a pointer to the shared statistics data, as a process-local
38  * address, to reduce access costs.
39  *
40  * The names for structs stored in shared memory are prefixed with
41  * PgStatShared instead of PgStat. Each stats entry in shared memory is
42  * protected by a dedicated lwlock.
43  *
44  * Most stats updates are first accumulated locally in each process as pending
45  * entries, then later flushed to shared memory (just after commit, or by
46  * idle-timeout). This practically eliminates contention on individual stats
47  * entries. For most kinds of variable-numbered pending stats data is stored
48  * in PgStat_EntryRef->pending. All entries with pending data are in the
49  * pgStatPending list. Pending statistics updates are flushed out by
50  * pgstat_report_stat().
51  *
52  * The behavior of different kinds of statistics is determined by the kind's
53  * entry in pgstat_kind_infos, see PgStat_KindInfo for details.
54  *
55  * The consistency of read accesses to statistics can be configured using the
56  * stats_fetch_consistency GUC (see config.sgml and monitoring.sgml for the
57  * settings). When using PGSTAT_FETCH_CONSISTENCY_CACHE or
58  * PGSTAT_FETCH_CONSISTENCY_SNAPSHOT statistics are stored in
59  * pgStatLocal.snapshot.
60  *
61  * To keep things manageable, stats handling is split across several
62  * files. Infrastructure pieces are in:
63  * - pgstat.c - this file, to tie it all together
64  * - pgstat_shmem.c - nearly everything dealing with shared memory, including
65  * the maintenance of hashtable entries
66  * - pgstat_xact.c - transactional integration, including the transactional
67  * creation and dropping of stats entries
68  *
69  * Each statistics kind is handled in a dedicated file:
70  * - pgstat_archiver.c
71  * - pgstat_bgwriter.c
72  * - pgstat_checkpointer.c
73  * - pgstat_database.c
74  * - pgstat_function.c
75  * - pgstat_io.c
76  * - pgstat_relation.c
77  * - pgstat_replslot.c
78  * - pgstat_slru.c
79  * - pgstat_subscription.c
80  * - pgstat_wal.c
81  *
82  * Whenever possible infrastructure files should not contain code related to
83  * specific kinds of stats.
84  *
85  *
86  * Copyright (c) 2001-2023, PostgreSQL Global Development Group
87  *
88  * IDENTIFICATION
89  * src/backend/utils/activity/pgstat.c
90  * ----------
91  */
92 #include "postgres.h"
93 
94 #include <unistd.h>
95 
96 #include "access/transam.h"
97 #include "access/xact.h"
98 #include "lib/dshash.h"
99 #include "pgstat.h"
100 #include "port/atomics.h"
101 #include "storage/fd.h"
102 #include "storage/ipc.h"
103 #include "storage/lwlock.h"
104 #include "storage/pg_shmem.h"
105 #include "storage/shmem.h"
106 #include "utils/guc.h"
107 #include "utils/memutils.h"
108 #include "utils/pgstat_internal.h"
109 #include "utils/timestamp.h"
110 
111 
112 /* ----------
113  * Timer definitions.
114  *
115  * In milliseconds.
116  * ----------
117  */
118 
119 /* minimum interval non-forced stats flushes.*/
120 #define PGSTAT_MIN_INTERVAL 1000
121 /* how long until to block flushing pending stats updates */
122 #define PGSTAT_MAX_INTERVAL 60000
123 /* when to call pgstat_report_stat() again, even when idle */
124 #define PGSTAT_IDLE_INTERVAL 10000
125 
126 /* ----------
127  * Initial size hints for the hash tables used in statistics.
128  * ----------
129  */
130 
131 #define PGSTAT_SNAPSHOT_HASH_SIZE 512
132 
133 
134 /* hash table for statistics snapshots entry */
135 typedef struct PgStat_SnapshotEntry
136 {
138  char status; /* for simplehash use */
139  void *data; /* the stats data itself */
141 
142 
143 /* ----------
144  * Backend-local Hash Table Definitions
145  * ----------
146  */
147 
148 /* for stats snapshot entries */
149 #define SH_PREFIX pgstat_snapshot
150 #define SH_ELEMENT_TYPE PgStat_SnapshotEntry
151 #define SH_KEY_TYPE PgStat_HashKey
152 #define SH_KEY key
153 #define SH_HASH_KEY(tb, key) \
154  pgstat_hash_hash_key(&key, sizeof(PgStat_HashKey), NULL)
155 #define SH_EQUAL(tb, a, b) \
156  pgstat_cmp_hash_key(&a, &b, sizeof(PgStat_HashKey), NULL) == 0
157 #define SH_SCOPE static inline
158 #define SH_DEFINE
159 #define SH_DECLARE
160 #include "lib/simplehash.h"
161 
162 
163 /* ----------
164  * Local function forward declarations
165  * ----------
166  */
167 
168 static void pgstat_write_statsfile(void);
169 static void pgstat_read_statsfile(void);
170 
171 static void pgstat_reset_after_failure(void);
172 
173 static bool pgstat_flush_pending_entries(bool nowait);
174 
175 static void pgstat_prep_snapshot(void);
176 static void pgstat_build_snapshot(void);
177 static void pgstat_build_snapshot_fixed(PgStat_Kind kind);
178 
179 static inline bool pgstat_is_kind_valid(int ikind);
180 
181 
182 /* ----------
183  * GUC parameters
184  * ----------
185  */
186 
187 bool pgstat_track_counts = false;
189 
190 
191 /* ----------
192  * state shared with pgstat_*.c
193  * ----------
194  */
195 
197 
198 
199 /* ----------
200  * Local data
201  *
202  * NB: There should be only variables related to stats infrastructure here,
203  * not for specific kinds of stats.
204  * ----------
205  */
206 
207 /*
208  * Memory contexts containing the pgStatEntryRefHash table, the
209  * pgStatSharedRef entries, and pending data respectively. Mostly to make it
210  * easier to track / attribute memory usage.
211  */
212 
214 
215 /*
216  * Backend local list of PgStat_EntryRef with unflushed pending stats.
217  *
218  * Newly pending entries should only ever be added to the end of the list,
219  * otherwise pgstat_flush_pending_entries() might not see them immediately.
220  */
222 
223 
224 /*
225  * Force the next stats flush to happen regardless of
226  * PGSTAT_MIN_INTERVAL. Useful in test scripts.
227  */
228 static bool pgStatForceNextFlush = false;
229 
230 /*
231  * For assertions that check pgstat is not used before initialization / after
232  * shutdown.
233  */
234 #ifdef USE_ASSERT_CHECKING
235 static bool pgstat_is_initialized = false;
236 static bool pgstat_is_shutdown = false;
237 #endif
238 
239 
240 /*
241  * The different kinds of statistics.
242  *
243  * If reasonably possible, handling specific to one kind of stats should go
244  * through this abstraction, rather than making more of pgstat.c aware.
245  *
246  * See comments for struct PgStat_KindInfo for details about the individual
247  * fields.
248  *
249  * XXX: It'd be nicer to define this outside of this file. But there doesn't
250  * seem to be a great way of doing that, given the split across multiple
251  * files.
252  */
254 
255  /* stats kinds for variable-numbered objects */
256 
258  .name = "database",
259 
260  .fixed_amount = false,
261  /* so pg_stat_database entries can be seen in all databases */
262  .accessed_across_databases = true,
263 
264  .shared_size = sizeof(PgStatShared_Database),
265  .shared_data_off = offsetof(PgStatShared_Database, stats),
266  .shared_data_len = sizeof(((PgStatShared_Database *) 0)->stats),
267  .pending_size = sizeof(PgStat_StatDBEntry),
268 
269  .flush_pending_cb = pgstat_database_flush_cb,
270  .reset_timestamp_cb = pgstat_database_reset_timestamp_cb,
271  },
272 
274  .name = "relation",
275 
276  .fixed_amount = false,
277 
278  .shared_size = sizeof(PgStatShared_Relation),
279  .shared_data_off = offsetof(PgStatShared_Relation, stats),
280  .shared_data_len = sizeof(((PgStatShared_Relation *) 0)->stats),
281  .pending_size = sizeof(PgStat_TableStatus),
282 
283  .flush_pending_cb = pgstat_relation_flush_cb,
284  .delete_pending_cb = pgstat_relation_delete_pending_cb,
285  },
286 
288  .name = "function",
289 
290  .fixed_amount = false,
291 
292  .shared_size = sizeof(PgStatShared_Function),
293  .shared_data_off = offsetof(PgStatShared_Function, stats),
294  .shared_data_len = sizeof(((PgStatShared_Function *) 0)->stats),
295  .pending_size = sizeof(PgStat_FunctionCounts),
296 
297  .flush_pending_cb = pgstat_function_flush_cb,
298  },
299 
301  .name = "replslot",
302 
303  .fixed_amount = false,
304 
305  .accessed_across_databases = true,
306  .named_on_disk = true,
307 
308  .shared_size = sizeof(PgStatShared_ReplSlot),
309  .shared_data_off = offsetof(PgStatShared_ReplSlot, stats),
310  .shared_data_len = sizeof(((PgStatShared_ReplSlot *) 0)->stats),
311 
312  .reset_timestamp_cb = pgstat_replslot_reset_timestamp_cb,
313  .to_serialized_name = pgstat_replslot_to_serialized_name_cb,
314  .from_serialized_name = pgstat_replslot_from_serialized_name_cb,
315  },
316 
318  .name = "subscription",
319 
320  .fixed_amount = false,
321  /* so pg_stat_subscription_stats entries can be seen in all databases */
322  .accessed_across_databases = true,
323 
324  .shared_size = sizeof(PgStatShared_Subscription),
325  .shared_data_off = offsetof(PgStatShared_Subscription, stats),
326  .shared_data_len = sizeof(((PgStatShared_Subscription *) 0)->stats),
327  .pending_size = sizeof(PgStat_BackendSubEntry),
328 
329  .flush_pending_cb = pgstat_subscription_flush_cb,
330  .reset_timestamp_cb = pgstat_subscription_reset_timestamp_cb,
331  },
332 
333 
334  /* stats for fixed-numbered (mostly 1) objects */
335 
337  .name = "archiver",
338 
339  .fixed_amount = true,
340 
341  .reset_all_cb = pgstat_archiver_reset_all_cb,
342  .snapshot_cb = pgstat_archiver_snapshot_cb,
343  },
344 
346  .name = "bgwriter",
347 
348  .fixed_amount = true,
349 
350  .reset_all_cb = pgstat_bgwriter_reset_all_cb,
351  .snapshot_cb = pgstat_bgwriter_snapshot_cb,
352  },
353 
355  .name = "checkpointer",
356 
357  .fixed_amount = true,
358 
359  .reset_all_cb = pgstat_checkpointer_reset_all_cb,
360  .snapshot_cb = pgstat_checkpointer_snapshot_cb,
361  },
362 
363  [PGSTAT_KIND_IO] = {
364  .name = "io",
365 
366  .fixed_amount = true,
367 
368  .reset_all_cb = pgstat_io_reset_all_cb,
369  .snapshot_cb = pgstat_io_snapshot_cb,
370  },
371 
372  [PGSTAT_KIND_SLRU] = {
373  .name = "slru",
374 
375  .fixed_amount = true,
376 
377  .reset_all_cb = pgstat_slru_reset_all_cb,
378  .snapshot_cb = pgstat_slru_snapshot_cb,
379  },
380 
381  [PGSTAT_KIND_WAL] = {
382  .name = "wal",
383 
384  .fixed_amount = true,
385 
386  .reset_all_cb = pgstat_wal_reset_all_cb,
387  .snapshot_cb = pgstat_wal_snapshot_cb,
388  },
389 };
390 
391 
392 /* ------------------------------------------------------------
393  * Functions managing the state of the stats system for all backends.
394  * ------------------------------------------------------------
395  */
396 
397 /*
398  * Read on-disk stats into memory at server start.
399  *
400  * Should only be called by the startup process or in single user mode.
401  */
402 void
404 {
406 }
407 
408 /*
409  * Remove the stats file. This is currently used only if WAL recovery is
410  * needed after a crash.
411  *
412  * Should only be called by the startup process or in single user mode.
413  */
414 void
416 {
417  int ret;
418 
419  /* NB: this needs to be done even in single user mode */
420 
421  ret = unlink(PGSTAT_STAT_PERMANENT_FILENAME);
422  if (ret != 0)
423  {
424  if (errno == ENOENT)
425  elog(DEBUG2,
426  "didn't need to unlink permanent stats file \"%s\" - didn't exist",
428  else
429  ereport(LOG,
431  errmsg("could not unlink permanent statistics file \"%s\": %m",
433  }
434  else
435  {
436  ereport(DEBUG2,
438  errmsg_internal("unlinked permanent statistics file \"%s\"",
440  }
441 
442  /*
443  * Reset stats contents. This will set reset timestamps of fixed-numbered
444  * stats to the current time (no variable stats exist).
445  */
447 }
448 
449 /*
450  * pgstat_before_server_shutdown() needs to be called by exactly one process
451  * during regular server shutdowns. Otherwise all stats will be lost.
452  *
453  * We currently only write out stats for proc_exit(0). We might want to change
454  * that at some point... But right now pgstat_discard_stats() would be called
455  * during the start after a disorderly shutdown, anyway.
456  */
457 void
459 {
460  Assert(pgStatLocal.shmem != NULL);
462 
463  /*
464  * Stats should only be reported after pgstat_initialize() and before
465  * pgstat_shutdown(). This is a convenient point to catch most violations
466  * of this rule.
467  */
468  Assert(pgstat_is_initialized && !pgstat_is_shutdown);
469 
470  /* flush out our own pending changes before writing out */
471  pgstat_report_stat(true);
472 
473  /*
474  * Only write out file during normal shutdown. Don't even signal that
475  * we've shutdown during irregular shutdowns, because the shutdown
476  * sequence isn't coordinated to ensure this backend shuts down last.
477  */
478  if (code == 0)
479  {
480  pgStatLocal.shmem->is_shutdown = true;
482  }
483 }
484 
485 
486 /* ------------------------------------------------------------
487  * Backend initialization / shutdown functions
488  * ------------------------------------------------------------
489  */
490 
491 /*
492  * Shut down a single backend's statistics reporting at process exit.
493  *
494  * Flush out any remaining statistics counts. Without this, operations
495  * triggered during backend exit (such as temp table deletions) won't be
496  * counted.
497  */
498 static void
500 {
501  Assert(!pgstat_is_shutdown);
503 
504  /*
505  * If we got as far as discovering our own database ID, we can flush out
506  * what we did so far. Otherwise, we'd be reporting an invalid database
507  * ID, so forget it. (This means that accesses to pg_database during
508  * failed backend starts might never get counted.)
509  */
512 
513  pgstat_report_stat(true);
514 
515  /* there shouldn't be any pending changes left */
518 
520 
521 #ifdef USE_ASSERT_CHECKING
522  pgstat_is_shutdown = true;
523 #endif
524 }
525 
526 /*
527  * Initialize pgstats state, and set up our on-proc-exit hook. Called from
528  * BaseInit().
529  *
530  * NOTE: MyDatabaseId isn't set yet; so the shutdown hook has to be careful.
531  */
532 void
534 {
535  Assert(!pgstat_is_initialized);
536 
538 
539  pgstat_init_wal();
540 
541  /* Set up a process-exit hook to clean up */
543 
544 #ifdef USE_ASSERT_CHECKING
545  pgstat_is_initialized = true;
546 #endif
547 }
548 
549 
550 /* ------------------------------------------------------------
551  * Public functions used by backends follow
552  * ------------------------------------------------------------
553  */
554 
555 /*
556  * Must be called by processes that performs DML: tcop/postgres.c, logical
557  * receiver processes, SPI worker, etc. to flush pending statistics updates to
558  * shared memory.
559  *
560  * Unless called with 'force', pending stats updates are flushed happen once
561  * per PGSTAT_MIN_INTERVAL (1000ms). When not forced, stats flushes do not
562  * block on lock acquisition, except if stats updates have been pending for
563  * longer than PGSTAT_MAX_INTERVAL (60000ms).
564  *
565  * Whenever pending stats updates remain at the end of pgstat_report_stat() a
566  * suggested idle timeout is returned. Currently this is always
567  * PGSTAT_IDLE_INTERVAL (10000ms). Callers can use the returned time to set up
568  * a timeout after which to call pgstat_report_stat(true), but are not
569  * required to do so.
570  *
571  * Note that this is called only when not within a transaction, so it is fair
572  * to use transaction stop time as an approximation of current time.
573  */
574 long
576 {
577  static TimestampTz pending_since = 0;
578  static TimestampTz last_flush = 0;
579  bool partial_flush;
581  bool nowait;
582 
585 
586  /* "absorb" the forced flush even if there's nothing to flush */
588  {
589  force = true;
590  pgStatForceNextFlush = false;
591  }
592 
593  /* Don't expend a clock check if nothing to do */
595  !have_iostats &&
596  !have_slrustats &&
598  {
599  Assert(pending_since == 0);
600  return 0;
601  }
602 
603  /*
604  * There should never be stats to report once stats are shut down. Can't
605  * assert that before the checks above, as there is an unconditional
606  * pgstat_report_stat() call in pgstat_shutdown_hook() - which at least
607  * the process that ran pgstat_before_server_shutdown() will still call.
608  */
610 
612 
613  if (!force)
614  {
615  if (pending_since > 0 &&
617  {
618  /* don't keep pending updates longer than PGSTAT_MAX_INTERVAL */
619  force = true;
620  }
621  else if (last_flush > 0 &&
623  {
624  /* don't flush too frequently */
625  if (pending_since == 0)
626  pending_since = now;
627 
628  return PGSTAT_IDLE_INTERVAL;
629  }
630  }
631 
633 
634  /* don't wait for lock acquisition when !force */
635  nowait = !force;
636 
637  partial_flush = false;
638 
639  /* flush database / relation / function / ... stats */
640  partial_flush |= pgstat_flush_pending_entries(nowait);
641 
642  /* flush IO stats */
643  partial_flush |= pgstat_flush_io(nowait);
644 
645  /* flush wal stats */
646  partial_flush |= pgstat_flush_wal(nowait);
647 
648  /* flush SLRU stats */
649  partial_flush |= pgstat_slru_flush(nowait);
650 
651  last_flush = now;
652 
653  /*
654  * If some of the pending stats could not be flushed due to lock
655  * contention, let the caller know when to retry.
656  */
657  if (partial_flush)
658  {
659  /* force should have prevented us from getting here */
660  Assert(!force);
661 
662  /* remember since when stats have been pending */
663  if (pending_since == 0)
664  pending_since = now;
665 
666  return PGSTAT_IDLE_INTERVAL;
667  }
668 
669  pending_since = 0;
670 
671  return 0;
672 }
673 
674 /*
675  * Force locally pending stats to be flushed during the next
676  * pgstat_report_stat() call. This is useful for writing tests.
677  */
678 void
680 {
681  pgStatForceNextFlush = true;
682 }
683 
684 /*
685  * Only for use by pgstat_reset_counters()
686  */
687 static bool
689 {
690  return entry->key.dboid == DatumGetObjectId(MyDatabaseId);
691 }
692 
693 /*
694  * Reset counters for our database.
695  *
696  * Permission checking for this function is managed through the normal
697  * GRANT system.
698  */
699 void
701 {
703 
706  ts);
707 }
708 
709 /*
710  * Reset a single variable-numbered entry.
711  *
712  * If the stats kind is within a database, also reset the database's
713  * stat_reset_timestamp.
714  *
715  * Permission checking for this function is managed through the normal
716  * GRANT system.
717  */
718 void
719 pgstat_reset(PgStat_Kind kind, Oid dboid, Oid objoid)
720 {
721  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
723 
724  /* not needed atm, and doesn't make sense with the current signature */
725  Assert(!pgstat_get_kind_info(kind)->fixed_amount);
726 
727  /* reset the "single counter" */
728  pgstat_reset_entry(kind, dboid, objoid, ts);
729 
730  if (!kind_info->accessed_across_databases)
732 }
733 
734 /*
735  * Reset stats for all entries of a kind.
736  *
737  * Permission checking for this function is managed through the normal
738  * GRANT system.
739  */
740 void
742 {
743  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
745 
746  if (kind_info->fixed_amount)
747  kind_info->reset_all_cb(ts);
748  else
750 }
751 
752 
753 /* ------------------------------------------------------------
754  * Fetching of stats
755  * ------------------------------------------------------------
756  */
757 
758 /*
759  * Discard any data collected in the current transaction. Any subsequent
760  * request will cause new snapshots to be read.
761  *
762  * This is also invoked during transaction commit or abort to discard
763  * the no-longer-wanted snapshot.
764  */
765 void
767 {
769 
770  memset(&pgStatLocal.snapshot.fixed_valid, 0,
772  pgStatLocal.snapshot.stats = NULL;
774 
775  /* Release memory, if any was allocated */
777  {
779 
780  /* Reset variables */
782  }
783 
784  /*
785  * Historically the backend_status.c facilities lived in this file, and
786  * were reset with the same function. For now keep it that way, and
787  * forward the reset request.
788  */
790 }
791 
792 void *
793 pgstat_fetch_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
794 {
796  PgStat_EntryRef *entry_ref;
797  void *stats_data;
798  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
799 
800  /* should be called from backends */
802  Assert(!kind_info->fixed_amount);
803 
805 
806  key.kind = kind;
807  key.dboid = dboid;
808  key.objoid = objoid;
809 
810  /* if we need to build a full snapshot, do so */
813 
814  /* if caching is desired, look up in cache */
816  {
817  PgStat_SnapshotEntry *entry = NULL;
818 
819  entry = pgstat_snapshot_lookup(pgStatLocal.snapshot.stats, key);
820 
821  if (entry)
822  return entry->data;
823 
824  /*
825  * If we built a full snapshot and the key is not in
826  * pgStatLocal.snapshot.stats, there are no matching stats.
827  */
829  return NULL;
830  }
831 
833 
834  entry_ref = pgstat_get_entry_ref(kind, dboid, objoid, false, NULL);
835 
836  if (entry_ref == NULL || entry_ref->shared_entry->dropped)
837  {
838  /* create empty entry when using PGSTAT_FETCH_CONSISTENCY_CACHE */
840  {
841  PgStat_SnapshotEntry *entry = NULL;
842  bool found;
843 
844  entry = pgstat_snapshot_insert(pgStatLocal.snapshot.stats, key, &found);
845  Assert(!found);
846  entry->data = NULL;
847  }
848  return NULL;
849  }
850 
851  /*
852  * Allocate in caller's context for PGSTAT_FETCH_CONSISTENCY_NONE,
853  * otherwise we could quickly end up with a fair bit of memory used due to
854  * repeated accesses.
855  */
857  stats_data = palloc(kind_info->shared_data_len);
858  else
860  kind_info->shared_data_len);
861 
862  pgstat_lock_entry_shared(entry_ref, false);
863  memcpy(stats_data,
864  pgstat_get_entry_data(kind, entry_ref->shared_stats),
865  kind_info->shared_data_len);
866  pgstat_unlock_entry(entry_ref);
867 
869  {
870  PgStat_SnapshotEntry *entry = NULL;
871  bool found;
872 
873  entry = pgstat_snapshot_insert(pgStatLocal.snapshot.stats, key, &found);
874  entry->data = stats_data;
875  }
876 
877  return stats_data;
878 }
879 
880 /*
881  * If a stats snapshot has been taken, return the timestamp at which that was
882  * done, and set *have_snapshot to true. Otherwise *have_snapshot is set to
883  * false.
884  */
887 {
889  {
890  *have_snapshot = true;
892  }
893 
894  *have_snapshot = false;
895 
896  return 0;
897 }
898 
899 bool
900 pgstat_have_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
901 {
902  /* fixed-numbered stats always exist */
903  if (pgstat_get_kind_info(kind)->fixed_amount)
904  return true;
905 
906  return pgstat_get_entry_ref(kind, dboid, objoid, false, NULL) != NULL;
907 }
908 
909 /*
910  * Ensure snapshot for fixed-numbered 'kind' exists.
911  *
912  * Typically used by the pgstat_fetch_* functions for a kind of stats, before
913  * massaging the data into the desired format.
914  */
915 void
917 {
919  Assert(pgstat_get_kind_info(kind)->fixed_amount);
920 
923  else
925 
927 }
928 
929 static void
931 {
933  pgStatLocal.snapshot.stats != NULL)
934  return;
935 
938  "PgStat Snapshot",
940 
942  pgstat_snapshot_create(pgStatLocal.snapshot.context,
944  NULL);
945 }
946 
947 static void
949 {
950  dshash_seq_status hstat;
952 
953  /* should only be called when we need a snapshot */
955 
956  /* snapshot already built */
958  return;
959 
961 
962  Assert(pgStatLocal.snapshot.stats->members == 0);
963 
965 
966  /*
967  * Snapshot all variable stats.
968  */
969  dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
970  while ((p = dshash_seq_next(&hstat)) != NULL)
971  {
972  PgStat_Kind kind = p->key.kind;
973  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
974  bool found;
975  PgStat_SnapshotEntry *entry;
976  PgStatShared_Common *stats_data;
977 
978  /*
979  * Check if the stats object should be included in the snapshot.
980  * Unless the stats kind can be accessed from all databases (e.g.,
981  * database stats themselves), we only include stats for the current
982  * database or objects not associated with a database (e.g. shared
983  * relations).
984  */
985  if (p->key.dboid != MyDatabaseId &&
986  p->key.dboid != InvalidOid &&
987  !kind_info->accessed_across_databases)
988  continue;
989 
990  if (p->dropped)
991  continue;
992 
994 
995  stats_data = dsa_get_address(pgStatLocal.dsa, p->body);
996  Assert(stats_data);
997 
998  entry = pgstat_snapshot_insert(pgStatLocal.snapshot.stats, p->key, &found);
999  Assert(!found);
1000 
1002  kind_info->shared_size);
1003 
1004  /*
1005  * Acquire the LWLock directly instead of using
1006  * pg_stat_lock_entry_shared() which requires a reference.
1007  */
1008  LWLockAcquire(&stats_data->lock, LW_SHARED);
1009  memcpy(entry->data,
1010  pgstat_get_entry_data(kind, stats_data),
1011  kind_info->shared_size);
1012  LWLockRelease(&stats_data->lock);
1013  }
1014  dshash_seq_term(&hstat);
1015 
1016  /*
1017  * Build snapshot of all fixed-numbered stats.
1018  */
1019  for (int kind = PGSTAT_KIND_FIRST_VALID; kind <= PGSTAT_KIND_LAST; kind++)
1020  {
1021  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
1022 
1023  if (!kind_info->fixed_amount)
1024  {
1025  Assert(kind_info->snapshot_cb == NULL);
1026  continue;
1027  }
1028 
1030  }
1031 
1033 }
1034 
1035 static void
1037 {
1038  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
1039 
1040  Assert(kind_info->fixed_amount);
1041  Assert(kind_info->snapshot_cb != NULL);
1042 
1044  {
1045  /* rebuild every time */
1046  pgStatLocal.snapshot.fixed_valid[kind] = false;
1047  }
1048  else if (pgStatLocal.snapshot.fixed_valid[kind])
1049  {
1050  /* in snapshot mode we shouldn't get called again */
1052  return;
1053  }
1054 
1056 
1057  kind_info->snapshot_cb();
1058 
1060  pgStatLocal.snapshot.fixed_valid[kind] = true;
1061 }
1062 
1063 
1064 /* ------------------------------------------------------------
1065  * Backend-local pending stats infrastructure
1066  * ------------------------------------------------------------
1067  */
1068 
1069 /*
1070  * Returns the appropriate PgStat_EntryRef, preparing it to receive pending
1071  * stats if not already done.
1072  *
1073  * If created_entry is non-NULL, it'll be set to true if the entry is newly
1074  * created, false otherwise.
1075  */
1077 pgstat_prep_pending_entry(PgStat_Kind kind, Oid dboid, Oid objoid, bool *created_entry)
1078 {
1079  PgStat_EntryRef *entry_ref;
1080 
1081  /* need to be able to flush out */
1082  Assert(pgstat_get_kind_info(kind)->flush_pending_cb != NULL);
1083 
1085  {
1088  "PgStat Pending",
1090  }
1091 
1092  entry_ref = pgstat_get_entry_ref(kind, dboid, objoid,
1093  true, created_entry);
1094 
1095  if (entry_ref->pending == NULL)
1096  {
1097  size_t entrysize = pgstat_get_kind_info(kind)->pending_size;
1098 
1099  Assert(entrysize != (size_t) -1);
1100 
1101  entry_ref->pending = MemoryContextAllocZero(pgStatPendingContext, entrysize);
1103  }
1104 
1105  return entry_ref;
1106 }
1107 
1108 /*
1109  * Return an existing stats entry, or NULL.
1110  *
1111  * This should only be used for helper function for pgstatfuncs.c - outside of
1112  * that it shouldn't be needed.
1113  */
1116 {
1117  PgStat_EntryRef *entry_ref;
1118 
1119  entry_ref = pgstat_get_entry_ref(kind, dboid, objoid, false, NULL);
1120 
1121  if (entry_ref == NULL || entry_ref->pending == NULL)
1122  return NULL;
1123 
1124  return entry_ref;
1125 }
1126 
1127 void
1129 {
1130  PgStat_Kind kind = entry_ref->shared_entry->key.kind;
1131  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
1132  void *pending_data = entry_ref->pending;
1133 
1134  Assert(pending_data != NULL);
1135  /* !fixed_amount stats should be handled explicitly */
1136  Assert(!pgstat_get_kind_info(kind)->fixed_amount);
1137 
1138  if (kind_info->delete_pending_cb)
1139  kind_info->delete_pending_cb(entry_ref);
1140 
1141  pfree(pending_data);
1142  entry_ref->pending = NULL;
1143 
1144  dlist_delete(&entry_ref->pending_node);
1145 }
1146 
1147 /*
1148  * Flush out pending stats for database objects (databases, relations,
1149  * functions).
1150  */
1151 static bool
1153 {
1154  bool have_pending = false;
1155  dlist_node *cur = NULL;
1156 
1157  /*
1158  * Need to be a bit careful iterating over the list of pending entries.
1159  * Processing a pending entry may queue further pending entries to the end
1160  * of the list that we want to process, so a simple iteration won't do.
1161  * Further complicating matters is that we want to delete the current
1162  * entry in each iteration from the list if we flushed successfully.
1163  *
1164  * So we just keep track of the next pointer in each loop iteration.
1165  */
1168 
1169  while (cur)
1170  {
1171  PgStat_EntryRef *entry_ref =
1172  dlist_container(PgStat_EntryRef, pending_node, cur);
1173  PgStat_HashKey key = entry_ref->shared_entry->key;
1174  PgStat_Kind kind = key.kind;
1175  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
1176  bool did_flush;
1177  dlist_node *next;
1178 
1179  Assert(!kind_info->fixed_amount);
1180  Assert(kind_info->flush_pending_cb != NULL);
1181 
1182  /* flush the stats, if possible */
1183  did_flush = kind_info->flush_pending_cb(entry_ref, nowait);
1184 
1185  Assert(did_flush || nowait);
1186 
1187  /* determine next entry, before deleting the pending entry */
1190  else
1191  next = NULL;
1192 
1193  /* if successfully flushed, remove entry */
1194  if (did_flush)
1195  pgstat_delete_pending_entry(entry_ref);
1196  else
1197  have_pending = true;
1198 
1199  cur = next;
1200  }
1201 
1202  Assert(dlist_is_empty(&pgStatPending) == !have_pending);
1203 
1204  return have_pending;
1205 }
1206 
1207 
1208 /* ------------------------------------------------------------
1209  * Helper / infrastructure functions
1210  * ------------------------------------------------------------
1211  */
1212 
1215 {
1216  for (int kind = PGSTAT_KIND_FIRST_VALID; kind <= PGSTAT_KIND_LAST; kind++)
1217  {
1218  if (pg_strcasecmp(kind_str, pgstat_kind_infos[kind].name) == 0)
1219  return kind;
1220  }
1221 
1222  ereport(ERROR,
1223  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1224  errmsg("invalid statistics kind: \"%s\"", kind_str)));
1225  return PGSTAT_KIND_DATABASE; /* avoid compiler warnings */
1226 }
1227 
1228 static inline bool
1230 {
1231  return ikind >= PGSTAT_KIND_FIRST_VALID && ikind <= PGSTAT_KIND_LAST;
1232 }
1233 
1234 const PgStat_KindInfo *
1236 {
1238 
1239  return &pgstat_kind_infos[kind];
1240 }
1241 
1242 /*
1243  * Stats should only be reported after pgstat_initialize() and before
1244  * pgstat_shutdown(). This check is put in a few central places to catch
1245  * violations of this rule more easily.
1246  */
1247 #ifdef USE_ASSERT_CHECKING
1248 void
1249 pgstat_assert_is_up(void)
1250 {
1251  Assert(pgstat_is_initialized && !pgstat_is_shutdown);
1252 }
1253 #endif
1254 
1255 
1256 /* ------------------------------------------------------------
1257  * reading and writing of on-disk stats file
1258  * ------------------------------------------------------------
1259  */
1260 
1261 /* helpers for pgstat_write_statsfile() */
1262 static void
1263 write_chunk(FILE *fpout, void *ptr, size_t len)
1264 {
1265  int rc;
1266 
1267  rc = fwrite(ptr, len, 1, fpout);
1268 
1269  /* we'll check for errors with ferror once at the end */
1270  (void) rc;
1271 }
1272 
1273 #define write_chunk_s(fpout, ptr) write_chunk(fpout, ptr, sizeof(*ptr))
1274 
1275 /*
1276  * This function is called in the last process that is accessing the shared
1277  * stats so locking is not required.
1278  */
1279 static void
1281 {
1282  FILE *fpout;
1283  int32 format_id;
1284  const char *tmpfile = PGSTAT_STAT_PERMANENT_TMPFILE;
1285  const char *statfile = PGSTAT_STAT_PERMANENT_FILENAME;
1286  dshash_seq_status hstat;
1288 
1290 
1291  /* we're shutting down, so it's ok to just override this */
1293 
1294  elog(DEBUG2, "writing stats file \"%s\"", statfile);
1295 
1296  /*
1297  * Open the statistics temp file to write out the current values.
1298  */
1299  fpout = AllocateFile(tmpfile, PG_BINARY_W);
1300  if (fpout == NULL)
1301  {
1302  ereport(LOG,
1304  errmsg("could not open temporary statistics file \"%s\": %m",
1305  tmpfile)));
1306  return;
1307  }
1308 
1309  /*
1310  * Write the file header --- currently just a format ID.
1311  */
1312  format_id = PGSTAT_FILE_FORMAT_ID;
1313  write_chunk_s(fpout, &format_id);
1314 
1315  /*
1316  * XXX: The following could now be generalized to just iterate over
1317  * pgstat_kind_infos instead of knowing about the different kinds of
1318  * stats.
1319  */
1320 
1321  /*
1322  * Write archiver stats struct
1323  */
1326 
1327  /*
1328  * Write bgwriter stats struct
1329  */
1332 
1333  /*
1334  * Write checkpointer stats struct
1335  */
1338 
1339  /*
1340  * Write IO stats struct
1341  */
1344 
1345  /*
1346  * Write SLRU stats struct
1347  */
1350 
1351  /*
1352  * Write WAL stats struct
1353  */
1356 
1357  /*
1358  * Walk through the stats entries
1359  */
1360  dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
1361  while ((ps = dshash_seq_next(&hstat)) != NULL)
1362  {
1363  PgStatShared_Common *shstats;
1364  const PgStat_KindInfo *kind_info = NULL;
1365 
1367 
1368  /* we may have some "dropped" entries not yet removed, skip them */
1369  Assert(!ps->dropped);
1370  if (ps->dropped)
1371  continue;
1372 
1373  shstats = (PgStatShared_Common *) dsa_get_address(pgStatLocal.dsa, ps->body);
1374 
1375  kind_info = pgstat_get_kind_info(ps->key.kind);
1376 
1377  /* if not dropped the valid-entry refcount should exist */
1378  Assert(pg_atomic_read_u32(&ps->refcount) > 0);
1379 
1380  if (!kind_info->to_serialized_name)
1381  {
1382  /* normal stats entry, identified by PgStat_HashKey */
1383  fputc('S', fpout);
1384  write_chunk_s(fpout, &ps->key);
1385  }
1386  else
1387  {
1388  /* stats entry identified by name on disk (e.g. slots) */
1389  NameData name;
1390 
1391  kind_info->to_serialized_name(&ps->key, shstats, &name);
1392 
1393  fputc('N', fpout);
1394  write_chunk_s(fpout, &ps->key.kind);
1395  write_chunk_s(fpout, &name);
1396  }
1397 
1398  /* Write except the header part of the entry */
1399  write_chunk(fpout,
1400  pgstat_get_entry_data(ps->key.kind, shstats),
1401  pgstat_get_entry_len(ps->key.kind));
1402  }
1403  dshash_seq_term(&hstat);
1404 
1405  /*
1406  * No more output to be done. Close the temp file and replace the old
1407  * pgstat.stat with it. The ferror() check replaces testing for error
1408  * after each individual fputc or fwrite (in write_chunk()) above.
1409  */
1410  fputc('E', fpout);
1411 
1412  if (ferror(fpout))
1413  {
1414  ereport(LOG,
1416  errmsg("could not write temporary statistics file \"%s\": %m",
1417  tmpfile)));
1418  FreeFile(fpout);
1419  unlink(tmpfile);
1420  }
1421  else if (FreeFile(fpout) < 0)
1422  {
1423  ereport(LOG,
1425  errmsg("could not close temporary statistics file \"%s\": %m",
1426  tmpfile)));
1427  unlink(tmpfile);
1428  }
1429  else if (rename(tmpfile, statfile) < 0)
1430  {
1431  ereport(LOG,
1433  errmsg("could not rename temporary statistics file \"%s\" to \"%s\": %m",
1434  tmpfile, statfile)));
1435  unlink(tmpfile);
1436  }
1437 }
1438 
1439 /* helpers for pgstat_read_statsfile() */
1440 static bool
1441 read_chunk(FILE *fpin, void *ptr, size_t len)
1442 {
1443  return fread(ptr, 1, len, fpin) == len;
1444 }
1445 
1446 #define read_chunk_s(fpin, ptr) read_chunk(fpin, ptr, sizeof(*ptr))
1447 
1448 /*
1449  * Reads in existing statistics file into the shared stats hash.
1450  *
1451  * This function is called in the only process that is accessing the shared
1452  * stats so locking is not required.
1453  */
1454 static void
1456 {
1457  FILE *fpin;
1458  int32 format_id;
1459  bool found;
1460  const char *statfile = PGSTAT_STAT_PERMANENT_FILENAME;
1462 
1463  /* shouldn't be called from postmaster */
1465 
1466  elog(DEBUG2, "reading stats file \"%s\"", statfile);
1467 
1468  /*
1469  * Try to open the stats file. If it doesn't exist, the backends simply
1470  * returns zero for anything and statistics simply starts from scratch
1471  * with empty counters.
1472  *
1473  * ENOENT is a possibility if stats collection was previously disabled or
1474  * has not yet written the stats file for the first time. Any other
1475  * failure condition is suspicious.
1476  */
1477  if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
1478  {
1479  if (errno != ENOENT)
1480  ereport(LOG,
1482  errmsg("could not open statistics file \"%s\": %m",
1483  statfile)));
1485  return;
1486  }
1487 
1488  /*
1489  * Verify it's of the expected format.
1490  */
1491  if (!read_chunk_s(fpin, &format_id) ||
1492  format_id != PGSTAT_FILE_FORMAT_ID)
1493  goto error;
1494 
1495  /*
1496  * XXX: The following could now be generalized to just iterate over
1497  * pgstat_kind_infos instead of knowing about the different kinds of
1498  * stats.
1499  */
1500 
1501  /*
1502  * Read archiver stats struct
1503  */
1504  if (!read_chunk_s(fpin, &shmem->archiver.stats))
1505  goto error;
1506 
1507  /*
1508  * Read bgwriter stats struct
1509  */
1510  if (!read_chunk_s(fpin, &shmem->bgwriter.stats))
1511  goto error;
1512 
1513  /*
1514  * Read checkpointer stats struct
1515  */
1516  if (!read_chunk_s(fpin, &shmem->checkpointer.stats))
1517  goto error;
1518 
1519  /*
1520  * Read IO stats struct
1521  */
1522  if (!read_chunk_s(fpin, &shmem->io.stats))
1523  goto error;
1524 
1525  /*
1526  * Read SLRU stats struct
1527  */
1528  if (!read_chunk_s(fpin, &shmem->slru.stats))
1529  goto error;
1530 
1531  /*
1532  * Read WAL stats struct
1533  */
1534  if (!read_chunk_s(fpin, &shmem->wal.stats))
1535  goto error;
1536 
1537  /*
1538  * We found an existing statistics file. Read it and put all the hash
1539  * table entries into place.
1540  */
1541  for (;;)
1542  {
1543  int t = fgetc(fpin);
1544 
1545  switch (t)
1546  {
1547  case 'S':
1548  case 'N':
1549  {
1553 
1555 
1556  if (t == 'S')
1557  {
1558  /* normal stats entry, identified by PgStat_HashKey */
1559  if (!read_chunk_s(fpin, &key))
1560  goto error;
1561 
1562  if (!pgstat_is_kind_valid(key.kind))
1563  goto error;
1564  }
1565  else
1566  {
1567  /* stats entry identified by name on disk (e.g. slots) */
1568  const PgStat_KindInfo *kind_info = NULL;
1569  PgStat_Kind kind;
1570  NameData name;
1571 
1572  if (!read_chunk_s(fpin, &kind))
1573  goto error;
1574  if (!read_chunk_s(fpin, &name))
1575  goto error;
1576  if (!pgstat_is_kind_valid(kind))
1577  goto error;
1578 
1579  kind_info = pgstat_get_kind_info(kind);
1580 
1581  if (!kind_info->from_serialized_name)
1582  goto error;
1583 
1584  if (!kind_info->from_serialized_name(&name, &key))
1585  {
1586  /* skip over data for entry we don't care about */
1587  if (fseek(fpin, pgstat_get_entry_len(kind), SEEK_CUR) != 0)
1588  goto error;
1589 
1590  continue;
1591  }
1592 
1593  Assert(key.kind == kind);
1594  }
1595 
1596  /*
1597  * This intentionally doesn't use pgstat_get_entry_ref() -
1598  * putting all stats into checkpointer's
1599  * pgStatEntryRefHash would be wasted effort and memory.
1600  */
1602 
1603  /* don't allow duplicate entries */
1604  if (found)
1605  {
1607  elog(WARNING, "found duplicate stats entry %d/%u/%u",
1608  key.kind, key.dboid, key.objoid);
1609  goto error;
1610  }
1611 
1612  header = pgstat_init_entry(key.kind, p);
1614 
1615  if (!read_chunk(fpin,
1617  pgstat_get_entry_len(key.kind)))
1618  goto error;
1619 
1620  break;
1621  }
1622  case 'E':
1623  /* check that 'E' actually signals end of file */
1624  if (fgetc(fpin) != EOF)
1625  goto error;
1626 
1627  goto done;
1628 
1629  default:
1630  goto error;
1631  }
1632  }
1633 
1634 done:
1635  FreeFile(fpin);
1636 
1637  elog(DEBUG2, "removing permanent stats file \"%s\"", statfile);
1638  unlink(statfile);
1639 
1640  return;
1641 
1642 error:
1643  ereport(LOG,
1644  (errmsg("corrupted statistics file \"%s\"", statfile)));
1645 
1647 
1648  goto done;
1649 }
1650 
1651 /*
1652  * Helper to reset / drop stats after a crash or after restoring stats from
1653  * disk failed, potentially after already loading parts.
1654  */
1655 static void
1657 {
1659 
1660  /* reset fixed-numbered stats */
1661  for (int kind = PGSTAT_KIND_FIRST_VALID; kind <= PGSTAT_KIND_LAST; kind++)
1662  {
1663  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
1664 
1665  if (!kind_info->fixed_amount)
1666  continue;
1667 
1668  kind_info->reset_all_cb(ts);
1669  }
1670 
1671  /* and drop variable-numbered ones */
1673 }
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:236
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
Definition: timestamp.c:1727
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1582
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1546
void pgstat_clear_backend_activity_snapshot(void)
static int32 next
Definition: blutils.c:219
#define PG_BINARY_R
Definition: c.h:1262
signed int int32
Definition: c.h:478
#define unlikely(x)
Definition: c.h:295
#define PG_BINARY_W
Definition: c.h:1263
#define OidIsValid(objectId)
Definition: c.h:759
int64 TimestampTz
Definition: timestamp.h:39
void * dsa_get_address(dsa_area *area, dsa_pointer dp)
Definition: dsa.c:944
void dshash_release_lock(dshash_table *hash_table, void *entry)
Definition: dshash.c:558
void dshash_seq_init(dshash_seq_status *status, dshash_table *hash_table, bool exclusive)
Definition: dshash.c:595
void dshash_seq_term(dshash_seq_status *status)
Definition: dshash.c:704
void * dshash_find_or_insert(dshash_table *hash_table, const void *key, bool *found)
Definition: dshash.c:433
void * dshash_seq_next(dshash_seq_status *status)
Definition: dshash.c:614
struct cursor * cur
Definition: ecpg.c:28
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1156
int errcode_for_file_access(void)
Definition: elog.c:881
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define LOG
Definition: elog.h:31
#define WARNING
Definition: elog.h:36
#define DEBUG2
Definition: elog.h:29
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
const char * name
Definition: encode.c:571
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2384
int FreeFile(FILE *file)
Definition: fd.c:2582
bool IsUnderPostmaster
Definition: globals.c:113
bool IsPostmasterEnvironment
Definition: globals.c:112
Oid MyDatabaseId
Definition: globals.c:89
static void dlist_init(dlist_head *head)
Definition: ilist.h:314
static bool dlist_has_next(const dlist_head *head, const dlist_node *node)
Definition: ilist.h:503
static void dlist_delete(dlist_node *node)
Definition: ilist.h:405
static dlist_node * dlist_next_node(dlist_head *head, dlist_node *node)
Definition: ilist.h:537
static bool dlist_is_empty(const dlist_head *head)
Definition: ilist.h:336
static void dlist_push_tail(dlist_head *head, dlist_node *node)
Definition: ilist.h:364
static dlist_node * dlist_head_node(dlist_head *head)
Definition: ilist.h:565
#define DLIST_STATIC_INIT(name)
Definition: ilist.h:281
#define dlist_container(type, membername, ptr)
Definition: ilist.h:593
struct parser_state ps
void before_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:333
Assert(fmt[strlen(fmt) - 1] !='\n')
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1195
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1803
@ LW_SHARED
Definition: lwlock.h:116
void pfree(void *pointer)
Definition: mcxt.c:1436
MemoryContext TopMemoryContext
Definition: mcxt.c:141
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1048
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1005
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:387
void * palloc(Size size)
Definition: mcxt.c:1210
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_SMALL_SIZES
Definition: memutils.h:163
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:121
void * arg
const void size_t len
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:207
void pgstat_reset(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat.c:719
static bool pgStatForceNextFlush
Definition: pgstat.c:228
int pgstat_fetch_consistency
Definition: pgstat.c:188
#define PGSTAT_MIN_INTERVAL
Definition: pgstat.c:120
void pgstat_snapshot_fixed(PgStat_Kind kind)
Definition: pgstat.c:916
const PgStat_KindInfo * pgstat_get_kind_info(PgStat_Kind kind)
Definition: pgstat.c:1235
static void pgstat_prep_snapshot(void)
Definition: pgstat.c:930
static void pgstat_build_snapshot_fixed(PgStat_Kind kind)
Definition: pgstat.c:1036
#define PGSTAT_SNAPSHOT_HASH_SIZE
Definition: pgstat.c:131
static bool pgstat_is_kind_valid(int ikind)
Definition: pgstat.c:1229
void pgstat_delete_pending_entry(PgStat_EntryRef *entry_ref)
Definition: pgstat.c:1128
void pgstat_reset_counters(void)
Definition: pgstat.c:700
static void pgstat_build_snapshot(void)
Definition: pgstat.c:948
void pgstat_initialize(void)
Definition: pgstat.c:533
bool pgstat_track_counts
Definition: pgstat.c:187
bool pgstat_have_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat.c:900
static void pgstat_write_statsfile(void)
Definition: pgstat.c:1280
long pgstat_report_stat(bool force)
Definition: pgstat.c:575
static void pgstat_read_statsfile(void)
Definition: pgstat.c:1455
void pgstat_reset_of_kind(PgStat_Kind kind)
Definition: pgstat.c:741
static bool pgstat_flush_pending_entries(bool nowait)
Definition: pgstat.c:1152
void pgstat_before_server_shutdown(int code, Datum arg)
Definition: pgstat.c:458
static void pgstat_reset_after_failure(void)
Definition: pgstat.c:1656
void pgstat_force_next_flush(void)
Definition: pgstat.c:679
void * pgstat_fetch_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat.c:793
void pgstat_clear_snapshot(void)
Definition: pgstat.c:766
TimestampTz pgstat_get_stat_snapshot_timestamp(bool *have_snapshot)
Definition: pgstat.c:886
static MemoryContext pgStatPendingContext
Definition: pgstat.c:213
static dlist_head pgStatPending
Definition: pgstat.c:221
static void write_chunk(FILE *fpout, void *ptr, size_t len)
Definition: pgstat.c:1263
void pgstat_restore_stats(void)
Definition: pgstat.c:403
PgStat_EntryRef * pgstat_prep_pending_entry(PgStat_Kind kind, Oid dboid, Oid objoid, bool *created_entry)
Definition: pgstat.c:1077
#define write_chunk_s(fpout, ptr)
Definition: pgstat.c:1273
struct PgStat_SnapshotEntry PgStat_SnapshotEntry
PgStat_EntryRef * pgstat_fetch_pending_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat.c:1115
#define PGSTAT_MAX_INTERVAL
Definition: pgstat.c:122
static bool read_chunk(FILE *fpin, void *ptr, size_t len)
Definition: pgstat.c:1441
#define read_chunk_s(fpin, ptr)
Definition: pgstat.c:1446
static const PgStat_KindInfo pgstat_kind_infos[PGSTAT_NUM_KINDS]
Definition: pgstat.c:253
#define PGSTAT_IDLE_INTERVAL
Definition: pgstat.c:124
PgStat_LocalState pgStatLocal
Definition: pgstat.c:196
void pgstat_discard_stats(void)
Definition: pgstat.c:415
static bool match_db_entries(PgStatShared_HashEntry *entry, Datum match_data)
Definition: pgstat.c:688
PgStat_Kind pgstat_get_kind_from_str(char *kind_str)
Definition: pgstat.c:1214
static void pgstat_shutdown_hook(int code, Datum arg)
Definition: pgstat.c:499
PgStat_Kind
Definition: pgstat.h:36
@ PGSTAT_KIND_DATABASE
Definition: pgstat.h:41
@ PGSTAT_KIND_REPLSLOT
Definition: pgstat.h:44
@ PGSTAT_KIND_ARCHIVER
Definition: pgstat.h:48
@ PGSTAT_KIND_SLRU
Definition: pgstat.h:52
@ PGSTAT_KIND_IO
Definition: pgstat.h:51
@ PGSTAT_KIND_BGWRITER
Definition: pgstat.h:49
@ PGSTAT_KIND_SUBSCRIPTION
Definition: pgstat.h:45
@ PGSTAT_KIND_CHECKPOINTER
Definition: pgstat.h:50
@ PGSTAT_KIND_FUNCTION
Definition: pgstat.h:43
@ PGSTAT_KIND_WAL
Definition: pgstat.h:53
@ PGSTAT_KIND_RELATION
Definition: pgstat.h:42
@ PGSTAT_FETCH_CONSISTENCY_NONE
Definition: pgstat.h:70
@ PGSTAT_FETCH_CONSISTENCY_CACHE
Definition: pgstat.h:71
@ PGSTAT_FETCH_CONSISTENCY_SNAPSHOT
Definition: pgstat.h:72
#define PGSTAT_STAT_PERMANENT_FILENAME
Definition: pgstat.h:28
#define PGSTAT_STAT_PERMANENT_TMPFILE
Definition: pgstat.h:29
#define PGSTAT_NUM_KINDS
Definition: pgstat.h:58
#define PGSTAT_FILE_FORMAT_ID
Definition: pgstat.h:237
#define PGSTAT_KIND_LAST
Definition: pgstat.h:57
#define PGSTAT_KIND_FIRST_VALID
Definition: pgstat.h:56
void pgstat_archiver_reset_all_cb(TimestampTz ts)
void pgstat_archiver_snapshot_cb(void)
void pgstat_bgwriter_reset_all_cb(TimestampTz ts)
void pgstat_bgwriter_snapshot_cb(void)
void pgstat_checkpointer_snapshot_cb(void)
void pgstat_checkpointer_reset_all_cb(TimestampTz ts)
void pgstat_database_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts)
void pgstat_update_dbstats(TimestampTz ts)
void pgstat_reset_database_timestamp(Oid dboid, TimestampTz ts)
void pgstat_report_disconnect(Oid dboid)
bool pgstat_database_flush_cb(PgStat_EntryRef *entry_ref, bool nowait)
bool pgstat_function_flush_cb(PgStat_EntryRef *entry_ref, bool nowait)
struct PgStatShared_Function PgStatShared_Function
static void * pgstat_get_entry_data(PgStat_Kind kind, PgStatShared_Common *entry)
struct PgStatShared_Subscription PgStatShared_Subscription
#define pgstat_assert_is_up()
struct PgStatShared_Relation PgStatShared_Relation
struct PgStatShared_Database PgStatShared_Database
static size_t pgstat_get_entry_len(PgStat_Kind kind)
struct PgStatShared_ReplSlot PgStatShared_ReplSlot
bool pgstat_flush_io(bool nowait)
Definition: pgstat_io.c:95
void pgstat_io_reset_all_cb(TimestampTz ts)
Definition: pgstat_io.c:168
bool have_iostats
Definition: pgstat_io.c:23
void pgstat_io_snapshot_cb(void)
Definition: pgstat_io.c:190
bool pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool nowait)
void pgstat_relation_delete_pending_cb(PgStat_EntryRef *entry_ref)
bool pgstat_replslot_from_serialized_name_cb(const NameData *name, PgStat_HashKey *key)
void pgstat_replslot_to_serialized_name_cb(const PgStat_HashKey *key, const PgStatShared_Common *header, NameData *name)
void pgstat_replslot_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts)
void pgstat_reset_entries_of_kind(PgStat_Kind kind, TimestampTz ts)
Definition: pgstat_shmem.c:989
PgStatShared_Common * pgstat_init_entry(PgStat_Kind kind, PgStatShared_HashEntry *shhashent)
Definition: pgstat_shmem.c:258
bool pgstat_lock_entry_shared(PgStat_EntryRef *entry_ref, bool nowait)
Definition: pgstat_shmem.c:591
void pgstat_attach_shmem(void)
Definition: pgstat_shmem.c:217
void pgstat_reset_entry(PgStat_Kind kind, Oid dboid, Oid objoid, TimestampTz ts)
Definition: pgstat_shmem.c:933
void pgstat_reset_matching_entries(bool(*do_reset)(PgStatShared_HashEntry *, Datum), Datum match_data, TimestampTz ts)
Definition: pgstat_shmem.c:953
void pgstat_drop_all_entries(void)
Definition: pgstat_shmem.c:895
PgStat_EntryRef * pgstat_get_entry_ref(PgStat_Kind kind, Oid dboid, Oid objoid, bool create, bool *created_entry)
Definition: pgstat_shmem.c:397
void pgstat_unlock_entry(PgStat_EntryRef *entry_ref)
Definition: pgstat_shmem.c:603
void pgstat_detach_shmem(void)
Definition: pgstat_shmem.c:237
bool have_slrustats
Definition: pgstat_slru.c:35
void pgstat_slru_snapshot_cb(void)
Definition: pgstat_slru.c:203
bool pgstat_slru_flush(bool nowait)
Definition: pgstat_slru.c:156
void pgstat_slru_reset_all_cb(TimestampTz ts)
Definition: pgstat_slru.c:196
bool pgstat_subscription_flush_cb(PgStat_EntryRef *entry_ref, bool nowait)
void pgstat_subscription_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts)
void pgstat_wal_reset_all_cb(TimestampTz ts)
Definition: pgstat_wal.c:154
bool pgstat_have_pending_wal(void)
Definition: pgstat_wal.c:146
void pgstat_init_wal(void)
Definition: pgstat_wal.c:128
bool pgstat_flush_wal(bool nowait)
Definition: pgstat_wal.c:70
void pgstat_wal_snapshot_cb(void)
Definition: pgstat_wal.c:165
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
uintptr_t Datum
Definition: postgres.h:64
static Oid DatumGetObjectId(Datum X)
Definition: postgres.h:242
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
static void error(void)
Definition: sql-dyntest.c:147
PgStat_ArchiverStats stats
PgStat_BgWriterStats stats
PgStat_CheckpointerStats stats
pg_atomic_uint32 refcount
PgStat_SLRUStats stats[SLRU_NUM_ELEMENTS]
PgStat_WalStats stats
PgStatShared_Common * shared_stats
PgStatShared_HashEntry * shared_entry
dlist_node pending_node
PgStat_Kind kind
bool accessed_across_databases
void(* to_serialized_name)(const PgStat_HashKey *key, const PgStatShared_Common *header, NameData *name)
bool(* from_serialized_name)(const NameData *name, PgStat_HashKey *key)
bool(* flush_pending_cb)(PgStat_EntryRef *sr, bool nowait)
void(* reset_all_cb)(TimestampTz ts)
const char *const name
void(* delete_pending_cb)(PgStat_EntryRef *sr)
void(* snapshot_cb)(void)
PgStat_Snapshot snapshot
dshash_table * shared_hash
PgStat_ShmemControl * shmem
PgStatShared_SLRU slru
PgStatShared_IO io
PgStatShared_Wal wal
PgStatShared_Archiver archiver
PgStatShared_Checkpointer checkpointer
PgStatShared_BgWriter bgwriter
PgStat_HashKey key
Definition: pgstat.c:137
PgStat_CheckpointerStats checkpointer
TimestampTz snapshot_timestamp
MemoryContext context
PgStat_WalStats wal
bool fixed_valid[PGSTAT_NUM_KINDS]
PgStat_ArchiverStats archiver
PgStat_FetchConsistency mode
PgStat_SLRUStats slru[SLRU_NUM_ELEMENTS]
struct pgstat_snapshot_hash * stats
PgStat_BgWriterStats bgwriter
Definition: c.h:725
bool IsTransactionOrTransactionBlock(void)
Definition: xact.c:4841
TimestampTz GetCurrentTransactionStopTimestamp(void)
Definition: xact.c:876