#include "postgres_fe.h"
#include "common/file_utils.h"
#include "compress_io.h"
#include "parallel.h"
#include "pg_backup_utils.h"

Include dependency graph for pg_backup_custom.c:

Data Structures
struct	lclContext

struct	lclTocEntry

Functions
static void	_ArchiveEntry (ArchiveHandle AH, TocEntry te)

static void	_StartData (ArchiveHandle AH, TocEntry te)

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

static void	_EndData (ArchiveHandle AH, TocEntry te)

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	_PrintData (ArchiveHandle *AH)

static void	_skipData (ArchiveHandle *AH)

static void	_skipLOs (ArchiveHandle *AH)

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, bool drop)

static void	_PrepParallelRestore (ArchiveHandle *AH)

static void	_Clone (ArchiveHandle *AH)

static void	_DeClone (ArchiveHandle *AH)

static int	_WorkerJobRestoreCustom (ArchiveHandle AH, TocEntry te)

static void	_readBlockHeader (ArchiveHandle AH, int type, int *id)

static pgoff_t	_getFilePos (ArchiveHandle AH, lclContext ctx)

static void	_CustomWriteFunc (ArchiveHandle AH, const char buf, size_t len)

static size_t	_CustomReadFunc (ArchiveHandle AH, char buf, size_t buflen)

void	InitArchiveFmt_Custom (ArchiveHandle *AH)

Function Documentation

◆ _ArchiveEntry()

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

static

Definition at line 199 of file pg_backup_custom.c.

 {
     lclTocEntry *ctx;
  
     ctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry));
     if (te->dataDumper)
         ctx->dataState = K_OFFSET_POS_NOT_SET;
     else
         ctx->dataState = K_OFFSET_NO_DATA;
  
     te->formatData = (void *) ctx;
 }

References _tocEntry::dataDumper, lclTocEntry::dataState, _tocEntry::formatData, K_OFFSET_NO_DATA, K_OFFSET_POS_NOT_SET, and pg_malloc0().

Referenced by InitArchiveFmt_Custom().

◆ _Clone()

static void _Clone ( ArchiveHandle * AH )

static

Definition at line 881 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     /*
      * Each thread must have private lclContext working state.
      */
     AH->formatData = (lclContext *) pg_malloc(sizeof(lclContext));
     memcpy(AH->formatData, ctx, sizeof(lclContext));
     ctx = (lclContext *) AH->formatData;
  
     /* sanity check, shouldn't happen */
     if (ctx->cs != NULL)
         pg_fatal("compressor active");
  
     /*
      * We intentionally do not clone TOC-entry-local state: it's useful to
      * share knowledge about where the data blocks are across threads.
      * _PrintTocData has to be careful about the order of operations on that
      * state, though.
      */
 }

References lclContext::cs, _archiveHandle::formatData, if(), pg_fatal, and pg_malloc().

Referenced by InitArchiveFmt_Custom().

◆ _CloseArchive()

static void _CloseArchive ( ArchiveHandle * AH )

static

Definition at line 740 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     pgoff_t     tpos;
  
     if (AH->mode == archModeWrite)
     {
         WriteHead(AH);
         /* Remember TOC's seek position for use below */
         tpos = ftello(AH->FH);
         if (tpos < 0 && ctx->hasSeek)
             pg_fatal("could not determine seek position in archive file: %m");
         WriteToc(AH);
         WriteDataChunks(AH, NULL);
  
         /*
          * If possible, re-write the TOC in order to update the data offset
          * information.  This is not essential, as pg_restore can cope in most
          * cases without it; but it can make pg_restore significantly faster
          * in some situations (especially parallel restore).
          */
         if (ctx->hasSeek &&
             fseeko(AH->FH, tpos, SEEK_SET) == 0)
             WriteToc(AH);
     }
  
     if (fclose(AH->FH) != 0)
         pg_fatal("could not close archive file: %m");
  
     /* Sync the output file if one is defined */
     if (AH->dosync && AH->mode == archModeWrite && AH->fSpec)
         (void) fsync_fname(AH->fSpec, false);
  
     AH->FH = NULL;
 }

