#include "postgres_fe.h"
#include "common/file_utils.h"
#include "compress_io.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 198 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 = 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 889 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 746 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).  We can skip this
         * step if we're not dumping any data; there are no offsets to update
         * in that case.
         */
        if (ctx->hasSeek && AH->public.dopt->dumpData &&
            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, Archive::dopt, _archiveHandle::dosync, _dumpOptions::dumpData, _archiveHandle::FH, _archiveHandle::formatData, fseeko, _archiveHandle::fSpec, fsync_fname(), ftello, lclContext::hasSeek, if(), _archiveHandle::mode, pg_fatal, pgoff_t, _archiveHandle::public, WriteDataChunks(), WriteHead(), and WriteToc().

Referenced by InitArchiveFmt_Custom().

◆ _CustomReadFunc()

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

static

Definition at line 1011 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 996 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 913 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 328 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 390 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 405 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 944 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 579 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 837 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 568 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 264 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 415 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 964 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 724 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 692 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, and READ_ERROR_EXIT.

Referenced by InitArchiveFmt_Custom().

◆ _ReadExtraToc()

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

static

Definition at line 237 of file pg_backup_custom.c.

{
    lclTocEntry *ctx = (lclTocEntry *) te->formatData;
 
    if (ctx == NULL)
    {
        ctx = (lclTocEntry *) pg_malloc0(sizeof(lclTocEntry));
        te->formatData = 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 792 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 622 of file pg_backup_custom.c.

{
    lclContext *ctx = (lclContext *) AH->formatData;
    size_t      blkLen;
    char       *buf = NULL;
    size_t      buflen = 0;
 
    blkLen = ReadInt(AH);
    while (blkLen != 0)
    {
        /*
         * Seeks of less than stdio's buffer size are less efficient than just
         * reading the data, at least on common platforms.  We don't know the
         * buffer size for sure, but 4kB is the usual value.  (While pg_dump
         * currently tries to avoid producing such short data blocks, older
         * dump files often contain them.)
         */
        if (ctx->hasSeek && blkLen >= 4 * 1024)
        {
            if (fseeko(AH->FH, blkLen, SEEK_CUR) != 0)
                pg_fatal("error during file seek: %m");
        }
        else
        {
            if (blkLen > buflen)
            {
                free(buf);
                buflen = Max(blkLen, 4 * 1024);
                buf = (char *) pg_malloc(buflen);
            }
            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, Max, pg_fatal, pg_malloc(), and ReadInt().

Referenced by _PrintTocData(), and _skipLOs().

◆ _skipLOs()

static void _skipLOs ( ArchiveHandle * AH )

static

Definition at line 604 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 284 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 370 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 349 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 925 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 710 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 675 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 311 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 221 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 105 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 = 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()