smgr.c File Reference

#include "postgres.h"
#include "access/xlogutils.h"
#include "lib/ilist.h"
#include "storage/bufmgr.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/md.h"
#include "storage/smgr.h"
#include "utils/hsearch.h"
#include "utils/inval.h"

Include dependency graph for smgr.c:

Go to the source code of this file.

Data Structures
struct	f_smgr

Typedefs
typedef struct f_smgr	f_smgr

Functions
static void	smgrshutdown (int code, Datum arg)
void	smgrinit (void)
SMgrRelation	smgropen (RelFileLocator rlocator, BackendId backend)
void	smgrsetowner (SMgrRelation *owner, SMgrRelation reln)
void	smgrclearowner (SMgrRelation *owner, SMgrRelation reln)
bool	smgrexists (SMgrRelation reln, ForkNumber forknum)
void	smgrclose (SMgrRelation reln)
void	smgrrelease (SMgrRelation reln)
void	smgrreleaseall (void)
void	smgrcloseall (void)
void	smgrcloserellocator (RelFileLocatorBackend rlocator)
void	smgrcreate (SMgrRelation reln, ForkNumber forknum, bool isRedo)
void	smgrdosyncall (SMgrRelation *rels, int nrels)
void	smgrdounlinkall (SMgrRelation *rels, int nrels, bool isRedo)
void	smgrextend (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, const void *buffer, bool skipFsync)
void	smgrzeroextend (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, int nblocks, bool skipFsync)
bool	smgrprefetch (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
void	smgrread (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void *buffer)
void	smgrwrite (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, const void *buffer, bool skipFsync)
void	smgrwriteback (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
BlockNumber	smgrnblocks (SMgrRelation reln, ForkNumber forknum)
BlockNumber	smgrnblocks_cached (SMgrRelation reln, ForkNumber forknum)
void	smgrtruncate (SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nblocks)
void	smgrimmedsync (SMgrRelation reln, ForkNumber forknum)
void	AtEOXact_SMgr (void)
bool	ProcessBarrierSmgrRelease (void)

Variables
static const f_smgr	smgrsw []
static const int	NSmgr = lengthof(smgrsw)
static HTAB *	SMgrRelationHash = NULL
static dlist_head	unowned_relns

Typedef Documentation

f_smgr

typedef struct f_smgr f_smgr

Function Documentation

AtEOXact_SMgr()

void AtEOXact_SMgr

(

void

)

Definition at line 739 of file smgr.c.

{
    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);
    }
}

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

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

ProcessBarrierSmgrRelease()

bool ProcessBarrierSmgrRelease

(

void

)

Definition at line 763 of file smgr.c.

{
    smgrreleaseall();
    return true;
}

References smgrreleaseall().

Referenced by ProcessProcSignalBarrier().

smgrclearowner()

void smgrclearowner	(	SMgrRelation *	owner,
		SMgrRelation	reln
	)

Definition at line 231 of file smgr.c.

{
    /* 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);
}

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

Referenced by FreeFakeRelcacheEntry().

smgrclose()

void smgrclose

(

SMgrRelation

reln

)

Definition at line 260 of file smgr.c.

{
    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,
                    &(reln->smgr_rlocator),
                    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;
}

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

Referenced by AtEOXact_SMgr(), DropRelationFiles(), fill_seq_with_data(), heapam_relation_copy_data(), heapam_relation_set_new_filelocator(), index_copy_data(), RelationCloseSmgr(), RelationSetNewRelfilenumber(), ScanSourceDatabasePgClass(), smgrcloseall(), smgrcloserellocator(), and smgrDoPendingDeletes().

smgrcloseall()

void smgrcloseall

(

void

)

Definition at line 327 of file smgr.c.

{
    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);
}

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

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

smgrcloserellocator()

void smgrcloserellocator

(

RelFileLocatorBackend

rlocator

)

Definition at line 351 of file smgr.c.

{
    SMgrRelation reln;
 
    /* Nothing to do if hashtable not set up */
    if (SMgrRelationHash == NULL)
        return;
 
    reln = (SMgrRelation) hash_search(SMgrRelationHash,
                                      &rlocator,
                                      HASH_FIND, NULL);
    if (reln != NULL)
        smgrclose(reln);
}

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

Referenced by CreateAndCopyRelationData(), and LocalExecuteInvalidationMessage().

smgrcreate()

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

Definition at line 374 of file smgr.c.

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

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

Referenced by CreateAndCopyRelationData(), ExtendBufferedRelTo(), fill_seq_with_data(), heapam_relation_copy_data(), heapam_relation_set_new_filelocator(), index_build(), index_copy_data(), RelationCreateStorage(), smgr_redo(), and XLogReadBufferExtended().

