smgr.h File Reference

#include "lib/ilist.h"
#include "storage/block.h"
#include "storage/relfilelocator.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)    RelFileLocatorBackendIsTemp((smgr)->smgr_rlocator)

Typedefs
typedef struct SMgrRelationData	SMgrRelationData
typedef SMgrRelationData *	SMgrRelation

Functions
void	smgrinit (void)
SMgrRelation	smgropen (RelFileLocator rlocator, ProcNumber backend)
bool	smgrexists (SMgrRelation reln, ForkNumber forknum)
void	smgrpin (SMgrRelation reln)
void	smgrunpin (SMgrRelation reln)
void	smgrclose (SMgrRelation reln)
void	smgrdestroyall (void)
void	smgrrelease (SMgrRelation reln)
void	smgrreleaseall (void)
void	smgrreleaserellocator (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, int nblocks)
uint32	smgrmaxcombine (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
void	smgrreadv (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void **buffers, BlockNumber nblocks)
void	smgrwritev (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, const void **buffers, BlockNumber nblocks, 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 *old_nblocks, BlockNumber *nblocks)
void	smgrimmedsync (SMgrRelation reln, ForkNumber forknum)
void	smgrregistersync (SMgrRelation reln, ForkNumber forknum)
void	AtEOXact_SMgr (void)
bool	ProcessBarrierSmgrRelease (void)
static void	smgrread (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void *buffer)
static void	smgrwrite (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, const void *buffer, bool skipFsync)

Macro Definition Documentation

SmgrIsTemp

#define SmgrIsTemp

(

smgr

)

RelFileLocatorBackendIsTemp((smgr)->smgr_rlocator)

Definition at line 73 of file smgr.h.

Typedef Documentation

SMgrRelation

typedef SMgrRelationData* SMgrRelation

Definition at line 71 of file smgr.h.

SMgrRelationData

typedef struct SMgrRelationData SMgrRelationData

Function Documentation

AtEOXact_SMgr()

void AtEOXact_SMgr

(

void

)

Definition at line 933 of file smgr.c.

{
    smgrdestroyall();
}

References smgrdestroyall().

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

ProcessBarrierSmgrRelease()

bool ProcessBarrierSmgrRelease

(

void

)

Definition at line 943 of file smgr.c.

{
    smgrreleaseall();
    return true;
}

References smgrreleaseall().

Referenced by ProcessProcSignalBarrier().

smgrclose()

void smgrclose

(

SMgrRelation

reln

)

Definition at line 356 of file smgr.c.

{
    smgrrelease(reln);
}

References smgrrelease().

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

smgrcreate()

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

Definition at line 463 of file smgr.c.

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

References HOLD_INTERRUPTS, RESUME_INTERRUPTS, 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().

smgrdestroyall()

void smgrdestroyall

(

void

)

Definition at line 368 of file smgr.c.

{
    dlist_mutable_iter iter;
 
    /* seems unsafe to accept interrupts while in a dlist_foreach_modify() */
    HOLD_INTERRUPTS();
 
    /*
     * Zap all unpinned SMgrRelations.  We rely on smgrdestroy() to remove
     * each one from the list.
     */
    dlist_foreach_modify(iter, &unpinned_relns)
    {
        SMgrRelation rel = dlist_container(SMgrRelationData, node,
                                           iter.cur);
 
        smgrdestroy(rel);
    }
 
    RESUME_INTERRUPTS();
}

References dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, HOLD_INTERRUPTS, RESUME_INTERRUPTS, smgrdestroy(), and unpinned_relns.

Referenced by AtEOXact_SMgr(), BackgroundWriterMain(), CheckpointerMain(), RequestCheckpoint(), and XLogDropDatabase().

smgrdosyncall()

void smgrdosyncall	(	SMgrRelation *	rels,
		int	nrels
	)

Definition at line 480 of file smgr.c.

{
    int         i = 0;
    ForkNumber  forknum;
 
    if (nrels == 0)
        return;
 
    FlushRelationsAllBuffers(rels, nrels);
 
    HOLD_INTERRUPTS();
 
    /*
     * 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);
        }
    }
 
    RESUME_INTERRUPTS();
}

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

Referenced by smgrDoPendingSyncs().

smgrdounlinkall()

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

Definition at line 520 of file smgr.c.

{
    int         i = 0;
    RelFileLocatorBackend *rlocators;
    ForkNumber  forknum;
 
    if (nrels == 0)
        return;
 
    /*
     * It would be unsafe to process interrupts between DropRelationBuffers()
     * and unlinking the underlying files. This probably should be a critical
     * section, but we're not there yet.
     */
    HOLD_INTERRUPTS();
 
    /*
     * 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);
 
    RESUME_INTERRUPTS();
}

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

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

smgrexists()

bool smgrexists	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 444 of file smgr.c.

{
    bool        ret;
 
    HOLD_INTERRUPTS();
    ret = smgrsw[reln->smgr_which].smgr_exists(reln, forknum);
    RESUME_INTERRUPTS();
 
    return ret;
}

References HOLD_INTERRUPTS, RESUME_INTERRUPTS, 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 602 of file smgr.c.

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

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

Referenced by _hash_alloc_buckets(), RelationCopyStorageUsingBuffer(), and smgr_bulk_flush().

smgrimmedsync()

void smgrimmedsync	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 913 of file smgr.c.

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

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

Referenced by smgr_bulk_finish().

smgrinit()

void smgrinit

(

void

)

Definition at line 170 of file smgr.c.

{
    int         i;
 
    HOLD_INTERRUPTS();
 
    for (i = 0; i < NSmgr; i++)
    {
        if (smgrsw[i].smgr_init)
            smgrsw[i].smgr_init();
    }
 
    RESUME_INTERRUPTS();
 
    /* register the shutdown proc */
    on_proc_exit(smgrshutdown, 0);
}

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

Referenced by BaseInit().

smgrmaxcombine()

uint32 smgrmaxcombine	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum
	)

