blkreftable.h File Reference

#include "storage/block.h"
#include "storage/relfilelocator.h"

Include dependency graph for blkreftable.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	BLOCKREFTABLE_MAGIC   0x652b137b

Typedefs
typedef struct BlockRefTable	BlockRefTable
typedef struct BlockRefTableEntry	BlockRefTableEntry
typedef struct BlockRefTableReader	BlockRefTableReader
typedef struct BlockRefTableWriter	BlockRefTableWriter
typedef size_t(*	io_callback_fn) (void *callback_arg, void *data, size_t length)
typedef void(*	report_error_fn) (void *callback_arg, char *msg,...) pg_attribute_printf(2
typedef void(*) BlockRefTable	CreateEmptyBlockRefTable) (void)

Functions
void	BlockRefTableSetLimitBlock (BlockRefTable *brtab, const RelFileLocator *rlocator, ForkNumber forknum, BlockNumber limit_block)
void	BlockRefTableMarkBlockModified (BlockRefTable *brtab, const RelFileLocator *rlocator, ForkNumber forknum, BlockNumber blknum)
void	WriteBlockRefTable (BlockRefTable *brtab, io_callback_fn write_callback, void *write_callback_arg)
BlockRefTableEntry *	BlockRefTableGetEntry (BlockRefTable *brtab, const RelFileLocator *rlocator, ForkNumber forknum, BlockNumber *limit_block)
int	BlockRefTableEntryGetBlocks (BlockRefTableEntry *entry, BlockNumber start_blkno, BlockNumber stop_blkno, BlockNumber *blocks, int nblocks)
BlockRefTableReader *	CreateBlockRefTableReader (io_callback_fn read_callback, void *read_callback_arg, char *error_filename, report_error_fn error_callback, void *error_callback_arg)
bool	BlockRefTableReaderNextRelation (BlockRefTableReader *reader, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *limit_block)
unsigned	BlockRefTableReaderGetBlocks (BlockRefTableReader *reader, BlockNumber *blocks, int nblocks)
void	DestroyBlockRefTableReader (BlockRefTableReader *reader)
BlockRefTableWriter *	CreateBlockRefTableWriter (io_callback_fn write_callback, void *write_callback_arg)
void	BlockRefTableWriteEntry (BlockRefTableWriter *writer, BlockRefTableEntry *entry)
void	DestroyBlockRefTableWriter (BlockRefTableWriter *writer)
BlockRefTableEntry *	CreateBlockRefTableEntry (RelFileLocator rlocator, ForkNumber forknum)
void	BlockRefTableEntrySetLimitBlock (BlockRefTableEntry *entry, BlockNumber limit_block)
void	BlockRefTableEntryMarkBlockModified (BlockRefTableEntry *entry, ForkNumber forknum, BlockNumber blknum)
void	BlockRefTableFreeEntry (BlockRefTableEntry *entry)

Macro Definition Documentation

BLOCKREFTABLE_MAGIC

#define BLOCKREFTABLE_MAGIC   0x652b137b

Definition at line 30 of file blkreftable.h.

Typedef Documentation

BlockRefTable

typedef struct BlockRefTable BlockRefTable

Definition at line 32 of file blkreftable.h.

BlockRefTableEntry

typedef struct BlockRefTableEntry BlockRefTableEntry

Definition at line 33 of file blkreftable.h.

BlockRefTableReader

typedef struct BlockRefTableReader BlockRefTableReader

Definition at line 34 of file blkreftable.h.

BlockRefTableWriter

typedef struct BlockRefTableWriter BlockRefTableWriter

Definition at line 35 of file blkreftable.h.

CreateEmptyBlockRefTable

typedef void(*) BlockRefTable CreateEmptyBlockRefTable) (void)

extern

io_callback_fn

typedef size_t(* io_callback_fn) (void *callback_arg, void *data, size_t length)

Definition at line 46 of file blkreftable.h.

report_error_fn

