LCOV - code coverage report
Current view: top level - src/bin/pg_controldata - pg_controldata.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 130 144 90.3 %
Date: 2024-04-25 00:11:39 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * pg_controldata
       3             :  *
       4             :  * reads the data from $PGDATA/global/pg_control
       5             :  *
       6             :  * copyright (c) Oliver Elphick <olly@lfix.co.uk>, 2001;
       7             :  * license: BSD
       8             :  *
       9             :  * src/bin/pg_controldata/pg_controldata.c
      10             :  */
      11             : 
      12             : /*
      13             :  * We have to use postgres.h not postgres_fe.h here, because there's so much
      14             :  * backend-only stuff in the XLOG include files we need.  But we need a
      15             :  * frontend-ish environment otherwise.  Hence this ugly hack.
      16             :  */
      17             : #define FRONTEND 1
      18             : 
      19             : #include "postgres.h"
      20             : 
      21             : #include <time.h>
      22             : 
      23             : #include "access/transam.h"
      24             : #include "access/xlog.h"
      25             : #include "access/xlog_internal.h"
      26             : #include "catalog/pg_control.h"
      27             : #include "common/controldata_utils.h"
      28             : #include "common/logging.h"
      29             : #include "getopt_long.h"
      30             : #include "pg_getopt.h"
      31             : 
      32             : static void
      33           2 : usage(const char *progname)
      34             : {
      35           2 :     printf(_("%s displays control information of a PostgreSQL database cluster.\n\n"), progname);
      36           2 :     printf(_("Usage:\n"));
      37           2 :     printf(_("  %s [OPTION] [DATADIR]\n"), progname);
      38           2 :     printf(_("\nOptions:\n"));
      39           2 :     printf(_(" [-D, --pgdata=]DATADIR  data directory\n"));
      40           2 :     printf(_("  -V, --version          output version information, then exit\n"));
      41           2 :     printf(_("  -?, --help             show this help, then exit\n"));
      42           2 :     printf(_("\nIf no data directory (DATADIR) is specified, "
      43             :              "the environment variable PGDATA\nis used.\n\n"));
      44           2 :     printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
      45           2 :     printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
      46           2 : }
      47             : 
      48             : 
      49             : static const char *
      50          60 : dbState(DBState state)
      51             : {
      52          60 :     switch (state)
      53             :     {
      54           2 :         case DB_STARTUP:
      55           2 :             return _("starting up");
      56          52 :         case DB_SHUTDOWNED:
      57          52 :             return _("shut down");
      58           4 :         case DB_SHUTDOWNED_IN_RECOVERY:
      59           4 :             return _("shut down in recovery");
      60           0 :         case DB_SHUTDOWNING:
      61           0 :             return _("shutting down");
      62           0 :         case DB_IN_CRASH_RECOVERY:
      63           0 :             return _("in crash recovery");
      64           0 :         case DB_IN_ARCHIVE_RECOVERY:
      65           0 :             return _("in archive recovery");
      66           2 :         case DB_IN_PRODUCTION:
      67           2 :             return _("in production");
      68             :     }
      69           0 :     return _("unrecognized status code");
      70             : }
      71             : 
      72             : static const char *
      73          60 : wal_level_str(WalLevel wal_level)
      74             : {
      75          60 :     switch (wal_level)
      76             :     {
      77          22 :         case WAL_LEVEL_MINIMAL:
      78          22 :             return "minimal";
      79          26 :         case WAL_LEVEL_REPLICA:
      80          26 :             return "replica";
      81          12 :         case WAL_LEVEL_LOGICAL:
      82          12 :             return "logical";
      83             :     }
      84           0 :     return _("unrecognized wal_level");
      85             : }
      86             : 
      87             : 
      88             : int
      89         106 : main(int argc, char *argv[])
      90             : {
      91             :     static struct option long_options[] = {
      92             :         {"pgdata", required_argument, NULL, 'D'},
      93             :         {NULL, 0, NULL, 0}
      94             :     };
      95             : 
      96             :     ControlFileData *ControlFile;
      97             :     bool        crc_ok;
      98         106 :     char       *DataDir = NULL;
      99             :     time_t      time_tmp;
     100             :     char        pgctime_str[128];
     101             :     char        ckpttime_str[128];
     102             :     char        mock_auth_nonce_str[MOCK_AUTH_NONCE_LEN * 2 + 1];
     103         106 :     const char *strftime_fmt = "%c";
     104             :     const char *progname;
     105             :     char        xlogfilename[MAXFNAMELEN];
     106             :     int         c;
     107             :     int         i;
     108             :     int         WalSegSz;
     109             : 
     110         106 :     pg_logging_init(argv[0]);
     111         106 :     set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_controldata"));
     112         106 :     progname = get_progname(argv[0]);
     113             : 
     114         106 :     if (argc > 1)
     115             :     {
     116         104 :         if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
     117             :         {
     118           2 :             usage(progname);
     119           2 :             exit(0);
     120             :         }
     121         102 :         if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
     122             :         {
     123          38 :             puts("pg_controldata (PostgreSQL) " PG_VERSION);
     124          38 :             exit(0);
     125             :         }
     126             :     }
     127             : 
     128          66 :     while ((c = getopt_long(argc, argv, "D:", long_options, NULL)) != -1)
     129             :     {
     130           2 :         switch (c)
     131             :         {
     132           0 :             case 'D':
     133           0 :                 DataDir = optarg;
     134           0 :                 break;
     135             : 
     136           2 :             default:
     137             :                 /* getopt_long already emitted a complaint */
     138           2 :                 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     139           2 :                 exit(1);
     140             :         }
     141             :     }
     142             : 
     143          64 :     if (DataDir == NULL)
     144             :     {
     145          64 :         if (optind < argc)
     146          62 :             DataDir = argv[optind++];
     147             :         else
     148           2 :             DataDir = getenv("PGDATA");
     149             :     }
     150             : 
     151             :     /* Complain if any arguments remain */
     152          64 :     if (optind < argc)
     153             :     {
     154           0 :         pg_log_error("too many command-line arguments (first is \"%s\")",
     155             :                      argv[optind]);
     156           0 :         pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     157           0 :         exit(1);
     158             :     }
     159             : 
     160          64 :     if (DataDir == NULL)
     161             :     {
     162           2 :         pg_log_error("no data directory specified");
     163           2 :         pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     164           2 :         exit(1);
     165             :     }
     166             : 
     167             :     /* get a copy of the control file */
     168          62 :     ControlFile = get_controlfile(DataDir, &crc_ok);
     169          60 :     if (!crc_ok)
     170             :     {
     171           2 :         pg_log_warning("calculated CRC checksum does not match value stored in control file");
     172           2 :         pg_log_warning_detail("Either the control file is corrupt, or it has a different layout than this program "
     173             :                               "is expecting.  The results below are untrustworthy.");
     174             :     }
     175             : 
     176             :     /* set wal segment size */
     177          60 :     WalSegSz = ControlFile->xlog_seg_size;
     178             : 
     179          60 :     if (!IsValidWalSegSize(WalSegSz))
     180             :     {
     181           2 :         pg_log_warning(ngettext("invalid WAL segment size in control file (%d byte)",
     182             :                                 "invalid WAL segment size in control file (%d bytes)",
     183             :                                 WalSegSz),
     184             :                        WalSegSz);
     185           2 :         pg_log_warning_detail("The WAL segment size must be a power of two between 1 MB and 1 GB.");
     186           2 :         pg_log_warning_detail("The file is corrupt and the results below are untrustworthy.");
     187             :     }
     188             : 
     189             :     /*
     190             :      * This slightly-chintzy coding will work as long as the control file
     191             :      * timestamps are within the range of time_t; that should be the case in
     192             :      * all foreseeable circumstances, so we don't bother importing the
     193             :      * backend's timezone library into pg_controldata.
     194             :      *
     195             :      * Use variable for format to suppress overly-anal-retentive gcc warning
     196             :      * about %c
     197             :      */
     198          60 :     time_tmp = (time_t) ControlFile->time;
     199          60 :     strftime(pgctime_str, sizeof(pgctime_str), strftime_fmt,
     200          60 :              localtime(&time_tmp));
     201          60 :     time_tmp = (time_t) ControlFile->checkPointCopy.time;
     202          60 :     strftime(ckpttime_str, sizeof(ckpttime_str), strftime_fmt,
     203          60 :              localtime(&time_tmp));
     204             : 
     205             :     /*
     206             :      * Calculate name of the WAL file containing the latest checkpoint's REDO
     207             :      * start point.
     208             :      *
     209             :      * A corrupted control file could report a WAL segment size of 0, and to
     210             :      * guard against division by zero, we need to treat that specially.
     211             :      */
     212          60 :     if (WalSegSz != 0)
     213             :     {
     214             :         XLogSegNo   segno;
     215             : 
     216          58 :         XLByteToSeg(ControlFile->checkPointCopy.redo, segno, WalSegSz);
     217          58 :         XLogFileName(xlogfilename, ControlFile->checkPointCopy.ThisTimeLineID,
     218             :                      segno, WalSegSz);
     219             :     }
     220             :     else
     221           2 :         strcpy(xlogfilename, _("???"));
     222             : 
     223        1980 :     for (i = 0; i < MOCK_AUTH_NONCE_LEN; i++)
     224        1920 :         snprintf(&mock_auth_nonce_str[i * 2], 3, "%02x",
     225        1920 :                  (unsigned char) ControlFile->mock_authentication_nonce[i]);
     226             : 
     227          60 :     printf(_("pg_control version number:            %u\n"),
     228             :            ControlFile->pg_control_version);
     229          60 :     printf(_("Catalog version number:               %u\n"),
     230             :            ControlFile->catalog_version_no);
     231          60 :     printf(_("Database system identifier:           %llu\n"),
     232             :            (unsigned long long) ControlFile->system_identifier);
     233          60 :     printf(_("Database cluster state:               %s\n"),
     234             :            dbState(ControlFile->state));
     235          60 :     printf(_("pg_control last modified:             %s\n"),
     236             :            pgctime_str);
     237          60 :     printf(_("Latest checkpoint location:           %X/%X\n"),
     238             :            LSN_FORMAT_ARGS(ControlFile->checkPoint));
     239          60 :     printf(_("Latest checkpoint's REDO location:    %X/%X\n"),
     240             :            LSN_FORMAT_ARGS(ControlFile->checkPointCopy.redo));
     241          60 :     printf(_("Latest checkpoint's REDO WAL file:    %s\n"),
     242             :            xlogfilename);
     243          60 :     printf(_("Latest checkpoint's TimeLineID:       %u\n"),
     244             :            ControlFile->checkPointCopy.ThisTimeLineID);
     245          60 :     printf(_("Latest checkpoint's PrevTimeLineID:   %u\n"),
     246             :            ControlFile->checkPointCopy.PrevTimeLineID);
     247          60 :     printf(_("Latest checkpoint's full_page_writes: %s\n"),
     248             :            ControlFile->checkPointCopy.fullPageWrites ? _("on") : _("off"));
     249          60 :     printf(_("Latest checkpoint's NextXID:          %u:%u\n"),
     250             :            EpochFromFullTransactionId(ControlFile->checkPointCopy.nextXid),
     251             :            XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid));
     252          60 :     printf(_("Latest checkpoint's NextOID:          %u\n"),
     253             :            ControlFile->checkPointCopy.nextOid);
     254          60 :     printf(_("Latest checkpoint's NextMultiXactId:  %u\n"),
     255             :            ControlFile->checkPointCopy.nextMulti);
     256          60 :     printf(_("Latest checkpoint's NextMultiOffset:  %u\n"),
     257             :            ControlFile->checkPointCopy.nextMultiOffset);
     258          60 :     printf(_("Latest checkpoint's oldestXID:        %u\n"),
     259             :            ControlFile->checkPointCopy.oldestXid);
     260          60 :     printf(_("Latest checkpoint's oldestXID's DB:   %u\n"),
     261             :            ControlFile->checkPointCopy.oldestXidDB);
     262          60 :     printf(_("Latest checkpoint's oldestActiveXID:  %u\n"),
     263             :            ControlFile->checkPointCopy.oldestActiveXid);
     264          60 :     printf(_("Latest checkpoint's oldestMultiXid:   %u\n"),
     265             :            ControlFile->checkPointCopy.oldestMulti);
     266          60 :     printf(_("Latest checkpoint's oldestMulti's DB: %u\n"),
     267             :            ControlFile->checkPointCopy.oldestMultiDB);
     268          60 :     printf(_("Latest checkpoint's oldestCommitTsXid:%u\n"),
     269             :            ControlFile->checkPointCopy.oldestCommitTsXid);
     270          60 :     printf(_("Latest checkpoint's newestCommitTsXid:%u\n"),
     271             :            ControlFile->checkPointCopy.newestCommitTsXid);
     272          60 :     printf(_("Time of latest checkpoint:            %s\n"),
     273             :            ckpttime_str);
     274          60 :     printf(_("Fake LSN counter for unlogged rels:   %X/%X\n"),
     275             :            LSN_FORMAT_ARGS(ControlFile->unloggedLSN));
     276          60 :     printf(_("Minimum recovery ending location:     %X/%X\n"),
     277             :            LSN_FORMAT_ARGS(ControlFile->minRecoveryPoint));
     278          60 :     printf(_("Min recovery ending loc's timeline:   %u\n"),
     279             :            ControlFile->minRecoveryPointTLI);
     280          60 :     printf(_("Backup start location:                %X/%X\n"),
     281             :            LSN_FORMAT_ARGS(ControlFile->backupStartPoint));
     282          60 :     printf(_("Backup end location:                  %X/%X\n"),
     283             :            LSN_FORMAT_ARGS(ControlFile->backupEndPoint));
     284          60 :     printf(_("End-of-backup record required:        %s\n"),
     285             :            ControlFile->backupEndRequired ? _("yes") : _("no"));
     286          60 :     printf(_("wal_level setting:                    %s\n"),
     287             :            wal_level_str(ControlFile->wal_level));
     288          60 :     printf(_("wal_log_hints setting:                %s\n"),
     289             :            ControlFile->wal_log_hints ? _("on") : _("off"));
     290          60 :     printf(_("max_connections setting:              %d\n"),
     291             :            ControlFile->MaxConnections);
     292          60 :     printf(_("max_worker_processes setting:         %d\n"),
     293             :            ControlFile->max_worker_processes);
     294          60 :     printf(_("max_wal_senders setting:              %d\n"),
     295             :            ControlFile->max_wal_senders);
     296          60 :     printf(_("max_prepared_xacts setting:           %d\n"),
     297             :            ControlFile->max_prepared_xacts);
     298          60 :     printf(_("max_locks_per_xact setting:           %d\n"),
     299             :            ControlFile->max_locks_per_xact);
     300          60 :     printf(_("track_commit_timestamp setting:       %s\n"),
     301             :            ControlFile->track_commit_timestamp ? _("on") : _("off"));
     302          60 :     printf(_("Maximum data alignment:               %u\n"),
     303             :            ControlFile->maxAlign);
     304             :     /* we don't print floatFormat since can't say much useful about it */
     305          60 :     printf(_("Database block size:                  %u\n"),
     306             :            ControlFile->blcksz);
     307          60 :     printf(_("Blocks per segment of large relation: %u\n"),
     308             :            ControlFile->relseg_size);
     309          60 :     printf(_("WAL block size:                       %u\n"),
     310             :            ControlFile->xlog_blcksz);
     311          60 :     printf(_("Bytes per WAL segment:                %u\n"),
     312             :            ControlFile->xlog_seg_size);
     313          60 :     printf(_("Maximum length of identifiers:        %u\n"),
     314             :            ControlFile->nameDataLen);
     315          60 :     printf(_("Maximum columns in an index:          %u\n"),
     316             :            ControlFile->indexMaxKeys);
     317          60 :     printf(_("Maximum size of a TOAST chunk:        %u\n"),
     318             :            ControlFile->toast_max_chunk_size);
     319          60 :     printf(_("Size of a large-object chunk:         %u\n"),
     320             :            ControlFile->loblksize);
     321             :     /* This is no longer configurable, but users may still expect to see it: */
     322          60 :     printf(_("Date/time type storage:               %s\n"),
     323             :            _("64-bit integers"));
     324          60 :     printf(_("Float8 argument passing:              %s\n"),
     325             :            (ControlFile->float8ByVal ? _("by value") : _("by reference")));
     326          60 :     printf(_("Data page checksum version:           %u\n"),
     327             :            ControlFile->data_checksum_version);
     328          60 :     printf(_("Mock authentication nonce:            %s\n"),
     329             :            mock_auth_nonce_str);
     330          60 :     return 0;
     331             : }

Generated by: LCOV version 1.14