smgrdosyncall()

void smgrdosyncall	(	SMgrRelation *	rels,
		int	nrels
	)

Definition at line 389 of file smgr.c.

{
    int         i = 0;
    ForkNumber  forknum;
 
    if (nrels == 0)
        return;
 
    FlushRelationsAllBuffers(rels, nrels);
 
    /*
     * Sync the physical file(s).
     */
    for (i = 0; i < nrels; i++)
    {
        int         which = rels[i]->smgr_which;
 
        for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
        {
            if (smgrsw[which].smgr_exists(rels[i], forknum))
                smgrsw[which].smgr_immedsync(rels[i], forknum);
        }
    }
}

References FlushRelationsAllBuffers(), i, MAX_FORKNUM, f_smgr::smgr_immedsync, SMgrRelationData::smgr_which, and smgrsw.

Referenced by smgrDoPendingSyncs().

smgrdounlinkall()

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

Definition at line 425 of file smgr.c.

{
    int         i = 0;
    RelFileLocatorBackend *rlocators;
    ForkNumber  forknum;
 
    if (nrels == 0)
        return;
 
    /*
     * Get rid of any remaining buffers for the relations.  bufmgr will just
     * drop them without bothering to write the contents.
     */
    DropRelationsAllBuffers(rels, nrels);
 
    /*
     * create an array which contains all relations to be dropped, and close
     * each relation's forks at the smgr level while at it
     */
    rlocators = palloc(sizeof(RelFileLocatorBackend) * nrels);
    for (i = 0; i < nrels; i++)
    {
        RelFileLocatorBackend rlocator = rels[i]->smgr_rlocator;
        int         which = rels[i]->smgr_which;
 
        rlocators[i] = rlocator;
 
        /* Close the forks at smgr level */
        for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
            smgrsw[which].smgr_close(rels[i], forknum);
    }
 
    /*
     * 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(rlocators[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(rlocators[i], forknum, isRedo);
    }
 
    pfree(rlocators);
}

References CacheInvalidateSmgr(), DropRelationsAllBuffers(), i, MAX_FORKNUM, palloc(), pfree(), SMgrRelationData::smgr_rlocator, SMgrRelationData::smgr_which, and smgrsw.

Referenced by DropRelationFiles(), RelationSetNewRelfilenumber(), and smgrDoPendingDeletes().

smgrexists()

bool smgrexists	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 251 of file smgr.c.

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

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

Referenced by autoprewarm_database_main(), bt_index_check_internal(), CreateAndCopyRelationData(), DropRelationsAllBuffers(), ExtendBufferedRelTo(), FreeSpaceMapPrepareTruncateRel(), fsm_readbuf(), heapam_relation_copy_data(), index_build(), index_copy_data(), pg_prewarm(), RelationTruncate(), smgr_redo(), smgrDoPendingSyncs(), visibilitymap_prepare_truncate(), vm_readbuf(), and XLogPrefetcherNextBlock().

smgrextend()

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

Definition at line 498 of file smgr.c.

{
    smgrsw[reln->smgr_which].smgr_extend(reln, forknum, blocknum,
                                         buffer, skipFsync);
 
    /*
     * Normally we expect this to increase nblocks by one, but if the cached
     * value isn't as expected, just invalidate it so the next call asks the
     * kernel.
     */
    if (reln->smgr_cached_nblocks[forknum] == blocknum)
        reln->smgr_cached_nblocks[forknum] = blocknum + 1;
    else
        reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
}

References InvalidBlockNumber, SMgrRelationData::smgr_cached_nblocks, f_smgr::smgr_extend, SMgrRelationData::smgr_which, and smgrsw.

Referenced by _bt_blwritepage(), _hash_alloc_buckets(), end_heap_rewrite(), gist_indexsortbuild(), gist_indexsortbuild_flush_ready_pages(), raw_heap_insert(), RelationCopyStorage(), and RelationCopyStorageUsingBuffer().

smgrimmedsync()

void smgrimmedsync	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 721 of file smgr.c.

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

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

Referenced by _bt_load(), end_heap_rewrite(), gist_indexsortbuild(), and RelationCopyStorage().

smgrinit()

void smgrinit

(

void

)

Definition at line 115 of file smgr.c.

{
    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);
}

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

Referenced by BaseInit().

smgrnblocks()

BlockNumber smgrnblocks	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 609 of file smgr.c.