References archModeWrite, _archiveHandle::dosync, _archiveHandle::FH, _archiveHandle::formatData, fseeko, _archiveHandle::fSpec, fsync_fname(), ftello, lclContext::hasSeek, if(), _archiveHandle::mode, pg_fatal, pgoff_t, WriteDataChunks(), WriteHead(), and WriteToc().

Referenced by InitArchiveFmt_Custom().

◆ _CustomReadFunc()

static size_t _CustomReadFunc	(	ArchiveHandle *	AH,
		char **	buf,
		size_t *	buflen
	)

static

Definition at line 1003 of file pg_backup_custom.c.

 {
     size_t      blkLen;
  
     /* Read length */
     blkLen = ReadInt(AH);
     if (blkLen == 0)
         return 0;
  
     /* If the caller's buffer is not large enough, allocate a bigger one */
     if (blkLen > *buflen)
     {
         free(*buf);
         *buf = (char *) pg_malloc(blkLen);
         *buflen = blkLen;
     }
  
     /* exits app on read errors */
     _ReadBuf(AH, *buf, blkLen);
  
     return blkLen;
 }

References _ReadBuf(), buf, free, pg_malloc(), and ReadInt().

Referenced by _PrintData().

◆ _CustomWriteFunc()

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

static

Definition at line 988 of file pg_backup_custom.c.

 {
     /* never write 0-byte blocks (this should not happen) */
     if (len > 0)
     {
         WriteInt(AH, len);
         _WriteBuf(AH, buf, len);
     }
 }

References _WriteBuf(), buf, len, and WriteInt().

Referenced by _StartData(), and _StartLO().

◆ _DeClone()

static void _DeClone ( ArchiveHandle * AH )

static

Definition at line 905 of file pg_backup_custom.c.

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

References _archiveHandle::formatData, and free.

Referenced by InitArchiveFmt_Custom().

◆ _EndData()

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

static

Definition at line 329 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     EndCompressor(AH, ctx->cs);
     ctx->cs = NULL;
  
     /* Send the end marker */
     WriteInt(AH, 0);
 }

References lclContext::cs, EndCompressor(), _archiveHandle::formatData, and WriteInt().

Referenced by InitArchiveFmt_Custom().

◆ _EndLO()

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

static

Definition at line 391 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     EndCompressor(AH, ctx->cs);
     /* Send the end marker */
     WriteInt(AH, 0);
 }

References lclContext::cs, EndCompressor(), _archiveHandle::formatData, and WriteInt().

Referenced by InitArchiveFmt_Custom().

◆ _EndLOs()

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

static

Definition at line 406 of file pg_backup_custom.c.

 {
     /* Write out a fake zero OID to mark end-of-LOs. */
     WriteInt(AH, 0);
 }

References WriteInt().

Referenced by InitArchiveFmt_Custom().

◆ _getFilePos()

static pgoff_t _getFilePos	(	ArchiveHandle *	AH,
		lclContext *	ctx
	)

static

Definition at line 936 of file pg_backup_custom.c.

 {
     pgoff_t     pos;
  
     pos = ftello(AH->FH);
     if (pos < 0)
     {
         /* Not expected if we found we can seek. */
         if (ctx->hasSeek)
             pg_fatal("could not determine seek position in archive file: %m");
     }
     return pos;
 }

References _archiveHandle::FH, ftello, lclContext::hasSeek, pg_fatal, and pgoff_t.

Referenced by _PrintTocData(), _StartData(), _StartLOs(), and InitArchiveFmt_Custom().

◆ _LoadLOs()

static void _LoadLOs	(	ArchiveHandle *	AH,
		bool	drop
	)

static

Definition at line 580 of file pg_backup_custom.c.

 {
     Oid         oid;
  
     StartRestoreLOs(AH);
  
     oid = ReadInt(AH);
     while (oid != 0)
     {
         StartRestoreLO(AH, oid, drop);
         _PrintData(AH);
         EndRestoreLO(AH, oid);
         oid = ReadInt(AH);
     }
  
     EndRestoreLOs(AH);
 }

References _PrintData(), EndRestoreLO(), EndRestoreLOs(), ReadInt(), StartRestoreLO(), and StartRestoreLOs().

