Line data Source code
1 : /* -------------------------------------------------------------------------
2 : *
3 : * pgstat_shmem.c
4 : * Storage of stats entries in shared memory
5 : *
6 : * Copyright (c) 2001-2025, PostgreSQL Global Development Group
7 : *
8 : * IDENTIFICATION
9 : * src/backend/utils/activity/pgstat_shmem.c
10 : * -------------------------------------------------------------------------
11 : */
12 :
13 : #include "postgres.h"
14 :
15 : #include "pgstat.h"
16 : #include "storage/shmem.h"
17 : #include "utils/memutils.h"
18 : #include "utils/pgstat_internal.h"
19 :
20 :
21 : #define PGSTAT_ENTRY_REF_HASH_SIZE 128
22 :
23 : /* hash table entry for finding the PgStat_EntryRef for a key */
24 : typedef struct PgStat_EntryRefHashEntry
25 : {
26 : PgStat_HashKey key; /* hash key */
27 : char status; /* for simplehash use */
28 : PgStat_EntryRef *entry_ref;
29 : } PgStat_EntryRefHashEntry;
30 :
31 :
32 : /* for references to shared statistics entries */
33 : #define SH_PREFIX pgstat_entry_ref_hash
34 : #define SH_ELEMENT_TYPE PgStat_EntryRefHashEntry
35 : #define SH_KEY_TYPE PgStat_HashKey
36 : #define SH_KEY key
37 : #define SH_HASH_KEY(tb, key) \
38 : pgstat_hash_hash_key(&key, sizeof(PgStat_HashKey), NULL)
39 : #define SH_EQUAL(tb, a, b) \
40 : pgstat_cmp_hash_key(&a, &b, sizeof(PgStat_HashKey), NULL) == 0
41 : #define SH_SCOPE static inline
42 : #define SH_DEFINE
43 : #define SH_DECLARE
44 : #include "lib/simplehash.h"
45 :
46 :
47 : static void pgstat_drop_database_and_contents(Oid dboid);
48 :
49 : static void pgstat_free_entry(PgStatShared_HashEntry *shent, dshash_seq_status *hstat);
50 :
51 : static void pgstat_release_entry_ref(PgStat_HashKey key, PgStat_EntryRef *entry_ref, bool discard_pending);
52 : static bool pgstat_need_entry_refs_gc(void);
53 : static void pgstat_gc_entry_refs(void);
54 : static void pgstat_release_all_entry_refs(bool discard_pending);
55 : typedef bool (*ReleaseMatchCB) (PgStat_EntryRefHashEntry *, Datum data);
56 : static void pgstat_release_matching_entry_refs(bool discard_pending, ReleaseMatchCB match, Datum match_data);
57 :
58 : static void pgstat_setup_memcxt(void);
59 :
60 :
61 : /* parameter for the shared hash */
62 : static const dshash_parameters dsh_params = {
63 : sizeof(PgStat_HashKey),
64 : sizeof(PgStatShared_HashEntry),
65 : pgstat_cmp_hash_key,
66 : pgstat_hash_hash_key,
67 : dshash_memcpy,
68 : LWTRANCHE_PGSTATS_HASH
69 : };
70 :
71 :
72 : /*
73 : * Backend local references to shared stats entries. If there are pending
74 : * updates to a stats entry, the PgStat_EntryRef is added to the pgStatPending
75 : * list.
76 : *
77 : * When a stats entry is dropped each backend needs to release its reference
78 : * to it before the memory can be released. To trigger that
79 : * pgStatLocal.shmem->gc_request_count is incremented - which each backend
80 : * compares to their copy of pgStatSharedRefAge on a regular basis.
81 : */
82 : static pgstat_entry_ref_hash_hash *pgStatEntryRefHash = NULL;
83 : static int pgStatSharedRefAge = 0; /* cache age of pgStatLocal.shmem */
84 :
85 : /*
86 : * Memory contexts containing the pgStatEntryRefHash table and the
87 : * pgStatSharedRef entries respectively. Kept separate to make it easier to
88 : * track / attribute memory usage.
89 : */
90 : static MemoryContext pgStatSharedRefContext = NULL;
91 : static MemoryContext pgStatEntryRefHashContext = NULL;
92 :
93 :
94 : /* ------------------------------------------------------------
95 : * Public functions called from postmaster follow
96 : * ------------------------------------------------------------
97 : */
98 :
99 : /*
100 : * The size of the shared memory allocation for stats stored in the shared
101 : * stats hash table. This allocation will be done as part of the main shared
102 : * memory, rather than dynamic shared memory, allowing it to be initialized in
103 : * postmaster.
104 : */
105 : static Size
106 10570 : pgstat_dsa_init_size(void)
107 : {
108 : Size sz;
109 :
110 : /*
111 : * The dshash header / initial buckets array needs to fit into "plain"
112 : * shared memory, but it's beneficial to not need dsm segments
113 : * immediately. A size of 256kB seems works well and is not
114 : * disproportional compared to other constant sized shared memory
115 : * allocations. NB: To avoid DSMs further, the user can configure
116 : * min_dynamic_shared_memory.
117 : */
118 10570 : sz = 256 * 1024;
119 : Assert(dsa_minimum_size() <= sz);
120 10570 : return MAXALIGN(sz);
121 : }
122 :
123 : /*
124 : * Compute shared memory space needed for cumulative statistics
125 : */
126 : Size
127 6222 : StatsShmemSize(void)
128 : {
129 : Size sz;
130 :
131 6222 : sz = MAXALIGN(sizeof(PgStat_ShmemControl));
132 6222 : sz = add_size(sz, pgstat_dsa_init_size());
133 :
134 : /* Add shared memory for all the custom fixed-numbered statistics */
135 62220 : for (PgStat_Kind kind = PGSTAT_KIND_CUSTOM_MIN; kind <= PGSTAT_KIND_CUSTOM_MAX; kind++)
136 : {
137 55998 : const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
138 :
139 55998 : if (!kind_info)
140 55938 : continue;
141 60 : if (!kind_info->fixed_amount)
142 30 : continue;
143 :
144 : Assert(kind_info->shared_size != 0);
145 :
146 30 : sz += MAXALIGN(kind_info->shared_size);
147 : }
148 :
149 6222 : return sz;
150 : }
151 :
152 : /*
153 : * Initialize cumulative statistics system during startup
154 : */
155 : void
156 2174 : StatsShmemInit(void)
157 : {
158 : bool found;
159 : Size sz;
160 :
161 2174 : sz = StatsShmemSize();
162 2174 : pgStatLocal.shmem = (PgStat_ShmemControl *)
163 2174 : ShmemInitStruct("Shared Memory Stats", sz, &found);
164 :
165 2174 : if (!IsUnderPostmaster)
166 : {
167 : dsa_area *dsa;
168 : dshash_table *dsh;
169 2174 : PgStat_ShmemControl *ctl = pgStatLocal.shmem;
170 2174 : char *p = (char *) ctl;
171 :
172 : Assert(!found);
173 :
174 : /* the allocation of pgStatLocal.shmem itself */
175 2174 : p += MAXALIGN(sizeof(PgStat_ShmemControl));
176 :
177 : /*
178 : * Create a small dsa allocation in plain shared memory. This is
179 : * required because postmaster cannot use dsm segments. It also
180 : * provides a small efficiency win.
181 : */
182 2174 : ctl->raw_dsa_area = p;
183 2174 : dsa = dsa_create_in_place(ctl->raw_dsa_area,
184 : pgstat_dsa_init_size(),
185 : LWTRANCHE_PGSTATS_DSA, NULL);
186 2174 : dsa_pin(dsa);
187 :
188 : /*
189 : * To ensure dshash is created in "plain" shared memory, temporarily
190 : * limit size of dsa to the initial size of the dsa.
191 : */
192 2174 : dsa_set_size_limit(dsa, pgstat_dsa_init_size());
193 :
194 : /*
195 : * With the limit in place, create the dshash table. XXX: It'd be nice
196 : * if there were dshash_create_in_place().
197 : */
198 2174 : dsh = dshash_create(dsa, &dsh_params, NULL);
199 2174 : ctl->hash_handle = dshash_get_hash_table_handle(dsh);
200 :
201 : /* lift limit set above */
202 2174 : dsa_set_size_limit(dsa, -1);
203 :
204 : /*
205 : * Postmaster will never access these again, thus free the local
206 : * dsa/dshash references.
207 : */
208 2174 : dshash_detach(dsh);
209 2174 : dsa_detach(dsa);
210 :
211 2174 : pg_atomic_init_u64(&ctl->gc_request_count, 1);
212 :
213 : /* initialize fixed-numbered stats */
214 71742 : for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
215 : {
216 69568 : const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
217 : char *ptr;
218 :
219 69568 : if (!kind_info || !kind_info->fixed_amount)
220 56514 : continue;
221 :
222 13054 : if (pgstat_is_kind_builtin(kind))
223 13044 : ptr = ((char *) ctl) + kind_info->shared_ctl_off;
224 : else
225 : {
226 10 : int idx = kind - PGSTAT_KIND_CUSTOM_MIN;
227 :
228 : Assert(kind_info->shared_size != 0);
229 10 : ctl->custom_data[idx] = ShmemAlloc(kind_info->shared_size);
230 10 : ptr = ctl->custom_data[idx];
231 : }
232 :
233 13054 : kind_info->init_shmem_cb(ptr);
234 : }
235 : }
236 : else
237 : {
238 : Assert(found);
239 : }
240 2174 : }
241 :
242 : void
243 43786 : pgstat_attach_shmem(void)
244 : {
245 : MemoryContext oldcontext;
246 :
247 : Assert(pgStatLocal.dsa == NULL);
248 :
249 : /* stats shared memory persists for the backend lifetime */
250 43786 : oldcontext = MemoryContextSwitchTo(TopMemoryContext);
251 :
252 43786 : pgStatLocal.dsa = dsa_attach_in_place(pgStatLocal.shmem->raw_dsa_area,
253 : NULL);
254 43786 : dsa_pin_mapping(pgStatLocal.dsa);
255 :
256 87572 : pgStatLocal.shared_hash = dshash_attach(pgStatLocal.dsa, &dsh_params,
257 43786 : pgStatLocal.shmem->hash_handle,
258 : NULL);
259 :
260 43786 : MemoryContextSwitchTo(oldcontext);
261 43786 : }
262 :
263 : void
264 43786 : pgstat_detach_shmem(void)
265 : {
266 : Assert(pgStatLocal.dsa);
267 :
268 : /* we shouldn't leave references to shared stats */
269 43786 : pgstat_release_all_entry_refs(false);
270 :
271 43786 : dshash_detach(pgStatLocal.shared_hash);
272 43786 : pgStatLocal.shared_hash = NULL;
273 :
274 43786 : dsa_detach(pgStatLocal.dsa);
275 :
276 : /*
277 : * dsa_detach() does not decrement the DSA reference count as no segment
278 : * was provided to dsa_attach_in_place(), causing no cleanup callbacks to
279 : * be registered. Hence, release it manually now.
280 : */
281 43786 : dsa_release_in_place(pgStatLocal.shmem->raw_dsa_area);
282 :
283 43786 : pgStatLocal.dsa = NULL;
284 43786 : }
285 :
286 :
287 : /* ------------------------------------------------------------
288 : * Maintenance of shared memory stats entries
289 : * ------------------------------------------------------------
290 : */
291 :
292 : /*
293 : * Initialize entry newly-created.
294 : *
295 : * Returns NULL in the event of an allocation failure, so as callers can
296 : * take cleanup actions as the entry initialized is already inserted in the
297 : * shared hashtable.
298 : */
299 : PgStatShared_Common *
300 637728 : pgstat_init_entry(PgStat_Kind kind,
301 : PgStatShared_HashEntry *shhashent)
302 : {
303 : /* Create new stats entry. */
304 : dsa_pointer chunk;
305 : PgStatShared_Common *shheader;
306 :
307 : /*
308 : * Initialize refcount to 1, marking it as valid / not dropped. The entry
309 : * can't be freed before the initialization because it can't be found as
310 : * long as we hold the dshash partition lock. Caller needs to increase
311 : * further if a longer lived reference is needed.
312 : */
313 637728 : pg_atomic_init_u32(&shhashent->refcount, 1);
314 :
315 : /*
316 : * Initialize "generation" to 0, as freshly created.
317 : */
318 637728 : pg_atomic_init_u32(&shhashent->generation, 0);
319 637728 : shhashent->dropped = false;
320 :
321 637728 : chunk = dsa_allocate_extended(pgStatLocal.dsa,
322 637728 : pgstat_get_kind_info(kind)->shared_size,
323 : DSA_ALLOC_ZERO | DSA_ALLOC_NO_OOM);
324 637728 : if (chunk == InvalidDsaPointer)
325 0 : return NULL;
326 :
327 637728 : shheader = dsa_get_address(pgStatLocal.dsa, chunk);
328 637728 : shheader->magic = 0xdeadbeef;
329 :
330 : /* Link the new entry from the hash entry. */
331 637728 : shhashent->body = chunk;
332 :
333 637728 : LWLockInitialize(&shheader->lock, LWTRANCHE_PGSTATS_DATA);
334 :
335 637728 : return shheader;
336 : }
337 :
338 : static PgStatShared_Common *
339 60 : pgstat_reinit_entry(PgStat_Kind kind, PgStatShared_HashEntry *shhashent)
340 : {
341 : PgStatShared_Common *shheader;
342 :
343 60 : shheader = dsa_get_address(pgStatLocal.dsa, shhashent->body);
344 :
345 : /* mark as not dropped anymore */
346 60 : pg_atomic_fetch_add_u32(&shhashent->refcount, 1);
347 :
348 : /*
349 : * Increment "generation", to let any backend with local references know
350 : * that what they point to is outdated.
351 : */
352 60 : pg_atomic_fetch_add_u32(&shhashent->generation, 1);
353 60 : shhashent->dropped = false;
354 :
355 : /* reinitialize content */
356 : Assert(shheader->magic == 0xdeadbeef);
357 60 : memset(pgstat_get_entry_data(kind, shheader), 0,
358 : pgstat_get_entry_len(kind));
359 :
360 60 : return shheader;
361 : }
362 :
363 : static void
364 7981808 : pgstat_setup_shared_refs(void)
365 : {
366 7981808 : if (likely(pgStatEntryRefHash != NULL))
367 7944922 : return;
368 :
369 36886 : pgStatEntryRefHash =
370 36886 : pgstat_entry_ref_hash_create(pgStatEntryRefHashContext,
371 : PGSTAT_ENTRY_REF_HASH_SIZE, NULL);
372 36886 : pgStatSharedRefAge = pg_atomic_read_u64(&pgStatLocal.shmem->gc_request_count);
373 : Assert(pgStatSharedRefAge != 0);
374 : }
375 :
376 : /*
377 : * Helper function for pgstat_get_entry_ref().
378 : */
379 : static void
380 2094620 : pgstat_acquire_entry_ref(PgStat_EntryRef *entry_ref,
381 : PgStatShared_HashEntry *shhashent,
382 : PgStatShared_Common *shheader)
383 : {
384 : Assert(shheader->magic == 0xdeadbeef);
385 : Assert(pg_atomic_read_u32(&shhashent->refcount) > 0);
386 :
387 2094620 : pg_atomic_fetch_add_u32(&shhashent->refcount, 1);
388 :
389 2094620 : dshash_release_lock(pgStatLocal.shared_hash, shhashent);
390 :
391 2094620 : entry_ref->shared_stats = shheader;
392 2094620 : entry_ref->shared_entry = shhashent;
393 2094620 : entry_ref->generation = pg_atomic_read_u32(&shhashent->generation);
394 2094620 : }
395 :
396 : /*
397 : * Helper function for pgstat_get_entry_ref().
398 : */
399 : static bool
400 7981808 : pgstat_get_entry_ref_cached(PgStat_HashKey key, PgStat_EntryRef **entry_ref_p)
401 : {
402 : bool found;
403 : PgStat_EntryRefHashEntry *cache_entry;
404 :
405 : /*
406 : * We immediately insert a cache entry, because it avoids 1) multiple
407 : * hashtable lookups in case of a cache miss 2) having to deal with
408 : * out-of-memory errors after incrementing PgStatShared_Common->refcount.
409 : */
410 :
411 7981808 : cache_entry = pgstat_entry_ref_hash_insert(pgStatEntryRefHash, key, &found);
412 :
413 7981808 : if (!found || !cache_entry->entry_ref)
414 2261452 : {
415 : PgStat_EntryRef *entry_ref;
416 :
417 2261452 : cache_entry->entry_ref = entry_ref =
418 2261452 : MemoryContextAlloc(pgStatSharedRefContext,
419 : sizeof(PgStat_EntryRef));
420 2261452 : entry_ref->shared_stats = NULL;
421 2261452 : entry_ref->shared_entry = NULL;
422 2261452 : entry_ref->pending = NULL;
423 :
424 2261452 : found = false;
425 : }
426 5720356 : else if (cache_entry->entry_ref->shared_stats == NULL)
427 : {
428 : Assert(cache_entry->entry_ref->pending == NULL);
429 0 : found = false;
430 : }
431 : else
432 : {
433 : PgStat_EntryRef *entry_ref PG_USED_FOR_ASSERTS_ONLY;
434 :
435 5720356 : entry_ref = cache_entry->entry_ref;
436 : Assert(entry_ref->shared_entry != NULL);
437 : Assert(entry_ref->shared_stats != NULL);
438 :
439 : Assert(entry_ref->shared_stats->magic == 0xdeadbeef);
440 : /* should have at least our reference */
441 : Assert(pg_atomic_read_u32(&entry_ref->shared_entry->refcount) > 0);
442 : }
443 :
444 7981808 : *entry_ref_p = cache_entry->entry_ref;
445 7981808 : return found;
446 : }
447 :
448 : /*
449 : * Get a shared stats reference. If create is true, the shared stats object is
450 : * created if it does not exist.
451 : *
452 : * When create is true, and created_entry is non-NULL, it'll be set to true
453 : * if the entry is newly created, false otherwise.
454 : */
455 : PgStat_EntryRef *
456 7981808 : pgstat_get_entry_ref(PgStat_Kind kind, Oid dboid, uint64 objid, bool create,
457 : bool *created_entry)
458 : {
459 : PgStat_HashKey key;
460 : PgStatShared_HashEntry *shhashent;
461 7981808 : PgStatShared_Common *shheader = NULL;
462 : PgStat_EntryRef *entry_ref;
463 :
464 : /* clear padding */
465 7981808 : memset(&key, 0, sizeof(struct PgStat_HashKey));
466 :
467 7981808 : key.kind = kind;
468 7981808 : key.dboid = dboid;
469 7981808 : key.objid = objid;
470 :
471 : /*
472 : * passing in created_entry only makes sense if we possibly could create
473 : * entry.
474 : */
475 : Assert(create || created_entry == NULL);
476 : pgstat_assert_is_up();
477 : Assert(pgStatLocal.shared_hash != NULL);
478 : Assert(!pgStatLocal.shmem->is_shutdown);
479 :
480 7981808 : pgstat_setup_memcxt();
481 7981808 : pgstat_setup_shared_refs();
482 :
483 7981808 : if (created_entry != NULL)
484 214 : *created_entry = false;
485 :
486 : /*
487 : * Check if other backends dropped stats that could not be deleted because
488 : * somebody held references to it. If so, check this backend's references.
489 : * This is not expected to happen often. The location of the check is a
490 : * bit random, but this is a relatively frequently called path, so better
491 : * than most.
492 : */
493 7981808 : if (pgstat_need_entry_refs_gc())
494 12084 : pgstat_gc_entry_refs();
495 :
496 : /*
497 : * First check the lookup cache hashtable in local memory. If we find a
498 : * match here we can avoid taking locks / causing contention.
499 : */
500 7981808 : if (pgstat_get_entry_ref_cached(key, &entry_ref))
501 5720356 : return entry_ref;
502 :
503 : Assert(entry_ref != NULL);
504 :
505 : /*
506 : * Do a lookup in the hash table first - it's quite likely that the entry
507 : * already exists, and that way we only need a shared lock.
508 : */
509 2261452 : shhashent = dshash_find(pgStatLocal.shared_hash, &key, false);
510 :
511 2261452 : if (create && !shhashent)
512 : {
513 : bool shfound;
514 :
515 : /*
516 : * It's possible that somebody created the entry since the above
517 : * lookup. If so, fall through to the same path as if we'd have if it
518 : * already had been created before the dshash_find() calls.
519 : */
520 235840 : shhashent = dshash_find_or_insert(pgStatLocal.shared_hash, &key, &shfound);
521 235840 : if (!shfound)
522 : {
523 235838 : shheader = pgstat_init_entry(kind, shhashent);
524 235838 : if (shheader == NULL)
525 : {
526 : /*
527 : * Failed the allocation of a new entry, so clean up the
528 : * shared hashtable before giving up.
529 : */
530 0 : dshash_delete_entry(pgStatLocal.shared_hash, shhashent);
531 :
532 0 : ereport(ERROR,
533 : (errcode(ERRCODE_OUT_OF_MEMORY),
534 : errmsg("out of memory"),
535 : errdetail("Failed while allocating entry %u/%u/%" PRIu64 ".",
536 : key.kind, key.dboid, key.objid)));
537 : }
538 235838 : pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
539 :
540 235838 : if (created_entry != NULL)
541 96 : *created_entry = true;
542 :
543 235838 : return entry_ref;
544 : }
545 : }
546 :
547 2025614 : if (!shhashent)
548 : {
549 : /*
550 : * If we're not creating, delete the reference again. In all
551 : * likelihood it's just a stats lookup - no point wasting memory for a
552 : * shared ref to nothing...
553 : */
554 166758 : pgstat_release_entry_ref(key, entry_ref, false);
555 :
556 166758 : return NULL;
557 : }
558 : else
559 : {
560 : /*
561 : * Can get here either because dshash_find() found a match, or if
562 : * dshash_find_or_insert() found a concurrently inserted entry.
563 : */
564 :
565 1858856 : if (shhashent->dropped && create)
566 : {
567 : /*
568 : * There are legitimate cases where the old stats entry might not
569 : * yet have been dropped by the time it's reused. The most obvious
570 : * case are replication slot stats, where a new slot can be
571 : * created with the same index just after dropping. But oid
572 : * wraparound can lead to other cases as well. We just reset the
573 : * stats to their plain state, while incrementing its "generation"
574 : * in the shared entry for any remaining local references.
575 : */
576 60 : shheader = pgstat_reinit_entry(kind, shhashent);
577 60 : pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
578 :
579 60 : if (created_entry != NULL)
580 0 : *created_entry = true;
581 :
582 60 : return entry_ref;
583 : }
584 1858796 : else if (shhashent->dropped)
585 : {
586 74 : dshash_release_lock(pgStatLocal.shared_hash, shhashent);
587 74 : pgstat_release_entry_ref(key, entry_ref, false);
588 :
589 74 : return NULL;
590 : }
591 : else
592 : {
593 1858722 : shheader = dsa_get_address(pgStatLocal.dsa, shhashent->body);
594 1858722 : pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
595 :
596 1858722 : return entry_ref;
597 : }
598 : }
599 : }
600 :
601 : static void
602 2261452 : pgstat_release_entry_ref(PgStat_HashKey key, PgStat_EntryRef *entry_ref,
603 : bool discard_pending)
604 : {
605 2261452 : if (entry_ref && entry_ref->pending)
606 : {
607 65360 : if (discard_pending)
608 65360 : pgstat_delete_pending_entry(entry_ref);
609 : else
610 0 : elog(ERROR, "releasing ref with pending data");
611 : }
612 :
613 2261452 : if (entry_ref && entry_ref->shared_stats)
614 : {
615 : Assert(entry_ref->shared_stats->magic == 0xdeadbeef);
616 : Assert(entry_ref->pending == NULL);
617 :
618 : /*
619 : * This can't race with another backend looking up the stats entry and
620 : * increasing the refcount because it is not "legal" to create
621 : * additional references to dropped entries.
622 : */
623 2094620 : if (pg_atomic_fetch_sub_u32(&entry_ref->shared_entry->refcount, 1) == 1)
624 : {
625 : PgStatShared_HashEntry *shent;
626 :
627 : /*
628 : * We're the last referrer to this entry, try to drop the shared
629 : * entry.
630 : */
631 :
632 : /* only dropped entries can reach a 0 refcount */
633 : Assert(entry_ref->shared_entry->dropped);
634 :
635 9700 : shent = dshash_find(pgStatLocal.shared_hash,
636 9700 : &entry_ref->shared_entry->key,
637 : true);
638 9700 : if (!shent)
639 0 : elog(ERROR, "could not find just referenced shared stats entry");
640 :
641 : /*
642 : * This entry may have been reinitialized while trying to release
643 : * it, so double-check that it has not been reused while holding a
644 : * lock on its shared entry.
645 : */
646 9700 : if (pg_atomic_read_u32(&entry_ref->shared_entry->generation) ==
647 9700 : entry_ref->generation)
648 : {
649 : /* Same "generation", so we're OK with the removal */
650 : Assert(pg_atomic_read_u32(&entry_ref->shared_entry->refcount) == 0);
651 : Assert(entry_ref->shared_entry == shent);
652 9700 : pgstat_free_entry(shent, NULL);
653 : }
654 : else
655 : {
656 : /*
657 : * Shared stats entry has been reinitialized, so do not drop
658 : * its shared entry, only release its lock.
659 : */
660 0 : dshash_release_lock(pgStatLocal.shared_hash, shent);
661 : }
662 : }
663 : }
664 :
665 2261452 : if (!pgstat_entry_ref_hash_delete(pgStatEntryRefHash, key))
666 0 : elog(ERROR, "entry ref vanished before deletion");
667 :
668 2261452 : if (entry_ref)
669 2261452 : pfree(entry_ref);
670 2261452 : }
671 :
672 : /*
673 : * Acquire exclusive lock on the entry.
674 : *
675 : * If nowait is true, it's just a conditional acquire, and the result
676 : * *must* be checked to verify success.
677 : * If nowait is false, waits as necessary, always returning true.
678 : */
679 : bool
680 2605448 : pgstat_lock_entry(PgStat_EntryRef *entry_ref, bool nowait)
681 : {
682 2605448 : LWLock *lock = &entry_ref->shared_stats->lock;
683 :
684 2605448 : if (nowait)
685 676232 : return LWLockConditionalAcquire(lock, LW_EXCLUSIVE);
686 :
687 1929216 : LWLockAcquire(lock, LW_EXCLUSIVE);
688 1929216 : return true;
689 : }
690 :
691 : /*
692 : * Acquire shared lock on the entry.
693 : *
694 : * Separate from pgstat_lock_entry() as most callers will need to lock
695 : * exclusively. The wait semantics are identical.
696 : */
697 : bool
698 629938 : pgstat_lock_entry_shared(PgStat_EntryRef *entry_ref, bool nowait)
699 : {
700 629938 : LWLock *lock = &entry_ref->shared_stats->lock;
701 :
702 629938 : if (nowait)
703 0 : return LWLockConditionalAcquire(lock, LW_SHARED);
704 :
705 629938 : LWLockAcquire(lock, LW_SHARED);
706 629938 : return true;
707 : }
708 :
709 : void
710 3235364 : pgstat_unlock_entry(PgStat_EntryRef *entry_ref)
711 : {
712 3235364 : LWLockRelease(&entry_ref->shared_stats->lock);
713 3235364 : }
714 :
715 : /*
716 : * Helper function to fetch and lock shared stats.
717 : */
718 : PgStat_EntryRef *
719 583224 : pgstat_get_entry_ref_locked(PgStat_Kind kind, Oid dboid, uint64 objid,
720 : bool nowait)
721 : {
722 : PgStat_EntryRef *entry_ref;
723 :
724 : /* find shared table stats entry corresponding to the local entry */
725 583224 : entry_ref = pgstat_get_entry_ref(kind, dboid, objid, true, NULL);
726 :
727 : /* lock the shared entry to protect the content, skip if failed */
728 583224 : if (!pgstat_lock_entry(entry_ref, nowait))
729 0 : return NULL;
730 :
731 583224 : return entry_ref;
732 : }
733 :
734 : void
735 3826 : pgstat_request_entry_refs_gc(void)
736 : {
737 3826 : pg_atomic_fetch_add_u64(&pgStatLocal.shmem->gc_request_count, 1);
738 3826 : }
739 :
740 : static bool
741 7981808 : pgstat_need_entry_refs_gc(void)
742 : {
743 : uint64 curage;
744 :
745 7981808 : if (!pgStatEntryRefHash)
746 0 : return false;
747 :
748 : /* should have been initialized when creating pgStatEntryRefHash */
749 : Assert(pgStatSharedRefAge != 0);
750 :
751 7981808 : curage = pg_atomic_read_u64(&pgStatLocal.shmem->gc_request_count);
752 :
753 7981808 : return pgStatSharedRefAge != curage;
754 : }
755 :
756 : static void
757 12084 : pgstat_gc_entry_refs(void)
758 : {
759 : pgstat_entry_ref_hash_iterator i;
760 : PgStat_EntryRefHashEntry *ent;
761 : uint64 curage;
762 :
763 12084 : curage = pg_atomic_read_u64(&pgStatLocal.shmem->gc_request_count);
764 : Assert(curage != 0);
765 :
766 : /*
767 : * Some entries have been dropped or reinitialized. Invalidate cache
768 : * pointer to them.
769 : */
770 12084 : pgstat_entry_ref_hash_start_iterate(pgStatEntryRefHash, &i);
771 1003910 : while ((ent = pgstat_entry_ref_hash_iterate(pgStatEntryRefHash, &i)) != NULL)
772 : {
773 991826 : PgStat_EntryRef *entry_ref = ent->entry_ref;
774 :
775 : Assert(!entry_ref->shared_stats ||
776 : entry_ref->shared_stats->magic == 0xdeadbeef);
777 :
778 : /*
779 : * "generation" checks for the case of entries being reinitialized,
780 : * and "dropped" for the case where these are.. dropped.
781 : */
782 991826 : if (!entry_ref->shared_entry->dropped &&
783 671820 : pg_atomic_read_u32(&entry_ref->shared_entry->generation) ==
784 671820 : entry_ref->generation)
785 671760 : continue;
786 :
787 : /* cannot gc shared ref that has pending data */
788 320066 : if (entry_ref->pending != NULL)
789 310888 : continue;
790 :
791 9178 : pgstat_release_entry_ref(ent->key, entry_ref, false);
792 : }
793 :
794 12084 : pgStatSharedRefAge = curage;
795 12084 : }
796 :
797 : static void
798 36958 : pgstat_release_matching_entry_refs(bool discard_pending, ReleaseMatchCB match,
799 : Datum match_data)
800 : {
801 : pgstat_entry_ref_hash_iterator i;
802 : PgStat_EntryRefHashEntry *ent;
803 :
804 36958 : if (pgStatEntryRefHash == NULL)
805 2 : return;
806 :
807 36956 : pgstat_entry_ref_hash_start_iterate(pgStatEntryRefHash, &i);
808 :
809 2022306 : while ((ent = pgstat_entry_ref_hash_iterate(pgStatEntryRefHash, &i))
810 2022306 : != NULL)
811 : {
812 : Assert(ent->entry_ref != NULL);
813 :
814 1985350 : if (match && !match(ent, match_data))
815 2102 : continue;
816 :
817 1983248 : pgstat_release_entry_ref(ent->key, ent->entry_ref, discard_pending);
818 : }
819 : }
820 :
821 : /*
822 : * Release all local references to shared stats entries.
823 : *
824 : * When a process exits it cannot do so while still holding references onto
825 : * stats entries, otherwise the shared stats entries could never be freed.
826 : */
827 : static void
828 43786 : pgstat_release_all_entry_refs(bool discard_pending)
829 : {
830 43786 : if (pgStatEntryRefHash == NULL)
831 6900 : return;
832 :
833 36886 : pgstat_release_matching_entry_refs(discard_pending, NULL, 0);
834 : Assert(pgStatEntryRefHash->members == 0);
835 36886 : pgstat_entry_ref_hash_destroy(pgStatEntryRefHash);
836 36886 : pgStatEntryRefHash = NULL;
837 : }
838 :
839 : static bool
840 2102 : match_db(PgStat_EntryRefHashEntry *ent, Datum match_data)
841 : {
842 2102 : Oid dboid = DatumGetObjectId(match_data);
843 :
844 2102 : return ent->key.dboid == dboid;
845 : }
846 :
847 : static void
848 72 : pgstat_release_db_entry_refs(Oid dboid)
849 : {
850 72 : pgstat_release_matching_entry_refs( /* discard pending = */ true,
851 : match_db,
852 : ObjectIdGetDatum(dboid));
853 72 : }
854 :
855 :
856 : /* ------------------------------------------------------------
857 : * Dropping and resetting of stats entries
858 : * ------------------------------------------------------------
859 : */
860 :
861 : static void
862 111218 : pgstat_free_entry(PgStatShared_HashEntry *shent, dshash_seq_status *hstat)
863 : {
864 : dsa_pointer pdsa;
865 :
866 : /*
867 : * Fetch dsa pointer before deleting entry - that way we can free the
868 : * memory after releasing the lock.
869 : */
870 111218 : pdsa = shent->body;
871 :
872 111218 : if (!hstat)
873 102416 : dshash_delete_entry(pgStatLocal.shared_hash, shent);
874 : else
875 8802 : dshash_delete_current(hstat);
876 :
877 111218 : dsa_free(pgStatLocal.dsa, pdsa);
878 111218 : }
879 :
880 : /*
881 : * Helper for both pgstat_drop_database_and_contents() and
882 : * pgstat_drop_entry(). If hstat is non-null delete the shared entry using
883 : * dshash_delete_current(), otherwise use dshash_delete_entry(). In either
884 : * case the entry needs to be already locked.
885 : */
886 : static bool
887 111278 : pgstat_drop_entry_internal(PgStatShared_HashEntry *shent,
888 : dshash_seq_status *hstat)
889 : {
890 : Assert(shent->body != InvalidDsaPointer);
891 :
892 : /* should already have released local reference */
893 111278 : if (pgStatEntryRefHash)
894 : Assert(!pgstat_entry_ref_hash_lookup(pgStatEntryRefHash, shent->key));
895 :
896 : /*
897 : * Signal that the entry is dropped - this will eventually cause other
898 : * backends to release their references.
899 : */
900 111278 : if (shent->dropped)
901 0 : elog(ERROR,
902 : "trying to drop stats entry already dropped: kind=%s dboid=%u objid=%" PRIu64 " refcount=%u generation=%u",
903 : pgstat_get_kind_info(shent->key.kind)->name,
904 : shent->key.dboid,
905 : shent->key.objid,
906 : pg_atomic_read_u32(&shent->refcount),
907 : pg_atomic_read_u32(&shent->generation));
908 111278 : shent->dropped = true;
909 :
910 : /* release refcount marking entry as not dropped */
911 111278 : if (pg_atomic_sub_fetch_u32(&shent->refcount, 1) == 0)
912 : {
913 101518 : pgstat_free_entry(shent, hstat);
914 101518 : return true;
915 : }
916 : else
917 : {
918 9760 : if (!hstat)
919 9760 : dshash_release_lock(pgStatLocal.shared_hash, shent);
920 9760 : return false;
921 : }
922 : }
923 :
924 : /*
925 : * Drop stats for the database and all the objects inside that database.
926 : */
927 : static void
928 72 : pgstat_drop_database_and_contents(Oid dboid)
929 : {
930 : dshash_seq_status hstat;
931 : PgStatShared_HashEntry *p;
932 72 : uint64 not_freed_count = 0;
933 :
934 : Assert(OidIsValid(dboid));
935 :
936 : Assert(pgStatLocal.shared_hash != NULL);
937 :
938 : /*
939 : * This backend might very well be the only backend holding a reference to
940 : * about-to-be-dropped entries. Ensure that we're not preventing it from
941 : * being cleaned up till later.
942 : *
943 : * Doing this separately from the dshash iteration below avoids having to
944 : * do so while holding a partition lock on the shared hashtable.
945 : */
946 72 : pgstat_release_db_entry_refs(dboid);
947 :
948 : /* some of the dshash entries are to be removed, take exclusive lock. */
949 72 : dshash_seq_init(&hstat, pgStatLocal.shared_hash, true);
950 26776 : while ((p = dshash_seq_next(&hstat)) != NULL)
951 : {
952 26704 : if (p->dropped)
953 2 : continue;
954 :
955 26702 : if (p->key.dboid != dboid)
956 18014 : continue;
957 :
958 8688 : if (!pgstat_drop_entry_internal(p, &hstat))
959 : {
960 : /*
961 : * Even statistics for a dropped database might currently be
962 : * accessed (consider e.g. database stats for pg_stat_database).
963 : */
964 0 : not_freed_count++;
965 : }
966 : }
967 72 : dshash_seq_term(&hstat);
968 :
969 : /*
970 : * If some of the stats data could not be freed, signal the reference
971 : * holders to run garbage collection of their cached pgStatLocal.shmem.
972 : */
973 72 : if (not_freed_count > 0)
974 0 : pgstat_request_entry_refs_gc();
975 72 : }
976 :
977 : /*
978 : * Drop a single stats entry.
979 : *
980 : * This routine returns false if the stats entry of the dropped object could
981 : * not be freed, true otherwise.
982 : *
983 : * The callers of this function should call pgstat_request_entry_refs_gc()
984 : * if the stats entry could not be freed, to ensure that this entry's memory
985 : * can be reclaimed later by a different backend calling
986 : * pgstat_gc_entry_refs().
987 : */
988 : bool
989 148164 : pgstat_drop_entry(PgStat_Kind kind, Oid dboid, uint64 objid)
990 : {
991 : PgStat_HashKey key;
992 : PgStatShared_HashEntry *shent;
993 148164 : bool freed = true;
994 :
995 : /* clear padding */
996 148164 : memset(&key, 0, sizeof(struct PgStat_HashKey));
997 :
998 148164 : key.kind = kind;
999 148164 : key.dboid = dboid;
1000 148164 : key.objid = objid;
1001 :
1002 : /* delete local reference */
1003 148164 : if (pgStatEntryRefHash)
1004 : {
1005 : PgStat_EntryRefHashEntry *lohashent =
1006 141254 : pgstat_entry_ref_hash_lookup(pgStatEntryRefHash, key);
1007 :
1008 141254 : if (lohashent)
1009 102194 : pgstat_release_entry_ref(lohashent->key, lohashent->entry_ref,
1010 : true);
1011 : }
1012 :
1013 : /* mark entry in shared hashtable as deleted, drop if possible */
1014 148164 : shent = dshash_find(pgStatLocal.shared_hash, &key, true);
1015 148164 : if (shent)
1016 : {
1017 102476 : freed = pgstat_drop_entry_internal(shent, NULL);
1018 :
1019 : /*
1020 : * Database stats contain other stats. Drop those as well when
1021 : * dropping the database. XXX: Perhaps this should be done in a
1022 : * slightly more principled way? But not obvious what that'd look
1023 : * like, and so far this is the only case...
1024 : */
1025 102476 : if (key.kind == PGSTAT_KIND_DATABASE)
1026 72 : pgstat_drop_database_and_contents(key.dboid);
1027 : }
1028 :
1029 148164 : return freed;
1030 : }
1031 :
1032 : /*
1033 : * Scan through the shared hashtable of stats, dropping statistics if
1034 : * approved by the optional do_drop() function.
1035 : */
1036 : void
1037 462 : pgstat_drop_matching_entries(bool (*do_drop) (PgStatShared_HashEntry *, Datum),
1038 : Datum match_data)
1039 : {
1040 : dshash_seq_status hstat;
1041 : PgStatShared_HashEntry *ps;
1042 462 : uint64 not_freed_count = 0;
1043 :
1044 : /* entries are removed, take an exclusive lock */
1045 462 : dshash_seq_init(&hstat, pgStatLocal.shared_hash, true);
1046 640 : while ((ps = dshash_seq_next(&hstat)) != NULL)
1047 : {
1048 178 : if (ps->dropped)
1049 0 : continue;
1050 :
1051 178 : if (do_drop != NULL && !do_drop(ps, match_data))
1052 64 : continue;
1053 :
1054 : /* delete local reference */
1055 114 : if (pgStatEntryRefHash)
1056 : {
1057 : PgStat_EntryRefHashEntry *lohashent =
1058 2 : pgstat_entry_ref_hash_lookup(pgStatEntryRefHash, ps->key);
1059 :
1060 2 : if (lohashent)
1061 0 : pgstat_release_entry_ref(lohashent->key, lohashent->entry_ref,
1062 : true);
1063 : }
1064 :
1065 114 : if (!pgstat_drop_entry_internal(ps, &hstat))
1066 0 : not_freed_count++;
1067 : }
1068 462 : dshash_seq_term(&hstat);
1069 :
1070 462 : if (not_freed_count > 0)
1071 0 : pgstat_request_entry_refs_gc();
1072 462 : }
1073 :
1074 : /*
1075 : * Scan through the shared hashtable of stats and drop all entries.
1076 : */
1077 : void
1078 460 : pgstat_drop_all_entries(void)
1079 : {
1080 460 : pgstat_drop_matching_entries(NULL, 0);
1081 460 : }
1082 :
1083 : static void
1084 17486 : shared_stat_reset_contents(PgStat_Kind kind, PgStatShared_Common *header,
1085 : TimestampTz ts)
1086 : {
1087 17486 : const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
1088 :
1089 17486 : memset(pgstat_get_entry_data(kind, header), 0,
1090 : pgstat_get_entry_len(kind));
1091 :
1092 17486 : if (kind_info->reset_timestamp_cb)
1093 400 : kind_info->reset_timestamp_cb(header, ts);
1094 17486 : }
1095 :
1096 : /*
1097 : * Reset one variable-numbered stats entry.
1098 : */
1099 : void
1100 372 : pgstat_reset_entry(PgStat_Kind kind, Oid dboid, uint64 objid, TimestampTz ts)
1101 : {
1102 : PgStat_EntryRef *entry_ref;
1103 :
1104 : Assert(!pgstat_get_kind_info(kind)->fixed_amount);
1105 :
1106 372 : entry_ref = pgstat_get_entry_ref(kind, dboid, objid, false, NULL);
1107 372 : if (!entry_ref || entry_ref->shared_entry->dropped)
1108 2 : return;
1109 :
1110 370 : (void) pgstat_lock_entry(entry_ref, false);
1111 370 : shared_stat_reset_contents(kind, entry_ref->shared_stats, ts);
1112 370 : pgstat_unlock_entry(entry_ref);
1113 : }
1114 :
1115 : /*
1116 : * Scan through the shared hashtable of stats, resetting statistics if
1117 : * approved by the provided do_reset() function.
1118 : */
1119 : void
1120 34 : pgstat_reset_matching_entries(bool (*do_reset) (PgStatShared_HashEntry *, Datum),
1121 : Datum match_data, TimestampTz ts)
1122 : {
1123 : dshash_seq_status hstat;
1124 : PgStatShared_HashEntry *p;
1125 :
1126 : /* dshash entry is not modified, take shared lock */
1127 34 : dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
1128 25770 : while ((p = dshash_seq_next(&hstat)) != NULL)
1129 : {
1130 : PgStatShared_Common *header;
1131 :
1132 25736 : if (p->dropped)
1133 2 : continue;
1134 :
1135 25734 : if (!do_reset(p, match_data))
1136 8618 : continue;
1137 :
1138 17116 : header = dsa_get_address(pgStatLocal.dsa, p->body);
1139 :
1140 17116 : LWLockAcquire(&header->lock, LW_EXCLUSIVE);
1141 :
1142 17116 : shared_stat_reset_contents(p->key.kind, header, ts);
1143 :
1144 17116 : LWLockRelease(&header->lock);
1145 : }
1146 34 : dshash_seq_term(&hstat);
1147 34 : }
1148 :
1149 : static bool
1150 2964 : match_kind(PgStatShared_HashEntry *p, Datum match_data)
1151 : {
1152 2964 : return p->key.kind == DatumGetInt32(match_data);
1153 : }
1154 :
1155 : void
1156 8 : pgstat_reset_entries_of_kind(PgStat_Kind kind, TimestampTz ts)
1157 : {
1158 8 : pgstat_reset_matching_entries(match_kind, Int32GetDatum(kind), ts);
1159 8 : }
1160 :
1161 : static void
1162 7981808 : pgstat_setup_memcxt(void)
1163 : {
1164 7981808 : if (unlikely(!pgStatSharedRefContext))
1165 36886 : pgStatSharedRefContext =
1166 36886 : AllocSetContextCreate(TopMemoryContext,
1167 : "PgStat Shared Ref",
1168 : ALLOCSET_SMALL_SIZES);
1169 7981808 : if (unlikely(!pgStatEntryRefHashContext))
1170 36886 : pgStatEntryRefHashContext =
1171 36886 : AllocSetContextCreate(TopMemoryContext,
1172 : "PgStat Shared Ref Hash",
1173 : ALLOCSET_SMALL_SIZES);
1174 7981808 : }
|