Definition at line 679 of file smgr.c.

{
    uint32      ret;
 
    HOLD_INTERRUPTS();
    ret = smgrsw[reln->smgr_which].smgr_maxcombine(reln, forknum, blocknum);
    RESUME_INTERRUPTS();
 
    return ret;
}

References HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_maxcombine, SMgrRelationData::smgr_which, and smgrsw.

Referenced by StartReadBuffersImpl().

smgrnblocks()

BlockNumber smgrnblocks	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 767 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;
 
    HOLD_INTERRUPTS();
 
    result = smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
 
    reln->smgr_cached_nblocks[forknum] = result;
 
    RESUME_INTERRUPTS();
 
    return result;
}

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

Referenced by ExtendBufferedRelLocal(), ExtendBufferedRelShared(), ExtendBufferedRelTo(), FreeSpaceMapPrepareTruncateRel(), fsm_readbuf(), gistBuildCallback(), pg_truncate_visibility_map(), RelationCopyStorage(), RelationCopyStorageUsingBuffer(), RelationGetNumberOfBlocksInFork(), RelationTruncate(), ScanSourceDatabasePgClass(), smgr_bulk_start_smgr(), smgr_redo(), 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 795 of file smgr.c.

{
    /*
     * For now, this function uses cached values only in recovery due to lack
     * of a shared invalidation mechanism for changes in file size.  Code
     * elsewhere reads smgr_cached_nblocks and copes with stale data.
     */
    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,
		ProcNumber	backend
	)

Definition at line 222 of file smgr.c.

{
    RelFileLocatorBackend brlocator;
    SMgrRelation reln;
    bool        found;
 
    Assert(RelFileNumberIsValid(rlocator.relNumber));
 
    HOLD_INTERRUPTS();
 
    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(&unpinned_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_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 */
 
        /* it is not pinned yet */
        reln->pincount = 0;
        dlist_push_tail(&unpinned_relns, &reln->node);
 
        /* implementation-specific initialization */
        smgrsw[reln->smgr_which].smgr_open(reln);
    }
 
    RESUME_INTERRUPTS();
 
    return reln;
}

References Assert(), RelFileLocatorBackend::backend, ctl, dlist_init(), dlist_push_tail(), HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), HOLD_INTERRUPTS, i, InvalidBlockNumber, RelFileLocatorBackend::locator, MAX_FORKNUM, SMgrRelationData::node, SMgrRelationData::pincount, RelFileNumberIsValid, RelFileLocator::relNumber, RESUME_INTERRUPTS, SMgrRelationData::smgr_cached_nblocks, f_smgr::smgr_open, SMgrRelationData::smgr_targblock, SMgrRelationData::smgr_which, SMgrRelationHash, smgrsw, and unpinned_relns.

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

smgrpin()

void smgrpin

(

SMgrRelation

reln

)

Definition at line 278 of file smgr.c.

{
    if (reln->pincount == 0)
        dlist_delete(&reln->node);
    reln->pincount++;
}

References dlist_delete(), SMgrRelationData::node, and SMgrRelationData::pincount.

Referenced by RelationGetSmgr().

smgrprefetch()

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

