smgr.h File Reference

#include "lib/ilist.h"
#include "storage/block.h"
#include "storage/relfilenode.h"

Include dependency graph for smgr.h:

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

Go to the source code of this file.

Data Structures
struct	SMgrRelationData

Macros
#define	SmgrIsTemp(smgr)   RelFileNodeBackendIsTemp((smgr)->smgr_rnode)

Typedefs
typedef struct SMgrRelationData	SMgrRelationData
typedef SMgrRelationData *	SMgrRelation

Functions
void	smgrinit (void)
SMgrRelation	smgropen (RelFileNode rnode, BackendId backend)
bool	smgrexists (SMgrRelation reln, ForkNumber forknum)
void	smgrsetowner (SMgrRelation *owner, SMgrRelation reln)
void	smgrclearowner (SMgrRelation *owner, SMgrRelation reln)
void	smgrclose (SMgrRelation reln)
void	smgrcloseall (void)
void	smgrclosenode (RelFileNodeBackend rnode)
void	smgrcreate (SMgrRelation reln, ForkNumber forknum, bool isRedo)
void	smgrdounlink (SMgrRelation reln, bool isRedo)
void	smgrdounlinkall (SMgrRelation *rels, int nrels, bool isRedo)
void	smgrextend (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
void	smgrprefetch (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
void	smgrread (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer)
void	smgrwrite (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
void	smgrwriteback (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
BlockNumber	smgrnblocks (SMgrRelation reln, ForkNumber forknum)
void	smgrtruncate (SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nblocks)
void	smgrimmedsync (SMgrRelation reln, ForkNumber forknum)
void	AtEOXact_SMgr (void)

Macro Definition Documentation

SmgrIsTemp

#define SmgrIsTemp

(

smgr

)

RelFileNodeBackendIsTemp((smgr)->smgr_rnode)

Definition at line 79 of file smgr.h.

Referenced by mdextend(), mdtruncate(), mdwrite(), ReadBuffer_common(), and register_dirty_segment().

Typedef Documentation

SMgrRelation

typedef SMgrRelationData* SMgrRelation

Definition at line 77 of file smgr.h.

SMgrRelationData

typedef struct SMgrRelationData SMgrRelationData

Function Documentation

AtEOXact_SMgr()

void AtEOXact_SMgr

(

void

)

Definition at line 655 of file smgr.c.

References Assert, dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, SMgrRelationData::smgr_owner, and smgrclose().

Referenced by AbortTransaction(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), CommitTransaction(), PrepareTransaction(), and WalWriterMain().

{
    dlist_mutable_iter iter;

    /*
     * Zap all unowned SMgrRelations.  We rely on smgrclose() to remove each
     * one from the list.
     */
    dlist_foreach_modify(iter, &unowned_relns)
    {
        SMgrRelation rel = dlist_container(SMgrRelationData, node,
                                           iter.cur);

        Assert(rel->smgr_owner == NULL);

        smgrclose(rel);
    }
}

smgrclearowner()

void smgrclearowner	(	SMgrRelation *	owner,
		SMgrRelation	reln
	)

Definition at line 227 of file smgr.c.

References dlist_push_tail(), SMgrRelationData::node, and SMgrRelationData::smgr_owner.

Referenced by FreeFakeRelcacheEntry().

{
    /* Do nothing if the SMgrRelation object is not owned by the owner */
    if (reln->smgr_owner != owner)
        return;

    /* unset the owner's reference */
    *owner = NULL;

    /* unset our reference to the owner */
    reln->smgr_owner = NULL;

    /* add to list of unowned relations */
    dlist_push_tail(&unowned_relns, &reln->node);
}

smgrclose()

void smgrclose

(

SMgrRelation

reln

)

Definition at line 256 of file smgr.c.

References dlist_delete(), elog, ERROR, HASH_REMOVE, hash_search(), MAX_FORKNUM, SMgrRelationData::node, f_smgr::smgr_close, SMgrRelationData::smgr_owner, SMgrRelationData::smgr_rnode, and SMgrRelationData::smgr_which.

Referenced by AtEOXact_SMgr(), DropRelationFiles(), heapam_relation_copy_data(), heapam_relation_set_new_filenode(), index_copy_data(), RelationSetNewRelfilenode(), smgrcloseall(), smgrclosenode(), and smgrDoPendingDeletes().

{
    SMgrRelation *owner;
    ForkNumber  forknum;

    for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
        smgrsw[reln->smgr_which].smgr_close(reln, forknum);

    owner = reln->smgr_owner;

    if (!owner)
        dlist_delete(&reln->node);

    if (hash_search(SMgrRelationHash,
                    (void *) &(reln->smgr_rnode),
                    HASH_REMOVE, NULL) == NULL)
        elog(ERROR, "SMgrRelation hashtable corrupted");

    /*
     * Unhook the owner pointer, if any.  We do this last since in the remote
     * possibility of failure above, the SMgrRelation object will still exist.
     */
    if (owner)
        *owner = NULL;
}

smgrcloseall()

void smgrcloseall

(

void

)

Definition at line 286 of file smgr.c.

References hash_seq_init(), hash_seq_search(), smgrclose(), and status().

Referenced by BackgroundWriterMain(), CheckpointerMain(), RelationCacheInvalidate(), RequestCheckpoint(), WalWriterMain(), and XLogDropDatabase().

{
    HASH_SEQ_STATUS status;
    SMgrRelation reln;

    /* Nothing to do if hashtable not set up */
    if (SMgrRelationHash == NULL)
        return;

    hash_seq_init(&status, SMgrRelationHash);

    while ((reln = (SMgrRelation) hash_seq_search(&status)) != NULL)
        smgrclose(reln);
}

smgrclosenode()

void smgrclosenode

(

RelFileNodeBackend

rnode

)

Definition at line 310 of file smgr.c.

References HASH_FIND, hash_search(), and smgrclose().

Referenced by LocalExecuteInvalidationMessage().

{
    SMgrRelation reln;

    /* Nothing to do if hashtable not set up */
    if (SMgrRelationHash == NULL)
        return;

    reln = (SMgrRelation) hash_search(SMgrRelationHash,
                                      (void *) &rnode,
                                      HASH_FIND, NULL);
    if (reln != NULL)
        smgrclose(reln);
}

smgrcreate()

void smgrcreate	(	SMgrRelation	reln,
		ForkNumber	forknum,
		bool	isRedo
	)

Definition at line 333 of file smgr.c.

References f_smgr::smgr_create, and SMgrRelationData::smgr_which.

Referenced by fsm_extend(), heapam_relation_copy_data(), heapam_relation_set_new_filenode(), index_build(), index_copy_data(), RelationCreateStorage(), smgr_redo(), vm_extend(), and XLogReadBufferExtended().

{
    smgrsw[reln->smgr_which].smgr_create(reln, forknum, isRedo);
}

smgrdounlink()

void smgrdounlink	(	SMgrRelation	reln,
		bool	isRedo
	)

Definition at line 348 of file smgr.c.

References CacheInvalidateSmgr(), DropRelFileNodesAllBuffers(), InvalidForkNumber, MAX_FORKNUM, f_smgr::smgr_close, SMgrRelationData::smgr_rnode, f_smgr::smgr_unlink, and SMgrRelationData::smgr_which.

{
    RelFileNodeBackend rnode = reln->smgr_rnode;
    int         which = reln->smgr_which;
    ForkNumber  forknum;

    /* Close the forks at smgr level */
    for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
        smgrsw[which].smgr_close(reln, forknum);

    /*
     * Get rid of any remaining buffers for the relation.  bufmgr will just
     * drop them without bothering to write the contents.
     */
    DropRelFileNodesAllBuffers(&rnode, 1);

    /*
     * It'd be nice to tell the stats collector to forget it immediately, too.
     * But we can't because we don't know the OID (and in cases involving
     * relfilenode swaps, it's not always clear which table OID to forget,
     * anyway).
     */

    /*
     * Send a shared-inval message to force other backends to close any
     * dangling smgr references they may have for this rel.  We should do this
     * before starting the actual unlinking, in case we fail partway through
     * that step.  Note that the sinval message will eventually come back to
     * this backend, too, and thereby provide a backstop that we closed our
     * own smgr rel.
     */
    CacheInvalidateSmgr(rnode);

    /*
     * Delete the physical file(s).
     *
     * Note: smgr_unlink must treat deletion failure as a WARNING, not an
     * ERROR, because we've already decided to commit or abort the current
     * xact.
     */
    smgrsw[which].smgr_unlink(rnode, InvalidForkNumber, isRedo);
}

smgrdounlinkall()

void smgrdounlinkall	(	SMgrRelation *	rels,
		int	nrels,
		bool	isRedo
	)

Definition at line 405 of file smgr.c.

References CacheInvalidateSmgr(), DropRelFileNodesAllBuffers(), i, MAX_FORKNUM, palloc(), pfree(), f_smgr::smgr_close, SMgrRelationData::smgr_rnode, f_smgr::smgr_unlink, and SMgrRelationData::smgr_which.

Referenced by DropRelationFiles(), and smgrDoPendingDeletes().

{
    int         i = 0;
    RelFileNodeBackend *rnodes;
    ForkNumber  forknum;

    if (nrels == 0)
        return;

    /*
     * create an array which contains all relations to be dropped, and close
     * each relation's forks at the smgr level while at it
     */
    rnodes = palloc(sizeof(RelFileNodeBackend) * nrels);
    for (i = 0; i < nrels; i++)
    {
        RelFileNodeBackend rnode = rels[i]->smgr_rnode;
        int         which = rels[i]->smgr_which;

        rnodes[i] = rnode;

        /* Close the forks at smgr level */
        for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
            smgrsw[which].smgr_close(rels[i], forknum);
    }

    /*
     * Get rid of any remaining buffers for the relations.  bufmgr will just
     * drop them without bothering to write the contents.
     */
    DropRelFileNodesAllBuffers(rnodes, nrels);

    /*
     * It'd be nice to tell the stats collector to forget them immediately,
     * too. But we can't because we don't know the OIDs.
     */

    /*
     * Send a shared-inval message to force other backends to close any
     * dangling smgr references they may have for these rels.  We should do
     * this before starting the actual unlinking, in case we fail partway
     * through that step.  Note that the sinval messages will eventually come
     * back to this backend, too, and thereby provide a backstop that we
     * closed our own smgr rel.
     */
    for (i = 0; i < nrels; i++)
        CacheInvalidateSmgr(rnodes[i]);

    /*
     * Delete the physical file(s).
     *
     * Note: smgr_unlink must treat deletion failure as a WARNING, not an
     * ERROR, because we've already decided to commit or abort the current
     * xact.
     */

    for (i = 0; i < nrels; i++)
    {
        int         which = rels[i]->smgr_which;

        for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
            smgrsw[which].smgr_unlink(rnodes[i], forknum, isRedo);
    }

    pfree(rnodes);
}

smgrexists()

bool smgrexists	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 247 of file smgr.c.

References f_smgr::smgr_exists, and SMgrRelationData::smgr_which.

Referenced by autoprewarm_database_main(), bt_index_check_internal(), FreeSpaceMapPrepareTruncateRel(), fsm_extend(), fsm_readbuf(), heapam_relation_copy_data(), index_build(), index_copy_data(), pg_prewarm(), RelationTruncate(), smgr_redo(), visibilitymap_prepare_truncate(), vm_extend(), and vm_readbuf().

{
    return smgrsw[reln->smgr_which].smgr_exists(reln, forknum);
}

smgrextend()

void smgrextend	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		char *	buffer,
		bool	skipFsync
	)

Definition at line 483 of file smgr.c.

References f_smgr::smgr_extend, and SMgrRelationData::smgr_which.

Referenced by _bt_blwritepage(), _hash_alloc_buckets(), end_heap_rewrite(), fsm_extend(), raw_heap_insert(), ReadBuffer_common(), RelationCopyStorage(), and vm_extend().

{
    smgrsw[reln->smgr_which].smgr_extend(reln, forknum, blocknum,
                                         buffer, skipFsync);
}

smgrimmedsync()

void smgrimmedsync	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 637 of file smgr.c.

References f_smgr::smgr_immedsync, and SMgrRelationData::smgr_which.

Referenced by _bt_load(), blbuildempty(), btbuildempty(), heap_sync(), heapam_relation_set_new_filenode(), RelationCopyStorage(), and spgbuildempty().

{
    smgrsw[reln->smgr_which].smgr_immedsync(reln, forknum);
}

smgrinit()

void smgrinit

(

void

)

Definition at line 110 of file smgr.c.

References i, NSmgr, on_proc_exit(), f_smgr::smgr_init, and smgrshutdown().

Referenced by BaseInit().

{
    int         i;

    for (i = 0; i < NSmgr; i++)
    {
        if (smgrsw[i].smgr_init)
            smgrsw[i].smgr_init();
    }

    /* register the shutdown proc */
    on_proc_exit(smgrshutdown, 0);
}

smgrnblocks()

BlockNumber smgrnblocks	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 555 of file smgr.c.

References f_smgr::smgr_nblocks, and SMgrRelationData::smgr_which.

Referenced by FreeSpaceMapPrepareTruncateRel(), fsm_extend(), fsm_readbuf(), gistBuildCallback(), ReadBuffer_common(), RelationCopyStorage(), RelationGetNumberOfBlocksInFork(), table_block_relation_size(), visibilitymap_prepare_truncate(), vm_extend(), vm_readbuf(), and XLogReadBufferExtended().

{
    return smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
}

smgropen()

SMgrRelation smgropen	(	RelFileNode	rnode,
		BackendId	backend
	)

Definition at line 145 of file smgr.c.

References RelFileNodeBackend::backend, dlist_init(), dlist_push_tail(), HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), InvalidBlockNumber, HASHCTL::keysize, MemSet, RelFileNodeBackend::node, SMgrRelationData::node, SMgrRelationData::smgr_fsm_nblocks, f_smgr::smgr_open, SMgrRelationData::smgr_owner, SMgrRelationData::smgr_targblock, SMgrRelationData::smgr_vm_nblocks, and SMgrRelationData::smgr_which.

Referenced by DropRelationFiles(), FlushBuffer(), heapam_relation_copy_data(), index_copy_data(), IssuePendingWritebacks(), LocalBufferAlloc(), mdsyncfiletag(), ReadBufferWithoutRelcache(), RelationCreateStorage(), smgr_redo(), smgrDoPendingDeletes(), and XLogReadBufferExtended().

{
    RelFileNodeBackend brnode;
    SMgrRelation reln;
    bool        found;

    if (SMgrRelationHash == NULL)
    {
        /* First time through: initialize the hash table */
        HASHCTL     ctl;

        MemSet(&ctl, 0, sizeof(ctl));
        ctl.keysize = sizeof(RelFileNodeBackend);
        ctl.entrysize = sizeof(SMgrRelationData);
        SMgrRelationHash = hash_create("smgr relation table", 400,
                                       &ctl, HASH_ELEM | HASH_BLOBS);
        dlist_init(&unowned_relns);
    }

    /* Look up or create an entry */
    brnode.node = rnode;
    brnode.backend = backend;
    reln = (SMgrRelation) hash_search(SMgrRelationHash,
                                      (void *) &brnode,
                                      HASH_ENTER, &found);

    /* Initialize it if not present before */
    if (!found)
    {
        /* hash_search already filled in the lookup key */
        reln->smgr_owner = NULL;
        reln->smgr_targblock = InvalidBlockNumber;
        reln->smgr_fsm_nblocks = InvalidBlockNumber;
        reln->smgr_vm_nblocks = InvalidBlockNumber;
        reln->smgr_which = 0;   /* we only have md.c at present */

        /* implementation-specific initialization */
        smgrsw[reln->smgr_which].smgr_open(reln);

        /* it has no owner yet */
        dlist_push_tail(&unowned_relns, &reln->node);
    }

    return reln;
}

smgrprefetch()

void smgrprefetch	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum
	)

Definition at line 494 of file smgr.c.

References f_smgr::smgr_prefetch, and SMgrRelationData::smgr_which.

Referenced by LocalPrefetchBuffer(), and PrefetchBuffer().

{
    smgrsw[reln->smgr_which].smgr_prefetch(reln, forknum, blocknum);
}

smgrread()

void smgrread	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		char *	buffer
	)

