LCOV - code coverage report
Current view: top level - src/bin/pg_combinebackup - reconstruct.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 166 227 73.1 %
Date: 2024-04-22 21:11:44 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * reconstruct.c
       4             :  *      Reconstruct full file from incremental file and backup chain.
       5             :  *
       6             :  * Copyright (c) 2017-2024, PostgreSQL Global Development Group
       7             :  *
       8             :  * IDENTIFICATION
       9             :  *    src/bin/pg_combinebackup/reconstruct.c
      10             :  *
      11             :  *-------------------------------------------------------------------------
      12             :  */
      13             : #include "postgres_fe.h"
      14             : 
      15             : #include <unistd.h>
      16             : 
      17             : #include "backup/basebackup_incremental.h"
      18             : #include "common/file_perm.h"
      19             : #include "common/logging.h"
      20             : #include "copy_file.h"
      21             : #include "lib/stringinfo.h"
      22             : #include "reconstruct.h"
      23             : #include "storage/block.h"
      24             : 
      25             : /*
      26             :  * An rfile stores the data that we need in order to be able to use some file
      27             :  * on disk for reconstruction. For any given output file, we create one rfile
      28             :  * per backup that we need to consult when we constructing that output file.
      29             :  *
      30             :  * If we find a full version of the file in the backup chain, then only
      31             :  * filename and fd are initialized; the remaining fields are 0 or NULL.
      32             :  * For an incremental file, header_length, num_blocks, relative_block_numbers,
      33             :  * and truncation_block_length are also set.
      34             :  *
      35             :  * num_blocks_read and highest_offset_read always start out as 0.
      36             :  */
      37             : typedef struct rfile
      38             : {
      39             :     char       *filename;
      40             :     int         fd;
      41             :     size_t      header_length;
      42             :     unsigned    num_blocks;
      43             :     BlockNumber *relative_block_numbers;
      44             :     unsigned    truncation_block_length;
      45             :     unsigned    num_blocks_read;
      46             :     off_t       highest_offset_read;
      47             : } rfile;
      48             : 
      49             : static void debug_reconstruction(int n_source,
      50             :                                  rfile **sources,
      51             :                                  bool dry_run);
      52             : static unsigned find_reconstructed_block_length(rfile *s);
      53             : static rfile *make_incremental_rfile(char *filename);
      54             : static rfile *make_rfile(char *filename, bool missing_ok);
      55             : static void write_reconstructed_file(char *input_filename,
      56             :                                      char *output_filename,
      57             :                                      unsigned block_length,
      58             :                                      rfile **sourcemap,
      59             :                                      off_t *offsetmap,
      60             :                                      pg_checksum_context *checksum_ctx,
      61             :                                      CopyMethod copy_method,
      62             :                                      bool debug,
      63             :                                      bool dry_run);
      64             : static void read_bytes(rfile *rf, void *buffer, unsigned length);
      65             : static void write_block(int wfd, char *output_filename,
      66             :                         uint8 *buffer,
      67             :                         pg_checksum_context *checksum_ctx);
      68             : static void read_block(rfile *s, off_t off, uint8 *buffer);
      69             : 
      70             : /*
      71             :  * Reconstruct a full file from an incremental file and a chain of prior
      72             :  * backups.
      73             :  *
      74             :  * input_filename should be the path to the incremental file, and
      75             :  * output_filename should be the path where the reconstructed file is to be
      76             :  * written.
      77             :  *
      78             :  * relative_path should be the path to the directory containing this file,
      79             :  * relative to the root of the backup (NOT relative to the root of the
      80             :  * tablespace). bare_file_name should be the name of the file within that
      81             :  * directory, without "INCREMENTAL.".
      82             :  *
      83             :  * n_prior_backups is the number of prior backups, and prior_backup_dirs is
      84             :  * an array of pathnames where those backups can be found.
      85             :  */
      86             : void
      87        9302 : reconstruct_from_incremental_file(char *input_filename,
      88             :                                   char *output_filename,
      89             :                                   char *relative_path,
      90             :                                   char *bare_file_name,
      91             :                                   int n_prior_backups,
      92             :                                   char **prior_backup_dirs,
      93             :                                   manifest_data **manifests,
      94             :                                   char *manifest_path,
      95             :                                   pg_checksum_type checksum_type,
      96             :                                   int *checksum_length,
      97             :                                   uint8 **checksum_payload,
      98             :                                   CopyMethod copy_method,
      99             :                                   bool debug,
     100             :                                   bool dry_run)
     101             : {
     102             :     rfile     **source;
     103        9302 :     rfile      *latest_source = NULL;
     104             :     rfile     **sourcemap;
     105             :     off_t      *offsetmap;
     106             :     unsigned    block_length;
     107             :     unsigned    i;
     108        9302 :     unsigned    sidx = n_prior_backups;
     109        9302 :     bool        full_copy_possible = true;
     110        9302 :     int         copy_source_index = -1;
     111        9302 :     rfile      *copy_source = NULL;
     112             :     pg_checksum_context checksum_ctx;
     113             : 
     114             :     /*
     115             :      * Every block must come either from the latest version of the file or
     116             :      * from one of the prior backups.
     117             :      */
     118        9302 :     source = pg_malloc0(sizeof(rfile *) * (1 + n_prior_backups));
     119             : 
     120             :     /*
     121             :      * Use the information from the latest incremental file to figure out how
     122             :      * long the reconstructed file should be.
     123             :      */
     124        9302 :     latest_source = make_incremental_rfile(input_filename);
     125        9302 :     source[n_prior_backups] = latest_source;
     126        9302 :     block_length = find_reconstructed_block_length(latest_source);
     127             : 
     128             :     /*
     129             :      * For each block in the output file, we need to know from which file we
     130             :      * need to obtain it and at what offset in that file it's stored.
     131             :      * sourcemap gives us the first of these things, and offsetmap the latter.
     132             :      */
     133        9302 :     sourcemap = pg_malloc0(sizeof(rfile *) * block_length);
     134        9302 :     offsetmap = pg_malloc0(sizeof(off_t) * block_length);
     135             : 
     136             :     /*
     137             :      * Every block that is present in the newest incremental file should be
     138             :      * sourced from that file. If it precedes the truncation_block_length,
     139             :      * it's a block that we would otherwise have had to find in an older
     140             :      * backup and thus reduces the number of blocks remaining to be found by
     141             :      * one; otherwise, it's an extra block that needs to be included in the
     142             :      * output but would not have needed to be found in an older backup if it
     143             :      * had not been present.
     144             :      */
     145        9372 :     for (i = 0; i < latest_source->num_blocks; ++i)
     146             :     {
     147          70 :         BlockNumber b = latest_source->relative_block_numbers[i];
     148             : 
     149             :         Assert(b < block_length);
     150          70 :         sourcemap[b] = latest_source;
     151          70 :         offsetmap[b] = latest_source->header_length + (i * BLCKSZ);
     152             : 
     153             :         /*
     154             :          * A full copy of a file from an earlier backup is only possible if no
     155             :          * blocks are needed from any later incremental file.
     156             :          */
     157          70 :         full_copy_possible = false;
     158             :     }
     159             : 
     160             :     while (1)
     161        2658 :     {
     162             :         char        source_filename[MAXPGPATH];
     163             :         rfile      *s;
     164             : 
     165             :         /*
     166             :          * Move to the next backup in the chain. If there are no more, then
     167             :          * we're done.
     168             :          */
     169       11960 :         if (sidx == 0)
     170           0 :             break;
     171       11960 :         --sidx;
     172             : 
     173             :         /*
     174             :          * Look for the full file in the previous backup. If not found, then
     175             :          * look for an incremental file instead.
     176             :          */
     177       11960 :         snprintf(source_filename, MAXPGPATH, "%s/%s/%s",
     178       11960 :                  prior_backup_dirs[sidx], relative_path, bare_file_name);
     179       11960 :         if ((s = make_rfile(source_filename, true)) == NULL)
     180             :         {
     181        2658 :             snprintf(source_filename, MAXPGPATH, "%s/%s/INCREMENTAL.%s",
     182        2658 :                      prior_backup_dirs[sidx], relative_path, bare_file_name);
     183        2658 :             s = make_incremental_rfile(source_filename);
     184             :         }
     185       11960 :         source[sidx] = s;
     186             : 
     187             :         /*
     188             :          * If s->header_length == 0, then this is a full file; otherwise, it's
     189             :          * an incremental file.
     190             :          */
     191       11960 :         if (s->header_length == 0)
     192             :         {
     193             :             struct stat sb;
     194             :             BlockNumber b;
     195             :             BlockNumber blocklength;
     196             : 
     197             :             /* We need to know the length of the file. */
     198        9302 :             if (fstat(s->fd, &sb) < 0)
     199           0 :                 pg_fatal("could not stat \"%s\": %m", s->filename);
     200             : 
     201             :             /*
     202             :              * Since we found a full file, source all blocks from it that
     203             :              * exist in the file.
     204             :              *
     205             :              * Note that there may be blocks that don't exist either in this
     206             :              * file or in any incremental file but that precede
     207             :              * truncation_block_length. These are, presumably, zero-filled
     208             :              * blocks that result from the server extending the file but
     209             :              * taking no action on those blocks that generated any WAL.
     210             :              *
     211             :              * Sadly, we have no way of validating that this is really what
     212             :              * happened, and neither does the server. From it's perspective,
     213             :              * an unmodified block that contains data looks exactly the same
     214             :              * as a zero-filled block that never had any data: either way,
     215             :              * it's not mentioned in any WAL summary and the server has no
     216             :              * reason to read it. From our perspective, all we know is that
     217             :              * nobody had a reason to back up the block. That certainly means
     218             :              * that the block didn't exist at the time of the full backup, but
     219             :              * the supposition that it was all zeroes at the time of every
     220             :              * later backup is one that we can't validate.
     221             :              */
     222        9302 :             blocklength = sb.st_size / BLCKSZ;
     223       43764 :             for (b = 0; b < latest_source->truncation_block_length; ++b)
     224             :             {
     225       34462 :                 if (sourcemap[b] == NULL && b < blocklength)
     226             :                 {
     227       34392 :                     sourcemap[b] = s;
     228       34392 :                     offsetmap[b] = b * BLCKSZ;
     229             :                 }
     230             :             }
     231             : 
     232             :             /*
     233             :              * If a full copy looks possible, check whether the resulting file
     234             :              * should be exactly as long as the source file is. If so, a full
     235             :              * copy is acceptable, otherwise not.
     236             :              */
     237        9302 :             if (full_copy_possible)
     238             :             {
     239             :                 uint64      expected_length;
     240             : 
     241        9256 :                 expected_length =
     242        9256 :                     (uint64) latest_source->truncation_block_length;
     243        9256 :                 expected_length *= BLCKSZ;
     244        9256 :                 if (expected_length == sb.st_size)
     245             :                 {
     246        9256 :                     copy_source = s;
     247        9256 :                     copy_source_index = sidx;
     248             :                 }
     249             :             }
     250             : 
     251             :             /* We don't need to consider any further sources. */
     252        9302 :             break;
     253             :         }
     254             : 
     255             :         /*
     256             :          * Since we found another incremental file, source all blocks from it
     257             :          * that we need but don't yet have.
     258             :          */
     259        2658 :         for (i = 0; i < s->num_blocks; ++i)
     260             :         {
     261           0 :             BlockNumber b = s->relative_block_numbers[i];
     262             : 
     263           0 :             if (b < latest_source->truncation_block_length &&
     264           0 :                 sourcemap[b] == NULL)
     265             :             {
     266           0 :                 sourcemap[b] = s;
     267           0 :                 offsetmap[b] = s->header_length + (i * BLCKSZ);
     268             : 
     269             :                 /*
     270             :                  * A full copy of a file from an earlier backup is only
     271             :                  * possible if no blocks are needed from any later incremental
     272             :                  * file.
     273             :                  */
     274           0 :                 full_copy_possible = false;
     275             :             }
     276             :         }
     277             :     }
     278             : 
     279             :     /*
     280             :      * If a checksum of the required type already exists in the
     281             :      * backup_manifest for the relevant input directory, we can save some work
     282             :      * by reusing that checksum instead of computing a new one.
     283             :      */
     284        9302 :     if (copy_source_index >= 0 && manifests[copy_source_index] != NULL &&
     285             :         checksum_type != CHECKSUM_TYPE_NONE)
     286             :     {
     287             :         manifest_file *mfile;
     288             : 
     289        9256 :         mfile = manifest_files_lookup(manifests[copy_source_index]->files,
     290             :                                       manifest_path);
     291        9256 :         if (mfile == NULL)
     292             :         {
     293           0 :             char       *path = psprintf("%s/backup_manifest",
     294           0 :                                         prior_backup_dirs[copy_source_index]);
     295             : 
     296             :             /*
     297             :              * The directory is out of sync with the backup_manifest, so emit
     298             :              * a warning.
     299             :              */
     300             :             /*- translator: the first %s is a backup manifest file, the second is a file absent therein */
     301           0 :             pg_log_warning("\"%s\" contains no entry for \"%s\"",
     302             :                            path,
     303             :                            manifest_path);
     304           0 :             pfree(path);
     305             :         }
     306        9256 :         else if (mfile->checksum_type == checksum_type)
     307             :         {
     308        9256 :             *checksum_length = mfile->checksum_length;
     309        9256 :             *checksum_payload = pg_malloc(*checksum_length);
     310        9256 :             memcpy(*checksum_payload, mfile->checksum_payload,
     311        9256 :                    *checksum_length);
     312        9256 :             checksum_type = CHECKSUM_TYPE_NONE;
     313             :         }
     314             :     }
     315             : 
     316             :     /* Prepare for checksum calculation, if required. */
     317        9302 :     pg_checksum_init(&checksum_ctx, checksum_type);
     318             : 
     319             :     /*
     320             :      * If the full file can be created by copying a file from an older backup
     321             :      * in the chain without needing to overwrite any blocks or truncate the
     322             :      * result, then forget about performing reconstruction and just copy that
     323             :      * file in its entirety.
     324             :      *
     325             :      * Otherwise, reconstruct.
     326             :      */
     327        9302 :     if (copy_source != NULL)
     328        9256 :         copy_file(copy_source->filename, output_filename,
     329             :                   &checksum_ctx, copy_method, dry_run);
     330             :     else
     331             :     {
     332          46 :         write_reconstructed_file(input_filename, output_filename,
     333             :                                  block_length, sourcemap, offsetmap,
     334             :                                  &checksum_ctx, copy_method,
     335             :                                  debug, dry_run);
     336          46 :         debug_reconstruction(n_prior_backups + 1, source, dry_run);
     337             :     }
     338             : 
     339             :     /* Save results of checksum calculation. */
     340        9302 :     if (checksum_type != CHECKSUM_TYPE_NONE)
     341             :     {
     342          46 :         *checksum_payload = pg_malloc(PG_CHECKSUM_MAX_LENGTH);
     343          46 :         *checksum_length = pg_checksum_final(&checksum_ctx,
     344             :                                              *checksum_payload);
     345             :     }
     346             : 
     347             :     /*
     348             :      * Close files and release memory.
     349             :      */
     350       30564 :     for (i = 0; i <= n_prior_backups; ++i)
     351             :     {
     352       21262 :         rfile      *s = source[i];
     353             : 
     354       21262 :         if (s == NULL)
     355           0 :             continue;
     356       21262 :         if (close(s->fd) != 0)
     357           0 :             pg_fatal("could not close \"%s\": %m", s->filename);
     358       21262 :         if (s->relative_block_numbers != NULL)
     359          46 :             pfree(s->relative_block_numbers);
     360       21262 :         pg_free(s->filename);
     361             :     }
     362        9302 :     pfree(sourcemap);
     363        9302 :     pfree(offsetmap);
     364        9302 :     pfree(source);
     365        9302 : }
     366             : 
     367             : /*
     368             :  * Perform post-reconstruction logging and sanity checks.
     369             :  */
     370             : static void
     371          46 : debug_reconstruction(int n_source, rfile **sources, bool dry_run)
     372             : {
     373             :     unsigned    i;
     374             : 
     375         144 :     for (i = 0; i < n_source; ++i)
     376             :     {
     377          98 :         rfile      *s = sources[i];
     378             : 
     379             :         /* Ignore source if not used. */
     380          98 :         if (s == NULL)
     381           0 :             continue;
     382             : 
     383             :         /* If no data is needed from this file, we can ignore it. */
     384          98 :         if (s->num_blocks_read == 0)
     385           6 :             continue;
     386             : 
     387             :         /* Debug logging. */
     388          92 :         if (dry_run)
     389           0 :             pg_log_debug("would have read %u blocks from \"%s\"",
     390             :                          s->num_blocks_read, s->filename);
     391             :         else
     392          92 :             pg_log_debug("read %u blocks from \"%s\"",
     393             :                          s->num_blocks_read, s->filename);
     394             : 
     395             :         /*
     396             :          * In dry-run mode, we don't actually try to read data from the file,
     397             :          * but we do try to verify that the file is long enough that we could
     398             :          * have read the data if we'd tried.
     399             :          *
     400             :          * If this fails, then it means that a non-dry-run attempt would fail,
     401             :          * complaining of not being able to read the required bytes from the
     402             :          * file.
     403             :          */
     404          92 :         if (dry_run)
     405             :         {
     406             :             struct stat sb;
     407             : 
     408           0 :             if (fstat(s->fd, &sb) < 0)
     409           0 :                 pg_fatal("could not stat \"%s\": %m", s->filename);
     410           0 :             if (sb.st_size < s->highest_offset_read)
     411           0 :                 pg_fatal("file \"%s\" is too short: expected %llu, found %llu",
     412             :                          s->filename,
     413             :                          (unsigned long long) s->highest_offset_read,
     414             :                          (unsigned long long) sb.st_size);
     415             :         }
     416             :     }
     417          46 : }
     418             : 
     419             : /*
     420             :  * When we perform reconstruction using an incremental file, the output file
     421             :  * should be at least as long as the truncation_block_length. Any blocks
     422             :  * present in the incremental file increase the output length as far as is
     423             :  * necessary to include those blocks.
     424             :  */
     425             : static unsigned
     426        9302 : find_reconstructed_block_length(rfile *s)
     427             : {
     428        9302 :     unsigned    block_length = s->truncation_block_length;
     429             :     unsigned    i;
     430             : 
     431        9372 :     for (i = 0; i < s->num_blocks; ++i)
     432          70 :         if (s->relative_block_numbers[i] >= block_length)
     433           0 :             block_length = s->relative_block_numbers[i] + 1;
     434             : 
     435        9302 :     return block_length;
     436             : }
     437             : 
     438             : /*
     439             :  * Initialize an incremental rfile, reading the header so that we know which
     440             :  * blocks it contains.
     441             :  */
     442             : static rfile *
     443       11960 : make_incremental_rfile(char *filename)
     444             : {
     445             :     rfile      *rf;
     446             :     unsigned    magic;
     447             : 
     448       11960 :     rf = make_rfile(filename, false);
     449             : 
     450             :     /* Read and validate magic number. */
     451       11960 :     read_bytes(rf, &magic, sizeof(magic));
     452       11960 :     if (magic != INCREMENTAL_MAGIC)
     453           0 :         pg_fatal("file \"%s\" has bad incremental magic number (0x%x not 0x%x)",
     454             :                  filename, magic, INCREMENTAL_MAGIC);
     455             : 
     456             :     /* Read block count. */
     457       11960 :     read_bytes(rf, &rf->num_blocks, sizeof(rf->num_blocks));
     458       11960 :     if (rf->num_blocks > RELSEG_SIZE)
     459           0 :         pg_fatal("file \"%s\" has block count %u in excess of segment size %u",
     460             :                  filename, rf->num_blocks, RELSEG_SIZE);
     461             : 
     462             :     /* Read truncation block length. */
     463       11960 :     read_bytes(rf, &rf->truncation_block_length,
     464             :                sizeof(rf->truncation_block_length));
     465       11960 :     if (rf->truncation_block_length > RELSEG_SIZE)
     466           0 :         pg_fatal("file \"%s\" has truncation block length %u in excess of segment size %u",
     467             :                  filename, rf->truncation_block_length, RELSEG_SIZE);
     468             : 
     469             :     /* Read block numbers if there are any. */
     470       11960 :     if (rf->num_blocks > 0)
     471             :     {
     472          46 :         rf->relative_block_numbers =
     473          46 :             pg_malloc0(sizeof(BlockNumber) * rf->num_blocks);
     474          46 :         read_bytes(rf, rf->relative_block_numbers,
     475          46 :                    sizeof(BlockNumber) * rf->num_blocks);
     476             :     }
     477             : 
     478             :     /* Remember length of header. */
     479       11960 :     rf->header_length = sizeof(magic) + sizeof(rf->num_blocks) +
     480       11960 :         sizeof(rf->truncation_block_length) +
     481       11960 :         sizeof(BlockNumber) * rf->num_blocks;
     482             : 
     483             :     /*
     484             :      * Round header length to a multiple of BLCKSZ, so that blocks contents
     485             :      * are properly aligned. Only do this when the file actually has data for
     486             :      * some blocks.
     487             :      */
     488       11960 :     if ((rf->num_blocks > 0) && ((rf->header_length % BLCKSZ) != 0))
     489          46 :         rf->header_length += (BLCKSZ - (rf->header_length % BLCKSZ));
     490             : 
     491       11960 :     return rf;
     492             : }
     493             : 
     494             : /*
     495             :  * Allocate and perform basic initialization of an rfile.
     496             :  */
     497             : static rfile *
     498       23920 : make_rfile(char *filename, bool missing_ok)
     499             : {
     500             :     rfile      *rf;
     501             : 
     502       23920 :     rf = pg_malloc0(sizeof(rfile));
     503       23920 :     rf->filename = pstrdup(filename);
     504       23920 :     if ((rf->fd = open(filename, O_RDONLY | PG_BINARY, 0)) < 0)
     505             :     {
     506        2658 :         if (missing_ok && errno == ENOENT)
     507             :         {
     508        2658 :             pg_free(rf);
     509        2658 :             return NULL;
     510             :         }
     511           0 :         pg_fatal("could not open file \"%s\": %m", filename);
     512             :     }
     513             : 
     514       21262 :     return rf;
     515             : }
     516             : 
     517             : /*
     518             :  * Read the indicated number of bytes from an rfile into the buffer.
     519             :  */
     520             : static void
     521       35926 : read_bytes(rfile *rf, void *buffer, unsigned length)
     522             : {
     523       35926 :     int         rb = read(rf->fd, buffer, length);
     524             : 
     525       35926 :     if (rb != length)
     526             :     {
     527           0 :         if (rb < 0)
     528           0 :             pg_fatal("could not read file \"%s\": %m", rf->filename);
     529             :         else
     530           0 :             pg_fatal("could not read file \"%s\": read only %d of %u bytes",
     531             :                      rf->filename, rb, length);
     532             :     }
     533       35926 : }
     534             : 
     535             : /*
     536             :  * Write out a reconstructed file.
     537             :  */
     538             : static void
     539          46 : write_reconstructed_file(char *input_filename,
     540             :                          char *output_filename,
     541             :                          unsigned block_length,
     542             :                          rfile **sourcemap,
     543             :                          off_t *offsetmap,
     544             :                          pg_checksum_context *checksum_ctx,
     545             :                          CopyMethod copy_method,
     546             :                          bool debug,
     547             :                          bool dry_run)
     548             : {
     549          46 :     int         wfd = -1;
     550             :     unsigned    i;
     551          46 :     unsigned    zero_blocks = 0;
     552             : 
     553             :     /* Debugging output. */
     554          46 :     if (debug)
     555             :     {
     556             :         StringInfoData debug_buf;
     557          46 :         unsigned    start_of_range = 0;
     558          46 :         unsigned    current_block = 0;
     559             : 
     560             :         /* Basic information about the output file to be produced. */
     561          46 :         if (dry_run)
     562           0 :             pg_log_debug("would reconstruct \"%s\" (%u blocks, checksum %s)",
     563             :                          output_filename, block_length,
     564             :                          pg_checksum_type_name(checksum_ctx->type));
     565             :         else
     566          46 :             pg_log_debug("reconstructing \"%s\" (%u blocks, checksum %s)",
     567             :                          output_filename, block_length,
     568             :                          pg_checksum_type_name(checksum_ctx->type));
     569             : 
     570             :         /* Print out the plan for reconstructing this file. */
     571          46 :         initStringInfo(&debug_buf);
     572         554 :         while (current_block < block_length)
     573             :         {
     574         508 :             rfile      *s = sourcemap[current_block];
     575             : 
     576             :             /* Extend range, if possible. */
     577         508 :             if (current_block + 1 < block_length &&
     578         462 :                 s == sourcemap[current_block + 1])
     579             :             {
     580         398 :                 ++current_block;
     581         398 :                 continue;
     582             :             }
     583             : 
     584             :             /* Add details about this range. */
     585         110 :             if (s == NULL)
     586             :             {
     587           0 :                 if (current_block == start_of_range)
     588           0 :                     appendStringInfo(&debug_buf, " %u:zero", current_block);
     589             :                 else
     590           0 :                     appendStringInfo(&debug_buf, " %u-%u:zero",
     591             :                                      start_of_range, current_block);
     592             :             }
     593             :             else
     594             :             {
     595         110 :                 if (current_block == start_of_range)
     596          72 :                     appendStringInfo(&debug_buf, " %u:%s@" UINT64_FORMAT,
     597             :                                      current_block, s->filename,
     598          72 :                                      (uint64) offsetmap[current_block]);
     599             :                 else
     600          38 :                     appendStringInfo(&debug_buf, " %u-%u:%s@" UINT64_FORMAT,
     601             :                                      start_of_range, current_block,
     602             :                                      s->filename,
     603          38 :                                      (uint64) offsetmap[current_block]);
     604             :             }
     605             : 
     606             :             /* Begin new range. */
     607         110 :             start_of_range = ++current_block;
     608             : 
     609             :             /* If the output is very long or we are done, dump it now. */
     610         110 :             if (current_block == block_length || debug_buf.len > 1024)
     611             :             {
     612          46 :                 pg_log_debug("reconstruction plan:%s", debug_buf.data);
     613          46 :                 resetStringInfo(&debug_buf);
     614             :             }
     615             :         }
     616             : 
     617             :         /* Free memory. */
     618          46 :         pfree(debug_buf.data);
     619             :     }
     620             : 
     621             :     /* Open the output file, except in dry_run mode. */
     622          92 :     if (!dry_run &&
     623          46 :         (wfd = open(output_filename,
     624             :                     O_RDWR | PG_BINARY | O_CREAT | O_EXCL,
     625             :                     pg_file_create_mode)) < 0)
     626           0 :         pg_fatal("could not open file \"%s\": %m", output_filename);
     627             : 
     628             :     /* Read and write the blocks as required. */
     629         554 :     for (i = 0; i < block_length; ++i)
     630             :     {
     631             :         uint8       buffer[BLCKSZ];
     632         508 :         rfile      *s = sourcemap[i];
     633             : 
     634             :         /* Update accounting information. */
     635         508 :         if (s == NULL)
     636           0 :             ++zero_blocks;
     637             :         else
     638             :         {
     639         508 :             s->num_blocks_read++;
     640         508 :             s->highest_offset_read = Max(s->highest_offset_read,
     641             :                                          offsetmap[i] + BLCKSZ);
     642             :         }
     643             : 
     644             :         /* Skip the rest of this in dry-run mode. */
     645         508 :         if (dry_run)
     646           0 :             continue;
     647             : 
     648             :         /* Read or zero-fill the block as appropriate. */
     649         508 :         if (s == NULL)
     650             :         {
     651             :             /*
     652             :              * New block not mentioned in the WAL summary. Should have been an
     653             :              * uninitialized block, so just zero-fill it.
     654             :              */
     655           0 :             memset(buffer, 0, BLCKSZ);
     656             : 
     657             :             /* Write out the block, update the checksum if needed. */
     658           0 :             write_block(wfd, output_filename, buffer, checksum_ctx);
     659             : 
     660             :             /* Nothing else to do for zero-filled blocks. */
     661           0 :             continue;
     662             :         }
     663             : 
     664             :         /* Copy the block using the appropriate copy method. */
     665         508 :         if (copy_method != COPY_METHOD_COPY_FILE_RANGE)
     666             :         {
     667             :             /*
     668             :              * Read the block from the correct source file, and then write it
     669             :              * out, possibly with a checksum update.
     670             :              */
     671         508 :             read_block(s, offsetmap[i], buffer);
     672         508 :             write_block(wfd, output_filename, buffer, checksum_ctx);
     673             :         }
     674             :         else                    /* use copy_file_range */
     675             :         {
     676             : #if defined(HAVE_COPY_FILE_RANGE)
     677             :             /* copy_file_range modifies the offset, so use a local copy */
     678           0 :             off_t       off = offsetmap[i];
     679           0 :             size_t      nwritten = 0;
     680             : 
     681             :             /*
     682             :              * Retry until we've written all the bytes (the offset is updated
     683             :              * by copy_file_range, and so is the wfd file offset).
     684             :              */
     685             :             do
     686             :             {
     687             :                 int         wb;
     688             : 
     689           0 :                 wb = copy_file_range(s->fd, &off, wfd, NULL, BLCKSZ - nwritten, 0);
     690             : 
     691           0 :                 if (wb < 0)
     692           0 :                     pg_fatal("error while copying file range from \"%s\" to \"%s\": %m",
     693             :                              input_filename, output_filename);
     694             : 
     695           0 :                 nwritten += wb;
     696             : 
     697           0 :             } while (BLCKSZ > nwritten);
     698             : 
     699             :             /*
     700             :              * When checksum calculation not needed, we're done, otherwise
     701             :              * read the block and pass it to the checksum calculation.
     702             :              */
     703           0 :             if (checksum_ctx->type == CHECKSUM_TYPE_NONE)
     704           0 :                 continue;
     705             : 
     706           0 :             read_block(s, offsetmap[i], buffer);
     707             : 
     708           0 :             if (pg_checksum_update(checksum_ctx, buffer, BLCKSZ) < 0)
     709           0 :                 pg_fatal("could not update checksum of file \"%s\"",
     710             :                          output_filename);
     711             : #else
     712             :             pg_fatal("copy_file_range not supported on this platform");
     713             : #endif
     714             :         }
     715             :     }
     716             : 
     717             :     /* Debugging output. */
     718          46 :     if (zero_blocks > 0)
     719             :     {
     720           0 :         if (dry_run)
     721           0 :             pg_log_debug("would have zero-filled %u blocks", zero_blocks);
     722             :         else
     723           0 :             pg_log_debug("zero-filled %u blocks", zero_blocks);
     724             :     }
     725             : 
     726             :     /* Close the output file. */
     727          46 :     if (wfd >= 0 && close(wfd) != 0)
     728           0 :         pg_fatal("could not close \"%s\": %m", output_filename);
     729          46 : }
     730             : 
     731             : /*
     732             :  * Write the block into the file (using the file descriptor), and
     733             :  * if needed update the checksum calculation.
     734             :  *
     735             :  * The buffer is expected to contain BLCKSZ bytes. The filename is
     736             :  * provided only for the error message.
     737             :  */
     738             : static void
     739         508 : write_block(int fd, char *output_filename,
     740             :             uint8 *buffer, pg_checksum_context *checksum_ctx)
     741             : {
     742             :     int         wb;
     743             : 
     744         508 :     if ((wb = write(fd, buffer, BLCKSZ)) != BLCKSZ)
     745             :     {
     746           0 :         if (wb < 0)
     747           0 :             pg_fatal("could not write file \"%s\": %m", output_filename);
     748             :         else
     749           0 :             pg_fatal("could not write file \"%s\": wrote only %d of %d bytes",
     750             :                      output_filename, wb, BLCKSZ);
     751             :     }
     752             : 
     753             :     /* Update the checksum computation. */
     754         508 :     if (pg_checksum_update(checksum_ctx, buffer, BLCKSZ) < 0)
     755           0 :         pg_fatal("could not update checksum of file \"%s\"",
     756             :                  output_filename);
     757         508 : }
     758             : 
     759             : /*
     760             :  * Read a block of data (BLCKSZ bytes) into the buffer.
     761             :  */
     762             : static void
     763         508 : read_block(rfile *s, off_t off, uint8 *buffer)
     764             : {
     765             :     int         rb;
     766             : 
     767             :     /* Read the block from the correct source, except if dry-run. */
     768         508 :     rb = pg_pread(s->fd, buffer, BLCKSZ, off);
     769         508 :     if (rb != BLCKSZ)
     770             :     {
     771           0 :         if (rb < 0)
     772           0 :             pg_fatal("could not read file \"%s\": %m", s->filename);
     773             :         else
     774           0 :             pg_fatal("could not read file \"%s\": read only %d of %d bytes at offset %llu",
     775             :                      s->filename, rb, BLCKSZ,
     776             :                      (unsigned long long) off);
     777             :     }
     778         508 : }

Generated by: LCOV version 1.14