Debian Codegraph @

src/backend/utils/time/snapmgr.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * snapmgr.c
4 * PostgreSQL snapshot manager
5 *
6 * The following functions return an MVCC snapshot that can be used in tuple
7 * visibility checks:
8 *
9 * - GetTransactionSnapshot
10 * - GetLatestSnapshot
11 * - GetCatalogSnapshot
12 * - GetNonHistoricCatalogSnapshot
13 *
14 * Each of these functions returns a reference to a statically allocated
15 * snapshot. The statically allocated snapshot is subject to change on any
16 * snapshot-related function call, and should not be used directly. Instead,
17 * call PushActiveSnapshot() or RegisterSnapshot() to create a longer-lived
18 * copy and use that.
19 *
20 * We keep track of snapshots in two ways: those "registered" by resowner.c,
21 * and the "active snapshot" stack. All snapshots in either of them live in
22 * persistent memory. When a snapshot is no longer in any of these lists
23 * (tracked by separate refcounts on each snapshot), its memory can be freed.
24 *
25 * In addition to the above-mentioned MVCC snapshots, there are some special
26 * snapshots like SnapshotSelf, SnapshotAny, and "dirty" snapshots. They can
27 * only be used in limited contexts and cannot be registered or pushed to the
28 * active stack.
29 *
30 * ActiveSnapshot stack
31 * --------------------
32 *
33 * Most visibility checks use the current "active snapshot" returned by
34 * GetActiveSnapshot(). When running normal queries, the active snapshot is
35 * set when query execution begins based on the transaction isolation level.
36 *
37 * The active snapshot is tracked in a stack so that the currently active one
38 * is at the top of the stack. It mirrors the process call stack: whenever we
39 * recurse or switch context to fetch rows from a different portal for
40 * example, the appropriate snapshot is pushed to become the active snapshot,
41 * and popped on return. Once upon a time, ActiveSnapshot was just a global
42 * variable that was saved and restored similar to CurrentMemoryContext, but
43 * nowadays it's managed as a separate data structure so that we can keep
44 * track of which snapshots are in use and reset MyProc->xmin when there is no
45 * active snapshot.
46 *
47 * However, there are a couple of exceptions where the active snapshot stack
48 * does not strictly mirror the call stack:
49 *
50 * - VACUUM and a few other utility commands manage their own transactions,
51 * which take their own snapshots. They are called with an active snapshot
52 * set, like most utility commands, but they pop the active snapshot that
53 * was pushed by the caller. PortalRunUtility knows about the possibility
54 * that the snapshot it pushed is no longer active on return.
55 *
56 * - When COMMIT or ROLLBACK is executed within a procedure or DO-block, the
57 * active snapshot stack is destroyed, and re-established later when
58 * subsequent statements in the procedure are executed. There are many
59 * limitations on when in-procedure COMMIT/ROLLBACK is allowed; one such
60 * limitation is that all the snapshots on the active snapshot stack are
61 * known to portals that are being executed, which makes it safe to reset
62 * the stack. See EnsurePortalSnapshotExists().
63 *
64 * Registered snapshots
65 * --------------------
66 *
67 * In addition to snapshots pushed to the active snapshot stack, a snapshot
68 * can be registered with a resource owner.
69 *
70 * The FirstXactSnapshot, if any, is treated a bit specially: we increment its
71 * regd_count and list it in RegisteredSnapshots, but this reference is not
72 * tracked by a resource owner. We used to use the TopTransactionResourceOwner
73 * to track this snapshot reference, but that introduces logical circularity
74 * and thus makes it impossible to clean up in a sane fashion. It's better to
75 * handle this reference as an internally-tracked registration, so that this
76 * module is entirely lower-level than ResourceOwners.
77 *
78 * Likewise, any snapshots that have been exported by pg_export_snapshot
79 * have regd_count = 1 and are listed in RegisteredSnapshots, but are not
80 * tracked by any resource owner.
81 *
82 * Likewise, the CatalogSnapshot is listed in RegisteredSnapshots when it
83 * is valid, but is not tracked by any resource owner.
84 *
85 * The same is true for historic snapshots used during logical decoding,
86 * their lifetime is managed separately (as they live longer than one xact.c
87 * transaction).
88 *
89 * These arrangements let us reset MyProc->xmin when there are no snapshots
90 * referenced by this transaction, and advance it when the one with oldest
91 * Xmin is no longer referenced. For simplicity however, only registered
92 * snapshots not active snapshots participate in tracking which one is oldest;
93 * we don't try to change MyProc->xmin except when the active-snapshot
94 * stack is empty.
95 *
96 *
97 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
98 * Portions Copyright (c) 1994, Regents of the University of California
99 *
100 * IDENTIFICATION
101 * src/backend/utils/time/snapmgr.c
102 *
103 *-------------------------------------------------------------------------
104 */
105 #include "postgres.h"
106
107 #include <sys/stat.h>
108 #include <unistd.h>
109
110 #include "access/subtrans.h"
111 #include "access/transam.h"
112 #include "access/xact.h"
113 #include "datatype/timestamp.h"
114 #include "lib/pairingheap.h"
115 #include "miscadmin.h"
116 #include "port/pg_lfind.h"
117 #include "storage/fd.h"
118 #include "storage/predicate.h"
119 #include "storage/proc.h"
120 #include "storage/procarray.h"
121 #include "utils/builtins.h"
122 #include "utils/memutils.h"
123 #include "utils/resowner.h"
124 #include "utils/snapmgr.h"
125 #include "utils/syscache.h"
126
127
128 /*
129 * CurrentSnapshot points to the only snapshot taken in transaction-snapshot
130 * mode, and to the latest one taken in a read-committed transaction.
131 * SecondarySnapshot is a snapshot that's always up-to-date as of the current
132 * instant, even in transaction-snapshot mode. It should only be used for
133 * special-purpose code (say, RI checking.) CatalogSnapshot points to an
134 * MVCC snapshot intended to be used for catalog scans; we must invalidate it
135 * whenever a system catalog change occurs.
136 *
137 * These SnapshotData structs are static to simplify memory allocation
138 * (see the hack in GetSnapshotData to avoid repeated malloc/free).
139 */
140 static SnapshotData CurrentSnapshotData = {SNAPSHOT_MVCC};
141 static SnapshotData SecondarySnapshotData = {SNAPSHOT_MVCC};
142 static SnapshotData CatalogSnapshotData = {SNAPSHOT_MVCC};
143 SnapshotData SnapshotSelfData = {SNAPSHOT_SELF};
144 SnapshotData SnapshotAnyData = {SNAPSHOT_ANY};
145 SnapshotData SnapshotToastData = {SNAPSHOT_TOAST};
146
147 /* Pointers to valid snapshots */
148 static Snapshot CurrentSnapshot = NULL;
149 static Snapshot SecondarySnapshot = NULL;
150 static Snapshot CatalogSnapshot = NULL;
151 static Snapshot HistoricSnapshot = NULL;
152
153 /*
154 * These are updated by GetSnapshotData. We initialize them this way
155 * for the convenience of TransactionIdIsInProgress: even in bootstrap
156 * mode, we don't want it to say that BootstrapTransactionId is in progress.
157 */
158 TransactionId TransactionXmin = FirstNormalTransactionId;
159 TransactionId RecentXmin = FirstNormalTransactionId;
160
161 /* (table, ctid) => (cmin, cmax) mapping during timetravel */
162 static HTAB *tuplecid_data = NULL;
163
164 /*
165 * Elements of the active snapshot stack.
166 *
167 * Each element here accounts for exactly one active_count on SnapshotData.
168 *
169 * NB: the code assumes that elements in this list are in non-increasing
170 * order of as_level; also, the list must be NULL-terminated.
171 */
172 typedef struct ActiveSnapshotElt
173 {
174 Snapshot as_snap;
175 int as_level;
176 struct ActiveSnapshotElt *as_next;
177 } ActiveSnapshotElt;
178
179 /* Top of the stack of active snapshots */
180 static ActiveSnapshotElt *ActiveSnapshot = NULL;
181
182 /*
183 * Currently registered Snapshots. Ordered in a heap by xmin, so that we can
184 * quickly find the one with lowest xmin, to advance our MyProc->xmin.
185 */
186 static int xmin_cmp(const pairingheap_node *a, const pairingheap_node *b,
187 void *arg);
188
189 static pairingheap RegisteredSnapshots = {&xmin_cmp, NULL, NULL};
190
191 /* first GetTransactionSnapshot call in a transaction? */
192 bool FirstSnapshotSet = false;
193
194 /*
195 * Remember the serializable transaction snapshot, if any. We cannot trust
196 * FirstSnapshotSet in combination with IsolationUsesXactSnapshot(), because
197 * GUC may be reset before us, changing the value of IsolationUsesXactSnapshot.
198 */
199 static Snapshot FirstXactSnapshot = NULL;
200
201 /* Define pathname of exported-snapshot files */
202 #define SNAPSHOT_EXPORT_DIR "pg_snapshots"
203
204 /* Structure holding info about exported snapshot. */
205 typedef struct ExportedSnapshot
206 {
207 char *snapfile;
208 Snapshot snapshot;
209 } ExportedSnapshot;
210
211 /* Current xact's exported snapshots (a list of ExportedSnapshot structs) */
212 static List *exportedSnapshots = NIL;
213
214 /* Prototypes for local functions */
215 static Snapshot CopySnapshot(Snapshot snapshot);
216 static void UnregisterSnapshotNoOwner(Snapshot snapshot);
217 static void FreeSnapshot(Snapshot snapshot);
218 static void SnapshotResetXmin(void);
219
220 /* ResourceOwner callbacks to track snapshot references */
221 static void ResOwnerReleaseSnapshot(Datum res);
222
223 static const ResourceOwnerDesc snapshot_resowner_desc =
224 {
225 .name = "snapshot reference",
226 .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
227 .release_priority = RELEASE_PRIO_SNAPSHOT_REFS,
228 .ReleaseResource = ResOwnerReleaseSnapshot,
229 .DebugPrint = NULL /* the default message is fine */
230 };
231
232 /* Convenience wrappers over ResourceOwnerRemember/Forget */
233 static inline void
234 ResourceOwnerRememberSnapshot(ResourceOwner owner, Snapshot snap)
235 {
236 ResourceOwnerRemember(owner, PointerGetDatum(snap), &snapshot_resowner_desc);
237 }
238 static inline void
239 ResourceOwnerForgetSnapshot(ResourceOwner owner, Snapshot snap)
240 {
241 ResourceOwnerForget(owner, PointerGetDatum(snap), &snapshot_resowner_desc);
242 }
243
244 /*
245 * Snapshot fields to be serialized.
246 *
247 * Only these fields need to be sent to the cooperating backend; the
248 * remaining ones can (and must) be set by the receiver upon restore.
249 */
250 typedef struct SerializedSnapshotData
251 {
252 TransactionId xmin;
253 TransactionId xmax;
254 uint32 xcnt;
255 int32 subxcnt;
256 bool suboverflowed;
257 bool takenDuringRecovery;
258 CommandId curcid;
259 } SerializedSnapshotData;
260
261 /*
262 * GetTransactionSnapshot
263 * Get the appropriate snapshot for a new query in a transaction.
264 *
265 * Note that the return value points at static storage that will be modified
266 * by future calls and by CommandCounterIncrement(). Callers must call
267 * RegisterSnapshot or PushActiveSnapshot on the returned snap before doing
268 * any other non-trivial work that could invalidate it.
269 */
270 Snapshot
271 GetTransactionSnapshot(void)
272 {
273 /*
274 * Return historic snapshot if doing logical decoding.
275 *
276 * Historic snapshots are only usable for catalog access, not for
277 * general-purpose queries. The caller is responsible for ensuring that
278 * the snapshot is used correctly! (PostgreSQL code never calls this
279 * during logical decoding, but extensions can do it.)
280 */
281 if (HistoricSnapshotActive())
282 {
283 /*
284 * We'll never need a non-historic transaction snapshot in this
285 * (sub-)transaction, so there's no need to be careful to set one up
286 * for later calls to GetTransactionSnapshot().
287 */
288 Assert(!FirstSnapshotSet);
289 return HistoricSnapshot;
290 }
291
292 /* First call in transaction? */
293 if (!FirstSnapshotSet)
294 {
295 /*
296 * Don't allow catalog snapshot to be older than xact snapshot. Must
297 * do this first to allow the empty-heap Assert to succeed.
298 */
299 InvalidateCatalogSnapshot();
300
301 Assert(pairingheap_is_empty(&RegisteredSnapshots));
302 Assert(FirstXactSnapshot == NULL);
303
304 if (IsInParallelMode())
305 elog(ERROR,
306 "cannot take query snapshot during a parallel operation");
307
308 /*
309 * In transaction-snapshot mode, the first snapshot must live until
310 * end of xact regardless of what the caller does with it, so we must
311 * make a copy of it rather than returning CurrentSnapshotData
312 * directly. Furthermore, if we're running in serializable mode,
313 * predicate.c needs to wrap the snapshot fetch in its own processing.
314 */
315 if (IsolationUsesXactSnapshot())
316 {
317 /* First, create the snapshot in CurrentSnapshotData */
318 if (IsolationIsSerializable())
319 CurrentSnapshot = GetSerializableTransactionSnapshot(&CurrentSnapshotData);
320 else
321 CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
322 /* Make a saved copy */
323 CurrentSnapshot = CopySnapshot(CurrentSnapshot);
324 FirstXactSnapshot = CurrentSnapshot;
325 /* Mark it as "registered" in FirstXactSnapshot */
326 FirstXactSnapshot->regd_count++;
327 pairingheap_add(&RegisteredSnapshots, &FirstXactSnapshot->ph_node);
328 }
329 else
330 CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
331
332 FirstSnapshotSet = true;
333 return CurrentSnapshot;
334 }
335
336 if (IsolationUsesXactSnapshot())
337 return CurrentSnapshot;
338
339 /* Don't allow catalog snapshot to be older than xact snapshot. */
340 InvalidateCatalogSnapshot();
341
342 CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
343
344 return CurrentSnapshot;
345 }
346
347 /*
348 * GetLatestSnapshot
349 * Get a snapshot that is up-to-date as of the current instant,
350 * even if we are executing in transaction-snapshot mode.
351 */
352 Snapshot
353 GetLatestSnapshot(void)
354 {
355 /*
356 * We might be able to relax this, but nothing that could otherwise work
357 * needs it.
358 */
359 if (IsInParallelMode())
360 elog(ERROR,
361 "cannot update SecondarySnapshot during a parallel operation");
362
363 /*
364 * So far there are no cases requiring support for GetLatestSnapshot()
365 * during logical decoding, but it wouldn't be hard to add if required.
366 */
367 Assert(!HistoricSnapshotActive());
368
369 /* If first call in transaction, go ahead and set the xact snapshot */
370 if (!FirstSnapshotSet)
371 return GetTransactionSnapshot();
372
373 SecondarySnapshot = GetSnapshotData(&SecondarySnapshotData);
374
375 return SecondarySnapshot;
376 }
377
378 /*
379 * GetCatalogSnapshot
380 * Get a snapshot that is sufficiently up-to-date for scan of the
381 * system catalog with the specified OID.
382 */
383 Snapshot
384 GetCatalogSnapshot(Oid relid)
385 {
386 /*
387 * Return historic snapshot while we're doing logical decoding, so we can
388 * see the appropriate state of the catalog.
389 *
390 * This is the primary reason for needing to reset the system caches after
391 * finishing decoding.
392 */
393 if (HistoricSnapshotActive())
394 return HistoricSnapshot;
395
396 return GetNonHistoricCatalogSnapshot(relid);
397 }
398
399 /*
400 * GetNonHistoricCatalogSnapshot
401 * Get a snapshot that is sufficiently up-to-date for scan of the system
402 * catalog with the specified OID, even while historic snapshots are set
403 * up.
404 */
405 Snapshot
406 GetNonHistoricCatalogSnapshot(Oid relid)
407 {
408 /*
409 * If the caller is trying to scan a relation that has no syscache, no
410 * catcache invalidations will be sent when it is updated. For a few key
411 * relations, snapshot invalidations are sent instead. If we're trying to
412 * scan a relation for which neither catcache nor snapshot invalidations
413 * are sent, we must refresh the snapshot every time.
414 */
415 if (CatalogSnapshot &&
416 !RelationInvalidatesSnapshotsOnly(relid) &&
417 !RelationHasSysCache(relid))
418 InvalidateCatalogSnapshot();
419
420 if (CatalogSnapshot == NULL)
421 {
422 /* Get new snapshot. */
423 CatalogSnapshot = GetSnapshotData(&CatalogSnapshotData);
424
425 /*
426 * Make sure the catalog snapshot will be accounted for in decisions
427 * about advancing PGPROC->xmin. We could apply RegisterSnapshot, but
428 * that would result in making a physical copy, which is overkill; and
429 * it would also create a dependency on some resource owner, which we
430 * do not want for reasons explained at the head of this file. Instead
431 * just shove the CatalogSnapshot into the pairing heap manually. This
432 * has to be reversed in InvalidateCatalogSnapshot, of course.
433 *
434 * NB: it had better be impossible for this to throw error, since the
435 * CatalogSnapshot pointer is already valid.
436 */
437 pairingheap_add(&RegisteredSnapshots, &CatalogSnapshot->ph_node);
438 }
439
440 return CatalogSnapshot;
441 }
442
443 /*
444 * InvalidateCatalogSnapshot
445 * Mark the current catalog snapshot, if any, as invalid
446 *
447 * We could change this API to allow the caller to provide more fine-grained
448 * invalidation details, so that a change to relation A wouldn't prevent us
449 * from using our cached snapshot to scan relation B, but so far there's no
450 * evidence that the CPU cycles we spent tracking such fine details would be
451 * well-spent.
452 */
453 void
454 InvalidateCatalogSnapshot(void)
455 {
456 if (CatalogSnapshot)
457 {
458 pairingheap_remove(&RegisteredSnapshots, &CatalogSnapshot->ph_node);
459 CatalogSnapshot = NULL;
460 SnapshotResetXmin();
461 }
462 }
463
464 /*
465 * InvalidateCatalogSnapshotConditionally
466 * Drop catalog snapshot if it's the only one we have
467 *
468 * This is called when we are about to wait for client input, so we don't
469 * want to continue holding the catalog snapshot if it might mean that the
470 * global xmin horizon can't advance. However, if there are other snapshots
471 * still active or registered, the catalog snapshot isn't likely to be the
472 * oldest one, so we might as well keep it.
473 */
474 void
475 InvalidateCatalogSnapshotConditionally(void)
476 {
477 if (CatalogSnapshot &&
478 ActiveSnapshot == NULL &&
479 pairingheap_is_singular(&RegisteredSnapshots))
480 InvalidateCatalogSnapshot();
481 }
482
483 /*
484 * SnapshotSetCommandId
485 * Propagate CommandCounterIncrement into the static snapshots, if set
486 */
487 void
488 SnapshotSetCommandId(CommandId curcid)
489 {
490 if (!FirstSnapshotSet)
491 return;
492
493 if (CurrentSnapshot)
494 CurrentSnapshot->curcid = curcid;
495 if (SecondarySnapshot)
496 SecondarySnapshot->curcid = curcid;
497 /* Should we do the same with CatalogSnapshot? */
498 }
499
500 /*
501 * SetTransactionSnapshot
502 * Set the transaction's snapshot from an imported MVCC snapshot.
503 *
504 * Note that this is very closely tied to GetTransactionSnapshot --- it
505 * must take care of all the same considerations as the first-snapshot case
506 * in GetTransactionSnapshot.
507 */
508 static void
509 SetTransactionSnapshot(Snapshot sourcesnap, VirtualTransactionId *sourcevxid,
510 int sourcepid, PGPROC *sourceproc)
511 {
512 /* Caller should have checked this already */
513 Assert(!FirstSnapshotSet);
514
515 /* Better do this to ensure following Assert succeeds. */
516 InvalidateCatalogSnapshot();
517
518 Assert(pairingheap_is_empty(&RegisteredSnapshots));
519 Assert(FirstXactSnapshot == NULL);
520 Assert(!HistoricSnapshotActive());
521
522 /*
523 * Even though we are not going to use the snapshot it computes, we must
524 * call GetSnapshotData, for two reasons: (1) to be sure that
525 * CurrentSnapshotData's XID arrays have been allocated, and (2) to update
526 * the state for GlobalVis*.
527 */
528 CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
529
530 /*
531 * Now copy appropriate fields from the source snapshot.
532 */
533 CurrentSnapshot->xmin = sourcesnap->xmin;
534 CurrentSnapshot->xmax = sourcesnap->xmax;
535 CurrentSnapshot->xcnt = sourcesnap->xcnt;
536 Assert(sourcesnap->xcnt <= GetMaxSnapshotXidCount());
537 if (sourcesnap->xcnt > 0)
538 memcpy(CurrentSnapshot->xip, sourcesnap->xip,
539 sourcesnap->xcnt * sizeof(TransactionId));
540 CurrentSnapshot->subxcnt = sourcesnap->subxcnt;
541 Assert(sourcesnap->subxcnt <= GetMaxSnapshotSubxidCount());
542 if (sourcesnap->subxcnt > 0)
543 memcpy(CurrentSnapshot->subxip, sourcesnap->subxip,
544 sourcesnap->subxcnt * sizeof(TransactionId));
545 CurrentSnapshot->suboverflowed = sourcesnap->suboverflowed;
546 CurrentSnapshot->takenDuringRecovery = sourcesnap->takenDuringRecovery;
547 /* NB: curcid should NOT be copied, it's a local matter */
548
549 CurrentSnapshot->snapXactCompletionCount = 0;
550
551 /*
552 * Now we have to fix what GetSnapshotData did with MyProc->xmin and
553 * TransactionXmin. There is a race condition: to make sure we are not
554 * causing the global xmin to go backwards, we have to test that the
555 * source transaction is still running, and that has to be done
556 * atomically. So let procarray.c do it.
557 *
558 * Note: in serializable mode, predicate.c will do this a second time. It
559 * doesn't seem worth contorting the logic here to avoid two calls,
560 * especially since it's not clear that predicate.c *must* do this.
561 */
562 if (sourceproc != NULL)
563 {
564 if (!ProcArrayInstallRestoredXmin(CurrentSnapshot->xmin, sourceproc))
565 ereport(ERROR,
566 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
567 errmsg("could not import the requested snapshot"),
568 errdetail("The source transaction is not running anymore.")));
569 }
570 else if (!ProcArrayInstallImportedXmin(CurrentSnapshot->xmin, sourcevxid))
571 ereport(ERROR,
572 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
573 errmsg("could not import the requested snapshot"),
574 errdetail("The source process with PID %d is not running anymore.",
575 sourcepid)));
576
577 /*
578 * In transaction-snapshot mode, the first snapshot must live until end of
579 * xact, so we must make a copy of it. Furthermore, if we're running in
580 * serializable mode, predicate.c needs to do its own processing.
581 */
582 if (IsolationUsesXactSnapshot())
583 {
584 if (IsolationIsSerializable())
585 SetSerializableTransactionSnapshot(CurrentSnapshot, sourcevxid,
586 sourcepid);
587 /* Make a saved copy */
588 CurrentSnapshot = CopySnapshot(CurrentSnapshot);
589 FirstXactSnapshot = CurrentSnapshot;
590 /* Mark it as "registered" in FirstXactSnapshot */
591 FirstXactSnapshot->regd_count++;
592 pairingheap_add(&RegisteredSnapshots, &FirstXactSnapshot->ph_node);
593 }
594
595 FirstSnapshotSet = true;
596 }
597
598 /*
599 * CopySnapshot
600 * Copy the given snapshot.
601 *
602 * The copy is palloc'd in TopTransactionContext and has initial refcounts set
603 * to 0. The returned snapshot has the copied flag set.
604 */
605 static Snapshot
606 CopySnapshot(Snapshot snapshot)
607 {
608 Snapshot newsnap;
609 Size subxipoff;
610 Size size;
611
612 Assert(snapshot != InvalidSnapshot);
613
614 /* We allocate any XID arrays needed in the same palloc block. */
615 size = subxipoff = sizeof(SnapshotData) +
616 snapshot->xcnt * sizeof(TransactionId);
617 if (snapshot->subxcnt > 0)
618 size += snapshot->subxcnt * sizeof(TransactionId);
619
620 newsnap = (Snapshot) MemoryContextAlloc(TopTransactionContext, size);
621 memcpy(newsnap, snapshot, sizeof(SnapshotData));
622
623 newsnap->regd_count = 0;
624 newsnap->active_count = 0;
625 newsnap->copied = true;
626 newsnap->snapXactCompletionCount = 0;
627
628 /* setup XID array */
629 if (snapshot->xcnt > 0)
630 {
631 newsnap->xip = (TransactionId *) (newsnap + 1);
632 memcpy(newsnap->xip, snapshot->xip,
633 snapshot->xcnt * sizeof(TransactionId));
634 }
635 else
636 newsnap->xip = NULL;
637
638 /*
639 * Setup subXID array. Don't bother to copy it if it had overflowed,
640 * though, because it's not used anywhere in that case. Except if it's a
641 * snapshot taken during recovery; all the top-level XIDs are in subxip as
642 * well in that case, so we mustn't lose them.
643 */
644 if (snapshot->subxcnt > 0 &&
645 (!snapshot->suboverflowed || snapshot->takenDuringRecovery))
646 {
647 newsnap->subxip = (TransactionId *) ((char *) newsnap + subxipoff);
648 memcpy(newsnap->subxip, snapshot->subxip,
649 snapshot->subxcnt * sizeof(TransactionId));
650 }
651 else
652 newsnap->subxip = NULL;
653
654 return newsnap;
655 }
656
657 /*
658 * FreeSnapshot
659 * Free the memory associated with a snapshot.
660 */
661 static void
662 FreeSnapshot(Snapshot snapshot)
663 {
664 Assert(snapshot->regd_count == 0);
665 Assert(snapshot->active_count == 0);
666 Assert(snapshot->copied);
667
668 pfree(snapshot);
669 }
670
671 /*
672 * PushActiveSnapshot
673 * Set the given snapshot as the current active snapshot
674 *
675 * If the passed snapshot is a statically-allocated one, or it is possibly
676 * subject to a future command counter update, create a new long-lived copy
677 * with active refcount=1. Otherwise, only increment the refcount.
678 */
679 void
680 PushActiveSnapshot(Snapshot snapshot)
681 {
682 PushActiveSnapshotWithLevel(snapshot, GetCurrentTransactionNestLevel());
683 }
684
685 /*
686 * PushActiveSnapshotWithLevel
687 * Set the given snapshot as the current active snapshot
688 *
689 * Same as PushActiveSnapshot except that caller can specify the
690 * transaction nesting level that "owns" the snapshot. This level
691 * must not be deeper than the current top of the snapshot stack.
692 */
693 void
694 PushActiveSnapshotWithLevel(Snapshot snapshot, int snap_level)
695 {
696 ActiveSnapshotElt *newactive;
697
698 Assert(snapshot != InvalidSnapshot);
699 Assert(ActiveSnapshot == NULL || snap_level >= ActiveSnapshot->as_level);
700
701 newactive = MemoryContextAlloc(TopTransactionContext, sizeof(ActiveSnapshotElt));
702
703 /*
704 * Checking SecondarySnapshot is probably useless here, but it seems
705 * better to be sure.
706 */
707 if (snapshot == CurrentSnapshot || snapshot == SecondarySnapshot ||
708 !snapshot->copied)
709 newactive->as_snap = CopySnapshot(snapshot);
710 else
711 newactive->as_snap = snapshot;
712
713 newactive->as_next = ActiveSnapshot;
714 newactive->as_level = snap_level;
715
716 newactive->as_snap->active_count++;
717
718 ActiveSnapshot = newactive;
719 }
720
721 /*
722 * PushCopiedSnapshot
723 * As above, except forcibly copy the presented snapshot.
724 *
725 * This should be used when the ActiveSnapshot has to be modifiable, for
726 * example if the caller intends to call UpdateActiveSnapshotCommandId.
727 * The new snapshot will be released when popped from the stack.
728 */
729 void
730 PushCopiedSnapshot(Snapshot snapshot)
731 {
732 PushActiveSnapshot(CopySnapshot(snapshot));
733 }
734
735 /*
736 * UpdateActiveSnapshotCommandId
737 *
738 * Update the current CID of the active snapshot. This can only be applied
739 * to a snapshot that is not referenced elsewhere.
740 */
741 void
742 UpdateActiveSnapshotCommandId(void)
743 {
744 CommandId save_curcid,
745 curcid;
746
747 Assert(ActiveSnapshot != NULL);
748 Assert(ActiveSnapshot->as_snap->active_count == 1);
749 Assert(ActiveSnapshot->as_snap->regd_count == 0);
750
751 /*
752 * Don't allow modification of the active snapshot during parallel
753 * operation. We share the snapshot to worker backends at the beginning
754 * of parallel operation, so any change to the snapshot can lead to
755 * inconsistencies. We have other defenses against
756 * CommandCounterIncrement, but there are a few places that call this
757 * directly, so we put an additional guard here.
758 */
759 save_curcid = ActiveSnapshot->as_snap->curcid;
760 curcid = GetCurrentCommandId(false);
761 if (IsInParallelMode() && save_curcid != curcid)
762 elog(ERROR, "cannot modify commandid in active snapshot during a parallel operation");
763 ActiveSnapshot->as_snap->curcid = curcid;
764 }
765
766 /*
767 * PopActiveSnapshot
768 *
769 * Remove the topmost snapshot from the active snapshot stack, decrementing the
770 * reference count, and free it if this was the last reference.
771 */
772 void
773 PopActiveSnapshot(void)
774 {
775 ActiveSnapshotElt *newstack;
776
777 newstack = ActiveSnapshot->as_next;
778
779 Assert(ActiveSnapshot->as_snap->active_count > 0);
780
781 ActiveSnapshot->as_snap->active_count--;
782
783 if (ActiveSnapshot->as_snap->active_count == 0 &&
784 ActiveSnapshot->as_snap->regd_count == 0)
785 FreeSnapshot(ActiveSnapshot->as_snap);
786
787 pfree(ActiveSnapshot);
788 ActiveSnapshot = newstack;
789
790 SnapshotResetXmin();
791 }
792
793 /*
794 * GetActiveSnapshot
795 * Return the topmost snapshot in the Active stack.
796 */
797 Snapshot
798 GetActiveSnapshot(void)
799 {
800 Assert(ActiveSnapshot != NULL);
801
802 return ActiveSnapshot->as_snap;
803 }
804
805 /*
806 * ActiveSnapshotSet
807 * Return whether there is at least one snapshot in the Active stack
808 */
809 bool
810 ActiveSnapshotSet(void)
811 {
812 return ActiveSnapshot != NULL;
813 }
814
815 /*
816 * RegisterSnapshot
817 * Register a snapshot as being in use by the current resource owner
818 *
819 * If InvalidSnapshot is passed, it is not registered.
820 */
821 Snapshot
822 RegisterSnapshot(Snapshot snapshot)
823 {
824 if (snapshot == InvalidSnapshot)
825 return InvalidSnapshot;
826
827 return RegisterSnapshotOnOwner(snapshot, CurrentResourceOwner);
828 }
829
830 /*
831 * RegisterSnapshotOnOwner
832 * As above, but use the specified resource owner
833 */
834 Snapshot
835 RegisterSnapshotOnOwner(Snapshot snapshot, ResourceOwner owner)
836 {
837 Snapshot snap;
838
839 if (snapshot == InvalidSnapshot)
840 return InvalidSnapshot;
841
842 /* Static snapshot? Create a persistent copy */
843 snap = snapshot->copied ? snapshot : CopySnapshot(snapshot);
844
845 /* and tell resowner.c about it */
846 ResourceOwnerEnlarge(owner);
847 snap->regd_count++;
848 ResourceOwnerRememberSnapshot(owner, snap);
849
850 if (snap->regd_count == 1)
851 pairingheap_add(&RegisteredSnapshots, &snap->ph_node);
852
853 return snap;
854 }
855
856 /*
857 * UnregisterSnapshot
858 *
859 * Decrement the reference count of a snapshot, remove the corresponding
860 * reference from CurrentResourceOwner, and free the snapshot if no more
861 * references remain.
862 */
863 void
864 UnregisterSnapshot(Snapshot snapshot)
865 {
866 if (snapshot == NULL)
867 return;
868
869 UnregisterSnapshotFromOwner(snapshot, CurrentResourceOwner);
870 }
871
872 /*
873 * UnregisterSnapshotFromOwner
874 * As above, but use the specified resource owner
875 */
876 void
877 UnregisterSnapshotFromOwner(Snapshot snapshot, ResourceOwner owner)
878 {
879 if (snapshot == NULL)
880 return;
881
882 ResourceOwnerForgetSnapshot(owner, snapshot);
883 UnregisterSnapshotNoOwner(snapshot);
884 }
885
886 static void
887 UnregisterSnapshotNoOwner(Snapshot snapshot)
888 {
889 Assert(snapshot->regd_count > 0);
890 Assert(!pairingheap_is_empty(&RegisteredSnapshots));
891
892 snapshot->regd_count--;
893 if (snapshot->regd_count == 0)
894 pairingheap_remove(&RegisteredSnapshots, &snapshot->ph_node);
895
896 if (snapshot->regd_count == 0 && snapshot->active_count == 0)
897 {
898 FreeSnapshot(snapshot);
899 SnapshotResetXmin();
900 }
901 }
902
903 /*
904 * Comparison function for RegisteredSnapshots heap. Snapshots are ordered
905 * by xmin, so that the snapshot with smallest xmin is at the top.
906 */
907 static int
908 xmin_cmp(const pairingheap_node *a, const pairingheap_node *b, void *arg)
909 {
910 const SnapshotData *asnap = pairingheap_const_container(SnapshotData, ph_node, a);
911 const SnapshotData *bsnap = pairingheap_const_container(SnapshotData, ph_node, b);
912
913 if (TransactionIdPrecedes(asnap->xmin, bsnap->xmin))
914 return 1;
915 else if (TransactionIdFollows(asnap->xmin, bsnap->xmin))
916 return -1;
917 else
918 return 0;
919 }
920
921 /*
922 * SnapshotResetXmin
923 *
924 * If there are no more snapshots, we can reset our PGPROC->xmin to
925 * InvalidTransactionId. Note we can do this without locking because we assume
926 * that storing an Xid is atomic.
927 *
928 * Even if there are some remaining snapshots, we may be able to advance our
929 * PGPROC->xmin to some degree. This typically happens when a portal is
930 * dropped. For efficiency, we only consider recomputing PGPROC->xmin when
931 * the active snapshot stack is empty; this allows us not to need to track
932 * which active snapshot is oldest.
933 */
934 static void
935 SnapshotResetXmin(void)
936 {
937 Snapshot minSnapshot;
938
939 if (ActiveSnapshot != NULL)
940 return;
941
942 if (pairingheap_is_empty(&RegisteredSnapshots))
943 {
944 MyProc->xmin = TransactionXmin = InvalidTransactionId;
945 return;
946 }
947
948 minSnapshot = pairingheap_container(SnapshotData, ph_node,
949 pairingheap_first(&RegisteredSnapshots));
950
951 if (TransactionIdPrecedes(MyProc->xmin, minSnapshot->xmin))
952 MyProc->xmin = TransactionXmin = minSnapshot->xmin;
953 }
954
955 /*
956 * AtSubCommit_Snapshot
957 */
958 void
959 AtSubCommit_Snapshot(int level)
960 {
961 ActiveSnapshotElt *active;
962
963 /*
964 * Relabel the active snapshots set in this subtransaction as though they
965 * are owned by the parent subxact.
966 */
967 for (active = ActiveSnapshot; active != NULL; active = active->as_next)
968 {
969 if (active->as_level < level)
970 break;
971 active->as_level = level - 1;
972 }
973 }
974
975 /*
976 * AtSubAbort_Snapshot
977 * Clean up snapshots after a subtransaction abort
978 */
979 void
980 AtSubAbort_Snapshot(int level)
981 {
982 /* Forget the active snapshots set by this subtransaction */
983 while (ActiveSnapshot && ActiveSnapshot->as_level >= level)
984 {
985 ActiveSnapshotElt *next;
986
987 next = ActiveSnapshot->as_next;
988
989 /*
990 * Decrement the snapshot's active count. If it's still registered or
991 * marked as active by an outer subtransaction, we can't free it yet.
992 */
993 Assert(ActiveSnapshot->as_snap->active_count >= 1);
994 ActiveSnapshot->as_snap->active_count -= 1;
995
996 if (ActiveSnapshot->as_snap->active_count == 0 &&
997 ActiveSnapshot->as_snap->regd_count == 0)
998 FreeSnapshot(ActiveSnapshot->as_snap);
999
1000 /* and free the stack element */
1001 pfree(ActiveSnapshot);
1002
1003 ActiveSnapshot = next;
1004 }
1005
1006 SnapshotResetXmin();
1007 }
1008
1009 /*
1010 * AtEOXact_Snapshot
1011 * Snapshot manager's cleanup function for end of transaction
1012 */
1013 void
1014 AtEOXact_Snapshot(bool isCommit, bool resetXmin)
1015 {
1016 /*
1017 * In transaction-snapshot mode we must release our privately-managed
1018 * reference to the transaction snapshot. We must remove it from
1019 * RegisteredSnapshots to keep the check below happy. But we don't bother
1020 * to do FreeSnapshot, for two reasons: the memory will go away with
1021 * TopTransactionContext anyway, and if someone has left the snapshot
1022 * stacked as active, we don't want the code below to be chasing through a
1023 * dangling pointer.
1024 */
1025 if (FirstXactSnapshot != NULL)
1026 {
1027 Assert(FirstXactSnapshot->regd_count > 0);
1028 Assert(!pairingheap_is_empty(&RegisteredSnapshots));
1029 pairingheap_remove(&RegisteredSnapshots, &FirstXactSnapshot->ph_node);
1030 }
1031 FirstXactSnapshot = NULL;
1032
1033 /*
1034 * If we exported any snapshots, clean them up.
1035 */
1036 if (exportedSnapshots != NIL)
1037 {
1038 ListCell *lc;
1039
1040 /*
1041 * Get rid of the files. Unlink failure is only a WARNING because (1)
1042 * it's too late to abort the transaction, and (2) leaving a leaked
1043 * file around has little real consequence anyway.
1044 *
1045 * We also need to remove the snapshots from RegisteredSnapshots to
1046 * prevent a warning below.
1047 *
1048 * As with the FirstXactSnapshot, we don't need to free resources of
1049 * the snapshot itself as it will go away with the memory context.
1050 */
1051 foreach(lc, exportedSnapshots)
1052 {
1053 ExportedSnapshot *esnap = (ExportedSnapshot *) lfirst(lc);
1054
1055 if (unlink(esnap->snapfile))
1056 elog(WARNING, "could not unlink file \"%s\": %m",
1057 esnap->snapfile);
1058
1059 pairingheap_remove(&RegisteredSnapshots,
1060 &esnap->snapshot->ph_node);
1061 }
1062
1063 exportedSnapshots = NIL;
1064 }
1065
1066 /* Drop catalog snapshot if any */
1067 InvalidateCatalogSnapshot();
1068
1069 /* On commit, complain about leftover snapshots */
1070 if (isCommit)
1071 {
1072 ActiveSnapshotElt *active;
1073
1074 if (!pairingheap_is_empty(&RegisteredSnapshots))
1075 elog(WARNING, "registered snapshots seem to remain after cleanup");
1076
1077 /* complain about unpopped active snapshots */
1078 for (active = ActiveSnapshot; active != NULL; active = active->as_next)
1079 elog(WARNING, "snapshot %p still active", active);
1080 }
1081
1082 /*
1083 * And reset our state. We don't need to free the memory explicitly --
1084 * it'll go away with TopTransactionContext.
1085 */
1086 ActiveSnapshot = NULL;
1087 pairingheap_reset(&RegisteredSnapshots);
1088
1089 CurrentSnapshot = NULL;
1090 SecondarySnapshot = NULL;
1091
1092 FirstSnapshotSet = false;
1093
1094 /*
1095 * During normal commit processing, we call ProcArrayEndTransaction() to
1096 * reset the MyProc->xmin. That call happens prior to the call to
1097 * AtEOXact_Snapshot(), so we need not touch xmin here at all.
1098 */
1099 if (resetXmin)
1100 SnapshotResetXmin();
1101
1102 Assert(resetXmin || MyProc->xmin == 0);
1103 }
1104
1105
1106 /*
1107 * ExportSnapshot
1108 * Export the snapshot to a file so that other backends can import it.
1109 * Returns the token (the file name) that can be used to import this
1110 * snapshot.
1111 */
1112 char *
1113 ExportSnapshot(Snapshot snapshot)
1114 {
1115 TransactionId topXid;
1116 TransactionId *children;
1117 ExportedSnapshot *esnap;
1118 int nchildren;
1119 int addTopXid;
1120 StringInfoData buf;
1121 FILE *f;
1122 int i;
1123 MemoryContext oldcxt;
1124 char path[MAXPGPATH];
1125 char pathtmp[MAXPGPATH];
1126
1127 /*
1128 * It's tempting to call RequireTransactionBlock here, since it's not very
1129 * useful to export a snapshot that will disappear immediately afterwards.
1130 * However, we haven't got enough information to do that, since we don't
1131 * know if we're at top level or not. For example, we could be inside a
1132 * plpgsql function that is going to fire off other transactions via
1133 * dblink. Rather than disallow perfectly legitimate usages, don't make a
1134 * check.
1135 *
1136 * Also note that we don't make any restriction on the transaction's
1137 * isolation level; however, importers must check the level if they are
1138 * serializable.
1139 */
1140
1141 /*
1142 * Get our transaction ID if there is one, to include in the snapshot.
1143 */
1144 topXid = GetTopTransactionIdIfAny();
1145
1146 /*
1147 * We cannot export a snapshot from a subtransaction because there's no
1148 * easy way for importers to verify that the same subtransaction is still
1149 * running.
1150 */
1151 if (IsSubTransaction())
1152 ereport(ERROR,
1153 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
1154 errmsg("cannot export a snapshot from a subtransaction")));
1155
1156 /*
1157 * We do however allow previous committed subtransactions to exist.
1158 * Importers of the snapshot must see them as still running, so get their
1159 * XIDs to add them to the snapshot.
1160 */
1161 nchildren = xactGetCommittedChildren(&children);
1162
1163 /*
1164 * Generate file path for the snapshot. We start numbering of snapshots
1165 * inside the transaction from 1.
1166 */
1167 snprintf(path, sizeof(path), SNAPSHOT_EXPORT_DIR "/%08X-%08X-%d",
1168 MyProc->vxid.procNumber, MyProc->vxid.lxid,
1169 list_length(exportedSnapshots) + 1);
1170
1171 /*
1172 * Copy the snapshot into TopTransactionContext, add it to the
1173 * exportedSnapshots list, and mark it pseudo-registered. We do this to
1174 * ensure that the snapshot's xmin is honored for the rest of the
1175 * transaction.
1176 */
1177 snapshot = CopySnapshot(snapshot);
1178
1179 oldcxt = MemoryContextSwitchTo(TopTransactionContext);
1180 esnap = (ExportedSnapshot *) palloc(sizeof(ExportedSnapshot));
1181 esnap->snapfile = pstrdup(path);
1182 esnap->snapshot = snapshot;
1183 exportedSnapshots = lappend(exportedSnapshots, esnap);
1184 MemoryContextSwitchTo(oldcxt);
1185
1186 snapshot->regd_count++;
1187 pairingheap_add(&RegisteredSnapshots, &snapshot->ph_node);
1188
1189 /*
1190 * Fill buf with a text serialization of the snapshot, plus identification
1191 * data about this transaction. The format expected by ImportSnapshot is
1192 * pretty rigid: each line must be fieldname:value.
1193 */
1194 initStringInfo(&buf);
1195
1196 appendStringInfo(&buf, "vxid:%d/%u\n", MyProc->vxid.procNumber, MyProc->vxid.lxid);
1197 appendStringInfo(&buf, "pid:%d\n", MyProcPid);
1198 appendStringInfo(&buf, "dbid:%u\n", MyDatabaseId);
1199 appendStringInfo(&buf, "iso:%d\n", XactIsoLevel);
1200 appendStringInfo(&buf, "ro:%d\n", XactReadOnly);
1201
1202 appendStringInfo(&buf, "xmin:%u\n", snapshot->xmin);
1203 appendStringInfo(&buf, "xmax:%u\n", snapshot->xmax);
1204
1205 /*
1206 * We must include our own top transaction ID in the top-xid data, since
1207 * by definition we will still be running when the importing transaction
1208 * adopts the snapshot, but GetSnapshotData never includes our own XID in
1209 * the snapshot. (There must, therefore, be enough room to add it.)
1210 *
1211 * However, it could be that our topXid is after the xmax, in which case
1212 * we shouldn't include it because xip[] members are expected to be before
1213 * xmax. (We need not make the same check for subxip[] members, see
1214 * snapshot.h.)
1215 */
1216 addTopXid = (TransactionIdIsValid(topXid) &&
1217 TransactionIdPrecedes(topXid, snapshot->xmax)) ? 1 : 0;
1218 appendStringInfo(&buf, "xcnt:%d\n", snapshot->xcnt + addTopXid);
1219 for (i = 0; i < snapshot->xcnt; i++)
1220 appendStringInfo(&buf, "xip:%u\n", snapshot->xip[i]);
1221 if (addTopXid)
1222 appendStringInfo(&buf, "xip:%u\n", topXid);
1223
1224 /*
1225 * Similarly, we add our subcommitted child XIDs to the subxid data. Here,
1226 * we have to cope with possible overflow.
1227 */
1228 if (snapshot->suboverflowed ||
1229 snapshot->subxcnt + nchildren > GetMaxSnapshotSubxidCount())
1230 appendStringInfoString(&buf, "sof:1\n");
1231 else
1232 {
1233 appendStringInfoString(&buf, "sof:0\n");
1234 appendStringInfo(&buf, "sxcnt:%d\n", snapshot->subxcnt + nchildren);
1235 for (i = 0; i < snapshot->subxcnt; i++)
1236 appendStringInfo(&buf, "sxp:%u\n", snapshot->subxip[i]);
1237 for (i = 0; i < nchildren; i++)
1238 appendStringInfo(&buf, "sxp:%u\n", children[i]);
1239 }
1240 appendStringInfo(&buf, "rec:%u\n", snapshot->takenDuringRecovery);
1241
1242 /*
1243 * Now write the text representation into a file. We first write to a
1244 * ".tmp" filename, and rename to final filename if no error. This
1245 * ensures that no other backend can read an incomplete file
1246 * (ImportSnapshot won't allow it because of its valid-characters check).
1247 */
1248 snprintf(pathtmp, sizeof(pathtmp), "%s.tmp", path);
1249 if (!(f = AllocateFile(pathtmp, PG_BINARY_W)))
1250 ereport(ERROR,
1251 (errcode_for_file_access(),
1252 errmsg("could not create file \"%s\": %m", pathtmp)));
1253
1254 if (fwrite(buf.data, buf.len, 1, f) != 1)
1255 ereport(ERROR,
1256 (errcode_for_file_access(),
1257 errmsg("could not write to file \"%s\": %m", pathtmp)));
1258
1259 /* no fsync() since file need not survive a system crash */
1260
1261 if (FreeFile(f))
1262 ereport(ERROR,
1263 (errcode_for_file_access(),
1264 errmsg("could not write to file \"%s\": %m", pathtmp)));
1265
1266 /*
1267 * Now that we have written everything into a .tmp file, rename the file
1268 * to remove the .tmp suffix.
1269 */
1270 if (rename(pathtmp, path) < 0)
1271 ereport(ERROR,
1272 (errcode_for_file_access(),
1273 errmsg("could not rename file \"%s\" to \"%s\": %m",
1274 pathtmp, path)));
1275
1276 /*
1277 * The basename of the file is what we return from pg_export_snapshot().
1278 * It's already in path in a textual format and we know that the path
1279 * starts with SNAPSHOT_EXPORT_DIR. Skip over the prefix and the slash
1280 * and pstrdup it so as not to return the address of a local variable.
1281 */
1282 return pstrdup(path + strlen(SNAPSHOT_EXPORT_DIR) + 1);
1283 }
1284
1285 /*
1286 * pg_export_snapshot
1287 * SQL-callable wrapper for ExportSnapshot.
1288 */
1289 Datum
1290 pg_export_snapshot(PG_FUNCTION_ARGS)
1291 {
1292 char *snapshotName;
1293
1294 snapshotName = ExportSnapshot(GetActiveSnapshot());
1295 PG_RETURN_TEXT_P(cstring_to_text(snapshotName));
1296 }
1297
1298
1299 /*
1300 * Parsing subroutines for ImportSnapshot: parse a line with the given
1301 * prefix followed by a value, and advance *s to the next line. The
1302 * filename is provided for use in error messages.
1303 */
1304 static int
1305 parseIntFromText(const char *prefix, char **s, const char *filename)
1306 {
1307 char *ptr = *s;
1308 int prefixlen = strlen(prefix);
1309 int val;
1310
1311 if (strncmp(ptr, prefix, prefixlen) != 0)
1312 ereport(ERROR,
1313 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1314 errmsg("invalid snapshot data in file \"%s\"", filename)));
1315 ptr += prefixlen;
1316 if (sscanf(ptr, "%d", &val) != 1)
1317 ereport(ERROR,
1318 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1319 errmsg("invalid snapshot data in file \"%s\"", filename)));
1320 ptr = strchr(ptr, '\n');
1321 if (!ptr)
1322 ereport(ERROR,
1323 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1324 errmsg("invalid snapshot data in file \"%s\"", filename)));
1325 *s = ptr + 1;
1326 return val;
1327 }
1328
1329 static TransactionId
1330 parseXidFromText(const char *prefix, char **s, const char *filename)
1331 {
1332 char *ptr = *s;
1333 int prefixlen = strlen(prefix);
1334 TransactionId val;
1335
1336 if (strncmp(ptr, prefix, prefixlen) != 0)
1337 ereport(ERROR,
1338 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1339 errmsg("invalid snapshot data in file \"%s\"", filename)));
1340 ptr += prefixlen;
1341 if (sscanf(ptr, "%u", &val) != 1)
1342 ereport(ERROR,
1343 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1344 errmsg("invalid snapshot data in file \"%s\"", filename)));
1345 ptr = strchr(ptr, '\n');
1346 if (!ptr)
1347 ereport(ERROR,
1348 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1349 errmsg("invalid snapshot data in file \"%s\"", filename)));
1350 *s = ptr + 1;
1351 return val;
1352 }
1353
1354 static void
1355 parseVxidFromText(const char *prefix, char **s, const char *filename,
1356 VirtualTransactionId *vxid)
1357 {
1358 char *ptr = *s;
1359 int prefixlen = strlen(prefix);
1360
1361 if (strncmp(ptr, prefix, prefixlen) != 0)
1362 ereport(ERROR,
1363 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1364 errmsg("invalid snapshot data in file \"%s\"", filename)));
1365 ptr += prefixlen;
1366 if (sscanf(ptr, "%d/%u", &vxid->procNumber, &vxid->localTransactionId) != 2)
1367 ereport(ERROR,
1368 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1369 errmsg("invalid snapshot data in file \"%s\"", filename)));
1370 ptr = strchr(ptr, '\n');
1371 if (!ptr)
1372 ereport(ERROR,
1373 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1374 errmsg("invalid snapshot data in file \"%s\"", filename)));
1375 *s = ptr + 1;
1376 }
1377
1378 /*
1379 * ImportSnapshot
1380 * Import a previously exported snapshot. The argument should be a
1381 * filename in SNAPSHOT_EXPORT_DIR. Load the snapshot from that file.
1382 * This is called by "SET TRANSACTION SNAPSHOT 'foo'".
1383 */
1384 void
1385 ImportSnapshot(const char *idstr)
1386 {
1387 char path[MAXPGPATH];
1388 FILE *f;
1389 struct stat stat_buf;
1390 char *filebuf;
1391 int xcnt;
1392 int i;
1393 VirtualTransactionId src_vxid;
1394 int src_pid;
1395 Oid src_dbid;
1396 int src_isolevel;
1397 bool src_readonly;
1398 SnapshotData snapshot;
1399
1400 /*
1401 * Must be at top level of a fresh transaction. Note in particular that
1402 * we check we haven't acquired an XID --- if we have, it's conceivable
1403 * that the snapshot would show it as not running, making for very screwy
1404 * behavior.
1405 */
1406 if (FirstSnapshotSet ||
1407 GetTopTransactionIdIfAny() != InvalidTransactionId ||
1408 IsSubTransaction())
1409 ereport(ERROR,
1410 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
1411 errmsg("SET TRANSACTION SNAPSHOT must be called before any query")));
1412
1413 /*
1414 * If we are in read committed mode then the next query would execute with
1415 * a new snapshot thus making this function call quite useless.
1416 */
1417 if (!IsolationUsesXactSnapshot())
1418 ereport(ERROR,
1419 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1420 errmsg("a snapshot-importing transaction must have isolation level SERIALIZABLE or REPEATABLE READ")));
1421
1422 /*
1423 * Verify the identifier: only 0-9, A-F and hyphens are allowed. We do
1424 * this mainly to prevent reading arbitrary files.
1425 */
1426 if (strspn(idstr, "0123456789ABCDEF-") != strlen(idstr))
1427 ereport(ERROR,
1428 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1429 errmsg("invalid snapshot identifier: \"%s\"", idstr)));
1430
1431 /* OK, read the file */
1432 snprintf(path, MAXPGPATH, SNAPSHOT_EXPORT_DIR "/%s", idstr);
1433
1434 f = AllocateFile(path, PG_BINARY_R);
1435 if (!f)
1436 {
1437 /*
1438 * If file is missing while identifier has a correct format, avoid
1439 * system errors.
1440 */
1441 if (errno == ENOENT)
1442 ereport(ERROR,
1443 (errcode(ERRCODE_UNDEFINED_OBJECT),
1444 errmsg("snapshot \"%s\" does not exist", idstr)));
1445 else
1446 ereport(ERROR,
1447 (errcode_for_file_access(),
1448 errmsg("could not open file \"%s\" for reading: %m",
1449 path)));
1450 }
1451
1452 /* get the size of the file so that we know how much memory we need */
1453 if (fstat(fileno(f), &stat_buf))
1454 elog(ERROR, "could not stat file \"%s\": %m", path);
1455
1456 /* and read the file into a palloc'd string */
1457 filebuf = (char *) palloc(stat_buf.st_size + 1);
1458 if (fread(filebuf, stat_buf.st_size, 1, f) != 1)
1459 elog(ERROR, "could not read file \"%s\": %m", path);
1460
1461 filebuf[stat_buf.st_size] = '\0';
1462
1463 FreeFile(f);
1464
1465 /*
1466 * Construct a snapshot struct by parsing the file content.
1467 */
1468 memset(&snapshot, 0, sizeof(snapshot));
1469
1470 parseVxidFromText("vxid:", &filebuf, path, &src_vxid);
1471 src_pid = parseIntFromText("pid:", &filebuf, path);
1472 /* we abuse parseXidFromText a bit here ... */
1473 src_dbid = parseXidFromText("dbid:", &filebuf, path);
1474 src_isolevel = parseIntFromText("iso:", &filebuf, path);
1475 src_readonly = parseIntFromText("ro:", &filebuf, path);
1476
1477 snapshot.snapshot_type = SNAPSHOT_MVCC;
1478
1479 snapshot.xmin = parseXidFromText("xmin:", &filebuf, path);
1480 snapshot.xmax = parseXidFromText("xmax:", &filebuf, path);
1481
1482 snapshot.xcnt = xcnt = parseIntFromText("xcnt:", &filebuf, path);
1483
1484 /* sanity-check the xid count before palloc */
1485 if (xcnt < 0 || xcnt > GetMaxSnapshotXidCount())
1486 ereport(ERROR,
1487 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1488 errmsg("invalid snapshot data in file \"%s\"", path)));
1489
1490 snapshot.xip = (TransactionId *) palloc(xcnt * sizeof(TransactionId));
1491 for (i = 0; i < xcnt; i++)
1492 snapshot.xip[i] = parseXidFromText("xip:", &filebuf, path);
1493
1494 snapshot.suboverflowed = parseIntFromText("sof:", &filebuf, path);
1495
1496 if (!snapshot.suboverflowed)
1497 {
1498 snapshot.subxcnt = xcnt = parseIntFromText("sxcnt:", &filebuf, path);
1499
1500 /* sanity-check the xid count before palloc */
1501 if (xcnt < 0 || xcnt > GetMaxSnapshotSubxidCount())
1502 ereport(ERROR,
1503 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1504 errmsg("invalid snapshot data in file \"%s\"", path)));
1505
1506 snapshot.subxip = (TransactionId *) palloc(xcnt * sizeof(TransactionId));
1507 for (i = 0; i < xcnt; i++)
1508 snapshot.subxip[i] = parseXidFromText("sxp:", &filebuf, path);
1509 }
1510 else
1511 {
1512 snapshot.subxcnt = 0;
1513 snapshot.subxip = NULL;
1514 }
1515
1516 snapshot.takenDuringRecovery = parseIntFromText("rec:", &filebuf, path);
1517
1518 /*
1519 * Do some additional sanity checking, just to protect ourselves. We
1520 * don't trouble to check the array elements, just the most critical
1521 * fields.
1522 */
1523 if (!VirtualTransactionIdIsValid(src_vxid) ||
1524 !OidIsValid(src_dbid) ||
1525 !TransactionIdIsNormal(snapshot.xmin) ||
1526 !TransactionIdIsNormal(snapshot.xmax))
1527 ereport(ERROR,
1528 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1529 errmsg("invalid snapshot data in file \"%s\"", path)));
1530
1531 /*
1532 * If we're serializable, the source transaction must be too, otherwise
1533 * predicate.c has problems (SxactGlobalXmin could go backwards). Also, a
1534 * non-read-only transaction can't adopt a snapshot from a read-only
1535 * transaction, as predicate.c handles the cases very differently.
1536 */
1537 if (IsolationIsSerializable())
1538 {
1539 if (src_isolevel != XACT_SERIALIZABLE)
1540 ereport(ERROR,
1541 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1542 errmsg("a serializable transaction cannot import a snapshot from a non-serializable transaction")));
1543 if (src_readonly && !XactReadOnly)
1544 ereport(ERROR,
1545 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1546 errmsg("a non-read-only serializable transaction cannot import a snapshot from a read-only transaction")));
1547 }
1548
1549 /*
1550 * We cannot import a snapshot that was taken in a different database,
1551 * because vacuum calculates OldestXmin on a per-database basis; so the
1552 * source transaction's xmin doesn't protect us from data loss. This
1553 * restriction could be removed if the source transaction were to mark its
1554 * xmin as being globally applicable. But that would require some
1555 * additional syntax, since that has to be known when the snapshot is
1556 * initially taken. (See pgsql-hackers discussion of 2011-10-21.)
1557 */
1558 if (src_dbid != MyDatabaseId)
1559 ereport(ERROR,
1560 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1561 errmsg("cannot import a snapshot from a different database")));
1562
1563 /* OK, install the snapshot */
1564 SetTransactionSnapshot(&snapshot, &src_vxid, src_pid, NULL);
1565 }
1566
1567 /*
1568 * XactHasExportedSnapshots
1569 * Test whether current transaction has exported any snapshots.
1570 */
1571 bool
1572 XactHasExportedSnapshots(void)
1573 {
1574 return (exportedSnapshots != NIL);
1575 }
1576
1577 /*
1578 * DeleteAllExportedSnapshotFiles
1579 * Clean up any files that have been left behind by a crashed backend
1580 * that had exported snapshots before it died.
1581 *
1582 * This should be called during database startup or crash recovery.
1583 */
1584 void
1585 DeleteAllExportedSnapshotFiles(void)
1586 {
1587 char buf[MAXPGPATH + sizeof(SNAPSHOT_EXPORT_DIR)];
1588 DIR *s_dir;
1589 struct dirent *s_de;
1590
1591 /*
1592 * Problems in reading the directory, or unlinking files, are reported at
1593 * LOG level. Since we're running in the startup process, ERROR level
1594 * would prevent database start, and it's not important enough for that.
1595 */
1596 s_dir = AllocateDir(SNAPSHOT_EXPORT_DIR);
1597
1598 while ((s_de = ReadDirExtended(s_dir, SNAPSHOT_EXPORT_DIR, LOG)) != NULL)
1599 {
1600 if (strcmp(s_de->d_name, ".") == 0 ||
1601 strcmp(s_de->d_name, "..") == 0)
1602 continue;
1603
1604 snprintf(buf, sizeof(buf), SNAPSHOT_EXPORT_DIR "/%s", s_de->d_name);
1605
1606 if (unlink(buf) != 0)
1607 ereport(LOG,
1608 (errcode_for_file_access(),
1609 errmsg("could not remove file \"%s\": %m", buf)));
1610 }
1611
1612 FreeDir(s_dir);
1613 }
1614
1615 /*
1616 * ThereAreNoPriorRegisteredSnapshots
1617 * Is the registered snapshot count less than or equal to one?
1618 *
1619 * Don't use this to settle important decisions. While zero registrations and
1620 * no ActiveSnapshot would confirm a certain idleness, the system makes no
1621 * guarantees about the significance of one registered snapshot.
1622 */
1623 bool
1624 ThereAreNoPriorRegisteredSnapshots(void)
1625 {
1626 if (pairingheap_is_empty(&RegisteredSnapshots) ||
1627 pairingheap_is_singular(&RegisteredSnapshots))
1628 return true;
1629
1630 return false;
1631 }
1632
1633 /*
1634 * HaveRegisteredOrActiveSnapshot
1635 * Is there any registered or active snapshot?
1636 *
1637 * NB: Unless pushed or active, the cached catalog snapshot will not cause
1638 * this function to return true. That allows this function to be used in
1639 * checks enforcing a longer-lived snapshot.
1640 */
1641 bool
1642 HaveRegisteredOrActiveSnapshot(void)
1643 {
1644 if (ActiveSnapshot != NULL)
1645 return true;
1646
1647 /*
1648 * The catalog snapshot is in RegisteredSnapshots when valid, but can be
1649 * removed at any time due to invalidation processing. If explicitly
1650 * registered more than one snapshot has to be in RegisteredSnapshots.
1651 */
1652 if (CatalogSnapshot != NULL &&
1653 pairingheap_is_singular(&RegisteredSnapshots))
1654 return false;
1655
1656 return !pairingheap_is_empty(&RegisteredSnapshots);
1657 }
1658
1659
1660 /*
1661 * Setup a snapshot that replaces normal catalog snapshots that allows catalog
1662 * access to behave just like it did at a certain point in the past.
1663 *
1664 * Needed for logical decoding.
1665 */
1666 void
1667 SetupHistoricSnapshot(Snapshot historic_snapshot, HTAB *tuplecids)
1668 {
1669 Assert(historic_snapshot != NULL);
1670
1671 /* setup the timetravel snapshot */
1672 HistoricSnapshot = historic_snapshot;
1673
1674 /* setup (cmin, cmax) lookup hash */
1675 tuplecid_data = tuplecids;
1676 }
1677
1678
1679 /*
1680 * Make catalog snapshots behave normally again.
1681 */
1682 void
1683 TeardownHistoricSnapshot(bool is_error)
1684 {
1685 HistoricSnapshot = NULL;
1686 tuplecid_data = NULL;
1687 }
1688
1689 bool
1690 HistoricSnapshotActive(void)
1691 {
1692 return HistoricSnapshot != NULL;
1693 }
1694
1695 HTAB *
1696 HistoricSnapshotGetTupleCids(void)
1697 {
1698 Assert(HistoricSnapshotActive());
1699 return tuplecid_data;
1700 }
1701
1702 /*
1703 * EstimateSnapshotSpace
1704 * Returns the size needed to store the given snapshot.
1705 *
1706 * We are exporting only required fields from the Snapshot, stored in
1707 * SerializedSnapshotData.
1708 */
1709 Size
1710 EstimateSnapshotSpace(Snapshot snapshot)
1711 {
1712 Size size;
1713
1714 Assert(snapshot != InvalidSnapshot);
1715 Assert(snapshot->snapshot_type == SNAPSHOT_MVCC);
1716
1717 /* We allocate any XID arrays needed in the same palloc block. */
1718 size = add_size(sizeof(SerializedSnapshotData),
1719 mul_size(snapshot->xcnt, sizeof(TransactionId)));
1720 if (snapshot->subxcnt > 0 &&
1721 (!snapshot->suboverflowed || snapshot->takenDuringRecovery))
1722 size = add_size(size,
1723 mul_size(snapshot->subxcnt, sizeof(TransactionId)));
1724
1725 return size;
1726 }
1727
1728 /*
1729 * SerializeSnapshot
1730 * Dumps the serialized snapshot (extracted from given snapshot) onto the
1731 * memory location at start_address.
1732 */
1733 void
1734 SerializeSnapshot(Snapshot snapshot, char *start_address)
1735 {
1736 SerializedSnapshotData serialized_snapshot;
1737
1738 Assert(snapshot->subxcnt >= 0);
1739
1740 /* Copy all required fields */
1741 serialized_snapshot.xmin = snapshot->xmin;
1742 serialized_snapshot.xmax = snapshot->xmax;
1743 serialized_snapshot.xcnt = snapshot->xcnt;
1744 serialized_snapshot.subxcnt = snapshot->subxcnt;
1745 serialized_snapshot.suboverflowed = snapshot->suboverflowed;
1746 serialized_snapshot.takenDuringRecovery = snapshot->takenDuringRecovery;
1747 serialized_snapshot.curcid = snapshot->curcid;
1748
1749 /*
1750 * Ignore the SubXID array if it has overflowed, unless the snapshot was
1751 * taken during recovery - in that case, top-level XIDs are in subxip as
1752 * well, and we mustn't lose them.
1753 */
1754 if (serialized_snapshot.suboverflowed && !snapshot->takenDuringRecovery)
1755 serialized_snapshot.subxcnt = 0;
1756
1757 /* Copy struct to possibly-unaligned buffer */
1758 memcpy(start_address,
1759 &serialized_snapshot, sizeof(SerializedSnapshotData));
1760
1761 /* Copy XID array */
1762 if (snapshot->xcnt > 0)
1763 memcpy((TransactionId *) (start_address +
1764 sizeof(SerializedSnapshotData)),
1765 snapshot->xip, snapshot->xcnt * sizeof(TransactionId));
1766
1767 /*
1768 * Copy SubXID array. Don't bother to copy it if it had overflowed,
1769 * though, because it's not used anywhere in that case. Except if it's a
1770 * snapshot taken during recovery; all the top-level XIDs are in subxip as
1771 * well in that case, so we mustn't lose them.
1772 */
1773 if (serialized_snapshot.subxcnt > 0)
1774 {
1775 Size subxipoff = sizeof(SerializedSnapshotData) +
1776 snapshot->xcnt * sizeof(TransactionId);
1777
1778 memcpy((TransactionId *) (start_address + subxipoff),
1779 snapshot->subxip, snapshot->subxcnt * sizeof(TransactionId));
1780 }
1781 }
1782
1783 /*
1784 * RestoreSnapshot
1785 * Restore a serialized snapshot from the specified address.
1786 *
1787 * The copy is palloc'd in TopTransactionContext and has initial refcounts set
1788 * to 0. The returned snapshot has the copied flag set.
1789 */
1790 Snapshot
1791 RestoreSnapshot(char *start_address)
1792 {
1793 SerializedSnapshotData serialized_snapshot;
1794 Size size;
1795 Snapshot snapshot;
1796 TransactionId *serialized_xids;
1797
1798 memcpy(&serialized_snapshot, start_address,
1799 sizeof(SerializedSnapshotData));
1800 serialized_xids = (TransactionId *)
1801 (start_address + sizeof(SerializedSnapshotData));
1802
1803 /* We allocate any XID arrays needed in the same palloc block. */
1804 size = sizeof(SnapshotData)
1805 + serialized_snapshot.xcnt * sizeof(TransactionId)
1806 + serialized_snapshot.subxcnt * sizeof(TransactionId);
1807
1808 /* Copy all required fields */
1809 snapshot = (Snapshot) MemoryContextAlloc(TopTransactionContext, size);
1810 snapshot->snapshot_type = SNAPSHOT_MVCC;
1811 snapshot->xmin = serialized_snapshot.xmin;
1812 snapshot->xmax = serialized_snapshot.xmax;
1813 snapshot->xip = NULL;
1814 snapshot->xcnt = serialized_snapshot.xcnt;
1815 snapshot->subxip = NULL;
1816 snapshot->subxcnt = serialized_snapshot.subxcnt;
1817 snapshot->suboverflowed = serialized_snapshot.suboverflowed;
1818 snapshot->takenDuringRecovery = serialized_snapshot.takenDuringRecovery;
1819 snapshot->curcid = serialized_snapshot.curcid;
1820 snapshot->snapXactCompletionCount = 0;
1821
1822 /* Copy XIDs, if present. */
1823 if (serialized_snapshot.xcnt > 0)
1824 {
1825 snapshot->xip = (TransactionId *) (snapshot + 1);
1826 memcpy(snapshot->xip, serialized_xids,
1827 serialized_snapshot.xcnt * sizeof(TransactionId));
1828 }
1829
1830 /* Copy SubXIDs, if present. */
1831 if (serialized_snapshot.subxcnt > 0)
1832 {
1833 snapshot->subxip = ((TransactionId *) (snapshot + 1)) +
1834 serialized_snapshot.xcnt;
1835 memcpy(snapshot->subxip, serialized_xids + serialized_snapshot.xcnt,
1836 serialized_snapshot.subxcnt * sizeof(TransactionId));
1837 }
1838
1839 /* Set the copied flag so that the caller will set refcounts correctly. */
1840 snapshot->regd_count = 0;
1841 snapshot->active_count = 0;
1842 snapshot->copied = true;
1843
1844 return snapshot;
1845 }
1846
1847 /*
1848 * Install a restored snapshot as the transaction snapshot.
1849 *
1850 * The second argument is of type void * so that snapmgr.h need not include
1851 * the declaration for PGPROC.
1852 */
1853 void
1854 RestoreTransactionSnapshot(Snapshot snapshot, void *source_pgproc)
1855 {
1856 SetTransactionSnapshot(snapshot, NULL, InvalidPid, source_pgproc);
1857 }
1858
1859 /*
1860 * XidInMVCCSnapshot
1861 * Is the given XID still-in-progress according to the snapshot?
1862 *
1863 * Note: GetSnapshotData never stores either top xid or subxids of our own
1864 * backend into a snapshot, so these xids will not be reported as "running"
1865 * by this function. This is OK for current uses, because we always check
1866 * TransactionIdIsCurrentTransactionId first, except when it's known the
1867 * XID could not be ours anyway.
1868 */
1869 bool
1870 XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot)
1871 {
1872 /*
1873 * Make a quick range check to eliminate most XIDs without looking at the
1874 * xip arrays. Note that this is OK even if we convert a subxact XID to
1875 * its parent below, because a subxact with XID < xmin has surely also got
1876 * a parent with XID < xmin, while one with XID >= xmax must belong to a
1877 * parent that was not yet committed at the time of this snapshot.
1878 */
1879
1880 /* Any xid < xmin is not in-progress */
1881 if (TransactionIdPrecedes(xid, snapshot->xmin))
1882 return false;
1883 /* Any xid >= xmax is in-progress */
1884 if (TransactionIdFollowsOrEquals(xid, snapshot->xmax))
1885 return true;
1886
1887 /*
1888 * Snapshot information is stored slightly differently in snapshots taken
1889 * during recovery.
1890 */
1891 if (!snapshot->takenDuringRecovery)
1892 {
1893 /*
1894 * If the snapshot contains full subxact data, the fastest way to
1895 * check things is just to compare the given XID against both subxact
1896 * XIDs and top-level XIDs. If the snapshot overflowed, we have to
1897 * use pg_subtrans to convert a subxact XID to its parent XID, but
1898 * then we need only look at top-level XIDs not subxacts.
1899 */
1900 if (!snapshot->suboverflowed)
1901 {
1902 /* we have full data, so search subxip */
1903 if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
1904 return true;
1905
1906 /* not there, fall through to search xip[] */
1907 }
1908 else
1909 {
1910 /*
1911 * Snapshot overflowed, so convert xid to top-level. This is safe
1912 * because we eliminated too-old XIDs above.
1913 */
1914 xid = SubTransGetTopmostTransaction(xid);
1915
1916 /*
1917 * If xid was indeed a subxact, we might now have an xid < xmin,
1918 * so recheck to avoid an array scan. No point in rechecking
1919 * xmax.
1920 */
1921 if (TransactionIdPrecedes(xid, snapshot->xmin))
1922 return false;
1923 }
1924
1925 if (pg_lfind32(xid, snapshot->xip, snapshot->xcnt))
1926 return true;
1927 }
1928 else
1929 {
1930 /*
1931 * In recovery we store all xids in the subxip array because it is by
1932 * far the bigger array, and we mostly don't know which xids are
1933 * top-level and which are subxacts. The xip array is empty.
1934 *
1935 * We start by searching subtrans, if we overflowed.
1936 */
1937 if (snapshot->suboverflowed)
1938 {
1939 /*
1940 * Snapshot overflowed, so convert xid to top-level. This is safe
1941 * because we eliminated too-old XIDs above.
1942 */
1943 xid = SubTransGetTopmostTransaction(xid);
1944
1945 /*
1946 * If xid was indeed a subxact, we might now have an xid < xmin,
1947 * so recheck to avoid an array scan. No point in rechecking
1948 * xmax.
1949 */
1950 if (TransactionIdPrecedes(xid, snapshot->xmin))
1951 return false;
1952 }
1953
1954 /*
1955 * We now have either a top-level xid higher than xmin or an
1956 * indeterminate xid. We don't know whether it's top level or subxact
1957 * but it doesn't matter. If it's present, the xid is visible.
1958 */
1959 if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
1960 return true;
1961 }
1962
1963 return false;
1964 }
1965
1966 /* ResourceOwner callbacks */
1967
1968 static void
1969 ResOwnerReleaseSnapshot(Datum res)
1970 {
1971 UnregisterSnapshotNoOwner((Snapshot) DatumGetPointer(res));
1972 }