typedef void(* report_error_fn) (void *callback_arg, char *msg,...) pg_attribute_printf(2

Definition at line 47 of file blkreftable.h.

Function Documentation

BlockRefTableEntryGetBlocks()

int BlockRefTableEntryGetBlocks ( BlockRefTableEntry *  entry, BlockNumber  start_blkno, BlockNumber  stop_blkno, BlockNumber *  blocks, int  nblocks  )

extern

Definition at line 369 of file blkreftable.c.

{
    uint32      start_chunkno;
    uint32      stop_chunkno;
    uint32      chunkno;
    int         nresults = 0;
 
    Assert(entry != NULL);
 
    /*
     * Figure out which chunks could potentially contain blocks of interest.
     *
     * We need to be careful about overflow here, because stop_blkno could be
     * InvalidBlockNumber or something very close to it.
     */
    start_chunkno = start_blkno / BLOCKS_PER_CHUNK;
    stop_chunkno = stop_blkno / BLOCKS_PER_CHUNK;
    if ((stop_blkno % BLOCKS_PER_CHUNK) != 0)
        ++stop_chunkno;
    if (stop_chunkno > entry->nchunks)
        stop_chunkno = entry->nchunks;
 
    /*
     * Loop over chunks.
     */
    for (chunkno = start_chunkno; chunkno < stop_chunkno; ++chunkno)
    {
        uint16      chunk_usage = entry->chunk_usage[chunkno];
        BlockRefTableChunk chunk_data = entry->chunk_data[chunkno];
        unsigned    start_offset = 0;
        unsigned    stop_offset = BLOCKS_PER_CHUNK;
 
        /*
         * If the start and/or stop block number falls within this chunk, the
         * whole chunk may not be of interest. Figure out which portion we
         * care about, if it's not the whole thing.
         */
        if (chunkno == start_chunkno)
            start_offset = start_blkno % BLOCKS_PER_CHUNK;
        if (chunkno == stop_chunkno - 1)
        {
            Assert(stop_blkno > chunkno * BLOCKS_PER_CHUNK);
            stop_offset = stop_blkno - (chunkno * BLOCKS_PER_CHUNK);
            Assert(stop_offset <= BLOCKS_PER_CHUNK);
        }
 
        /*
         * Handling differs depending on whether this is an array of offsets
         * or a bitmap.
         */
        if (chunk_usage == MAX_ENTRIES_PER_CHUNK)
        {
            unsigned    i;
 
            /* It's a bitmap, so test every relevant bit. */
            for (i = start_offset; i < stop_offset; ++i)
            {
                uint16      w = chunk_data[i / BLOCKS_PER_ENTRY];
 
                if ((w & (1 << (i % BLOCKS_PER_ENTRY))) != 0)
                {
                    BlockNumber blkno = chunkno * BLOCKS_PER_CHUNK + i;
 
                    blocks[nresults++] = blkno;
 
                    /* Early exit if we run out of output space. */
                    if (nresults == nblocks)
                        return nresults;
                }
            }
        }
        else
        {
            unsigned    i;
 
            /* It's an array of offsets, so check each one. */
            for (i = 0; i < chunk_usage; ++i)
            {
                uint16      offset = chunk_data[i];
 
                if (offset >= start_offset && offset < stop_offset)
                {
                    BlockNumber blkno = chunkno * BLOCKS_PER_CHUNK + offset;
 
                    blocks[nresults++] = blkno;
 
                    /* Early exit if we run out of output space. */
                    if (nresults == nblocks)
                        return nresults;
                }
            }
        }
    }
 
    return nresults;
}

References Assert, BLOCKS_PER_CHUNK, BLOCKS_PER_ENTRY, BlockRefTableEntry::chunk_data, BlockRefTableEntry::chunk_usage, fb(), i, MAX_ENTRIES_PER_CHUNK, and BlockRefTableEntry::nchunks.

Referenced by GetFileBackupMethod().

BlockRefTableEntryMarkBlockModified()

void BlockRefTableEntryMarkBlockModified ( BlockRefTableEntry *  entry, ForkNumber  forknum, BlockNumber  blknum  )

extern

Definition at line 1001 of file blkreftable.c.

{
    unsigned    chunkno;
    unsigned    chunkoffset;
    unsigned    i;
 
    /*
     * Which chunk should store the state of this block? And what is the
     * offset of this block relative to the start of that chunk?
     */
    chunkno = blknum / BLOCKS_PER_CHUNK;
    chunkoffset = blknum % BLOCKS_PER_CHUNK;
 
    /*
     * If 'nchunks' isn't big enough for us to be able to represent the state
     * of this block, we need to enlarge our arrays.
     */
    if (chunkno >= entry->nchunks)
    {
        unsigned    max_chunks;
        unsigned    extra_chunks;
 
        /*
         * New array size is a power of 2, at least 16, big enough so that
         * chunkno will be a valid array index.
         */
        max_chunks = Max(16, entry->nchunks);
        while (max_chunks < chunkno + 1)
            max_chunks *= 2;
        extra_chunks = max_chunks - entry->nchunks;
 
        if (entry->nchunks == 0)
        {
            entry->chunk_size = palloc0_array(uint16, max_chunks);
            entry->chunk_usage = palloc0_array(uint16, max_chunks);
            entry->chunk_data = palloc0_array(BlockRefTableChunk, max_chunks);
        }
        else
        {
            entry->chunk_size = repalloc(entry->chunk_size,
                                         sizeof(uint16) * max_chunks);
            memset(&entry->chunk_size[entry->nchunks], 0,
                   extra_chunks * sizeof(uint16));
            entry->chunk_usage = repalloc(entry->chunk_usage,
                                          sizeof(uint16) * max_chunks);
            memset(&entry->chunk_usage[entry->nchunks], 0,
                   extra_chunks * sizeof(uint16));
            entry->chunk_data = repalloc(entry->chunk_data,
                                         sizeof(BlockRefTableChunk) * max_chunks);
            memset(&entry->chunk_data[entry->nchunks], 0,
                   extra_chunks * sizeof(BlockRefTableChunk));
        }
        entry->nchunks = max_chunks;
    }
 
    /*
     * If the chunk that covers this block number doesn't exist yet, create it
     * as an array and add the appropriate offset to it. We make it pretty
     * small initially, because there might only be 1 or a few block
     * references in this chunk and we don't want to use up too much memory.
     */
    if (entry->chunk_size[chunkno] == 0)
    {
        entry->chunk_data[chunkno] =
            palloc_array(uint16, INITIAL_ENTRIES_PER_CHUNK);
        entry->chunk_size[chunkno] = INITIAL_ENTRIES_PER_CHUNK;
        entry->chunk_data[chunkno][0] = chunkoffset;
        entry->chunk_usage[chunkno] = 1;
        return;
    }
 
    /*
     * If the number of entries in this chunk is already maximum, it must be a
     * bitmap. Just set the appropriate bit.
     */
    if (entry->chunk_usage[chunkno] == MAX_ENTRIES_PER_CHUNK)
    {
        BlockRefTableChunk chunk = entry->chunk_data[chunkno];
 
        chunk[chunkoffset / BLOCKS_PER_ENTRY] |=
            1 << (chunkoffset % BLOCKS_PER_ENTRY);
        return;
    }
 
    /*
     * There is an existing chunk and it's in array format. Let's find out
     * whether it already has an entry for this block. If so, we do not need
     * to do anything.
     */
    for (i = 0; i < entry->chunk_usage[chunkno]; ++i)
    {
        if (entry->chunk_data[chunkno][i] == chunkoffset)
            return;
    }
 
    /*
     * If the number of entries currently used is one less than the maximum,
     * it's time to convert to bitmap format.
     */
    if (entry->chunk_usage[chunkno] == MAX_ENTRIES_PER_CHUNK - 1)
    {
        BlockRefTableChunk newchunk;
        unsigned    j;
 
        /* Allocate a new chunk. */
        newchunk = palloc0(MAX_ENTRIES_PER_CHUNK * sizeof(uint16));
 
        /* Set the bit for each existing entry. */
        for (j = 0; j < entry->chunk_usage[chunkno]; ++j)
        {
            unsigned    coff = entry->chunk_data[chunkno][j];
 
            newchunk[coff / BLOCKS_PER_ENTRY] |=
                1 << (coff % BLOCKS_PER_ENTRY);
        }
 
        /* Set the bit for the new entry. */
        newchunk[chunkoffset / BLOCKS_PER_ENTRY] |=
            1 << (chunkoffset % BLOCKS_PER_ENTRY);
 
        /* Swap the new chunk into place and update metadata. */
        pfree(entry->chunk_data[chunkno]);
        entry->chunk_data[chunkno] = newchunk;
        entry->chunk_size[chunkno] = MAX_ENTRIES_PER_CHUNK;
        entry->chunk_usage[chunkno] = MAX_ENTRIES_PER_CHUNK;
        return;
    }
 
    /*
     * OK, we currently have an array, and we don't need to convert to a
     * bitmap, but we do need to add a new element. If there's not enough
     * room, we'll have to expand the array.
     */
    if (entry->chunk_usage[chunkno] == entry->chunk_size[chunkno])
    {
        unsigned    newsize = entry->chunk_size[chunkno] * 2;
 
        Assert(newsize <= MAX_ENTRIES_PER_CHUNK);
        entry->chunk_data[chunkno] = repalloc(entry->chunk_data[chunkno],
                                              newsize * sizeof(uint16));
        entry->chunk_size[chunkno] = newsize;
    }
 
    /* Now we can add the new entry. */
    entry->chunk_data[chunkno][entry->chunk_usage[chunkno]] =
        chunkoffset;
    entry->chunk_usage[chunkno]++;
}

References Assert, BLOCKS_PER_CHUNK, BLOCKS_PER_ENTRY, BlockRefTableEntry::chunk_data, BlockRefTableEntry::chunk_size, BlockRefTableEntry::chunk_usage, fb(), i, INITIAL_ENTRIES_PER_CHUNK, j, Max, MAX_ENTRIES_PER_CHUNK, BlockRefTableEntry::nchunks, palloc0(), palloc0_array, palloc_array, pfree(), and repalloc().

Referenced by BlockRefTableMarkBlockModified().

BlockRefTableEntrySetLimitBlock()

void BlockRefTableEntrySetLimitBlock ( BlockRefTableEntry *  entry, BlockNumber  limit_block  )

extern

Definition at line 930 of file blkreftable.c.

{
    unsigned    chunkno;
    unsigned    limit_chunkno;
    unsigned    limit_chunkoffset;
    BlockRefTableChunk limit_chunk;
 
    /* If we already have an equal or lower limit block, do nothing. */
    if (limit_block >= entry->limit_block)
        return;
 
    /* Record the new limit block value. */
    entry->limit_block = limit_block;
 
    /*
     * Figure out which chunk would store the state of the new limit block,
     * and which offset within that chunk.
     */
    limit_chunkno = limit_block / BLOCKS_PER_CHUNK;
    limit_chunkoffset = limit_block % BLOCKS_PER_CHUNK;
 
    /*
     * If the number of chunks is not large enough for any blocks with equal
     * or higher block numbers to exist, then there is nothing further to do.
     */
    if (limit_chunkno >= entry->nchunks)
        return;
 
    /* Discard entire contents of any higher-numbered chunks. */
    for (chunkno = limit_chunkno + 1; chunkno < entry->nchunks; ++chunkno)
        entry->chunk_usage[chunkno] = 0;
 
    /*
     * Next, we need to discard any offsets within the chunk that would
     * contain the limit_block. We must handle this differently depending on
     * whether the chunk that would contain limit_block is a bitmap or an
     * array of offsets.
     */
    limit_chunk = entry->chunk_data[limit_chunkno];
    if (entry->chunk_usage[limit_chunkno] == MAX_ENTRIES_PER_CHUNK)
    {
        unsigned    chunkoffset;
 
        /* It's a bitmap. Unset bits. */
        for (chunkoffset = limit_chunkoffset; chunkoffset < BLOCKS_PER_CHUNK;
             ++chunkoffset)
            limit_chunk[chunkoffset / BLOCKS_PER_ENTRY] &=
                ~(1 << (chunkoffset % BLOCKS_PER_ENTRY));
    }
    else
    {
        unsigned    i,
                    j = 0;
 
        /* It's an offset array. Filter out large offsets. */
        for (i = 0; i < entry->chunk_usage[limit_chunkno]; ++i)
        {
            Assert(j <= i);
            if (limit_chunk[i] < limit_chunkoffset)
                limit_chunk[j++] = limit_chunk[i];
        }
        Assert(j <= entry->chunk_usage[limit_chunkno]);
        entry->chunk_usage[limit_chunkno] = j;
    }
}

References Assert, BLOCKS_PER_CHUNK, BLOCKS_PER_ENTRY, BlockRefTableEntry::chunk_data, BlockRefTableEntry::chunk_usage, fb(), i, j, BlockRefTableEntry::limit_block, MAX_ENTRIES_PER_CHUNK, and BlockRefTableEntry::nchunks.

Referenced by BlockRefTableSetLimitBlock().

BlockRefTableFreeEntry()

void BlockRefTableFreeEntry ( BlockRefTableEntry *  entry )

extern

Definition at line 1157 of file blkreftable.c.

{
    if (entry->chunk_size != NULL)
    {
        pfree(entry->chunk_size);
        entry->chunk_size = NULL;
    }
 
    if (entry->chunk_usage != NULL)
    {
        pfree(entry->chunk_usage);
        entry->chunk_usage = NULL;
    }
 
    if (entry->chunk_data != NULL)
    {
        pfree(entry->chunk_data);
        entry->chunk_data = NULL;
    }
 
    pfree(entry);
}

References BlockRefTableEntry::chunk_data, BlockRefTableEntry::chunk_size, BlockRefTableEntry::chunk_usage, fb(), and pfree().

BlockRefTableGetEntry()

BlockRefTableEntry * BlockRefTableGetEntry ( BlockRefTable *  brtab, const RelFileLocator *  rlocator, ForkNumber  forknum, BlockNumber *  limit_block  )

extern

Definition at line 340 of file blkreftable.c.

{
    BlockRefTableKey key = {0}; /* make sure any padding is zero */
    BlockRefTableEntry *entry;
 
    Assert(limit_block != NULL);
 
    memcpy(&key.rlocator, rlocator, sizeof(RelFileLocator));
    key.forknum = forknum;
    entry = blockreftable_lookup(brtab->hash, key);
 
    if (entry != NULL)
        *limit_block = entry->limit_block;
 
    return entry;
}

References Assert, fb(), BlockRefTable::hash, BlockRefTableEntry::limit_block, and memcpy().

Referenced by GetFileBackupMethod().

BlockRefTableMarkBlockModified()

void BlockRefTableMarkBlockModified ( BlockRefTable *  brtab, const RelFileLocator *  rlocator, ForkNumber  forknum, BlockNumber  blknum  )

extern

Definition at line 297 of file blkreftable.c.

{
    BlockRefTableEntry *brtentry;
    BlockRefTableKey key = {0}; /* make sure any padding is zero */
    bool        found;
#ifndef FRONTEND
    MemoryContext oldcontext = MemoryContextSwitchTo(brtab->mcxt);
#endif
 
    memcpy(&key.rlocator, rlocator, sizeof(RelFileLocator));
    key.forknum = forknum;
    brtentry = blockreftable_insert(brtab->hash, key, &found);
 
    if (!found)
    {
        /*
         * We want to set the initial limit block value to something higher
         * than any legal block number. InvalidBlockNumber fits the bill.
         */
        brtentry->limit_block = InvalidBlockNumber;
        brtentry->nchunks = 0;
        brtentry->chunk_size = NULL;
        brtentry->chunk_usage = NULL;
        brtentry->chunk_data = NULL;
    }
 
    BlockRefTableEntryMarkBlockModified(brtentry, forknum, blknum);
 
#ifndef FRONTEND
    MemoryContextSwitchTo(oldcontext);
#endif
}

References BlockRefTableEntryMarkBlockModified(), fb(), BlockRefTable::hash, InvalidBlockNumber, BlockRefTable::mcxt, memcpy(), and MemoryContextSwitchTo().

Referenced by PrepareForIncrementalBackup(), and SummarizeWAL().

BlockRefTableReaderGetBlocks()

unsigned BlockRefTableReaderGetBlocks ( BlockRefTableReader *  reader, BlockNumber *  blocks, int  nblocks  )

extern

Definition at line 725 of file blkreftable.c.

{
    unsigned    blocks_found = 0;
 
    /* Must provide space for at least one block number to be returned. */
    Assert(nblocks > 0);
 
    /* Loop collecting blocks to return to caller. */
    for (;;)
    {
        uint16      next_chunk_size;
 
        /*
         * If we've read at least one chunk, maybe it contains some block
         * numbers that could satisfy caller's request.
         */
        if (reader->consumed_chunks > 0)
        {
            uint32      chunkno = reader->consumed_chunks - 1;
            uint16      chunk_size = reader->chunk_size[chunkno];
 
            if (chunk_size == MAX_ENTRIES_PER_CHUNK)
            {
                /* Bitmap format, so search for bits that are set. */
                while (reader->chunk_position < BLOCKS_PER_CHUNK &&
                       blocks_found < nblocks)
                {
                    uint16      chunkoffset = reader->chunk_position;
                    uint16      w;
 
                    w = reader->chunk_data[chunkoffset / BLOCKS_PER_ENTRY];
                    if ((w & (1u << (chunkoffset % BLOCKS_PER_ENTRY))) != 0)
                        blocks[blocks_found++] =
                            chunkno * BLOCKS_PER_CHUNK + chunkoffset;
                    ++reader->chunk_position;
                }
            }
            else
            {
                /* Not in bitmap format, so each entry is a 2-byte offset. */
                while (reader->chunk_position < chunk_size &&
                       blocks_found < nblocks)
                {
                    blocks[blocks_found++] = chunkno * BLOCKS_PER_CHUNK
                        + reader->chunk_data[reader->chunk_position];
                    ++reader->chunk_position;
                }
            }
        }
 
        /* We found enough blocks, so we're done. */
        if (blocks_found >= nblocks)
            break;
 
        /*
         * We didn't find enough blocks, so we must need the next chunk. If
         * there are none left, though, then we're done anyway.
         */
        if (reader->consumed_chunks == reader->total_chunks)
            break;
 
        /*
         * Read data for next chunk and reset scan position to beginning of
         * chunk. Note that the next chunk might be empty, in which case we
         * consume the chunk without actually consuming any bytes from the
         * underlying file.
         */
        next_chunk_size = reader->chunk_size[reader->consumed_chunks];
        if (next_chunk_size > 0)
            BlockRefTableRead(reader, reader->chunk_data,
                              next_chunk_size * sizeof(uint16));
        ++reader->consumed_chunks;
        reader->chunk_position = 0;
    }
 
    return blocks_found;
}

References Assert, BlockRefTableRead(), BLOCKS_PER_CHUNK, BLOCKS_PER_ENTRY, BlockRefTableReader::chunk_data, BlockRefTableReader::chunk_position, BlockRefTableReader::chunk_size, BlockRefTableReader::consumed_chunks, fb(), MAX_ENTRIES_PER_CHUNK, and BlockRefTableReader::total_chunks.

Referenced by dump_one_relation(), pg_wal_summary_contents(), and PrepareForIncrementalBackup().

BlockRefTableReaderNextRelation()

bool BlockRefTableReaderNextRelation ( BlockRefTableReader *  reader, RelFileLocator *  rlocator, ForkNumber *  forknum, BlockNumber *  limit_block  )

extern

Definition at line 613 of file blkreftable.c.

{
    BlockRefTableSerializedEntry sentry;
    BlockRefTableSerializedEntry zentry = {0};
 
    /*
     * Sanity check: caller must read all blocks from all chunks before moving
     * on to the next relation.
     */
    Assert(reader->total_chunks == reader->consumed_chunks);
 
    /* Read serialized entry. */
    BlockRefTableRead(reader, &sentry,
                      sizeof(BlockRefTableSerializedEntry));
 
    /*
     * If we just read the sentinel entry indicating that we've reached the
     * end, read and check the CRC.
     */
    if (memcmp(&sentry, &zentry, sizeof(BlockRefTableSerializedEntry)) == 0)
    {
        pg_crc32c   expected_crc;
        pg_crc32c   actual_crc;
 
        /*
         * We want to know the CRC of the file excluding the 4-byte CRC
         * itself, so copy the current value of the CRC accumulator before
         * reading those bytes, and use the copy to finalize the calculation.
         */
        expected_crc = reader->buffer.crc;
        FIN_CRC32C(expected_crc);
 
        /* Now we can read the actual value. */
        BlockRefTableRead(reader, &actual_crc, sizeof(pg_crc32c));
 
        /* Throw an error if there is a mismatch. */
        if (!EQ_CRC32C(expected_crc, actual_crc))
            reader->error_callback(reader->error_callback_arg,
                                   "file \"%s\" has wrong checksum: expected %08X, found %08X",
                                   reader->error_filename, expected_crc, actual_crc);
 
        return false;
    }
 
    /* Sanity-check the fork number. */
    if (sentry.forknum < 0 || sentry.forknum > MAX_FORKNUM)
    {
        reader->error_callback(reader->error_callback_arg,
                               "file \"%s\" has invalid fork number %d",
                               reader->error_filename, sentry.forknum);
        return false;
    }
 
    /*
     * Sanity-check the nchunks value.  In the backend, palloc_array would
     * enforce this anyway (with a more generic error message); but in
     * frontend it would not, potentially allowing BlockRefTableRead's length
     * parameter to overflow.
     */
    if (sentry.nchunks > MaxAllocSize / sizeof(uint16))
    {
        reader->error_callback(reader->error_callback_arg,
                               "file \"%s\" has oversized chunk size array",
                               reader->error_filename);
        return false;
    }
 
    /* Read chunk size array. */
    if (reader->chunk_size != NULL)
        pfree(reader->chunk_size);
    reader->chunk_size = palloc_array(uint16, sentry.nchunks);
    BlockRefTableRead(reader, reader->chunk_size,
                      sentry.nchunks * sizeof(uint16));
 
    /* Sanity-check the chunk sizes. */
    for (unsigned i = 0; i < sentry.nchunks; ++i)
    {
        if (reader->chunk_size[i] > MAX_ENTRIES_PER_CHUNK)
        {
            reader->error_callback(reader->error_callback_arg,
                                   "file \"%s\" chunk %u has invalid size %u",
                                   reader->error_filename, i,
                                   (unsigned) reader->chunk_size[i]);
            return false;
        }
    }
 
    /* Set up for chunk scan. */
    reader->total_chunks = sentry.nchunks;
    reader->consumed_chunks = 0;
 
    /* Return data to caller. */
    memcpy(rlocator, &sentry.rlocator, sizeof(RelFileLocator));
    *forknum = sentry.forknum;
    *limit_block = sentry.limit_block;
    return true;
}

References Assert, BlockRefTableRead(), BlockRefTableReader::buffer, BlockRefTableReader::chunk_size, BlockRefTableReader::consumed_chunks, BlockRefTableBuffer::crc, EQ_CRC32C, BlockRefTableReader::error_callback, BlockRefTableReader::error_callback_arg, BlockRefTableReader::error_filename, fb(), FIN_CRC32C, i, MAX_ENTRIES_PER_CHUNK, MAX_FORKNUM, MaxAllocSize, memcpy(), palloc_array, pfree(), and BlockRefTableReader::total_chunks.

Referenced by main(), pg_wal_summary_contents(), and PrepareForIncrementalBackup().

BlockRefTableSetLimitBlock()

void BlockRefTableSetLimitBlock ( BlockRefTable *  brtab, const RelFileLocator *  rlocator, ForkNumber  forknum, BlockNumber  limit_block  )

extern

Definition at line 262 of file blkreftable.c.

{
    BlockRefTableEntry *brtentry;
    BlockRefTableKey key = {0}; /* make sure any padding is zero */
    bool        found;
 
    memcpy(&key.rlocator, rlocator, sizeof(RelFileLocator));
    key.forknum = forknum;
    brtentry = blockreftable_insert(brtab->hash, key, &found);
 
    if (!found)
    {
        /*
         * We have no existing data about this relation fork, so just record
         * the limit_block value supplied by the caller, and make sure other
         * parts of the entry are properly initialized.
         */
        brtentry->limit_block = limit_block;
        brtentry->nchunks = 0;
        brtentry->chunk_size = NULL;
        brtentry->chunk_usage = NULL;
        brtentry->chunk_data = NULL;
        return;
    }
 
    BlockRefTableEntrySetLimitBlock(brtentry, limit_block);
}

References BlockRefTableEntrySetLimitBlock(), fb(), BlockRefTable::hash, and memcpy().

Referenced by PrepareForIncrementalBackup(), SummarizeDbaseRecord(), SummarizeSmgrRecord(), and SummarizeXactRecord().

BlockRefTableWriteEntry()

void BlockRefTableWriteEntry ( BlockRefTableWriter *  writer, BlockRefTableEntry *  entry  )

extern

Definition at line 853 of file blkreftable.c.

{
    BlockRefTableSerializedEntry sentry;
    unsigned    j;
 
    /* Convert to serialized entry format. */
    sentry.rlocator = entry->key.rlocator;
    sentry.forknum = entry->key.forknum;
    sentry.limit_block = entry->limit_block;
    sentry.nchunks = entry->nchunks;
 
    /* Trim trailing zero entries. */
    while (sentry.nchunks > 0 && entry->chunk_usage[sentry.nchunks - 1] == 0)
        sentry.nchunks--;
 
    /* Write the serialized entry itself. */
    BlockRefTableWrite(&writer->buffer, &sentry,
                       sizeof(BlockRefTableSerializedEntry));
 
    /* Write the untruncated portion of the chunk length array. */
    if (sentry.nchunks != 0)
        BlockRefTableWrite(&writer->buffer, entry->chunk_usage,
                           sentry.nchunks * sizeof(uint16));
 
    /* Write the contents of each chunk. */
    for (j = 0; j < entry->nchunks; ++j)
    {
        if (entry->chunk_usage[j] == 0)
            continue;
        BlockRefTableWrite(&writer->buffer, entry->chunk_data[j],
                           entry->chunk_usage[j] * sizeof(uint16));
    }
}

References BlockRefTableWrite(), BlockRefTableEntry::chunk_data, BlockRefTableEntry::chunk_usage, fb(), BlockRefTableKey::forknum, j, BlockRefTableEntry::key, BlockRefTableEntry::limit_block, BlockRefTableEntry::nchunks, BlockRefTableKey::rlocator, and BlockRefTableSerializedEntry::rlocator.

CreateBlockRefTableEntry()

BlockRefTableEntry * CreateBlockRefTableEntry ( RelFileLocator  rlocator, ForkNumber  forknum  )

extern

Definition at line 911 of file blkreftable.c.

{
    BlockRefTableEntry *entry = palloc0_object(BlockRefTableEntry);
 
    memcpy(&entry->key.rlocator, &rlocator, sizeof(RelFileLocator));
    entry->key.forknum = forknum;
    entry->limit_block = InvalidBlockNumber;
 
    return entry;
}

References BlockRefTableKey::forknum, InvalidBlockNumber, BlockRefTableEntry::key, BlockRefTableEntry::limit_block, memcpy(), palloc0_object, and BlockRefTableKey::rlocator.

CreateBlockRefTableReader()

BlockRefTableReader * CreateBlockRefTableReader ( io_callback_fn  read_callback, void *  read_callback_arg, char *  error_filename, report_error_fn  error_callback, void *  error_callback_arg  )

extern

Definition at line 577 of file blkreftable.c.

{
    BlockRefTableReader *reader;
    uint32      magic;
 
    /* Initialize data structure. */
    reader = palloc0_object(BlockRefTableReader);
    reader->buffer.io_callback = read_callback;
    reader->buffer.io_callback_arg = read_callback_arg;
    reader->error_filename = error_filename;
    reader->error_callback = error_callback;
    reader->error_callback_arg = error_callback_arg;
    INIT_CRC32C(reader->buffer.crc);
 
    /* Verify magic number. */
    BlockRefTableRead(reader, &magic, sizeof(uint32));
    if (magic != BLOCKREFTABLE_MAGIC)
        error_callback(error_callback_arg,
                       "file \"%s\" has wrong magic number: expected %u, found %u",
                       error_filename,
                       BLOCKREFTABLE_MAGIC, magic);
 
    return reader;
}

References BLOCKREFTABLE_MAGIC, BlockRefTableRead(), BlockRefTableReader::buffer, BlockRefTableBuffer::crc, BlockRefTableReader::error_callback, BlockRefTableReader::error_callback_arg, BlockRefTableReader::error_filename, fb(), INIT_CRC32C, BlockRefTableBuffer::io_callback, BlockRefTableBuffer::io_callback_arg, and palloc0_object.

Referenced by main(), pg_wal_summary_contents(), and PrepareForIncrementalBackup().

CreateBlockRefTableWriter()

BlockRefTableWriter * CreateBlockRefTableWriter ( io_callback_fn  write_callback, void *  write_callback_arg  )

extern

Definition at line 826 of file blkreftable.c.

{
    BlockRefTableWriter *writer;
    uint32      magic = BLOCKREFTABLE_MAGIC;
 
    /* Prepare buffer and CRC check and save callbacks. */
    writer = palloc0_object(BlockRefTableWriter);
    writer->buffer.io_callback = write_callback;
    writer->buffer.io_callback_arg = write_callback_arg;
    INIT_CRC32C(writer->buffer.crc);
 
    /* Write magic number. */
    BlockRefTableWrite(&writer->buffer, &magic, sizeof(uint32));
 
    return writer;
}

References BLOCKREFTABLE_MAGIC, BlockRefTableWrite(), fb(), INIT_CRC32C, and palloc0_object.

DestroyBlockRefTableReader()

void DestroyBlockRefTableReader ( BlockRefTableReader *  reader )

extern

Definition at line 809 of file blkreftable.c.

{
    if (reader->chunk_size != NULL)
    {
        pfree(reader->chunk_size);
        reader->chunk_size = NULL;
    }
    pfree(reader);
}

References BlockRefTableReader::chunk_size, fb(), and pfree().

Referenced by main(), pg_wal_summary_contents(), and PrepareForIncrementalBackup().

DestroyBlockRefTableWriter()

void DestroyBlockRefTableWriter ( BlockRefTableWriter *  writer )

extern

Definition at line 891 of file blkreftable.c.

{
    BlockRefTableFileTerminate(&writer->buffer);
    pfree(writer);
}

References BlockRefTableFileTerminate(), fb(), and pfree().

WriteBlockRefTable()

void WriteBlockRefTable ( BlockRefTable *  brtab, io_callback_fn  write_callback, void *  write_callback_arg  )

extern

Definition at line 474 of file blkreftable.c.

{
    BlockRefTableSerializedEntry *sdata = NULL;
    BlockRefTableBuffer buffer;
    uint32      magic = BLOCKREFTABLE_MAGIC;
 
    /* Prepare buffer. */
    memset(&buffer, 0, sizeof(BlockRefTableBuffer));
    buffer.io_callback = write_callback;
    buffer.io_callback_arg = write_callback_arg;
    INIT_CRC32C(buffer.crc);
 
    /* Write magic number. */
    BlockRefTableWrite(&buffer, &magic, sizeof(uint32));
 
    /* Write the entries, assuming there are some. */
    if (brtab->hash->members > 0)
    {
        unsigned    i = 0;
        blockreftable_iterator it;
        BlockRefTableEntry *brtentry;
 
        /* Extract entries into serializable format and sort them. */
        sdata =
            palloc_array(BlockRefTableSerializedEntry, brtab->hash->members);
        blockreftable_start_iterate(brtab->hash, &it);
        while ((brtentry = blockreftable_iterate(brtab->hash, &it)) != NULL)
        {
            BlockRefTableSerializedEntry *sentry = &sdata[i++];
 
            sentry->rlocator = brtentry->key.rlocator;
            sentry->forknum = brtentry->key.forknum;
            sentry->limit_block = brtentry->limit_block;
            sentry->nchunks = brtentry->nchunks;
 
            /* trim trailing zero entries */
            while (sentry->nchunks > 0 &&
                   brtentry->chunk_usage[sentry->nchunks - 1] == 0)
                sentry->nchunks--;
        }
        Assert(i == brtab->hash->members);
        qsort(sdata, i, sizeof(BlockRefTableSerializedEntry),
              BlockRefTableComparator);
 
        /* Loop over entries in sorted order and serialize each one. */
        for (i = 0; i < brtab->hash->members; ++i)
        {
            BlockRefTableSerializedEntry *sentry = &sdata[i];
            BlockRefTableKey key = {0}; /* make sure any padding is zero */
            unsigned    j;
 
            /* Write the serialized entry itself. */
            BlockRefTableWrite(&buffer, sentry,
                               sizeof(BlockRefTableSerializedEntry));
 
            /* Look up the original entry so we can access the chunks. */
            memcpy(&key.rlocator, &sentry->rlocator, sizeof(RelFileLocator));
            key.forknum = sentry->forknum;
            brtentry = blockreftable_lookup(brtab->hash, key);
            Assert(brtentry != NULL);
 
            /* Write the untruncated portion of the chunk length array. */
            if (sentry->nchunks != 0)
                BlockRefTableWrite(&buffer, brtentry->chunk_usage,
                                   sentry->nchunks * sizeof(uint16));
 
            /* Write the contents of each chunk. */
            for (j = 0; j < brtentry->nchunks; ++j)
            {
                if (brtentry->chunk_usage[j] == 0)
                    continue;
                BlockRefTableWrite(&buffer, brtentry->chunk_data[j],
                                   brtentry->chunk_usage[j] * sizeof(uint16));
            }
        }
    }
 
    /* Write out appropriate terminator and CRC and flush buffer. */
    BlockRefTableFileTerminate(&buffer);
}

References Assert, BLOCKREFTABLE_MAGIC, BlockRefTableComparator(), BlockRefTableFileTerminate(), BlockRefTableWrite(), BlockRefTableBuffer::crc, fb(), BlockRefTable::hash, i, INIT_CRC32C, BlockRefTableBuffer::io_callback, BlockRefTableBuffer::io_callback_arg, j, memcpy(), palloc_array, qsort, and BlockRefTableSerializedEntry::rlocator.

Referenced by SummarizeWAL().