Referenced by _PrintTocData().

◆ _PrepParallelRestore()

static void _PrepParallelRestore ( ArchiveHandle * AH )

static

Definition at line 829 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     TocEntry   *prev_te = NULL;
     lclTocEntry *prev_tctx = NULL;
     TocEntry   *te;
  
     /*
      * Knowing that the data items were dumped out in TOC order, we can
      * reconstruct the length of each item as the delta to the start offset of
      * the next data item.
      */
     for (te = AH->toc->next; te != AH->toc; te = te->next)
     {
         lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
         /*
          * Ignore entries without a known data offset; if we were unable to
          * seek to rewrite the TOC when creating the archive, this'll be all
          * of them, and we'll end up with no size estimates.
          */
         if (tctx->dataState != K_OFFSET_POS_SET)
             continue;
  
         /* Compute previous data item's length */
         if (prev_te)
         {
             if (tctx->dataPos > prev_tctx->dataPos)
                 prev_te->dataLength = tctx->dataPos - prev_tctx->dataPos;
         }
  
         prev_te = te;
         prev_tctx = tctx;
     }
  
     /* If OK to seek, we can determine the length of the last item */
     if (prev_te && ctx->hasSeek)
     {
         pgoff_t     endpos;
  
         if (fseeko(AH->FH, 0, SEEK_END) != 0)
             pg_fatal("error during file seek: %m");
         endpos = ftello(AH->FH);
         if (endpos > prev_tctx->dataPos)
             prev_te->dataLength = endpos - prev_tctx->dataPos;
     }
 }

References lclTocEntry::dataPos, lclTocEntry::dataState, endpos, _archiveHandle::FH, for(), _archiveHandle::formatData, fseeko, ftello, lclContext::hasSeek, if(), K_OFFSET_POS_SET, _tocEntry::next, pg_fatal, pgoff_t, and _archiveHandle::toc.

Referenced by InitArchiveFmt_Custom().

◆ _PrintData()

static void _PrintData ( ArchiveHandle * AH )

static

Definition at line 569 of file pg_backup_custom.c.

 {
     CompressorState *cs;
  
     cs = AllocateCompressor(AH->compression_spec,
                             _CustomReadFunc, NULL);
     cs->readData(AH, cs);
     EndCompressor(AH, cs);
 }

References _CustomReadFunc(), AllocateCompressor(), _archiveHandle::compression_spec, EndCompressor(), and CompressorState::readData.

Referenced by _LoadLOs(), and _PrintTocData().

◆ _PrintExtraToc()

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

static

Definition at line 265 of file pg_backup_custom.c.

 {
     lclTocEntry *ctx = (lclTocEntry *) te->formatData;
  
     if (AH->public.verbose)
         ahprintf(AH, "-- Data Pos: " INT64_FORMAT "\n",
                  (int64) ctx->dataPos);
 }

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

Referenced by InitArchiveFmt_Custom().

◆ _PrintTocData()

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

static

