storage.h File Reference

#include "access/xlog.h"
#include "lib/stringinfo.h"
#include "storage/block.h"
#include "storage/relfilenode.h"
#include "utils/relcache.h"

Include dependency graph for storage.h:

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

Go to the source code of this file.

Functions
void	RelationCreateStorage (RelFileNode rnode, bool istemp)
void	RelationDropStorage (Relation rel)
void	RelationTruncate (Relation rel, BlockNumber nblocks)
void	smgrDoPendingDeletes (bool isCommit)
int	smgrGetPendingDeletes (bool forCommit, RelFileNode **ptr, bool *haveNonTemp)
void	AtSubCommit_smgr (void)
void	AtSubAbort_smgr (void)
void	PostPrepare_smgr (void)
void	smgr_redo (XLogRecPtr lsn, XLogRecord *record)
void	smgr_desc (StringInfo buf, uint8 xl_info, char *rec)

---

Function Documentation

void AtSubAbort_smgr

(

void

)

Definition at line 394 of file storage.c.

References smgrDoPendingDeletes().

Referenced by AbortSubTransaction().

{
    smgrDoPendingDeletes(false);
}

void AtSubCommit_smgr

(

void

)

Definition at line 374 of file storage.c.

References GetCurrentTransactionNestLevel(), PendingRelDelete::nestLevel, PendingRelDelete::next, and NULL.

Referenced by CommitSubTransaction().

{
    int         nestLevel = GetCurrentTransactionNestLevel();
    PendingRelDelete *pending;

    for (pending = pendingDeletes; pending != NULL; pending = pending->next)
    {
        if (pending->nestLevel >= nestLevel)
            pending->nestLevel = nestLevel - 1;
    }
}

void PostPrepare_smgr

(

void

)

Definition at line 353 of file storage.c.

References PendingRelDelete::next, next(), NULL, and pfree().

Referenced by PrepareTransaction().

{
    PendingRelDelete *pending;
    PendingRelDelete *next;

    for (pending = pendingDeletes; pending != NULL; pending = next)
    {
        next = pending->next;
        pendingDeletes = next;
        /* must explicitly free the list entry */
        pfree(pending);
    }
}

void RelationCreateStorage	(	RelFileNode	rnode,
		bool	istemp
	)

Definition at line 98 of file storage.c.

References PendingRelDelete::atCommit, XLogRecData::buffer, XLogRecData::data, GetCurrentTransactionNestLevel(), InvalidBuffer, PendingRelDelete::isTemp, XLogRecData::len, MAIN_FORKNUM, MemoryContextAlloc(), PendingRelDelete::nestLevel, PendingRelDelete::next, XLogRecData::next, NULL, PendingRelDelete::relnode, RM_SMGR_ID, xl_smgr_create::rnode, smgrcreate(), smgropen(), TopMemoryContext, XLOG_SMGR_CREATE, and XLogInsert().

Referenced by ATExecSetTableSpace(), heap_create(), and setNewRelfilenode().

{
    PendingRelDelete *pending;
    XLogRecPtr  lsn;
    XLogRecData rdata;
    xl_smgr_create xlrec;
    SMgrRelation srel;

    srel = smgropen(rnode);
    smgrcreate(srel, MAIN_FORKNUM, false);

    if (!istemp)
    {
        /*
         * Make an XLOG entry showing the file creation.  If we abort, the
         * file will be dropped at abort time.
         */
        xlrec.rnode = rnode;

        rdata.data = (char *) &xlrec;
        rdata.len = sizeof(xlrec);
        rdata.buffer = InvalidBuffer;
        rdata.next = NULL;

        lsn = XLogInsert(RM_SMGR_ID, XLOG_SMGR_CREATE, &rdata);
    }

    /* Add the relation to the list of stuff to delete at abort */
    pending = (PendingRelDelete *)
        MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete));
    pending->relnode = rnode;
    pending->isTemp = istemp;
    pending->atCommit = false;  /* delete if abort */
    pending->nestLevel = GetCurrentTransactionNestLevel();
    pending->next = pendingDeletes;
    pendingDeletes = pending;
}

