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

Generated by: LCOV version 1.13