Definition at line 508 of file smgr.c.

References f_smgr::smgr_read, and SMgrRelationData::smgr_which.

Referenced by pg_prewarm(), ReadBuffer_common(), and RelationCopyStorage().

{
    smgrsw[reln->smgr_which].smgr_read(reln, forknum, blocknum, buffer);
}

smgrsetowner()

void smgrsetowner	(	SMgrRelation *	owner,
		SMgrRelation	reln
	)

Definition at line 198 of file smgr.c.

References Assert, dlist_delete(), SMgrRelationData::node, and SMgrRelationData::smgr_owner.

{
    /* We don't support "disowning" an SMgrRelation here, use smgrclearowner */
    Assert(owner != NULL);

    /*
     * First, unhook any old owner.  (Normally there shouldn't be any, but it
     * seems possible that this can happen during swap_relation_files()
     * depending on the order of processing.  It's ok to close the old
     * relcache entry early in that case.)
     *
     * If there isn't an old owner, then the reln should be in the unowned
     * list, and we need to remove it.
     */
    if (reln->smgr_owner)
        *(reln->smgr_owner) = NULL;
    else
        dlist_delete(&reln->node);

    /* Now establish the ownership relationship. */
    reln->smgr_owner = owner;
    *owner = reln;
}

smgrtruncate()

