LCOV - code coverage report
Current view: top level - src/bin/pg_waldump - xlogdesc.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 78 142 54.9 %
Date: 2024-10-10 03:14:42 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * xlogdesc.c
       4             :  *    rmgr descriptor routines for access/transam/xlog.c
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/access/rmgrdesc/xlogdesc.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/transam.h"
      18             : #include "access/xlog.h"
      19             : #include "access/xlog_internal.h"
      20             : #include "catalog/pg_control.h"
      21             : #include "utils/guc.h"
      22             : #include "utils/timestamp.h"
      23             : 
      24             : /*
      25             :  * GUC support
      26             :  */
      27             : const struct config_enum_entry wal_level_options[] = {
      28             :     {"minimal", WAL_LEVEL_MINIMAL, false},
      29             :     {"replica", WAL_LEVEL_REPLICA, false},
      30             :     {"archive", WAL_LEVEL_REPLICA, true}, /* deprecated */
      31             :     {"hot_standby", WAL_LEVEL_REPLICA, true}, /* deprecated */
      32             :     {"logical", WAL_LEVEL_LOGICAL, false},
      33             :     {NULL, 0, false}
      34             : };
      35             : 
      36             : /*
      37             :  * Find a string representation for wal_level
      38             :  */
      39             : static const char *
      40          74 : get_wal_level_string(int wal_level)
      41             : {
      42             :     const struct config_enum_entry *entry;
      43          74 :     const char *wal_level_str = "?";
      44             : 
      45         238 :     for (entry = wal_level_options; entry->name; entry++)
      46             :     {
      47         238 :         if (entry->val == wal_level)
      48             :         {
      49          74 :             wal_level_str = entry->name;
      50          74 :             break;
      51             :         }
      52             :     }
      53             : 
      54          74 :     return wal_level_str;
      55             : }
      56             : 
      57             : void
      58       13924 : xlog_desc(StringInfo buf, XLogReaderState *record)
      59             : {
      60       13924 :     char       *rec = XLogRecGetData(record);
      61       13924 :     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
      62             : 
      63       13924 :     if (info == XLOG_CHECKPOINT_SHUTDOWN ||
      64             :         info == XLOG_CHECKPOINT_ONLINE)
      65          42 :     {
      66          42 :         CheckPoint *checkpoint = (CheckPoint *) rec;
      67             : 
      68          84 :         appendStringInfo(buf, "redo %X/%X; "
      69             :                          "tli %u; prev tli %u; fpw %s; wal_level %s; xid %u:%u; oid %u; multi %u; offset %u; "
      70             :                          "oldest xid %u in DB %u; oldest multi %u in DB %u; "
      71             :                          "oldest/newest commit timestamp xid: %u/%u; "
      72             :                          "oldest running xid %u; %s",
      73          42 :                          LSN_FORMAT_ARGS(checkpoint->redo),
      74             :                          checkpoint->ThisTimeLineID,
      75             :                          checkpoint->PrevTimeLineID,
      76          42 :                          checkpoint->fullPageWrites ? "true" : "false",
      77             :                          get_wal_level_string(checkpoint->wal_level),
      78          42 :                          EpochFromFullTransactionId(checkpoint->nextXid),
      79          42 :                          XidFromFullTransactionId(checkpoint->nextXid),
      80             :                          checkpoint->nextOid,
      81             :                          checkpoint->nextMulti,
      82             :                          checkpoint->nextMultiOffset,
      83             :                          checkpoint->oldestXid,
      84             :                          checkpoint->oldestXidDB,
      85             :                          checkpoint->oldestMulti,
      86             :                          checkpoint->oldestMultiDB,
      87             :                          checkpoint->oldestCommitTsXid,
      88             :                          checkpoint->newestCommitTsXid,
      89             :                          checkpoint->oldestActiveXid,
      90             :                          (info == XLOG_CHECKPOINT_SHUTDOWN) ? "shutdown" : "online");
      91             :     }
      92       13882 :     else if (info == XLOG_NEXTOID)
      93             :     {
      94             :         Oid         nextOid;
      95             : 
      96          24 :         memcpy(&nextOid, rec, sizeof(Oid));
      97          24 :         appendStringInfo(buf, "%u", nextOid);
      98             :     }
      99       13858 :     else if (info == XLOG_RESTORE_POINT)
     100             :     {
     101           0 :         xl_restore_point *xlrec = (xl_restore_point *) rec;
     102             : 
     103           0 :         appendStringInfoString(buf, xlrec->rp_name);
     104             :     }
     105       13858 :     else if (info == XLOG_FPI || info == XLOG_FPI_FOR_HINT)
     106             :     {
     107             :         /* no further information to print */
     108             :     }
     109          40 :     else if (info == XLOG_BACKUP_END)
     110             :     {
     111             :         XLogRecPtr  startpoint;
     112             : 
     113           0 :         memcpy(&startpoint, rec, sizeof(XLogRecPtr));
     114           0 :         appendStringInfo(buf, "%X/%X", LSN_FORMAT_ARGS(startpoint));
     115             :     }
     116          40 :     else if (info == XLOG_PARAMETER_CHANGE)
     117             :     {
     118             :         xl_parameter_change xlrec;
     119             :         const char *wal_level_str;
     120             : 
     121           4 :         memcpy(&xlrec, rec, sizeof(xl_parameter_change));
     122           4 :         wal_level_str = get_wal_level_string(xlrec.wal_level);
     123             : 
     124           8 :         appendStringInfo(buf, "max_connections=%d max_worker_processes=%d "
     125             :                          "max_wal_senders=%d max_prepared_xacts=%d "
     126             :                          "max_locks_per_xact=%d wal_level=%s "
     127             :                          "wal_log_hints=%s track_commit_timestamp=%s",
     128             :                          xlrec.MaxConnections,
     129             :                          xlrec.max_worker_processes,
     130             :                          xlrec.max_wal_senders,
     131             :                          xlrec.max_prepared_xacts,
     132             :                          xlrec.max_locks_per_xact,
     133             :                          wal_level_str,
     134           4 :                          xlrec.wal_log_hints ? "on" : "off",
     135           4 :                          xlrec.track_commit_timestamp ? "on" : "off");
     136             :     }
     137          36 :     else if (info == XLOG_FPW_CHANGE)
     138             :     {
     139             :         bool        fpw;
     140             : 
     141           0 :         memcpy(&fpw, rec, sizeof(bool));
     142           0 :         appendStringInfoString(buf, fpw ? "true" : "false");
     143             :     }
     144          36 :     else if (info == XLOG_END_OF_RECOVERY)
     145             :     {
     146             :         xl_end_of_recovery xlrec;
     147             : 
     148           0 :         memcpy(&xlrec, rec, sizeof(xl_end_of_recovery));
     149           0 :         appendStringInfo(buf, "tli %u; prev tli %u; time %s; wal_level %s",
     150             :                          xlrec.ThisTimeLineID, xlrec.PrevTimeLineID,
     151             :                          timestamptz_to_str(xlrec.end_time),
     152             :                          get_wal_level_string(xlrec.wal_level));
     153             :     }
     154          36 :     else if (info == XLOG_OVERWRITE_CONTRECORD)
     155             :     {
     156             :         xl_overwrite_contrecord xlrec;
     157             : 
     158           0 :         memcpy(&xlrec, rec, sizeof(xl_overwrite_contrecord));
     159           0 :         appendStringInfo(buf, "lsn %X/%X; time %s",
     160           0 :                          LSN_FORMAT_ARGS(xlrec.overwritten_lsn),
     161             :                          timestamptz_to_str(xlrec.overwrite_time));
     162             :     }
     163          36 :     else if (info == XLOG_CHECKPOINT_REDO)
     164             :     {
     165             :         int         wal_level;
     166             : 
     167          28 :         memcpy(&wal_level, rec, sizeof(int));
     168          28 :         appendStringInfo(buf, "wal_level %s", get_wal_level_string(wal_level));
     169             :     }
     170       13924 : }
     171             : 
     172             : const char *
     173       13932 : xlog_identify(uint8 info)
     174             : {
     175       13932 :     const char *id = NULL;
     176             : 
     177       13932 :     switch (info & ~XLR_INFO_MASK)
     178             :     {
     179          14 :         case XLOG_CHECKPOINT_SHUTDOWN:
     180          14 :             id = "CHECKPOINT_SHUTDOWN";
     181          14 :             break;
     182          30 :         case XLOG_CHECKPOINT_ONLINE:
     183          30 :             id = "CHECKPOINT_ONLINE";
     184          30 :             break;
     185           0 :         case XLOG_NOOP:
     186           0 :             id = "NOOP";
     187           0 :             break;
     188          26 :         case XLOG_NEXTOID:
     189          26 :             id = "NEXTOID";
     190          26 :             break;
     191           8 :         case XLOG_SWITCH:
     192           8 :             id = "SWITCH";
     193           8 :             break;
     194           0 :         case XLOG_BACKUP_END:
     195           0 :             id = "BACKUP_END";
     196           0 :             break;
     197           4 :         case XLOG_PARAMETER_CHANGE:
     198           4 :             id = "PARAMETER_CHANGE";
     199           4 :             break;
     200           0 :         case XLOG_RESTORE_POINT:
     201           0 :             id = "RESTORE_POINT";
     202           0 :             break;
     203           0 :         case XLOG_FPW_CHANGE:
     204           0 :             id = "FPW_CHANGE";
     205           0 :             break;
     206           0 :         case XLOG_END_OF_RECOVERY:
     207           0 :             id = "END_OF_RECOVERY";
     208           0 :             break;
     209           0 :         case XLOG_OVERWRITE_CONTRECORD:
     210           0 :             id = "OVERWRITE_CONTRECORD";
     211           0 :             break;
     212       13820 :         case XLOG_FPI:
     213       13820 :             id = "FPI";
     214       13820 :             break;
     215           0 :         case XLOG_FPI_FOR_HINT:
     216           0 :             id = "FPI_FOR_HINT";
     217           0 :             break;
     218          30 :         case XLOG_CHECKPOINT_REDO:
     219          30 :             id = "CHECKPOINT_REDO";
     220          30 :             break;
     221             :     }
     222             : 
     223       13932 :     return id;
     224             : }
     225             : 
     226             : /*
     227             :  * Returns a string giving information about all the blocks in an
     228             :  * XLogRecord.
     229             :  */
     230             : void
     231      510516 : XLogRecGetBlockRefInfo(XLogReaderState *record, bool pretty,
     232             :                        bool detailed_format, StringInfo buf,
     233             :                        uint32 *fpi_len)
     234             : {
     235             :     int         block_id;
     236             : 
     237             :     Assert(record != NULL);
     238             : 
     239      510516 :     if (detailed_format && pretty)
     240           0 :         appendStringInfoChar(buf, '\n');
     241             : 
     242     1076622 :     for (block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
     243             :     {
     244             :         RelFileLocator rlocator;
     245             :         ForkNumber  forknum;
     246             :         BlockNumber blk;
     247             : 
     248      566106 :         if (!XLogRecGetBlockTagExtended(record, block_id,
     249             :                                         &rlocator, &forknum, &blk, NULL))
     250         178 :             continue;
     251             : 
     252      565928 :         if (detailed_format)
     253             :         {
     254             :             /* Get block references in detailed format. */
     255             : 
     256           0 :             if (pretty)
     257           0 :                 appendStringInfoChar(buf, '\t');
     258           0 :             else if (block_id > 0)
     259           0 :                 appendStringInfoChar(buf, ' ');
     260             : 
     261           0 :             appendStringInfo(buf,
     262             :                              "blkref #%d: rel %u/%u/%u fork %s blk %u",
     263             :                              block_id,
     264             :                              rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
     265             :                              forkNames[forknum],
     266             :                              blk);
     267             : 
     268           0 :             if (XLogRecHasBlockImage(record, block_id))
     269             :             {
     270           0 :                 uint8       bimg_info = XLogRecGetBlock(record, block_id)->bimg_info;
     271             : 
     272             :                 /* Calculate the amount of FPI data in the record. */
     273           0 :                 if (fpi_len)
     274           0 :                     *fpi_len += XLogRecGetBlock(record, block_id)->bimg_len;
     275             : 
     276           0 :                 if (BKPIMAGE_COMPRESSED(bimg_info))
     277             :                 {
     278             :                     const char *method;
     279             : 
     280           0 :                     if ((bimg_info & BKPIMAGE_COMPRESS_PGLZ) != 0)
     281           0 :                         method = "pglz";
     282           0 :                     else if ((bimg_info & BKPIMAGE_COMPRESS_LZ4) != 0)
     283           0 :                         method = "lz4";
     284           0 :                     else if ((bimg_info & BKPIMAGE_COMPRESS_ZSTD) != 0)
     285           0 :                         method = "zstd";
     286             :                     else
     287           0 :                         method = "unknown";
     288             : 
     289           0 :                     appendStringInfo(buf,
     290             :                                      " (FPW%s); hole: offset: %u, length: %u, "
     291             :                                      "compression saved: %u, method: %s",
     292           0 :                                      XLogRecBlockImageApply(record, block_id) ?
     293             :                                      "" : " for WAL verification",
     294           0 :                                      XLogRecGetBlock(record, block_id)->hole_offset,
     295           0 :                                      XLogRecGetBlock(record, block_id)->hole_length,
     296             :                                      BLCKSZ -
     297           0 :                                      XLogRecGetBlock(record, block_id)->hole_length -
     298           0 :                                      XLogRecGetBlock(record, block_id)->bimg_len,
     299             :                                      method);
     300             :                 }
     301             :                 else
     302             :                 {
     303           0 :                     appendStringInfo(buf,
     304             :                                      " (FPW%s); hole: offset: %u, length: %u",
     305           0 :                                      XLogRecBlockImageApply(record, block_id) ?
     306             :                                      "" : " for WAL verification",
     307           0 :                                      XLogRecGetBlock(record, block_id)->hole_offset,
     308           0 :                                      XLogRecGetBlock(record, block_id)->hole_length);
     309             :                 }
     310             :             }
     311             : 
     312           0 :             if (pretty)
     313           0 :                 appendStringInfoChar(buf, '\n');
     314             :         }
     315             :         else
     316             :         {
     317             :             /* Get block references in short format. */
     318             : 
     319      565928 :             if (forknum != MAIN_FORKNUM)
     320             :             {
     321        5192 :                 appendStringInfo(buf,
     322             :                                  ", blkref #%d: rel %u/%u/%u fork %s blk %u",
     323             :                                  block_id,
     324             :                                  rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
     325             :                                  forkNames[forknum],
     326             :                                  blk);
     327             :             }
     328             :             else
     329             :             {
     330      560736 :                 appendStringInfo(buf,
     331             :                                  ", blkref #%d: rel %u/%u/%u blk %u",
     332             :                                  block_id,
     333             :                                  rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
     334             :                                  blk);
     335             :             }
     336             : 
     337      565928 :             if (XLogRecHasBlockImage(record, block_id))
     338             :             {
     339             :                 /* Calculate the amount of FPI data in the record. */
     340       16228 :                 if (fpi_len)
     341           0 :                     *fpi_len += XLogRecGetBlock(record, block_id)->bimg_len;
     342             : 
     343       16228 :                 if (XLogRecBlockImageApply(record, block_id))
     344       16228 :                     appendStringInfoString(buf, " FPW");
     345             :                 else
     346           0 :                     appendStringInfoString(buf, " FPW for WAL verification");
     347             :             }
     348             :         }
     349             :     }
     350             : 
     351      510516 :     if (!detailed_format && pretty)
     352      510516 :         appendStringInfoChar(buf, '\n');
     353      510516 : }

Generated by: LCOV version 1.14