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