#include "postgres_fe.h"
#include <dirent.h>
#include <sys/stat.h>
#include "common/file_utils.h"
#include "compress_io.h"
#include "parallel.h"
#include "pg_backup_utils.h"

Include dependency graph for pg_backup_directory.c:

Data Structures
struct	lclContext

struct	lclTocEntry

Functions
static void	_ArchiveEntry (ArchiveHandle AH, TocEntry te)

static void	_StartData (ArchiveHandle AH, TocEntry te)

static void	_EndData (ArchiveHandle AH, TocEntry te)

static void	_WriteData (ArchiveHandle AH, const void data, size_t dLen)

static int	_WriteByte (ArchiveHandle *AH, const int i)

static int	_ReadByte (ArchiveHandle *AH)

static void	_WriteBuf (ArchiveHandle AH, const void buf, size_t len)

static void	_ReadBuf (ArchiveHandle AH, void buf, size_t len)

static void	_CloseArchive (ArchiveHandle *AH)

static void	_ReopenArchive (ArchiveHandle *AH)

static void	_PrintTocData (ArchiveHandle AH, TocEntry te)

static void	_WriteExtraToc (ArchiveHandle AH, TocEntry te)

static void	_ReadExtraToc (ArchiveHandle AH, TocEntry te)

static void	_PrintExtraToc (ArchiveHandle AH, TocEntry te)

static void	_StartLOs (ArchiveHandle AH, TocEntry te)

static void	_StartLO (ArchiveHandle AH, TocEntry te, Oid oid)

static void	_EndLO (ArchiveHandle AH, TocEntry te, Oid oid)

static void	_EndLOs (ArchiveHandle AH, TocEntry te)

static void	_LoadLOs (ArchiveHandle *AH)

static void	_PrepParallelRestore (ArchiveHandle *AH)

static void	_Clone (ArchiveHandle *AH)

static void	_DeClone (ArchiveHandle *AH)

static int	_WorkerJobRestoreDirectory (ArchiveHandle AH, TocEntry te)

static int	_WorkerJobDumpDirectory (ArchiveHandle AH, TocEntry te)

static void	setFilePath (ArchiveHandle AH, char buf, const char *relativeFilename)

void	InitArchiveFmt_Directory (ArchiveHandle *AH)

static void	_PrintFileData (ArchiveHandle AH, char filename)

Function Documentation

◆ _ArchiveEntry()

static void _ArchiveEntry	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 232 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx;
     char        fn[MAXPGPATH];
  
     tctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry));
     if (strcmp(te->desc, "BLOBS") == 0)
         tctx->filename = pg_strdup("blobs.toc");
     else if (te->dataDumper)
     {
         snprintf(fn, MAXPGPATH, "%d.dat", te->dumpId);
         tctx->filename = pg_strdup(fn);
     }
     else
         tctx->filename = NULL;
  
     te->formatData = (void *) tctx;
 }

References _tocEntry::dataDumper, _tocEntry::desc, _tocEntry::dumpId, lclTocEntry::filename, fn(), _tocEntry::formatData, MAXPGPATH, pg_malloc0(), pg_strdup(), and snprintf.

Referenced by InitArchiveFmt_Directory().

◆ _Clone()

static void _Clone ( ArchiveHandle * AH )

static

Definition at line 817 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     AH->formatData = (lclContext *) pg_malloc(sizeof(lclContext));
     memcpy(AH->formatData, ctx, sizeof(lclContext));
     ctx = (lclContext *) AH->formatData;
  
     /*
      * Note: we do not make a local lo_buf because we expect at most one BLOBS
      * entry per archive, so no parallelism is possible.  Likewise,
      * TOC-entry-local state isn't an issue because any one TOC entry is
      * touched by just one worker child.
      */
  
     /*
      * We also don't copy the ParallelState pointer (pstate), only the leader
      * process ever writes to it.
      */
 }

References _archiveHandle::formatData, and pg_malloc().

Referenced by InitArchiveFmt_Directory().

◆ _CloseArchive()

static void _CloseArchive ( ArchiveHandle * AH )