void RelationDropStorage

(

Relation

rel

)

Definition at line 141 of file storage.c.

References PendingRelDelete::atCommit, GetCurrentTransactionNestLevel(), PendingRelDelete::isTemp, MemoryContextAlloc(), PendingRelDelete::nestLevel, PendingRelDelete::next, RelationData::rd_istemp, RelationData::rd_node, RelationCloseSmgr, PendingRelDelete::relnode, and TopMemoryContext.

Referenced by ATExecSetTableSpace(), DefineQueryRewrite(), heap_drop_with_catalog(), index_drop(), and setNewRelfilenode().

{
    PendingRelDelete *pending;

    /* Add the relation to the list of stuff to delete at commit */
    pending = (PendingRelDelete *)
        MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete));
    pending->relnode = rel->rd_node;
    pending->isTemp = rel->rd_istemp;
    pending->atCommit = true;   /* delete if commit */
    pending->nestLevel = GetCurrentTransactionNestLevel();
    pending->next = pendingDeletes;
    pendingDeletes = pending;

    /*
     * NOTE: if the relation was created in this transaction, it will now be
     * present in the pending-delete list twice, once with atCommit true and
     * once with atCommit false.  Hence, it will be physically deleted at end
     * of xact in either case (and the other entry will be ignored by
     * smgrDoPendingDeletes, so no error will occur).  We could instead remove
     * the existing list entry and delete the physical file immediately, but
     * for now I'll keep the logic simple.
     */

    RelationCloseSmgr(rel);
}

void RelationTruncate	(	Relation	rel,
		BlockNumber	nblocks
	)

Definition at line 176 of file storage.c.

References xl_smgr_truncate::blkno, XLogRecData::buffer, XLogRecData::data, FreeSpaceMapTruncateRel(), FSM_FORKNUM, InvalidBlockNumber, InvalidBuffer, XLogRecData::len, MAIN_FORKNUM, XLogRecData::next, NULL, RelationData::rd_istemp, RelationData::rd_node, RelationData::rd_smgr, RelationData::rd_targblock, RelationOpenSmgr, RM_SMGR_ID, xl_smgr_truncate::rnode, smgrexists(), smgrtruncate(), VISIBILITYMAP_FORKNUM, visibilitymap_truncate(), XLOG_SMGR_TRUNCATE, XLogFlush(), and XLogInsert().

Referenced by btvacuumscan(), ginvacuumcleanup(), gistvacuumcleanup(), heap_truncate(), lazy_truncate_heap(), reindex_index(), RelationTruncateIndexes(), repair_frag(), and vacuum_heap().

{
    bool        fsm;
    bool        vm;

    /* Open it at the smgr level if not already done */
    RelationOpenSmgr(rel);

    /* Make sure rd_targblock isn't pointing somewhere past end */
    rel->rd_targblock = InvalidBlockNumber;

    /* Truncate the FSM first if it exists */
    fsm = smgrexists(rel->rd_smgr, FSM_FORKNUM);
    if (fsm)
        FreeSpaceMapTruncateRel(rel, nblocks);

    /* Truncate the visibility map too if it exists. */
    vm = smgrexists(rel->rd_smgr, VISIBILITYMAP_FORKNUM);
    if (vm)
        visibilitymap_truncate(rel, nblocks);

    /*
     * We WAL-log the truncation before actually truncating, which means
     * trouble if the truncation fails. If we then crash, the WAL replay
     * likely isn't going to succeed in the truncation either, and cause a
     * PANIC. It's tempting to put a critical section here, but that cure
     * would be worse than the disease. It would turn a usually harmless
     * failure to truncate, that could spell trouble at WAL replay, into a
     * certain PANIC.
     */
    if (!rel->rd_istemp)
    {
        /*
         * Make an XLOG entry showing the file truncation.
         */
        XLogRecPtr  lsn;
        XLogRecData rdata;
        xl_smgr_truncate xlrec;

        xlrec.blkno = nblocks;
        xlrec.rnode = rel->rd_node;

        rdata.data = (char *) &xlrec;
        rdata.len = sizeof(xlrec);
        rdata.buffer = InvalidBuffer;
        rdata.next = NULL;

        lsn = XLogInsert(RM_SMGR_ID, XLOG_SMGR_TRUNCATE, &rdata);

        /*
         * Flush, because otherwise the truncation of the main relation might
         * hit the disk before the WAL record, and the truncation of the FSM
         * or visibility map. If we crashed during that window, we'd be left
         * with a truncated heap, but the FSM or visibility map would still
         * contain entries for the non-existent heap pages.
         */
        if (fsm || vm)
            XLogFlush(lsn);
    }

    /* Do the real work */
    smgrtruncate(rel->rd_smgr, MAIN_FORKNUM, nblocks, rel->rd_istemp);
}