Definition at line 416 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
     int         blkType;
     int         id;
  
     if (tctx->dataState == K_OFFSET_NO_DATA)
         return;
  
     if (!ctx->hasSeek || tctx->dataState == K_OFFSET_POS_NOT_SET)
     {
         /*
          * We cannot seek directly to the desired block.  Instead, skip over
          * block headers until we find the one we want.  Remember the
          * positions of skipped-over blocks, so that if we later decide we
          * need to read one, we'll be able to seek to it.
          *
          * When our input file is seekable, we can do the search starting from
          * the point after the last data block we scanned in previous
          * iterations of this function.
          */
         if (ctx->hasSeek)
         {
             if (fseeko(AH->FH, ctx->lastFilePos, SEEK_SET) != 0)
                 pg_fatal("error during file seek: %m");
         }
  
         for (;;)
         {
             pgoff_t     thisBlkPos = _getFilePos(AH, ctx);
  
             _readBlockHeader(AH, &blkType, &id);
  
             if (blkType == EOF || id == te->dumpId)
                 break;
  
             /* Remember the block position, if we got one */
             if (thisBlkPos >= 0)
             {
                 TocEntry   *otherte = getTocEntryByDumpId(AH, id);
  
                 if (otherte && otherte->formatData)
                 {
                     lclTocEntry *othertctx = (lclTocEntry *) otherte->formatData;
  
                     /*
                      * Note: on Windows, multiple threads might access/update
                      * the same lclTocEntry concurrently, but that should be
                      * safe as long as we update dataPos before dataState.
                      * Ideally, we'd use pg_write_barrier() to enforce that,
                      * but the needed infrastructure doesn't exist in frontend
                      * code.  But Windows only runs on machines with strong
                      * store ordering, so it should be okay for now.
                      */
                     if (othertctx->dataState == K_OFFSET_POS_NOT_SET)
                     {
                         othertctx->dataPos = thisBlkPos;
                         othertctx->dataState = K_OFFSET_POS_SET;
                     }
                     else if (othertctx->dataPos != thisBlkPos ||
                              othertctx->dataState != K_OFFSET_POS_SET)
                     {
                         /* sanity check */
                         pg_log_warning("data block %d has wrong seek position",
                                        id);
                     }
                 }
             }
  
             switch (blkType)
             {
                 case BLK_DATA:
                     _skipData(AH);
                     break;
  
                 case BLK_BLOBS:
                     _skipLOs(AH);
                     break;
  
                 default:        /* Always have a default */
                     pg_fatal("unrecognized data block type (%d) while searching archive",
                              blkType);
                     break;
             }
         }
     }
     else
     {
         /* We can just seek to the place we need to be. */
         if (fseeko(AH->FH, tctx->dataPos, SEEK_SET) != 0)
             pg_fatal("error during file seek: %m");
  
         _readBlockHeader(AH, &blkType, &id);
     }
  
     /*
      * If we reached EOF without finding the block we want, then either it
      * doesn't exist, or it does but we lack the ability to seek back to it.
      */
     if (blkType == EOF)
     {
         if (!ctx->hasSeek)
             pg_fatal("could not find block ID %d in archive -- "
                      "possibly due to out-of-order restore request, "
                      "which cannot be handled due to non-seekable input file",
                      te->dumpId);
         else
             pg_fatal("could not find block ID %d in archive -- "
                      "possibly corrupt archive",
                      te->dumpId);
     }
  
     /* Are we sane? */
     if (id != te->dumpId)
         pg_fatal("found unexpected block ID (%d) when reading data -- expected %d",
                  id, te->dumpId);
  
     switch (blkType)
     {
         case BLK_DATA:
             _PrintData(AH);
             break;
  
         case BLK_BLOBS:
             _LoadLOs(AH, AH->public.ropt->dropSchema);
             break;
  
         default:                /* Always have a default */
             pg_fatal("unrecognized data block type %d while restoring archive",
                      blkType);
             break;
     }
  
     /*
      * If our input file is seekable but lacks data offsets, update our
      * knowledge of where to start future searches from.  (Note that we did
      * not update the current TE's dataState/dataPos.  We could have, but
      * there is no point since it will not be visited again.)
      */
     if (ctx->hasSeek && tctx->dataState == K_OFFSET_POS_NOT_SET)
     {
         pgoff_t     curPos = _getFilePos(AH, ctx);
  
         if (curPos > ctx->lastFilePos)
             ctx->lastFilePos = curPos;
     }
 }

References _getFilePos(), _LoadLOs(), _PrintData(), _readBlockHeader(), _skipData(), _skipLOs(), BLK_BLOBS, BLK_DATA, lclTocEntry::dataPos, lclTocEntry::dataState, _restoreOptions::dropSchema, _tocEntry::dumpId, _archiveHandle::FH, _archiveHandle::formatData, _tocEntry::formatData, fseeko, getTocEntryByDumpId(), lclContext::hasSeek, if(), K_OFFSET_NO_DATA, K_OFFSET_POS_NOT_SET, K_OFFSET_POS_SET, lclContext::lastFilePos, pg_fatal, pg_log_warning, pgoff_t, _archiveHandle::public, and Archive::ropt.

Referenced by InitArchiveFmt_Custom().

◆ _readBlockHeader()

