src/bin/pg_controldata/pg_controldata.c

   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 usage(const char *progname)
  34 {
  35         printf(_("%s displays control information of a PostgreSQL database cluster.\n\n"), progname);
  36         printf(_("Usage:\n"));
  37         printf(_("  %s [OPTION] [DATADIR]\n"), progname);
  38         printf(_("\nOptions:\n"));
  39         printf(_(" [-D, --pgdata=]DATADIR  data directory\n"));
  40         printf(_("  -V, --version          output version information, then exit\n"));
  41         printf(_("  -?, --help             show this help, then exit\n"));
  42         printf(_("\nIf no data directory (DATADIR) is specified, "
  43                          "the environment variable PGDATA\nis used.\n\n"));
  44         printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
  45         printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
  46 }
  47
  48
  49 static const char *
  50 dbState(DBState state)
  51 {
  52         switch (state)
  53         {
  54                 case DB_STARTUP:
  55                         return _("starting up");
  56                 case DB_SHUTDOWNED:
  57                         return _("shut down");
  58                 case DB_SHUTDOWNED_IN_RECOVERY:
  59                         return _("shut down in recovery");
  60                 case DB_SHUTDOWNING:
  61                         return _("shutting down");
  62                 case DB_IN_CRASH_RECOVERY:
  63                         return _("in crash recovery");
  64                 case DB_IN_ARCHIVE_RECOVERY:
  65                         return _("in archive recovery");
  66                 case DB_IN_PRODUCTION:
  67                         return _("in production");
  68         }
  69         return _("unrecognized status code");
  70 }
  71
  72 static const char *
  73 wal_level_str(WalLevel wal_level)
  74 {
  75         switch (wal_level)
  76         {
  77                 case WAL_LEVEL_MINIMAL:
  78                         return "minimal";
  79                 case WAL_LEVEL_REPLICA:
  80                         return "replica";
  81                 case WAL_LEVEL_LOGICAL:
  82                         return "logical";
  83         }
  84         return _("unrecognized wal_level");
  85 }
  86
  87
  88 int
  89 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         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         const char *strftime_fmt = "%c";
 104         const char *progname;
 105         char            xlogfilename[MAXFNAMELEN];
 106         int                     c;
 107         int                     i;
 108         int                     WalSegSz;
 109
 110         pg_logging_init(argv[0]);
 111         set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_controldata"));
 112         progname = get_progname(argv[0]);
 113
 114         if (argc > 1)
 115         {
 116                 if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
 117                 {
 118                         usage(progname);
 119                         exit(0);
 120                 }
 121                 if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
 122                 {
 123                         puts("pg_controldata (PostgreSQL) " PG_VERSION);
 124                         exit(0);
 125                 }
 126         }
 127
 128         while ((c = getopt_long(argc, argv, "D:", long_options, NULL)) != -1)
 129         {
 130                 switch (c)
 131                 {
 132                         case 'D':
 133                                 DataDir = optarg;
 134                                 break;
 135
 136                         default:
 137                                 fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
 138                                 exit(1);
 139                 }
 140         }
 141
 142         if (DataDir == NULL)
 143         {
 144                 if (optind < argc)
 145                         DataDir = argv[optind++];
 146                 else
 147                         DataDir = getenv("PGDATA");
 148         }
 149
 150         /* Complain if any arguments remain */
 151         if (optind < argc)
 152         {
 153                 pg_log_error("too many command-line arguments (first is \"%s\")",
 154                                          argv[optind]);
 155                 fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
 156                                 progname);
 157                 exit(1);
 158         }
 159
 160         if (DataDir == NULL)
 161         {
 162                 pg_log_error("no data directory specified");
 163                 fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
 164                 exit(1);
 165         }
 166
 167         /* get a copy of the control file */
 168         ControlFile = get_controlfile(DataDir, &crc_ok);
 169         if (!crc_ok)
 170                 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         WalSegSz = ControlFile->xlog_seg_size;
 176
 177         if (!IsValidWalSegSize(WalSegSz))
 178         {
 179                 printf(_("WARNING: invalid WAL segment size\n"));
 180                 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         time_tmp = (time_t) ControlFile->time;
 200         strftime(pgctime_str, sizeof(pgctime_str), strftime_fmt,
 201                          localtime(&time_tmp));
 202         time_tmp = (time_t) ControlFile->checkPointCopy.time;
 203         strftime(ckpttime_str, sizeof(ckpttime_str), strftime_fmt,
 204                          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         if (WalSegSz != 0)
 214         {
 215                 XLogSegNo       segno;
 216
 217                 XLByteToSeg(ControlFile->checkPointCopy.redo, segno, WalSegSz);
 218                 XLogFileName(xlogfilename, ControlFile->checkPointCopy.ThisTimeLineID,
 219                                          segno, WalSegSz);
 220         }
 221         else
 222                 strcpy(xlogfilename, _("???"));
 223
 224         for (i = 0; i < MOCK_AUTH_NONCE_LEN; i++)
 225                 snprintf(&mock_auth_nonce_str[i * 2], 3, "%02x",
 226                                  (unsigned char) ControlFile->mock_authentication_nonce[i]);
 227
 228         printf(_("pg_control version number:            %u\n"),
 229                    ControlFile->pg_control_version);
 230         printf(_("Catalog version number:               %u\n"),
 231                    ControlFile->catalog_version_no);
 232         printf(_("Database system identifier:           %llu\n"),
 233                    (unsigned long long) ControlFile->system_identifier);
 234         printf(_("Database cluster state:               %s\n"),
 235                    dbState(ControlFile->state));
 236         printf(_("pg_control last modified:             %s\n"),
 237                    pgctime_str);
 238         printf(_("Latest checkpoint location:           %X/%X\n"),
 239                    LSN_FORMAT_ARGS(ControlFile->checkPoint));
 240         printf(_("Latest checkpoint's REDO location:    %X/%X\n"),
 241                    LSN_FORMAT_ARGS(ControlFile->checkPointCopy.redo));
 242         printf(_("Latest checkpoint's REDO WAL file:    %s\n"),
 243                    xlogfilename);
 244         printf(_("Latest checkpoint's TimeLineID:       %u\n"),
 245                    ControlFile->checkPointCopy.ThisTimeLineID);
 246         printf(_("Latest checkpoint's PrevTimeLineID:   %u\n"),
 247                    ControlFile->checkPointCopy.PrevTimeLineID);
 248         printf(_("Latest checkpoint's full_page_writes: %s\n"),
 249                    ControlFile->checkPointCopy.fullPageWrites ? _("on") : _("off"));
 250         printf(_("Latest checkpoint's NextXID:          %u:%u\n"),
 251                    EpochFromFullTransactionId(ControlFile->checkPointCopy.nextXid),
 252                    XidFromFullTransactionId(ControlFile->checkPointCopy.nextXid));
 253         printf(_("Latest checkpoint's NextOID:          %u\n"),
 254                    ControlFile->checkPointCopy.nextOid);
 255         printf(_("Latest checkpoint's NextMultiXactId:  %u\n"),
 256                    ControlFile->checkPointCopy.nextMulti);
 257         printf(_("Latest checkpoint's NextMultiOffset:  %u\n"),
 258                    ControlFile->checkPointCopy.nextMultiOffset);
 259         printf(_("Latest checkpoint's oldestXID:        %u\n"),
 260                    ControlFile->checkPointCopy.oldestXid);
 261         printf(_("Latest checkpoint's oldestXID's DB:   %u\n"),
 262                    ControlFile->checkPointCopy.oldestXidDB);
 263         printf(_("Latest checkpoint's oldestActiveXID:  %u\n"),
 264                    ControlFile->checkPointCopy.oldestActiveXid);
 265         printf(_("Latest checkpoint's oldestMultiXid:   %u\n"),
 266                    ControlFile->checkPointCopy.oldestMulti);
 267         printf(_("Latest checkpoint's oldestMulti's DB: %u\n"),
 268                    ControlFile->checkPointCopy.oldestMultiDB);
 269         printf(_("Latest checkpoint's oldestCommitTsXid:%u\n"),
 270                    ControlFile->checkPointCopy.oldestCommitTsXid);
 271         printf(_("Latest checkpoint's newestCommitTsXid:%u\n"),
 272                    ControlFile->checkPointCopy.newestCommitTsXid);
 273         printf(_("Time of latest checkpoint:            %s\n"),
 274                    ckpttime_str);
 275         printf(_("Fake LSN counter for unlogged rels:   %X/%X\n"),
 276                    LSN_FORMAT_ARGS(ControlFile->unloggedLSN));
 277         printf(_("Minimum recovery ending location:     %X/%X\n"),
 278                    LSN_FORMAT_ARGS(ControlFile->minRecoveryPoint));
 279         printf(_("Min recovery ending loc's timeline:   %u\n"),
 280                    ControlFile->minRecoveryPointTLI);
 281         printf(_("Backup start location:                %X/%X\n"),
 282                    LSN_FORMAT_ARGS(ControlFile->backupStartPoint));
 283         printf(_("Backup end location:                  %X/%X\n"),
 284                    LSN_FORMAT_ARGS(ControlFile->backupEndPoint));
 285         printf(_("End-of-backup record required:        %s\n"),
 286                    ControlFile->backupEndRequired ? _("yes") : _("no"));
 287         printf(_("wal_level setting:                    %s\n"),
 288                    wal_level_str(ControlFile->wal_level));
 289         printf(_("wal_log_hints setting:                %s\n"),
 290                    ControlFile->wal_log_hints ? _("on") : _("off"));
 291         printf(_("max_connections setting:              %d\n"),
 292                    ControlFile->MaxConnections);
 293         printf(_("max_worker_processes setting:         %d\n"),
 294                    ControlFile->max_worker_processes);
 295         printf(_("max_wal_senders setting:              %d\n"),
 296                    ControlFile->max_wal_senders);
 297         printf(_("max_prepared_xacts setting:           %d\n"),
 298                    ControlFile->max_prepared_xacts);
 299         printf(_("max_locks_per_xact setting:           %d\n"),
 300                    ControlFile->max_locks_per_xact);
 301         printf(_("track_commit_timestamp setting:       %s\n"),
 302                    ControlFile->track_commit_timestamp ? _("on") : _("off"));
 303         printf(_("Maximum data alignment:               %u\n"),
 304                    ControlFile->maxAlign);
 305         /* we don't print floatFormat since can't say much useful about it */
 306         printf(_("Database block size:                  %u\n"),
 307                    ControlFile->blcksz);
 308         printf(_("Blocks per segment of large relation: %u\n"),
 309                    ControlFile->relseg_size);
 310         printf(_("WAL block size:                       %u\n"),
 311                    ControlFile->xlog_blcksz);
 312         printf(_("Bytes per WAL segment:                %u\n"),
 313                    ControlFile->xlog_seg_size);
 314         printf(_("Maximum length of identifiers:        %u\n"),
 315                    ControlFile->nameDataLen);
 316         printf(_("Maximum columns in an index:          %u\n"),
 317                    ControlFile->indexMaxKeys);
 318         printf(_("Maximum size of a TOAST chunk:        %u\n"),
 319                    ControlFile->toast_max_chunk_size);
 320         printf(_("Size of a large-object chunk:         %u\n"),
 321                    ControlFile->loblksize);
 322         /* This is no longer configurable, but users may still expect to see it: */
 323         printf(_("Date/time type storage:               %s\n"),
 324                    _("64-bit integers"));
 325         printf(_("Float8 argument passing:              %s\n"),
 326                    (ControlFile->float8ByVal ? _("by value") : _("by reference")));
 327         printf(_("Data page checksum version:           %u\n"),
 328                    ControlFile->data_checksum_version);
 329         printf(_("Mock authentication nonce:            %s\n"),
 330                    mock_auth_nonce_str);
 331         return 0;
 332 }