static

Definition at line 574 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     if (AH->mode == archModeWrite)
     {
         CompressFileHandle *tocFH;
         pg_compress_specification compression_spec = {0};
         char        fname[MAXPGPATH];
  
         setFilePath(AH, fname, "toc.dat");
  
         /* this will actually fork the processes for a parallel backup */
         ctx->pstate = ParallelBackupStart(AH);
  
         /* The TOC is always created uncompressed */
         compression_spec.algorithm = PG_COMPRESSION_NONE;
         tocFH = InitCompressFileHandle(compression_spec);
         if (!tocFH->open_write_func(fname, PG_BINARY_W, tocFH))
             pg_fatal("could not open output file \"%s\": %m", fname);
         ctx->dataFH = tocFH;
  
         /*
          * Write 'tar' in the format field of the toc.dat file. The directory
          * is compatible with 'tar', so there's no point having a different
          * format code for it.
          */
         AH->format = archTar;
         WriteHead(AH);
         AH->format = archDirectory;
         WriteToc(AH);
         if (!EndCompressFileHandle(tocFH))
             pg_fatal("could not close TOC file: %m");
         WriteDataChunks(AH, ctx->pstate);
  
         ParallelBackupEnd(AH, ctx->pstate);
  
         /*
          * In directory mode, there is no need to sync all the entries
          * individually. Just recurse once through all the files generated.
          */
         if (AH->dosync)
             sync_dir_recurse(ctx->directory, AH->sync_method);
     }
     AH->FH = NULL;
 }

References pg_compress_specification::algorithm, archDirectory, archModeWrite, archTar, lclContext::dataFH, lclContext::directory, _archiveHandle::dosync, EndCompressFileHandle(), _archiveHandle::FH, _archiveHandle::format, _archiveHandle::formatData, if(), InitCompressFileHandle(), MAXPGPATH, _archiveHandle::mode, CompressFileHandle::open_write_func, ParallelBackupEnd(), ParallelBackupStart(), PG_BINARY_W, PG_COMPRESSION_NONE, pg_fatal, lclContext::pstate, setFilePath(), _archiveHandle::sync_method, WriteDataChunks(), WriteHead(), and WriteToc().

Referenced by InitArchiveFmt_Directory().

◆ _DeClone()

static void _DeClone ( ArchiveHandle * AH )

static

Definition at line 839 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     free(ctx);
 }

References _archiveHandle::formatData, and free.

Referenced by InitArchiveFmt_Directory().

◆ _EndData()

static void _EndData	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 368 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     /* Close the file */
     if (!EndCompressFileHandle(ctx->dataFH))
         pg_fatal("could not close data file: %m");
  
     ctx->dataFH = NULL;
 }

References lclContext::dataFH, EndCompressFileHandle(), _archiveHandle::formatData, if(), and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _EndLO()

static void _EndLO	(	ArchiveHandle *	AH,
		TocEntry *	te,
		Oid	oid
	)

static

Definition at line 685 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     CompressFileHandle *CFH = ctx->LOsTocFH;
     char        buf[50];
     int         len;
  
     /* Close the BLOB data file itself */
     if (!EndCompressFileHandle(ctx->dataFH))
         pg_fatal("could not close LO data file: %m");
     ctx->dataFH = NULL;
  
     /* register the LO in blobs.toc */
     len = snprintf(buf, sizeof(buf), "%u blob_%u.dat\n", oid, oid);
     if (!CFH->write_func(buf, len, CFH))
     {
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         pg_fatal("could not write to LOs TOC file: %s",
                  CFH->get_error_func(CFH));
     }
 }

References buf, lclContext::dataFH, EndCompressFileHandle(), _archiveHandle::formatData, if(), len, lclContext::LOsTocFH, pg_fatal, and snprintf.

Referenced by InitArchiveFmt_Directory().

◆ _EndLOs()

static void _EndLOs	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 715 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     if (!EndCompressFileHandle(ctx->LOsTocFH))
         pg_fatal("could not close LOs TOC file: %m");
     ctx->LOsTocFH = NULL;
 }