static void _readBlockHeader	(	ArchiveHandle *	AH,
		int *	type,
		int *	id
	)

static

Definition at line 956 of file pg_backup_custom.c.

 {
     int         byt;
  
     /*
      * Note: if we are at EOF with a pre-1.3 input file, we'll pg_fatal()
      * inside ReadInt rather than returning EOF.  It doesn't seem worth
      * jumping through hoops to deal with that case better, because no such
      * files are likely to exist in the wild: only some 7.1 development
      * versions of pg_dump ever generated such files.
      */
     if (AH->version < K_VERS_1_3)
         *type = BLK_DATA;
     else
     {
         byt = getc(AH->FH);
         *type = byt;
         if (byt == EOF)
         {
             *id = 0;            /* don't return an uninitialized value */
             return;
         }
     }
  
     *id = ReadInt(AH);
 }

References BLK_DATA, _archiveHandle::FH, K_VERS_1_3, ReadInt(), type, and _archiveHandle::version.

Referenced by _PrintTocData().

◆ _ReadBuf()

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

static

Definition at line 718 of file pg_backup_custom.c.

 {
     if (fread(buf, 1, len, AH->FH) != len)
         READ_ERROR_EXIT(AH->FH);
 }

References buf, _archiveHandle::FH, len, and READ_ERROR_EXIT.

Referenced by _CustomReadFunc(), and InitArchiveFmt_Custom().

◆ _ReadByte()

static int _ReadByte ( ArchiveHandle * AH )

static

Definition at line 686 of file pg_backup_custom.c.

 {
     int         res;
  
     res = getc(AH->FH);
     if (res == EOF)
         READ_ERROR_EXIT(AH->FH);
     return res;
 }

References _archiveHandle::FH, READ_ERROR_EXIT, and res.

Referenced by InitArchiveFmt_Custom().

◆ _ReadExtraToc()

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

static

Definition at line 238 of file pg_backup_custom.c.

 {
     lclTocEntry *ctx = (lclTocEntry *) te->formatData;
  
     if (ctx == NULL)
     {
         ctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry));
         te->formatData = (void *) ctx;
     }
  
     ctx->dataState = ReadOffset(AH, &(ctx->dataPos));
  
     /*
      * Prior to V1.7 (pg7.3), we dumped the data size as an int now we don't
      * dump it at all.
      */
     if (AH->version < K_VERS_1_7)
         ReadInt(AH);
 }

References lclTocEntry::dataPos, lclTocEntry::dataState, _tocEntry::formatData, if(), K_VERS_1_7, pg_malloc0(), ReadInt(), ReadOffset(), and _archiveHandle::version.

Referenced by InitArchiveFmt_Custom().

◆ _ReopenArchive()

static void _ReopenArchive ( ArchiveHandle * AH )

static

Definition at line 784 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     pgoff_t     tpos;
  
     if (AH->mode == archModeWrite)
         pg_fatal("can only reopen input archives");
  
     /*
      * These two cases are user-facing errors since they represent unsupported
      * (but not invalid) use-cases.  Word the error messages appropriately.
      */
     if (AH->fSpec == NULL || strcmp(AH->fSpec, "") == 0)
         pg_fatal("parallel restore from standard input is not supported");
     if (!ctx->hasSeek)
         pg_fatal("parallel restore from non-seekable file is not supported");
  
     tpos = ftello(AH->FH);
     if (tpos < 0)
         pg_fatal("could not determine seek position in archive file: %m");
  
 #ifndef WIN32
     if (fclose(AH->FH) != 0)
         pg_fatal("could not close archive file: %m");
 #endif
  
     AH->FH = fopen(AH->fSpec, PG_BINARY_R);
     if (!AH->FH)
         pg_fatal("could not open input file \"%s\": %m", AH->fSpec);
  
     if (fseeko(AH->FH, tpos, SEEK_SET) != 0)
         pg_fatal("could not set seek position in archive file: %m");
 }

References archModeWrite, _archiveHandle::FH, _archiveHandle::formatData, fseeko, _archiveHandle::fSpec, ftello, lclContext::hasSeek, if(), _archiveHandle::mode, PG_BINARY_R, pg_fatal, and pgoff_t.

