Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * pg_backup_directory.c
4 : *
5 : * A directory format dump is a directory, which contains a "toc.dat" file
6 : * for the TOC, and a separate file for each data entry, named "<oid>.dat".
7 : * Large objects are stored in separate files named "blob_<oid>.dat",
8 : * and there's a plain-text TOC file for each BLOBS TOC entry named
9 : * "blobs_<dumpID>.toc" (or just "blobs.toc" in archive versions before 16).
10 : *
11 : * If compression is used, each data file is individually compressed and the
12 : * ".gz" suffix is added to the filenames. The TOC files are never
13 : * compressed by pg_dump, however they are accepted with the .gz suffix too,
14 : * in case the user has manually compressed them with 'gzip'.
15 : *
16 : * NOTE: This format is identical to the files written in the tar file in
17 : * the 'tar' format, except that we don't write the restore.sql file (TODO),
18 : * and the tar format doesn't support compression. Please keep the formats in
19 : * sync.
20 : *
21 : *
22 : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
23 : * Portions Copyright (c) 1994, Regents of the University of California
24 : * Portions Copyright (c) 2000, Philip Warner
25 : *
26 : * Rights are granted to use this software in any way so long
27 : * as this notice is not removed.
28 : *
29 : * The author is not responsible for loss or damages that may
30 : * result from its use.
31 : *
32 : * IDENTIFICATION
33 : * src/bin/pg_dump/pg_backup_directory.c
34 : *
35 : *-------------------------------------------------------------------------
36 : */
37 : #include "postgres_fe.h"
38 :
39 : #include <dirent.h>
40 : #include <sys/stat.h>
41 :
42 : #include "common/file_utils.h"
43 : #include "compress_io.h"
44 : #include "dumputils.h"
45 : #include "parallel.h"
46 : #include "pg_backup_utils.h"
47 :
48 : typedef struct
49 : {
50 : /*
51 : * Our archive location. This is basically what the user specified as his
52 : * backup file but of course here it is a directory.
53 : */
54 : char *directory;
55 :
56 : CompressFileHandle *dataFH; /* currently open data file */
57 : CompressFileHandle *LOsTocFH; /* file handle for blobs_NNN.toc */
58 : ParallelState *pstate; /* for parallel backup / restore */
59 : } lclContext;
60 :
61 : typedef struct
62 : {
63 : char *filename; /* filename excluding the directory (basename) */
64 : } lclTocEntry;
65 :
66 : /* prototypes for private functions */
67 : static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te);
68 : static void _StartData(ArchiveHandle *AH, TocEntry *te);
69 : static void _EndData(ArchiveHandle *AH, TocEntry *te);
70 : static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen);
71 : static int _WriteByte(ArchiveHandle *AH, const int i);
72 : static int _ReadByte(ArchiveHandle *AH);
73 : static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len);
74 : static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len);
75 : static void _CloseArchive(ArchiveHandle *AH);
76 : static void _ReopenArchive(ArchiveHandle *AH);
77 : static void _PrintTocData(ArchiveHandle *AH, TocEntry *te);
78 :
79 : static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te);
80 : static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te);
81 : static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te);
82 :
83 : static void _StartLOs(ArchiveHandle *AH, TocEntry *te);
84 : static void _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid);
85 : static void _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid);
86 : static void _EndLOs(ArchiveHandle *AH, TocEntry *te);
87 : static void _LoadLOs(ArchiveHandle *AH, TocEntry *te);
88 :
89 : static void _PrepParallelRestore(ArchiveHandle *AH);
90 : static void _Clone(ArchiveHandle *AH);
91 : static void _DeClone(ArchiveHandle *AH);
92 :
93 : static int _WorkerJobRestoreDirectory(ArchiveHandle *AH, TocEntry *te);
94 : static int _WorkerJobDumpDirectory(ArchiveHandle *AH, TocEntry *te);
95 :
96 : static void setFilePath(ArchiveHandle *AH, char *buf,
97 : const char *relativeFilename);
98 :
99 : /*
100 : * Init routine required by ALL formats. This is a global routine
101 : * and should be declared in pg_backup_archiver.h
102 : *
103 : * Its task is to create any extra archive context (using AH->formatData),
104 : * and to initialize the supported function pointers.
105 : *
106 : * It should also prepare whatever its input source is for reading/writing,
107 : * and in the case of a read mode connection, it should load the Header & TOC.
108 : */
109 : void
110 44 : InitArchiveFmt_Directory(ArchiveHandle *AH)
111 : {
112 : lclContext *ctx;
113 :
114 : /* Assuming static functions, this can be copied for each format. */
115 44 : AH->ArchiveEntryPtr = _ArchiveEntry;
116 44 : AH->StartDataPtr = _StartData;
117 44 : AH->WriteDataPtr = _WriteData;
118 44 : AH->EndDataPtr = _EndData;
119 44 : AH->WriteBytePtr = _WriteByte;
120 44 : AH->ReadBytePtr = _ReadByte;
121 44 : AH->WriteBufPtr = _WriteBuf;
122 44 : AH->ReadBufPtr = _ReadBuf;
123 44 : AH->ClosePtr = _CloseArchive;
124 44 : AH->ReopenPtr = _ReopenArchive;
125 44 : AH->PrintTocDataPtr = _PrintTocData;
126 44 : AH->ReadExtraTocPtr = _ReadExtraToc;
127 44 : AH->WriteExtraTocPtr = _WriteExtraToc;
128 44 : AH->PrintExtraTocPtr = _PrintExtraToc;
129 :
130 44 : AH->StartLOsPtr = _StartLOs;
131 44 : AH->StartLOPtr = _StartLO;
132 44 : AH->EndLOPtr = _EndLO;
133 44 : AH->EndLOsPtr = _EndLOs;
134 :
135 44 : AH->PrepParallelRestorePtr = _PrepParallelRestore;
136 44 : AH->ClonePtr = _Clone;
137 44 : AH->DeClonePtr = _DeClone;
138 :
139 44 : AH->WorkerJobRestorePtr = _WorkerJobRestoreDirectory;
140 44 : AH->WorkerJobDumpPtr = _WorkerJobDumpDirectory;
141 :
142 : /* Set up our private context */
143 44 : ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
144 44 : AH->formatData = ctx;
145 :
146 44 : ctx->dataFH = NULL;
147 44 : ctx->LOsTocFH = NULL;
148 :
149 : /*
150 : * Now open the TOC file
151 : */
152 :
153 44 : if (!AH->fSpec || strcmp(AH->fSpec, "") == 0)
154 0 : pg_fatal("no output directory specified");
155 :
156 44 : ctx->directory = AH->fSpec;
157 :
158 44 : if (AH->mode == archModeWrite)
159 : {
160 : /* we accept an empty existing directory */
161 20 : create_or_open_dir(ctx->directory);
162 : }
163 : else
164 : { /* Read Mode */
165 : char fname[MAXPGPATH];
166 : CompressFileHandle *tocFH;
167 :
168 24 : setFilePath(AH, fname, "toc.dat");
169 :
170 24 : tocFH = InitDiscoverCompressFileHandle(fname, PG_BINARY_R);
171 24 : if (tocFH == NULL)
172 0 : pg_fatal("could not open input file \"%s\": %m", fname);
173 :
174 24 : ctx->dataFH = tocFH;
175 :
176 : /*
177 : * The TOC of a directory format dump shares the format code of the
178 : * tar format.
179 : */
180 24 : AH->format = archTar;
181 24 : ReadHead(AH);
182 24 : AH->format = archDirectory;
183 24 : ReadToc(AH);
184 :
185 : /* Nothing else in the file, so close it again... */
186 24 : if (!EndCompressFileHandle(tocFH))
187 0 : pg_fatal("could not close TOC file: %m");
188 24 : ctx->dataFH = NULL;
189 : }
190 44 : }
191 :
192 : /*
193 : * Called by the Archiver when the dumper creates a new TOC entry.
194 : *
195 : * We determine the filename for this entry.
196 : */
197 : static void
198 3362 : _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
199 : {
200 : lclTocEntry *tctx;
201 : char fn[MAXPGPATH];
202 :
203 3362 : tctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry));
204 3362 : if (strcmp(te->desc, "BLOBS") == 0)
205 : {
206 16 : snprintf(fn, MAXPGPATH, "blobs_%d.toc", te->dumpId);
207 16 : tctx->filename = pg_strdup(fn);
208 : }
209 3346 : else if (te->dataDumper)
210 : {
211 338 : snprintf(fn, MAXPGPATH, "%d.dat", te->dumpId);
212 338 : tctx->filename = pg_strdup(fn);
213 : }
214 : else
215 3008 : tctx->filename = NULL;
216 :
217 3362 : te->formatData = tctx;
218 3362 : }
219 :
220 : /*
221 : * Called by the Archiver to save any extra format-related TOC entry
222 : * data.
223 : *
224 : * Use the Archiver routines to write data - they are non-endian, and
225 : * maintain other important file information.
226 : */
227 : static void
228 3362 : _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
229 : {
230 3362 : lclTocEntry *tctx = (lclTocEntry *) te->formatData;
231 :
232 : /*
233 : * A dumpable object has set tctx->filename, any other object has not.
234 : * (see _ArchiveEntry).
235 : */
236 3362 : if (tctx->filename)
237 354 : WriteStr(AH, tctx->filename);
238 : else
239 3008 : WriteStr(AH, "");
240 3362 : }
241 :
242 : /*
243 : * Called by the Archiver to read any extra format-related TOC data.
244 : *
245 : * Needs to match the order defined in _WriteExtraToc, and should also
246 : * use the Archiver input routines.
247 : */
248 : static void
249 4120 : _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
250 : {
251 4120 : lclTocEntry *tctx = (lclTocEntry *) te->formatData;
252 :
253 4120 : if (tctx == NULL)
254 : {
255 4120 : tctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry));
256 4120 : te->formatData = tctx;
257 : }
258 :
259 4120 : tctx->filename = ReadStr(AH);
260 4120 : if (strlen(tctx->filename) == 0)
261 : {
262 3688 : free(tctx->filename);
263 3688 : tctx->filename = NULL;
264 : }
265 4120 : }
266 :
267 : /*
268 : * Called by the Archiver when restoring an archive to output a comment
269 : * that includes useful information about the TOC entry.
270 : */
271 : static void
272 3112 : _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
273 : {
274 3112 : lclTocEntry *tctx = (lclTocEntry *) te->formatData;
275 :
276 3112 : if (AH->public.verbose && tctx->filename)
277 0 : ahprintf(AH, "-- File: %s\n", tctx->filename);
278 3112 : }
279 :
280 : /*
281 : * Called by the archiver when saving TABLE DATA (not schema). This routine
282 : * should save whatever format-specific information is needed to read
283 : * the archive back.
284 : *
285 : * It is called just prior to the dumper's 'DataDumper' routine being called.
286 : *
287 : * We create the data file for writing.
288 : */
289 : static void
290 338 : _StartData(ArchiveHandle *AH, TocEntry *te)
291 : {
292 338 : lclTocEntry *tctx = (lclTocEntry *) te->formatData;
293 338 : lclContext *ctx = (lclContext *) AH->formatData;
294 : char fname[MAXPGPATH];
295 :
296 338 : setFilePath(AH, fname, tctx->filename);
297 :
298 338 : ctx->dataFH = InitCompressFileHandle(AH->compression_spec);
299 :
300 338 : if (!ctx->dataFH->open_write_func(fname, PG_BINARY_W, ctx->dataFH))
301 0 : pg_fatal("could not open output file \"%s\": %m", fname);
302 338 : }
303 :
304 : /*
305 : * Called by archiver when dumper calls WriteData. This routine is
306 : * called for both LO and table data; it is the responsibility of
307 : * the format to manage each kind of data using StartLO/StartData.
308 : *
309 : * It should only be called from within a DataDumper routine.
310 : *
311 : * We write the data to the open data file.
312 : */
313 : static void
314 49404 : _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
315 : {
316 49404 : lclContext *ctx = (lclContext *) AH->formatData;
317 49404 : CompressFileHandle *CFH = ctx->dataFH;
318 :
319 49404 : errno = 0;
320 49404 : if (dLen > 0 && !CFH->write_func(data, dLen, CFH))
321 : {
322 : /* if write didn't set errno, assume problem is no disk space */
323 0 : if (errno == 0)
324 0 : errno = ENOSPC;
325 0 : pg_fatal("could not write to output file: %s",
326 : CFH->get_error_func(CFH));
327 : }
328 49404 : }
329 :
330 : /*
331 : * Called by the archiver when a dumper's 'DataDumper' routine has
332 : * finished.
333 : *
334 : * We close the data file.
335 : */
336 : static void
337 338 : _EndData(ArchiveHandle *AH, TocEntry *te)
338 : {
339 338 : lclContext *ctx = (lclContext *) AH->formatData;
340 :
341 : /* Close the file */
342 338 : if (!EndCompressFileHandle(ctx->dataFH))
343 0 : pg_fatal("could not close data file: %m");
344 :
345 338 : ctx->dataFH = NULL;
346 338 : }
347 :
348 : /*
349 : * Print data for a given file (can be a LO as well)
350 : */
351 : static void
352 356 : _PrintFileData(ArchiveHandle *AH, char *filename)
353 : {
354 356 : size_t cnt = 0;
355 : char *buf;
356 : size_t buflen;
357 : CompressFileHandle *CFH;
358 :
359 356 : if (!filename)
360 0 : return;
361 :
362 356 : CFH = InitDiscoverCompressFileHandle(filename, PG_BINARY_R);
363 356 : if (!CFH)
364 0 : pg_fatal("could not open input file \"%s\": %m", filename);
365 :
366 356 : buflen = DEFAULT_IO_BUFFER_SIZE;
367 356 : buf = pg_malloc(buflen);
368 :
369 790 : while (CFH->read_func(buf, buflen, &cnt, CFH) && cnt > 0)
370 : {
371 434 : ahwrite(buf, 1, cnt, AH);
372 : }
373 :
374 356 : free(buf);
375 356 : if (!EndCompressFileHandle(CFH))
376 0 : pg_fatal("could not close data file \"%s\": %m", filename);
377 : }
378 :
379 : /*
380 : * Print data for a given TOC entry
381 : */
382 : static void
383 356 : _PrintTocData(ArchiveHandle *AH, TocEntry *te)
384 : {
385 356 : lclTocEntry *tctx = (lclTocEntry *) te->formatData;
386 :
387 356 : if (!tctx->filename)
388 0 : return;
389 :
390 356 : if (strcmp(te->desc, "BLOBS") == 0)
391 16 : _LoadLOs(AH, te);
392 : else
393 : {
394 : char fname[MAXPGPATH];
395 :
396 340 : setFilePath(AH, fname, tctx->filename);
397 340 : _PrintFileData(AH, fname);
398 : }
399 : }
400 :
401 : static void
402 16 : _LoadLOs(ArchiveHandle *AH, TocEntry *te)
403 : {
404 : Oid oid;
405 16 : lclContext *ctx = (lclContext *) AH->formatData;
406 16 : lclTocEntry *tctx = (lclTocEntry *) te->formatData;
407 : CompressFileHandle *CFH;
408 : char tocfname[MAXPGPATH];
409 : char line[MAXPGPATH];
410 :
411 16 : StartRestoreLOs(AH);
412 :
413 : /*
414 : * Note: before archive v16, there was always only one BLOBS TOC entry,
415 : * now there can be multiple. Furthermore, although the actual filename
416 : * was always "blobs.toc" before v16, the value of tctx->filename did not
417 : * match that before commit 548e50976 fixed it. For simplicity we assume
418 : * it must be "blobs.toc" in all archives before v16.
419 : */
420 16 : if (AH->version < K_VERS_1_16)
421 0 : setFilePath(AH, tocfname, "blobs.toc");
422 : else
423 16 : setFilePath(AH, tocfname, tctx->filename);
424 :
425 16 : CFH = ctx->LOsTocFH = InitDiscoverCompressFileHandle(tocfname, PG_BINARY_R);
426 :
427 16 : if (ctx->LOsTocFH == NULL)
428 0 : pg_fatal("could not open large object TOC file \"%s\" for input: %m",
429 : tocfname);
430 :
431 : /* Read the LOs TOC file line-by-line, and process each LO */
432 32 : while ((CFH->gets_func(line, MAXPGPATH, CFH)) != NULL)
433 : {
434 : char lofname[MAXPGPATH + 1];
435 : char path[MAXPGPATH];
436 :
437 : /* Can't overflow because line and lofname are the same length */
438 16 : if (sscanf(line, "%u %" CppAsString2(MAXPGPATH) "s\n", &oid, lofname) != 2)
439 0 : pg_fatal("invalid line in large object TOC file \"%s\": \"%s\"",
440 : tocfname, line);
441 :
442 16 : StartRestoreLO(AH, oid, AH->public.ropt->dropSchema);
443 16 : snprintf(path, MAXPGPATH, "%s/%s", ctx->directory, lofname);
444 16 : _PrintFileData(AH, path);
445 16 : EndRestoreLO(AH, oid);
446 : }
447 16 : if (!CFH->eof_func(CFH))
448 0 : pg_fatal("error reading large object TOC file \"%s\"",
449 : tocfname);
450 :
451 16 : if (!EndCompressFileHandle(ctx->LOsTocFH))
452 0 : pg_fatal("could not close large object TOC file \"%s\": %m",
453 : tocfname);
454 :
455 16 : ctx->LOsTocFH = NULL;
456 :
457 16 : EndRestoreLOs(AH);
458 16 : }
459 :
460 :
461 : /*
462 : * Write a byte of data to the archive.
463 : * Called by the archiver to do integer & byte output to the archive.
464 : * These routines are only used to read & write the headers & TOC.
465 : */
466 : static int
467 332850 : _WriteByte(ArchiveHandle *AH, const int i)
468 : {
469 332850 : unsigned char c = (unsigned char) i;
470 332850 : lclContext *ctx = (lclContext *) AH->formatData;
471 332850 : CompressFileHandle *CFH = ctx->dataFH;
472 :
473 332850 : errno = 0;
474 332850 : if (!CFH->write_func(&c, 1, CFH))
475 : {
476 : /* if write didn't set errno, assume problem is no disk space */
477 0 : if (errno == 0)
478 0 : errno = ENOSPC;
479 0 : pg_fatal("could not write to output file: %s",
480 : CFH->get_error_func(CFH));
481 : }
482 :
483 332850 : return 1;
484 : }
485 :
486 : /*
487 : * Read a byte of data from the archive.
488 : * Called by the archiver to read bytes & integers from the archive.
489 : * These routines are only used to read & write headers & TOC.
490 : * EOF should be treated as a fatal error.
491 : */
492 : static int
493 407768 : _ReadByte(ArchiveHandle *AH)
494 : {
495 407768 : lclContext *ctx = (lclContext *) AH->formatData;
496 407768 : CompressFileHandle *CFH = ctx->dataFH;
497 :
498 407768 : return CFH->getc_func(CFH);
499 : }
500 :
501 : /*
502 : * Write a buffer of data to the archive.
503 : * Called by the archiver to write a block of bytes to the TOC or a data file.
504 : */
505 : static void
506 37428 : _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
507 : {
508 37428 : lclContext *ctx = (lclContext *) AH->formatData;
509 37428 : CompressFileHandle *CFH = ctx->dataFH;
510 :
511 37428 : errno = 0;
512 37428 : if (!CFH->write_func(buf, len, CFH))
513 : {
514 : /* if write didn't set errno, assume problem is no disk space */
515 0 : if (errno == 0)
516 0 : errno = ENOSPC;
517 0 : pg_fatal("could not write to output file: %s",
518 : CFH->get_error_func(CFH));
519 : }
520 37428 : }
521 :
522 : /*
523 : * Read a block of bytes from the archive.
524 : *
525 : * Called by the archiver to read a block of bytes from the archive
526 : */
527 : static void
528 45830 : _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
529 : {
530 45830 : lclContext *ctx = (lclContext *) AH->formatData;
531 45830 : CompressFileHandle *CFH = ctx->dataFH;
532 :
533 : /*
534 : * If there was an I/O error, we already exited in readF(), so here we
535 : * exit on short reads.
536 : */
537 45830 : if (!CFH->read_func(buf, len, NULL, CFH))
538 0 : pg_fatal("could not read from input file: end of file");
539 45830 : }
540 :
541 : /*
542 : * Close the archive.
543 : *
544 : * When writing the archive, this is the routine that actually starts
545 : * the process of saving it to files. No data should be written prior
546 : * to this point, since the user could sort the TOC after creating it.
547 : *
548 : * If an archive is to be written, this routine must call:
549 : * WriteHead to save the archive header
550 : * WriteToc to save the TOC entries
551 : * WriteDataChunks to save all data & LOs.
552 : */
553 : static void
554 44 : _CloseArchive(ArchiveHandle *AH)
555 : {
556 44 : lclContext *ctx = (lclContext *) AH->formatData;
557 :
558 44 : if (AH->mode == archModeWrite)
559 : {
560 : CompressFileHandle *tocFH;
561 20 : pg_compress_specification compression_spec = {0};
562 : char fname[MAXPGPATH];
563 :
564 20 : setFilePath(AH, fname, "toc.dat");
565 :
566 : /* this will actually fork the processes for a parallel backup */
567 20 : ctx->pstate = ParallelBackupStart(AH);
568 :
569 : /* The TOC is always created uncompressed */
570 20 : compression_spec.algorithm = PG_COMPRESSION_NONE;
571 20 : tocFH = InitCompressFileHandle(compression_spec);
572 20 : if (!tocFH->open_write_func(fname, PG_BINARY_W, tocFH))
573 0 : pg_fatal("could not open output file \"%s\": %m", fname);
574 20 : ctx->dataFH = tocFH;
575 :
576 : /*
577 : * Write 'tar' in the format field of the toc.dat file. The directory
578 : * is compatible with 'tar', so there's no point having a different
579 : * format code for it.
580 : */
581 20 : AH->format = archTar;
582 20 : WriteHead(AH);
583 20 : AH->format = archDirectory;
584 20 : WriteToc(AH);
585 20 : if (!EndCompressFileHandle(tocFH))
586 0 : pg_fatal("could not close TOC file: %m");
587 20 : WriteDataChunks(AH, ctx->pstate);
588 :
589 20 : ParallelBackupEnd(AH, ctx->pstate);
590 :
591 : /*
592 : * In directory mode, there is no need to sync all the entries
593 : * individually. Just recurse once through all the files generated.
594 : */
595 20 : if (AH->dosync)
596 8 : sync_dir_recurse(ctx->directory, AH->sync_method);
597 : }
598 44 : AH->FH = NULL;
599 44 : }
600 :
601 : /*
602 : * Reopen the archive's file handle.
603 : */
604 : static void
605 28 : _ReopenArchive(ArchiveHandle *AH)
606 : {
607 : /*
608 : * Our TOC is in memory, our data files are opened by each child anyway as
609 : * they are separate. We support reopening the archive by just doing
610 : * nothing.
611 : */
612 28 : }
613 :
614 : /*
615 : * LO support
616 : */
617 :
618 : /*
619 : * Called by the archiver when starting to save BLOB DATA (not schema).
620 : * It is called just prior to the dumper's DataDumper routine.
621 : *
622 : * We open the large object TOC file here, so that we can append a line to
623 : * it for each LO.
624 : */
625 : static void
626 16 : _StartLOs(ArchiveHandle *AH, TocEntry *te)
627 : {
628 16 : lclContext *ctx = (lclContext *) AH->formatData;
629 16 : lclTocEntry *tctx = (lclTocEntry *) te->formatData;
630 16 : pg_compress_specification compression_spec = {0};
631 : char fname[MAXPGPATH];
632 :
633 16 : setFilePath(AH, fname, tctx->filename);
634 :
635 : /* The LO TOC file is never compressed */
636 16 : compression_spec.algorithm = PG_COMPRESSION_NONE;
637 16 : ctx->LOsTocFH = InitCompressFileHandle(compression_spec);
638 16 : if (!ctx->LOsTocFH->open_write_func(fname, "ab", ctx->LOsTocFH))
639 0 : pg_fatal("could not open output file \"%s\": %m", fname);
640 16 : }
641 :
642 : /*
643 : * Called by the archiver when we're about to start dumping a LO.
644 : *
645 : * We create a file to write the LO to.
646 : */
647 : static void
648 16 : _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
649 : {
650 16 : lclContext *ctx = (lclContext *) AH->formatData;
651 : char fname[MAXPGPATH];
652 :
653 16 : snprintf(fname, MAXPGPATH, "%s/blob_%u.dat", ctx->directory, oid);
654 :
655 16 : ctx->dataFH = InitCompressFileHandle(AH->compression_spec);
656 16 : if (!ctx->dataFH->open_write_func(fname, PG_BINARY_W, ctx->dataFH))
657 0 : pg_fatal("could not open output file \"%s\": %m", fname);
658 16 : }
659 :
660 : /*
661 : * Called by the archiver when the dumper is finished writing a LO.
662 : *
663 : * We close the LO file and write an entry to the LO TOC file for it.
664 : */
665 : static void
666 16 : _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
667 : {
668 16 : lclContext *ctx = (lclContext *) AH->formatData;
669 16 : CompressFileHandle *CFH = ctx->LOsTocFH;
670 : char buf[50];
671 : int len;
672 :
673 : /* Close the BLOB data file itself */
674 16 : if (!EndCompressFileHandle(ctx->dataFH))
675 0 : pg_fatal("could not close LO data file: %m");
676 16 : ctx->dataFH = NULL;
677 :
678 : /* register the LO in blobs_NNN.toc */
679 16 : len = snprintf(buf, sizeof(buf), "%u blob_%u.dat\n", oid, oid);
680 16 : if (!CFH->write_func(buf, len, CFH))
681 : {
682 : /* if write didn't set errno, assume problem is no disk space */
683 0 : if (errno == 0)
684 0 : errno = ENOSPC;
685 0 : pg_fatal("could not write to LOs TOC file: %s",
686 : CFH->get_error_func(CFH));
687 : }
688 16 : }
689 :
690 : /*
691 : * Called by the archiver when finishing saving BLOB DATA.
692 : *
693 : * We close the LOs TOC file.
694 : */
695 : static void
696 16 : _EndLOs(ArchiveHandle *AH, TocEntry *te)
697 : {
698 16 : lclContext *ctx = (lclContext *) AH->formatData;
699 :
700 16 : if (!EndCompressFileHandle(ctx->LOsTocFH))
701 0 : pg_fatal("could not close LOs TOC file: %m");
702 16 : ctx->LOsTocFH = NULL;
703 16 : }
704 :
705 : /*
706 : * Gets a relative file name and prepends the output directory, writing the
707 : * result to buf. The caller needs to make sure that buf is MAXPGPATH bytes
708 : * big. Can't use a static char[MAXPGPATH] inside the function because we run
709 : * multithreaded on Windows.
710 : */
711 : static void
712 786 : setFilePath(ArchiveHandle *AH, char *buf, const char *relativeFilename)
713 : {
714 786 : lclContext *ctx = (lclContext *) AH->formatData;
715 : char *dname;
716 :
717 786 : dname = ctx->directory;
718 :
719 786 : if (strlen(dname) + 1 + strlen(relativeFilename) + 1 > MAXPGPATH)
720 0 : pg_fatal("file name too long: \"%s\"", dname);
721 :
722 786 : strcpy(buf, dname);
723 786 : strcat(buf, "/");
724 786 : strcat(buf, relativeFilename);
725 786 : }
726 :
727 : /*
728 : * Prepare for parallel restore.
729 : *
730 : * The main thing that needs to happen here is to fill in TABLE DATA and BLOBS
731 : * TOC entries' dataLength fields with appropriate values to guide the
732 : * ordering of restore jobs. The source of said data is format-dependent,
733 : * as is the exact meaning of the values.
734 : *
735 : * A format module might also choose to do other setup here.
736 : */
737 : static void
738 8 : _PrepParallelRestore(ArchiveHandle *AH)
739 : {
740 : TocEntry *te;
741 :
742 200 : for (te = AH->toc->next; te != AH->toc; te = te->next)
743 : {
744 192 : lclTocEntry *tctx = (lclTocEntry *) te->formatData;
745 : char fname[MAXPGPATH];
746 : struct stat st;
747 :
748 : /*
749 : * A dumpable object has set tctx->filename, any other object has not.
750 : * (see _ArchiveEntry).
751 : */
752 192 : if (tctx->filename == NULL)
753 160 : continue;
754 :
755 : /* We may ignore items not due to be restored */
756 32 : if ((te->reqs & (REQ_DATA | REQ_STATS)) == 0)
757 0 : continue;
758 :
759 : /*
760 : * Stat the file and, if successful, put its size in dataLength. When
761 : * using compression, the physical file size might not be a very good
762 : * guide to the amount of work involved in restoring the file, but we
763 : * only need an approximate indicator of that.
764 : */
765 32 : setFilePath(AH, fname, tctx->filename);
766 :
767 32 : if (stat(fname, &st) == 0)
768 0 : te->dataLength = st.st_size;
769 32 : else if (AH->compression_spec.algorithm != PG_COMPRESSION_NONE)
770 : {
771 32 : if (AH->compression_spec.algorithm == PG_COMPRESSION_GZIP)
772 32 : strlcat(fname, ".gz", sizeof(fname));
773 0 : else if (AH->compression_spec.algorithm == PG_COMPRESSION_LZ4)
774 0 : strlcat(fname, ".lz4", sizeof(fname));
775 0 : else if (AH->compression_spec.algorithm == PG_COMPRESSION_ZSTD)
776 0 : strlcat(fname, ".zst", sizeof(fname));
777 :
778 32 : if (stat(fname, &st) == 0)
779 32 : te->dataLength = st.st_size;
780 : }
781 :
782 : /*
783 : * If this is a BLOBS entry, what we stat'd was blobs_NNN.toc, which
784 : * most likely is a lot smaller than the actual blob data. We don't
785 : * have a cheap way to estimate how much smaller, but fortunately it
786 : * doesn't matter too much as long as we get the LOs processed
787 : * reasonably early. Arbitrarily scale up by a factor of 1K.
788 : */
789 32 : if (strcmp(te->desc, "BLOBS") == 0)
790 0 : te->dataLength *= 1024;
791 : }
792 8 : }
793 :
794 : /*
795 : * Clone format-specific fields during parallel restoration.
796 : */
797 : static void
798 52 : _Clone(ArchiveHandle *AH)
799 : {
800 52 : lclContext *ctx = (lclContext *) AH->formatData;
801 :
802 52 : AH->formatData = (lclContext *) pg_malloc(sizeof(lclContext));
803 52 : memcpy(AH->formatData, ctx, sizeof(lclContext));
804 52 : ctx = (lclContext *) AH->formatData;
805 :
806 : /*
807 : * TOC-entry-local state isn't an issue because any one TOC entry is
808 : * touched by just one worker child.
809 : */
810 :
811 : /*
812 : * We also don't copy the ParallelState pointer (pstate), only the leader
813 : * process ever writes to it.
814 : */
815 52 : }
816 :
817 : static void
818 52 : _DeClone(ArchiveHandle *AH)
819 : {
820 52 : lclContext *ctx = (lclContext *) AH->formatData;
821 :
822 52 : free(ctx);
823 52 : }
824 :
825 : /*
826 : * This function is executed in the child of a parallel backup for a
827 : * directory-format archive and dumps the actual data for one TOC entry.
828 : */
829 : static int
830 272 : _WorkerJobDumpDirectory(ArchiveHandle *AH, TocEntry *te)
831 : {
832 : /*
833 : * This function returns void. We either fail and die horribly or
834 : * succeed... A failure will be detected by the parent when the child dies
835 : * unexpectedly.
836 : */
837 272 : WriteDataChunksForTocEntry(AH, te);
838 :
839 272 : return 0;
840 : }
841 :
842 : /*
843 : * This function is executed in the child of a parallel restore from a
844 : * directory-format archive and restores the actual data for one TOC entry.
845 : */
846 : static int
847 92 : _WorkerJobRestoreDirectory(ArchiveHandle *AH, TocEntry *te)
848 : {
849 92 : return parallel_restore(AH, te);
850 : }
|
