smgr.h File Reference

#include "lib/ilist.h"
#include "storage/aio_types.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	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	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)
void	pgaio_io_set_target_smgr (PgAioHandle *ioh, SMgrRelationData *smgr, ForkNumber forknum, BlockNumber blocknum, int nblocks, bool skip_fsync)

Variables
PGDLLIMPORT const PgAioTargetInfo	aio_smgr_target_info

Macro Definition Documentation

SmgrIsTemp

#define SmgrIsTemp

(

smgr

)

RelFileLocatorBackendIsTemp((smgr)->smgr_rlocator)

Definition at line 74 of file smgr.h.

{
    smgrreadv(reln, forknum, blocknum, &buffer, 1);
}
 
static inline void
smgrwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
          const void *buffer, bool skipFsync)
{
    smgrwritev(reln, forknum, blocknum, &buffer, 1, skipFsync);
}
 
extern void pgaio_io_set_target_smgr(PgAioHandle *ioh,
                                     SMgrRelationData *smgr,
                                     ForkNumber forknum,
                                     BlockNumber blocknum,
                                     int nblocks,
                                     bool skip_fsync);
 
#endif                          /* SMGR_H */

Typedef Documentation

SMgrRelation

typedef SMgrRelationData* SMgrRelation

Definition at line 72 of file smgr.h.

SMgrRelationData

typedef struct SMgrRelationData SMgrRelationData

Function Documentation

AtEOXact_SMgr()

void AtEOXact_SMgr ( void  )

extern

Definition at line 1017 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  )

extern

Definition at line 1038 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 fb(), RelFileLocatorBackend::locator, pgaio_io_get_target_data(), pgaio_io_set_target(), PGAIO_TID_SMGR, SMgrRelationData::smgr_rlocator, and SmgrIsTemp.

Referenced by mdstartreadv().

ProcessBarrierSmgrRelease()

bool ProcessBarrierSmgrRelease ( void  )

extern

Definition at line 1027 of file smgr.c.

{
    smgrreleaseall();
    return true;
}

References smgrreleaseall().

Referenced by ProcessProcSignalBarrier().

smgrclose()

void smgrclose ( SMgrRelation  reln )

extern

Definition at line 374 of file smgr.c.

{
    smgrrelease(reln);
}

References fb(), and 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  )

extern

Definition at line 481 of file smgr.c.

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

References fb(), HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_create, 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  )

extern

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(), xlog_redo(), and XLogDropDatabase().

smgrdosyncall()

void smgrdosyncall ( SMgrRelation *  rels, int  nrels  )

extern

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 fb(), 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  )

extern

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_array(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(), fb(), HOLD_INTERRUPTS, i, MAX_FORKNUM, palloc_array, pfree(), RESUME_INTERRUPTS, SMgrRelationData::smgr_rlocator, SMgrRelationData::smgr_which, and smgrsw.

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

smgrexists()

bool smgrexists ( SMgrRelation  reln, ForkNumber  forknum  )

extern

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 fb(), HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_exists, 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  )

extern

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 fb(), HOLD_INTERRUPTS, InvalidBlockNumber, RESUME_INTERRUPTS, f_smgr::smgr_extend, and smgrsw.

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

smgrimmedsync()

void smgrimmedsync ( SMgrRelation  reln, ForkNumber  forknum  )

extern

Definition at line 974 of file smgr.c.

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

References fb(), HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_immedsync, and smgrsw.

Referenced by smgr_bulk_finish().

smgrinit()

void smgrinit ( void  )

extern

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  )

extern

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 fb(), HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_maxcombine, and smgrsw.

Referenced by StartReadBuffersImpl().

smgrnblocks()

BlockNumber smgrnblocks ( SMgrRelation  reln, ForkNumber  forknum  )

extern

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 fb(), HOLD_INTERRUPTS, InvalidBlockNumber, RESUME_INTERRUPTS, f_smgr::smgr_nblocks, 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  )

extern

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 fb(), InRecovery, and InvalidBlockNumber.

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

smgropen()

SMgrRelation smgropen ( RelFileLocator  rlocator, ProcNumber  backend  )

extern

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, ctl, dlist_init(), dlist_push_tail(), fb(), HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), HOLD_INTERRUPTS, i, InvalidBlockNumber, HASHCTL::keysize, MAX_FORKNUM, RelFileNumberIsValid, RelFileLocator::relNumber, RESUME_INTERRUPTS, f_smgr::smgr_open, 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 )

extern

Definition at line 296 of file smgr.c.

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

References dlist_delete(), and fb().

Referenced by RelationGetSmgr().

smgrprefetch()

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

extern

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 fb(), HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_prefetch, and smgrsw.

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

smgrread()

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

inlinestatic

Definition at line 124 of file smgr.h.

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

References fb(), and smgrreadv().

Referenced by pg_prewarm(), and RelationCopyStorage().

smgrreadv()

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

extern

Definition at line 721 of file smgr.c.

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

References fb(), HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_readv, and smgrsw.

Referenced by smgrread().

smgrregistersync()

void smgrregistersync ( SMgrRelation  reln, ForkNumber  forknum  )

extern

Definition at line 940 of file smgr.c.

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

References fb(), HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_registersync, and smgrsw.

Referenced by smgr_bulk_finish().

smgrrelease()

void smgrrelease ( SMgrRelation  reln )

extern

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 fb(), HOLD_INTERRUPTS, InvalidBlockNumber, MAX_FORKNUM, RESUME_INTERRUPTS, f_smgr::smgr_close, and smgrsw.

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

smgrreleaseall()

void smgrreleaseall ( void  )

extern

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 fb(), 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 )

extern

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 fb(), HASH_FIND, hash_search(), SMgrRelationHash, and smgrrelease().

Referenced by LocalExecuteInvalidationMessage().

smgrstartreadv()

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

extern

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 fb(), HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_startreadv, and smgrsw.

Referenced by AsyncReadBuffers(), and read_rel_block_ll().

smgrtruncate()

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

extern

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.
         *
         * We can have nblocks > old_nblocks when a relation was truncated
         * multiple times, a replica applied all the truncations, and later
         * restarts from a restartpoint located before the truncations. The
         * relation on disk will be the size of the last truncate. When
         * replaying the first truncate, we will have nblocks > current size.
         * In such cases, smgr_truncate does nothing, so set the cached size
         * to the old size rather than the requested size.
         */
        reln->smgr_cached_nblocks[forknum[i]] =
            nblocks[i] > old_nblocks[i] ? old_nblocks[i] : nblocks[i];
    }
}

References CacheInvalidateSmgr(), DropRelationBuffers(), fb(), i, InvalidBlockNumber, f_smgr::smgr_truncate, and smgrsw.

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

smgrunpin()

void smgrunpin ( SMgrRelation  reln )

extern

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(), fb(), 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 131 of file smgr.h.

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

References fb(), and smgrwritev().

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

smgrwriteback()

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

extern

Definition at line 805 of file smgr.c.

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

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

extern

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 fb(), HOLD_INTERRUPTS, RESUME_INTERRUPTS, f_smgr::smgr_writev, and smgrsw.

Referenced by smgrwrite().

smgrzeroextend()

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

extern

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 fb(), HOLD_INTERRUPTS, InvalidBlockNumber, RESUME_INTERRUPTS, f_smgr::smgr_zeroextend, and smgrsw.

Referenced by ExtendBufferedRelLocal(), and ExtendBufferedRelShared().

Variable Documentation

aio_smgr_target_info

PGDLLIMPORT const PgAioTargetInfo aio_smgr_target_info

extern

Definition at line 172 of file smgr.c.

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