{
    BlockNumber result;
 
    /* Check and return if we get the cached value for the number of blocks. */
    result = smgrnblocks_cached(reln, forknum);
    if (result != InvalidBlockNumber)
        return result;
 
    result = smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
 
    reln->smgr_cached_nblocks[forknum] = result;
 
    return result;
}

References InvalidBlockNumber, SMgrRelationData::smgr_cached_nblocks, f_smgr::smgr_nblocks, SMgrRelationData::smgr_which, smgrnblocks_cached(), and smgrsw.

Referenced by ExtendBufferedRelLocal(), ExtendBufferedRelShared(), ExtendBufferedRelTo(), FreeSpaceMapPrepareTruncateRel(), fsm_readbuf(), gistBuildCallback(), RelationCopyStorage(), RelationCopyStorageUsingBuffer(), RelationGetNumberOfBlocksInFork(), ScanSourceDatabasePgClass(), smgrDoPendingSyncs(), table_block_relation_size(), visibilitymap_prepare_truncate(), vm_readbuf(), XLogPrefetcherNextBlock(), and XLogReadBufferExtended().

smgrnblocks_cached()

BlockNumber smgrnblocks_cached	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 633 of file smgr.c.

{
    /*
     * For now, we only use cached values in recovery due to lack of a shared
     * invalidation mechanism for changes in file size.
     */
    if (InRecovery && reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
        return reln->smgr_cached_nblocks[forknum];
 
    return InvalidBlockNumber;
}

References InRecovery, InvalidBlockNumber, and SMgrRelationData::smgr_cached_nblocks.

Referenced by DropRelationBuffers(), DropRelationsAllBuffers(), and smgrnblocks().

smgropen()

SMgrRelation smgropen	(	RelFileLocator	rlocator,
		BackendId	backend
	)

Definition at line 150 of file smgr.c.

{
    RelFileLocatorBackend brlocator;
    SMgrRelation reln;
    bool        found;
 
    if (SMgrRelationHash == NULL)
    {
        /* First time through: initialize the hash table */
        HASHCTL     ctl;
 
        ctl.keysize = sizeof(RelFileLocatorBackend);
        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 */
    brlocator.locator = rlocator;
    brlocator.backend = backend;
    reln = (SMgrRelation) hash_search(SMgrRelationHash,
                                      &brlocator,
                                      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;
        for (int i = 0; i <= MAX_FORKNUM; ++i)
            reln->smgr_cached_nblocks[i] = 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;
}

References RelFileLocatorBackend::backend, dlist_init(), dlist_push_tail(), HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), i, InvalidBlockNumber, HASHCTL::keysize, RelFileLocatorBackend::locator, MAX_FORKNUM, SMgrRelationData::node, SMgrRelationData::smgr_cached_nblocks, f_smgr::smgr_open, SMgrRelationData::smgr_owner, SMgrRelationData::smgr_targblock, SMgrRelationData::smgr_which, SMgrRelationHash, smgrsw, and unowned_relns.

Referenced by CreateAndCopyRelationData(), DropRelationFiles(), fill_seq_with_data(), FlushBuffer(), GetLocalVictimBuffer(), heapam_relation_copy_data(), index_copy_data(), IssuePendingWritebacks(), mdsyncfiletag(), ReadBufferWithoutRelcache(), RelationCopyStorageUsingBuffer(), RelationCreateStorage(), RelationGetSmgr(), RelationSetNewRelfilenumber(), ScanSourceDatabasePgClass(), smgr_redo(), smgrDoPendingDeletes(), smgrDoPendingSyncs(), XLogPrefetcherNextBlock(), and XLogReadBufferExtended().

smgrprefetch()

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

Definition at line 548 of file smgr.c.

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

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

Referenced by PrefetchLocalBuffer(), and PrefetchSharedBuffer().

smgrread()

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

Definition at line 562 of file smgr.c.

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

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

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

smgrrelease()

void smgrrelease

(

SMgrRelation

reln

)

Definition at line 292 of file smgr.c.

{
    for (ForkNumber forknum = 0; forknum <= MAX_FORKNUM; forknum++)
    {
        smgrsw[reln->smgr_which].smgr_close(reln, forknum);
        reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
    }
    reln->smgr_targblock = InvalidBlockNumber;
}

References InvalidBlockNumber, MAX_FORKNUM, SMgrRelationData::smgr_cached_nblocks, f_smgr::smgr_close, SMgrRelationData::smgr_targblock, SMgrRelationData::smgr_which, and smgrsw.

Referenced by smgrreleaseall().

smgrreleaseall()

void smgrreleaseall

(

void

)

Definition at line 308 of file smgr.c.

{
    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)
        smgrrelease(reln);
}

References hash_seq_init(), hash_seq_search(), SMgrRelationHash, and smgrrelease().

Referenced by ProcessBarrierSmgrRelease().

smgrsetowner()

void smgrsetowner	(	SMgrRelation *	owner,
		SMgrRelation	reln
	)

Definition at line 202 of file smgr.c.

{
    /* 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;
}

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

Referenced by RelationGetSmgr().

smgrshutdown()

static void smgrshutdown ( int  code, Datum  arg  )

static

Definition at line 133 of file smgr.c.

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

References i, NSmgr, f_smgr::smgr_shutdown, and smgrsw.

Referenced by smgrinit().

smgrtruncate()

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

Definition at line 656 of file smgr.c.

{
    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.
     */
    DropRelationBuffers(reln, 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_rlocator);
 
    /* Do the truncation */
    for (i = 0; i < nforks; i++)
    {
        /* Make the cached size is invalid if we encounter an error. */
        reln->smgr_cached_nblocks[forknum[i]] = InvalidBlockNumber;
 
        smgrsw[reln->smgr_which].smgr_truncate(reln, forknum[i], nblocks[i]);
 
        /*
         * We might as well update the local smgr_cached_nblocks values. 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.
         */
        reln->smgr_cached_nblocks[forknum[i]] = nblocks[i];
    }
}

References CacheInvalidateSmgr(), DropRelationBuffers(), i, InvalidBlockNumber, SMgrRelationData::smgr_cached_nblocks, SMgrRelationData::smgr_rlocator, f_smgr::smgr_truncate, SMgrRelationData::smgr_which, and smgrsw.

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

smgrwrite()

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

Definition at line 584 of file smgr.c.

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

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

Referenced by _bt_blwritepage(), FlushBuffer(), FlushRelationBuffers(), GetLocalVictimBuffer(), and gist_indexsortbuild().

smgrwriteback()

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

Definition at line 597 of file smgr.c.

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

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

Referenced by IssuePendingWritebacks().

smgrzeroextend()

void smgrzeroextend	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		int	nblocks,
		bool	skipFsync
	)