Definition at line 660 of file smgr.c.

{
    bool        ret;
 
    HOLD_INTERRUPTS();
    ret = smgrsw[reln->smgr_which].smgr_prefetch(reln, forknum, blocknum, nblocks);
    RESUME_INTERRUPTS();
 
    return ret;
}

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

Referenced by PrefetchLocalBuffer(), PrefetchSharedBuffer(), and StartReadBuffersImpl().

smgrread()

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

inlinestatic

Definition at line 117 of file smgr.h.

{
    smgrreadv(reln, forknum, blocknum, &buffer, 1);
}

References smgrreadv().

Referenced by pg_prewarm(), and RelationCopyStorage().

smgrreadv()

void smgrreadv	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		void **	buffers,
		BlockNumber	nblocks
	)

Definition at line 703 of file smgr.c.

{
    HOLD_INTERRUPTS();
    smgrsw[reln->smgr_which].smgr_readv(reln, forknum, blocknum, buffers,
                                        nblocks);
    RESUME_INTERRUPTS();
}

References HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_readv, SMgrRelationData::smgr_which, and smgrsw.

Referenced by smgrread(), and WaitReadBuffers().

smgrregistersync()

void smgrregistersync	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 879 of file smgr.c.

{
    HOLD_INTERRUPTS();
    smgrsw[reln->smgr_which].smgr_registersync(reln, forknum);
    RESUME_INTERRUPTS();
}

References HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_registersync, SMgrRelationData::smgr_which, and smgrsw.

Referenced by smgr_bulk_finish().

smgrrelease()

void smgrrelease

(

SMgrRelation

reln

)

Definition at line 332 of file smgr.c.

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

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

Referenced by smgrclose(), smgrreleaseall(), and smgrreleaserellocator().

smgrreleaseall()

void smgrreleaseall

(

void

)

Definition at line 394 of file smgr.c.

{
    HASH_SEQ_STATUS status;
    SMgrRelation reln;
 
    /* Nothing to do if hashtable not set up */
    if (SMgrRelationHash == NULL)
        return;
 
    /* seems unsafe to accept interrupts while iterating */
    HOLD_INTERRUPTS();
 
    hash_seq_init(&status, SMgrRelationHash);
 
    while ((reln = (SMgrRelation) hash_seq_search(&status)) != NULL)
    {
        smgrrelease(reln);
    }
 
    RESUME_INTERRUPTS();
}

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

Referenced by ProcessBarrierSmgrRelease(), and RelationCacheInvalidate().

smgrreleaserellocator()

void smgrreleaserellocator

(

RelFileLocatorBackend

rlocator

)

Definition at line 425 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)
        smgrrelease(reln);
}

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

Referenced by LocalExecuteInvalidationMessage().

smgrtruncate()

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

Definition at line 823 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],
                                               old_nblocks[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_cached_nblocks, and
         * these ones too at the next command boundary. But 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().

smgrunpin()

void smgrunpin

(

SMgrRelation

reln

)

Definition at line 293 of file smgr.c.

{
    Assert(reln->pincount > 0);
    reln->pincount--;
    if (reln->pincount == 0)
        dlist_push_tail(&unpinned_relns, &reln->node);
}

References Assert(), dlist_push_tail(), SMgrRelationData::node, SMgrRelationData::pincount, and unpinned_relns.

Referenced by RelationCloseSmgr().

smgrwrite()

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

inlinestatic

Definition at line 124 of file smgr.h.

{
    smgrwritev(reln, forknum, blocknum, &buffer, 1, skipFsync);
}

References smgrwritev().

Referenced by FlushBuffer(), FlushLocalBuffer(), and smgr_bulk_flush().

smgrwriteback()

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

Definition at line 753 of file smgr.c.

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

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

Referenced by IssuePendingWritebacks().

smgrwritev()

void smgrwritev	(	SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		const void **	buffers,
		BlockNumber	nblocks,
		bool	skipFsync
	)

Definition at line 739 of file smgr.c.

{
    HOLD_INTERRUPTS();
    smgrsw[reln->smgr_which].smgr_writev(reln, forknum, blocknum,
                                         buffers, nblocks, skipFsync);
    RESUME_INTERRUPTS();
}

References HOLD_INTERRUPTS, RESUME_INTERRUPTS, SMgrRelationData::smgr_which, f_smgr::smgr_writev, and smgrsw.

Referenced by smgrwrite().

smgrzeroextend()

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

Definition at line 631 of file smgr.c.

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

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

Referenced by ExtendBufferedRelLocal(), and ExtendBufferedRelShared().