blkreftable.c File Reference

#include "postgres.h"
#include "common/blkreftable.h"
#include "common/hashfn.h"
#include "port/pg_crc32c.h"
#include "lib/simplehash.h"

Include dependency graph for blkreftable.c:

Go to the source code of this file.

Data Structures
struct	BlockRefTableKey
struct	BlockRefTableEntry
struct	BlockRefTable
struct	BlockRefTableSerializedEntry
struct	BlockRefTableBuffer
struct	BlockRefTableReader
struct	BlockRefTableWriter

Macros
#define	BLOCKS_PER_CHUNK   (1 << 16)
#define	BLOCKS_PER_ENTRY   (BITS_PER_BYTE * sizeof(uint16))
#define	MAX_ENTRIES_PER_CHUNK   (BLOCKS_PER_CHUNK / BLOCKS_PER_ENTRY)
#define	INITIAL_ENTRIES_PER_CHUNK   16
#define	SH_PREFIX   blockreftable
#define	SH_ELEMENT_TYPE   BlockRefTableEntry
#define	SH_KEY_TYPE   BlockRefTableKey
#define	SH_KEY   key
#define	SH_HASH_KEY(tb, key)    hash_bytes((const unsigned char *) &key, sizeof(BlockRefTableKey))
#define	SH_EQUAL(tb, a, b)   (memcmp(&a, &b, sizeof(BlockRefTableKey)) == 0)
#define	SH_SCOPE   static inline
#define	SH_DEFINE
#define	SH_DECLARE
#define	BUFSIZE   65536

Typedefs
typedef struct BlockRefTableKey	BlockRefTableKey
typedef uint16 *	BlockRefTableChunk
typedef struct BlockRefTableSerializedEntry	BlockRefTableSerializedEntry
typedef struct BlockRefTableBuffer	BlockRefTableBuffer

Functions
static int	BlockRefTableComparator (const void *a, const void *b)
static void	BlockRefTableFlush (BlockRefTableBuffer *buffer)
static void	BlockRefTableRead (BlockRefTableReader *reader, void *data, int length)
static void	BlockRefTableWrite (BlockRefTableBuffer *buffer, void *data, int length)
static void	BlockRefTableFileTerminate (BlockRefTableBuffer *buffer)
BlockRefTable *	CreateEmptyBlockRefTable (void)
void	BlockRefTableSetLimitBlock (BlockRefTable *brtab, const RelFileLocator *rlocator, ForkNumber forknum, BlockNumber limit_block)
void	BlockRefTableMarkBlockModified (BlockRefTable *brtab, const RelFileLocator *rlocator, ForkNumber forknum, BlockNumber blknum)
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)
void	WriteBlockRefTable (BlockRefTable *brtab, io_callback_fn write_callback, void *write_callback_arg)
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

BLOCKS_PER_CHUNK

#define BLOCKS_PER_CHUNK   (1 << 16)

Definition at line 78 of file blkreftable.c.

BLOCKS_PER_ENTRY

#define BLOCKS_PER_ENTRY   (BITS_PER_BYTE * sizeof(uint16))

Definition at line 79 of file blkreftable.c.

BUFSIZE

#define BUFSIZE   65536

Definition at line 166 of file blkreftable.c.

INITIAL_ENTRIES_PER_CHUNK

#define INITIAL_ENTRIES_PER_CHUNK   16

Definition at line 81 of file blkreftable.c.

MAX_ENTRIES_PER_CHUNK

#define MAX_ENTRIES_PER_CHUNK   (BLOCKS_PER_CHUNK / BLOCKS_PER_ENTRY)

Definition at line 80 of file blkreftable.c.

SH_DECLARE

#define SH_DECLARE

Definition at line 134 of file blkreftable.c.

SH_DEFINE

#define SH_DEFINE

Definition at line 133 of file blkreftable.c.

SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE   BlockRefTableEntry

Definition at line 123 of file blkreftable.c.

SH_EQUAL

#define SH_EQUAL	(		tb,
			a,
			b
	)		(memcmp(&a, &b, sizeof(BlockRefTableKey)) == 0)

Definition at line 128 of file blkreftable.c.

SH_HASH_KEY

#define SH_HASH_KEY	(		tb,
			key
	)		hash_bytes((const unsigned char *) &key, sizeof(BlockRefTableKey))

Definition at line 126 of file blkreftable.c.

SH_KEY

#define SH_KEY   key

Definition at line 125 of file blkreftable.c.

SH_KEY_TYPE

#define SH_KEY_TYPE   BlockRefTableKey

Definition at line 124 of file blkreftable.c.

SH_PREFIX

#define SH_PREFIX   blockreftable

Definition at line 122 of file blkreftable.c.

SH_SCOPE

#define SH_SCOPE   static inline

Definition at line 129 of file blkreftable.c.