References EndCompressFileHandle(), _archiveHandle::formatData, if(), lclContext::LOsTocFH, and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _LoadLOs()

static void _LoadLOs ( ArchiveHandle * AH )

static

Definition at line 433 of file pg_backup_directory.c.

 {
     Oid         oid;
     lclContext *ctx = (lclContext *) AH->formatData;
     CompressFileHandle *CFH;
     char        tocfname[MAXPGPATH];
     char        line[MAXPGPATH];
  
     StartRestoreLOs(AH);
  
     setFilePath(AH, tocfname, "blobs.toc");
  
     CFH = ctx->LOsTocFH = InitDiscoverCompressFileHandle(tocfname, PG_BINARY_R);
  
     if (ctx->LOsTocFH == NULL)
         pg_fatal("could not open large object TOC file \"%s\" for input: %m",
                  tocfname);
  
     /* Read the LOs TOC file line-by-line, and process each LO */
     while ((CFH->gets_func(line, MAXPGPATH, CFH)) != NULL)
     {
         char        lofname[MAXPGPATH + 1];
         char        path[MAXPGPATH];
  
         /* Can't overflow because line and lofname are the same length */
         if (sscanf(line, "%u %" CppAsString2(MAXPGPATH) "s\n", &oid, lofname) != 2)
             pg_fatal("invalid line in large object TOC file \"%s\": \"%s\"",
                      tocfname, line);
  
         StartRestoreLO(AH, oid, AH->public.ropt->dropSchema);
         snprintf(path, MAXPGPATH, "%s/%s", ctx->directory, lofname);
         _PrintFileData(AH, path);
         EndRestoreLO(AH, oid);
     }
     if (!CFH->eof_func(CFH))
         pg_fatal("error reading large object TOC file \"%s\"",
                  tocfname);
  
     if (!EndCompressFileHandle(ctx->LOsTocFH))
         pg_fatal("could not close large object TOC file \"%s\": %m",
                  tocfname);
  
     ctx->LOsTocFH = NULL;
  
     EndRestoreLOs(AH);
 }

References _PrintFileData(), CppAsString2, lclContext::directory, _restoreOptions::dropSchema, EndCompressFileHandle(), EndRestoreLO(), EndRestoreLOs(), _archiveHandle::formatData, InitDiscoverCompressFileHandle(), lclContext::LOsTocFH, MAXPGPATH, PG_BINARY_R, pg_fatal, _archiveHandle::public, Archive::ropt, setFilePath(), snprintf, StartRestoreLO(), and StartRestoreLOs().

Referenced by _PrintTocData().

◆ _PrepParallelRestore()

static void _PrepParallelRestore ( ArchiveHandle * AH )

static

Definition at line 757 of file pg_backup_directory.c.

 {
     TocEntry   *te;
  
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         lclTocEntry *tctx = (lclTocEntry *) te->formatData;
         char        fname[MAXPGPATH];
         struct stat st;
  
         /*
          * A dumpable object has set tctx->filename, any other object has not.
          * (see _ArchiveEntry).
          */
         if (tctx->filename == NULL)
             continue;
  
         /* We may ignore items not due to be restored */
         if ((te->reqs & REQ_DATA) == 0)
             continue;
  
         /*
          * Stat the file and, if successful, put its size in dataLength.  When
          * using compression, the physical file size might not be a very good
          * guide to the amount of work involved in restoring the file, but we
          * only need an approximate indicator of that.
          */
         setFilePath(AH, fname, tctx->filename);
  
         if (stat(fname, &st) == 0)
             te->dataLength = st.st_size;
         else if (AH->compression_spec.algorithm != PG_COMPRESSION_NONE)
         {
             if (AH->compression_spec.algorithm == PG_COMPRESSION_GZIP)
                 strlcat(fname, ".gz", sizeof(fname));
             else if (AH->compression_spec.algorithm == PG_COMPRESSION_LZ4)
                 strlcat(fname, ".lz4", sizeof(fname));
             else if (AH->compression_spec.algorithm == PG_COMPRESSION_ZSTD)
                 strlcat(fname, ".zst", sizeof(fname));
  
             if (stat(fname, &st) == 0)
                 te->dataLength = st.st_size;
         }
  
         /*
          * If this is the BLOBS entry, what we stat'd was blobs.toc, which
          * most likely is a lot smaller than the actual blob data.  We don't
          * have a cheap way to estimate how much smaller, but fortunately it
          * doesn't matter too much as long as we get the LOs processed
          * reasonably early.  Arbitrarily scale up by a factor of 1K.
          */
         if (strcmp(te->desc, "BLOBS") == 0)
             te->dataLength *= 1024;
     }
 }

