Debian Codegraph @

src/backend/utils/activity/wait_event.c

raw
1 /* ----------
2 * wait_event.c
3 * Wait event reporting infrastructure.
4 *
5 * Copyright (c) 2001-2025, PostgreSQL Global Development Group
6 *
7 *
8 * IDENTIFICATION
9 * src/backend/utils/activity/wait_event.c
10 *
11 * NOTES
12 *
13 * To make pgstat_report_wait_start() and pgstat_report_wait_end() as
14 * lightweight as possible, they do not check if shared memory (MyProc
15 * specifically, where the wait event is stored) is already available. Instead
16 * we initially set my_wait_event_info to a process local variable, which then
17 * is redirected to shared memory using pgstat_set_wait_event_storage(). For
18 * the same reason pgstat_track_activities is not checked - the check adds
19 * more work than it saves.
20 *
21 * ----------
22 */
23 #include "postgres.h"
24
25 #include "storage/lmgr.h" /* for GetLockNameFromTagType */
26 #include "storage/lwlock.h" /* for GetLWLockIdentifier */
27 #include "storage/spin.h"
28 #include "utils/wait_event.h"
29
30
31 static const char *pgstat_get_wait_activity(WaitEventActivity w);
32 static const char *pgstat_get_wait_bufferpin(WaitEventBufferPin w);
33 static const char *pgstat_get_wait_client(WaitEventClient w);
34 static const char *pgstat_get_wait_ipc(WaitEventIPC w);
35 static const char *pgstat_get_wait_timeout(WaitEventTimeout w);
36 static const char *pgstat_get_wait_io(WaitEventIO w);
37
38
39 static uint32 local_my_wait_event_info;
40 uint32 *my_wait_event_info = &local_my_wait_event_info;
41
42 #define WAIT_EVENT_CLASS_MASK 0xFF000000
43 #define WAIT_EVENT_ID_MASK 0x0000FFFF
44
45 /*
46 * Hash tables for storing custom wait event ids and their names in
47 * shared memory.
48 *
49 * WaitEventCustomHashByInfo is used to find the name from wait event
50 * information. Any backend can search it to find custom wait events.
51 *
52 * WaitEventCustomHashByName is used to find the wait event information from a
53 * name. It is used to ensure that no duplicated entries are registered.
54 *
55 * For simplicity, we use the same ID counter across types of custom events.
56 * We could end that anytime the need arises.
57 *
58 * The size of the hash table is based on the assumption that
59 * WAIT_EVENT_CUSTOM_HASH_INIT_SIZE is enough for most cases, and it seems
60 * unlikely that the number of entries will reach
61 * WAIT_EVENT_CUSTOM_HASH_MAX_SIZE.
62 */
63 static HTAB *WaitEventCustomHashByInfo; /* find names from infos */
64 static HTAB *WaitEventCustomHashByName; /* find infos from names */
65
66 #define WAIT_EVENT_CUSTOM_HASH_INIT_SIZE 16
67 #define WAIT_EVENT_CUSTOM_HASH_MAX_SIZE 128
68
69 /* hash table entries */
70 typedef struct WaitEventCustomEntryByInfo
71 {
72 uint32 wait_event_info; /* hash key */
73 char wait_event_name[NAMEDATALEN]; /* custom wait event name */
74 } WaitEventCustomEntryByInfo;
75
76 typedef struct WaitEventCustomEntryByName
77 {
78 char wait_event_name[NAMEDATALEN]; /* hash key */
79 uint32 wait_event_info;
80 } WaitEventCustomEntryByName;
81
82
83 /* dynamic allocation counter for custom wait events */
84 typedef struct WaitEventCustomCounterData
85 {
86 int nextId; /* next ID to assign */
87 slock_t mutex; /* protects the counter */
88 } WaitEventCustomCounterData;
89
90 /* pointer to the shared memory */
91 static WaitEventCustomCounterData *WaitEventCustomCounter;
92
93 /* first event ID of custom wait events */
94 #define WAIT_EVENT_CUSTOM_INITIAL_ID 1
95
96 static uint32 WaitEventCustomNew(uint32 classId, const char *wait_event_name);
97 static const char *GetWaitEventCustomIdentifier(uint32 wait_event_info);
98
99 /*
100 * Return the space for dynamic shared hash tables and dynamic allocation counter.
101 */
102 Size
103 WaitEventCustomShmemSize(void)
104 {
105 Size sz;
106
107 sz = MAXALIGN(sizeof(WaitEventCustomCounterData));
108 sz = add_size(sz, hash_estimate_size(WAIT_EVENT_CUSTOM_HASH_MAX_SIZE,
109 sizeof(WaitEventCustomEntryByInfo)));
110 sz = add_size(sz, hash_estimate_size(WAIT_EVENT_CUSTOM_HASH_MAX_SIZE,
111 sizeof(WaitEventCustomEntryByName)));
112 return sz;
113 }
114
115 /*
116 * Allocate shmem space for dynamic shared hash and dynamic allocation counter.
117 */
118 void
119 WaitEventCustomShmemInit(void)
120 {
121 bool found;
122 HASHCTL info;
123
124 WaitEventCustomCounter = (WaitEventCustomCounterData *)
125 ShmemInitStruct("WaitEventCustomCounterData",
126 sizeof(WaitEventCustomCounterData), &found);
127
128 if (!found)
129 {
130 /* initialize the allocation counter and its spinlock. */
131 WaitEventCustomCounter->nextId = WAIT_EVENT_CUSTOM_INITIAL_ID;
132 SpinLockInit(&WaitEventCustomCounter->mutex);
133 }
134
135 /* initialize or attach the hash tables to store custom wait events */
136 info.keysize = sizeof(uint32);
137 info.entrysize = sizeof(WaitEventCustomEntryByInfo);
138 WaitEventCustomHashByInfo =
139 ShmemInitHash("WaitEventCustom hash by wait event information",
140 WAIT_EVENT_CUSTOM_HASH_INIT_SIZE,
141 WAIT_EVENT_CUSTOM_HASH_MAX_SIZE,
142 &info,
143 HASH_ELEM | HASH_BLOBS);
144
145 /* key is a NULL-terminated string */
146 info.keysize = sizeof(char[NAMEDATALEN]);
147 info.entrysize = sizeof(WaitEventCustomEntryByName);
148 WaitEventCustomHashByName =
149 ShmemInitHash("WaitEventCustom hash by name",
150 WAIT_EVENT_CUSTOM_HASH_INIT_SIZE,
151 WAIT_EVENT_CUSTOM_HASH_MAX_SIZE,
152 &info,
153 HASH_ELEM | HASH_STRINGS);
154 }
155
156 /*
157 * Allocate a new event ID and return the wait event info.
158 *
159 * If the wait event name is already defined, this does not allocate a new
160 * entry; it returns the wait event information associated to the name.
161 */
162 uint32
163 WaitEventExtensionNew(const char *wait_event_name)
164 {
165 return WaitEventCustomNew(PG_WAIT_EXTENSION, wait_event_name);
166 }
167
168 uint32
169 WaitEventInjectionPointNew(const char *wait_event_name)
170 {
171 return WaitEventCustomNew(PG_WAIT_INJECTIONPOINT, wait_event_name);
172 }
173
174 static uint32
175 WaitEventCustomNew(uint32 classId, const char *wait_event_name)
176 {
177 uint16 eventId;
178 bool found;
179 WaitEventCustomEntryByName *entry_by_name;
180 WaitEventCustomEntryByInfo *entry_by_info;
181 uint32 wait_event_info;
182
183 /* Check the limit of the length of the event name */
184 if (strlen(wait_event_name) >= NAMEDATALEN)
185 elog(ERROR,
186 "cannot use custom wait event string longer than %u characters",
187 NAMEDATALEN - 1);
188
189 /*
190 * Check if the wait event info associated to the name is already defined,
191 * and return it if so.
192 */
193 LWLockAcquire(WaitEventCustomLock, LW_SHARED);
194 entry_by_name = (WaitEventCustomEntryByName *)
195 hash_search(WaitEventCustomHashByName, wait_event_name,
196 HASH_FIND, &found);
197 LWLockRelease(WaitEventCustomLock);
198 if (found)
199 {
200 uint32 oldClassId;
201
202 oldClassId = entry_by_name->wait_event_info & WAIT_EVENT_CLASS_MASK;
203 if (oldClassId != classId)
204 ereport(ERROR,
205 (errcode(ERRCODE_DUPLICATE_OBJECT),
206 errmsg("wait event \"%s\" already exists in type \"%s\"",
207 wait_event_name,
208 pgstat_get_wait_event_type(entry_by_name->wait_event_info))));
209 return entry_by_name->wait_event_info;
210 }
211
212 /*
213 * Allocate and register a new wait event. Recheck if the event name
214 * exists, as it could be possible that a concurrent process has inserted
215 * one with the same name since the LWLock acquired again here was
216 * previously released.
217 */
218 LWLockAcquire(WaitEventCustomLock, LW_EXCLUSIVE);
219 entry_by_name = (WaitEventCustomEntryByName *)
220 hash_search(WaitEventCustomHashByName, wait_event_name,
221 HASH_FIND, &found);
222 if (found)
223 {
224 uint32 oldClassId;
225
226 LWLockRelease(WaitEventCustomLock);
227 oldClassId = entry_by_name->wait_event_info & WAIT_EVENT_CLASS_MASK;
228 if (oldClassId != classId)
229 ereport(ERROR,
230 (errcode(ERRCODE_DUPLICATE_OBJECT),
231 errmsg("wait event \"%s\" already exists in type \"%s\"",
232 wait_event_name,
233 pgstat_get_wait_event_type(entry_by_name->wait_event_info))));
234 return entry_by_name->wait_event_info;
235 }
236
237 /* Allocate a new event Id */
238 SpinLockAcquire(&WaitEventCustomCounter->mutex);
239
240 if (WaitEventCustomCounter->nextId >= WAIT_EVENT_CUSTOM_HASH_MAX_SIZE)
241 {
242 SpinLockRelease(&WaitEventCustomCounter->mutex);
243 ereport(ERROR,
244 errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
245 errmsg("too many custom wait events"));
246 }
247
248 eventId = WaitEventCustomCounter->nextId++;
249
250 SpinLockRelease(&WaitEventCustomCounter->mutex);
251
252 /* Register the new wait event */
253 wait_event_info = classId | eventId;
254 entry_by_info = (WaitEventCustomEntryByInfo *)
255 hash_search(WaitEventCustomHashByInfo, &wait_event_info,
256 HASH_ENTER, &found);
257 Assert(!found);
258 strlcpy(entry_by_info->wait_event_name, wait_event_name,
259 sizeof(entry_by_info->wait_event_name));
260
261 entry_by_name = (WaitEventCustomEntryByName *)
262 hash_search(WaitEventCustomHashByName, wait_event_name,
263 HASH_ENTER, &found);
264 Assert(!found);
265 entry_by_name->wait_event_info = wait_event_info;
266
267 LWLockRelease(WaitEventCustomLock);
268
269 return wait_event_info;
270 }
271
272 /*
273 * Return the name of a custom wait event information.
274 */
275 static const char *
276 GetWaitEventCustomIdentifier(uint32 wait_event_info)
277 {
278 bool found;
279 WaitEventCustomEntryByInfo *entry;
280
281 /* Built-in event? */
282 if (wait_event_info == PG_WAIT_EXTENSION)
283 return "Extension";
284
285 /* It is a user-defined wait event, so lookup hash table. */
286 LWLockAcquire(WaitEventCustomLock, LW_SHARED);
287 entry = (WaitEventCustomEntryByInfo *)
288 hash_search(WaitEventCustomHashByInfo, &wait_event_info,
289 HASH_FIND, &found);
290 LWLockRelease(WaitEventCustomLock);
291
292 if (!entry)
293 elog(ERROR,
294 "could not find custom name for wait event information %u",
295 wait_event_info);
296
297 return entry->wait_event_name;
298 }
299
300
301 /*
302 * Returns a list of currently defined custom wait event names. The result is
303 * a palloc'd array, with the number of elements saved in *nwaitevents.
304 */
305 char **
306 GetWaitEventCustomNames(uint32 classId, int *nwaitevents)
307 {
308 char **waiteventnames;
309 WaitEventCustomEntryByName *hentry;
310 HASH_SEQ_STATUS hash_seq;
311 int index;
312 int els;
313
314 LWLockAcquire(WaitEventCustomLock, LW_SHARED);
315
316 /* Now we can safely count the number of entries */
317 els = hash_get_num_entries(WaitEventCustomHashByName);
318
319 /* Allocate enough space for all entries */
320 waiteventnames = palloc(els * sizeof(char *));
321
322 /* Now scan the hash table to copy the data */
323 hash_seq_init(&hash_seq, WaitEventCustomHashByName);
324
325 index = 0;
326 while ((hentry = (WaitEventCustomEntryByName *) hash_seq_search(&hash_seq)) != NULL)
327 {
328 if ((hentry->wait_event_info & WAIT_EVENT_CLASS_MASK) != classId)
329 continue;
330 waiteventnames[index] = pstrdup(hentry->wait_event_name);
331 index++;
332 }
333
334 LWLockRelease(WaitEventCustomLock);
335
336 *nwaitevents = index;
337 return waiteventnames;
338 }
339
340 /*
341 * Configure wait event reporting to report wait events to *wait_event_info.
342 * *wait_event_info needs to be valid until pgstat_reset_wait_event_storage()
343 * is called.
344 *
345 * Expected to be called during backend startup, to point my_wait_event_info
346 * into shared memory.
347 */
348 void
349 pgstat_set_wait_event_storage(uint32 *wait_event_info)
350 {
351 my_wait_event_info = wait_event_info;
352 }
353
354 /*
355 * Reset wait event storage location.
356 *
357 * Expected to be called during backend shutdown, before the location set up
358 * pgstat_set_wait_event_storage() becomes invalid.
359 */
360 void
361 pgstat_reset_wait_event_storage(void)
362 {
363 my_wait_event_info = &local_my_wait_event_info;
364 }
365
366 /* ----------
367 * pgstat_get_wait_event_type() -
368 *
369 * Return a string representing the current wait event type, backend is
370 * waiting on.
371 */
372 const char *
373 pgstat_get_wait_event_type(uint32 wait_event_info)
374 {
375 uint32 classId;
376 const char *event_type;
377
378 /* report process as not waiting. */
379 if (wait_event_info == 0)
380 return NULL;
381
382 classId = wait_event_info & WAIT_EVENT_CLASS_MASK;
383
384 switch (classId)
385 {
386 case PG_WAIT_LWLOCK:
387 event_type = "LWLock";
388 break;
389 case PG_WAIT_LOCK:
390 event_type = "Lock";
391 break;
392 case PG_WAIT_BUFFERPIN:
393 event_type = "BufferPin";
394 break;
395 case PG_WAIT_ACTIVITY:
396 event_type = "Activity";
397 break;
398 case PG_WAIT_CLIENT:
399 event_type = "Client";
400 break;
401 case PG_WAIT_EXTENSION:
402 event_type = "Extension";
403 break;
404 case PG_WAIT_IPC:
405 event_type = "IPC";
406 break;
407 case PG_WAIT_TIMEOUT:
408 event_type = "Timeout";
409 break;
410 case PG_WAIT_IO:
411 event_type = "IO";
412 break;
413 case PG_WAIT_INJECTIONPOINT:
414 event_type = "InjectionPoint";
415 break;
416 default:
417 event_type = "???";
418 break;
419 }
420
421 return event_type;
422 }
423
424 /* ----------
425 * pgstat_get_wait_event() -
426 *
427 * Return a string representing the current wait event, backend is
428 * waiting on.
429 */
430 const char *
431 pgstat_get_wait_event(uint32 wait_event_info)
432 {
433 uint32 classId;
434 uint16 eventId;
435 const char *event_name;
436
437 /* report process as not waiting. */
438 if (wait_event_info == 0)
439 return NULL;
440
441 classId = wait_event_info & WAIT_EVENT_CLASS_MASK;
442 eventId = wait_event_info & WAIT_EVENT_ID_MASK;
443
444 switch (classId)
445 {
446 case PG_WAIT_LWLOCK:
447 event_name = GetLWLockIdentifier(classId, eventId);
448 break;
449 case PG_WAIT_LOCK:
450 event_name = GetLockNameFromTagType(eventId);
451 break;
452 case PG_WAIT_EXTENSION:
453 case PG_WAIT_INJECTIONPOINT:
454 event_name = GetWaitEventCustomIdentifier(wait_event_info);
455 break;
456 case PG_WAIT_BUFFERPIN:
457 {
458 WaitEventBufferPin w = (WaitEventBufferPin) wait_event_info;
459
460 event_name = pgstat_get_wait_bufferpin(w);
461 break;
462 }
463 case PG_WAIT_ACTIVITY:
464 {
465 WaitEventActivity w = (WaitEventActivity) wait_event_info;
466
467 event_name = pgstat_get_wait_activity(w);
468 break;
469 }
470 case PG_WAIT_CLIENT:
471 {
472 WaitEventClient w = (WaitEventClient) wait_event_info;
473
474 event_name = pgstat_get_wait_client(w);
475 break;
476 }
477 case PG_WAIT_IPC:
478 {
479 WaitEventIPC w = (WaitEventIPC) wait_event_info;
480
481 event_name = pgstat_get_wait_ipc(w);
482 break;
483 }
484 case PG_WAIT_TIMEOUT:
485 {
486 WaitEventTimeout w = (WaitEventTimeout) wait_event_info;
487
488 event_name = pgstat_get_wait_timeout(w);
489 break;
490 }
491 case PG_WAIT_IO:
492 {
493 WaitEventIO w = (WaitEventIO) wait_event_info;
494
495 event_name = pgstat_get_wait_io(w);
496 break;
497 }
498 default:
499 event_name = "unknown wait event";
500 break;
501 }
502
503 return event_name;
504 }
505
506 #include "utils/pgstat_wait_event.c"