void smgrtruncate	(	SMgrRelation	reln,
		ForkNumber *	forknum,
		int	nforks,
		BlockNumber *	nblocks
	)

Definition at line 571 of file smgr.c.

References CacheInvalidateSmgr(), DropRelFileNodeBuffers(), FSM_FORKNUM, i, SMgrRelationData::smgr_fsm_nblocks, SMgrRelationData::smgr_rnode, f_smgr::smgr_truncate, SMgrRelationData::smgr_vm_nblocks, SMgrRelationData::smgr_which, and VISIBILITYMAP_FORKNUM.

Referenced by pg_truncate_visibility_map(), RelationTruncate(), and smgr_redo().

{
    int     i;

    /*
     * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
     * just drop them without bothering to write the contents.
     */
    DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);

    /*
     * Send a shared-inval message to force other backends to close any smgr
     * references they may have for this rel.  This is useful because they
     * might have open file pointers to segments that got removed, and/or
     * smgr_targblock variables pointing past the new rel end.  (The inval
     * message will come back to our backend, too, causing a
     * probably-unnecessary local smgr flush.  But we don't expect that this
     * is a performance-critical path.)  As in the unlink code, we want to be
     * sure the message is sent before we start changing things on-disk.
     */
    CacheInvalidateSmgr(reln->smgr_rnode);

    /* Do the truncation */
    for (i = 0; i < nforks; i++)
    {
        smgrsw[reln->smgr_which].smgr_truncate(reln, forknum[i], nblocks[i]);

        /*
         * We might as well update the local smgr_fsm_nblocks and
         * smgr_vm_nblocks settings. The smgr cache inval message that
         * this function sent will cause other backends to invalidate
         * their copies of smgr_fsm_nblocks and smgr_vm_nblocks,
         * and these ones too at the next command boundary.
         * But these ensure they aren't outright wrong until then.
         */
        if (forknum[i] == FSM_FORKNUM)
            reln->smgr_fsm_nblocks = nblocks[i];
        if (forknum[i] == VISIBILITYMAP_FORKNUM)
            reln->smgr_vm_nblocks = nblocks[i];
    }
}

smgrwrite()

void smgrwrite	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		char *	buffer,
		bool	skipFsync
	)

Definition at line 530 of file smgr.c.

References SMgrRelationData::smgr_which, and f_smgr::smgr_write.

Referenced by _bt_blwritepage(), blbuildempty(), btbuildempty(), FlushBuffer(), FlushRelationBuffers(), LocalBufferAlloc(), and spgbuildempty().

{
    smgrsw[reln->smgr_which].smgr_write(reln, forknum, blocknum,
                                        buffer, skipFsync);
}

smgrwriteback()

void smgrwriteback	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		BlockNumber	nblocks
	)

Definition at line 543 of file smgr.c.

References SMgrRelationData::smgr_which, and f_smgr::smgr_writeback.

Referenced by IssuePendingWritebacks().

{
    smgrsw[reln->smgr_which].smgr_writeback(reln, forknum, blocknum,
                                            nblocks);
}