References pg_compress_specification::algorithm, _archiveHandle::compression_spec, _tocEntry::dataLength, _tocEntry::desc, lclTocEntry::filename, _tocEntry::formatData, if(), MAXPGPATH, _tocEntry::next, PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_ZSTD, REQ_DATA, _tocEntry::reqs, setFilePath(), stat, strlcat(), and _archiveHandle::toc.

Referenced by InitArchiveFmt_Directory().

◆ _PrintExtraToc()

static void _PrintExtraToc	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 303 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     if (AH->public.verbose && tctx->filename)
         ahprintf(AH, "-- File: %s\n", tctx->filename);
 }

References ahprintf(), lclTocEntry::filename, _tocEntry::formatData, if(), _archiveHandle::public, and Archive::verbose.

Referenced by InitArchiveFmt_Directory().

◆ _PrintFileData()

static void _PrintFileData	(	ArchiveHandle *	AH,
		char *	filename
	)

static

Definition at line 383 of file pg_backup_directory.c.

 {
     size_t      cnt = 0;
     char       *buf;
     size_t      buflen;
     CompressFileHandle *CFH;
  
     if (!filename)
         return;
  
     CFH = InitDiscoverCompressFileHandle(filename, PG_BINARY_R);
     if (!CFH)
         pg_fatal("could not open input file \"%s\": %m", filename);
  
     buflen = DEFAULT_IO_BUFFER_SIZE;
     buf = pg_malloc(buflen);
  
     while (CFH->read_func(buf, buflen, &cnt, CFH) && cnt > 0)
     {
         ahwrite(buf, 1, cnt, AH);
     }
  
     free(buf);
     if (!EndCompressFileHandle(CFH))
         pg_fatal("could not close data file \"%s\": %m", filename);
 }

References ahwrite(), buf, DEFAULT_IO_BUFFER_SIZE, EndCompressFileHandle(), filename, free, InitDiscoverCompressFileHandle(), PG_BINARY_R, pg_fatal, pg_malloc(), and CompressFileHandle::read_func.

Referenced by _LoadLOs(), and _PrintTocData().

◆ _PrintTocData()

static void _PrintTocData	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 414 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     if (!tctx->filename)
         return;
  
     if (strcmp(te->desc, "BLOBS") == 0)
         _LoadLOs(AH);
     else
     {
         char        fname[MAXPGPATH];
  
         setFilePath(AH, fname, tctx->filename);
         _PrintFileData(AH, fname);
     }
 }

References _LoadLOs(), _PrintFileData(), _tocEntry::desc, lclTocEntry::filename, _tocEntry::formatData, if(), MAXPGPATH, and setFilePath().

Referenced by InitArchiveFmt_Directory().

◆ _ReadBuf()

static void _ReadBuf	(	ArchiveHandle *	AH,
		void *	buf,
		size_t	len
	)

static

Definition at line 548 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     CompressFileHandle *CFH = ctx->dataFH;
  
     /*
      * If there was an I/O error, we already exited in readF(), so here we
      * exit on short reads.
      */
     if (!CFH->read_func(buf, len, NULL, CFH))
         pg_fatal("could not read from input file: end of file");
 }

References buf, lclContext::dataFH, _archiveHandle::formatData, if(), len, and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _ReadByte()

static int _ReadByte ( ArchiveHandle * AH )

static

Definition at line 513 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     CompressFileHandle *CFH = ctx->dataFH;
  
     return CFH->getc_func(CFH);
 }

