src/backend/access/transam/subtrans.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * subtrans.c
   4  *              PostgreSQL subtransaction-log manager
   5  *
   6  * The pg_subtrans manager is a pg_xact-like manager that stores the parent
   7  * transaction Id for each transaction.  It is a fundamental part of the
   8  * nested transactions implementation.  A main transaction has a parent
   9  * of InvalidTransactionId, and each subtransaction has its immediate parent.
  10  * The tree can easily be walked from child to parent, but not in the
  11  * opposite direction.
  12  *
  13  * This code is based on xact.c, but the robustness requirements
  14  * are completely different from pg_xact, because we only need to remember
  15  * pg_subtrans information for currently-open transactions.  Thus, there is
  16  * no need to preserve data over a crash and restart.
  17  *
  18  * There are no XLOG interactions since we do not care about preserving
  19  * data across crashes.  During database startup, we simply force the
  20  * currently-active page of SUBTRANS to zeroes.
  21  *
  22  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  23  * Portions Copyright (c) 1994, Regents of the University of California
  24  *
  25  * src/backend/access/transam/subtrans.c
  26  *
  27  *-------------------------------------------------------------------------
  28  */
  29 #include "postgres.h"
  30
  31 #include "access/slru.h"
  32 #include "access/subtrans.h"
  33 #include "access/transam.h"
  34 #include "pg_trace.h"
  35 #include "utils/snapmgr.h"
  36
  37
  38 /*
  39  * Defines for SubTrans page sizes.  A page is the same BLCKSZ as is used
  40  * everywhere else in Postgres.
  41  *
  42  * Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF,
  43  * SubTrans page numbering also wraps around at
  44  * 0xFFFFFFFF/SUBTRANS_XACTS_PER_PAGE, and segment numbering at
  45  * 0xFFFFFFFF/SUBTRANS_XACTS_PER_PAGE/SLRU_PAGES_PER_SEGMENT.  We need take no
  46  * explicit notice of that fact in this module, except when comparing segment
  47  * and page numbers in TruncateSUBTRANS (see SubTransPagePrecedes) and zeroing
  48  * them in StartupSUBTRANS.
  49  */
  50
  51 /* We need four bytes per xact */
  52 #define SUBTRANS_XACTS_PER_PAGE (BLCKSZ / sizeof(TransactionId))
  53
  54 #define TransactionIdToPage(xid) ((xid) / (TransactionId) SUBTRANS_XACTS_PER_PAGE)
  55 #define TransactionIdToEntry(xid) ((xid) % (TransactionId) SUBTRANS_XACTS_PER_PAGE)
  56
  57
  58 /*
  59  * Link to shared-memory data structures for SUBTRANS control
  60  */
  61 static SlruCtlData SubTransCtlData;
  62
  63 #define SubTransCtl  (&SubTransCtlData)
  64
  65
  66 static int      ZeroSUBTRANSPage(int pageno);
  67 static bool SubTransPagePrecedes(int page1, int page2);
  68
  69
  70 /*
  71  * Record the parent of a subtransaction in the subtrans log.
  72  */
  73 void
  74 SubTransSetParent(TransactionId xid, TransactionId parent)
  75 {
  76         int                     pageno = TransactionIdToPage(xid);
  77         int                     entryno = TransactionIdToEntry(xid);
  78         int                     slotno;
  79         TransactionId *ptr;
  80
  81         Assert(TransactionIdIsValid(parent));
  82         Assert(TransactionIdFollows(xid, parent));
  83
  84         LWLockAcquire(SubtransSLRULock, LW_EXCLUSIVE);
  85
  86         slotno = SimpleLruReadPage(SubTransCtl, pageno, true, xid);
  87         ptr = (TransactionId *) SubTransCtl->shared->page_buffer[slotno];
  88         ptr += entryno;
  89
  90         /*
  91          * It's possible we'll try to set the parent xid multiple times but we
  92          * shouldn't ever be changing the xid from one valid xid to another valid
  93          * xid, which would corrupt the data structure.
  94          */
  95         if (*ptr != parent)
  96         {
  97                 Assert(*ptr == InvalidTransactionId);
  98                 *ptr = parent;
  99                 SubTransCtl->shared->page_dirty[slotno] = true;
 100         }
 101
 102         LWLockRelease(SubtransSLRULock);
 103 }
 104
 105 /*
 106  * Interrogate the parent of a transaction in the subtrans log.
 107  */
 108 TransactionId
 109 SubTransGetParent(TransactionId xid)
 110 {
 111         int                     pageno = TransactionIdToPage(xid);
 112         int                     entryno = TransactionIdToEntry(xid);
 113         int                     slotno;
 114         TransactionId *ptr;
 115         TransactionId parent;
 116
 117         /* Can't ask about stuff that might not be around anymore */
 118         Assert(TransactionIdFollowsOrEquals(xid, TransactionXmin));
 119
 120         /* Bootstrap and frozen XIDs have no parent */
 121         if (!TransactionIdIsNormal(xid))
 122                 return InvalidTransactionId;
 123
 124         /* lock is acquired by SimpleLruReadPage_ReadOnly */
 125
 126         slotno = SimpleLruReadPage_ReadOnly(SubTransCtl, pageno, xid);
 127         ptr = (TransactionId *) SubTransCtl->shared->page_buffer[slotno];
 128         ptr += entryno;
 129
 130         parent = *ptr;
 131
 132         LWLockRelease(SubtransSLRULock);
 133
 134         return parent;
 135 }
 136
 137 /*
 138  * SubTransGetTopmostTransaction
 139  *
 140  * Returns the topmost transaction of the given transaction id.
 141  *
 142  * Because we cannot look back further than TransactionXmin, it is possible
 143  * that this function will lie and return an intermediate subtransaction ID
 144  * instead of the true topmost parent ID.  This is OK, because in practice
 145  * we only care about detecting whether the topmost parent is still running
 146  * or is part of a current snapshot's list of still-running transactions.
 147  * Therefore, any XID before TransactionXmin is as good as any other.
 148  */
 149 TransactionId
 150 SubTransGetTopmostTransaction(TransactionId xid)
 151 {
 152         TransactionId parentXid = xid,
 153                                 previousXid = xid;
 154
 155         /* Can't ask about stuff that might not be around anymore */
 156         Assert(TransactionIdFollowsOrEquals(xid, TransactionXmin));
 157
 158         while (TransactionIdIsValid(parentXid))
 159         {
 160                 previousXid = parentXid;
 161                 if (TransactionIdPrecedes(parentXid, TransactionXmin))
 162                         break;
 163                 parentXid = SubTransGetParent(parentXid);
 164
 165                 /*
 166                  * By convention the parent xid gets allocated first, so should always
 167                  * precede the child xid. Anything else points to a corrupted data
 168                  * structure that could lead to an infinite loop, so exit.
 169                  */
 170                 if (!TransactionIdPrecedes(parentXid, previousXid))
 171                         elog(ERROR, "pg_subtrans contains invalid entry: xid %u points to parent xid %u",
 172                                  previousXid, parentXid);
 173         }
 174
 175         Assert(TransactionIdIsValid(previousXid));
 176
 177         return previousXid;
 178 }
 179
 180
 181 /*
 182  * Initialization of shared memory for SUBTRANS
 183  */
 184 Size
 185 SUBTRANSShmemSize(void)
 186 {
 187         return SimpleLruShmemSize(NUM_SUBTRANS_BUFFERS, 0);
 188 }
 189
 190 void
 191 SUBTRANSShmemInit(void)
 192 {
 193         SubTransCtl->PagePrecedes = SubTransPagePrecedes;
 194         SimpleLruInit(SubTransCtl, "Subtrans", NUM_SUBTRANS_BUFFERS, 0,
 195                                   SubtransSLRULock, "pg_subtrans",
 196                                   LWTRANCHE_SUBTRANS_BUFFER, SYNC_HANDLER_NONE);
 197         SlruPagePrecedesUnitTests(SubTransCtl, SUBTRANS_XACTS_PER_PAGE);
 198 }
 199
 200 /*
 201  * This func must be called ONCE on system install.  It creates
 202  * the initial SUBTRANS segment.  (The SUBTRANS directory is assumed to
 203  * have been created by the initdb shell script, and SUBTRANSShmemInit
 204  * must have been called already.)
 205  *
 206  * Note: it's not really necessary to create the initial segment now,
 207  * since slru.c would create it on first write anyway.  But we may as well
 208  * do it to be sure the directory is set up correctly.
 209  */
 210 void
 211 BootStrapSUBTRANS(void)
 212 {
 213         int                     slotno;
 214
 215         LWLockAcquire(SubtransSLRULock, LW_EXCLUSIVE);
 216
 217         /* Create and zero the first page of the subtrans log */
 218         slotno = ZeroSUBTRANSPage(0);
 219
 220         /* Make sure it's written out */
 221         SimpleLruWritePage(SubTransCtl, slotno);
 222         Assert(!SubTransCtl->shared->page_dirty[slotno]);
 223
 224         LWLockRelease(SubtransSLRULock);
 225 }
 226
 227 /*
 228  * Initialize (or reinitialize) a page of SUBTRANS to zeroes.
 229  *
 230  * The page is not actually written, just set up in shared memory.
 231  * The slot number of the new page is returned.
 232  *
 233  * Control lock must be held at entry, and will be held at exit.
 234  */
 235 static int
 236 ZeroSUBTRANSPage(int pageno)
 237 {
 238         return SimpleLruZeroPage(SubTransCtl, pageno);
 239 }
 240
 241 /*
 242  * This must be called ONCE during postmaster or standalone-backend startup,
 243  * after StartupXLOG has initialized ShmemVariableCache->nextXid.
 244  *
 245  * oldestActiveXID is the oldest XID of any prepared transaction, or nextXid
 246  * if there are none.
 247  */
 248 void
 249 StartupSUBTRANS(TransactionId oldestActiveXID)
 250 {
 251         FullTransactionId nextXid;
 252         int                     startPage;
 253         int                     endPage;
 254
 255         /*
 256          * Since we don't expect pg_subtrans to be valid across crashes, we
 257          * initialize the currently-active page(s) to zeroes during startup.
 258          * Whenever we advance into a new page, ExtendSUBTRANS will likewise zero
 259          * the new page without regard to whatever was previously on disk.
 260          */
 261         LWLockAcquire(SubtransSLRULock, LW_EXCLUSIVE);
 262
 263         startPage = TransactionIdToPage(oldestActiveXID);
 264         nextXid = ShmemVariableCache->nextXid;
 265         endPage = TransactionIdToPage(XidFromFullTransactionId(nextXid));
 266
 267         while (startPage != endPage)
 268         {
 269                 (void) ZeroSUBTRANSPage(startPage);
 270                 startPage++;
 271                 /* must account for wraparound */
 272                 if (startPage > TransactionIdToPage(MaxTransactionId))
 273                         startPage = 0;
 274         }
 275         (void) ZeroSUBTRANSPage(startPage);
 276
 277         LWLockRelease(SubtransSLRULock);
 278 }
 279
 280 /*
 281  * Perform a checkpoint --- either during shutdown, or on-the-fly
 282  */
 283 void
 284 CheckPointSUBTRANS(void)
 285 {
 286         /*
 287          * Write dirty SUBTRANS pages to disk
 288          *
 289          * This is not actually necessary from a correctness point of view. We do
 290          * it merely to improve the odds that writing of dirty pages is done by
 291          * the checkpoint process and not by backends.
 292          */
 293         TRACE_POSTGRESQL_SUBTRANS_CHECKPOINT_START(true);
 294         SimpleLruWriteAll(SubTransCtl, true);
 295         TRACE_POSTGRESQL_SUBTRANS_CHECKPOINT_DONE(true);
 296 }
 297
 298
 299 /*
 300  * Make sure that SUBTRANS has room for a newly-allocated XID.
 301  *
 302  * NB: this is called while holding XidGenLock.  We want it to be very fast
 303  * most of the time; even when it's not so fast, no actual I/O need happen
 304  * unless we're forced to write out a dirty subtrans page to make room
 305  * in shared memory.
 306  */
 307 void
 308 ExtendSUBTRANS(TransactionId newestXact)
 309 {
 310         int                     pageno;
 311
 312         /*
 313          * No work except at first XID of a page.  But beware: just after
 314          * wraparound, the first XID of page zero is FirstNormalTransactionId.
 315          */
 316         if (TransactionIdToEntry(newestXact) != 0 &&
 317                 !TransactionIdEquals(newestXact, FirstNormalTransactionId))
 318                 return;
 319
 320         pageno = TransactionIdToPage(newestXact);
 321
 322         LWLockAcquire(SubtransSLRULock, LW_EXCLUSIVE);
 323
 324         /* Zero the page */
 325         ZeroSUBTRANSPage(pageno);
 326
 327         LWLockRelease(SubtransSLRULock);
 328 }
 329
 330
 331 /*
 332  * Remove all SUBTRANS segments before the one holding the passed transaction ID
 333  *
 334  * oldestXact is the oldest TransactionXmin of any running transaction.  This
 335  * is called only during checkpoint.
 336  */
 337 void
 338 TruncateSUBTRANS(TransactionId oldestXact)
 339 {
 340         int                     cutoffPage;
 341
 342         /*
 343          * The cutoff point is the start of the segment containing oldestXact. We
 344          * pass the *page* containing oldestXact to SimpleLruTruncate.  We step
 345          * back one transaction to avoid passing a cutoff page that hasn't been
 346          * created yet in the rare case that oldestXact would be the first item on
 347          * a page and oldestXact == next XID.  In that case, if we didn't subtract
 348          * one, we'd trigger SimpleLruTruncate's wraparound detection.
 349          */
 350         TransactionIdRetreat(oldestXact);
 351         cutoffPage = TransactionIdToPage(oldestXact);
 352
 353         SimpleLruTruncate(SubTransCtl, cutoffPage);
 354 }
 355
 356
 357 /*
 358  * Decide whether a SUBTRANS page number is "older" for truncation purposes.
 359  * Analogous to CLOGPagePrecedes().
 360  */
 361 static bool
 362 SubTransPagePrecedes(int page1, int page2)
 363 {
 364         TransactionId xid1;
 365         TransactionId xid2;
 366
 367         xid1 = ((TransactionId) page1) * SUBTRANS_XACTS_PER_PAGE;
 368         xid1 += FirstNormalTransactionId + 1;
 369         xid2 = ((TransactionId) page2) * SUBTRANS_XACTS_PER_PAGE;
 370         xid2 += FirstNormalTransactionId + 1;
 371
 372         return (TransactionIdPrecedes(xid1, xid2) &&
 373                         TransactionIdPrecedes(xid1, xid2 + SUBTRANS_XACTS_PER_PAGE - 1));
 374 }