void smgr_desc	(	StringInfo	buf,
		uint8	xl_info,
		char *	rec
	)

Definition at line 450 of file storage.c.

References appendStringInfo(), xl_smgr_truncate::blkno, MAIN_FORKNUM, pfree(), relpath(), xl_smgr_truncate::rnode, xl_smgr_create::rnode, XLOG_SMGR_CREATE, XLOG_SMGR_TRUNCATE, and XLR_INFO_MASK.

{
    uint8       info = xl_info & ~XLR_INFO_MASK;

    if (info == XLOG_SMGR_CREATE)
    {
        xl_smgr_create *xlrec = (xl_smgr_create *) rec;
        char       *path = relpath(xlrec->rnode, MAIN_FORKNUM);

        appendStringInfo(buf, "file create: %s", path);
        pfree(path);
    }
    else if (info == XLOG_SMGR_TRUNCATE)
    {
        xl_smgr_truncate *xlrec = (xl_smgr_truncate *) rec;
        char       *path = relpath(xlrec->rnode, MAIN_FORKNUM);

        appendStringInfo(buf, "file truncate: %s to %u blocks", path,
                         xlrec->blkno);
        pfree(path);
    }
    else
        appendStringInfo(buf, "UNKNOWN");
}

void smgr_redo	(	XLogRecPtr	lsn,
		XLogRecord *	record
	)

Definition at line 400 of file storage.c.

References Assert, xl_smgr_truncate::blkno, CreateFakeRelcacheEntry(), elog, FreeFakeRelcacheEntry(), FreeSpaceMapTruncateRel(), FSM_FORKNUM, MAIN_FORKNUM, PANIC, xl_smgr_truncate::rnode, xl_smgr_create::rnode, smgrcreate(), smgrexists(), smgropen(), smgrtruncate(), XLogRecord::xl_info, XLOG_SMGR_CREATE, XLOG_SMGR_TRUNCATE, XLogRecGetData, XLogTruncateRelation(), XLR_BKP_BLOCK_MASK, and XLR_INFO_MASK.

{
    uint8       info = record->xl_info & ~XLR_INFO_MASK;

    /* Backup blocks are not used in smgr records */
    Assert(!(record->xl_info & XLR_BKP_BLOCK_MASK));

    if (info == XLOG_SMGR_CREATE)
    {
        xl_smgr_create *xlrec = (xl_smgr_create *) XLogRecGetData(record);
        SMgrRelation reln;

        reln = smgropen(xlrec->rnode);
        smgrcreate(reln, MAIN_FORKNUM, true);
    }
    else if (info == XLOG_SMGR_TRUNCATE)
    {
        xl_smgr_truncate *xlrec = (xl_smgr_truncate *) XLogRecGetData(record);
        SMgrRelation reln;

        reln = smgropen(xlrec->rnode);

        /*
         * Forcibly create relation if it doesn't exist (which suggests that
         * it was dropped somewhere later in the WAL sequence).  As in
         * XLogOpenRelation, we prefer to recreate the rel and replay the log
         * as best we can until the drop is seen.
         */
        smgrcreate(reln, MAIN_FORKNUM, true);

        smgrtruncate(reln, MAIN_FORKNUM, xlrec->blkno, false);

        /* Also tell xlogutils.c about it */
        XLogTruncateRelation(xlrec->rnode, MAIN_FORKNUM, xlrec->blkno);

        /* Truncate FSM too */
        if (smgrexists(reln, FSM_FORKNUM))
        {
            Relation    rel = CreateFakeRelcacheEntry(xlrec->rnode);

            FreeSpaceMapTruncateRel(rel, xlrec->blkno);
            FreeFakeRelcacheEntry(rel);
        }

    }
    else
        elog(PANIC, "smgr_redo: unknown op code %u", info);
}

