generic_xlog.h File Reference

#include "access/xlog.h"
#include "access/xlog_internal.h"
#include "access/xloginsert.h"
#include "storage/bufpage.h"
#include "utils/rel.h"

Include dependency graph for generic_xlog.h:

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

Go to the source code of this file.

Macros
#define	MAX_GENERIC_XLOG_PAGES   XLR_NORMAL_MAX_BLOCK_ID
#define	GENERIC_XLOG_FULL_IMAGE   0x0001 /* write full-page image */

Typedefs
typedef struct GenericXLogState	GenericXLogState

Functions
GenericXLogState *	GenericXLogStart (Relation relation)
Page	GenericXLogRegisterBuffer (GenericXLogState *state, Buffer buffer, int flags)
XLogRecPtr	GenericXLogFinish (GenericXLogState *state)
void	GenericXLogAbort (GenericXLogState *state)
void	generic_redo (XLogReaderState *record)
const char *	generic_identify (uint8 info)
void	generic_desc (StringInfo buf, XLogReaderState *record)
void	generic_mask (char *page, BlockNumber blkno)

Macro Definition Documentation

GENERIC_XLOG_FULL_IMAGE

#define GENERIC_XLOG_FULL_IMAGE   0x0001 /* write full-page image */

Definition at line 26 of file generic_xlog.h.

MAX_GENERIC_XLOG_PAGES

#define MAX_GENERIC_XLOG_PAGES   XLR_NORMAL_MAX_BLOCK_ID

Definition at line 23 of file generic_xlog.h.

Typedef Documentation

GenericXLogState

typedef struct GenericXLogState GenericXLogState

Definition at line 1 of file generic_xlog.h.

Function Documentation

generic_desc()

void generic_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 25 of file genericdesc.c.

{
    Pointer     ptr = XLogRecGetData(record),
                end = ptr + XLogRecGetDataLen(record);
 
    while (ptr < end)
    {
        OffsetNumber offset,
                    length;
 
        memcpy(&offset, ptr, sizeof(offset));
        ptr += sizeof(offset);
        memcpy(&length, ptr, sizeof(length));
        ptr += sizeof(length);
        ptr += length;
 
        if (ptr < end)
            appendStringInfo(buf, "offset %u, length %u; ", offset, length);
        else
            appendStringInfo(buf, "offset %u, length %u", offset, length);
    }
}

References appendStringInfo(), buf, XLogRecGetData, and XLogRecGetDataLen.

generic_identify()

const char* generic_identify

(

uint8

info

)

Definition at line 53 of file genericdesc.c.

{
    return "Generic";
}

generic_mask()

void generic_mask	(	char *	page,
		BlockNumber	blkno
	)

Definition at line 540 of file generic_xlog.c.

{
    mask_page_lsn_and_checksum(page);
 
    mask_unused_space(page);
}

References mask_page_lsn_and_checksum(), and mask_unused_space().

generic_redo()

void generic_redo

(

XLogReaderState *

record

)

Definition at line 479 of file generic_xlog.c.

