Debian Codegraph @

src/backend/storage/sync/sync.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * sync.c
4 * File synchronization management code.
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/storage/sync/sync.c
12 *
13 *-------------------------------------------------------------------------
14 */
15 #include "postgres.h"
16
17 #include <unistd.h>
18 #include <fcntl.h>
19 #include <sys/file.h>
20
21 #include "access/clog.h"
22 #include "access/commit_ts.h"
23 #include "access/multixact.h"
24 #include "access/xlog.h"
25 #include "miscadmin.h"
26 #include "pgstat.h"
27 #include "portability/instr_time.h"
28 #include "postmaster/bgwriter.h"
29 #include "storage/fd.h"
30 #include "storage/latch.h"
31 #include "storage/md.h"
32 #include "utils/hsearch.h"
33 #include "utils/memutils.h"
34
35 /*
36 * In some contexts (currently, standalone backends and the checkpointer)
37 * we keep track of pending fsync operations: we need to remember all relation
38 * segments that have been written since the last checkpoint, so that we can
39 * fsync them down to disk before completing the next checkpoint. This hash
40 * table remembers the pending operations. We use a hash table mostly as
41 * a convenient way of merging duplicate requests.
42 *
43 * We use a similar mechanism to remember no-longer-needed files that can
44 * be deleted after the next checkpoint, but we use a linked list instead of
45 * a hash table, because we don't expect there to be any duplicate requests.
46 *
47 * These mechanisms are only used for non-temp relations; we never fsync
48 * temp rels, nor do we need to postpone their deletion (see comments in
49 * mdunlink).
50 *
51 * (Regular backends do not track pending operations locally, but forward
52 * them to the checkpointer.)
53 */
54 typedef uint16 CycleCtr; /* can be any convenient integer size */
55
56 typedef struct
57 {
58 FileTag tag; /* identifies handler and file */
59 CycleCtr cycle_ctr; /* sync_cycle_ctr of oldest request */
60 bool canceled; /* canceled is true if we canceled "recently" */
61 } PendingFsyncEntry;
62
63 typedef struct
64 {
65 FileTag tag; /* identifies handler and file */
66 CycleCtr cycle_ctr; /* checkpoint_cycle_ctr when request was made */
67 bool canceled; /* true if request has been canceled */
68 } PendingUnlinkEntry;
69
70 static HTAB *pendingOps = NULL;
71 static List *pendingUnlinks = NIL;
72 static MemoryContext pendingOpsCxt; /* context for the above */
73
74 static CycleCtr sync_cycle_ctr = 0;
75 static CycleCtr checkpoint_cycle_ctr = 0;
76
77 /* Intervals for calling AbsorbSyncRequests */
78 #define FSYNCS_PER_ABSORB 10
79 #define UNLINKS_PER_ABSORB 10
80
81 /*
82 * Function pointers for handling sync and unlink requests.
83 */
84 typedef struct SyncOps
85 {
86 int (*sync_syncfiletag) (const FileTag *ftag, char *path);
87 int (*sync_unlinkfiletag) (const FileTag *ftag, char *path);
88 bool (*sync_filetagmatches) (const FileTag *ftag,
89 const FileTag *candidate);
90 } SyncOps;
91
92 /*
93 * These indexes must correspond to the values of the SyncRequestHandler enum.
94 */
95 static const SyncOps syncsw[] = {
96 /* magnetic disk */
97 [SYNC_HANDLER_MD] = {
98 .sync_syncfiletag = mdsyncfiletag,
99 .sync_unlinkfiletag = mdunlinkfiletag,
100 .sync_filetagmatches = mdfiletagmatches
101 },
102 /* pg_xact */
103 [SYNC_HANDLER_CLOG] = {
104 .sync_syncfiletag = clogsyncfiletag
105 },
106 /* pg_commit_ts */
107 [SYNC_HANDLER_COMMIT_TS] = {
108 .sync_syncfiletag = committssyncfiletag
109 },
110 /* pg_multixact/offsets */
111 [SYNC_HANDLER_MULTIXACT_OFFSET] = {
112 .sync_syncfiletag = multixactoffsetssyncfiletag
113 },
114 /* pg_multixact/members */
115 [SYNC_HANDLER_MULTIXACT_MEMBER] = {
116 .sync_syncfiletag = multixactmemberssyncfiletag
117 }
118 };
119
120 /*
121 * Initialize data structures for the file sync tracking.
122 */
123 void
124 InitSync(void)
125 {
126 /*
127 * Create pending-operations hashtable if we need it. Currently, we need
128 * it if we are standalone (not under a postmaster) or if we are a
129 * checkpointer auxiliary process.
130 */
131 if (!IsUnderPostmaster || AmCheckpointerProcess())
132 {
133 HASHCTL hash_ctl;
134
135 /*
136 * XXX: The checkpointer needs to add entries to the pending ops table
137 * when absorbing fsync requests. That is done within a critical
138 * section, which isn't usually allowed, but we make an exception. It
139 * means that there's a theoretical possibility that you run out of
140 * memory while absorbing fsync requests, which leads to a PANIC.
141 * Fortunately the hash table is small so that's unlikely to happen in
142 * practice.
143 */
144 pendingOpsCxt = AllocSetContextCreate(TopMemoryContext,
145 "Pending ops context",
146 ALLOCSET_DEFAULT_SIZES);
147 MemoryContextAllowInCriticalSection(pendingOpsCxt, true);
148
149 hash_ctl.keysize = sizeof(FileTag);
150 hash_ctl.entrysize = sizeof(PendingFsyncEntry);
151 hash_ctl.hcxt = pendingOpsCxt;
152 pendingOps = hash_create("Pending Ops Table",
153 100L,
154 &hash_ctl,
155 HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
156 pendingUnlinks = NIL;
157 }
158 }
159
160 /*
161 * SyncPreCheckpoint() -- Do pre-checkpoint work
162 *
163 * To distinguish unlink requests that arrived before this checkpoint
164 * started from those that arrived during the checkpoint, we use a cycle
165 * counter similar to the one we use for fsync requests. That cycle
166 * counter is incremented here.
167 *
168 * This must be called *before* the checkpoint REDO point is determined.
169 * That ensures that we won't delete files too soon. Since this calls
170 * AbsorbSyncRequests(), which performs memory allocations, it cannot be
171 * called within a critical section.
172 *
173 * Note that we can't do anything here that depends on the assumption
174 * that the checkpoint will be completed.
175 */
176 void
177 SyncPreCheckpoint(void)
178 {
179 /*
180 * Operations such as DROP TABLESPACE assume that the next checkpoint will
181 * process all recently forwarded unlink requests, but if they aren't
182 * absorbed prior to advancing the cycle counter, they won't be processed
183 * until a future checkpoint. The following absorb ensures that any
184 * unlink requests forwarded before the checkpoint began will be processed
185 * in the current checkpoint.
186 */
187 AbsorbSyncRequests();
188
189 /*
190 * Any unlink requests arriving after this point will be assigned the next
191 * cycle counter, and won't be unlinked until next checkpoint.
192 */
193 checkpoint_cycle_ctr++;
194 }
195
196 /*
197 * SyncPostCheckpoint() -- Do post-checkpoint work
198 *
199 * Remove any lingering files that can now be safely removed.
200 */
201 void
202 SyncPostCheckpoint(void)
203 {
204 int absorb_counter;
205 ListCell *lc;
206
207 absorb_counter = UNLINKS_PER_ABSORB;
208 foreach(lc, pendingUnlinks)
209 {
210 PendingUnlinkEntry *entry = (PendingUnlinkEntry *) lfirst(lc);
211 char path[MAXPGPATH];
212
213 /* Skip over any canceled entries */
214 if (entry->canceled)
215 continue;
216
217 /*
218 * New entries are appended to the end, so if the entry is new we've
219 * reached the end of old entries.
220 *
221 * Note: if just the right number of consecutive checkpoints fail, we
222 * could be fooled here by cycle_ctr wraparound. However, the only
223 * consequence is that we'd delay unlinking for one more checkpoint,
224 * which is perfectly tolerable.
225 */
226 if (entry->cycle_ctr == checkpoint_cycle_ctr)
227 break;
228
229 /* Unlink the file */
230 if (syncsw[entry->tag.handler].sync_unlinkfiletag(&entry->tag,
231 path) < 0)
232 {
233 /*
234 * There's a race condition, when the database is dropped at the
235 * same time that we process the pending unlink requests. If the
236 * DROP DATABASE deletes the file before we do, we will get ENOENT
237 * here. rmtree() also has to ignore ENOENT errors, to deal with
238 * the possibility that we delete the file first.
239 */
240 if (errno != ENOENT)
241 ereport(WARNING,
242 (errcode_for_file_access(),
243 errmsg("could not remove file \"%s\": %m", path)));
244 }
245
246 /* Mark the list entry as canceled, just in case */
247 entry->canceled = true;
248
249 /*
250 * As in ProcessSyncRequests, we don't want to stop absorbing fsync
251 * requests for a long time when there are many deletions to be done.
252 * We can safely call AbsorbSyncRequests() at this point in the loop.
253 */
254 if (--absorb_counter <= 0)
255 {
256 AbsorbSyncRequests();
257 absorb_counter = UNLINKS_PER_ABSORB;
258 }
259 }
260
261 /*
262 * If we reached the end of the list, we can just remove the whole list
263 * (remembering to pfree all the PendingUnlinkEntry objects). Otherwise,
264 * we must keep the entries at or after "lc".
265 */
266 if (lc == NULL)
267 {
268 list_free_deep(pendingUnlinks);
269 pendingUnlinks = NIL;
270 }
271 else
272 {
273 int ntodelete = list_cell_number(pendingUnlinks, lc);
274
275 for (int i = 0; i < ntodelete; i++)
276 pfree(list_nth(pendingUnlinks, i));
277
278 pendingUnlinks = list_delete_first_n(pendingUnlinks, ntodelete);
279 }
280 }
281
282 /*
283 * ProcessSyncRequests() -- Process queued fsync requests.
284 */
285 void
286 ProcessSyncRequests(void)
287 {
288 static bool sync_in_progress = false;
289
290 HASH_SEQ_STATUS hstat;
291 PendingFsyncEntry *entry;
292 int absorb_counter;
293
294 /* Statistics on sync times */
295 int processed = 0;
296 instr_time sync_start,
297 sync_end,
298 sync_diff;
299 uint64 elapsed;
300 uint64 longest = 0;
301 uint64 total_elapsed = 0;
302
303 /*
304 * This is only called during checkpoints, and checkpoints should only
305 * occur in processes that have created a pendingOps.
306 */
307 if (!pendingOps)
308 elog(ERROR, "cannot sync without a pendingOps table");
309
310 /*
311 * If we are in the checkpointer, the sync had better include all fsync
312 * requests that were queued by backends up to this point. The tightest
313 * race condition that could occur is that a buffer that must be written
314 * and fsync'd for the checkpoint could have been dumped by a backend just
315 * before it was visited by BufferSync(). We know the backend will have
316 * queued an fsync request before clearing the buffer's dirtybit, so we
317 * are safe as long as we do an Absorb after completing BufferSync().
318 */
319 AbsorbSyncRequests();
320
321 /*
322 * To avoid excess fsync'ing (in the worst case, maybe a never-terminating
323 * checkpoint), we want to ignore fsync requests that are entered into the
324 * hashtable after this point --- they should be processed next time,
325 * instead. We use sync_cycle_ctr to tell old entries apart from new
326 * ones: new ones will have cycle_ctr equal to the incremented value of
327 * sync_cycle_ctr.
328 *
329 * In normal circumstances, all entries present in the table at this point
330 * will have cycle_ctr exactly equal to the current (about to be old)
331 * value of sync_cycle_ctr. However, if we fail partway through the
332 * fsync'ing loop, then older values of cycle_ctr might remain when we
333 * come back here to try again. Repeated checkpoint failures would
334 * eventually wrap the counter around to the point where an old entry
335 * might appear new, causing us to skip it, possibly allowing a checkpoint
336 * to succeed that should not have. To forestall wraparound, any time the
337 * previous ProcessSyncRequests() failed to complete, run through the
338 * table and forcibly set cycle_ctr = sync_cycle_ctr.
339 *
340 * Think not to merge this loop with the main loop, as the problem is
341 * exactly that that loop may fail before having visited all the entries.
342 * From a performance point of view it doesn't matter anyway, as this path
343 * will never be taken in a system that's functioning normally.
344 */
345 if (sync_in_progress)
346 {
347 /* prior try failed, so update any stale cycle_ctr values */
348 hash_seq_init(&hstat, pendingOps);
349 while ((entry = (PendingFsyncEntry *) hash_seq_search(&hstat)) != NULL)
350 {
351 entry->cycle_ctr = sync_cycle_ctr;
352 }
353 }
354
355 /* Advance counter so that new hashtable entries are distinguishable */
356 sync_cycle_ctr++;
357
358 /* Set flag to detect failure if we don't reach the end of the loop */
359 sync_in_progress = true;
360
361 /* Now scan the hashtable for fsync requests to process */
362 absorb_counter = FSYNCS_PER_ABSORB;
363 hash_seq_init(&hstat, pendingOps);
364 while ((entry = (PendingFsyncEntry *) hash_seq_search(&hstat)) != NULL)
365 {
366 int failures;
367
368 /*
369 * If the entry is new then don't process it this time; it is new.
370 * Note "continue" bypasses the hash-remove call at the bottom of the
371 * loop.
372 */
373 if (entry->cycle_ctr == sync_cycle_ctr)
374 continue;
375
376 /* Else assert we haven't missed it */
377 Assert((CycleCtr) (entry->cycle_ctr + 1) == sync_cycle_ctr);
378
379 /*
380 * If fsync is off then we don't have to bother opening the file at
381 * all. (We delay checking until this point so that changing fsync on
382 * the fly behaves sensibly.)
383 */
384 if (enableFsync)
385 {
386 /*
387 * If in checkpointer, we want to absorb pending requests every so
388 * often to prevent overflow of the fsync request queue. It is
389 * unspecified whether newly-added entries will be visited by
390 * hash_seq_search, but we don't care since we don't need to
391 * process them anyway.
392 */
393 if (--absorb_counter <= 0)
394 {
395 AbsorbSyncRequests();
396 absorb_counter = FSYNCS_PER_ABSORB;
397 }
398
399 /*
400 * The fsync table could contain requests to fsync segments that
401 * have been deleted (unlinked) by the time we get to them. Rather
402 * than just hoping an ENOENT (or EACCES on Windows) error can be
403 * ignored, what we do on error is absorb pending requests and
404 * then retry. Since mdunlink() queues a "cancel" message before
405 * actually unlinking, the fsync request is guaranteed to be
406 * marked canceled after the absorb if it really was this case.
407 * DROP DATABASE likewise has to tell us to forget fsync requests
408 * before it starts deletions.
409 */
410 for (failures = 0; !entry->canceled; failures++)
411 {
412 char path[MAXPGPATH];
413
414 INSTR_TIME_SET_CURRENT(sync_start);
415 if (syncsw[entry->tag.handler].sync_syncfiletag(&entry->tag,
416 path) == 0)
417 {
418 /* Success; update statistics about sync timing */
419 INSTR_TIME_SET_CURRENT(sync_end);
420 sync_diff = sync_end;
421 INSTR_TIME_SUBTRACT(sync_diff, sync_start);
422 elapsed = INSTR_TIME_GET_MICROSEC(sync_diff);
423 if (elapsed > longest)
424 longest = elapsed;
425 total_elapsed += elapsed;
426 processed++;
427
428 if (log_checkpoints)
429 elog(DEBUG1, "checkpoint sync: number=%d file=%s time=%.3f ms",
430 processed,
431 path,
432 (double) elapsed / 1000);
433
434 break; /* out of retry loop */
435 }
436
437 /*
438 * It is possible that the relation has been dropped or
439 * truncated since the fsync request was entered. Therefore,
440 * allow ENOENT, but only if we didn't fail already on this
441 * file.
442 */
443 if (!FILE_POSSIBLY_DELETED(errno) || failures > 0)
444 ereport(data_sync_elevel(ERROR),
445 (errcode_for_file_access(),
446 errmsg("could not fsync file \"%s\": %m",
447 path)));
448 else
449 ereport(DEBUG1,
450 (errcode_for_file_access(),
451 errmsg_internal("could not fsync file \"%s\" but retrying: %m",
452 path)));
453
454 /*
455 * Absorb incoming requests and check to see if a cancel
456 * arrived for this relation fork.
457 */
458 AbsorbSyncRequests();
459 absorb_counter = FSYNCS_PER_ABSORB; /* might as well... */
460 } /* end retry loop */
461 }
462
463 /* We are done with this entry, remove it */
464 if (hash_search(pendingOps, &entry->tag, HASH_REMOVE, NULL) == NULL)
465 elog(ERROR, "pendingOps corrupted");
466 } /* end loop over hashtable entries */
467
468 /* Return sync performance metrics for report at checkpoint end */
469 CheckpointStats.ckpt_sync_rels = processed;
470 CheckpointStats.ckpt_longest_sync = longest;
471 CheckpointStats.ckpt_agg_sync_time = total_elapsed;
472
473 /* Flag successful completion of ProcessSyncRequests */
474 sync_in_progress = false;
475 }
476
477 /*
478 * RememberSyncRequest() -- callback from checkpointer side of sync request
479 *
480 * We stuff fsync requests into the local hash table for execution
481 * during the checkpointer's next checkpoint. UNLINK requests go into a
482 * separate linked list, however, because they get processed separately.
483 *
484 * See sync.h for more information on the types of sync requests supported.
485 */
486 void
487 RememberSyncRequest(const FileTag *ftag, SyncRequestType type)
488 {
489 Assert(pendingOps);
490
491 if (type == SYNC_FORGET_REQUEST)
492 {
493 PendingFsyncEntry *entry;
494
495 /* Cancel previously entered request */
496 entry = (PendingFsyncEntry *) hash_search(pendingOps,
497 ftag,
498 HASH_FIND,
499 NULL);
500 if (entry != NULL)
501 entry->canceled = true;
502 }
503 else if (type == SYNC_FILTER_REQUEST)
504 {
505 HASH_SEQ_STATUS hstat;
506 PendingFsyncEntry *pfe;
507 ListCell *cell;
508
509 /* Cancel matching fsync requests */
510 hash_seq_init(&hstat, pendingOps);
511 while ((pfe = (PendingFsyncEntry *) hash_seq_search(&hstat)) != NULL)
512 {
513 if (pfe->tag.handler == ftag->handler &&
514 syncsw[ftag->handler].sync_filetagmatches(ftag, &pfe->tag))
515 pfe->canceled = true;
516 }
517
518 /* Cancel matching unlink requests */
519 foreach(cell, pendingUnlinks)
520 {
521 PendingUnlinkEntry *pue = (PendingUnlinkEntry *) lfirst(cell);
522
523 if (pue->tag.handler == ftag->handler &&
524 syncsw[ftag->handler].sync_filetagmatches(ftag, &pue->tag))
525 pue->canceled = true;
526 }
527 }
528 else if (type == SYNC_UNLINK_REQUEST)
529 {
530 /* Unlink request: put it in the linked list */
531 MemoryContext oldcxt = MemoryContextSwitchTo(pendingOpsCxt);
532 PendingUnlinkEntry *entry;
533
534 entry = palloc(sizeof(PendingUnlinkEntry));
535 entry->tag = *ftag;
536 entry->cycle_ctr = checkpoint_cycle_ctr;
537 entry->canceled = false;
538
539 pendingUnlinks = lappend(pendingUnlinks, entry);
540
541 MemoryContextSwitchTo(oldcxt);
542 }
543 else
544 {
545 /* Normal case: enter a request to fsync this segment */
546 MemoryContext oldcxt = MemoryContextSwitchTo(pendingOpsCxt);
547 PendingFsyncEntry *entry;
548 bool found;
549
550 Assert(type == SYNC_REQUEST);
551
552 entry = (PendingFsyncEntry *) hash_search(pendingOps,
553 ftag,
554 HASH_ENTER,
555 &found);
556 /* if new entry, or was previously canceled, initialize it */
557 if (!found || entry->canceled)
558 {
559 entry->cycle_ctr = sync_cycle_ctr;
560 entry->canceled = false;
561 }
562
563 /*
564 * NB: it's intentional that we don't change cycle_ctr if the entry
565 * already exists. The cycle_ctr must represent the oldest fsync
566 * request that could be in the entry.
567 */
568
569 MemoryContextSwitchTo(oldcxt);
570 }
571 }
572
573 /*
574 * Register the sync request locally, or forward it to the checkpointer.
575 *
576 * If retryOnError is true, we'll keep trying if there is no space in the
577 * queue. Return true if we succeeded, or false if there wasn't space.
578 */
579 bool
580 RegisterSyncRequest(const FileTag *ftag, SyncRequestType type,
581 bool retryOnError)
582 {
583 bool ret;
584
585 if (pendingOps != NULL)
586 {
587 /* standalone backend or startup process: fsync state is local */
588 RememberSyncRequest(ftag, type);
589 return true;
590 }
591
592 for (;;)
593 {
594 /*
595 * Notify the checkpointer about it. If we fail to queue a message in
596 * retryOnError mode, we have to sleep and try again ... ugly, but
597 * hopefully won't happen often.
598 *
599 * XXX should we CHECK_FOR_INTERRUPTS in this loop? Escaping with an
600 * error in the case of SYNC_UNLINK_REQUEST would leave the
601 * no-longer-used file still present on disk, which would be bad, so
602 * I'm inclined to assume that the checkpointer will always empty the
603 * queue soon.
604 */
605 ret = ForwardSyncRequest(ftag, type);
606
607 /*
608 * If we are successful in queueing the request, or we failed and were
609 * instructed not to retry on error, break.
610 */
611 if (ret || (!ret && !retryOnError))
612 break;
613
614 WaitLatch(NULL, WL_EXIT_ON_PM_DEATH | WL_TIMEOUT, 10,
615 WAIT_EVENT_REGISTER_SYNC_REQUEST);
616 }
617
618 return ret;
619 }