Referenced by InitArchiveFmt_Custom().

◆ _skipData()

static void _skipData ( ArchiveHandle * AH )

static

Definition at line 623 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     size_t      blkLen;
     char       *buf = NULL;
     int         buflen = 0;
  
     blkLen = ReadInt(AH);
     while (blkLen != 0)
     {
         if (ctx->hasSeek)
         {
             if (fseeko(AH->FH, blkLen, SEEK_CUR) != 0)
                 pg_fatal("error during file seek: %m");
         }
         else
         {
             if (blkLen > buflen)
             {
                 free(buf);
                 buf = (char *) pg_malloc(blkLen);
                 buflen = blkLen;
             }
             if (fread(buf, 1, blkLen, AH->FH) != blkLen)
             {
                 if (feof(AH->FH))
                     pg_fatal("could not read from input file: end of file");
                 else
                     pg_fatal("could not read from input file: %m");
             }
         }
  
         blkLen = ReadInt(AH);
     }
  
     free(buf);
 }

References buf, _archiveHandle::FH, _archiveHandle::formatData, free, fseeko, lclContext::hasSeek, pg_fatal, pg_malloc(), and ReadInt().

Referenced by _PrintTocData(), and _skipLOs().

◆ _skipLOs()

static void _skipLOs ( ArchiveHandle * AH )

static

Definition at line 605 of file pg_backup_custom.c.

 {
     Oid         oid;
  
     oid = ReadInt(AH);
     while (oid != 0)
     {
         _skipData(AH);
         oid = ReadInt(AH);
     }
 }

References _skipData(), and ReadInt().

Referenced by _PrintTocData().

◆ _StartData()

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

static

Definition at line 285 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     tctx->dataPos = _getFilePos(AH, ctx);
     if (tctx->dataPos >= 0)
         tctx->dataState = K_OFFSET_POS_SET;
  
     _WriteByte(AH, BLK_DATA);   /* Block type */
     WriteInt(AH, te->dumpId);   /* For sanity check */
  
     ctx->cs = AllocateCompressor(AH->compression_spec,
                                  NULL,
                                  _CustomWriteFunc);
 }

References _CustomWriteFunc(), _getFilePos(), _WriteByte(), AllocateCompressor(), BLK_DATA, _archiveHandle::compression_spec, lclContext::cs, _tocEntry::dumpId, _archiveHandle::formatData, _tocEntry::formatData, K_OFFSET_POS_SET, and WriteInt().

Referenced by InitArchiveFmt_Custom().

◆ _StartLO()

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

static

Definition at line 371 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
  
     if (oid == 0)
         pg_fatal("invalid OID for large object");
  
     WriteInt(AH, oid);
  
     ctx->cs = AllocateCompressor(AH->compression_spec,
                                  NULL,
                                  _CustomWriteFunc);
 }

References _CustomWriteFunc(), AllocateCompressor(), _archiveHandle::compression_spec, lclContext::cs, _archiveHandle::formatData, if(), pg_fatal, and WriteInt().

Referenced by InitArchiveFmt_Custom().

◆ _StartLOs()

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

static

Definition at line 350 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     lclTocEntry *tctx = (lclTocEntry *) te->formatData;
  
     tctx->dataPos = _getFilePos(AH, ctx);
     if (tctx->dataPos >= 0)
         tctx->dataState = K_OFFSET_POS_SET;
  
     _WriteByte(AH, BLK_BLOBS);  /* Block type */
     WriteInt(AH, te->dumpId);   /* For sanity check */
 }

References _getFilePos(), _WriteByte(), BLK_BLOBS, _tocEntry::dumpId, _archiveHandle::formatData, _tocEntry::formatData, K_OFFSET_POS_SET, and WriteInt().

Referenced by InitArchiveFmt_Custom().

◆ _WorkerJobRestoreCustom()

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

static

Definition at line 917 of file pg_backup_custom.c.

 {
     return parallel_restore(AH, te);
 }

References parallel_restore().

Referenced by InitArchiveFmt_Custom().

◆ _WriteBuf()

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

static