{
    XLogRecPtr  lsn = record->EndRecPtr;
    Buffer      buffers[MAX_GENERIC_XLOG_PAGES];
    uint8       block_id;
 
    /* Protect limited size of buffers[] array */
    Assert(XLogRecMaxBlockId(record) < MAX_GENERIC_XLOG_PAGES);
 
    /* Iterate over blocks */
    for (block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
    {
        XLogRedoAction action;
 
        if (!XLogRecHasBlockRef(record, block_id))
        {
            buffers[block_id] = InvalidBuffer;
            continue;
        }
 
        action = XLogReadBufferForRedo(record, block_id, &buffers[block_id]);
 
        /* Apply redo to given block if needed */
        if (action == BLK_NEEDS_REDO)
        {
            Page        page;
            PageHeader  pageHeader;
            char       *blockDelta;
            Size        blockDeltaSize;
 
            page = BufferGetPage(buffers[block_id]);
            blockDelta = XLogRecGetBlockData(record, block_id, &blockDeltaSize);
            applyPageRedo(page, blockDelta, blockDeltaSize);
 
            /*
             * Since the delta contains no information about what's in the
             * "hole" between pd_lower and pd_upper, set that to zero to
             * ensure we produce the same page state that application of the
             * logged action by GenericXLogFinish did.
             */
            pageHeader = (PageHeader) page;
            memset(page + pageHeader->pd_lower, 0,
                   pageHeader->pd_upper - pageHeader->pd_lower);
 
            PageSetLSN(page, lsn);
            MarkBufferDirty(buffers[block_id]);
        }
    }
 
    /* Changes are done: unlock and release all buffers */
    for (block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
    {
        if (BufferIsValid(buffers[block_id]))
            UnlockReleaseBuffer(buffers[block_id]);
    }
}

References generate_unaccent_rules::action, applyPageRedo(), Assert(), BLK_NEEDS_REDO, BufferGetPage(), BufferIsValid(), XLogReaderState::EndRecPtr, InvalidBuffer, MarkBufferDirty(), MAX_GENERIC_XLOG_PAGES, PageSetLSN(), PageHeaderData::pd_lower, PageHeaderData::pd_upper, UnlockReleaseBuffer(), XLogReadBufferForRedo(), XLogRecGetBlockData(), XLogRecHasBlockRef, and XLogRecMaxBlockId.

GenericXLogAbort()

void GenericXLogAbort

(

GenericXLogState *

state

)

Definition at line 445 of file generic_xlog.c.

{
    pfree(state);
}

References pfree().

Referenced by blbulkdelete(), and blinsert().

GenericXLogFinish()

XLogRecPtr GenericXLogFinish

(

GenericXLogState *

state

)

Definition at line 338 of file generic_xlog.c.

{
    XLogRecPtr  lsn;
    int         i;
 
    if (state->isLogged)
    {
        /* Logged relation: make xlog record in critical section. */
        XLogBeginInsert();
 
        START_CRIT_SECTION();
 
        /*
         * Compute deltas if necessary, write changes to buffers, mark buffers
         * dirty, and register changes.
         */
        for (i = 0; i < MAX_GENERIC_XLOG_PAGES; i++)
        {
            PageData   *pageData = &state->pages[i];
            Page        page;
            PageHeader  pageHeader;
 
            if (BufferIsInvalid(pageData->buffer))
                continue;
 
            page = BufferGetPage(pageData->buffer);
            pageHeader = (PageHeader) pageData->image;
 
            /*
             * Compute delta while we still have both the unmodified page and
             * the new image. Not needed if we are logging the full image.
             */
            if (!(pageData->flags & GENERIC_XLOG_FULL_IMAGE))
                computeDelta(pageData, page, (Page) pageData->image);
 
            /*
             * Apply the image, being careful to zero the "hole" between
             * pd_lower and pd_upper in order to avoid divergence between
             * actual page state and what replay would produce.
             */
            memcpy(page, pageData->image, pageHeader->pd_lower);
            memset(page + pageHeader->pd_lower, 0,
                   pageHeader->pd_upper - pageHeader->pd_lower);
            memcpy(page + pageHeader->pd_upper,
                   pageData->image + pageHeader->pd_upper,
                   BLCKSZ - pageHeader->pd_upper);
 
            MarkBufferDirty(pageData->buffer);
 
            if (pageData->flags & GENERIC_XLOG_FULL_IMAGE)
            {
                XLogRegisterBuffer(i, pageData->buffer,
                                   REGBUF_FORCE_IMAGE | REGBUF_STANDARD);
            }
            else
            {
                XLogRegisterBuffer(i, pageData->buffer, REGBUF_STANDARD);
                XLogRegisterBufData(i, pageData->delta, pageData->deltaLen);
            }
        }
 
        /* Insert xlog record */
        lsn = XLogInsert(RM_GENERIC_ID, 0);
 
        /* Set LSN */
        for (i = 0; i < MAX_GENERIC_XLOG_PAGES; i++)
        {
            PageData   *pageData = &state->pages[i];
 
            if (BufferIsInvalid(pageData->buffer))
                continue;
            PageSetLSN(BufferGetPage(pageData->buffer), lsn);
        }
        END_CRIT_SECTION();
    }
    else
    {
        /* Unlogged relation: skip xlog-related stuff */
        START_CRIT_SECTION();
        for (i = 0; i < MAX_GENERIC_XLOG_PAGES; i++)
        {
            PageData   *pageData = &state->pages[i];
 
            if (BufferIsInvalid(pageData->buffer))
                continue;
            memcpy(BufferGetPage(pageData->buffer),
                   pageData->image,
                   BLCKSZ);
            /* We don't worry about zeroing the "hole" in this case */
            MarkBufferDirty(pageData->buffer);
        }
        END_CRIT_SECTION();
        /* We don't have a LSN to return, in this case */
        lsn = InvalidXLogRecPtr;
    }
 
    pfree(state);
 
    return lsn;
}

References PageData::buffer, BufferGetPage(), BufferIsInvalid, computeDelta(), PageData::delta, PageData::deltaLen, END_CRIT_SECTION, PageData::flags, GENERIC_XLOG_FULL_IMAGE, i, if(), PageData::image, InvalidXLogRecPtr, MarkBufferDirty(), MAX_GENERIC_XLOG_PAGES, PageSetLSN(), PageHeaderData::pd_lower, PageHeaderData::pd_upper, pfree(), REGBUF_FORCE_IMAGE, REGBUF_STANDARD, START_CRIT_SECTION, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), and XLogRegisterBuffer().

Referenced by blbulkdelete(), blinsert(), BloomInitMetapage(), and flushCachedPage().

GenericXLogRegisterBuffer()

Page GenericXLogRegisterBuffer	(	GenericXLogState *	state,
		Buffer	buffer,
		int	flags
	)

Definition at line 300 of file generic_xlog.c.

{
    int         block_id;
 
    /* Search array for existing entry or first unused slot */
    for (block_id = 0; block_id < MAX_GENERIC_XLOG_PAGES; block_id++)
    {
        PageData   *page = &state->pages[block_id];
 
        if (BufferIsInvalid(page->buffer))
        {
            /* Empty slot, so use it (there cannot be a match later) */
            page->buffer = buffer;
            page->flags = flags;
            memcpy(page->image, BufferGetPage(buffer), BLCKSZ);
            return (Page) page->image;
        }
        else if (page->buffer == buffer)
        {
            /*
             * Buffer is already registered.  Just return the image, which is
             * already prepared.
             */
            return (Page) page->image;
        }
    }
 
    elog(ERROR, "maximum number %d of generic xlog buffers is exceeded",
         MAX_GENERIC_XLOG_PAGES);
    /* keep compiler quiet */
    return NULL;
}

References PageData::buffer, BufferGetPage(), BufferIsInvalid, elog(), ERROR, PageData::flags, PageData::image, and MAX_GENERIC_XLOG_PAGES.

Referenced by blbulkdelete(), blinsert(), BloomInitMetapage(), and flushCachedPage().

GenericXLogStart()

GenericXLogState* GenericXLogStart

(

Relation

relation

)

Definition at line 270 of file generic_xlog.c.

{
    GenericXLogState *state;
    int         i;
 
    state = (GenericXLogState *) palloc_aligned(sizeof(GenericXLogState),
                                                PG_IO_ALIGN_SIZE,
                                                0);
    state->isLogged = RelationNeedsWAL(relation);
 
    for (i = 0; i < MAX_GENERIC_XLOG_PAGES; i++)
    {
        state->pages[i].image = state->images[i].data;
        state->pages[i].buffer = InvalidBuffer;
    }
 
    return state;
}

References i, InvalidBuffer, MAX_GENERIC_XLOG_PAGES, palloc_aligned(), PG_IO_ALIGN_SIZE, and RelationNeedsWAL.

Referenced by blbulkdelete(), blinsert(), BloomInitMetapage(), and flushCachedPage().