LCOV - code coverage report
Current view: top level - src/bin/pg_verifybackup - pg_verifybackup.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 326 360 90.6 %
Date: 2024-09-08 22:11:48 Functions: 19 19 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * pg_verifybackup.c
       4             :  *    Verify a backup against a backup manifest.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * src/bin/pg_verifybackup/pg_verifybackup.c
      10             :  *
      11             :  *-------------------------------------------------------------------------
      12             :  */
      13             : 
      14             : #include "postgres_fe.h"
      15             : 
      16             : #include <dirent.h>
      17             : #include <fcntl.h>
      18             : #include <sys/stat.h>
      19             : #include <time.h>
      20             : 
      21             : #include "common/logging.h"
      22             : #include "common/parse_manifest.h"
      23             : #include "fe_utils/simple_list.h"
      24             : #include "getopt_long.h"
      25             : #include "pg_verifybackup.h"
      26             : #include "pgtime.h"
      27             : 
      28             : /*
      29             :  * For efficiency, we'd like our hash table containing information about the
      30             :  * manifest to start out with approximately the correct number of entries.
      31             :  * There's no way to know the exact number of entries without reading the whole
      32             :  * file, but we can get an estimate by dividing the file size by the estimated
      33             :  * number of bytes per line.
      34             :  *
      35             :  * This could be off by about a factor of two in either direction, because the
      36             :  * checksum algorithm has a big impact on the line lengths; e.g. a SHA512
      37             :  * checksum is 128 hex bytes, whereas a CRC-32C value is only 8, and there
      38             :  * might be no checksum at all.
      39             :  */
      40             : #define ESTIMATED_BYTES_PER_MANIFEST_LINE   100
      41             : 
      42             : /*
      43             :  * How many bytes should we try to read from a file at once?
      44             :  */
      45             : #define READ_CHUNK_SIZE             (128 * 1024)
      46             : 
      47             : static manifest_data *parse_manifest_file(char *manifest_path);
      48             : static void verifybackup_version_cb(JsonManifestParseContext *context,
      49             :                                     int manifest_version);
      50             : static void verifybackup_system_identifier(JsonManifestParseContext *context,
      51             :                                            uint64 manifest_system_identifier);
      52             : static void verifybackup_per_file_cb(JsonManifestParseContext *context,
      53             :                                      const char *pathname, size_t size,
      54             :                                      pg_checksum_type checksum_type,
      55             :                                      int checksum_length,
      56             :                                      uint8 *checksum_payload);
      57             : static void verifybackup_per_wal_range_cb(JsonManifestParseContext *context,
      58             :                                           TimeLineID tli,
      59             :                                           XLogRecPtr start_lsn,
      60             :                                           XLogRecPtr end_lsn);
      61             : static void report_manifest_error(JsonManifestParseContext *context,
      62             :                                   const char *fmt,...)
      63             :             pg_attribute_printf(2, 3) pg_attribute_noreturn();
      64             : 
      65             : static void verify_backup_directory(verifier_context *context,
      66             :                                     char *relpath, char *fullpath);
      67             : static void verify_backup_file(verifier_context *context,
      68             :                                char *relpath, char *fullpath);
      69             : static void verify_control_file(const char *controlpath,
      70             :                                 uint64 manifest_system_identifier);
      71             : static void report_extra_backup_files(verifier_context *context);
      72             : static void verify_backup_checksums(verifier_context *context);
      73             : static void verify_file_checksum(verifier_context *context,
      74             :                                  manifest_file *m, char *fullpath,
      75             :                                  uint8 *buffer);
      76             : static void parse_required_wal(verifier_context *context,
      77             :                                char *pg_waldump_path,
      78             :                                char *wal_directory);
      79             : 
      80             : static void progress_report(bool finished);
      81             : static void usage(void);
      82             : 
      83             : static const char *progname;
      84             : 
      85             : /* is progress reporting enabled? */
      86             : static bool show_progress = false;
      87             : 
      88             : /* Progress indicators */
      89             : static uint64 total_size = 0;
      90             : static uint64 done_size = 0;
      91             : 
      92             : /*
      93             :  * Main entry point.
      94             :  */
      95             : int
      96         198 : main(int argc, char **argv)
      97             : {
      98             :     static struct option long_options[] = {
      99             :         {"exit-on-error", no_argument, NULL, 'e'},
     100             :         {"ignore", required_argument, NULL, 'i'},
     101             :         {"manifest-path", required_argument, NULL, 'm'},
     102             :         {"no-parse-wal", no_argument, NULL, 'n'},
     103             :         {"progress", no_argument, NULL, 'P'},
     104             :         {"quiet", no_argument, NULL, 'q'},
     105             :         {"skip-checksums", no_argument, NULL, 's'},
     106             :         {"wal-directory", required_argument, NULL, 'w'},
     107             :         {NULL, 0, NULL, 0}
     108             :     };
     109             : 
     110             :     int         c;
     111             :     verifier_context context;
     112         198 :     char       *manifest_path = NULL;
     113         198 :     bool        no_parse_wal = false;
     114         198 :     bool        quiet = false;
     115         198 :     char       *wal_directory = NULL;
     116         198 :     char       *pg_waldump_path = NULL;
     117             : 
     118         198 :     pg_logging_init(argv[0]);
     119         198 :     set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_verifybackup"));
     120         198 :     progname = get_progname(argv[0]);
     121             : 
     122         198 :     memset(&context, 0, sizeof(context));
     123             : 
     124         198 :     if (argc > 1)
     125             :     {
     126         196 :         if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
     127             :         {
     128           2 :             usage();
     129           2 :             exit(0);
     130             :         }
     131         194 :         if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
     132             :         {
     133           2 :             puts("pg_verifybackup (PostgreSQL) " PG_VERSION);
     134           2 :             exit(0);
     135             :         }
     136             :     }
     137             : 
     138             :     /*
     139             :      * Skip certain files in the toplevel directory.
     140             :      *
     141             :      * Ignore the backup_manifest file, because it's not included in the
     142             :      * backup manifest.
     143             :      *
     144             :      * Ignore the pg_wal directory, because those files are not included in
     145             :      * the backup manifest either, since they are fetched separately from the
     146             :      * backup itself, and verified via a separate mechanism.
     147             :      *
     148             :      * Ignore postgresql.auto.conf, recovery.signal, and standby.signal,
     149             :      * because we expect that those files may sometimes be created or changed
     150             :      * as part of the backup process. For example, pg_basebackup -R will
     151             :      * modify postgresql.auto.conf and create standby.signal.
     152             :      */
     153         194 :     simple_string_list_append(&context.ignore_list, "backup_manifest");
     154         194 :     simple_string_list_append(&context.ignore_list, "pg_wal");
     155         194 :     simple_string_list_append(&context.ignore_list, "postgresql.auto.conf");
     156         194 :     simple_string_list_append(&context.ignore_list, "recovery.signal");
     157         194 :     simple_string_list_append(&context.ignore_list, "standby.signal");
     158             : 
     159         280 :     while ((c = getopt_long(argc, argv, "ei:m:nPqsw:", long_options, NULL)) != -1)
     160             :     {
     161          88 :         switch (c)
     162             :         {
     163          32 :             case 'e':
     164          32 :                 context.exit_on_error = true;
     165          32 :                 break;
     166           8 :             case 'i':
     167             :                 {
     168           8 :                     char       *arg = pstrdup(optarg);
     169             : 
     170           8 :                     canonicalize_path(arg);
     171           8 :                     simple_string_list_append(&context.ignore_list, arg);
     172           8 :                     break;
     173             :                 }
     174          16 :             case 'm':
     175          16 :                 manifest_path = pstrdup(optarg);
     176          16 :                 canonicalize_path(manifest_path);
     177          16 :                 break;
     178          14 :             case 'n':
     179          14 :                 no_parse_wal = true;
     180          14 :                 break;
     181           4 :             case 'P':
     182           4 :                 show_progress = true;
     183           4 :                 break;
     184           6 :             case 'q':
     185           6 :                 quiet = true;
     186           6 :                 break;
     187           4 :             case 's':
     188           4 :                 context.skip_checksums = true;
     189           4 :                 break;
     190           2 :             case 'w':
     191           2 :                 wal_directory = pstrdup(optarg);
     192           2 :                 canonicalize_path(wal_directory);
     193           2 :                 break;
     194           2 :             default:
     195             :                 /* getopt_long already emitted a complaint */
     196           2 :                 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     197           2 :                 exit(1);
     198             :         }
     199             :     }
     200             : 
     201             :     /* Get backup directory name */
     202         192 :     if (optind >= argc)
     203             :     {
     204           2 :         pg_log_error("no backup directory specified");
     205           2 :         pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     206           2 :         exit(1);
     207             :     }
     208         190 :     context.backup_directory = pstrdup(argv[optind++]);
     209         190 :     canonicalize_path(context.backup_directory);
     210             : 
     211             :     /* Complain if any arguments remain */
     212         190 :     if (optind < argc)
     213             :     {
     214           2 :         pg_log_error("too many command-line arguments (first is \"%s\")",
     215             :                      argv[optind]);
     216           2 :         pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     217           2 :         exit(1);
     218             :     }
     219             : 
     220             :     /* Complain if the specified arguments conflict */
     221         188 :     if (show_progress && quiet)
     222           2 :         pg_fatal("cannot specify both %s and %s",
     223             :                  "-P/--progress", "-q/--quiet");
     224             : 
     225             :     /* Unless --no-parse-wal was specified, we will need pg_waldump. */
     226         186 :     if (!no_parse_wal)
     227             :     {
     228             :         int         ret;
     229             : 
     230         172 :         pg_waldump_path = pg_malloc(MAXPGPATH);
     231         172 :         ret = find_other_exec(argv[0], "pg_waldump",
     232             :                               "pg_waldump (PostgreSQL) " PG_VERSION "\n",
     233             :                               pg_waldump_path);
     234         172 :         if (ret < 0)
     235             :         {
     236             :             char        full_path[MAXPGPATH];
     237             : 
     238           0 :             if (find_my_exec(argv[0], full_path) < 0)
     239           0 :                 strlcpy(full_path, progname, sizeof(full_path));
     240             : 
     241           0 :             if (ret == -1)
     242           0 :                 pg_fatal("program \"%s\" is needed by %s but was not found in the same directory as \"%s\"",
     243             :                          "pg_waldump", "pg_verifybackup", full_path);
     244             :             else
     245           0 :                 pg_fatal("program \"%s\" was found by \"%s\" but was not the same version as %s",
     246             :                          "pg_waldump", full_path, "pg_verifybackup");
     247             :         }
     248             :     }
     249             : 
     250             :     /* By default, look for the manifest in the backup directory. */
     251         186 :     if (manifest_path == NULL)
     252         170 :         manifest_path = psprintf("%s/backup_manifest",
     253             :                                  context.backup_directory);
     254             : 
     255             :     /* By default, look for the WAL in the backup directory, too. */
     256         186 :     if (wal_directory == NULL)
     257         184 :         wal_directory = psprintf("%s/pg_wal", context.backup_directory);
     258             : 
     259             :     /*
     260             :      * Try to read the manifest. We treat any errors encountered while parsing
     261             :      * the manifest as fatal; there doesn't seem to be much point in trying to
     262             :      * verify the backup directory against a corrupted manifest.
     263             :      */
     264         186 :     context.manifest = parse_manifest_file(manifest_path);
     265             : 
     266             :     /*
     267             :      * Now scan the files in the backup directory. At this stage, we verify
     268             :      * that every file on disk is present in the manifest and that the sizes
     269             :      * match. We also set the "matched" flag on every manifest entry that
     270             :      * corresponds to a file on disk.
     271             :      */
     272         118 :     verify_backup_directory(&context, NULL, context.backup_directory);
     273             : 
     274             :     /*
     275             :      * The "matched" flag should now be set on every entry in the hash table.
     276             :      * Any entries for which the bit is not set are files mentioned in the
     277             :      * manifest that don't exist on disk.
     278             :      */
     279         114 :     report_extra_backup_files(&context);
     280             : 
     281             :     /*
     282             :      * Now do the expensive work of verifying file checksums, unless we were
     283             :      * told to skip it.
     284             :      */
     285         112 :     if (!context.skip_checksums)
     286         108 :         verify_backup_checksums(&context);
     287             : 
     288             :     /*
     289             :      * Try to parse the required ranges of WAL records, unless we were told
     290             :      * not to do so.
     291             :      */
     292         112 :     if (!no_parse_wal)
     293          98 :         parse_required_wal(&context, pg_waldump_path, wal_directory);
     294             : 
     295             :     /*
     296             :      * If everything looks OK, tell the user this, unless we were asked to
     297             :      * work quietly.
     298             :      */
     299         112 :     if (!context.saw_any_error && !quiet)
     300          80 :         printf(_("backup successfully verified\n"));
     301             : 
     302         112 :     return context.saw_any_error ? 1 : 0;
     303             : }
     304             : 
     305             : /*
     306             :  * Parse a manifest file and return a data structure describing the contents.
     307             :  */
     308             : static manifest_data *
     309         186 : parse_manifest_file(char *manifest_path)
     310             : {
     311             :     int         fd;
     312             :     struct stat statbuf;
     313             :     off_t       estimate;
     314             :     uint32      initial_size;
     315             :     manifest_files_hash *ht;
     316             :     char       *buffer;
     317             :     int         rc;
     318             :     JsonManifestParseContext context;
     319             :     manifest_data *result;
     320             : 
     321         186 :     int         chunk_size = READ_CHUNK_SIZE;
     322             : 
     323             :     /* Open the manifest file. */
     324         186 :     if ((fd = open(manifest_path, O_RDONLY | PG_BINARY, 0)) < 0)
     325           6 :         report_fatal_error("could not open file \"%s\": %m", manifest_path);
     326             : 
     327             :     /* Figure out how big the manifest is. */
     328         180 :     if (fstat(fd, &statbuf) != 0)
     329           0 :         report_fatal_error("could not stat file \"%s\": %m", manifest_path);
     330             : 
     331             :     /* Guess how large to make the hash table based on the manifest size. */
     332         180 :     estimate = statbuf.st_size / ESTIMATED_BYTES_PER_MANIFEST_LINE;
     333         180 :     initial_size = Min(PG_UINT32_MAX, Max(estimate, 256));
     334             : 
     335             :     /* Create the hash table. */
     336         180 :     ht = manifest_files_create(initial_size, NULL);
     337             : 
     338         180 :     result = pg_malloc0(sizeof(manifest_data));
     339         180 :     result->files = ht;
     340         180 :     context.private_data = result;
     341         180 :     context.version_cb = verifybackup_version_cb;
     342         180 :     context.system_identifier_cb = verifybackup_system_identifier;
     343         180 :     context.per_file_cb = verifybackup_per_file_cb;
     344         180 :     context.per_wal_range_cb = verifybackup_per_wal_range_cb;
     345         180 :     context.error_cb = report_manifest_error;
     346             : 
     347             :     /*
     348             :      * Parse the file, in chunks if necessary.
     349             :      */
     350         180 :     if (statbuf.st_size <= chunk_size)
     351             :     {
     352          64 :         buffer = pg_malloc(statbuf.st_size);
     353          64 :         rc = read(fd, buffer, statbuf.st_size);
     354          64 :         if (rc != statbuf.st_size)
     355             :         {
     356           0 :             if (rc < 0)
     357           0 :                 pg_fatal("could not read file \"%s\": %m", manifest_path);
     358             :             else
     359           0 :                 pg_fatal("could not read file \"%s\": read %d of %lld",
     360             :                          manifest_path, rc, (long long int) statbuf.st_size);
     361             :         }
     362             : 
     363             :         /* Close the manifest file. */
     364          64 :         close(fd);
     365             : 
     366             :         /* Parse the manifest. */
     367          64 :         json_parse_manifest(&context, buffer, statbuf.st_size);
     368             :     }
     369             :     else
     370             :     {
     371         116 :         int         bytes_left = statbuf.st_size;
     372             :         JsonManifestParseIncrementalState *inc_state;
     373             : 
     374         116 :         inc_state = json_parse_manifest_incremental_init(&context);
     375             : 
     376         116 :         buffer = pg_malloc(chunk_size + 1);
     377             : 
     378         346 :         while (bytes_left > 0)
     379             :         {
     380         232 :             int         bytes_to_read = chunk_size;
     381             : 
     382             :             /*
     383             :              * Make sure that the last chunk is sufficiently large. (i.e. at
     384             :              * least half the chunk size) so that it will contain fully the
     385             :              * piece at the end with the checksum.
     386             :              */
     387         232 :             if (bytes_left < chunk_size)
     388         116 :                 bytes_to_read = bytes_left;
     389         116 :             else if (bytes_left < 2 * chunk_size)
     390         116 :                 bytes_to_read = bytes_left / 2;
     391         232 :             rc = read(fd, buffer, bytes_to_read);
     392         232 :             if (rc != bytes_to_read)
     393             :             {
     394           0 :                 if (rc < 0)
     395           0 :                     pg_fatal("could not read file \"%s\": %m", manifest_path);
     396             :                 else
     397           0 :                     pg_fatal("could not read file \"%s\": read %lld of %lld",
     398             :                              manifest_path,
     399             :                              (long long int) (statbuf.st_size + rc - bytes_left),
     400             :                              (long long int) statbuf.st_size);
     401             :             }
     402         232 :             bytes_left -= rc;
     403         232 :             json_parse_manifest_incremental_chunk(inc_state, buffer, rc,
     404             :                                                   bytes_left == 0);
     405             :         }
     406             : 
     407             :         /* Release the incremental state memory */
     408         114 :         json_parse_manifest_incremental_shutdown(inc_state);
     409             : 
     410         114 :         close(fd);
     411             :     }
     412             : 
     413             :     /* Done with the buffer. */
     414         118 :     pfree(buffer);
     415             : 
     416         118 :     return result;
     417             : }
     418             : 
     419             : /*
     420             :  * Report an error while parsing the manifest.
     421             :  *
     422             :  * We consider all such errors to be fatal errors. The manifest parser
     423             :  * expects this function not to return.
     424             :  */
     425             : static void
     426          60 : report_manifest_error(JsonManifestParseContext *context, const char *fmt,...)
     427             : {
     428             :     va_list     ap;
     429             : 
     430          60 :     va_start(ap, fmt);
     431          60 :     pg_log_generic_v(PG_LOG_ERROR, PG_LOG_PRIMARY, gettext(fmt), ap);
     432          60 :     va_end(ap);
     433             : 
     434          60 :     exit(1);
     435             : }
     436             : 
     437             : /*
     438             :  * Record details extracted from the backup manifest.
     439             :  */
     440             : static void
     441         168 : verifybackup_version_cb(JsonManifestParseContext *context,
     442             :                         int manifest_version)
     443             : {
     444         168 :     manifest_data *manifest = context->private_data;
     445             : 
     446             :     /* Validation will be at the later stage */
     447         168 :     manifest->version = manifest_version;
     448         168 : }
     449             : 
     450             : /*
     451             :  * Record details extracted from the backup manifest.
     452             :  */
     453             : static void
     454         120 : verifybackup_system_identifier(JsonManifestParseContext *context,
     455             :                                uint64 manifest_system_identifier)
     456             : {
     457         120 :     manifest_data *manifest = context->private_data;
     458             : 
     459             :     /* Validation will be at the later stage */
     460         120 :     manifest->system_identifier = manifest_system_identifier;
     461         120 : }
     462             : 
     463             : /*
     464             :  * Record details extracted from the backup manifest for one file.
     465             :  */
     466             : static void
     467      116070 : verifybackup_per_file_cb(JsonManifestParseContext *context,
     468             :                          const char *pathname, size_t size,
     469             :                          pg_checksum_type checksum_type,
     470             :                          int checksum_length, uint8 *checksum_payload)
     471             : {
     472      116070 :     manifest_data *manifest = context->private_data;
     473      116070 :     manifest_files_hash *ht = manifest->files;
     474             :     manifest_file *m;
     475             :     bool        found;
     476             : 
     477             :     /* Make a new entry in the hash table for this file. */
     478      116070 :     m = manifest_files_insert(ht, pathname, &found);
     479      116070 :     if (found)
     480           2 :         report_fatal_error("duplicate path name in backup manifest: \"%s\"",
     481             :                            pathname);
     482             : 
     483             :     /* Initialize the entry. */
     484      116068 :     m->size = size;
     485      116068 :     m->checksum_type = checksum_type;
     486      116068 :     m->checksum_length = checksum_length;
     487      116068 :     m->checksum_payload = checksum_payload;
     488      116068 :     m->matched = false;
     489      116068 :     m->bad = false;
     490      116068 : }
     491             : 
     492             : /*
     493             :  * Record details extracted from the backup manifest for one WAL range.
     494             :  */
     495             : static void
     496         122 : verifybackup_per_wal_range_cb(JsonManifestParseContext *context,
     497             :                               TimeLineID tli,
     498             :                               XLogRecPtr start_lsn, XLogRecPtr end_lsn)
     499             : {
     500         122 :     manifest_data *manifest = context->private_data;
     501             :     manifest_wal_range *range;
     502             : 
     503             :     /* Allocate and initialize a struct describing this WAL range. */
     504         122 :     range = palloc(sizeof(manifest_wal_range));
     505         122 :     range->tli = tli;
     506         122 :     range->start_lsn = start_lsn;
     507         122 :     range->end_lsn = end_lsn;
     508         122 :     range->prev = manifest->last_wal_range;
     509         122 :     range->next = NULL;
     510             : 
     511             :     /* Add it to the end of the list. */
     512         122 :     if (manifest->first_wal_range == NULL)
     513         122 :         manifest->first_wal_range = range;
     514             :     else
     515           0 :         manifest->last_wal_range->next = range;
     516         122 :     manifest->last_wal_range = range;
     517         122 : }
     518             : 
     519             : /*
     520             :  * Verify one directory.
     521             :  *
     522             :  * 'relpath' is NULL if we are to verify the top-level backup directory,
     523             :  * and otherwise the relative path to the directory that is to be verified.
     524             :  *
     525             :  * 'fullpath' is the backup directory with 'relpath' appended; i.e. the actual
     526             :  * filesystem path at which it can be found.
     527             :  */
     528             : static void
     529        2876 : verify_backup_directory(verifier_context *context, char *relpath,
     530             :                         char *fullpath)
     531             : {
     532             :     DIR        *dir;
     533             :     struct dirent *dirent;
     534             : 
     535        2876 :     dir = opendir(fullpath);
     536        2876 :     if (dir == NULL)
     537             :     {
     538             :         /*
     539             :          * If even the toplevel backup directory cannot be found, treat this
     540             :          * as a fatal error.
     541             :          */
     542           4 :         if (relpath == NULL)
     543           2 :             report_fatal_error("could not open directory \"%s\": %m", fullpath);
     544             : 
     545             :         /*
     546             :          * Otherwise, treat this as a non-fatal error, but ignore any further
     547             :          * errors related to this path and anything beneath it.
     548             :          */
     549           2 :         report_backup_error(context,
     550             :                             "could not open directory \"%s\": %m", fullpath);
     551           2 :         simple_string_list_append(&context->ignore_list, relpath);
     552             : 
     553           2 :         return;
     554             :     }
     555             : 
     556      120102 :     while (errno = 0, (dirent = readdir(dir)) != NULL)
     557             :     {
     558      117234 :         char       *filename = dirent->d_name;
     559      117234 :         char       *newfullpath = psprintf("%s/%s", fullpath, filename);
     560             :         char       *newrelpath;
     561             : 
     562             :         /* Skip "." and ".." */
     563      117234 :         if (filename[0] == '.' && (filename[1] == '\0'
     564        2868 :                                    || strcmp(filename, "..") == 0))
     565        5738 :             continue;
     566             : 
     567      111496 :         if (relpath == NULL)
     568        2748 :             newrelpath = pstrdup(filename);
     569             :         else
     570      108748 :             newrelpath = psprintf("%s/%s", relpath, filename);
     571             : 
     572      111496 :         if (!should_ignore_relpath(context, newrelpath))
     573      111166 :             verify_backup_file(context, newrelpath, newfullpath);
     574             : 
     575      111492 :         pfree(newfullpath);
     576      111492 :         pfree(newrelpath);
     577             :     }
     578             : 
     579        2868 :     if (closedir(dir))
     580             :     {
     581           0 :         report_backup_error(context,
     582             :                             "could not close directory \"%s\": %m", fullpath);
     583           0 :         return;
     584             :     }
     585             : }
     586             : 
     587             : /*
     588             :  * Verify one file (which might actually be a directory or a symlink).
     589             :  *
     590             :  * The arguments to this function have the same meaning as the arguments to
     591             :  * verify_backup_directory.
     592             :  */
     593             : static void
     594      111166 : verify_backup_file(verifier_context *context, char *relpath, char *fullpath)
     595             : {
     596             :     struct stat sb;
     597             :     manifest_file *m;
     598             : 
     599      111166 :     if (stat(fullpath, &sb) != 0)
     600             :     {
     601           6 :         report_backup_error(context,
     602             :                             "could not stat file or directory \"%s\": %m",
     603             :                             relpath);
     604             : 
     605             :         /*
     606             :          * Suppress further errors related to this path name and, if it's a
     607             :          * directory, anything underneath it.
     608             :          */
     609           6 :         simple_string_list_append(&context->ignore_list, relpath);
     610             : 
     611        2766 :         return;
     612             :     }
     613             : 
     614             :     /* If it's a directory, just recurse. */
     615      111160 :     if (S_ISDIR(sb.st_mode))
     616             :     {
     617        2758 :         verify_backup_directory(context, relpath, fullpath);
     618        2756 :         return;
     619             :     }
     620             : 
     621             :     /* If it's not a directory, it should be a plain file. */
     622      108402 :     if (!S_ISREG(sb.st_mode))
     623             :     {
     624           0 :         report_backup_error(context,
     625             :                             "\"%s\" is not a file or directory",
     626             :                             relpath);
     627           0 :         return;
     628             :     }
     629             : 
     630             :     /* Check whether there's an entry in the manifest hash. */
     631      108402 :     m = manifest_files_lookup(context->manifest->files, relpath);
     632      108402 :     if (m == NULL)
     633             :     {
     634           4 :         report_backup_error(context,
     635             :                             "\"%s\" is present on disk but not in the manifest",
     636             :                             relpath);
     637           4 :         return;
     638             :     }
     639             : 
     640             :     /* Flag this entry as having been encountered in the filesystem. */
     641      108398 :     m->matched = true;
     642             : 
     643             :     /* Check that the size matches. */
     644      108398 :     if (m->size != sb.st_size)
     645             :     {
     646           4 :         report_backup_error(context,
     647             :                             "\"%s\" has size %lld on disk but size %zu in the manifest",
     648           4 :                             relpath, (long long int) sb.st_size, m->size);
     649           4 :         m->bad = true;
     650             :     }
     651             : 
     652             :     /*
     653             :      * Validate the manifest system identifier, not available in manifest
     654             :      * version 1.
     655             :      */
     656      108398 :     if (context->manifest->version != 1 &&
     657      108398 :         strcmp(relpath, "global/pg_control") == 0)
     658         116 :         verify_control_file(fullpath, context->manifest->system_identifier);
     659             : 
     660             :     /* Update statistics for progress report, if necessary */
     661      108396 :     if (show_progress && !context->skip_checksums &&
     662        1928 :         should_verify_checksum(m))
     663        1928 :         total_size += m->size;
     664             : 
     665             :     /*
     666             :      * We don't verify checksums at this stage. We first finish verifying that
     667             :      * we have the expected set of files with the expected sizes, and only
     668             :      * afterwards verify the checksums. That's because computing checksums may
     669             :      * take a while, and we'd like to report more obvious problems quickly.
     670             :      */
     671             : }
     672             : 
     673             : /*
     674             :  * Sanity check control file and validate system identifier against manifest
     675             :  * system identifier.
     676             :  */
     677             : static void
     678         116 : verify_control_file(const char *controlpath, uint64 manifest_system_identifier)
     679             : {
     680             :     ControlFileData *control_file;
     681             :     bool        crc_ok;
     682             : 
     683         116 :     pg_log_debug("reading \"%s\"", controlpath);
     684         116 :     control_file = get_controlfile_by_exact_path(controlpath, &crc_ok);
     685             : 
     686             :     /* Control file contents not meaningful if CRC is bad. */
     687         116 :     if (!crc_ok)
     688           0 :         report_fatal_error("%s: CRC is incorrect", controlpath);
     689             : 
     690             :     /* Can't interpret control file if not current version. */
     691         116 :     if (control_file->pg_control_version != PG_CONTROL_VERSION)
     692           0 :         report_fatal_error("%s: unexpected control file version",
     693             :                            controlpath);
     694             : 
     695             :     /* System identifiers should match. */
     696         116 :     if (manifest_system_identifier != control_file->system_identifier)
     697           2 :         report_fatal_error("%s: manifest system identifier is %llu, but control file has %llu",
     698             :                            controlpath,
     699             :                            (unsigned long long) manifest_system_identifier,
     700           2 :                            (unsigned long long) control_file->system_identifier);
     701             : 
     702             :     /* Release memory. */
     703         114 :     pfree(control_file);
     704         114 : }
     705             : 
     706             : /*
     707             :  * Scan the hash table for entries where the 'matched' flag is not set; report
     708             :  * that such files are present in the manifest but not on disk.
     709             :  */
     710             : static void
     711         114 : report_extra_backup_files(verifier_context *context)
     712             : {
     713         114 :     manifest_data *manifest = context->manifest;
     714             :     manifest_files_iterator it;
     715             :     manifest_file *m;
     716             : 
     717         114 :     manifest_files_start_iterate(manifest->files, &it);
     718      109200 :     while ((m = manifest_files_iterate(manifest->files, &it)) != NULL)
     719      109088 :         if (!m->matched && !should_ignore_relpath(context, m->pathname))
     720          10 :             report_backup_error(context,
     721             :                                 "\"%s\" is present in the manifest but not on disk",
     722             :                                 m->pathname);
     723         112 : }
     724             : 
     725             : /*
     726             :  * Verify checksums for hash table entries that are otherwise unproblematic.
     727             :  * If we've already reported some problem related to a hash table entry, or
     728             :  * if it has no checksum, just skip it.
     729             :  */
     730             : static void
     731         108 : verify_backup_checksums(verifier_context *context)
     732             : {
     733         108 :     manifest_data *manifest = context->manifest;
     734             :     manifest_files_iterator it;
     735             :     manifest_file *m;
     736             :     uint8      *buffer;
     737             : 
     738         108 :     progress_report(false);
     739             : 
     740         108 :     buffer = pg_malloc(READ_CHUNK_SIZE * sizeof(uint8));
     741             : 
     742         108 :     manifest_files_start_iterate(manifest->files, &it);
     743      104578 :     while ((m = manifest_files_iterate(manifest->files, &it)) != NULL)
     744             :     {
     745      104470 :         if (should_verify_checksum(m) &&
     746       98670 :             !should_ignore_relpath(context, m->pathname))
     747             :         {
     748             :             char       *fullpath;
     749             : 
     750             :             /* Compute the full pathname to the target file. */
     751       98670 :             fullpath = psprintf("%s/%s", context->backup_directory,
     752             :                                 m->pathname);
     753             : 
     754             :             /* Do the actual checksum verification. */
     755       98670 :             verify_file_checksum(context, m, fullpath, buffer);
     756             : 
     757             :             /* Avoid leaking memory. */
     758       98670 :             pfree(fullpath);
     759             :         }
     760             :     }
     761             : 
     762         108 :     pfree(buffer);
     763             : 
     764         108 :     progress_report(true);
     765         108 : }
     766             : 
     767             : /*
     768             :  * Verify the checksum of a single file.
     769             :  */
     770             : static void
     771       98670 : verify_file_checksum(verifier_context *context, manifest_file *m,
     772             :                      char *fullpath, uint8 *buffer)
     773             : {
     774             :     pg_checksum_context checksum_ctx;
     775       98670 :     const char *relpath = m->pathname;
     776             :     int         fd;
     777             :     int         rc;
     778       98670 :     size_t      bytes_read = 0;
     779             :     uint8       checksumbuf[PG_CHECKSUM_MAX_LENGTH];
     780             :     int         checksumlen;
     781             : 
     782             :     /* Open the target file. */
     783       98670 :     if ((fd = open(fullpath, O_RDONLY | PG_BINARY, 0)) < 0)
     784             :     {
     785           2 :         report_backup_error(context, "could not open file \"%s\": %m",
     786             :                             relpath);
     787           2 :         return;
     788             :     }
     789             : 
     790             :     /* Initialize checksum context. */
     791       98668 :     if (pg_checksum_init(&checksum_ctx, m->checksum_type) < 0)
     792             :     {
     793           0 :         report_backup_error(context, "could not initialize checksum of file \"%s\"",
     794             :                             relpath);
     795           0 :         close(fd);
     796           0 :         return;
     797             :     }
     798             : 
     799             :     /* Read the file chunk by chunk, updating the checksum as we go. */
     800      185108 :     while ((rc = read(fd, buffer, READ_CHUNK_SIZE)) > 0)
     801             :     {
     802       86440 :         bytes_read += rc;
     803       86440 :         if (pg_checksum_update(&checksum_ctx, buffer, rc) < 0)
     804             :         {
     805           0 :             report_backup_error(context, "could not update checksum of file \"%s\"",
     806             :                                 relpath);
     807           0 :             close(fd);
     808           0 :             return;
     809             :         }
     810             : 
     811             :         /* Report progress */
     812       86440 :         done_size += rc;
     813       86440 :         progress_report(false);
     814             :     }
     815       98668 :     if (rc < 0)
     816           0 :         report_backup_error(context, "could not read file \"%s\": %m",
     817             :                             relpath);
     818             : 
     819             :     /* Close the file. */
     820       98668 :     if (close(fd) != 0)
     821             :     {
     822           0 :         report_backup_error(context, "could not close file \"%s\": %m",
     823             :                             relpath);
     824           0 :         return;
     825             :     }
     826             : 
     827             :     /* If we didn't manage to read the whole file, bail out now. */
     828       98668 :     if (rc < 0)
     829           0 :         return;
     830             : 
     831             :     /*
     832             :      * Double-check that we read the expected number of bytes from the file.
     833             :      * Normally, a file size mismatch would be caught in verify_backup_file
     834             :      * and this check would never be reached, but this provides additional
     835             :      * safety and clarity in the event of concurrent modifications or
     836             :      * filesystem misbehavior.
     837             :      */
     838       98668 :     if (bytes_read != m->size)
     839             :     {
     840           0 :         report_backup_error(context,
     841             :                             "file \"%s\" should contain %zu bytes, but read %zu bytes",
     842             :                             relpath, m->size, bytes_read);
     843           0 :         return;
     844             :     }
     845             : 
     846             :     /* Get the final checksum. */
     847       98668 :     checksumlen = pg_checksum_final(&checksum_ctx, checksumbuf);
     848       98668 :     if (checksumlen < 0)
     849             :     {
     850           0 :         report_backup_error(context,
     851             :                             "could not finalize checksum of file \"%s\"",
     852             :                             relpath);
     853           0 :         return;
     854             :     }
     855             : 
     856             :     /* And check it against the manifest. */
     857       98668 :     if (checksumlen != m->checksum_length)
     858           0 :         report_backup_error(context,
     859             :                             "file \"%s\" has checksum of length %d, but expected %d",
     860             :                             relpath, m->checksum_length, checksumlen);
     861       98668 :     else if (memcmp(checksumbuf, m->checksum_payload, checksumlen) != 0)
     862           6 :         report_backup_error(context,
     863             :                             "checksum mismatch for file \"%s\"",
     864             :                             relpath);
     865             : }
     866             : 
     867             : /*
     868             :  * Attempt to parse the WAL files required to restore from backup using
     869             :  * pg_waldump.
     870             :  */
     871             : static void
     872          98 : parse_required_wal(verifier_context *context, char *pg_waldump_path,
     873             :                    char *wal_directory)
     874             : {
     875          98 :     manifest_data *manifest = context->manifest;
     876          98 :     manifest_wal_range *this_wal_range = manifest->first_wal_range;
     877             : 
     878         196 :     while (this_wal_range != NULL)
     879             :     {
     880             :         char       *pg_waldump_cmd;
     881             : 
     882          98 :         pg_waldump_cmd = psprintf("\"%s\" --quiet --path=\"%s\" --timeline=%u --start=%X/%X --end=%X/%X\n",
     883             :                                   pg_waldump_path, wal_directory, this_wal_range->tli,
     884          98 :                                   LSN_FORMAT_ARGS(this_wal_range->start_lsn),
     885          98 :                                   LSN_FORMAT_ARGS(this_wal_range->end_lsn));
     886          98 :         fflush(NULL);
     887          98 :         if (system(pg_waldump_cmd) != 0)
     888           4 :             report_backup_error(context,
     889             :                                 "WAL parsing failed for timeline %u",
     890             :                                 this_wal_range->tli);
     891             : 
     892          98 :         this_wal_range = this_wal_range->next;
     893             :     }
     894          98 : }
     895             : 
     896             : /*
     897             :  * Report a problem with the backup.
     898             :  *
     899             :  * Update the context to indicate that we saw an error, and exit if the
     900             :  * context says we should.
     901             :  */
     902             : void
     903          38 : report_backup_error(verifier_context *context, const char *pg_restrict fmt,...)
     904             : {
     905             :     va_list     ap;
     906             : 
     907          38 :     va_start(ap, fmt);
     908          38 :     pg_log_generic_v(PG_LOG_ERROR, PG_LOG_PRIMARY, gettext(fmt), ap);
     909          38 :     va_end(ap);
     910             : 
     911          38 :     context->saw_any_error = true;
     912          38 :     if (context->exit_on_error)
     913           2 :         exit(1);
     914          36 : }
     915             : 
     916             : /*
     917             :  * Report a fatal error and exit
     918             :  */
     919             : void
     920          12 : report_fatal_error(const char *pg_restrict fmt,...)
     921             : {
     922             :     va_list     ap;
     923             : 
     924          12 :     va_start(ap, fmt);
     925          12 :     pg_log_generic_v(PG_LOG_ERROR, PG_LOG_PRIMARY, gettext(fmt), ap);
     926          12 :     va_end(ap);
     927             : 
     928          12 :     exit(1);
     929             : }
     930             : 
     931             : /*
     932             :  * Is the specified relative path, or some prefix of it, listed in the set
     933             :  * of paths to ignore?
     934             :  *
     935             :  * Note that by "prefix" we mean a parent directory; for this purpose,
     936             :  * "aa/bb" is not a prefix of "aa/bbb", but it is a prefix of "aa/bb/cc".
     937             :  */
     938             : bool
     939      212108 : should_ignore_relpath(verifier_context *context, const char *relpath)
     940             : {
     941             :     SimpleStringListCell *cell;
     942             : 
     943     1292550 :     for (cell = context->ignore_list.head; cell != NULL; cell = cell->next)
     944             :     {
     945     1082704 :         const char *r = relpath;
     946     1082704 :         char       *v = cell->val;
     947             : 
     948     1515794 :         while (*v != '\0' && *r == *v)
     949      433090 :             ++r, ++v;
     950             : 
     951     1082704 :         if (*v == '\0' && (*r == '\0' || *r == '/'))
     952        2262 :             return true;
     953             :     }
     954             : 
     955      209846 :     return false;
     956             : }
     957             : 
     958             : /*
     959             :  * Print a progress report based on the global variables.
     960             :  *
     961             :  * Progress report is written at maximum once per second, unless the finished
     962             :  * parameter is set to true.
     963             :  *
     964             :  * If finished is set to true, this is the last progress report. The cursor
     965             :  * is moved to the next line.
     966             :  */
     967             : static void
     968       86656 : progress_report(bool finished)
     969             : {
     970             :     static pg_time_t last_progress_report = 0;
     971             :     pg_time_t   now;
     972       86656 :     int         percent_size = 0;
     973             :     char        totalsize_str[32];
     974             :     char        donesize_str[32];
     975             : 
     976       86656 :     if (!show_progress)
     977       86652 :         return;
     978             : 
     979        1698 :     now = time(NULL);
     980        1698 :     if (now == last_progress_report && !finished)
     981        1694 :         return;                 /* Max once per second */
     982             : 
     983           4 :     last_progress_report = now;
     984           4 :     percent_size = total_size ? (int) ((done_size * 100 / total_size)) : 0;
     985             : 
     986           4 :     snprintf(totalsize_str, sizeof(totalsize_str), UINT64_FORMAT,
     987             :              total_size / 1024);
     988           4 :     snprintf(donesize_str, sizeof(donesize_str), UINT64_FORMAT,
     989             :              done_size / 1024);
     990             : 
     991           4 :     fprintf(stderr,
     992           4 :             _("%*s/%s kB (%d%%) verified"),
     993           4 :             (int) strlen(totalsize_str),
     994             :             donesize_str, totalsize_str, percent_size);
     995             : 
     996             :     /*
     997             :      * Stay on the same line if reporting to a terminal and we're not done
     998             :      * yet.
     999             :      */
    1000           4 :     fputc((!finished && isatty(fileno(stderr))) ? '\r' : '\n', stderr);
    1001             : }
    1002             : 
    1003             : /*
    1004             :  * Print out usage information and exit.
    1005             :  */
    1006             : static void
    1007           2 : usage(void)
    1008             : {
    1009           2 :     printf(_("%s verifies a backup against the backup manifest.\n\n"), progname);
    1010           2 :     printf(_("Usage:\n  %s [OPTION]... BACKUPDIR\n\n"), progname);
    1011           2 :     printf(_("Options:\n"));
    1012           2 :     printf(_("  -e, --exit-on-error         exit immediately on error\n"));
    1013           2 :     printf(_("  -i, --ignore=RELATIVE_PATH  ignore indicated path\n"));
    1014           2 :     printf(_("  -m, --manifest-path=PATH    use specified path for manifest\n"));
    1015           2 :     printf(_("  -n, --no-parse-wal          do not try to parse WAL files\n"));
    1016           2 :     printf(_("  -P, --progress              show progress information\n"));
    1017           2 :     printf(_("  -q, --quiet                 do not print any output, except for errors\n"));
    1018           2 :     printf(_("  -s, --skip-checksums        skip checksum verification\n"));
    1019           2 :     printf(_("  -w, --wal-directory=PATH    use specified path for WAL files\n"));
    1020           2 :     printf(_("  -V, --version               output version information, then exit\n"));
    1021           2 :     printf(_("  -?, --help                  show this help, then exit\n"));
    1022           2 :     printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
    1023           2 :     printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
    1024           2 : }

Generated by: LCOV version 1.14