Definition at line 704 of file pg_backup_custom.c.

 {
     if (fwrite(buf, 1, len, AH->FH) != len)
         WRITE_ERROR_EXIT;
 }

References buf, _archiveHandle::FH, len, and WRITE_ERROR_EXIT.

Referenced by _CustomWriteFunc(), and InitArchiveFmt_Custom().

◆ _WriteByte()

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

static

Definition at line 669 of file pg_backup_custom.c.

 {
     if (fputc(i, AH->FH) == EOF)
         WRITE_ERROR_EXIT;
  
     return 1;
 }

References _archiveHandle::FH, i, and WRITE_ERROR_EXIT.

Referenced by _StartData(), _StartLOs(), and InitArchiveFmt_Custom().

◆ _WriteData()

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

static

Definition at line 312 of file pg_backup_custom.c.

 {
     lclContext *ctx = (lclContext *) AH->formatData;
     CompressorState *cs = ctx->cs;
  
     if (dLen > 0)
         /* writeData() internally throws write errors */
         cs->writeData(AH, cs, data, dLen);
 }

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

Referenced by InitArchiveFmt_Custom().

◆ _WriteExtraToc()

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

static

Definition at line 222 of file pg_backup_custom.c.

 {
     lclTocEntry *ctx = (lclTocEntry *) te->formatData;
  
     WriteOffset(AH, ctx->dataPos, ctx->dataState);
 }

References lclTocEntry::dataPos, lclTocEntry::dataState, _tocEntry::formatData, and WriteOffset().

Referenced by InitArchiveFmt_Custom().

◆ InitArchiveFmt_Custom()

void InitArchiveFmt_Custom ( ArchiveHandle * AH )

Definition at line 106 of file pg_backup_custom.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;
  
     /* no parallel dump in the custom archive, only parallel restore */
     AH->WorkerJobDumpPtr = NULL;
     AH->WorkerJobRestorePtr = _WorkerJobRestoreCustom;
  
     /* Set up a private area. */
     ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
     AH->formatData = (void *) ctx;
  
     /*
      * Now open the file
      */
     if (AH->mode == archModeWrite)
     {
         if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
         {
             AH->FH = fopen(AH->fSpec, PG_BINARY_W);
             if (!AH->FH)
                 pg_fatal("could not open output file \"%s\": %m", AH->fSpec);
         }
         else
         {
             AH->FH = stdout;
             if (!AH->FH)
                 pg_fatal("could not open output file: %m");
         }
  
         ctx->hasSeek = checkSeek(AH->FH);
     }
     else
     {
         if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
         {
             AH->FH = fopen(AH->fSpec, PG_BINARY_R);
             if (!AH->FH)
                 pg_fatal("could not open input file \"%s\": %m", AH->fSpec);
         }
         else
         {
             AH->FH = stdin;
             if (!AH->FH)
                 pg_fatal("could not open input file: %m");
         }
  
         ctx->hasSeek = checkSeek(AH->FH);
  
         ReadHead(AH);
         ReadToc(AH);
  
         /*
          * Remember location of first data block (i.e., the point after TOC)
          * in case we have to search for desired data blocks.
          */
         ctx->lastFilePos = _getFilePos(AH, ctx);
     }
 }

Referenced by _allocAH().

Data Structures

Functions

Function Documentation

◆ _ArchiveEntry()

◆ _Clone()

◆ _CloseArchive()

◆ _CustomReadFunc()

◆ _CustomWriteFunc()

◆ _DeClone()

◆ _EndData()

◆ _EndLO()

◆ _EndLOs()

◆ _getFilePos()

◆ _LoadLOs()

◆ _PrepParallelRestore()

◆ _PrintData()

◆ _PrintExtraToc()

◆ _PrintTocData()

◆ _readBlockHeader()

◆ _ReadBuf()

◆ _ReadByte()

◆ _ReadExtraToc()

◆ _ReopenArchive()

◆ _skipData()

◆ _skipLOs()

◆ _StartData()

◆ _StartLO()

◆ _StartLOs()

◆ _WorkerJobRestoreCustom()

◆ _WriteBuf()

◆ _WriteByte()

◆ _WriteData()

◆ _WriteExtraToc()

◆ InitArchiveFmt_Custom()