Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * stashpersist.c
4 : * Persistence support for pg_stash_advice.
5 : *
6 : * Copyright (c) 2016-2026, PostgreSQL Global Development Group
7 : *
8 : * contrib/pg_stash_advice/stashpersist.c
9 : *
10 : *-------------------------------------------------------------------------
11 : */
12 : #include "postgres.h"
13 :
14 : #include <sys/stat.h>
15 :
16 : #include "common/hashfn.h"
17 : #include "miscadmin.h"
18 : #include "pg_stash_advice.h"
19 : #include "postmaster/bgworker.h"
20 : #include "postmaster/interrupt.h"
21 : #include "storage/fd.h"
22 : #include "storage/ipc.h"
23 : #include "storage/latch.h"
24 : #include "storage/proc.h"
25 : #include "storage/procsignal.h"
26 : #include "utils/backend_status.h"
27 : #include "utils/guc.h"
28 : #include "utils/memutils.h"
29 : #include "utils/timestamp.h"
30 :
31 : typedef struct pgsa_writer_context
32 : {
33 : char pathname[MAXPGPATH];
34 : FILE *file;
35 : pgsa_stash_name_table_hash *nhash;
36 : StringInfoData buf;
37 : int entries_written;
38 : } pgsa_writer_context;
39 :
40 : /*
41 : * A parsed entry line, with pointers into the slurp buffer.
42 : */
43 : typedef struct pgsa_saved_entry
44 : {
45 : char *stash_name;
46 : int64 queryId;
47 : char *advice_string;
48 : } pgsa_saved_entry;
49 :
50 : /*
51 : * simplehash for detecting duplicate stash names during parsing.
52 : * Keyed by stash name (char *), pointing into the slurp buffer.
53 : */
54 : typedef struct pgsa_saved_stash
55 : {
56 : uint32 status;
57 : char *name;
58 : } pgsa_saved_stash;
59 :
60 : #define SH_PREFIX pgsa_saved_stash_table
61 : #define SH_ELEMENT_TYPE pgsa_saved_stash
62 : #define SH_KEY_TYPE char *
63 : #define SH_KEY name
64 : #define SH_HASH_KEY(tb, key) hash_bytes((const unsigned char *) (key), strlen(key))
65 : #define SH_EQUAL(tb, a, b) (strcmp(a, b) == 0)
66 : #define SH_SCOPE static inline
67 : #define SH_DEFINE
68 : #define SH_DECLARE
69 : #include "lib/simplehash.h"
70 :
71 : extern PGDLLEXPORT void pg_stash_advice_worker_main(Datum main_arg);
72 : static void pgsa_append_tsv_escaped_string(StringInfo buf, const char *str);
73 : static void pgsa_detach_shmem(int code, Datum arg);
74 : static char *pgsa_next_tsv_field(char **cursor);
75 : static void pgsa_read_from_disk(void);
76 : static void pgsa_restore_entries(pgsa_saved_entry *entries, int num_entries);
77 : static void pgsa_restore_stashes(pgsa_saved_stash_table_hash *saved_stashes);
78 : static void pgsa_unescape_tsv_field(char *str, const char *filename,
79 : unsigned lineno);
80 : static void pgsa_write_entries(pgsa_writer_context *wctx);
81 : pg_noreturn static void pgsa_write_error(pgsa_writer_context *wctx);
82 : static void pgsa_write_stashes(pgsa_writer_context *wctx);
83 : static void pgsa_write_to_disk(void);
84 :
85 : /*
86 : * Background worker entry point for pg_stash_advice persistence.
87 : *
88 : * On startup, if stashes_ready is set, we load previously saved
89 : * stash data from disk. Then we enter a loop, periodically checking whether
90 : * any changes have been made (via the change_count atomic counter) and
91 : * writing them to disk. On shutdown, we perform a final write.
92 : */
93 : PGDLLEXPORT void
94 4 : pg_stash_advice_worker_main(Datum main_arg)
95 : {
96 : uint64 last_change_count;
97 4 : TimestampTz last_write_time = 0;
98 :
99 : /* Establish signal handlers; once that's done, unblock signals. */
100 4 : pqsignal(SIGTERM, SignalHandlerForShutdownRequest);
101 4 : pqsignal(SIGHUP, SignalHandlerForConfigReload);
102 4 : pqsignal(SIGUSR1, procsignal_sigusr1_handler);
103 4 : BackgroundWorkerUnblockSignals();
104 :
105 : /* Log a debug message */
106 4 : ereport(DEBUG1,
107 : errmsg("pg_stash_advice worker started"));
108 :
109 : /* Set up session user so pgstat can report it. */
110 4 : InitializeSessionUserIdStandalone();
111 :
112 : /* Report this worker in pg_stat_activity. */
113 4 : pgstat_beinit();
114 4 : pgstat_bestart_initial();
115 4 : pgstat_bestart_final();
116 :
117 : /* Attach to shared memory structures. */
118 4 : pgsa_attach();
119 :
120 : /* Set on-detach hook so that our PID will be cleared on exit. */
121 4 : before_shmem_exit(pgsa_detach_shmem, 0);
122 :
123 : /*
124 : * Store our PID in shared memory, unless there's already another worker
125 : * running, in which case just exit.
126 : */
127 4 : LWLockAcquire(&pgsa_state->lock, LW_EXCLUSIVE);
128 4 : if (pgsa_state->bgworker_pid != InvalidPid)
129 : {
130 0 : LWLockRelease(&pgsa_state->lock);
131 0 : ereport(LOG,
132 : (errmsg("pg_stash_advice worker is already running under PID %d",
133 : (int) pgsa_state->bgworker_pid)));
134 0 : return;
135 : }
136 4 : pgsa_state->bgworker_pid = MyProcPid;
137 4 : LWLockRelease(&pgsa_state->lock);
138 :
139 : /*
140 : * If pg_stash_advice.persist was set to true during
141 : * process_shared_preload_libraries() and the data has not yet been
142 : * successfully loaded, load it now.
143 : */
144 4 : if (pg_atomic_unlocked_test_flag(&pgsa_state->stashes_ready))
145 : {
146 4 : pgsa_read_from_disk();
147 4 : pg_atomic_test_set_flag(&pgsa_state->stashes_ready);
148 : }
149 :
150 : /* Note the current change count so we can detect future changes. */
151 4 : last_change_count = pg_atomic_read_u64(&pgsa_state->change_count);
152 :
153 : /* Periodically write to disk until terminated. */
154 12 : while (!ShutdownRequestPending)
155 : {
156 : /* In case of a SIGHUP, just reload the configuration. */
157 8 : if (ConfigReloadPending)
158 : {
159 0 : ConfigReloadPending = false;
160 0 : ProcessConfigFile(PGC_SIGHUP);
161 : }
162 :
163 8 : if (pg_stash_advice_persist_interval <= 0)
164 : {
165 : /* Only writing at shutdown, so just wait forever. */
166 8 : (void) WaitLatch(MyLatch,
167 : WL_LATCH_SET | WL_EXIT_ON_PM_DEATH,
168 : -1L,
169 : PG_WAIT_EXTENSION);
170 : }
171 : else
172 : {
173 : TimestampTz next_write_time;
174 : long delay_in_ms;
175 : uint64 current_change_count;
176 :
177 : /* Compute when the next write should happen. */
178 0 : next_write_time =
179 0 : TimestampTzPlusMilliseconds(last_write_time,
180 : pg_stash_advice_persist_interval * 1000);
181 : delay_in_ms =
182 0 : TimestampDifferenceMilliseconds(GetCurrentTimestamp(),
183 : next_write_time);
184 :
185 : /*
186 : * When we reach next_write_time, we always update last_write_time
187 : * (which is really the time at which we last considered writing),
188 : * but we only actually write to disk if something has changed.
189 : */
190 0 : if (delay_in_ms <= 0)
191 : {
192 : current_change_count =
193 0 : pg_atomic_read_u64(&pgsa_state->change_count);
194 0 : if (current_change_count != last_change_count)
195 : {
196 0 : pgsa_write_to_disk();
197 0 : last_change_count = current_change_count;
198 : }
199 0 : last_write_time = GetCurrentTimestamp();
200 0 : continue;
201 : }
202 :
203 : /* Sleep until the next write time. */
204 0 : (void) WaitLatch(MyLatch,
205 : WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
206 : delay_in_ms,
207 : PG_WAIT_EXTENSION);
208 : }
209 :
210 8 : ResetLatch(MyLatch);
211 : }
212 :
213 : /* Write one last time before exiting. */
214 4 : pgsa_write_to_disk();
215 : }
216 :
217 : /*
218 : * Clear our PID from shared memory on exit.
219 : */
220 : static void
221 4 : pgsa_detach_shmem(int code, Datum arg)
222 : {
223 4 : LWLockAcquire(&pgsa_state->lock, LW_EXCLUSIVE);
224 4 : if (pgsa_state->bgworker_pid == MyProcPid)
225 4 : pgsa_state->bgworker_pid = InvalidPid;
226 4 : LWLockRelease(&pgsa_state->lock);
227 4 : }
228 :
229 : /*
230 : * Load advice stash data from a dump file on disk, if there is one.
231 : */
232 : static void
233 4 : pgsa_read_from_disk(void)
234 : {
235 : struct stat statbuf;
236 : FILE *file;
237 : char *filebuf;
238 : size_t nread;
239 : char *p;
240 : unsigned lineno;
241 : pgsa_saved_stash_table_hash *saved_stashes;
242 4 : int num_stashes = 0;
243 : pgsa_saved_entry *entries;
244 4 : int num_entries = 0;
245 4 : int max_entries = 64;
246 : MemoryContext tmpcxt;
247 : MemoryContext oldcxt;
248 :
249 : Assert(pgsa_entry_dshash != NULL);
250 :
251 : /*
252 : * Clear any existing shared memory state.
253 : *
254 : * Normally, there won't be any, but if this function was called before
255 : * and failed after beginning to apply changes to shared memory, then we
256 : * need to get rid of any entries created at that time before trying
257 : * again.
258 : */
259 4 : LWLockAcquire(&pgsa_state->lock, LW_EXCLUSIVE);
260 4 : pgsa_reset_all_stashes();
261 4 : LWLockRelease(&pgsa_state->lock);
262 :
263 : /* Open the dump file. If it doesn't exist, we're done. */
264 4 : file = AllocateFile(PGSA_DUMP_FILE, "r");
265 4 : if (!file)
266 : {
267 2 : if (errno == ENOENT)
268 2 : return;
269 0 : ereport(ERROR,
270 : (errcode_for_file_access(),
271 : errmsg("could not open file \"%s\": %m", PGSA_DUMP_FILE)));
272 : }
273 :
274 : /* Use a temporary context for all parse-phase allocations. */
275 2 : tmpcxt = AllocSetContextCreate(CurrentMemoryContext,
276 : "pg_stash_advice load",
277 : ALLOCSET_DEFAULT_SIZES);
278 2 : oldcxt = MemoryContextSwitchTo(tmpcxt);
279 :
280 : /* Figure out how long the file is. */
281 2 : if (fstat(fileno(file), &statbuf) != 0)
282 0 : ereport(ERROR,
283 : (errcode_for_file_access(),
284 : errmsg("could not stat file \"%s\": %m", PGSA_DUMP_FILE)));
285 :
286 : /*
287 : * Slurp the entire file into memory all at once.
288 : *
289 : * We could avoid this by reading the file incrementally and applying
290 : * changes to pgsa_stash_dshash and pgsa_entry_dshash as we go. Given the
291 : * lockout mechanism implemented by stashes_ready, that shouldn't have any
292 : * user-visible behavioral consequences, but it would consume shared
293 : * memory to no benefit. It seems better to buffer everything in private
294 : * memory first, and then only apply the changes once the file has been
295 : * successfully parsed in its entirety.
296 : *
297 : * That also has the advantage of possibly being more future-proof: if we
298 : * decide to remove the stashes_ready mechanism in the future, or say
299 : * allow for multiple save files, fully validating the file before
300 : * applying any changes will become much more important.
301 : *
302 : * Of course, this approach does have one major disadvantage, which is
303 : * that we'll temporarily use about twice as much memory as we're
304 : * ultimately going to need, but that seems like it shouldn't be a problem
305 : * in practice. If there's so much stashed advice that parsing the disk
306 : * file runs us out of memory, something has gone terribly wrong. In that
307 : * situation, there probably also isn't enough free memory for the
308 : * workload that the advice is attempting to manipulate to run
309 : * successfully.
310 : */
311 2 : filebuf = palloc_extended(statbuf.st_size + 1, MCXT_ALLOC_HUGE);
312 2 : nread = fread(filebuf, 1, statbuf.st_size, file);
313 2 : if (ferror(file))
314 0 : ereport(ERROR,
315 : (errcode_for_file_access(),
316 : errmsg("could not read file \"%s\": %m", PGSA_DUMP_FILE)));
317 2 : FreeFile(file);
318 2 : filebuf[nread] = '\0';
319 :
320 : /* Initial memory allocations. */
321 2 : saved_stashes = pgsa_saved_stash_table_create(tmpcxt, 64, NULL);
322 2 : entries = palloc(max_entries * sizeof(pgsa_saved_entry));
323 :
324 : /*
325 : * For memory and CPU efficiency, we parse the file in place. The end of
326 : * each line gets replaced with a NUL byte, and then the end of each field
327 : * within a line gets the same treatment. The advice string is unescaped
328 : * in place, and stash names and query IDs can't contain any special
329 : * characters. All of the resulting pointers point right back into the
330 : * buffer; we only need additional memory to grow the 'entries' array and
331 : * the 'saved_stashes' hash table.
332 : */
333 13 : for (p = filebuf, lineno = 1; *p != '\0'; lineno++)
334 : {
335 11 : char *cursor = p;
336 : char *eol;
337 : char *line_type;
338 :
339 : /* Find end of line and NUL-terminate. */
340 11 : eol = strchr(p, '\n');
341 11 : if (eol != NULL)
342 : {
343 11 : *eol = '\0';
344 11 : p = eol + 1;
345 11 : if (eol > cursor && eol[-1] == '\r')
346 0 : eol[-1] = '\0';
347 : }
348 : else
349 0 : p += strlen(p);
350 :
351 : /* Skip empty lines. */
352 11 : if (*cursor == '\0')
353 0 : continue;
354 :
355 : /* First field is the type of line, either "stash" or "entry". */
356 11 : line_type = pgsa_next_tsv_field(&cursor);
357 11 : if (strcmp(line_type, "stash") == 0)
358 : {
359 : char *name;
360 : bool found;
361 :
362 : /* Second field should be the stash name. */
363 5 : name = pgsa_next_tsv_field(&cursor);
364 5 : if (name == NULL || *name == '\0')
365 0 : ereport(ERROR,
366 : (errcode(ERRCODE_DATA_CORRUPTED),
367 : errmsg("syntax error in file \"%s\" line %u: expected stash name",
368 : PGSA_DUMP_FILE, lineno)));
369 :
370 : /* No further fields are expected. */
371 5 : if (*cursor != '\0')
372 0 : ereport(ERROR,
373 : (errcode(ERRCODE_DATA_CORRUPTED),
374 : errmsg("syntax error in file \"%s\" line %u: expected end of line",
375 : PGSA_DUMP_FILE, lineno)));
376 :
377 : /* Reject overlong stash names. */
378 5 : if (strlen(name) >= NAMEDATALEN)
379 0 : ereport(ERROR,
380 : (errcode(ERRCODE_DATA_CORRUPTED),
381 : errmsg("syntax error in file \"%s\" line %u: stash name too long",
382 : PGSA_DUMP_FILE, lineno)));
383 :
384 : /* Duplicate check. */
385 5 : (void) pgsa_saved_stash_table_insert(saved_stashes, name, &found);
386 5 : if (found)
387 0 : ereport(ERROR,
388 : (errcode(ERRCODE_DATA_CORRUPTED),
389 : errmsg("syntax error in file \"%s\" line %u: duplicate stash name \"%s\"",
390 : PGSA_DUMP_FILE, lineno, name)));
391 5 : num_stashes++;
392 : }
393 6 : else if (strcmp(line_type, "entry") == 0)
394 : {
395 : char *stash_name;
396 : char *queryid_str;
397 : char *advice_str;
398 : char *endptr;
399 : int64 queryId;
400 :
401 : /* Second field should be the stash name. */
402 6 : stash_name = pgsa_next_tsv_field(&cursor);
403 6 : if (stash_name == NULL)
404 0 : ereport(ERROR,
405 : (errcode(ERRCODE_DATA_CORRUPTED),
406 : errmsg("syntax error in file \"%s\" line %u: expected stash name",
407 : PGSA_DUMP_FILE, lineno)));
408 :
409 : /* Third field should be the query ID. */
410 6 : queryid_str = pgsa_next_tsv_field(&cursor);
411 6 : if (queryid_str == NULL)
412 0 : ereport(ERROR,
413 : (errcode(ERRCODE_DATA_CORRUPTED),
414 : errmsg("syntax error in file \"%s\" line %u: expected query ID",
415 : PGSA_DUMP_FILE, lineno)));
416 :
417 : /* Fourth field should be the advice string. */
418 6 : advice_str = pgsa_next_tsv_field(&cursor);
419 6 : if (advice_str == NULL)
420 0 : ereport(ERROR,
421 : (errcode(ERRCODE_DATA_CORRUPTED),
422 : errmsg("syntax error in file \"%s\" line %u: expected advice string",
423 : PGSA_DUMP_FILE, lineno)));
424 :
425 : /* No further fields are expected. */
426 6 : if (*cursor != '\0')
427 0 : ereport(ERROR,
428 : (errcode(ERRCODE_DATA_CORRUPTED),
429 : errmsg("syntax error in file \"%s\" line %u: expected end of line",
430 : PGSA_DUMP_FILE, lineno)));
431 :
432 : /* Make sure the stash is one we've actually seen. */
433 6 : if (pgsa_saved_stash_table_lookup(saved_stashes,
434 : stash_name) == NULL)
435 0 : ereport(ERROR,
436 : (errcode(ERRCODE_DATA_CORRUPTED),
437 : errmsg("syntax error in file \"%s\" line %u: unknown stash \"%s\"",
438 : PGSA_DUMP_FILE, lineno, stash_name)));
439 :
440 : /* Parse the query ID. */
441 6 : errno = 0;
442 6 : queryId = strtoi64(queryid_str, &endptr, 10);
443 6 : if (*endptr != '\0' || errno != 0 || queryid_str == endptr ||
444 : queryId == 0)
445 0 : ereport(ERROR,
446 : (errcode(ERRCODE_DATA_CORRUPTED),
447 : errmsg("syntax error in file \"%s\" line %u: invalid query ID \"%s\"",
448 : PGSA_DUMP_FILE, lineno, queryid_str)));
449 :
450 : /* Unescape the advice string. */
451 6 : pgsa_unescape_tsv_field(advice_str, PGSA_DUMP_FILE, lineno);
452 :
453 : /* Append to the entry array. */
454 6 : if (num_entries >= max_entries)
455 : {
456 0 : max_entries *= 2;
457 0 : entries = repalloc(entries,
458 : max_entries * sizeof(pgsa_saved_entry));
459 : }
460 6 : entries[num_entries].stash_name = stash_name;
461 6 : entries[num_entries].queryId = queryId;
462 6 : entries[num_entries].advice_string = advice_str;
463 6 : num_entries++;
464 : }
465 : else
466 : {
467 0 : ereport(ERROR,
468 : (errcode(ERRCODE_DATA_CORRUPTED),
469 : errmsg("syntax error in file \"%s\" line %u: unrecognized line type",
470 : PGSA_DUMP_FILE, lineno)));
471 : }
472 : }
473 :
474 : /*
475 : * Parsing succeeded. Apply everything to shared memory.
476 : *
477 : * At this point, we know that the file we just read is fully valid, but
478 : * it's still possible for this to fail if, for example, DSA memory cannot
479 : * be allocated. If that happens, the worker will die, the postmaster will
480 : * eventually restart it, and we'll try again after clearing any data that
481 : * we did manage to put into shared memory. (Note that we call
482 : * pgsa_reset_all_stashes() at the top of this function.)
483 : */
484 2 : pgsa_restore_stashes(saved_stashes);
485 2 : pgsa_restore_entries(entries, num_entries);
486 :
487 : /* Hooray, it worked! Notify the user. */
488 2 : ereport(LOG,
489 : (errmsg("loaded %d advice stashes and %d entries from \"%s\"",
490 : num_stashes, num_entries, PGSA_DUMP_FILE)));
491 :
492 : /* Clean up. */
493 2 : MemoryContextSwitchTo(oldcxt);
494 2 : MemoryContextDelete(tmpcxt);
495 : }
496 :
497 : /*
498 : * Write all advice stash data to disk.
499 : *
500 : * The file format is a simple TSV with a line-type prefix:
501 : * stash\tstash_name
502 : * entry\tstash_name\tquery_id\tadvice_string
503 : */
504 : static void
505 4 : pgsa_write_to_disk(void)
506 : {
507 4 : pgsa_writer_context wctx = {0};
508 : MemoryContext tmpcxt;
509 : MemoryContext oldcxt;
510 :
511 : Assert(pgsa_entry_dshash != NULL);
512 :
513 : /* Use a temporary context so all allocations are freed at the end. */
514 4 : tmpcxt = AllocSetContextCreate(CurrentMemoryContext,
515 : "pg_stash_advice dump",
516 : ALLOCSET_DEFAULT_SIZES);
517 4 : oldcxt = MemoryContextSwitchTo(tmpcxt);
518 :
519 : /* Set up the writer context. */
520 4 : snprintf(wctx.pathname, MAXPGPATH, "%s.tmp", PGSA_DUMP_FILE);
521 4 : wctx.file = AllocateFile(wctx.pathname, "w");
522 4 : if (!wctx.file)
523 0 : ereport(ERROR,
524 : (errcode_for_file_access(),
525 : errmsg("could not open file \"%s\": %m", wctx.pathname)));
526 4 : wctx.nhash = pgsa_stash_name_table_create(tmpcxt, 64, NULL);
527 4 : initStringInfo(&wctx.buf);
528 :
529 : /* Write stash lines, then entry lines. */
530 4 : pgsa_write_stashes(&wctx);
531 4 : pgsa_write_entries(&wctx);
532 :
533 : /*
534 : * If nothing was written, remove both the temp file and any existing dump
535 : * file rather than installing a zero-length file.
536 : */
537 4 : if (wctx.nhash->members == 0)
538 : {
539 2 : ereport(DEBUG1,
540 : errmsg("there are no advice stashes to save"));
541 2 : FreeFile(wctx.file);
542 2 : unlink(wctx.pathname);
543 2 : if (unlink(PGSA_DUMP_FILE) == 0)
544 1 : ereport(DEBUG1,
545 : errmsg("removed \"%s\"", PGSA_DUMP_FILE));
546 : }
547 : else
548 : {
549 2 : if (FreeFile(wctx.file) != 0)
550 : {
551 0 : int save_errno = errno;
552 :
553 0 : unlink(wctx.pathname);
554 0 : errno = save_errno;
555 0 : ereport(ERROR,
556 : (errcode_for_file_access(),
557 : errmsg("could not close file \"%s\": %m",
558 : wctx.pathname)));
559 : }
560 2 : (void) durable_rename(wctx.pathname, PGSA_DUMP_FILE, ERROR);
561 :
562 2 : ereport(LOG,
563 : errmsg("saved %d advice stashes and %d entries to \"%s\"",
564 : (int) wctx.nhash->members, wctx.entries_written,
565 : PGSA_DUMP_FILE));
566 : }
567 :
568 4 : MemoryContextSwitchTo(oldcxt);
569 4 : MemoryContextDelete(tmpcxt);
570 4 : }
571 :
572 : /*
573 : * Append the TSV-escaped form of str to buf.
574 : *
575 : * Backslash, tab, newline, and carriage return are escaped with backslash
576 : * sequences. All other characters are passed through unchanged.
577 : */
578 : static void
579 6 : pgsa_append_tsv_escaped_string(StringInfo buf, const char *str)
580 : {
581 100 : for (const char *p = str; *p != '\0'; p++)
582 : {
583 94 : switch (*p)
584 : {
585 2 : case '\\':
586 2 : appendStringInfoString(buf, "\\\\");
587 2 : break;
588 2 : case '\t':
589 2 : appendStringInfoString(buf, "\\t");
590 2 : break;
591 2 : case '\n':
592 2 : appendStringInfoString(buf, "\\n");
593 2 : break;
594 0 : case '\r':
595 0 : appendStringInfoString(buf, "\\r");
596 0 : break;
597 88 : default:
598 88 : appendStringInfoChar(buf, *p);
599 88 : break;
600 : }
601 : }
602 6 : }
603 :
604 : /*
605 : * Extract the next tab-delimited field from *cursor.
606 : *
607 : * The tab delimiter is replaced with '\0' and *cursor is advanced past it.
608 : * If *cursor already points to '\0' (no more fields), returns NULL.
609 : */
610 : static char *
611 34 : pgsa_next_tsv_field(char **cursor)
612 : {
613 34 : char *start = *cursor;
614 34 : char *p = start;
615 :
616 34 : if (*p == '\0')
617 0 : return NULL;
618 :
619 290 : while (*p != '\0' && *p != '\t')
620 256 : p++;
621 :
622 34 : if (*p == '\t')
623 23 : *p++ = '\0';
624 :
625 34 : *cursor = p;
626 34 : return start;
627 : }
628 :
629 : /*
630 : * Insert entries into shared memory from the parsed entry array.
631 : */
632 : static void
633 2 : pgsa_restore_entries(pgsa_saved_entry *entries, int num_entries)
634 : {
635 2 : LWLockAcquire(&pgsa_state->lock, LW_SHARED);
636 8 : for (int i = 0; i < num_entries; i++)
637 : {
638 6 : ereport(DEBUG2,
639 : errmsg("restoring advice stash entry for \"%s\", query ID %" PRId64,
640 : entries[i].stash_name, entries[i].queryId));
641 6 : pgsa_set_advice_string(entries[i].stash_name,
642 6 : entries[i].queryId,
643 6 : entries[i].advice_string);
644 : }
645 2 : LWLockRelease(&pgsa_state->lock);
646 2 : }
647 :
648 : /*
649 : * Create stashes in shared memory from the parsed stash hash table.
650 : */
651 : static void
652 2 : pgsa_restore_stashes(pgsa_saved_stash_table_hash *saved_stashes)
653 : {
654 : pgsa_saved_stash_table_iterator iter;
655 : pgsa_saved_stash *s;
656 :
657 2 : LWLockAcquire(&pgsa_state->lock, LW_EXCLUSIVE);
658 2 : pgsa_saved_stash_table_start_iterate(saved_stashes, &iter);
659 7 : while ((s = pgsa_saved_stash_table_iterate(saved_stashes,
660 7 : &iter)) != NULL)
661 : {
662 5 : ereport(DEBUG2,
663 : errmsg("restoring advice stash \"%s\"", s->name));
664 5 : pgsa_create_stash(s->name);
665 : }
666 2 : LWLockRelease(&pgsa_state->lock);
667 2 : }
668 :
669 : /*
670 : * Unescape a TSV field in place.
671 : *
672 : * Recognized escape sequences are \\, \t, \n, and \r. A trailing backslash
673 : * or an unrecognized escape sequence is a syntax error.
674 : */
675 : static void
676 6 : pgsa_unescape_tsv_field(char *str, const char *filename, unsigned lineno)
677 : {
678 6 : char *src = str;
679 6 : char *dst = str;
680 :
681 100 : while (*src != '\0')
682 : {
683 : /* Just pass through anything that's not a backslash-escape. */
684 94 : if (likely(*src != '\\'))
685 : {
686 88 : *dst++ = *src++;
687 88 : continue;
688 : }
689 :
690 : /* Check what sort of escape we've got. */
691 6 : switch (src[1])
692 : {
693 2 : case '\\':
694 2 : *dst++ = '\\';
695 2 : break;
696 2 : case 't':
697 2 : *dst++ = '\t';
698 2 : break;
699 2 : case 'n':
700 2 : *dst++ = '\n';
701 2 : break;
702 0 : case 'r':
703 0 : *dst++ = '\r';
704 0 : break;
705 0 : case '\0':
706 0 : ereport(ERROR,
707 : (errcode(ERRCODE_DATA_CORRUPTED),
708 : errmsg("syntax error in file \"%s\" line %u: trailing backslash",
709 : filename, lineno)));
710 : break;
711 0 : default:
712 0 : ereport(ERROR,
713 : (errcode(ERRCODE_DATA_CORRUPTED),
714 : errmsg("syntax error in file \"%s\" line %u: unrecognized escape \"\\%c\"",
715 : filename, lineno, src[1])));
716 : break;
717 : }
718 :
719 : /* We consumed the backslash and the following character. */
720 6 : src += 2;
721 : }
722 6 : *dst = '\0';
723 6 : }
724 :
725 : /*
726 : * Write an entry line for each advice entry.
727 : */
728 : static void
729 4 : pgsa_write_entries(pgsa_writer_context *wctx)
730 : {
731 : dshash_seq_status iter;
732 : pgsa_entry *entry;
733 :
734 4 : dshash_seq_init(&iter, pgsa_entry_dshash, false);
735 10 : while ((entry = dshash_seq_next(&iter)) != NULL)
736 : {
737 : pgsa_stash_name *n;
738 : char *advice_string;
739 :
740 6 : if (entry->advice_string == InvalidDsaPointer)
741 0 : continue;
742 :
743 6 : n = pgsa_stash_name_table_lookup(wctx->nhash,
744 : entry->key.pgsa_stash_id);
745 6 : if (n == NULL)
746 0 : continue; /* orphan entry, skip */
747 :
748 6 : advice_string = dsa_get_address(pgsa_dsa_area, entry->advice_string);
749 :
750 6 : resetStringInfo(&wctx->buf);
751 6 : appendStringInfo(&wctx->buf, "entry\t%s\t%" PRId64 "\t",
752 : n->name, entry->key.queryId);
753 6 : pgsa_append_tsv_escaped_string(&wctx->buf, advice_string);
754 6 : appendStringInfoChar(&wctx->buf, '\n');
755 6 : fwrite(wctx->buf.data, 1, wctx->buf.len, wctx->file);
756 6 : if (ferror(wctx->file))
757 0 : pgsa_write_error(wctx);
758 6 : wctx->entries_written++;
759 : }
760 4 : dshash_seq_term(&iter);
761 4 : }
762 :
763 : /*
764 : * Clean up and report a write error. Does not return.
765 : */
766 : static void
767 0 : pgsa_write_error(pgsa_writer_context *wctx)
768 : {
769 0 : int save_errno = errno;
770 :
771 0 : FreeFile(wctx->file);
772 0 : unlink(wctx->pathname);
773 0 : errno = save_errno;
774 0 : ereport(ERROR,
775 : (errcode_for_file_access(),
776 : errmsg("could not write to file \"%s\": %m", wctx->pathname)));
777 : }
778 :
779 : /*
780 : * Write a stash line for each advice stash, and populate the ID-to-name
781 : * hash table for use by pgsa_write_entries.
782 : */
783 : static void
784 4 : pgsa_write_stashes(pgsa_writer_context *wctx)
785 : {
786 : dshash_seq_status iter;
787 : pgsa_stash *stash;
788 :
789 4 : dshash_seq_init(&iter, pgsa_stash_dshash, false);
790 9 : while ((stash = dshash_seq_next(&iter)) != NULL)
791 : {
792 : pgsa_stash_name *n;
793 : bool found;
794 :
795 5 : n = pgsa_stash_name_table_insert(wctx->nhash, stash->pgsa_stash_id,
796 : &found);
797 : Assert(!found);
798 5 : n->name = pstrdup(stash->name);
799 :
800 5 : resetStringInfo(&wctx->buf);
801 5 : appendStringInfo(&wctx->buf, "stash\t%s\n", n->name);
802 5 : fwrite(wctx->buf.data, 1, wctx->buf.len, wctx->file);
803 5 : if (ferror(wctx->file))
804 0 : pgsa_write_error(wctx);
805 : }
806 4 : dshash_seq_term(&iter);
807 4 : }
|