Definition at line 523 of file smgr.c.

{
    smgrsw[reln->smgr_which].smgr_zeroextend(reln, forknum, blocknum,
                                             nblocks, skipFsync);
 
    /*
     * Normally we expect this to increase the fork size by nblocks, but if
     * the cached value isn't as expected, just invalidate it so the next call
     * asks the kernel.
     */
    if (reln->smgr_cached_nblocks[forknum] == blocknum)
        reln->smgr_cached_nblocks[forknum] = blocknum + nblocks;
    else
        reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
}

References InvalidBlockNumber, SMgrRelationData::smgr_cached_nblocks, SMgrRelationData::smgr_which, f_smgr::smgr_zeroextend, and smgrsw.

Referenced by ExtendBufferedRelLocal(), and ExtendBufferedRelShared().

Variable Documentation

NSmgr

const int NSmgr = lengthof(smgrsw)

static

Definition at line 92 of file smgr.c.

Referenced by smgrinit(), and smgrshutdown().

SMgrRelationHash

HTAB* SMgrRelationHash = NULL

static

Definition at line 98 of file smgr.c.

Referenced by smgrclose(), smgrcloseall(), smgrcloserellocator(), smgropen(), and smgrreleaseall().

smgrsw

const f_smgr smgrsw[]

static

Initial value:

= {
    
    {
        .smgr_init = mdinit,
        .smgr_shutdown = NULL,
        .smgr_open = mdopen,
        .smgr_close = mdclose,
        .smgr_create = mdcreate,
        .smgr_exists = mdexists,
        .smgr_unlink = mdunlink,
        .smgr_extend = mdextend,
        .smgr_zeroextend = mdzeroextend,
        .smgr_prefetch = mdprefetch,
        .smgr_read = mdread,
        .smgr_write = mdwrite,
        .smgr_writeback = mdwriteback,
        .smgr_nblocks = mdnblocks,
        .smgr_truncate = mdtruncate,
        .smgr_immedsync = mdimmedsync,
    }
}

Definition at line 70 of file smgr.c.

Referenced by smgrclose(), smgrcreate(), smgrdosyncall(), smgrdounlinkall(), smgrexists(), smgrextend(), smgrimmedsync(), smgrinit(), smgrnblocks(), smgropen(), smgrprefetch(), smgrread(), smgrrelease(), smgrshutdown(), smgrtruncate(), smgrwrite(), smgrwriteback(), and smgrzeroextend().

unowned_relns

dlist_head unowned_relns

static

Definition at line 100 of file smgr.c.

Referenced by AtEOXact_SMgr(), smgrclearowner(), and smgropen().