References lclContext::dataFH, _archiveHandle::formatData, and CompressFileHandle::getc_func.

Referenced by InitArchiveFmt_Directory().

◆ _ReadExtraToc()

static void _ReadExtraToc	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 280 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     if (tctx == NULL)
     {
         tctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry));
         te->formatData = (void *) tctx;
     }
  
     tctx->filename = ReadStr(AH);
     if (strlen(tctx->filename) == 0)
     {
         free(tctx->filename);
         tctx->filename = NULL;
     }
 }

References lclTocEntry::filename, _tocEntry::formatData, free, if(), pg_malloc0(), and ReadStr().

Referenced by InitArchiveFmt_Directory().

◆ _ReopenArchive()

static void _ReopenArchive ( ArchiveHandle * AH )

static

Definition at line 625 of file pg_backup_directory.c.

 {
     /*
      * Our TOC is in memory, our data files are opened by each child anyway as
      * they are separate. We support reopening the archive by just doing
      * nothing.
      */
 }

Referenced by InitArchiveFmt_Directory().

◆ _StartData()

static void _StartData	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 321 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
     lclContext *ctx = (lclContext *) AH->formatData;
     char        fname[MAXPGPATH];
  
     setFilePath(AH, fname, tctx->filename);
  
     ctx->dataFH = InitCompressFileHandle(AH->compression_spec);
  
     if (!ctx->dataFH->open_write_func(fname, PG_BINARY_W, ctx->dataFH))
         pg_fatal("could not open output file \"%s\": %m", fname);
 }

References _archiveHandle::compression_spec, lclTocEntry::filename, _archiveHandle::formatData, _tocEntry::formatData, InitCompressFileHandle(), MAXPGPATH, PG_BINARY_W, pg_fatal, and setFilePath().

Referenced by InitArchiveFmt_Directory().

◆ _StartLO()

static void _StartLO	(	ArchiveHandle *	AH,
		TocEntry *	te,
		Oid	oid
	)

static

Definition at line 667 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     char        fname[MAXPGPATH];
  
     snprintf(fname, MAXPGPATH, "%s/blob_%u.dat", ctx->directory, oid);
  
     ctx->dataFH = InitCompressFileHandle(AH->compression_spec);
     if (!ctx->dataFH->open_write_func(fname, PG_BINARY_W, ctx->dataFH))
         pg_fatal("could not open output file \"%s\": %m", fname);
 }

References _archiveHandle::compression_spec, lclContext::dataFH, lclContext::directory, _archiveHandle::formatData, InitCompressFileHandle(), MAXPGPATH, CompressFileHandle::open_write_func, PG_BINARY_W, pg_fatal, and snprintf.

Referenced by InitArchiveFmt_Directory().

◆ _StartLOs()

static void _StartLOs	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 646 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     pg_compress_specification compression_spec = {0};
     char        fname[MAXPGPATH];
  
     setFilePath(AH, fname, "blobs.toc");
  
     /* The LO TOC file is never compressed */
     compression_spec.algorithm = PG_COMPRESSION_NONE;
     ctx->LOsTocFH = InitCompressFileHandle(compression_spec);
     if (!ctx->LOsTocFH->open_write_func(fname, "ab", ctx->LOsTocFH))
         pg_fatal("could not open output file \"%s\": %m", fname);
 }

References _archiveHandle::formatData.

Referenced by InitArchiveFmt_Directory().

◆ _WorkerJobDumpDirectory()

static int _WorkerJobDumpDirectory	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 851 of file pg_backup_directory.c.

 {
     /*
      * This function returns void. We either fail and die horribly or
      * succeed... A failure will be detected by the parent when the child dies
      * unexpectedly.
      */
     WriteDataChunksForTocEntry(AH, te);
  
     return 0;
 }

References WriteDataChunksForTocEntry().

Referenced by InitArchiveFmt_Directory().

◆ _WorkerJobRestoreDirectory()

static int _WorkerJobRestoreDirectory	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 868 of file pg_backup_directory.c.

 {
     return parallel_restore(AH, te);
 }