Typedef Documentation

BlockRefTableBuffer

typedef struct BlockRefTableBuffer BlockRefTableBuffer

BlockRefTableChunk

typedef uint16* BlockRefTableChunk

Definition at line 82 of file blkreftable.c.

BlockRefTableKey

typedef struct BlockRefTableKey BlockRefTableKey

BlockRefTableSerializedEntry

typedef struct BlockRefTableSerializedEntry BlockRefTableSerializedEntry

Function Documentation

BlockRefTableComparator()

static int BlockRefTableComparator ( const void *  a, const void *  b  )

static

Definition at line 1152 of file blkreftable.c.

{
    const BlockRefTableSerializedEntry *sa = a;
    const BlockRefTableSerializedEntry *sb = b;
 
    if (sa->rlocator.spcOid > sb->rlocator.spcOid)
        return 1;
    if (sa->rlocator.spcOid < sb->rlocator.spcOid)
        return -1;
 
    if (sa->rlocator.dbOid > sb->rlocator.dbOid)
        return 1;
    if (sa->rlocator.dbOid < sb->rlocator.dbOid)
        return -1;
 
    if (sa->rlocator.relNumber > sb->rlocator.relNumber)
        return 1;
    if (sa->rlocator.relNumber < sb->rlocator.relNumber)
        return -1;
 
    if (sa->forknum > sb->forknum)
        return 1;
    if (sa->forknum < sb->forknum)
        return -1;
 
    return 0;
}

References a, b, RelFileLocator::dbOid, BlockRefTableSerializedEntry::forknum, RelFileLocator::relNumber, BlockRefTableSerializedEntry::rlocator, and RelFileLocator::spcOid.

Referenced by WriteBlockRefTable().

BlockRefTableEntryGetBlocks()

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

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, i, MAX_ENTRIES_PER_CHUNK, and BlockRefTableEntry::nchunks.

Referenced by GetFileBackupMethod().

BlockRefTableEntryMarkBlockModified()

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

