smgr.c File Reference

#include "postgres.h"
#include "access/xlogutils.h"
#include "lib/ilist.h"
#include "miscadmin.h"
#include "storage/aio.h"
#include "storage/bufmgr.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)
static void	smgrdestroy (SMgrRelation reln)
static void	smgr_aio_reopen (PgAioHandle *ioh)
static char *	smgr_aio_describe_identity (const PgAioTargetData *sd)
void	smgrinit (void)
SMgrRelation	smgropen (RelFileLocator rlocator, ProcNumber backend)
void	smgrpin (SMgrRelation reln)
void	smgrunpin (SMgrRelation reln)
void	smgrrelease (SMgrRelation reln)
void	smgrclose (SMgrRelation reln)
void	smgrdestroyall (void)
void	smgrreleaseall (void)
void	smgrreleaserellocator (RelFileLocatorBackend rlocator)
bool	smgrexists (SMgrRelation reln, ForkNumber forknum)
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	smgrstartreadv (PgAioHandle *ioh, 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	smgrregistersync (SMgrRelation reln, ForkNumber forknum)
void	smgrimmedsync (SMgrRelation reln, ForkNumber forknum)
static int	smgrfd (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, uint32 *off)
void	AtEOXact_SMgr (void)
bool	ProcessBarrierSmgrRelease (void)
void	pgaio_io_set_target_smgr (PgAioHandle *ioh, SMgrRelationData *smgr, ForkNumber forknum, BlockNumber blocknum, int nblocks, bool skip_fsync)

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

Typedef Documentation

f_smgr

typedef struct f_smgr f_smgr

Function Documentation

AtEOXact_SMgr()

void AtEOXact_SMgr

(

void

)

Definition at line 1008 of file smgr.c.

{
    smgrdestroyall();
}

References smgrdestroyall().

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

pgaio_io_set_target_smgr()

void pgaio_io_set_target_smgr	(	PgAioHandle *	ioh,
		SMgrRelationData *	smgr,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		int	nblocks,
		bool	skip_fsync
	)

Definition at line 1029 of file smgr.c.

{
    PgAioTargetData *sd = pgaio_io_get_target_data(ioh);
 
    pgaio_io_set_target(ioh, PGAIO_TID_SMGR);
 
    /* backend is implied via IO owner */
    sd->smgr.rlocator = smgr->smgr_rlocator.locator;
    sd->smgr.forkNum = forknum;
    sd->smgr.blockNum = blocknum;
    sd->smgr.nblocks = nblocks;
    sd->smgr.is_temp = SmgrIsTemp(smgr);
    /* Temp relations should never be fsync'd */
    sd->smgr.skip_fsync = skip_fsync && !SmgrIsTemp(smgr);
}

References PgAioTargetData::blockNum, PgAioTargetData::forkNum, PgAioTargetData::is_temp, RelFileLocatorBackend::locator, PgAioTargetData::nblocks, pgaio_io_get_target_data(), pgaio_io_set_target(), PGAIO_TID_SMGR, PgAioTargetData::rlocator, PgAioTargetData::skip_fsync, PgAioTargetData::smgr, SMgrRelationData::smgr_rlocator, and SmgrIsTemp.

Referenced by mdstartreadv().

ProcessBarrierSmgrRelease()

bool ProcessBarrierSmgrRelease

(

void

)

Definition at line 1018 of file smgr.c.

{
    smgrreleaseall();
    return true;
}

References smgrreleaseall().

Referenced by ProcessProcSignalBarrier().

smgr_aio_describe_identity()

static char * smgr_aio_describe_identity ( const PgAioTargetData *  sd )

static

Definition at line 1095 of file smgr.c.

{
    RelPathStr  path;
    char       *desc;
 
    path = relpathbackend(sd->smgr.rlocator,
                          sd->smgr.is_temp ?
                          MyProcNumber : INVALID_PROC_NUMBER,
                          sd->smgr.forkNum);
 
    if (sd->smgr.nblocks == 0)
        desc = psprintf(_("file \"%s\""), path.str);
    else if (sd->smgr.nblocks == 1)
        desc = psprintf(_("block %u in file \"%s\""),
                        sd->smgr.blockNum,
                        path.str);
    else
        desc = psprintf(_("blocks %u..%u in file \"%s\""),
                        sd->smgr.blockNum,
                        sd->smgr.blockNum + sd->smgr.nblocks - 1,
                        path.str);
 
    return desc;
}

References _, PgAioTargetData::blockNum, PgAioTargetData::forkNum, INVALID_PROC_NUMBER, PgAioTargetData::is_temp, MyProcNumber, PgAioTargetData::nblocks, psprintf(), relpathbackend, PgAioTargetData::rlocator, PgAioTargetData::smgr, and RelPathStr::str.

smgr_aio_reopen()

static void smgr_aio_reopen ( PgAioHandle *  ioh )

static

Definition at line 1055 of file smgr.c.

{
    PgAioTargetData *sd = pgaio_io_get_target_data(ioh);
    PgAioOpData *od = pgaio_io_get_op_data(ioh);
    SMgrRelation reln;
    ProcNumber  procno;
    uint32      off;
 
    /*
     * The caller needs to prevent interrupts from being processed, otherwise
     * the FD could be closed again before we get to executing the IO.
     */
    Assert(!INTERRUPTS_CAN_BE_PROCESSED());
 
    if (sd->smgr.is_temp)
        procno = pgaio_io_get_owner(ioh);
    else
        procno = INVALID_PROC_NUMBER;
 
    reln = smgropen(sd->smgr.rlocator, procno);
    switch (pgaio_io_get_op(ioh))
    {
        case PGAIO_OP_INVALID:
            pg_unreachable();
            break;
        case PGAIO_OP_READV:
            od->read.fd = smgrfd(reln, sd->smgr.forkNum, sd->smgr.blockNum, &off);
            Assert(off == od->read.offset);
            break;
        case PGAIO_OP_WRITEV:
            od->write.fd = smgrfd(reln, sd->smgr.forkNum, sd->smgr.blockNum, &off);
            Assert(off == od->write.offset);
            break;
    }
}

References Assert(), PgAioTargetData::blockNum, PgAioOpData::fd, PgAioTargetData::forkNum, INTERRUPTS_CAN_BE_PROCESSED, INVALID_PROC_NUMBER, PgAioTargetData::is_temp, PgAioOpData::offset, pg_unreachable, pgaio_io_get_op(), pgaio_io_get_op_data(), pgaio_io_get_owner(), pgaio_io_get_target_data(), PGAIO_OP_INVALID, PGAIO_OP_READV, PGAIO_OP_WRITEV, PgAioOpData::read, PgAioTargetData::rlocator, PgAioTargetData::smgr, smgrfd(), smgropen(), and PgAioOpData::write.

smgrclose()

void smgrclose

(

SMgrRelation

reln

)

Definition at line 374 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 481 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().

smgrdestroy()

static void smgrdestroy ( SMgrRelation  reln )

static

Definition at line 323 of file smgr.c.

{
    ForkNumber  forknum;
 
    Assert(reln->pincount == 0);
 
    HOLD_INTERRUPTS();
 
    for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
        smgrsw[reln->smgr_which].smgr_close(reln, forknum);
 
    dlist_delete(&reln->node);
 
    if (hash_search(SMgrRelationHash,
                    &(reln->smgr_rlocator),
                    HASH_REMOVE, NULL) == NULL)
        elog(ERROR, "SMgrRelation hashtable corrupted");
 
    RESUME_INTERRUPTS();
}

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

Referenced by smgrdestroyall().

smgrdestroyall()

void smgrdestroyall

(

void

)

Definition at line 386 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 498 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 538 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 462 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_callback(), 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 620 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().

smgrfd()

static int smgrfd ( SMgrRelation  reln, ForkNumber  forknum, BlockNumber  blocknum, uint32 *  off  )

static

Definition at line 980 of file smgr.c.

{
    int         fd;
 
    /*
     * The caller needs to prevent interrupts from being processed, otherwise
     * the FD could be closed prematurely.
     */
    Assert(!INTERRUPTS_CAN_BE_PROCESSED());
 
    fd = smgrsw[reln->smgr_which].smgr_fd(reln, forknum, blocknum, off);
 
    return fd;
}

References Assert(), fd(), INTERRUPTS_CAN_BE_PROCESSED, f_smgr::smgr_fd, SMgrRelationData::smgr_which, and smgrsw.

Referenced by smgr_aio_reopen().

smgrimmedsync()

void smgrimmedsync	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 965 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 188 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 697 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 819 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 847 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 240 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_aio_reopen(), smgr_redo(), smgrDoPendingDeletes(), smgrDoPendingSyncs(), XLogPrefetcherNextBlock(), and XLogReadBufferExtended().

smgrpin()

void smgrpin

(

SMgrRelation

reln

)

Definition at line 296 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 678 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().

smgrreadv()

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

Definition at line 721 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().

smgrregistersync()

void smgrregistersync	(	SMgrRelation	reln,
		ForkNumber	forknum
	)

Definition at line 931 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 350 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 412 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(), read_rel_block_ll(), and RelationCacheInvalidate().

smgrreleaserellocator()

void smgrreleaserellocator

(

RelFileLocatorBackend

rlocator

)

Definition at line 443 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().

smgrshutdown()

static void smgrshutdown ( int  code, Datum  arg  )

static

Definition at line 210 of file smgr.c.

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

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

Referenced by smgrinit().

smgrstartreadv()

void smgrstartreadv	(	PgAioHandle *	ioh,
		SMgrRelation	reln,
		ForkNumber	forknum,
		BlockNumber	blocknum,
		void **	buffers,
		BlockNumber	nblocks
	)

Definition at line 753 of file smgr.c.

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

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

Referenced by AsyncReadBuffers(), and read_rel_block_ll().

smgrtruncate()

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

Definition at line 875 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 311 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().

smgrwriteback()

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

Definition at line 805 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 791 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 649 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().

Variable Documentation

aio_smgr_target_info

const PgAioTargetInfo aio_smgr_target_info

Initial value:

= {
    .name = "smgr",
    .reopen = smgr_aio_reopen,
    .describe_identity = smgr_aio_describe_identity,
}

Definition at line 172 of file smgr.c.

NSmgr

const int NSmgr = lengthof(smgrsw)

static

Definition at line 154 of file smgr.c.

Referenced by smgrinit(), and smgrshutdown().

SMgrRelationHash

HTAB* SMgrRelationHash = NULL

static

Definition at line 160 of file smgr.c.

Referenced by smgrdestroy(), smgropen(), smgrreleaseall(), and smgrreleaserellocator().

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_maxcombine = mdmaxcombine,
        .smgr_readv = mdreadv,
        .smgr_startreadv = mdstartreadv,
        .smgr_writev = mdwritev,
        .smgr_writeback = mdwriteback,
        .smgr_nblocks = mdnblocks,
        .smgr_truncate = mdtruncate,
        .smgr_immedsync = mdimmedsync,
        .smgr_registersync = mdregistersync,
        .smgr_fd = mdfd,
    }
}

Definition at line 128 of file smgr.c.

Referenced by smgrcreate(), smgrdestroy(), smgrdosyncall(), smgrdounlinkall(), smgrexists(), smgrextend(), smgrfd(), smgrimmedsync(), smgrinit(), smgrmaxcombine(), smgrnblocks(), smgropen(), smgrprefetch(), smgrreadv(), smgrregistersync(), smgrrelease(), smgrshutdown(), smgrstartreadv(), smgrtruncate(), smgrwriteback(), smgrwritev(), and smgrzeroextend().

unpinned_relns

dlist_head unpinned_relns

static

Definition at line 162 of file smgr.c.

Referenced by smgrdestroyall(), smgropen(), and smgrunpin().