References parallel_restore().

Referenced by InitArchiveFmt_Directory().

◆ _WriteBuf()

static void _WriteBuf	(	ArchiveHandle *	AH,
		const void *	buf,
		size_t	len
	)

static

Definition at line 526 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     CompressFileHandle *CFH = ctx->dataFH;
  
     errno = 0;
     if (!CFH->write_func(buf, len, CFH))
     {
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         pg_fatal("could not write to output file: %s",
                  CFH->get_error_func(CFH));
     }
 }

References buf, lclContext::dataFH, _archiveHandle::formatData, if(), len, and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _WriteByte()

static int _WriteByte	(	ArchiveHandle *	AH,
		const int	i
	)

static

Definition at line 487 of file pg_backup_directory.c.

 {
     unsigned char c = (unsigned char) i;
     lclContext *ctx = (lclContext *) AH->formatData;
     CompressFileHandle *CFH = ctx->dataFH;
  
     errno = 0;
     if (!CFH->write_func(&c, 1, CFH))
     {
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         pg_fatal("could not write to output file: %s",
                  CFH->get_error_func(CFH));
     }
  
     return 1;
 }

References lclContext::dataFH, _archiveHandle::formatData, i, if(), and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _WriteData()

static void _WriteData	(	ArchiveHandle *	AH,
		const void *	data,
		size_t	dLen
	)

static

Definition at line 345 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     CompressFileHandle *CFH = ctx->dataFH;
  
     errno = 0;
     if (dLen > 0 && !CFH->write_func(data, dLen, CFH))
     {
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         pg_fatal("could not write to output file: %s",
                  CFH->get_error_func(CFH));
     }
 }

References data, lclContext::dataFH, _archiveHandle::formatData, if(), and pg_fatal.

Referenced by InitArchiveFmt_Directory().

◆ _WriteExtraToc()

static void _WriteExtraToc	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

static

Definition at line 259 of file pg_backup_directory.c.

 {
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     /*
      * A dumpable object has set tctx->filename, any other object has not.
      * (see _ArchiveEntry).
      */
     if (tctx->filename)
         WriteStr(AH, tctx->filename);
     else
         WriteStr(AH, "");
 }

References lclTocEntry::filename, _tocEntry::formatData, if(), and WriteStr().

Referenced by InitArchiveFmt_Directory().

◆ InitArchiveFmt_Directory()

void InitArchiveFmt_Directory ( ArchiveHandle * AH )