Definition at line 965 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(sizeof(uint16) * max_chunks);
            entry->chunk_usage = palloc0(sizeof(uint16) * max_chunks);
            entry->chunk_data =
                palloc0(sizeof(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(sizeof(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, i, INITIAL_ENTRIES_PER_CHUNK, j, Max, MAX_ENTRIES_PER_CHUNK, BlockRefTableEntry::nchunks, palloc(), palloc0(), pfree(), and repalloc().

Referenced by BlockRefTableMarkBlockModified().

BlockRefTableEntrySetLimitBlock()

void BlockRefTableEntrySetLimitBlock	(	BlockRefTableEntry *	entry,
		BlockNumber	limit_block
	)

Definition at line 894 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, i, if(), j, BlockRefTableEntry::limit_block, MAX_ENTRIES_PER_CHUNK, and BlockRefTableEntry::nchunks.

Referenced by BlockRefTableSetLimitBlock().

BlockRefTableFileTerminate()

static void BlockRefTableFileTerminate ( BlockRefTableBuffer *  buffer )

static

Definition at line 1292 of file blkreftable.c.

{
    BlockRefTableSerializedEntry zentry = {0};
    pg_crc32c   crc;
 
    /* Write a sentinel indicating that there are no more entries. */
    BlockRefTableWrite(buffer, &zentry,
                       sizeof(BlockRefTableSerializedEntry));
 
    /*
     * Writing the checksum will perturb the ongoing checksum calculation, so
     * copy the state first and finalize the computation using the copy.
     */
    crc = buffer->crc;
    FIN_CRC32C(crc);
    BlockRefTableWrite(buffer, &crc, sizeof(pg_crc32c));
 
    /* Flush any leftover data out of our buffer. */
    BlockRefTableFlush(buffer);
}

References BlockRefTableFlush(), BlockRefTableWrite(), BlockRefTableBuffer::crc, crc, and FIN_CRC32C.

Referenced by DestroyBlockRefTableWriter(), and WriteBlockRefTable().

BlockRefTableFlush()

static void BlockRefTableFlush ( BlockRefTableBuffer *  buffer )

static

Definition at line 1184 of file blkreftable.c.

{
    buffer->io_callback(buffer->io_callback_arg, buffer->data, buffer->used);
    buffer->used = 0;
}

References BlockRefTableBuffer::data, BlockRefTableBuffer::io_callback, BlockRefTableBuffer::io_callback_arg, and BlockRefTableBuffer::used.

Referenced by BlockRefTableFileTerminate().

BlockRefTableFreeEntry()

void BlockRefTableFreeEntry

(

BlockRefTableEntry *

entry

)

Definition at line 1122 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, and pfree().

BlockRefTableGetEntry()

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

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(), BlockRefTable::hash, sort-test::key, and BlockRefTableEntry::limit_block.

Referenced by GetFileBackupMethod().

BlockRefTableMarkBlockModified()

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

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(), BlockRefTableEntry::chunk_data, BlockRefTableEntry::chunk_size, BlockRefTableEntry::chunk_usage, BlockRefTable::hash, InvalidBlockNumber, sort-test::key, BlockRefTableEntry::limit_block, BlockRefTable::mcxt, MemoryContextSwitchTo(), and BlockRefTableEntry::nchunks.

Referenced by PrepareForIncrementalBackup(), and SummarizeWAL().

BlockRefTableRead()

static void BlockRefTableRead ( BlockRefTableReader *  reader, void *  data, int  length  )

static

Definition at line 1196 of file blkreftable.c.

{
    BlockRefTableBuffer *buffer = &reader->buffer;
 
    /* Loop until read is fully satisfied. */
    while (length > 0)
    {
        if (buffer->cursor < buffer->used)
        {
            /*
             * If any buffered data is available, use that to satisfy as much
             * of the request as possible.
             */
            int         bytes_to_copy = Min(length, buffer->used - buffer->cursor);
 
            memcpy(data, &buffer->data[buffer->cursor], bytes_to_copy);
            COMP_CRC32C(buffer->crc, &buffer->data[buffer->cursor],
                        bytes_to_copy);
            buffer->cursor += bytes_to_copy;
            data = ((char *) data) + bytes_to_copy;
            length -= bytes_to_copy;
        }
        else if (length >= BUFSIZE)
        {
            /*
             * If the request length is long, read directly into caller's
             * buffer.
             */
            int         bytes_read;
 
            bytes_read = buffer->io_callback(buffer->io_callback_arg,
                                             data, length);
            COMP_CRC32C(buffer->crc, data, bytes_read);
            data = ((char *) data) + bytes_read;
            length -= bytes_read;
 
            /* If we didn't get anything, that's bad. */
            if (bytes_read == 0)
                reader->error_callback(reader->error_callback_arg,
                                       "file \"%s\" ends unexpectedly",
                                       reader->error_filename);
        }
        else
        {
            /*
             * Refill our buffer.
             */
            buffer->used = buffer->io_callback(buffer->io_callback_arg,
                                               buffer->data, BUFSIZE);
            buffer->cursor = 0;
 
            /* If we didn't get anything, that's bad. */
            if (buffer->used == 0)
                reader->error_callback(reader->error_callback_arg,
                                       "file \"%s\" ends unexpectedly",
                                       reader->error_filename);
        }
    }
}

References BlockRefTableReader::buffer, BUFSIZE, COMP_CRC32C, BlockRefTableBuffer::crc, BlockRefTableBuffer::cursor, BlockRefTableBuffer::data, data, BlockRefTableReader::error_callback, BlockRefTableReader::error_callback_arg, BlockRefTableReader::error_filename, BlockRefTableBuffer::io_callback, BlockRefTableBuffer::io_callback_arg, Min, and BlockRefTableBuffer::used.

Referenced by BlockRefTableReaderGetBlocks(), BlockRefTableReaderNextRelation(), and CreateBlockRefTableReader().

BlockRefTableReaderGetBlocks()

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

Definition at line 689 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, 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
	)

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;
    }
 
    /* Read chunk size array. */
    if (reader->chunk_size != NULL)
        pfree(reader->chunk_size);
    reader->chunk_size = palloc(sentry.nchunks * sizeof(uint16));
    BlockRefTableRead(reader, reader->chunk_size,
                      sentry.nchunks * sizeof(uint16));
 
    /* 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, FIN_CRC32C, BlockRefTableSerializedEntry::forknum, BlockRefTableSerializedEntry::limit_block, BlockRefTableSerializedEntry::nchunks, palloc(), pfree(), BlockRefTableSerializedEntry::rlocator, 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
	)

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(), BlockRefTableEntry::chunk_data, BlockRefTableEntry::chunk_size, BlockRefTableEntry::chunk_usage, BlockRefTable::hash, sort-test::key, BlockRefTableEntry::limit_block, and BlockRefTableEntry::nchunks.

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

BlockRefTableWrite()

static void BlockRefTableWrite ( BlockRefTableBuffer *  buffer, void *  data, int  length  )

static

Definition at line 1261 of file blkreftable.c.

{
    /* Update running CRC calculation. */
    COMP_CRC32C(buffer->crc, data, length);
 
    /* If the new data can't fit into the buffer, flush the buffer. */
    if (buffer->used + length > BUFSIZE)
    {
        buffer->io_callback(buffer->io_callback_arg, buffer->data,
                            buffer->used);
        buffer->used = 0;
    }
 
    /* If the new data would fill the buffer, or more, write it directly. */
    if (length >= BUFSIZE)
    {
        buffer->io_callback(buffer->io_callback_arg, data, length);
        return;
    }
 
    /* Otherwise, copy the new data into the buffer. */
    memcpy(&buffer->data[buffer->used], data, length);
    buffer->used += length;
    Assert(buffer->used <= BUFSIZE);
}

References Assert(), BUFSIZE, COMP_CRC32C, BlockRefTableBuffer::crc, BlockRefTableBuffer::data, data, BlockRefTableBuffer::io_callback, BlockRefTableBuffer::io_callback_arg, and BlockRefTableBuffer::used.

Referenced by BlockRefTableFileTerminate(), BlockRefTableWriteEntry(), CreateBlockRefTableWriter(), and WriteBlockRefTable().

BlockRefTableWriteEntry()

void BlockRefTableWriteEntry	(	BlockRefTableWriter *	writer,
		BlockRefTableEntry *	entry
	)

Definition at line 817 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(), BlockRefTableWriter::buffer, BlockRefTableEntry::chunk_data, BlockRefTableEntry::chunk_usage, BlockRefTableKey::forknum, BlockRefTableSerializedEntry::forknum, j, BlockRefTableEntry::key, BlockRefTableEntry::limit_block, BlockRefTableSerializedEntry::limit_block, BlockRefTableEntry::nchunks, BlockRefTableSerializedEntry::nchunks, BlockRefTableKey::rlocator, and BlockRefTableSerializedEntry::rlocator.

CreateBlockRefTableEntry()

BlockRefTableEntry * CreateBlockRefTableEntry	(	RelFileLocator	rlocator,
		ForkNumber	forknum
	)

Definition at line 875 of file blkreftable.c.

{
    BlockRefTableEntry *entry = palloc0(sizeof(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, palloc0(), 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
	)

Definition at line 577 of file blkreftable.c.

{
    BlockRefTableReader *reader;
    uint32      magic;
 
    /* Initialize data structure. */
    reader = palloc0(sizeof(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, INIT_CRC32C, BlockRefTableBuffer::io_callback, BlockRefTableBuffer::io_callback_arg, and palloc0().

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

CreateBlockRefTableWriter()

BlockRefTableWriter * CreateBlockRefTableWriter	(	io_callback_fn	write_callback,
		void *	write_callback_arg
	)

Definition at line 790 of file blkreftable.c.

{
    BlockRefTableWriter *writer;
    uint32      magic = BLOCKREFTABLE_MAGIC;
 
    /* Prepare buffer and CRC check and save callbacks. */
    writer = palloc0(sizeof(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(), BlockRefTableWriter::buffer, BlockRefTableBuffer::crc, INIT_CRC32C, BlockRefTableBuffer::io_callback, BlockRefTableBuffer::io_callback_arg, and palloc0().

CreateEmptyBlockRefTable()

BlockRefTable * CreateEmptyBlockRefTable

(

void

)

Definition at line 235 of file blkreftable.c.

{
    BlockRefTable *brtab = palloc(sizeof(BlockRefTable));
 
    /*
     * Even completely empty database has a few hundred relation forks, so it
     * seems best to size the hash on the assumption that we're going to have
     * at least a few thousand entries.
     */
#ifdef FRONTEND
    brtab->hash = blockreftable_create(4096, NULL);
#else
    brtab->mcxt = CurrentMemoryContext;
    brtab->hash = blockreftable_create(brtab->mcxt, 4096, NULL);
#endif
 
    return brtab;
}

References CurrentMemoryContext, BlockRefTable::hash, BlockRefTable::mcxt, and palloc().

DestroyBlockRefTableReader()

void DestroyBlockRefTableReader

(

BlockRefTableReader *

reader

)

Definition at line 773 of file blkreftable.c.

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

References BlockRefTableReader::chunk_size, and pfree().

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

DestroyBlockRefTableWriter()

void DestroyBlockRefTableWriter

(

BlockRefTableWriter *

writer

)

Definition at line 855 of file blkreftable.c.

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

References BlockRefTableFileTerminate(), BlockRefTableWriter::buffer, and pfree().

WriteBlockRefTable()

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

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(brtab->hash->members * sizeof(BlockRefTableSerializedEntry));
        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(), BlockRefTableEntry::chunk_data, BlockRefTableEntry::chunk_usage, BlockRefTableBuffer::crc, BlockRefTableKey::forknum, BlockRefTableSerializedEntry::forknum, BlockRefTable::hash, i, INIT_CRC32C, BlockRefTableBuffer::io_callback, BlockRefTableBuffer::io_callback_arg, j, BlockRefTableEntry::key, sort-test::key, BlockRefTableEntry::limit_block, BlockRefTableSerializedEntry::limit_block, BlockRefTableEntry::nchunks, BlockRefTableSerializedEntry::nchunks, palloc(), qsort, BlockRefTableKey::rlocator, and BlockRefTableSerializedEntry::rlocator.

Referenced by SummarizeWAL().