void smgrDoPendingDeletes

(

bool

isCommit

)

Definition at line 247 of file storage.c.

References PendingRelDelete::atCommit, GetCurrentTransactionNestLevel(), i, PendingRelDelete::isTemp, MAX_FORKNUM, PendingRelDelete::nestLevel, PendingRelDelete::next, next(), NULL, pfree(), PendingRelDelete::relnode, smgrclose(), smgrdounlink(), smgrexists(), and smgropen().

Referenced by AbortTransaction(), AtSubAbort_smgr(), and CommitTransaction().

{
    int         nestLevel = GetCurrentTransactionNestLevel();
    PendingRelDelete *pending;
    PendingRelDelete *prev;
    PendingRelDelete *next;

    prev = NULL;
    for (pending = pendingDeletes; pending != NULL; pending = next)
    {
        next = pending->next;
        if (pending->nestLevel < nestLevel)
        {
            /* outer-level entries should not be processed yet */
            prev = pending;
        }
        else
        {
            /* unlink list entry first, so we don't retry on failure */
            if (prev)
                prev->next = next;
            else
                pendingDeletes = next;
            /* do deletion if called for */
            if (pending->atCommit == isCommit)
            {
                int         i;

                /* schedule unlinking old files */
                SMgrRelation srel;

                srel = smgropen(pending->relnode);
                for (i = 0; i <= MAX_FORKNUM; i++)
                {
                    if (smgrexists(srel, i))
                        smgrdounlink(srel,
                                     i,
                                     pending->isTemp,
                                     false);
                }
                smgrclose(srel);
            }
            /* must explicitly free the list entry */
            pfree(pending);
            /* prev does not change */
        }
    }
}

int smgrGetPendingDeletes	(	bool	forCommit,
		RelFileNode **	ptr,
		bool *	haveNonTemp
	)

Definition at line 310 of file storage.c.

References PendingRelDelete::atCommit, GetCurrentTransactionNestLevel(), PendingRelDelete::isTemp, PendingRelDelete::nestLevel, PendingRelDelete::next, NULL, palloc, and PendingRelDelete::relnode.

Referenced by RecordTransactionAbort(), RecordTransactionCommit(), and StartPrepare().

{
    int         nestLevel = GetCurrentTransactionNestLevel();
    int         nrels;
    RelFileNode *rptr;
    PendingRelDelete *pending;

    nrels = 0;
    if (haveNonTemp)
        *haveNonTemp = false;
    for (pending = pendingDeletes; pending != NULL; pending = pending->next)
    {
        if (pending->nestLevel >= nestLevel && pending->atCommit == forCommit)
            nrels++;
    }
    if (nrels == 0)
    {
        *ptr = NULL;
        return 0;
    }
    rptr = (RelFileNode *) palloc(nrels * sizeof(RelFileNode));
    *ptr = rptr;
    for (pending = pendingDeletes; pending != NULL; pending = pending->next)
    {
        if (pending->nestLevel >= nestLevel && pending->atCommit == forCommit)
        {
            *rptr = pending->relnode;
            rptr++;
        }
        if (haveNonTemp && !pending->isTemp)
            *haveNonTemp = true;
    }
    return nrels;
}