Definition at line 107 of file pg_backup_directory.c.

 {
     lclContext *ctx;
  
     /* Assuming static functions, this can be copied for each format. */
     AH->ArchiveEntryPtr = _ArchiveEntry;
     AH->StartDataPtr = _StartData;
     AH->WriteDataPtr = _WriteData;
     AH->EndDataPtr = _EndData;
     AH->WriteBytePtr = _WriteByte;
     AH->ReadBytePtr = _ReadByte;
     AH->WriteBufPtr = _WriteBuf;
     AH->ReadBufPtr = _ReadBuf;
     AH->ClosePtr = _CloseArchive;
     AH->ReopenPtr = _ReopenArchive;
     AH->PrintTocDataPtr = _PrintTocData;
     AH->ReadExtraTocPtr = _ReadExtraToc;
     AH->WriteExtraTocPtr = _WriteExtraToc;
     AH->PrintExtraTocPtr = _PrintExtraToc;
  
     AH->StartLOsPtr = _StartLOs;
     AH->StartLOPtr = _StartLO;
     AH->EndLOPtr = _EndLO;
     AH->EndLOsPtr = _EndLOs;
  
     AH->PrepParallelRestorePtr = _PrepParallelRestore;
     AH->ClonePtr = _Clone;
     AH->DeClonePtr = _DeClone;
  
     AH->WorkerJobRestorePtr = _WorkerJobRestoreDirectory;
     AH->WorkerJobDumpPtr = _WorkerJobDumpDirectory;
  
     /* Set up our private context */
     ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
     AH->formatData = (void *) ctx;
  
     ctx->dataFH = NULL;
     ctx->LOsTocFH = NULL;
  
     /* Initialize LO buffering */
     AH->lo_buf_size = LOBBUFSIZE;
     AH->lo_buf = (void *) pg_malloc(LOBBUFSIZE);
  
     /*
      * Now open the TOC file
      */
  
     if (!AH->fSpec || strcmp(AH->fSpec, "") == 0)
         pg_fatal("no output directory specified");
  
     ctx->directory = AH->fSpec;
  
     if (AH->mode == archModeWrite)
     {
         struct stat st;
         bool        is_empty = false;
  
         /* we accept an empty existing directory */
         if (stat(ctx->directory, &st) == 0 && S_ISDIR(st.st_mode))
         {
             DIR        *dir = opendir(ctx->directory);
  
             if (dir)
             {
                 struct dirent *d;
  
                 is_empty = true;
                 while (errno = 0, (d = readdir(dir)))
                 {
                     if (strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0)
                     {
                         is_empty = false;
                         break;
                     }
                 }
  
                 if (errno)
                     pg_fatal("could not read directory \"%s\": %m",
                              ctx->directory);
  
                 if (closedir(dir))
                     pg_fatal("could not close directory \"%s\": %m",
                              ctx->directory);
             }
         }
  
         if (!is_empty && mkdir(ctx->directory, 0700) < 0)
             pg_fatal("could not create directory \"%s\": %m",
                      ctx->directory);
     }
     else
     {                           /* Read Mode */
         char        fname[MAXPGPATH];
         CompressFileHandle *tocFH;
  
         setFilePath(AH, fname, "toc.dat");
  
         tocFH = InitDiscoverCompressFileHandle(fname, PG_BINARY_R);
         if (tocFH == NULL)
             pg_fatal("could not open input file \"%s\": %m", fname);
  
         ctx->dataFH = tocFH;
  
         /*
          * The TOC of a directory format dump shares the format code of the
          * tar format.
          */
         AH->format = archTar;
         ReadHead(AH);
         AH->format = archDirectory;
         ReadToc(AH);
  
         /* Nothing else in the file, so close it again... */
         if (!EndCompressFileHandle(tocFH))
             pg_fatal("could not close TOC file: %m");
         ctx->dataFH = NULL;
     }
 }

Referenced by _allocAH().

◆ setFilePath()

static void setFilePath	(	ArchiveHandle *	AH,
		char *	buf,
		const char *	relativeFilename
	)

static

Definition at line 731 of file pg_backup_directory.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     char       *dname;
  
     dname = ctx->directory;
  
     if (strlen(dname) + 1 + strlen(relativeFilename) + 1 > MAXPGPATH)
         pg_fatal("file name too long: \"%s\"", dname);
  
     strcpy(buf, dname);
     strcat(buf, "/");
     strcat(buf, relativeFilename);
 }

References buf, lclContext::directory, _archiveHandle::formatData, if(), MAXPGPATH, and pg_fatal.

Referenced by _CloseArchive(), _LoadLOs(), _PrepParallelRestore(), _PrintTocData(), _StartData(), and InitArchiveFmt_Directory().

Data Structures

Functions

Function Documentation

◆ _ArchiveEntry()

◆ _Clone()

◆ _CloseArchive()

◆ _DeClone()

◆ _EndData()

◆ _EndLO()

◆ _EndLOs()

◆ _LoadLOs()

◆ _PrepParallelRestore()

◆ _PrintExtraToc()

◆ _PrintFileData()

◆ _PrintTocData()

◆ _ReadBuf()

◆ _ReadByte()

◆ _ReadExtraToc()

◆ _ReopenArchive()

◆ _StartData()

◆ _StartLO()

◆ _StartLOs()

◆ _WorkerJobDumpDirectory()

◆ _WorkerJobRestoreDirectory()

◆ _WriteBuf()

◆ _WriteByte()

◆ _WriteData()

◆ _WriteExtraToc()

◆ InitArchiveFmt_Directory()

◆ setFilePath()