bufmgr.c File Reference

#include "postgres.h"
#include <sys/file.h>
#include <unistd.h>
#include "access/tableam.h"
#include "access/xloginsert.h"
#include "access/xlogutils.h"
#include "catalog/catalog.h"
#include "catalog/storage.h"
#include "catalog/storage_xlog.h"
#include "executor/instrument.h"
#include "lib/binaryheap.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "postmaster/bgwriter.h"
#include "storage/buf_internals.h"
#include "storage/bufmgr.h"
#include "storage/ipc.h"
#include "storage/lmgr.h"
#include "storage/proc.h"
#include "storage/smgr.h"
#include "storage/standby.h"
#include "utils/memdebug.h"
#include "utils/ps_status.h"
#include "utils/rel.h"
#include "utils/resowner_private.h"
#include "utils/timestamp.h"
#include <lib/sort_template.h>

Include dependency graph for bufmgr.c:

Go to the source code of this file.

Data Structures
struct	PrivateRefCountEntry
struct	CkptTsStatus
struct	SMgrSortArray

Macros
#define	BufHdrGetBlock(bufHdr)   ((Block) (BufferBlocks + ((Size) (bufHdr)->buf_id) * BLCKSZ))
#define	BufferGetLSN(bufHdr)   (PageGetLSN(BufHdrGetBlock(bufHdr)))
#define	LocalBufHdrGetBlock(bufHdr)    LocalBufferBlockPointers[-((bufHdr)->buf_id + 2)]
#define	BUF_WRITTEN   0x01
#define	BUF_REUSABLE   0x02
#define	RELS_BSEARCH_THRESHOLD   20
#define	BUF_DROP_FULL_SCAN_THRESHOLD   (uint64) (NBuffers / 32)
#define	REFCOUNT_ARRAY_ENTRIES   8
#define	BufferIsPinned(bufnum)
#define	ST_SORT   sort_checkpoint_bufferids
#define	ST_ELEMENT_TYPE   CkptSortItem
#define	ST_COMPARE(a, b)   ckpt_buforder_comparator(a, b)
#define	ST_SCOPE   static
#define	ST_DEFINE
#define	ST_SORT   sort_pending_writebacks
#define	ST_ELEMENT_TYPE   PendingWriteback
#define	ST_COMPARE(a, b)   buffertag_comparator(&a->tag, &b->tag)
#define	ST_SCOPE   static
#define	ST_DEFINE

Typedefs
typedef struct PrivateRefCountEntry	PrivateRefCountEntry
typedef struct CkptTsStatus	CkptTsStatus
typedef struct SMgrSortArray	SMgrSortArray

Functions
static void	ReservePrivateRefCountEntry (void)
static PrivateRefCountEntry *	NewPrivateRefCountEntry (Buffer buffer)
static PrivateRefCountEntry *	GetPrivateRefCountEntry (Buffer buffer, bool do_move)
static int32	GetPrivateRefCount (Buffer buffer)
static void	ForgetPrivateRefCountEntry (PrivateRefCountEntry *ref)
static Buffer	ReadBuffer_common (SMgrRelation smgr, char relpersistence, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy, bool *hit)
static BlockNumber	ExtendBufferedRelCommon (BufferManagerRelation bmr, ForkNumber fork, BufferAccessStrategy strategy, uint32 flags, uint32 extend_by, BlockNumber extend_upto, Buffer *buffers, uint32 *extended_by)
static BlockNumber	ExtendBufferedRelShared (BufferManagerRelation bmr, ForkNumber fork, BufferAccessStrategy strategy, uint32 flags, uint32 extend_by, BlockNumber extend_upto, Buffer *buffers, uint32 *extended_by)
static bool	PinBuffer (BufferDesc *buf, BufferAccessStrategy strategy)
static void	PinBuffer_Locked (BufferDesc *buf)
static void	UnpinBuffer (BufferDesc *buf)
static void	BufferSync (int flags)
static uint32	WaitBufHdrUnlocked (BufferDesc *buf)
static int	SyncOneBuffer (int buf_id, bool skip_recently_used, WritebackContext *wb_context)
static void	WaitIO (BufferDesc *buf)
static bool	StartBufferIO (BufferDesc *buf, bool forInput)
static void	TerminateBufferIO (BufferDesc *buf, bool clear_dirty, uint32 set_flag_bits)
static void	shared_buffer_write_error_callback (void *arg)
static void	local_buffer_write_error_callback (void *arg)
static BufferDesc *	BufferAlloc (SMgrRelation smgr, char relpersistence, ForkNumber forkNum, BlockNumber blockNum, BufferAccessStrategy strategy, bool *foundPtr, IOContext io_context)
static Buffer	GetVictimBuffer (BufferAccessStrategy strategy, IOContext io_context)
static void	FlushBuffer (BufferDesc *buf, SMgrRelation reln, IOObject io_object, IOContext io_context)
static void	FindAndDropRelationBuffers (RelFileLocator rlocator, ForkNumber forkNum, BlockNumber nForkBlock, BlockNumber firstDelBlock)
static void	RelationCopyStorageUsingBuffer (RelFileLocator srclocator, RelFileLocator dstlocator, ForkNumber forkNum, bool permanent)
static void	AtProcExit_Buffers (int code, Datum arg)
static void	CheckForBufferLeaks (void)
static int	rlocator_comparator (const void *p1, const void *p2)
static int	buffertag_comparator (const BufferTag *ba, const BufferTag *bb)
static int	ckpt_buforder_comparator (const CkptSortItem *a, const CkptSortItem *b)
static int	ts_ckpt_progress_comparator (Datum a, Datum b, void *arg)
PrefetchBufferResult	PrefetchSharedBuffer (SMgrRelation smgr_reln, ForkNumber forkNum, BlockNumber blockNum)
PrefetchBufferResult	PrefetchBuffer (Relation reln, ForkNumber forkNum, BlockNumber blockNum)
bool	ReadRecentBuffer (RelFileLocator rlocator, ForkNumber forkNum, BlockNumber blockNum, Buffer recent_buffer)
Buffer	ReadBuffer (Relation reln, BlockNumber blockNum)
Buffer	ReadBufferExtended (Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy)
Buffer	ReadBufferWithoutRelcache (RelFileLocator rlocator, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy, bool permanent)
Buffer	ExtendBufferedRel (BufferManagerRelation bmr, ForkNumber forkNum, BufferAccessStrategy strategy, uint32 flags)
BlockNumber	ExtendBufferedRelBy (BufferManagerRelation bmr, ForkNumber fork, BufferAccessStrategy strategy, uint32 flags, uint32 extend_by, Buffer *buffers, uint32 *extended_by)
Buffer	ExtendBufferedRelTo (BufferManagerRelation bmr, ForkNumber fork, BufferAccessStrategy strategy, uint32 flags, BlockNumber extend_to, ReadBufferMode mode)
static void	InvalidateBuffer (BufferDesc *buf)
static bool	InvalidateVictimBuffer (BufferDesc *buf_hdr)
static void	LimitAdditionalPins (uint32 *additional_pins)
void	MarkBufferDirty (Buffer buffer)
Buffer	ReleaseAndReadBuffer (Buffer buffer, Relation relation, BlockNumber blockNum)
bool	BgBufferSync (WritebackContext *wb_context)
void	AtEOXact_Buffers (bool isCommit)
void	InitBufferPoolAccess (void)
void	PrintBufferLeakWarning (Buffer buffer)
void	CheckPointBuffers (int flags)
BlockNumber	BufferGetBlockNumber (Buffer buffer)
void	BufferGetTag (Buffer buffer, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum)
BlockNumber	RelationGetNumberOfBlocksInFork (Relation relation, ForkNumber forkNum)
bool	BufferIsPermanent (Buffer buffer)
XLogRecPtr	BufferGetLSNAtomic (Buffer buffer)
void	DropRelationBuffers (SMgrRelation smgr_reln, ForkNumber *forkNum, int nforks, BlockNumber *firstDelBlock)
void	DropRelationsAllBuffers (SMgrRelation *smgr_reln, int nlocators)
void	DropDatabaseBuffers (Oid dbid)
void	FlushRelationBuffers (Relation rel)
void	FlushRelationsAllBuffers (SMgrRelation *smgrs, int nrels)
void	CreateAndCopyRelationData (RelFileLocator src_rlocator, RelFileLocator dst_rlocator, bool permanent)
void	FlushDatabaseBuffers (Oid dbid)
void	FlushOneBuffer (Buffer buffer)
void	ReleaseBuffer (Buffer buffer)
void	UnlockReleaseBuffer (Buffer buffer)
void	IncrBufferRefCount (Buffer buffer)
void	MarkBufferDirtyHint (Buffer buffer, bool buffer_std)
void	UnlockBuffers (void)
void	LockBuffer (Buffer buffer, int mode)
bool	ConditionalLockBuffer (Buffer buffer)
void	CheckBufferIsPinnedOnce (Buffer buffer)
void	LockBufferForCleanup (Buffer buffer)
bool	HoldingBufferPinThatDelaysRecovery (void)
bool	ConditionalLockBufferForCleanup (Buffer buffer)
bool	IsBufferCleanupOK (Buffer buffer)
void	AbortBufferIO (Buffer buffer)
uint32	LockBufHdr (BufferDesc *desc)
void	WritebackContextInit (WritebackContext *context, int *max_pending)
void	ScheduleBufferTagForWriteback (WritebackContext *wb_context, IOContext io_context, BufferTag *tag)
void	IssuePendingWritebacks (WritebackContext *wb_context, IOContext io_context)

Variables
bool	zero_damaged_pages = false
int	bgwriter_lru_maxpages = 100
double	bgwriter_lru_multiplier = 2.0
bool	track_io_timing = false
int	effective_io_concurrency = DEFAULT_EFFECTIVE_IO_CONCURRENCY
int	maintenance_io_concurrency = DEFAULT_MAINTENANCE_IO_CONCURRENCY
int	checkpoint_flush_after = DEFAULT_CHECKPOINT_FLUSH_AFTER
int	bgwriter_flush_after = DEFAULT_BGWRITER_FLUSH_AFTER
int	backend_flush_after = DEFAULT_BACKEND_FLUSH_AFTER
static BufferDesc *	PinCountWaitBuf = NULL
static struct PrivateRefCountEntry	PrivateRefCountArray [REFCOUNT_ARRAY_ENTRIES]
static HTAB *	PrivateRefCountHash = NULL
static int32	PrivateRefCountOverflowed = 0
static uint32	PrivateRefCountClock = 0
static PrivateRefCountEntry *	ReservedRefCountEntry = NULL

Macro Definition Documentation

BUF_DROP_FULL_SCAN_THRESHOLD

#define BUF_DROP_FULL_SCAN_THRESHOLD   (uint64) (NBuffers / 32)

Definition at line 82 of file bufmgr.c.

BUF_REUSABLE

#define BUF_REUSABLE   0x02

Definition at line 72 of file bufmgr.c.

BUF_WRITTEN

#define BUF_WRITTEN   0x01

Definition at line 71 of file bufmgr.c.

BufferGetLSN

#define BufferGetLSN

(

bufHdr

)

(PageGetLSN(BufHdrGetBlock(bufHdr)))

Definition at line 64 of file bufmgr.c.

BufferIsPinned

#define BufferIsPinned

(

bufnum

)

Value:

( \
    !BufferIsValid(bufnum) ? \
        false \
    : \
        BufferIsLocal(bufnum) ? \
            (LocalRefCount[-(bufnum) - 1] > 0) \
        : \
    (GetPrivateRefCount(bufnum) > 0) \
)

Definition at line 438 of file bufmgr.c.

BufHdrGetBlock

#define BufHdrGetBlock

(

bufHdr

)

((Block) (BufferBlocks + ((Size) (bufHdr)->buf_id) * BLCKSZ))

Definition at line 63 of file bufmgr.c.

LocalBufHdrGetBlock

#define LocalBufHdrGetBlock

(

bufHdr

)

LocalBufferBlockPointers[-((bufHdr)->buf_id + 2)]

Definition at line 67 of file bufmgr.c.

REFCOUNT_ARRAY_ENTRIES

#define REFCOUNT_ARRAY_ENTRIES   8

Definition at line 91 of file bufmgr.c.

RELS_BSEARCH_THRESHOLD

#define RELS_BSEARCH_THRESHOLD   20

Definition at line 74 of file bufmgr.c.

ST_COMPARE [1/2]

#define ST_COMPARE	(		a,
			b
	)		ckpt_buforder_comparator(a, b)

Definition at line 5486 of file bufmgr.c.

ST_COMPARE [2/2]

#define ST_COMPARE	(		a,
			b
	)		buffertag_comparator(&a->tag, &b->tag)

Definition at line 5486 of file bufmgr.c.

ST_DEFINE [1/2]

#define ST_DEFINE

Definition at line 5488 of file bufmgr.c.

ST_DEFINE [2/2]

#define ST_DEFINE

Definition at line 5488 of file bufmgr.c.

ST_ELEMENT_TYPE [1/2]

#define ST_ELEMENT_TYPE   CkptSortItem

Definition at line 5485 of file bufmgr.c.

ST_ELEMENT_TYPE [2/2]

#define ST_ELEMENT_TYPE   PendingWriteback

Definition at line 5485 of file bufmgr.c.

ST_SCOPE [1/2]

#define ST_SCOPE   static

Definition at line 5487 of file bufmgr.c.

ST_SCOPE [2/2]

#define ST_SCOPE   static

Definition at line 5487 of file bufmgr.c.

ST_SORT [1/2]

#define ST_SORT   sort_checkpoint_bufferids

Definition at line 5484 of file bufmgr.c.

ST_SORT [2/2]

#define ST_SORT   sort_pending_writebacks

Definition at line 5484 of file bufmgr.c.

Typedef Documentation

CkptTsStatus

typedef struct CkptTsStatus CkptTsStatus

PrivateRefCountEntry

typedef struct PrivateRefCountEntry PrivateRefCountEntry

SMgrSortArray

typedef struct SMgrSortArray SMgrSortArray

Function Documentation

AbortBufferIO()

void AbortBufferIO

(

Buffer

buffer

)

Definition at line 5191 of file bufmgr.c.

{
    BufferDesc *buf_hdr = GetBufferDescriptor(buffer - 1);
    uint32      buf_state;
 
    buf_state = LockBufHdr(buf_hdr);
    Assert(buf_state & (BM_IO_IN_PROGRESS | BM_TAG_VALID));
 
    if (!(buf_state & BM_VALID))
    {
        Assert(!(buf_state & BM_DIRTY));
        UnlockBufHdr(buf_hdr, buf_state);
    }
    else
    {
        Assert(buf_state & BM_DIRTY);
        UnlockBufHdr(buf_hdr, buf_state);
 
        /* Issue notice if this is not the first failure... */
        if (buf_state & BM_IO_ERROR)
        {
            /* Buffer is pinned, so we can read tag without spinlock */
            char       *path;
 
            path = relpathperm(BufTagGetRelFileLocator(&buf_hdr->tag),
                               BufTagGetForkNum(&buf_hdr->tag));
            ereport(WARNING,
                    (errcode(ERRCODE_IO_ERROR),
                     errmsg("could not write block %u of %s",
                            buf_hdr->tag.blockNum, path),
                     errdetail("Multiple failures --- write error might be permanent.")));
            pfree(path);
        }
    }
 
    TerminateBufferIO(buf_hdr, false, BM_IO_ERROR);
}

References Assert(), buftag::blockNum, BM_DIRTY, BM_IO_ERROR, BM_IO_IN_PROGRESS, BM_TAG_VALID, BM_VALID, PrivateRefCountEntry::buffer, BufTagGetForkNum(), BufTagGetRelFileLocator(), ereport, errcode(), errdetail(), errmsg(), GetBufferDescriptor(), LockBufHdr(), pfree(), relpathperm, BufferDesc::tag, TerminateBufferIO(), UnlockBufHdr(), and WARNING.

Referenced by ResourceOwnerReleaseInternal().

AtEOXact_Buffers()

void AtEOXact_Buffers

(

bool

isCommit

)

Definition at line 3132 of file bufmgr.c.

{
    CheckForBufferLeaks();
 
    AtEOXact_LocalBuffers(isCommit);
 
    Assert(PrivateRefCountOverflowed == 0);
}

References Assert(), AtEOXact_LocalBuffers(), CheckForBufferLeaks(), and PrivateRefCountOverflowed.

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

AtProcExit_Buffers()

static void AtProcExit_Buffers ( int  code, Datum  arg  )

static

Definition at line 3174 of file bufmgr.c.

{
    UnlockBuffers();
 
    CheckForBufferLeaks();
 
    /* localbuf.c needs a chance too */
    AtProcExit_LocalBuffers();
}

References AtProcExit_LocalBuffers(), CheckForBufferLeaks(), and UnlockBuffers().

Referenced by InitBufferPoolAccess().

BgBufferSync()

bool BgBufferSync

(

WritebackContext *

wb_context

)

Definition at line 2758 of file bufmgr.c.

{
    /* info obtained from freelist.c */
    int         strategy_buf_id;
    uint32      strategy_passes;
    uint32      recent_alloc;
 
    /*
     * Information saved between calls so we can determine the strategy
     * point's advance rate and avoid scanning already-cleaned buffers.
     */
    static bool saved_info_valid = false;
    static int  prev_strategy_buf_id;
    static uint32 prev_strategy_passes;
    static int  next_to_clean;
    static uint32 next_passes;
 
    /* Moving averages of allocation rate and clean-buffer density */
    static float smoothed_alloc = 0;
    static float smoothed_density = 10.0;
 
    /* Potentially these could be tunables, but for now, not */
    float       smoothing_samples = 16;
    float       scan_whole_pool_milliseconds = 120000.0;
 
    /* Used to compute how far we scan ahead */
    long        strategy_delta;
    int         bufs_to_lap;
    int         bufs_ahead;
    float       scans_per_alloc;
    int         reusable_buffers_est;
    int         upcoming_alloc_est;
    int         min_scan_buffers;
 
    /* Variables for the scanning loop proper */
    int         num_to_scan;
    int         num_written;
    int         reusable_buffers;
 
    /* Variables for final smoothed_density update */
    long        new_strategy_delta;
    uint32      new_recent_alloc;
 
    /*
     * Find out where the freelist clock sweep currently is, and how many
     * buffer allocations have happened since our last call.
     */
    strategy_buf_id = StrategySyncStart(&strategy_passes, &recent_alloc);
 
    /* Report buffer alloc counts to pgstat */
    PendingBgWriterStats.buf_alloc += recent_alloc;
 
    /*
     * If we're not running the LRU scan, just stop after doing the stats
     * stuff.  We mark the saved state invalid so that we can recover sanely
     * if LRU scan is turned back on later.
     */
    if (bgwriter_lru_maxpages <= 0)
    {
        saved_info_valid = false;
        return true;
    }
 
    /*
     * Compute strategy_delta = how many buffers have been scanned by the
     * clock sweep since last time.  If first time through, assume none. Then
     * see if we are still ahead of the clock sweep, and if so, how many
     * buffers we could scan before we'd catch up with it and "lap" it. Note:
     * weird-looking coding of xxx_passes comparisons are to avoid bogus
     * behavior when the passes counts wrap around.
     */
    if (saved_info_valid)
    {
        int32       passes_delta = strategy_passes - prev_strategy_passes;
 
        strategy_delta = strategy_buf_id - prev_strategy_buf_id;
        strategy_delta += (long) passes_delta * NBuffers;
 
        Assert(strategy_delta >= 0);
 
        if ((int32) (next_passes - strategy_passes) > 0)
        {
            /* we're one pass ahead of the strategy point */
            bufs_to_lap = strategy_buf_id - next_to_clean;
#ifdef BGW_DEBUG
            elog(DEBUG2, "bgwriter ahead: bgw %u-%u strategy %u-%u delta=%ld lap=%d",
                 next_passes, next_to_clean,
                 strategy_passes, strategy_buf_id,
                 strategy_delta, bufs_to_lap);
#endif
        }
        else if (next_passes == strategy_passes &&
                 next_to_clean >= strategy_buf_id)
        {
            /* on same pass, but ahead or at least not behind */
            bufs_to_lap = NBuffers - (next_to_clean - strategy_buf_id);
#ifdef BGW_DEBUG
            elog(DEBUG2, "bgwriter ahead: bgw %u-%u strategy %u-%u delta=%ld lap=%d",
                 next_passes, next_to_clean,
                 strategy_passes, strategy_buf_id,
                 strategy_delta, bufs_to_lap);
#endif
        }
        else
        {
            /*
             * We're behind, so skip forward to the strategy point and start
             * cleaning from there.
             */
#ifdef BGW_DEBUG
            elog(DEBUG2, "bgwriter behind: bgw %u-%u strategy %u-%u delta=%ld",
                 next_passes, next_to_clean,
                 strategy_passes, strategy_buf_id,
                 strategy_delta);
#endif
            next_to_clean = strategy_buf_id;
            next_passes = strategy_passes;
            bufs_to_lap = NBuffers;
        }
    }
    else
    {
        /*
         * Initializing at startup or after LRU scanning had been off. Always
         * start at the strategy point.
         */
#ifdef BGW_DEBUG
        elog(DEBUG2, "bgwriter initializing: strategy %u-%u",
             strategy_passes, strategy_buf_id);
#endif
        strategy_delta = 0;
        next_to_clean = strategy_buf_id;
        next_passes = strategy_passes;
        bufs_to_lap = NBuffers;
    }
 
    /* Update saved info for next time */
    prev_strategy_buf_id = strategy_buf_id;
    prev_strategy_passes = strategy_passes;
    saved_info_valid = true;
 
    /*
     * Compute how many buffers had to be scanned for each new allocation, ie,
     * 1/density of reusable buffers, and track a moving average of that.
     *
     * If the strategy point didn't move, we don't update the density estimate
     */
    if (strategy_delta > 0 && recent_alloc > 0)
    {
        scans_per_alloc = (float) strategy_delta / (float) recent_alloc;
        smoothed_density += (scans_per_alloc - smoothed_density) /
            smoothing_samples;
    }
 
    /*
     * Estimate how many reusable buffers there are between the current
     * strategy point and where we've scanned ahead to, based on the smoothed
     * density estimate.
     */
    bufs_ahead = NBuffers - bufs_to_lap;
    reusable_buffers_est = (float) bufs_ahead / smoothed_density;
 
    /*
     * Track a moving average of recent buffer allocations.  Here, rather than
     * a true average we want a fast-attack, slow-decline behavior: we
     * immediately follow any increase.
     */
    if (smoothed_alloc <= (float) recent_alloc)
        smoothed_alloc = recent_alloc;
    else
        smoothed_alloc += ((float) recent_alloc - smoothed_alloc) /
            smoothing_samples;
 
    /* Scale the estimate by a GUC to allow more aggressive tuning. */
    upcoming_alloc_est = (int) (smoothed_alloc * bgwriter_lru_multiplier);
 
    /*
     * If recent_alloc remains at zero for many cycles, smoothed_alloc will
     * eventually underflow to zero, and the underflows produce annoying
     * kernel warnings on some platforms.  Once upcoming_alloc_est has gone to
     * zero, there's no point in tracking smaller and smaller values of
     * smoothed_alloc, so just reset it to exactly zero to avoid this
     * syndrome.  It will pop back up as soon as recent_alloc increases.
     */
    if (upcoming_alloc_est == 0)
        smoothed_alloc = 0;
 
    /*
     * Even in cases where there's been little or no buffer allocation
     * activity, we want to make a small amount of progress through the buffer
     * cache so that as many reusable buffers as possible are clean after an
     * idle period.
     *
     * (scan_whole_pool_milliseconds / BgWriterDelay) computes how many times
     * the BGW will be called during the scan_whole_pool time; slice the
     * buffer pool into that many sections.
     */
    min_scan_buffers = (int) (NBuffers / (scan_whole_pool_milliseconds / BgWriterDelay));
 
    if (upcoming_alloc_est < (min_scan_buffers + reusable_buffers_est))
    {
#ifdef BGW_DEBUG
        elog(DEBUG2, "bgwriter: alloc_est=%d too small, using min=%d + reusable_est=%d",
             upcoming_alloc_est, min_scan_buffers, reusable_buffers_est);
#endif
        upcoming_alloc_est = min_scan_buffers + reusable_buffers_est;
    }
 
    /*
     * Now write out dirty reusable buffers, working forward from the
     * next_to_clean point, until we have lapped the strategy scan, or cleaned
     * enough buffers to match our estimate of the next cycle's allocation
     * requirements, or hit the bgwriter_lru_maxpages limit.
     */
 
    /* Make sure we can handle the pin inside SyncOneBuffer */
    ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
 
    num_to_scan = bufs_to_lap;
    num_written = 0;
    reusable_buffers = reusable_buffers_est;
 
    /* Execute the LRU scan */
    while (num_to_scan > 0 && reusable_buffers < upcoming_alloc_est)
    {
        int         sync_state = SyncOneBuffer(next_to_clean, true,
                                               wb_context);
 
        if (++next_to_clean >= NBuffers)
        {
            next_to_clean = 0;
            next_passes++;
        }
        num_to_scan--;
 
        if (sync_state & BUF_WRITTEN)
        {
            reusable_buffers++;
            if (++num_written >= bgwriter_lru_maxpages)
            {
                PendingBgWriterStats.maxwritten_clean++;
                break;
            }
        }
        else if (sync_state & BUF_REUSABLE)
            reusable_buffers++;
    }
 
    PendingBgWriterStats.buf_written_clean += num_written;
 
#ifdef BGW_DEBUG
    elog(DEBUG1, "bgwriter: recent_alloc=%u smoothed=%.2f delta=%ld ahead=%d density=%.2f reusable_est=%d upcoming_est=%d scanned=%d wrote=%d reusable=%d",
         recent_alloc, smoothed_alloc, strategy_delta, bufs_ahead,
         smoothed_density, reusable_buffers_est, upcoming_alloc_est,
         bufs_to_lap - num_to_scan,
         num_written,
         reusable_buffers - reusable_buffers_est);
#endif
 
    /*
     * Consider the above scan as being like a new allocation scan.
     * Characterize its density and update the smoothed one based on it. This
     * effectively halves the moving average period in cases where both the
     * strategy and the background writer are doing some useful scanning,
     * which is helpful because a long memory isn't as desirable on the
     * density estimates.
     */
    new_strategy_delta = bufs_to_lap - num_to_scan;
    new_recent_alloc = reusable_buffers - reusable_buffers_est;
    if (new_strategy_delta > 0 && new_recent_alloc > 0)
    {
        scans_per_alloc = (float) new_strategy_delta / (float) new_recent_alloc;
        smoothed_density += (scans_per_alloc - smoothed_density) /
            smoothing_samples;
 
#ifdef BGW_DEBUG
        elog(DEBUG2, "bgwriter: cleaner density alloc=%u scan=%ld density=%.2f new smoothed=%.2f",
             new_recent_alloc, new_strategy_delta,
             scans_per_alloc, smoothed_density);
#endif
    }
 
    /* Return true if OK to hibernate */
    return (bufs_to_lap == 0 && recent_alloc == 0);
}

References Assert(), bgwriter_lru_maxpages, bgwriter_lru_multiplier, BgWriterDelay, PgStat_BgWriterStats::buf_alloc, BUF_REUSABLE, BUF_WRITTEN, PgStat_BgWriterStats::buf_written_clean, CurrentResourceOwner, DEBUG1, DEBUG2, elog(), PgStat_BgWriterStats::maxwritten_clean, NBuffers, PendingBgWriterStats, ResourceOwnerEnlargeBuffers(), StrategySyncStart(), and SyncOneBuffer().

Referenced by BackgroundWriterMain().

BufferAlloc()

static BufferDesc * BufferAlloc ( SMgrRelation  smgr, char  relpersistence, ForkNumber  forkNum, BlockNumber  blockNum, BufferAccessStrategy  strategy, bool *  foundPtr, IOContext  io_context  )

static

Definition at line 1220 of file bufmgr.c.

{
    BufferTag   newTag;         /* identity of requested block */
    uint32      newHash;        /* hash value for newTag */
    LWLock     *newPartitionLock;   /* buffer partition lock for it */
    int         existing_buf_id;
    Buffer      victim_buffer;
    BufferDesc *victim_buf_hdr;
    uint32      victim_buf_state;
 
    /* create a tag so we can lookup the buffer */
    InitBufferTag(&newTag, &smgr->smgr_rlocator.locator, forkNum, blockNum);
 
    /* determine its hash code and partition lock ID */
    newHash = BufTableHashCode(&newTag);
    newPartitionLock = BufMappingPartitionLock(newHash);
 
    /* see if the block is in the buffer pool already */
    LWLockAcquire(newPartitionLock, LW_SHARED);
    existing_buf_id = BufTableLookup(&newTag, newHash);
    if (existing_buf_id >= 0)
    {
        BufferDesc *buf;
        bool        valid;
 
        /*
         * Found it.  Now, pin the buffer so no one can steal it from the
         * buffer pool, and check to see if the correct data has been loaded
         * into the buffer.
         */
        buf = GetBufferDescriptor(existing_buf_id);
 
        valid = PinBuffer(buf, strategy);
 
        /* Can release the mapping lock as soon as we've pinned it */
        LWLockRelease(newPartitionLock);
 
        *foundPtr = true;
 
        if (!valid)
        {
            /*
             * We can only get here if (a) someone else is still reading in
             * the page, or (b) a previous read attempt failed.  We have to
             * wait for any active read attempt to finish, and then set up our
             * own read attempt if the page is still not BM_VALID.
             * StartBufferIO does it all.
             */
            if (StartBufferIO(buf, true))
            {
                /*
                 * If we get here, previous attempts to read the buffer must
                 * have failed ... but we shall bravely try again.
                 */
                *foundPtr = false;
            }
        }
 
        return buf;
    }
 
    /*
     * Didn't find it in the buffer pool.  We'll have to initialize a new
     * buffer.  Remember to unlock the mapping lock while doing the work.
     */
    LWLockRelease(newPartitionLock);
 
    /*
     * Acquire a victim buffer. Somebody else might try to do the same, we
     * don't hold any conflicting locks. If so we'll have to undo our work
     * later.
     */
    victim_buffer = GetVictimBuffer(strategy, io_context);
    victim_buf_hdr = GetBufferDescriptor(victim_buffer - 1);
 
    /*
     * Try to make a hashtable entry for the buffer under its new tag. If
     * somebody else inserted another buffer for the tag, we'll release the
     * victim buffer we acquired and use the already inserted one.
     */
    LWLockAcquire(newPartitionLock, LW_EXCLUSIVE);
    existing_buf_id = BufTableInsert(&newTag, newHash, victim_buf_hdr->buf_id);
    if (existing_buf_id >= 0)
    {
        BufferDesc *existing_buf_hdr;
        bool        valid;
 
        /*
         * Got a collision. Someone has already done what we were about to do.
         * We'll just handle this as if it were found in the buffer pool in
         * the first place.  First, give up the buffer we were planning to
         * use.
         *
         * We could do this after releasing the partition lock, but then we'd
         * have to call ResourceOwnerEnlargeBuffers() &
         * ReservePrivateRefCountEntry() before acquiring the lock, for the
         * rare case of such a collision.
         */
        UnpinBuffer(victim_buf_hdr);
 
        /*
         * The victim buffer we acquired peviously is clean and unused, let it
         * be found again quickly
         */
        StrategyFreeBuffer(victim_buf_hdr);
 
        /* remaining code should match code at top of routine */
 
        existing_buf_hdr = GetBufferDescriptor(existing_buf_id);
 
        valid = PinBuffer(existing_buf_hdr, strategy);
 
        /* Can release the mapping lock as soon as we've pinned it */
        LWLockRelease(newPartitionLock);
 
        *foundPtr = true;
 
        if (!valid)
        {
            /*
             * We can only get here if (a) someone else is still reading in
             * the page, or (b) a previous read attempt failed.  We have to
             * wait for any active read attempt to finish, and then set up our
             * own read attempt if the page is still not BM_VALID.
             * StartBufferIO does it all.
             */
            if (StartBufferIO(existing_buf_hdr, true))
            {
                /*
                 * If we get here, previous attempts to read the buffer must
                 * have failed ... but we shall bravely try again.
                 */
                *foundPtr = false;
            }
        }
 
        return existing_buf_hdr;
    }
 
    /*
     * Need to lock the buffer header too in order to change its tag.
     */
    victim_buf_state = LockBufHdr(victim_buf_hdr);
 
    /* some sanity checks while we hold the buffer header lock */
    Assert(BUF_STATE_GET_REFCOUNT(victim_buf_state) == 1);
    Assert(!(victim_buf_state & (BM_TAG_VALID | BM_VALID | BM_DIRTY | BM_IO_IN_PROGRESS)));
 
    victim_buf_hdr->tag = newTag;
 
    /*
     * Make sure BM_PERMANENT is set for buffers that must be written at every
     * checkpoint.  Unlogged buffers only need to be written at shutdown
     * checkpoints, except for their "init" forks, which need to be treated
     * just like permanent relations.
     */
    victim_buf_state |= BM_TAG_VALID | BUF_USAGECOUNT_ONE;
    if (relpersistence == RELPERSISTENCE_PERMANENT || forkNum == INIT_FORKNUM)
        victim_buf_state |= BM_PERMANENT;
 
    UnlockBufHdr(victim_buf_hdr, victim_buf_state);
 
    LWLockRelease(newPartitionLock);
 
    /*
     * Buffer contents are currently invalid.  Try to obtain the right to
     * start I/O.  If StartBufferIO returns false, then someone else managed
     * to read it before we did, so there's nothing left for BufferAlloc() to
     * do.
     */
    if (StartBufferIO(victim_buf_hdr, true))
        *foundPtr = false;
    else
        *foundPtr = true;
 
    return victim_buf_hdr;
}

References Assert(), BM_DIRTY, BM_IO_IN_PROGRESS, BM_PERMANENT, BM_TAG_VALID, BM_VALID, buf, BufferDesc::buf_id, BUF_STATE_GET_REFCOUNT, BUF_USAGECOUNT_ONE, BufMappingPartitionLock(), BufTableHashCode(), BufTableInsert(), BufTableLookup(), GetBufferDescriptor(), GetVictimBuffer(), INIT_FORKNUM, InitBufferTag(), RelFileLocatorBackend::locator, LockBufHdr(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), PinBuffer(), SMgrRelationData::smgr_rlocator, StartBufferIO(), StrategyFreeBuffer(), BufferDesc::tag, UnlockBufHdr(), and UnpinBuffer().

Referenced by ReadBuffer_common().

BufferGetBlockNumber()

BlockNumber BufferGetBlockNumber

(

Buffer

buffer

)

Definition at line 3290 of file bufmgr.c.

{
    BufferDesc *bufHdr;
 
    Assert(BufferIsPinned(buffer));
 
    if (BufferIsLocal(buffer))
        bufHdr = GetLocalBufferDescriptor(-buffer - 1);
    else
        bufHdr = GetBufferDescriptor(buffer - 1);
 
    /* pinned, so OK to read tag without spinlock */
    return bufHdr->tag.blockNum;
}

References Assert(), buftag::blockNum, PrivateRefCountEntry::buffer, BufferIsLocal, BufferIsPinned, GetBufferDescriptor(), GetLocalBufferDescriptor(), and BufferDesc::tag.

Referenced by _bt_binsrch_insert(), _bt_bottomupdel_pass(), _bt_check_unique(), _bt_checkpage(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_doinsert(), _bt_endpoint(), _bt_finish_split(), _bt_first(), _bt_getroot(), _bt_insert_parent(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_moveright(), _bt_newlevel(), _bt_pagedel(), _bt_readnextpage(), _bt_readpage(), _bt_restore_meta(), _bt_search(), _bt_simpledel_pass(), _bt_split(), _bt_unlink_halfdead_page(), _bt_walk_left(), _hash_addovflpage(), _hash_checkpage(), _hash_doinsert(), _hash_first(), _hash_freeovflpage(), _hash_getnewbuf(), _hash_readnext(), _hash_readpage(), _hash_splitbucket(), allocNewBuffer(), blinsert(), BloomInitMetapage(), brin_doinsert(), brin_doupdate(), brin_getinsertbuffer(), brin_initialize_empty_new_buffer(), brin_page_cleanup(), brin_xlog_insert_update(), brinbuild(), brinGetTupleForHeapBlock(), btbuildempty(), collectMatchBitmap(), createPostingTree(), dataBeginPlaceToPageLeaf(), dataPrepareDownlink(), doPickSplit(), entryPrepareDownlink(), fill_seq_fork_with_data(), ginEntryInsert(), ginFindParents(), ginFinishSplit(), ginPlaceToPage(), ginRedoDeleteListPages(), ginRedoUpdateMetapage(), ginScanToDelete(), gistbufferinginserttuples(), gistbuild(), gistcheckpage(), gistdeletepage(), gistformdownlink(), gistinserttuples(), gistMemorizeAllDownlinks(), gistplacetopage(), gistRelocateBuildBuffersOnSplit(), gistScanPage(), hash_xlog_add_ovfl_page(), heap_delete(), heap_hot_search_buffer(), heap_insert(), heap_multi_insert(), heap_page_is_all_visible(), heap_page_prune(), heap_prune_chain(), heap_update(), heap_xlog_confirm(), heap_xlog_lock(), index_compute_xid_horizon_for_tuples(), lazy_scan_noprune(), lazy_scan_prune(), makeSublist(), moveLeafs(), moveRightIfItNeeded(), pgstathashindex(), ReadBufferBI(), RelationAddBlocks(), RelationGetBufferForTuple(), RelationPutHeapTuple(), revmap_get_buffer(), revmap_physical_extend(), ScanSourceDatabasePgClassPage(), spgAddNodeAction(), spgbuild(), spgbuildempty(), spgdoinsert(), SpGistSetLastUsedPage(), spgSplitNodeAction(), spgWalk(), startScanEntry(), terminate_brin_buildstate(), vacuumLeafPage(), visibilitymap_clear(), visibilitymap_get_status(), visibilitymap_pin(), visibilitymap_pin_ok(), and visibilitymap_set().

BufferGetLSNAtomic()

XLogRecPtr BufferGetLSNAtomic

(

Buffer

buffer

)

Definition at line 3551 of file bufmgr.c.

{
    BufferDesc *bufHdr = GetBufferDescriptor(buffer - 1);
    char       *page = BufferGetPage(buffer);
    XLogRecPtr  lsn;
    uint32      buf_state;
 
    /*
     * If we don't need locking for correctness, fastpath out.
     */
    if (!XLogHintBitIsNeeded() || BufferIsLocal(buffer))
        return PageGetLSN(page);
 
    /* Make sure we've got a real buffer, and that we hold a pin on it. */
    Assert(BufferIsValid(buffer));
    Assert(BufferIsPinned(buffer));
 
    buf_state = LockBufHdr(bufHdr);
    lsn = PageGetLSN(page);
    UnlockBufHdr(bufHdr, buf_state);
 
    return lsn;
}

References Assert(), PrivateRefCountEntry::buffer, BufferGetPage(), BufferIsLocal, BufferIsPinned, BufferIsValid(), GetBufferDescriptor(), LockBufHdr(), PageGetLSN(), UnlockBufHdr(), and XLogHintBitIsNeeded.

Referenced by _bt_killitems(), _bt_readpage(), gistdoinsert(), gistFindPath(), gistkillitems(), gistScanPage(), SetHintBits(), and XLogSaveBufferForHint().

BufferGetTag()

void BufferGetTag	(	Buffer	buffer,
		RelFileLocator *	rlocator,
		ForkNumber *	forknum,
		BlockNumber *	blknum
	)

Definition at line 3311 of file bufmgr.c.

{
    BufferDesc *bufHdr;
 
    /* Do the same checks as BufferGetBlockNumber. */
    Assert(BufferIsPinned(buffer));
 
    if (BufferIsLocal(buffer))
        bufHdr = GetLocalBufferDescriptor(-buffer - 1);
    else
        bufHdr = GetBufferDescriptor(buffer - 1);
 
    /* pinned, so OK to read tag without spinlock */
    *rlocator = BufTagGetRelFileLocator(&bufHdr->tag);
    *forknum = BufTagGetForkNum(&bufHdr->tag);
    *blknum = bufHdr->tag.blockNum;
}

References Assert(), buftag::blockNum, PrivateRefCountEntry::buffer, BufferIsLocal, BufferIsPinned, BufTagGetForkNum(), BufTagGetRelFileLocator(), GetBufferDescriptor(), GetLocalBufferDescriptor(), and BufferDesc::tag.

Referenced by fsm_search_avail(), ginRedoInsertEntry(), log_newpage_buffer(), ResolveCminCmaxDuringDecoding(), XLogRegisterBuffer(), and XLogSaveBufferForHint().

BufferIsPermanent()

bool BufferIsPermanent

(

Buffer

buffer

)

Definition at line 3521 of file bufmgr.c.

{
    BufferDesc *bufHdr;
 
    /* Local buffers are used only for temp relations. */
    if (BufferIsLocal(buffer))
        return false;
 
    /* Make sure we've got a real buffer, and that we hold a pin on it. */
    Assert(BufferIsValid(buffer));
    Assert(BufferIsPinned(buffer));
 
    /*
     * BM_PERMANENT can't be changed while we hold a pin on the buffer, so we
     * need not bother with the buffer header spinlock.  Even if someone else
     * changes the buffer header state while we're doing this, the state is
     * changed atomically, so we'll read the old value or the new value, but
     * not random garbage.
     */
    bufHdr = GetBufferDescriptor(buffer - 1);
    return (pg_atomic_read_u32(&bufHdr->state) & BM_PERMANENT) != 0;
}

References Assert(), BM_PERMANENT, PrivateRefCountEntry::buffer, BufferIsLocal, BufferIsPinned, BufferIsValid(), GetBufferDescriptor(), pg_atomic_read_u32(), and BufferDesc::state.

Referenced by SetHintBits().

BufferSync()

static void BufferSync ( int  flags )

static

Definition at line 2479 of file bufmgr.c.

{
    uint32      buf_state;
    int         buf_id;
    int         num_to_scan;
    int         num_spaces;
    int         num_processed;
    int         num_written;
    CkptTsStatus *per_ts_stat = NULL;
    Oid         last_tsid;
    binaryheap *ts_heap;
    int         i;
    int         mask = BM_DIRTY;
    WritebackContext wb_context;
 
    /* Make sure we can handle the pin inside SyncOneBuffer */
    ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
 
    /*
     * Unless this is a shutdown checkpoint or we have been explicitly told,
     * we write only permanent, dirty buffers.  But at shutdown or end of
     * recovery, we write all dirty buffers.
     */
    if (!((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
                    CHECKPOINT_FLUSH_ALL))))
        mask |= BM_PERMANENT;
 
    /*
     * Loop over all buffers, and mark the ones that need to be written with
     * BM_CHECKPOINT_NEEDED.  Count them as we go (num_to_scan), so that we
     * can estimate how much work needs to be done.
     *
     * This allows us to write only those pages that were dirty when the
     * checkpoint began, and not those that get dirtied while it proceeds.
     * Whenever a page with BM_CHECKPOINT_NEEDED is written out, either by us
     * later in this function, or by normal backends or the bgwriter cleaning
     * scan, the flag is cleared.  Any buffer dirtied after this point won't
     * have the flag set.
     *
     * Note that if we fail to write some buffer, we may leave buffers with
     * BM_CHECKPOINT_NEEDED still set.  This is OK since any such buffer would
     * certainly need to be written for the next checkpoint attempt, too.
     */
    num_to_scan = 0;
    for (buf_id = 0; buf_id < NBuffers; buf_id++)
    {
        BufferDesc *bufHdr = GetBufferDescriptor(buf_id);
 
        /*
         * Header spinlock is enough to examine BM_DIRTY, see comment in
         * SyncOneBuffer.
         */
        buf_state = LockBufHdr(bufHdr);
 
        if ((buf_state & mask) == mask)
        {
            CkptSortItem *item;
 
            buf_state |= BM_CHECKPOINT_NEEDED;
 
            item = &CkptBufferIds[num_to_scan++];
            item->buf_id = buf_id;
            item->tsId = bufHdr->tag.spcOid;
            item->relNumber = BufTagGetRelNumber(&bufHdr->tag);
            item->forkNum = BufTagGetForkNum(&bufHdr->tag);
            item->blockNum = bufHdr->tag.blockNum;
        }
 
        UnlockBufHdr(bufHdr, buf_state);
 
        /* Check for barrier events in case NBuffers is large. */
        if (ProcSignalBarrierPending)
            ProcessProcSignalBarrier();
    }
 
    if (num_to_scan == 0)
        return;                 /* nothing to do */
 
    WritebackContextInit(&wb_context, &checkpoint_flush_after);
 
    TRACE_POSTGRESQL_BUFFER_SYNC_START(NBuffers, num_to_scan);
 
    /*
     * Sort buffers that need to be written to reduce the likelihood of random
     * IO. The sorting is also important for the implementation of balancing
     * writes between tablespaces. Without balancing writes we'd potentially
     * end up writing to the tablespaces one-by-one; possibly overloading the
     * underlying system.
     */
    sort_checkpoint_bufferids(CkptBufferIds, num_to_scan);
 
    num_spaces = 0;
 
    /*
     * Allocate progress status for each tablespace with buffers that need to
     * be flushed. This requires the to-be-flushed array to be sorted.
     */
    last_tsid = InvalidOid;
    for (i = 0; i < num_to_scan; i++)
    {
        CkptTsStatus *s;
        Oid         cur_tsid;
 
        cur_tsid = CkptBufferIds[i].tsId;
 
        /*
         * Grow array of per-tablespace status structs, every time a new
         * tablespace is found.
         */
        if (last_tsid == InvalidOid || last_tsid != cur_tsid)
        {
            Size        sz;
 
            num_spaces++;
 
            /*
             * Not worth adding grow-by-power-of-2 logic here - even with a
             * few hundred tablespaces this should be fine.
             */
            sz = sizeof(CkptTsStatus) * num_spaces;
 
            if (per_ts_stat == NULL)
                per_ts_stat = (CkptTsStatus *) palloc(sz);
            else
                per_ts_stat = (CkptTsStatus *) repalloc(per_ts_stat, sz);
 
            s = &per_ts_stat[num_spaces - 1];
            memset(s, 0, sizeof(*s));
            s->tsId = cur_tsid;
 
            /*
             * The first buffer in this tablespace. As CkptBufferIds is sorted
             * by tablespace all (s->num_to_scan) buffers in this tablespace
             * will follow afterwards.
             */
            s->index = i;
 
            /*
             * progress_slice will be determined once we know how many buffers
             * are in each tablespace, i.e. after this loop.
             */
 
            last_tsid = cur_tsid;
        }
        else
        {
            s = &per_ts_stat[num_spaces - 1];
        }
 
        s->num_to_scan++;
 
        /* Check for barrier events. */
        if (ProcSignalBarrierPending)
            ProcessProcSignalBarrier();
    }
 
    Assert(num_spaces > 0);
 
    /*
     * Build a min-heap over the write-progress in the individual tablespaces,
     * and compute how large a portion of the total progress a single
     * processed buffer is.
     */
    ts_heap = binaryheap_allocate(num_spaces,
                                  ts_ckpt_progress_comparator,
                                  NULL);
 
    for (i = 0; i < num_spaces; i++)
    {
        CkptTsStatus *ts_stat = &per_ts_stat[i];
 
        ts_stat->progress_slice = (float8) num_to_scan / ts_stat->num_to_scan;
 
        binaryheap_add_unordered(ts_heap, PointerGetDatum(ts_stat));
    }
 
    binaryheap_build(ts_heap);
 
    /*
     * Iterate through to-be-checkpointed buffers and write the ones (still)
     * marked with BM_CHECKPOINT_NEEDED. The writes are balanced between
     * tablespaces; otherwise the sorting would lead to only one tablespace
     * receiving writes at a time, making inefficient use of the hardware.
     */
    num_processed = 0;
    num_written = 0;
    while (!binaryheap_empty(ts_heap))
    {
        BufferDesc *bufHdr = NULL;
        CkptTsStatus *ts_stat = (CkptTsStatus *)
            DatumGetPointer(binaryheap_first(ts_heap));
 
        buf_id = CkptBufferIds[ts_stat->index].buf_id;
        Assert(buf_id != -1);
 
        bufHdr = GetBufferDescriptor(buf_id);
 
        num_processed++;
 
        /*
         * We don't need to acquire the lock here, because we're only looking
         * at a single bit. It's possible that someone else writes the buffer
         * and clears the flag right after we check, but that doesn't matter
         * since SyncOneBuffer will then do nothing.  However, there is a
         * further race condition: it's conceivable that between the time we
         * examine the bit here and the time SyncOneBuffer acquires the lock,
         * someone else not only wrote the buffer but replaced it with another
         * page and dirtied it.  In that improbable case, SyncOneBuffer will
         * write the buffer though we didn't need to.  It doesn't seem worth
         * guarding against this, though.
         */
        if (pg_atomic_read_u32(&bufHdr->state) & BM_CHECKPOINT_NEEDED)
        {
            if (SyncOneBuffer(buf_id, false, &wb_context) & BUF_WRITTEN)
            {
                TRACE_POSTGRESQL_BUFFER_SYNC_WRITTEN(buf_id);
                PendingCheckpointerStats.buf_written_checkpoints++;
                num_written++;
            }
        }
 
        /*
         * Measure progress independent of actually having to flush the buffer
         * - otherwise writing become unbalanced.
         */
        ts_stat->progress += ts_stat->progress_slice;
        ts_stat->num_scanned++;
        ts_stat->index++;
 
        /* Have all the buffers from the tablespace been processed? */
        if (ts_stat->num_scanned == ts_stat->num_to_scan)
        {
            binaryheap_remove_first(ts_heap);
        }
        else
        {
            /* update heap with the new progress */
            binaryheap_replace_first(ts_heap, PointerGetDatum(ts_stat));
        }
 
        /*
         * Sleep to throttle our I/O rate.
         *
         * (This will check for barrier events even if it doesn't sleep.)
         */
        CheckpointWriteDelay(flags, (double) num_processed / num_to_scan);
    }
 
    /*
     * Issue all pending flushes. Only checkpointer calls BufferSync(), so
     * IOContext will always be IOCONTEXT_NORMAL.
     */
    IssuePendingWritebacks(&wb_context, IOCONTEXT_NORMAL);
 
    pfree(per_ts_stat);
    per_ts_stat = NULL;
    binaryheap_free(ts_heap);
 
    /*
     * Update checkpoint statistics. As noted above, this doesn't include
     * buffers written by other backends or bgwriter scan.
     */
    CheckpointStats.ckpt_bufs_written += num_written;
 
    TRACE_POSTGRESQL_BUFFER_SYNC_DONE(NBuffers, num_written, num_to_scan);
}

References Assert(), binaryheap_add_unordered(), binaryheap_allocate(), binaryheap_build(), binaryheap_empty, binaryheap_first(), binaryheap_free(), binaryheap_remove_first(), binaryheap_replace_first(), buftag::blockNum, CkptSortItem::blockNum, BM_CHECKPOINT_NEEDED, BM_DIRTY, BM_PERMANENT, CkptSortItem::buf_id, BUF_WRITTEN, PgStat_CheckpointerStats::buf_written_checkpoints, BufTagGetForkNum(), BufTagGetRelNumber(), CHECKPOINT_END_OF_RECOVERY, checkpoint_flush_after, CHECKPOINT_FLUSH_ALL, CHECKPOINT_IS_SHUTDOWN, CheckpointStats, CheckpointWriteDelay(), CheckpointStatsData::ckpt_bufs_written, CkptBufferIds, CurrentResourceOwner, DatumGetPointer(), CkptSortItem::forkNum, GetBufferDescriptor(), i, CkptTsStatus::index, InvalidOid, IOCONTEXT_NORMAL, IssuePendingWritebacks(), LockBufHdr(), NBuffers, CkptTsStatus::num_scanned, CkptTsStatus::num_to_scan, palloc(), PendingCheckpointerStats, pfree(), pg_atomic_read_u32(), PointerGetDatum(), ProcessProcSignalBarrier(), ProcSignalBarrierPending, CkptTsStatus::progress, CkptTsStatus::progress_slice, CkptSortItem::relNumber, repalloc(), ResourceOwnerEnlargeBuffers(), buftag::spcOid, BufferDesc::state, SyncOneBuffer(), BufferDesc::tag, ts_ckpt_progress_comparator(), CkptTsStatus::tsId, CkptSortItem::tsId, UnlockBufHdr(), and WritebackContextInit().

Referenced by CheckPointBuffers().

buffertag_comparator()

static int buffertag_comparator ( const BufferTag *  ba, const BufferTag *  bb  )

inlinestatic

Definition at line 5354 of file bufmgr.c.

{
    int         ret;
    RelFileLocator rlocatora;
    RelFileLocator rlocatorb;
 
    rlocatora = BufTagGetRelFileLocator(ba);
    rlocatorb = BufTagGetRelFileLocator(bb);
 
    ret = rlocator_comparator(&rlocatora, &rlocatorb);
 
    if (ret != 0)
        return ret;
 
    if (BufTagGetForkNum(ba) < BufTagGetForkNum(bb))
        return -1;
    if (BufTagGetForkNum(ba) > BufTagGetForkNum(bb))
        return 1;
 
    if (ba->blockNum < bb->blockNum)
        return -1;
    if (ba->blockNum > bb->blockNum)
        return 1;
 
    return 0;
}

References buftag::blockNum, BufTagGetForkNum(), BufTagGetRelFileLocator(), and rlocator_comparator().

CheckBufferIsPinnedOnce()

void CheckBufferIsPinnedOnce

(

Buffer

buffer

)

Definition at line 4762 of file bufmgr.c.

{
    if (BufferIsLocal(buffer))
    {
        if (LocalRefCount[-buffer - 1] != 1)
            elog(ERROR, "incorrect local pin count: %d",
                 LocalRefCount[-buffer - 1]);
    }
    else
    {
        if (GetPrivateRefCount(buffer) != 1)
            elog(ERROR, "incorrect local pin count: %d",
                 GetPrivateRefCount(buffer));
    }
}

References PrivateRefCountEntry::buffer, BufferIsLocal, elog(), ERROR, GetPrivateRefCount(), and LocalRefCount.

Referenced by GetVictimBuffer(), and LockBufferForCleanup().

CheckForBufferLeaks()

static void CheckForBufferLeaks ( void  )

static

Definition at line 3192 of file bufmgr.c.

{
#ifdef USE_ASSERT_CHECKING
    int         RefCountErrors = 0;
    PrivateRefCountEntry *res;
    int         i;
 
    /* check the array */
    for (i = 0; i < REFCOUNT_ARRAY_ENTRIES; i++)
    {
        res = &PrivateRefCountArray[i];
 
        if (res->buffer != InvalidBuffer)
        {
            PrintBufferLeakWarning(res->buffer);
            RefCountErrors++;
        }
    }
 
    /* if necessary search the hash */
    if (PrivateRefCountOverflowed)
    {
        HASH_SEQ_STATUS hstat;
 
        hash_seq_init(&hstat, PrivateRefCountHash);
        while ((res = (PrivateRefCountEntry *) hash_seq_search(&hstat)) != NULL)
        {
            PrintBufferLeakWarning(res->buffer);
            RefCountErrors++;
        }
    }
 
    Assert(RefCountErrors == 0);
#endif
}

References Assert(), hash_seq_init(), hash_seq_search(), i, InvalidBuffer, PrintBufferLeakWarning(), PrivateRefCountArray, PrivateRefCountHash, PrivateRefCountOverflowed, REFCOUNT_ARRAY_ENTRIES, and res.

Referenced by AtEOXact_Buffers(), and AtProcExit_Buffers().

CheckPointBuffers()

void CheckPointBuffers

(

int

flags

)

Definition at line 3276 of file bufmgr.c.

{
    BufferSync(flags);
}

References BufferSync().

Referenced by CheckPointGuts().

ckpt_buforder_comparator()

static int ckpt_buforder_comparator ( const CkptSortItem *  a, const CkptSortItem *  b  )

inlinestatic

Definition at line 5388 of file bufmgr.c.

{
    /* compare tablespace */
    if (a->tsId < b->tsId)
        return -1;
    else if (a->tsId > b->tsId)
        return 1;
    /* compare relation */
    if (a->relNumber < b->relNumber)
        return -1;
    else if (a->relNumber > b->relNumber)
        return 1;
    /* compare fork */
    else if (a->forkNum < b->forkNum)
        return -1;
    else if (a->forkNum > b->forkNum)
        return 1;
    /* compare block number */
    else if (a->blockNum < b->blockNum)
        return -1;
    else if (a->blockNum > b->blockNum)
        return 1;
    /* equal page IDs are unlikely, but not impossible */
    return 0;
}

References a, and b.

ConditionalLockBuffer()

bool ConditionalLockBuffer

(

Buffer

buffer

)

Definition at line 4741 of file bufmgr.c.

{
    BufferDesc *buf;
 
    Assert(BufferIsPinned(buffer));
    if (BufferIsLocal(buffer))
        return true;            /* act as though we got it */
 
    buf = GetBufferDescriptor(buffer - 1);
 
    return LWLockConditionalAcquire(BufferDescriptorGetContentLock(buf),
                                    LW_EXCLUSIVE);
}

References Assert(), buf, PrivateRefCountEntry::buffer, BufferDescriptorGetContentLock(), BufferIsLocal, BufferIsPinned, GetBufferDescriptor(), LW_EXCLUSIVE, and LWLockConditionalAcquire().

Referenced by _bt_conditionallockbuf(), BloomNewBuffer(), ConditionalLockBufferForCleanup(), GinNewBuffer(), gistNewBuffer(), RelationGetBufferForTuple(), spgdoinsert(), SpGistGetBuffer(), SpGistNewBuffer(), and SpGistUpdateMetaPage().

ConditionalLockBufferForCleanup()

bool ConditionalLockBufferForCleanup

(

Buffer

buffer

)

Definition at line 4956 of file bufmgr.c.

{
    BufferDesc *bufHdr;
    uint32      buf_state,
                refcount;
 
    Assert(BufferIsValid(buffer));
 
    if (BufferIsLocal(buffer))
    {
        refcount = LocalRefCount[-buffer - 1];
        /* There should be exactly one pin */
        Assert(refcount > 0);
        if (refcount != 1)
            return false;
        /* Nobody else to wait for */
        return true;
    }
 
    /* There should be exactly one local pin */
    refcount = GetPrivateRefCount(buffer);
    Assert(refcount);
    if (refcount != 1)
        return false;
 
    /* Try to acquire lock */
    if (!ConditionalLockBuffer(buffer))
        return false;
 
    bufHdr = GetBufferDescriptor(buffer - 1);
    buf_state = LockBufHdr(bufHdr);
    refcount = BUF_STATE_GET_REFCOUNT(buf_state);
 
    Assert(refcount > 0);
    if (refcount == 1)
    {
        /* Successfully acquired exclusive lock with pincount 1 */
        UnlockBufHdr(bufHdr, buf_state);
        return true;
    }
 
    /* Failed, so release the lock */
    UnlockBufHdr(bufHdr, buf_state);
    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
    return false;
}

References Assert(), BUF_STATE_GET_REFCOUNT, PrivateRefCountEntry::buffer, BUFFER_LOCK_UNLOCK, BufferIsLocal, BufferIsValid(), ConditionalLockBuffer(), GetBufferDescriptor(), GetPrivateRefCount(), LocalRefCount, LockBuffer(), LockBufHdr(), PrivateRefCountEntry::refcount, and UnlockBufHdr().

Referenced by _hash_finish_split(), _hash_getbuf_with_condlock_cleanup(), heap_page_prune_opt(), and lazy_scan_heap().

CreateAndCopyRelationData()

void CreateAndCopyRelationData	(	RelFileLocator	src_rlocator,
		RelFileLocator	dst_rlocator,
		bool	permanent
	)

Definition at line 4348 of file bufmgr.c.

{
    RelFileLocatorBackend rlocator;
    char        relpersistence;
 
    /* Set the relpersistence. */
    relpersistence = permanent ?
        RELPERSISTENCE_PERMANENT : RELPERSISTENCE_UNLOGGED;
 
    /*
     * Create and copy all forks of the relation.  During create database we
     * have a separate cleanup mechanism which deletes complete database
     * directory.  Therefore, each individual relation doesn't need to be
     * registered for cleanup.
     */
    RelationCreateStorage(dst_rlocator, relpersistence, false);
 
    /* copy main fork. */
    RelationCopyStorageUsingBuffer(src_rlocator, dst_rlocator, MAIN_FORKNUM,
                                   permanent);
 
    /* copy those extra forks that exist */
    for (ForkNumber forkNum = MAIN_FORKNUM + 1;
         forkNum <= MAX_FORKNUM; forkNum++)
    {
        if (smgrexists(smgropen(src_rlocator, InvalidBackendId), forkNum))
        {
            smgrcreate(smgropen(dst_rlocator, InvalidBackendId), forkNum, false);
 
            /*
             * WAL log creation if the relation is persistent, or this is the
             * init fork of an unlogged relation.
             */
            if (permanent || forkNum == INIT_FORKNUM)
                log_smgrcreate(&dst_rlocator, forkNum);
 
            /* Copy a fork's data, block by block. */
            RelationCopyStorageUsingBuffer(src_rlocator, dst_rlocator, forkNum,
                                           permanent);
        }
    }
 
    /* close source and destination smgr if exists. */
    rlocator.backend = InvalidBackendId;
 
    rlocator.locator = src_rlocator;
    smgrcloserellocator(rlocator);
 
    rlocator.locator = dst_rlocator;
    smgrcloserellocator(rlocator);
}

References RelFileLocatorBackend::backend, INIT_FORKNUM, InvalidBackendId, RelFileLocatorBackend::locator, log_smgrcreate(), MAIN_FORKNUM, MAX_FORKNUM, RelationCopyStorageUsingBuffer(), RelationCreateStorage(), smgrcloserellocator(), smgrcreate(), smgrexists(), and smgropen().

Referenced by CreateDatabaseUsingWalLog().

DropDatabaseBuffers()

void DropDatabaseBuffers

(

Oid

dbid

)

Definition at line 3952 of file bufmgr.c.

{
    int         i;
 
    /*
     * We needn't consider local buffers, since by assumption the target
     * database isn't our own.
     */
 
    for (i = 0; i < NBuffers; i++)
    {
        BufferDesc *bufHdr = GetBufferDescriptor(i);
        uint32      buf_state;
 
        /*
         * As in DropRelationBuffers, an unlocked precheck should be safe and
         * saves some cycles.
         */
        if (bufHdr->tag.dbOid != dbid)
            continue;
 
        buf_state = LockBufHdr(bufHdr);
        if (bufHdr->tag.dbOid == dbid)
            InvalidateBuffer(bufHdr);   /* releases spinlock */
        else
            UnlockBufHdr(bufHdr, buf_state);
    }
}

References buftag::dbOid, GetBufferDescriptor(), i, InvalidateBuffer(), LockBufHdr(), NBuffers, BufferDesc::tag, and UnlockBufHdr().

Referenced by createdb_failure_callback(), dbase_redo(), dropdb(), and movedb().

DropRelationBuffers()

void DropRelationBuffers	(	SMgrRelation	smgr_reln,
		ForkNumber *	forkNum,
		int	nforks,
		BlockNumber *	firstDelBlock
	)

Definition at line 3597 of file bufmgr.c.

{
    int         i;
    int         j;
    RelFileLocatorBackend rlocator;
    BlockNumber nForkBlock[MAX_FORKNUM];
    uint64      nBlocksToInvalidate = 0;
 
    rlocator = smgr_reln->smgr_rlocator;
 
    /* If it's a local relation, it's localbuf.c's problem. */
    if (RelFileLocatorBackendIsTemp(rlocator))
    {
        if (rlocator.backend == MyBackendId)
        {
            for (j = 0; j < nforks; j++)
                DropRelationLocalBuffers(rlocator.locator, forkNum[j],
                                         firstDelBlock[j]);
        }
        return;
    }
 
    /*
     * To remove all the pages of the specified relation forks from the buffer
     * pool, we need to scan the entire buffer pool but we can optimize it by
     * finding the buffers from BufMapping table provided we know the exact
     * size of each fork of the relation. The exact size is required to ensure
     * that we don't leave any buffer for the relation being dropped as
     * otherwise the background writer or checkpointer can lead to a PANIC
     * error while flushing buffers corresponding to files that don't exist.
     *
     * To know the exact size, we rely on the size cached for each fork by us
     * during recovery which limits the optimization to recovery and on
     * standbys but we can easily extend it once we have shared cache for
     * relation size.
     *
     * In recovery, we cache the value returned by the first lseek(SEEK_END)
     * and the future writes keeps the cached value up-to-date. See
     * smgrextend. It is possible that the value of the first lseek is smaller
     * than the actual number of existing blocks in the file due to buggy
     * Linux kernels that might not have accounted for the recent write. But
     * that should be fine because there must not be any buffers after that
     * file size.
     */
    for (i = 0; i < nforks; i++)
    {
        /* Get the number of blocks for a relation's fork */
        nForkBlock[i] = smgrnblocks_cached(smgr_reln, forkNum[i]);
 
        if (nForkBlock[i] == InvalidBlockNumber)
        {
            nBlocksToInvalidate = InvalidBlockNumber;
            break;
        }
 
        /* calculate the number of blocks to be invalidated */
        nBlocksToInvalidate += (nForkBlock[i] - firstDelBlock[i]);
    }
 
    /*
     * We apply the optimization iff the total number of blocks to invalidate
     * is below the BUF_DROP_FULL_SCAN_THRESHOLD.
     */
    if (BlockNumberIsValid(nBlocksToInvalidate) &&
        nBlocksToInvalidate < BUF_DROP_FULL_SCAN_THRESHOLD)
    {
        for (j = 0; j < nforks; j++)
            FindAndDropRelationBuffers(rlocator.locator, forkNum[j],
                                       nForkBlock[j], firstDelBlock[j]);
        return;
    }
 
    for (i = 0; i < NBuffers; i++)
    {
        BufferDesc *bufHdr = GetBufferDescriptor(i);
        uint32      buf_state;
 
        /*
         * We can make this a tad faster by prechecking the buffer tag before
         * we attempt to lock the buffer; this saves a lot of lock
         * acquisitions in typical cases.  It should be safe because the
         * caller must have AccessExclusiveLock on the relation, or some other
         * reason to be certain that no one is loading new pages of the rel
         * into the buffer pool.  (Otherwise we might well miss such pages
         * entirely.)  Therefore, while the tag might be changing while we
         * look at it, it can't be changing *to* a value we care about, only
         * *away* from such a value.  So false negatives are impossible, and
         * false positives are safe because we'll recheck after getting the
         * buffer lock.
         *
         * We could check forkNum and blockNum as well as the rlocator, but
         * the incremental win from doing so seems small.
         */
        if (!BufTagMatchesRelFileLocator(&bufHdr->tag, &rlocator.locator))
            continue;
 
        buf_state = LockBufHdr(bufHdr);
 
        for (j = 0; j < nforks; j++)
        {
            if (BufTagMatchesRelFileLocator(&bufHdr->tag, &rlocator.locator) &&
                BufTagGetForkNum(&bufHdr->tag) == forkNum[j] &&
                bufHdr->tag.blockNum >= firstDelBlock[j])
            {
                InvalidateBuffer(bufHdr);   /* releases spinlock */
                break;
            }
        }
        if (j >= nforks)
            UnlockBufHdr(bufHdr, buf_state);
    }
}

References RelFileLocatorBackend::backend, buftag::blockNum, BlockNumberIsValid(), BUF_DROP_FULL_SCAN_THRESHOLD, BufTagGetForkNum(), BufTagMatchesRelFileLocator(), DropRelationLocalBuffers(), FindAndDropRelationBuffers(), GetBufferDescriptor(), i, InvalidateBuffer(), InvalidBlockNumber, j, RelFileLocatorBackend::locator, LockBufHdr(), MAX_FORKNUM, MyBackendId, NBuffers, RelFileLocatorBackendIsTemp, SMgrRelationData::smgr_rlocator, smgrnblocks_cached(), BufferDesc::tag, and UnlockBufHdr().

Referenced by smgrtruncate().

DropRelationsAllBuffers()

void DropRelationsAllBuffers	(	SMgrRelation *	smgr_reln,
		int	nlocators
	)

Definition at line 3720 of file bufmgr.c.

{
    int         i;
    int         n = 0;
    SMgrRelation *rels;
    BlockNumber (*block)[MAX_FORKNUM + 1];
    uint64      nBlocksToInvalidate = 0;
    RelFileLocator *locators;
    bool        cached = true;
    bool        use_bsearch;
 
    if (nlocators == 0)
        return;
 
    rels = palloc(sizeof(SMgrRelation) * nlocators);    /* non-local relations */
 
    /* If it's a local relation, it's localbuf.c's problem. */
    for (i = 0; i < nlocators; i++)
    {
        if (RelFileLocatorBackendIsTemp(smgr_reln[i]->smgr_rlocator))
        {
            if (smgr_reln[i]->smgr_rlocator.backend == MyBackendId)
                DropRelationAllLocalBuffers(smgr_reln[i]->smgr_rlocator.locator);
        }
        else
            rels[n++] = smgr_reln[i];
    }
 
    /*
     * If there are no non-local relations, then we're done. Release the
     * memory and return.
     */
    if (n == 0)
    {
        pfree(rels);
        return;
    }
 
    /*
     * This is used to remember the number of blocks for all the relations
     * forks.
     */
    block = (BlockNumber (*)[MAX_FORKNUM + 1])
        palloc(sizeof(BlockNumber) * n * (MAX_FORKNUM + 1));
 
    /*
     * We can avoid scanning the entire buffer pool if we know the exact size
     * of each of the given relation forks. See DropRelationBuffers.
     */
    for (i = 0; i < n && cached; i++)
    {
        for (int j = 0; j <= MAX_FORKNUM; j++)
        {
            /* Get the number of blocks for a relation's fork. */
            block[i][j] = smgrnblocks_cached(rels[i], j);
 
            /* We need to only consider the relation forks that exists. */
            if (block[i][j] == InvalidBlockNumber)
            {
                if (!smgrexists(rels[i], j))
                    continue;
                cached = false;
                break;
            }
 
            /* calculate the total number of blocks to be invalidated */
            nBlocksToInvalidate += block[i][j];
        }
    }
 
    /*
     * We apply the optimization iff the total number of blocks to invalidate
     * is below the BUF_DROP_FULL_SCAN_THRESHOLD.
     */
    if (cached && nBlocksToInvalidate < BUF_DROP_FULL_SCAN_THRESHOLD)
    {
        for (i = 0; i < n; i++)
        {
            for (int j = 0; j <= MAX_FORKNUM; j++)
            {
                /* ignore relation forks that doesn't exist */
                if (!BlockNumberIsValid(block[i][j]))
                    continue;
 
                /* drop all the buffers for a particular relation fork */
                FindAndDropRelationBuffers(rels[i]->smgr_rlocator.locator,
                                           j, block[i][j], 0);
            }
        }
 
        pfree(block);
        pfree(rels);
        return;
    }
 
    pfree(block);
    locators = palloc(sizeof(RelFileLocator) * n);  /* non-local relations */
    for (i = 0; i < n; i++)
        locators[i] = rels[i]->smgr_rlocator.locator;
 
    /*
     * For low number of relations to drop just use a simple walk through, to
     * save the bsearch overhead. The threshold to use is rather a guess than
     * an exactly determined value, as it depends on many factors (CPU and RAM
     * speeds, amount of shared buffers etc.).
     */
    use_bsearch = n > RELS_BSEARCH_THRESHOLD;
 
    /* sort the list of rlocators if necessary */
    if (use_bsearch)
        pg_qsort(locators, n, sizeof(RelFileLocator), rlocator_comparator);
 
    for (i = 0; i < NBuffers; i++)
    {
        RelFileLocator *rlocator = NULL;
        BufferDesc *bufHdr = GetBufferDescriptor(i);
        uint32      buf_state;
 
        /*
         * As in DropRelationBuffers, an unlocked precheck should be safe and
         * saves some cycles.
         */
 
        if (!use_bsearch)
        {
            int         j;
 
            for (j = 0; j < n; j++)
            {
                if (BufTagMatchesRelFileLocator(&bufHdr->tag, &locators[j]))
                {
                    rlocator = &locators[j];
                    break;
                }
            }
        }
        else
        {
            RelFileLocator locator;
 
            locator = BufTagGetRelFileLocator(&bufHdr->tag);
            rlocator = bsearch((const void *) &(locator),
                               locators, n, sizeof(RelFileLocator),
                               rlocator_comparator);
        }
 
        /* buffer doesn't belong to any of the given relfilelocators; skip it */
        if (rlocator == NULL)
            continue;
 
        buf_state = LockBufHdr(bufHdr);
        if (BufTagMatchesRelFileLocator(&bufHdr->tag, rlocator))
            InvalidateBuffer(bufHdr);   /* releases spinlock */
        else
            UnlockBufHdr(bufHdr, buf_state);
    }
 
    pfree(locators);
    pfree(rels);
}

References BlockNumberIsValid(), BUF_DROP_FULL_SCAN_THRESHOLD, BufTagGetRelFileLocator(), BufTagMatchesRelFileLocator(), DropRelationAllLocalBuffers(), FindAndDropRelationBuffers(), GetBufferDescriptor(), i, if(), InvalidateBuffer(), InvalidBlockNumber, j, LockBufHdr(), MAX_FORKNUM, MyBackendId, NBuffers, palloc(), pfree(), pg_qsort(), RelFileLocatorBackendIsTemp, RELS_BSEARCH_THRESHOLD, rlocator_comparator(), smgrexists(), smgrnblocks_cached(), BufferDesc::tag, and UnlockBufHdr().

Referenced by smgrdounlinkall().

ExtendBufferedRel()

Buffer ExtendBufferedRel	(	BufferManagerRelation	bmr,
		ForkNumber	forkNum,
		BufferAccessStrategy	strategy,
		uint32	flags
	)

Definition at line 812 of file bufmgr.c.

{
    Buffer      buf;
    uint32      extend_by = 1;
 
    ExtendBufferedRelBy(bmr, forkNum, strategy, flags, extend_by,
                        &buf, &extend_by);
 
    return buf;
}

References buf, and ExtendBufferedRelBy().

Referenced by _bt_allocbuf(), _hash_getnewbuf(), BloomNewBuffer(), brinbuild(), brinbuildempty(), fill_seq_fork_with_data(), ginbuildempty(), GinNewBuffer(), gistbuildempty(), gistNewBuffer(), ReadBuffer_common(), revmap_physical_extend(), and SpGistNewBuffer().

ExtendBufferedRelBy()

BlockNumber ExtendBufferedRelBy	(	BufferManagerRelation	bmr,
		ForkNumber	fork,
		BufferAccessStrategy	strategy,
		uint32	flags,
		uint32	extend_by,
		Buffer *	buffers,
		uint32 *	extended_by
	)

Definition at line 844 of file bufmgr.c.

{
    Assert((bmr.rel != NULL) != (bmr.smgr != NULL));
    Assert(bmr.smgr == NULL || bmr.relpersistence != 0);
    Assert(extend_by > 0);
 
    if (bmr.smgr == NULL)
    {
        bmr.smgr = RelationGetSmgr(bmr.rel);
        bmr.relpersistence = bmr.rel->rd_rel->relpersistence;
    }
 
    return ExtendBufferedRelCommon(bmr, fork, strategy, flags,
                                   extend_by, InvalidBlockNumber,
                                   buffers, extended_by);
}

References Assert(), ExtendBufferedRelCommon(), InvalidBlockNumber, RelationData::rd_rel, BufferManagerRelation::rel, RelationGetSmgr(), BufferManagerRelation::relpersistence, and BufferManagerRelation::smgr.

Referenced by ExtendBufferedRel(), and RelationAddBlocks().

ExtendBufferedRelCommon()

static BlockNumber ExtendBufferedRelCommon ( BufferManagerRelation  bmr, ForkNumber  fork, BufferAccessStrategy  strategy, uint32  flags, uint32  extend_by, BlockNumber  extend_upto, Buffer *  buffers, uint32 *  extended_by  )

static

Definition at line 1782 of file bufmgr.c.

{
    BlockNumber first_block;
 
    TRACE_POSTGRESQL_BUFFER_EXTEND_START(fork,
                                         bmr.smgr->smgr_rlocator.locator.spcOid,
                                         bmr.smgr->smgr_rlocator.locator.dbOid,
                                         bmr.smgr->smgr_rlocator.locator.relNumber,
                                         bmr.smgr->smgr_rlocator.backend,
                                         extend_by);
 
    if (bmr.relpersistence == RELPERSISTENCE_TEMP)
        first_block = ExtendBufferedRelLocal(bmr, fork, flags,
                                             extend_by, extend_upto,
                                             buffers, &extend_by);
    else
        first_block = ExtendBufferedRelShared(bmr, fork, strategy, flags,
                                              extend_by, extend_upto,
                                              buffers, &extend_by);
    *extended_by = extend_by;
 
    TRACE_POSTGRESQL_BUFFER_EXTEND_DONE(fork,
                                        bmr.smgr->smgr_rlocator.locator.spcOid,
                                        bmr.smgr->smgr_rlocator.locator.dbOid,
                                        bmr.smgr->smgr_rlocator.locator.relNumber,
                                        bmr.smgr->smgr_rlocator.backend,
                                        *extended_by,
                                        first_block);
 
    return first_block;
}

References RelFileLocatorBackend::backend, RelFileLocator::dbOid, ExtendBufferedRelLocal(), ExtendBufferedRelShared(), RelFileLocatorBackend::locator, RelFileLocator::relNumber, BufferManagerRelation::relpersistence, BufferManagerRelation::smgr, SMgrRelationData::smgr_rlocator, and RelFileLocator::spcOid.

Referenced by ExtendBufferedRelBy(), and ExtendBufferedRelTo().

ExtendBufferedRelShared()

static BlockNumber ExtendBufferedRelShared ( BufferManagerRelation  bmr, ForkNumber  fork, BufferAccessStrategy  strategy, uint32  flags, uint32  extend_by, BlockNumber  extend_upto, Buffer *  buffers, uint32 *  extended_by  )

static

Definition at line 1826 of file bufmgr.c.

{
    BlockNumber first_block;
    IOContext   io_context = IOContextForStrategy(strategy);
    instr_time  io_start;
 
    LimitAdditionalPins(&extend_by);
 
    /*
     * Acquire victim buffers for extension without holding extension lock.
     * Writing out victim buffers is the most expensive part of extending the
     * relation, particularly when doing so requires WAL flushes. Zeroing out
     * the buffers is also quite expensive, so do that before holding the
     * extension lock as well.
     *
     * These pages are pinned by us and not valid. While we hold the pin they
     * can't be acquired as victim buffers by another backend.
     */
    for (uint32 i = 0; i < extend_by; i++)
    {
        Block       buf_block;
 
        buffers[i] = GetVictimBuffer(strategy, io_context);
        buf_block = BufHdrGetBlock(GetBufferDescriptor(buffers[i] - 1));
 
        /* new buffers are zero-filled */
        MemSet((char *) buf_block, 0, BLCKSZ);
    }
 
    /* in case we need to pin an existing buffer below */
    ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
 
    /*
     * Lock relation against concurrent extensions, unless requested not to.
     *
     * We use the same extension lock for all forks. That's unnecessarily
     * restrictive, but currently extensions for forks don't happen often
     * enough to make it worth locking more granularly.
     *
     * Note that another backend might have extended the relation by the time
     * we get the lock.
     */
    if (!(flags & EB_SKIP_EXTENSION_LOCK))
    {
        LockRelationForExtension(bmr.rel, ExclusiveLock);
        if (bmr.rel)
            bmr.smgr = RelationGetSmgr(bmr.rel);
    }
 
    /*
     * If requested, invalidate size cache, so that smgrnblocks asks the
     * kernel.
     */
    if (flags & EB_CLEAR_SIZE_CACHE)
        bmr.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
 
    first_block = smgrnblocks(bmr.smgr, fork);
 
    /*
     * Now that we have the accurate relation size, check if the caller wants
     * us to extend to only up to a specific size. If there were concurrent
     * extensions, we might have acquired too many buffers and need to release
     * them.
     */
    if (extend_upto != InvalidBlockNumber)
    {
        uint32      orig_extend_by = extend_by;
 
        if (first_block > extend_upto)
            extend_by = 0;
        else if ((uint64) first_block + extend_by > extend_upto)
            extend_by = extend_upto - first_block;
 
        for (uint32 i = extend_by; i < orig_extend_by; i++)
        {
            BufferDesc *buf_hdr = GetBufferDescriptor(buffers[i] - 1);
 
            /*
             * The victim buffer we acquired peviously is clean and unused,
             * let it be found again quickly
             */
            StrategyFreeBuffer(buf_hdr);
            UnpinBuffer(buf_hdr);
        }
 
        if (extend_by == 0)
        {
            if (!(flags & EB_SKIP_EXTENSION_LOCK))
                UnlockRelationForExtension(bmr.rel, ExclusiveLock);
            *extended_by = extend_by;
            return first_block;
        }
    }
 
    /* Fail if relation is already at maximum possible length */
    if ((uint64) first_block + extend_by >= MaxBlockNumber)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("cannot extend relation %s beyond %u blocks",
                        relpath(bmr.smgr->smgr_rlocator, fork),
                        MaxBlockNumber)));
 
    /*
     * Insert buffers into buffer table, mark as IO_IN_PROGRESS.
     *
     * This needs to happen before we extend the relation, because as soon as
     * we do, other backends can start to read in those pages.
     */
    for (uint32 i = 0; i < extend_by; i++)
    {
        Buffer      victim_buf = buffers[i];
        BufferDesc *victim_buf_hdr = GetBufferDescriptor(victim_buf - 1);
        BufferTag   tag;
        uint32      hash;
        LWLock     *partition_lock;
        int         existing_id;
 
        InitBufferTag(&tag, &bmr.smgr->smgr_rlocator.locator, fork, first_block + i);
        hash = BufTableHashCode(&tag);
        partition_lock = BufMappingPartitionLock(hash);
 
        LWLockAcquire(partition_lock, LW_EXCLUSIVE);
 
        existing_id = BufTableInsert(&tag, hash, victim_buf_hdr->buf_id);
 
        /*
         * We get here only in the corner case where we are trying to extend
         * the relation but we found a pre-existing buffer. This can happen
         * because a prior attempt at extending the relation failed, and
         * because mdread doesn't complain about reads beyond EOF (when
         * zero_damaged_pages is ON) and so a previous attempt to read a block
         * beyond EOF could have left a "valid" zero-filled buffer.
         * Unfortunately, we have also seen this case occurring because of
         * buggy Linux kernels that sometimes return an lseek(SEEK_END) result
         * that doesn't account for a recent write. In that situation, the
         * pre-existing buffer would contain valid data that we don't want to
         * overwrite.  Since the legitimate cases should always have left a
         * zero-filled buffer, complain if not PageIsNew.
         */
        if (existing_id >= 0)
        {
            BufferDesc *existing_hdr = GetBufferDescriptor(existing_id);
            Block       buf_block;
            bool        valid;
 
            /*
             * Pin the existing buffer before releasing the partition lock,
             * preventing it from being evicted.
             */
            valid = PinBuffer(existing_hdr, strategy);
 
            LWLockRelease(partition_lock);
 
            /*
             * The victim buffer we acquired peviously is clean and unused,
             * let it be found again quickly
             */
            StrategyFreeBuffer(victim_buf_hdr);
            UnpinBuffer(victim_buf_hdr);
 
            buffers[i] = BufferDescriptorGetBuffer(existing_hdr);
            buf_block = BufHdrGetBlock(existing_hdr);
 
            if (valid && !PageIsNew((Page) buf_block))
                ereport(ERROR,
                        (errmsg("unexpected data beyond EOF in block %u of relation %s",
                                existing_hdr->tag.blockNum, relpath(bmr.smgr->smgr_rlocator, fork)),
                         errhint("This has been seen to occur with buggy kernels; consider updating your system.")));
 
            /*
             * We *must* do smgr[zero]extend before succeeding, else the page
             * will not be reserved by the kernel, and the next P_NEW call
             * will decide to return the same page.  Clear the BM_VALID bit,
             * do StartBufferIO() and proceed.
             *
             * Loop to handle the very small possibility that someone re-sets
             * BM_VALID between our clearing it and StartBufferIO inspecting
             * it.
             */
            do
            {
                uint32      buf_state = LockBufHdr(existing_hdr);
 
                buf_state &= ~BM_VALID;
                UnlockBufHdr(existing_hdr, buf_state);
            } while (!StartBufferIO(existing_hdr, true));
        }
        else
        {
            uint32      buf_state;
 
            buf_state = LockBufHdr(victim_buf_hdr);
 
            /* some sanity checks while we hold the buffer header lock */
            Assert(!(buf_state & (BM_VALID | BM_TAG_VALID | BM_DIRTY | BM_JUST_DIRTIED)));
            Assert(BUF_STATE_GET_REFCOUNT(buf_state) == 1);
 
            victim_buf_hdr->tag = tag;
 
            buf_state |= BM_TAG_VALID | BUF_USAGECOUNT_ONE;
            if (bmr.relpersistence == RELPERSISTENCE_PERMANENT || fork == INIT_FORKNUM)
                buf_state |= BM_PERMANENT;
 
            UnlockBufHdr(victim_buf_hdr, buf_state);
 
            LWLockRelease(partition_lock);
 
            /* XXX: could combine the locked operations in it with the above */
            StartBufferIO(victim_buf_hdr, true);
        }
    }
 
    io_start = pgstat_prepare_io_time();
 
    /*
     * Note: if smgrzeroextend fails, we will end up with buffers that are
     * allocated but not marked BM_VALID.  The next relation extension will
     * still select the same block number (because the relation didn't get any
     * longer on disk) and so future attempts to extend the relation will find
     * the same buffers (if they have not been recycled) but come right back
     * here to try smgrzeroextend again.
     *
     * We don't need to set checksum for all-zero pages.
     */
    smgrzeroextend(bmr.smgr, fork, first_block, extend_by, false);
 
    /*
     * Release the file-extension lock; it's now OK for someone else to extend
     * the relation some more.
     *
     * We remove IO_IN_PROGRESS after this, as waking up waiting backends can
     * take noticeable time.
     */
    if (!(flags & EB_SKIP_EXTENSION_LOCK))
        UnlockRelationForExtension(bmr.rel, ExclusiveLock);
 
    pgstat_count_io_op_time(IOOBJECT_RELATION, io_context, IOOP_EXTEND,
                            io_start, extend_by);
 
    /* Set BM_VALID, terminate IO, and wake up any waiters */
    for (uint32 i = 0; i < extend_by; i++)
    {
        Buffer      buf = buffers[i];
        BufferDesc *buf_hdr = GetBufferDescriptor(buf - 1);
        bool        lock = false;
 
        if (flags & EB_LOCK_FIRST && i == 0)
            lock = true;
        else if (flags & EB_LOCK_TARGET)
        {
            Assert(extend_upto != InvalidBlockNumber);
            if (first_block + i + 1 == extend_upto)
                lock = true;
        }
 
        if (lock)
            LWLockAcquire(BufferDescriptorGetContentLock(buf_hdr), LW_EXCLUSIVE);
 
        TerminateBufferIO(buf_hdr, false, BM_VALID);
    }
 
    pgBufferUsage.shared_blks_written += extend_by;
 
    *extended_by = extend_by;
 
    return first_block;
}

References Assert(), buftag::blockNum, BM_DIRTY, BM_JUST_DIRTIED, BM_PERMANENT, BM_TAG_VALID, BM_VALID, buf, BufferDesc::buf_id, BUF_STATE_GET_REFCOUNT, BUF_USAGECOUNT_ONE, BufferDescriptorGetBuffer(), BufferDescriptorGetContentLock(), BufHdrGetBlock, BufMappingPartitionLock(), BufTableHashCode(), BufTableInsert(), CurrentResourceOwner, EB_CLEAR_SIZE_CACHE, EB_LOCK_FIRST, EB_LOCK_TARGET, EB_SKIP_EXTENSION_LOCK, ereport, errcode(), errhint(), errmsg(), ERROR, ExclusiveLock, GetBufferDescriptor(), GetVictimBuffer(), hash(), i, INIT_FORKNUM, InitBufferTag(), InvalidBlockNumber, IOContextForStrategy(), IOOBJECT_RELATION, IOOP_EXTEND, LimitAdditionalPins(), RelFileLocatorBackend::locator, LockBufHdr(), LockRelationForExtension(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaxBlockNumber, MemSet, PageIsNew(), pgBufferUsage, pgstat_count_io_op_time(), pgstat_prepare_io_time(), PinBuffer(), BufferManagerRelation::rel, RelationGetSmgr(), relpath, BufferManagerRelation::relpersistence, ResourceOwnerEnlargeBuffers(), BufferUsage::shared_blks_written, BufferManagerRelation::smgr, SMgrRelationData::smgr_cached_nblocks, SMgrRelationData::smgr_rlocator, smgrnblocks(), smgrzeroextend(), StartBufferIO(), StrategyFreeBuffer(), BufferDesc::tag, TerminateBufferIO(), UnlockBufHdr(), UnlockRelationForExtension(), and UnpinBuffer().

Referenced by ExtendBufferedRelCommon().

ExtendBufferedRelTo()

Buffer ExtendBufferedRelTo	(	BufferManagerRelation	bmr,
		ForkNumber	fork,
		BufferAccessStrategy	strategy,
		uint32	flags,
		BlockNumber	extend_to,
		ReadBufferMode	mode
	)

Definition at line 876 of file bufmgr.c.

{
    BlockNumber current_size;
    uint32      extended_by = 0;
    Buffer      buffer = InvalidBuffer;
    Buffer      buffers[64];
 
    Assert((bmr.rel != NULL) != (bmr.smgr != NULL));
    Assert(bmr.smgr == NULL || bmr.relpersistence != 0);
    Assert(extend_to != InvalidBlockNumber && extend_to > 0);
 
    if (bmr.smgr == NULL)
    {
        bmr.smgr = RelationGetSmgr(bmr.rel);
        bmr.relpersistence = bmr.rel->rd_rel->relpersistence;
    }
 
    /*
     * If desired, create the file if it doesn't exist.  If
     * smgr_cached_nblocks[fork] is positive then it must exist, no need for
     * an smgrexists call.
     */
    if ((flags & EB_CREATE_FORK_IF_NEEDED) &&
        (bmr.smgr->smgr_cached_nblocks[fork] == 0 ||
         bmr.smgr->smgr_cached_nblocks[fork] == InvalidBlockNumber) &&
        !smgrexists(bmr.smgr, fork))
    {
        LockRelationForExtension(bmr.rel, ExclusiveLock);
 
        /* could have been closed while waiting for lock */
        if (bmr.rel)
            bmr.smgr = RelationGetSmgr(bmr.rel);
 
        /* recheck, fork might have been created concurrently */
        if (!smgrexists(bmr.smgr, fork))
            smgrcreate(bmr.smgr, fork, flags & EB_PERFORMING_RECOVERY);
 
        UnlockRelationForExtension(bmr.rel, ExclusiveLock);
    }
 
    /*
     * If requested, invalidate size cache, so that smgrnblocks asks the
     * kernel.
     */
    if (flags & EB_CLEAR_SIZE_CACHE)
        bmr.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
 
    /*
     * Estimate how many pages we'll need to extend by. This avoids acquiring
     * unnecessarily many victim buffers.
     */
    current_size = smgrnblocks(bmr.smgr, fork);
 
    /*
     * Since no-one else can be looking at the page contents yet, there is no
     * difference between an exclusive lock and a cleanup-strength lock. Note
     * that we pass the original mode to ReadBuffer_common() below, when
     * falling back to reading the buffer to a concurrent relation extension.
     */
    if (mode == RBM_ZERO_AND_LOCK || mode == RBM_ZERO_AND_CLEANUP_LOCK)
        flags |= EB_LOCK_TARGET;
 
    while (current_size < extend_to)
    {
        uint32      num_pages = lengthof(buffers);
        BlockNumber first_block;
 
        if ((uint64) current_size + num_pages > extend_to)
            num_pages = extend_to - current_size;
 
        first_block = ExtendBufferedRelCommon(bmr, fork, strategy, flags,
                                              num_pages, extend_to,
                                              buffers, &extended_by);
 
        current_size = first_block + extended_by;
        Assert(num_pages != 0 || current_size >= extend_to);
 
        for (uint32 i = 0; i < extended_by; i++)
        {
            if (first_block + i != extend_to - 1)
                ReleaseBuffer(buffers[i]);
            else
                buffer = buffers[i];
        }
    }
 
    /*
     * It's possible that another backend concurrently extended the relation.
     * In that case read the buffer.
     *
     * XXX: Should we control this via a flag?
     */
    if (buffer == InvalidBuffer)
    {
        bool        hit;
 
        Assert(extended_by == 0);
        buffer = ReadBuffer_common(bmr.smgr, bmr.relpersistence,
                                   fork, extend_to - 1, mode, strategy,
                                   &hit);
    }
 
    return buffer;
}

References Assert(), PrivateRefCountEntry::buffer, current_size, EB_CLEAR_SIZE_CACHE, EB_CREATE_FORK_IF_NEEDED, EB_LOCK_TARGET, EB_PERFORMING_RECOVERY, ExclusiveLock, ExtendBufferedRelCommon(), i, InvalidBlockNumber, InvalidBuffer, lengthof, LockRelationForExtension(), mode, RBM_ZERO_AND_CLEANUP_LOCK, RBM_ZERO_AND_LOCK, RelationData::rd_rel, ReadBuffer_common(), BufferManagerRelation::rel, RelationGetSmgr(), ReleaseBuffer(), BufferManagerRelation::relpersistence, BufferManagerRelation::smgr, SMgrRelationData::smgr_cached_nblocks, smgrcreate(), smgrexists(), smgrnblocks(), and UnlockRelationForExtension().

Referenced by fsm_extend(), vm_extend(), and XLogReadBufferExtended().

FindAndDropRelationBuffers()

static void FindAndDropRelationBuffers ( RelFileLocator  rlocator, ForkNumber  forkNum, BlockNumber  nForkBlock, BlockNumber  firstDelBlock  )

static

Definition at line 3891 of file bufmgr.c.

{
    BlockNumber curBlock;
 
    for (curBlock = firstDelBlock; curBlock < nForkBlock; curBlock++)
    {
        uint32      bufHash;    /* hash value for tag */
        BufferTag   bufTag;     /* identity of requested block */
        LWLock     *bufPartitionLock;   /* buffer partition lock for it */
        int         buf_id;
        BufferDesc *bufHdr;
        uint32      buf_state;
 
        /* create a tag so we can lookup the buffer */
        InitBufferTag(&bufTag, &rlocator, forkNum, curBlock);
 
        /* determine its hash code and partition lock ID */
        bufHash = BufTableHashCode(&bufTag);
        bufPartitionLock = BufMappingPartitionLock(bufHash);
 
        /* Check that it is in the buffer pool. If not, do nothing. */
        LWLockAcquire(bufPartitionLock, LW_SHARED);
        buf_id = BufTableLookup(&bufTag, bufHash);
        LWLockRelease(bufPartitionLock);
 
        if (buf_id < 0)
            continue;
 
        bufHdr = GetBufferDescriptor(buf_id);
 
        /*
         * We need to lock the buffer header and recheck if the buffer is
         * still associated with the same block because the buffer could be
         * evicted by some other backend loading blocks for a different
         * relation after we release lock on the BufMapping table.
         */
        buf_state = LockBufHdr(bufHdr);
 
        if (BufTagMatchesRelFileLocator(&bufHdr->tag, &rlocator) &&
            BufTagGetForkNum(&bufHdr->tag) == forkNum &&
            bufHdr->tag.blockNum >= firstDelBlock)
            InvalidateBuffer(bufHdr);   /* releases spinlock */
        else
            UnlockBufHdr(bufHdr, buf_state);
    }
}

References buftag::blockNum, BufMappingPartitionLock(), BufTableHashCode(), BufTableLookup(), BufTagGetForkNum(), BufTagMatchesRelFileLocator(), GetBufferDescriptor(), InitBufferTag(), InvalidateBuffer(), LockBufHdr(), LW_SHARED, LWLockAcquire(), LWLockRelease(), BufferDesc::tag, and UnlockBufHdr().

Referenced by DropRelationBuffers(), and DropRelationsAllBuffers().

FlushBuffer()

static void FlushBuffer ( BufferDesc *  buf, SMgrRelation  reln, IOObject  io_object, IOContext  io_context  )

static

Definition at line 3350 of file bufmgr.c.

{
    XLogRecPtr  recptr;
    ErrorContextCallback errcallback;
    instr_time  io_start;
    Block       bufBlock;
    char       *bufToWrite;
    uint32      buf_state;
 
    /*
     * Try to start an I/O operation.  If StartBufferIO returns false, then
     * someone else flushed the buffer before we could, so we need not do
     * anything.
     */
    if (!StartBufferIO(buf, false))
        return;
 
    /* Setup error traceback support for ereport() */
    errcallback.callback = shared_buffer_write_error_callback;
    errcallback.arg = (void *) buf;
    errcallback.previous = error_context_stack;
    error_context_stack = &errcallback;
 
    /* Find smgr relation for buffer */
    if (reln == NULL)
        reln = smgropen(BufTagGetRelFileLocator(&buf->tag), InvalidBackendId);
 
    TRACE_POSTGRESQL_BUFFER_FLUSH_START(BufTagGetForkNum(&buf->tag),
                                        buf->tag.blockNum,
                                        reln->smgr_rlocator.locator.spcOid,
                                        reln->smgr_rlocator.locator.dbOid,
                                        reln->smgr_rlocator.locator.relNumber);
 
    buf_state = LockBufHdr(buf);
 
    /*
     * Run PageGetLSN while holding header lock, since we don't have the
     * buffer locked exclusively in all cases.
     */
    recptr = BufferGetLSN(buf);
 
    /* To check if block content changes while flushing. - vadim 01/17/97 */
    buf_state &= ~BM_JUST_DIRTIED;
    UnlockBufHdr(buf, buf_state);
 
    /*
     * Force XLOG flush up to buffer's LSN.  This implements the basic WAL
     * rule that log updates must hit disk before any of the data-file changes
     * they describe do.
     *
     * However, this rule does not apply to unlogged relations, which will be
     * lost after a crash anyway.  Most unlogged relation pages do not bear
     * LSNs since we never emit WAL records for them, and therefore flushing
     * up through the buffer LSN would be useless, but harmless.  However,
     * GiST indexes use LSNs internally to track page-splits, and therefore
     * unlogged GiST pages bear "fake" LSNs generated by
     * GetFakeLSNForUnloggedRel.  It is unlikely but possible that the fake
     * LSN counter could advance past the WAL insertion point; and if it did
     * happen, attempting to flush WAL through that location would fail, with
     * disastrous system-wide consequences.  To make sure that can't happen,
     * skip the flush if the buffer isn't permanent.
     */
    if (buf_state & BM_PERMANENT)
        XLogFlush(recptr);
 
    /*
     * Now it's safe to write buffer to disk. Note that no one else should
     * have been able to write it while we were busy with log flushing because
     * only one process at a time can set the BM_IO_IN_PROGRESS bit.
     */
    bufBlock = BufHdrGetBlock(buf);
 
    /*
     * Update page checksum if desired.  Since we have only shared lock on the
     * buffer, other processes might be updating hint bits in it, so we must
     * copy the page to private storage if we do checksumming.
     */
    bufToWrite = PageSetChecksumCopy((Page) bufBlock, buf->tag.blockNum);
 
    io_start = pgstat_prepare_io_time();
 
    /*
     * bufToWrite is either the shared buffer or a copy, as appropriate.
     */
    smgrwrite(reln,
              BufTagGetForkNum(&buf->tag),
              buf->tag.blockNum,
              bufToWrite,
              false);
 
    /*
     * When a strategy is in use, only flushes of dirty buffers already in the
     * strategy ring are counted as strategy writes (IOCONTEXT
     * [BULKREAD|BULKWRITE|VACUUM] IOOP_WRITE) for the purpose of IO
     * statistics tracking.
     *
     * If a shared buffer initially added to the ring must be flushed before
     * being used, this is counted as an IOCONTEXT_NORMAL IOOP_WRITE.
     *
     * If a shared buffer which was added to the ring later because the
     * current strategy buffer is pinned or in use or because all strategy
     * buffers were dirty and rejected (for BAS_BULKREAD operations only)
     * requires flushing, this is counted as an IOCONTEXT_NORMAL IOOP_WRITE
     * (from_ring will be false).
     *
     * When a strategy is not in use, the write can only be a "regular" write
     * of a dirty shared buffer (IOCONTEXT_NORMAL IOOP_WRITE).
     */
    pgstat_count_io_op_time(IOOBJECT_RELATION, io_context,
                            IOOP_WRITE, io_start, 1);
 
    pgBufferUsage.shared_blks_written++;
 
    /*
     * Mark the buffer as clean (unless BM_JUST_DIRTIED has become set) and
     * end the BM_IO_IN_PROGRESS state.
     */
    TerminateBufferIO(buf, true, 0);
 
    TRACE_POSTGRESQL_BUFFER_FLUSH_DONE(BufTagGetForkNum(&buf->tag),
                                       buf->tag.blockNum,
                                       reln->smgr_rlocator.locator.spcOid,
                                       reln->smgr_rlocator.locator.dbOid,
                                       reln->smgr_rlocator.locator.relNumber);
 
    /* Pop the error context stack */
    error_context_stack = errcallback.previous;
}

References ErrorContextCallback::arg, BM_JUST_DIRTIED, BM_PERMANENT, buf, BufferGetLSN, BufHdrGetBlock, BufTagGetForkNum(), BufTagGetRelFileLocator(), ErrorContextCallback::callback, RelFileLocator::dbOid, error_context_stack, InvalidBackendId, IOOBJECT_RELATION, IOOP_WRITE, RelFileLocatorBackend::locator, LockBufHdr(), PageSetChecksumCopy(), pgBufferUsage, pgstat_count_io_op_time(), pgstat_prepare_io_time(), ErrorContextCallback::previous, RelFileLocator::relNumber, BufferUsage::shared_blks_written, shared_buffer_write_error_callback(), SMgrRelationData::smgr_rlocator, smgropen(), smgrwrite(), RelFileLocator::spcOid, StartBufferIO(), TerminateBufferIO(), UnlockBufHdr(), and XLogFlush().

Referenced by FlushDatabaseBuffers(), FlushOneBuffer(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetVictimBuffer(), and SyncOneBuffer().

FlushDatabaseBuffers()

void FlushDatabaseBuffers

(

Oid

dbid

)

Definition at line 4417 of file bufmgr.c.

{
    int         i;
    BufferDesc *bufHdr;
 
    /* Make sure we can handle the pin inside the loop */
    ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
 
    for (i = 0; i < NBuffers; i++)
    {
        uint32      buf_state;
 
        bufHdr = GetBufferDescriptor(i);
 
        /*
         * As in DropRelationBuffers, an unlocked precheck should be safe and
         * saves some cycles.
         */
        if (bufHdr->tag.dbOid != dbid)
            continue;
 
        ReservePrivateRefCountEntry();
 
        buf_state = LockBufHdr(bufHdr);
        if (bufHdr->tag.dbOid == dbid &&
            (buf_state & (BM_VALID | BM_DIRTY)) == (BM_VALID | BM_DIRTY))
        {
            PinBuffer_Locked(bufHdr);
            LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_SHARED);
            FlushBuffer(bufHdr, NULL, IOOBJECT_RELATION, IOCONTEXT_NORMAL);
            LWLockRelease(BufferDescriptorGetContentLock(bufHdr));
            UnpinBuffer(bufHdr);
        }
        else
            UnlockBufHdr(bufHdr, buf_state);
    }
}

References BM_DIRTY, BM_VALID, BufferDescriptorGetContentLock(), CurrentResourceOwner, buftag::dbOid, FlushBuffer(), GetBufferDescriptor(), i, IOCONTEXT_NORMAL, IOOBJECT_RELATION, LockBufHdr(), LW_SHARED, LWLockAcquire(), LWLockRelease(), NBuffers, PinBuffer_Locked(), ReservePrivateRefCountEntry(), ResourceOwnerEnlargeBuffers(), BufferDesc::tag, UnlockBufHdr(), and UnpinBuffer().

Referenced by dbase_redo().

FlushOneBuffer()

void FlushOneBuffer

(

Buffer

buffer

)

Definition at line 4460 of file bufmgr.c.

{
    BufferDesc *bufHdr;
 
    /* currently not needed, but no fundamental reason not to support */
    Assert(!BufferIsLocal(buffer));
 
    Assert(BufferIsPinned(buffer));
 
    bufHdr = GetBufferDescriptor(buffer - 1);
 
    Assert(LWLockHeldByMe(BufferDescriptorGetContentLock(bufHdr)));
 
    FlushBuffer(bufHdr, NULL, IOOBJECT_RELATION, IOCONTEXT_NORMAL);
}

References Assert(), PrivateRefCountEntry::buffer, BufferDescriptorGetContentLock(), BufferIsLocal, BufferIsPinned, FlushBuffer(), GetBufferDescriptor(), IOCONTEXT_NORMAL, IOOBJECT_RELATION, and LWLockHeldByMe().

Referenced by hash_xlog_init_bitmap_page(), hash_xlog_init_meta_page(), and XLogReadBufferForRedoExtended().

FlushRelationBuffers()

void FlushRelationBuffers

(

Relation

rel

)

Definition at line 4058 of file bufmgr.c.

{
    int         i;
    BufferDesc *bufHdr;
 
    if (RelationUsesLocalBuffers(rel))
    {
        for (i = 0; i < NLocBuffer; i++)
        {
            uint32      buf_state;
            instr_time  io_start;
 
            bufHdr = GetLocalBufferDescriptor(i);
            if (BufTagMatchesRelFileLocator(&bufHdr->tag, &rel->rd_locator) &&
                ((buf_state = pg_atomic_read_u32(&bufHdr->state)) &
                 (BM_VALID | BM_DIRTY)) == (BM_VALID | BM_DIRTY))
            {
                ErrorContextCallback errcallback;
                Page        localpage;
 
                localpage = (char *) LocalBufHdrGetBlock(bufHdr);
 
                /* Setup error traceback support for ereport() */
                errcallback.callback = local_buffer_write_error_callback;
                errcallback.arg = (void *) bufHdr;
                errcallback.previous = error_context_stack;
                error_context_stack = &errcallback;
 
                PageSetChecksumInplace(localpage, bufHdr->tag.blockNum);
 
                io_start = pgstat_prepare_io_time();
 
                smgrwrite(RelationGetSmgr(rel),
                          BufTagGetForkNum(&bufHdr->tag),
                          bufHdr->tag.blockNum,
                          localpage,
                          false);
 
                pgstat_count_io_op_time(IOOBJECT_TEMP_RELATION,
                                        IOCONTEXT_NORMAL, IOOP_WRITE,
                                        io_start, 1);
 
                buf_state &= ~(BM_DIRTY | BM_JUST_DIRTIED);
                pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
 
                pgBufferUsage.local_blks_written++;
 
                /* Pop the error context stack */
                error_context_stack = errcallback.previous;
            }
        }
 
        return;
    }
 
    /* Make sure we can handle the pin inside the loop */
    ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
 
    for (i = 0; i < NBuffers; i++)
    {
        uint32      buf_state;
 
        bufHdr = GetBufferDescriptor(i);
 
        /*
         * As in DropRelationBuffers, an unlocked precheck should be safe and
         * saves some cycles.
         */
        if (!BufTagMatchesRelFileLocator(&bufHdr->tag, &rel->rd_locator))
            continue;
 
        ReservePrivateRefCountEntry();
 
        buf_state = LockBufHdr(bufHdr);
        if (BufTagMatchesRelFileLocator(&bufHdr->tag, &rel->rd_locator) &&
            (buf_state & (BM_VALID | BM_DIRTY)) == (BM_VALID | BM_DIRTY))
        {
            PinBuffer_Locked(bufHdr);
            LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_SHARED);
            FlushBuffer(bufHdr, RelationGetSmgr(rel), IOOBJECT_RELATION, IOCONTEXT_NORMAL);
            LWLockRelease(BufferDescriptorGetContentLock(bufHdr));
            UnpinBuffer(bufHdr);
        }
        else
            UnlockBufHdr(bufHdr, buf_state);
    }
}

References ErrorContextCallback::arg, buftag::blockNum, BM_DIRTY, BM_JUST_DIRTIED, BM_VALID, BufferDescriptorGetContentLock(), BufTagGetForkNum(), BufTagMatchesRelFileLocator(), ErrorContextCallback::callback, CurrentResourceOwner, error_context_stack, FlushBuffer(), GetBufferDescriptor(), GetLocalBufferDescriptor(), i, IOCONTEXT_NORMAL, IOOBJECT_RELATION, IOOBJECT_TEMP_RELATION, IOOP_WRITE, BufferUsage::local_blks_written, local_buffer_write_error_callback(), LocalBufHdrGetBlock, LockBufHdr(), LW_SHARED, LWLockAcquire(), LWLockRelease(), NBuffers, NLocBuffer, PageSetChecksumInplace(), pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), pgBufferUsage, pgstat_count_io_op_time(), pgstat_prepare_io_time(), PinBuffer_Locked(), ErrorContextCallback::previous, RelationData::rd_locator, RelationGetSmgr(), RelationUsesLocalBuffers, ReservePrivateRefCountEntry(), ResourceOwnerEnlargeBuffers(), smgrwrite(), BufferDesc::state, BufferDesc::tag, UnlockBufHdr(), and UnpinBuffer().

Referenced by fill_seq_with_data(), heapam_relation_copy_data(), and index_copy_data().

FlushRelationsAllBuffers()

void FlushRelationsAllBuffers	(	SMgrRelation *	smgrs,
		int	nrels
	)

Definition at line 4156 of file bufmgr.c.

{
    int         i;
    SMgrSortArray *srels;
    bool        use_bsearch;
 
    if (nrels == 0)
        return;
 
    /* fill-in array for qsort */
    srels = palloc(sizeof(SMgrSortArray) * nrels);
 
    for (i = 0; i < nrels; i++)
    {
        Assert(!RelFileLocatorBackendIsTemp(smgrs[i]->smgr_rlocator));
 
        srels[i].rlocator = smgrs[i]->smgr_rlocator.locator;
        srels[i].srel = smgrs[i];
    }
 
    /*
     * Save the bsearch overhead for low number of relations to sync. See
     * DropRelationsAllBuffers for details.
     */
    use_bsearch = nrels > RELS_BSEARCH_THRESHOLD;
 
    /* sort the list of SMgrRelations if necessary */
    if (use_bsearch)
        pg_qsort(srels, nrels, sizeof(SMgrSortArray), rlocator_comparator);
 
    /* Make sure we can handle the pin inside the loop */
    ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
 
    for (i = 0; i < NBuffers; i++)
    {
        SMgrSortArray *srelent = NULL;
        BufferDesc *bufHdr = GetBufferDescriptor(i);
        uint32      buf_state;
 
        /*
         * As in DropRelationBuffers, an unlocked precheck should be safe and
         * saves some cycles.
         */
 
        if (!use_bsearch)
        {
            int         j;
 
            for (j = 0; j < nrels; j++)
            {
                if (BufTagMatchesRelFileLocator(&bufHdr->tag, &srels[j].rlocator))
                {
                    srelent = &srels[j];
                    break;
                }
            }
        }
        else
        {
            RelFileLocator rlocator;
 
            rlocator = BufTagGetRelFileLocator(&bufHdr->tag);
            srelent = bsearch((const void *) &(rlocator),
                              srels, nrels, sizeof(SMgrSortArray),
                              rlocator_comparator);
        }
 
        /* buffer doesn't belong to any of the given relfilelocators; skip it */
        if (srelent == NULL)
            continue;
 
        ReservePrivateRefCountEntry();
 
        buf_state = LockBufHdr(bufHdr);
        if (BufTagMatchesRelFileLocator(&bufHdr->tag, &srelent->rlocator) &&
            (buf_state & (BM_VALID | BM_DIRTY)) == (BM_VALID | BM_DIRTY))
        {
            PinBuffer_Locked(bufHdr);
            LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_SHARED);
            FlushBuffer(bufHdr, srelent->srel, IOOBJECT_RELATION, IOCONTEXT_NORMAL);
            LWLockRelease(BufferDescriptorGetContentLock(bufHdr));
            UnpinBuffer(bufHdr);
        }
        else
            UnlockBufHdr(bufHdr, buf_state);
    }
 
    pfree(srels);
}

References Assert(), BM_DIRTY, BM_VALID, BufferDescriptorGetContentLock(), BufTagGetRelFileLocator(), BufTagMatchesRelFileLocator(), CurrentResourceOwner, FlushBuffer(), GetBufferDescriptor(), i, IOCONTEXT_NORMAL, IOOBJECT_RELATION, j, RelFileLocatorBackend::locator, LockBufHdr(), LW_SHARED, LWLockAcquire(), LWLockRelease(), NBuffers, palloc(), pfree(), pg_qsort(), PinBuffer_Locked(), RelFileLocatorBackendIsTemp, RELS_BSEARCH_THRESHOLD, ReservePrivateRefCountEntry(), ResourceOwnerEnlargeBuffers(), SMgrSortArray::rlocator, rlocator_comparator(), SMgrRelationData::smgr_rlocator, SMgrSortArray::srel, BufferDesc::tag, UnlockBufHdr(), and UnpinBuffer().

Referenced by smgrdosyncall().

ForgetPrivateRefCountEntry()

static void ForgetPrivateRefCountEntry ( PrivateRefCountEntry *  ref )

static

Definition at line 403 of file bufmgr.c.

{
    Assert(ref->refcount == 0);
 
    if (ref >= &PrivateRefCountArray[0] &&
        ref < &PrivateRefCountArray[REFCOUNT_ARRAY_ENTRIES])
    {
        ref->buffer = InvalidBuffer;
 
        /*
         * Mark the just used entry as reserved - in many scenarios that
         * allows us to avoid ever having to search the array/hash for free
         * entries.
         */
        ReservedRefCountEntry = ref;
    }
    else
    {
        bool        found;
        Buffer      buffer = ref->buffer;
 
        hash_search(PrivateRefCountHash, &buffer, HASH_REMOVE, &found);
        Assert(found);
        Assert(PrivateRefCountOverflowed > 0);
        PrivateRefCountOverflowed--;
    }
}

References Assert(), PrivateRefCountEntry::buffer, HASH_REMOVE, hash_search(), InvalidBuffer, PrivateRefCountArray, PrivateRefCountHash, PrivateRefCountOverflowed, PrivateRefCountEntry::refcount, REFCOUNT_ARRAY_ENTRIES, and ReservedRefCountEntry.

Referenced by UnpinBuffer().

GetPrivateRefCount()

static int32 GetPrivateRefCount ( Buffer  buffer )

inlinestatic

Definition at line 380 of file bufmgr.c.

{
    PrivateRefCountEntry *ref;
 
    Assert(BufferIsValid(buffer));
    Assert(!BufferIsLocal(buffer));
 
    /*
     * Not moving the entry - that's ok for the current users, but we might
     * want to change this one day.
     */
    ref = GetPrivateRefCountEntry(buffer, false);
 
    if (ref == NULL)
        return 0;
    return ref->refcount;
}

References Assert(), PrivateRefCountEntry::buffer, BufferIsLocal, BufferIsValid(), GetPrivateRefCountEntry(), and PrivateRefCountEntry::refcount.

Referenced by CheckBufferIsPinnedOnce(), ConditionalLockBufferForCleanup(), HoldingBufferPinThatDelaysRecovery(), InvalidateBuffer(), InvalidateVictimBuffer(), IsBufferCleanupOK(), MarkBufferDirtyHint(), PrintBufferLeakWarning(), and ReadRecentBuffer().

GetPrivateRefCountEntry()

static PrivateRefCountEntry * GetPrivateRefCountEntry ( Buffer  buffer, bool  do_move  )

static

Definition at line 306 of file bufmgr.c.

{
    PrivateRefCountEntry *res;
    int         i;
 
    Assert(BufferIsValid(buffer));
    Assert(!BufferIsLocal(buffer));
 
    /*
     * First search for references in the array, that'll be sufficient in the
     * majority of cases.
     */
    for (i = 0; i < REFCOUNT_ARRAY_ENTRIES; i++)
    {
        res = &PrivateRefCountArray[i];
 
        if (res->buffer == buffer)
            return res;
    }
 
    /*
     * By here we know that the buffer, if already pinned, isn't residing in
     * the array.
     *
     * Only look up the buffer in the hashtable if we've previously overflowed
     * into it.
     */
    if (PrivateRefCountOverflowed == 0)
        return NULL;
 
    res = hash_search(PrivateRefCountHash, &buffer, HASH_FIND, NULL);
 
    if (res == NULL)
        return NULL;
    else if (!do_move)
    {
        /* caller doesn't want us to move the hash entry into the array */
        return res;
    }
    else
    {
        /* move buffer from hashtable into the free array slot */
        bool        found;
        PrivateRefCountEntry *free;
 
        /* Ensure there's a free array slot */
        ReservePrivateRefCountEntry();
 
        /* Use up the reserved slot */
        Assert(ReservedRefCountEntry != NULL);
        free = ReservedRefCountEntry;
        ReservedRefCountEntry = NULL;
        Assert(free->buffer == InvalidBuffer);
 
        /* and fill it */
        free->buffer = buffer;
        free->refcount = res->refcount;
 
        /* delete from hashtable */
        hash_search(PrivateRefCountHash, &buffer, HASH_REMOVE, &found);
        Assert(found);
        Assert(PrivateRefCountOverflowed > 0);
        PrivateRefCountOverflowed--;
 
        return free;
    }
}

References Assert(), PrivateRefCountEntry::buffer, BufferIsLocal, BufferIsValid(), free, HASH_FIND, HASH_REMOVE, hash_search(), i, InvalidBuffer, PrivateRefCountArray, PrivateRefCountHash, PrivateRefCountOverflowed, REFCOUNT_ARRAY_ENTRIES, res, ReservedRefCountEntry, and ReservePrivateRefCountEntry().

Referenced by GetPrivateRefCount(), IncrBufferRefCount(), PinBuffer(), PinBuffer_Locked(), and UnpinBuffer().

GetVictimBuffer()

static Buffer GetVictimBuffer ( BufferAccessStrategy  strategy, IOContext  io_context  )

static

Definition at line 1585 of file bufmgr.c.

{
    BufferDesc *buf_hdr;
    Buffer      buf;
    uint32      buf_state;
    bool        from_ring;
 
    /*
     * Ensure, while the spinlock's not yet held, that there's a free refcount
     * entry.
     */
    ReservePrivateRefCountEntry();
    ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
 
    /* we return here if a prospective victim buffer gets used concurrently */
again:
 
    /*
     * Select a victim buffer.  The buffer is returned with its header
     * spinlock still held!
     */
    buf_hdr = StrategyGetBuffer(strategy, &buf_state, &from_ring);
    buf = BufferDescriptorGetBuffer(buf_hdr);
 
    Assert(BUF_STATE_GET_REFCOUNT(buf_state) == 0);
 
    /* Pin the buffer and then release the buffer spinlock */
    PinBuffer_Locked(buf_hdr);
 
    /*
     * We shouldn't have any other pins for this buffer.
     */
    CheckBufferIsPinnedOnce(buf);
 
    /*
     * If the buffer was dirty, try to write it out.  There is a race
     * condition here, in that someone might dirty it after we released the
     * buffer header lock above, or even while we are writing it out (since
     * our share-lock won't prevent hint-bit updates).  We will recheck the
     * dirty bit after re-locking the buffer header.
     */
    if (buf_state & BM_DIRTY)
    {
        LWLock     *content_lock;
 
        Assert(buf_state & BM_TAG_VALID);
        Assert(buf_state & BM_VALID);
 
        /*
         * We need a share-lock on the buffer contents to write it out (else
         * we might write invalid data, eg because someone else is compacting
         * the page contents while we write).  We must use a conditional lock
         * acquisition here to avoid deadlock.  Even though the buffer was not
         * pinned (and therefore surely not locked) when StrategyGetBuffer
         * returned it, someone else could have pinned and exclusive-locked it
         * by the time we get here. If we try to get the lock unconditionally,
         * we'd block waiting for them; if they later block waiting for us,
         * deadlock ensues. (This has been observed to happen when two
         * backends are both trying to split btree index pages, and the second
         * one just happens to be trying to split the page the first one got
         * from StrategyGetBuffer.)
         */
        content_lock = BufferDescriptorGetContentLock(buf_hdr);
        if (!LWLockConditionalAcquire(content_lock, LW_SHARED))
        {
            /*
             * Someone else has locked the buffer, so give it up and loop back
             * to get another one.
             */
            UnpinBuffer(buf_hdr);
            goto again;
        }
 
        /*
         * If using a nondefault strategy, and writing the buffer would
         * require a WAL flush, let the strategy decide whether to go ahead
         * and write/reuse the buffer or to choose another victim.  We need a
         * lock to inspect the page LSN, so this can't be done inside
         * StrategyGetBuffer.
         */
        if (strategy != NULL)
        {
            XLogRecPtr  lsn;
 
            /* Read the LSN while holding buffer header lock */
            buf_state = LockBufHdr(buf_hdr);
            lsn = BufferGetLSN(buf_hdr);
            UnlockBufHdr(buf_hdr, buf_state);
 
            if (XLogNeedsFlush(lsn)
                && StrategyRejectBuffer(strategy, buf_hdr, from_ring))
            {
                LWLockRelease(content_lock);
                UnpinBuffer(buf_hdr);
                goto again;
            }
        }
 
        /* OK, do the I/O */
        FlushBuffer(buf_hdr, NULL, IOOBJECT_RELATION, io_context);
        LWLockRelease(content_lock);
 
        ScheduleBufferTagForWriteback(&BackendWritebackContext, io_context,
                                      &buf_hdr->tag);
    }
 
 
    if (buf_state & BM_VALID)
    {
        /*
         * When a BufferAccessStrategy is in use, blocks evicted from shared
         * buffers are counted as IOOP_EVICT in the corresponding context
         * (e.g. IOCONTEXT_BULKWRITE). Shared buffers are evicted by a
         * strategy in two cases: 1) while initially claiming buffers for the
         * strategy ring 2) to replace an existing strategy ring buffer
         * because it is pinned or in use and cannot be reused.
         *
         * Blocks evicted from buffers already in the strategy ring are
         * counted as IOOP_REUSE in the corresponding strategy context.
         *
         * At this point, we can accurately count evictions and reuses,
         * because we have successfully claimed the valid buffer. Previously,
         * we may have been forced to release the buffer due to concurrent
         * pinners or erroring out.
         */
        pgstat_count_io_op(IOOBJECT_RELATION, io_context,
                           from_ring ? IOOP_REUSE : IOOP_EVICT);
    }
 
    /*
     * If the buffer has an entry in the buffer mapping table, delete it. This
     * can fail because another backend could have pinned or dirtied the
     * buffer.
     */
    if ((buf_state & BM_TAG_VALID) && !InvalidateVictimBuffer(buf_hdr))
    {
        UnpinBuffer(buf_hdr);
        goto again;
    }
 
    /* a final set of sanity checks */
#ifdef USE_ASSERT_CHECKING
    buf_state = pg_atomic_read_u32(&buf_hdr->state);
 
    Assert(BUF_STATE_GET_REFCOUNT(buf_state) == 1);
    Assert(!(buf_state & (BM_TAG_VALID | BM_VALID | BM_DIRTY)));
 
    CheckBufferIsPinnedOnce(buf);
#endif
 
    return buf;
}

References Assert(), BackendWritebackContext, BM_DIRTY, BM_TAG_VALID, BM_VALID, buf, BUF_STATE_GET_REFCOUNT, BufferDescriptorGetBuffer(), BufferDescriptorGetContentLock(), BufferGetLSN, CheckBufferIsPinnedOnce(), CurrentResourceOwner, FlushBuffer(), InvalidateVictimBuffer(), IOOBJECT_RELATION, IOOP_EVICT, IOOP_REUSE, LockBufHdr(), LW_SHARED, LWLockConditionalAcquire(), LWLockRelease(), pg_atomic_read_u32(), pgstat_count_io_op(), PinBuffer_Locked(), ReservePrivateRefCountEntry(), ResourceOwnerEnlargeBuffers(), ScheduleBufferTagForWriteback(), BufferDesc::state, StrategyGetBuffer(), StrategyRejectBuffer(), BufferDesc::tag, UnlockBufHdr(), UnpinBuffer(), and XLogNeedsFlush().

Referenced by BufferAlloc(), and ExtendBufferedRelShared().

HoldingBufferPinThatDelaysRecovery()

bool HoldingBufferPinThatDelaysRecovery

(

void

)

Definition at line 4930 of file bufmgr.c.

{
    int         bufid = GetStartupBufferPinWaitBufId();
 
    /*
     * If we get woken slowly then it's possible that the Startup process was
     * already woken by other backends before we got here. Also possible that
     * we get here by multiple interrupts or interrupts at inappropriate
     * times, so make sure we do nothing if the bufid is not set.
     */
    if (bufid < 0)
        return false;
 
    if (GetPrivateRefCount(bufid + 1) > 0)
        return true;
 
    return false;
}

References GetPrivateRefCount(), and GetStartupBufferPinWaitBufId().

Referenced by CheckRecoveryConflictDeadlock(), and ProcessRecoveryConflictInterrupt().

IncrBufferRefCount()

void IncrBufferRefCount

(

Buffer

buffer

)

Definition at line 4512 of file bufmgr.c.

{
    Assert(BufferIsPinned(buffer));
    ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
    if (BufferIsLocal(buffer))
        LocalRefCount[-buffer - 1]++;
    else
    {
        PrivateRefCountEntry *ref;
 
        ref = GetPrivateRefCountEntry(buffer, true);
        Assert(ref != NULL);
        ref->refcount++;
    }
    ResourceOwnerRememberBuffer(CurrentResourceOwner, buffer);
}

References Assert(), PrivateRefCountEntry::buffer, BufferIsLocal, BufferIsPinned, CurrentResourceOwner, GetPrivateRefCountEntry(), LocalRefCount, PrivateRefCountEntry::refcount, ResourceOwnerEnlargeBuffers(), and ResourceOwnerRememberBuffer().

Referenced by _bt_steppage(), btrestrpos(), entryLoadMoreItems(), ReadBufferBI(), RelationAddBlocks(), scanPostingTree(), startScanEntry(), and tts_buffer_heap_store_tuple().

InitBufferPoolAccess()

void InitBufferPoolAccess

(

void

)

Definition at line 3149 of file bufmgr.c.

{
    HASHCTL     hash_ctl;
 
    memset(&PrivateRefCountArray, 0, sizeof(PrivateRefCountArray));
 
    hash_ctl.keysize = sizeof(int32);
    hash_ctl.entrysize = sizeof(PrivateRefCountEntry);
 
    PrivateRefCountHash = hash_create("PrivateRefCount", 100, &hash_ctl,
                                      HASH_ELEM | HASH_BLOBS);
 
    /*
     * AtProcExit_Buffers needs LWLock access, and thereby has to be called at
     * the corresponding phase of backend shutdown.
     */
    Assert(MyProc != NULL);
    on_shmem_exit(AtProcExit_Buffers, 0);
}

References Assert(), AtProcExit_Buffers(), HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, HASHCTL::keysize, MyProc, on_shmem_exit(), PrivateRefCountArray, and PrivateRefCountHash.

Referenced by BaseInit().

InvalidateBuffer()

static void InvalidateBuffer ( BufferDesc *  buf )

static

Definition at line 1419 of file bufmgr.c.

{
    BufferTag   oldTag;
    uint32      oldHash;        /* hash value for oldTag */
    LWLock     *oldPartitionLock;   /* buffer partition lock for it */
    uint32      oldFlags;
    uint32      buf_state;
 
    /* Save the original buffer tag before dropping the spinlock */
    oldTag = buf->tag;
 
    buf_state = pg_atomic_read_u32(&buf->state);
    Assert(buf_state & BM_LOCKED);
    UnlockBufHdr(buf, buf_state);
 
    /*
     * Need to compute the old tag's hashcode and partition lock ID. XXX is it
     * worth storing the hashcode in BufferDesc so we need not recompute it
     * here?  Probably not.
     */
    oldHash = BufTableHashCode(&oldTag);
    oldPartitionLock = BufMappingPartitionLock(oldHash);
 
retry:
 
    /*
     * Acquire exclusive mapping lock in preparation for changing the buffer's
     * association.
     */
    LWLockAcquire(oldPartitionLock, LW_EXCLUSIVE);
 
    /* Re-lock the buffer header */
    buf_state = LockBufHdr(buf);
 
    /* If it's changed while we were waiting for lock, do nothing */
    if (!BufferTagsEqual(&buf->tag, &oldTag))
    {
        UnlockBufHdr(buf, buf_state);
        LWLockRelease(oldPartitionLock);
        return;
    }
 
    /*
     * We assume the only reason for it to be pinned is that someone else is
     * flushing the page out.  Wait for them to finish.  (This could be an
     * infinite loop if the refcount is messed up... it would be nice to time
     * out after awhile, but there seems no way to be sure how many loops may
     * be needed.  Note that if the other guy has pinned the buffer but not
     * yet done StartBufferIO, WaitIO will fall through and we'll effectively
     * be busy-looping here.)
     */
    if (BUF_STATE_GET_REFCOUNT(buf_state) != 0)
    {
        UnlockBufHdr(buf, buf_state);
        LWLockRelease(oldPartitionLock);
        /* safety check: should definitely not be our *own* pin */
        if (GetPrivateRefCount(BufferDescriptorGetBuffer(buf)) > 0)
            elog(ERROR, "buffer is pinned in InvalidateBuffer");
        WaitIO(buf);
        goto retry;
    }
 
    /*
     * Clear out the buffer's tag and flags.  We must do this to ensure that
     * linear scans of the buffer array don't think the buffer is valid.
     */
    oldFlags = buf_state & BUF_FLAG_MASK;
    ClearBufferTag(&buf->tag);
    buf_state &= ~(BUF_FLAG_MASK | BUF_USAGECOUNT_MASK);
    UnlockBufHdr(buf, buf_state);
 
    /*
     * Remove the buffer from the lookup hashtable, if it was in there.
     */
    if (oldFlags & BM_TAG_VALID)
        BufTableDelete(&oldTag, oldHash);
 
    /*
     * Done with mapping lock.
     */
    LWLockRelease(oldPartitionLock);
 
    /*
     * Insert the buffer at the head of the list of free buffers.
     */
    StrategyFreeBuffer(buf);
}

References Assert(), BM_LOCKED, BM_TAG_VALID, buf, BUF_FLAG_MASK, BUF_STATE_GET_REFCOUNT, BUF_USAGECOUNT_MASK, BufferDescriptorGetBuffer(), BufferTagsEqual(), BufMappingPartitionLock(), BufTableDelete(), BufTableHashCode(), ClearBufferTag(), elog(), ERROR, GetPrivateRefCount(), LockBufHdr(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pg_atomic_read_u32(), StrategyFreeBuffer(), UnlockBufHdr(), and WaitIO().

Referenced by DropDatabaseBuffers(), DropRelationBuffers(), DropRelationsAllBuffers(), and FindAndDropRelationBuffers().

InvalidateVictimBuffer()

static bool InvalidateVictimBuffer ( BufferDesc *  buf_hdr )

static

Definition at line 1517 of file bufmgr.c.

{
    uint32      buf_state;
    uint32      hash;
    LWLock     *partition_lock;
    BufferTag   tag;
 
    Assert(GetPrivateRefCount(BufferDescriptorGetBuffer(buf_hdr)) == 1);
 
    /* have buffer pinned, so it's safe to read tag without lock */
    tag = buf_hdr->tag;
 
    hash = BufTableHashCode(&tag);
    partition_lock = BufMappingPartitionLock(hash);
 
    LWLockAcquire(partition_lock, LW_EXCLUSIVE);
 
    /* lock the buffer header */
    buf_state = LockBufHdr(buf_hdr);
 
    /*
     * We have the buffer pinned nobody else should have been able to unset
     * this concurrently.
     */
    Assert(buf_state & BM_TAG_VALID);
    Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
    Assert(BufferTagsEqual(&buf_hdr->tag, &tag));
 
    /*
     * If somebody else pinned the buffer since, or even worse, dirtied it,
     * give up on this buffer: It's clearly in use.
     */
    if (BUF_STATE_GET_REFCOUNT(buf_state) != 1 || (buf_state & BM_DIRTY))
    {
        Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
 
        UnlockBufHdr(buf_hdr, buf_state);
        LWLockRelease(partition_lock);
 
        return false;
    }
 
    /*
     * Clear out the buffer's tag and flags and usagecount.  This is not
     * strictly required, as BM_TAG_VALID/BM_VALID needs to be checked before
     * doing anything with the buffer. But currently it's beneficial, as the
     * cheaper pre-check for several linear scans of shared buffers use the
     * tag (see e.g. FlushDatabaseBuffers()).
     */
    ClearBufferTag(&buf_hdr->tag);
    buf_state &= ~(BUF_FLAG_MASK | BUF_USAGECOUNT_MASK);
    UnlockBufHdr(buf_hdr, buf_state);
 
    Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
 
    /* finally delete buffer from the buffer mapping table */
    BufTableDelete(&tag, hash);
 
    LWLockRelease(partition_lock);
 
    Assert(!(buf_state & (BM_DIRTY | BM_VALID | BM_TAG_VALID)));
    Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
    Assert(BUF_STATE_GET_REFCOUNT(pg_atomic_read_u32(&buf_hdr->state)) > 0);
 
    return true;
}

References Assert(), BM_DIRTY, BM_TAG_VALID, BM_VALID, BUF_FLAG_MASK, BUF_STATE_GET_REFCOUNT, BUF_USAGECOUNT_MASK, BufferDescriptorGetBuffer(), BufferTagsEqual(), BufMappingPartitionLock(), BufTableDelete(), BufTableHashCode(), ClearBufferTag(), GetPrivateRefCount(), hash(), LockBufHdr(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pg_atomic_read_u32(), BufferDesc::state, BufferDesc::tag, and UnlockBufHdr().

Referenced by GetVictimBuffer().

IsBufferCleanupOK()

bool IsBufferCleanupOK

(

Buffer

buffer

)

Definition at line 5012 of file bufmgr.c.

{
    BufferDesc *bufHdr;
    uint32      buf_state;
 
    Assert(BufferIsValid(buffer));
 
    if (BufferIsLocal(buffer))
    {
        /* There should be exactly one pin */
        if (LocalRefCount[-buffer - 1] != 1)
            return false;
        /* Nobody else to wait for */
        return true;
    }
 
    /* There should be exactly one local pin */
    if (GetPrivateRefCount(buffer) != 1)
        return false;
 
    bufHdr = GetBufferDescriptor(buffer - 1);
 
    /* caller must hold exclusive lock on buffer */
    Assert(LWLockHeldByMeInMode(BufferDescriptorGetContentLock(bufHdr),
                                LW_EXCLUSIVE));
 
    buf_state = LockBufHdr(bufHdr);
 
    Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
    if (BUF_STATE_GET_REFCOUNT(buf_state) == 1)
    {
        /* pincount is OK. */
        UnlockBufHdr(bufHdr, buf_state);
        return true;
    }
 
    UnlockBufHdr(bufHdr, buf_state);
    return false;
}

References Assert(), BUF_STATE_GET_REFCOUNT, PrivateRefCountEntry::buffer, BufferDescriptorGetContentLock(), BufferIsLocal, BufferIsValid(), GetBufferDescriptor(), GetPrivateRefCount(), LocalRefCount, LockBufHdr(), LW_EXCLUSIVE, LWLockHeldByMeInMode(), and UnlockBufHdr().

Referenced by _hash_doinsert(), _hash_expandtable(), _hash_splitbucket(), and hashbucketcleanup().

IssuePendingWritebacks()

void IssuePendingWritebacks	(	WritebackContext *	wb_context,
		IOContext	io_context
	)

Definition at line 5499 of file bufmgr.c.

{
    instr_time  io_start;
    int         i;
 
    if (wb_context->nr_pending == 0)
        return;
 
    /*
     * Executing the writes in-order can make them a lot faster, and allows to
     * merge writeback requests to consecutive blocks into larger writebacks.
     */
    sort_pending_writebacks(wb_context->pending_writebacks,
                            wb_context->nr_pending);
 
    io_start = pgstat_prepare_io_time();
 
    /*
     * Coalesce neighbouring writes, but nothing else. For that we iterate
     * through the, now sorted, array of pending flushes, and look forward to
     * find all neighbouring (or identical) writes.
     */
    for (i = 0; i < wb_context->nr_pending; i++)
    {
        PendingWriteback *cur;
        PendingWriteback *next;
        SMgrRelation reln;
        int         ahead;
        BufferTag   tag;
        RelFileLocator currlocator;
        Size        nblocks = 1;
 
        cur = &wb_context->pending_writebacks[i];
        tag = cur->tag;
        currlocator = BufTagGetRelFileLocator(&tag);
 
        /*
         * Peek ahead, into following writeback requests, to see if they can
         * be combined with the current one.
         */
        for (ahead = 0; i + ahead + 1 < wb_context->nr_pending; ahead++)
        {
 
            next = &wb_context->pending_writebacks[i + ahead + 1];
 
            /* different file, stop */
            if (!RelFileLocatorEquals(currlocator,
                                      BufTagGetRelFileLocator(&next->tag)) ||
                BufTagGetForkNum(&cur->tag) != BufTagGetForkNum(&next->tag))
                break;
 
            /* ok, block queued twice, skip */
            if (cur->tag.blockNum == next->tag.blockNum)
                continue;
 
            /* only merge consecutive writes */
            if (cur->tag.blockNum + 1 != next->tag.blockNum)
                break;
 
            nblocks++;
            cur = next;
        }
 
        i += ahead;
 
        /* and finally tell the kernel to write the data to storage */
        reln = smgropen(currlocator, InvalidBackendId);
        smgrwriteback(reln, BufTagGetForkNum(&tag), tag.blockNum, nblocks);
    }
 
    /*
     * Assume that writeback requests are only issued for buffers containing
     * blocks of permanent relations.
     */
    pgstat_count_io_op_time(IOOBJECT_RELATION, io_context,
                            IOOP_WRITEBACK, io_start, wb_context->nr_pending);
 
    wb_context->nr_pending = 0;
}

References buftag::blockNum, BufTagGetForkNum(), BufTagGetRelFileLocator(), cur, i, InvalidBackendId, IOOBJECT_RELATION, IOOP_WRITEBACK, next, WritebackContext::nr_pending, WritebackContext::pending_writebacks, pgstat_count_io_op_time(), pgstat_prepare_io_time(), RelFileLocatorEquals, smgropen(), and smgrwriteback().

Referenced by BufferSync(), and ScheduleBufferTagForWriteback().

LimitAdditionalPins()

static void LimitAdditionalPins ( uint32 *  additional_pins )

static

Definition at line 1751 of file bufmgr.c.

{
    uint32      max_backends;
    int         max_proportional_pins;
 
    if (*additional_pins <= 1)
        return;
 
    max_backends = MaxBackends + NUM_AUXILIARY_PROCS;
    max_proportional_pins = NBuffers / max_backends;
 
    /*
     * Subtract the approximate number of buffers already pinned by this
     * backend. We get the number of "overflowed" pins for free, but don't
     * know the number of pins in PrivateRefCountArray. The cost of
     * calculating that exactly doesn't seem worth it, so just assume the max.
     */
    max_proportional_pins -= PrivateRefCountOverflowed + REFCOUNT_ARRAY_ENTRIES;
 
    if (max_proportional_pins <= 0)
        max_proportional_pins = 1;
 
    if (*additional_pins > max_proportional_pins)
        *additional_pins = max_proportional_pins;
}

References MaxBackends, NBuffers, NUM_AUXILIARY_PROCS, PrivateRefCountOverflowed, and REFCOUNT_ARRAY_ENTRIES.

Referenced by ExtendBufferedRelShared().

local_buffer_write_error_callback()

static void local_buffer_write_error_callback ( void *  arg )

static

Definition at line 5253 of file bufmgr.c.

{
    BufferDesc *bufHdr = (BufferDesc *) arg;
 
    if (bufHdr != NULL)
    {
        char       *path = relpathbackend(BufTagGetRelFileLocator(&bufHdr->tag),
                                          MyBackendId,
                                          BufTagGetForkNum(&bufHdr->tag));
 
        errcontext("writing block %u of relation %s",
                   bufHdr->tag.blockNum, path);
        pfree(path);
    }
}

References arg, buftag::blockNum, BufTagGetForkNum(), BufTagGetRelFileLocator(), errcontext, MyBackendId, pfree(), relpathbackend, and BufferDesc::tag.

Referenced by FlushRelationBuffers().

LockBuffer()

void LockBuffer	(	Buffer	buffer,
		int	mode
	)

Definition at line 4715 of file bufmgr.c.

{
    BufferDesc *buf;
 
    Assert(BufferIsPinned(buffer));
    if (BufferIsLocal(buffer))
        return;                 /* local buffers need no lock */
 
    buf = GetBufferDescriptor(buffer - 1);
 
    if (mode == BUFFER_LOCK_UNLOCK)
        LWLockRelease(BufferDescriptorGetContentLock(buf));
    else if (mode == BUFFER_LOCK_SHARE)
        LWLockAcquire(BufferDescriptorGetContentLock(buf), LW_SHARED);
    else if (mode == BUFFER_LOCK_EXCLUSIVE)
        LWLockAcquire(BufferDescriptorGetContentLock(buf), LW_EXCLUSIVE);
    else
        elog(ERROR, "unrecognized buffer lock mode: %d", mode);
}

References Assert(), buf, PrivateRefCountEntry::buffer, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferDescriptorGetContentLock(), BufferIsLocal, BufferIsPinned, elog(), ERROR, GetBufferDescriptor(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), and mode.

Referenced by _bt_lockbuf(), _bt_unlockbuf(), _bt_upgradelockbufcleanup(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_finish_split(), _hash_first(), _hash_freeovflpage(), _hash_getbuf(), _hash_getbuf_with_strategy(), _hash_getcachedmetap(), _hash_init(), _hash_kill_items(), _hash_readnext(), _hash_readpage(), _hash_readprev(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), blbulkdelete(), blgetbitmap(), blinsert(), BloomInitMetapage(), BloomNewBuffer(), blvacuumcleanup(), brin_doinsert(), brin_doupdate(), brin_evacuate_page(), brin_getinsertbuffer(), brin_page_cleanup(), bringetbitmap(), brinGetStats(), brinGetTupleForHeapBlock(), brininsert(), brinLockRevmapPageForUpdate(), brinRevmapDesummarizeRange(), brinRevmapInitialize(), brinsummarize(), bt_metap(), bt_multi_page_stats(), bt_page_items_internal(), bt_page_stats_internal(), bt_recheck_sibling_links(), collect_corrupt_items(), collect_visibility_data(), collectMatchBitmap(), ConditionalLockBufferForCleanup(), count_nondeletable_pages(), entryLoadMoreItems(), FreeSpaceMapPrepareTruncateRel(), fsm_readbuf(), fsm_search(), fsm_search_avail(), fsm_set_and_search(), fsm_vacuum_page(), get_raw_page_internal(), GetVisibilityMapPins(), ginbulkdelete(), ginEntryInsert(), ginFindLeafPage(), ginFindParents(), ginFinishSplit(), ginGetStats(), ginHeapTupleFastInsert(), ginInsertCleanup(), ginInsertValue(), GinNewBuffer(), ginScanToDelete(), ginStepRight(), ginTraverseLock(), ginUpdateStats(), ginvacuumcleanup(), ginVacuumPostingTreeLeaves(), gistBufferingFindCorrectParent(), gistbufferinginserttuples(), gistdoinsert(), gistFindCorrectParent(), gistFindPath(), gistfinishsplit(), gistfixsplit(), gistformdownlink(), gistGetMaxLevel(), gistinserttuples(), gistkillitems(), gistNewBuffer(), gistProcessItup(), gistScanPage(), gistvacuum_delete_empty_pages(), gistvacuumpage(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_fetch(), heap_finish_speculative(), heap_get_latest_tid(), heap_index_delete_tuples(), heap_inplace_update(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_page_prune_opt(), heap_update(), heap_xlog_visible(), heapam_index_build_range_scan(), heapam_index_fetch_tuple(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), heapam_scan_analyze_next_block(), heapam_scan_bitmap_next_block(), heapam_scan_sample_next_tuple(), heapam_tuple_satisfies_snapshot(), heapgetpage(), heapgettup(), initBloomState(), lazy_scan_heap(), lazy_scan_new_or_empty(), lazy_vacuum_heap_rel(), LockBufferForCleanup(), log_newpage_range(), palloc_btree_page(), pg_visibility(), pgrowlocks(), pgstat_btree_page(), pgstat_gist_page(), pgstat_heap(), pgstatginindex_internal(), pgstathashindex(), pgstatindex_impl(), read_seq_tuple(), RelationAddBlocks(), RelationCopyStorageUsingBuffer(), RelationGetBufferForTuple(), revmap_physical_extend(), scanGetCandidate(), scanPendingInsert(), ScanSourceDatabasePgClass(), shiftList(), spgbuildempty(), spgdoinsert(), spgGetCache(), SpGistNewBuffer(), spgprocesspending(), spgvacuumpage(), spgWalk(), startScanEntry(), statapprox_heap(), summarize_range(), UnlockReleaseBuffer(), verify_heapam(), verifyBackupPageConsistency(), visibilitymap_clear(), visibilitymap_prepare_truncate(), visibilitymap_set(), vm_readbuf(), XLogReadBufferForRedoExtended(), and XLogRecordPageWithFreeSpace().

LockBufferForCleanup()

void LockBufferForCleanup

(

Buffer

buffer

)

Definition at line 4795 of file bufmgr.c.

{
    BufferDesc *bufHdr;
    TimestampTz waitStart = 0;
    bool        waiting = false;
    bool        logged_recovery_conflict = false;
 
    Assert(BufferIsPinned(buffer));
    Assert(PinCountWaitBuf == NULL);
 
    CheckBufferIsPinnedOnce(buffer);
 
    /* Nobody else to wait for */
    if (BufferIsLocal(buffer))
        return;
 
    bufHdr = GetBufferDescriptor(buffer - 1);
 
    for (;;)
    {
        uint32      buf_state;
 
        /* Try to acquire lock */
        LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
        buf_state = LockBufHdr(bufHdr);
 
        Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
        if (BUF_STATE_GET_REFCOUNT(buf_state) == 1)
        {
            /* Successfully acquired exclusive lock with pincount 1 */
            UnlockBufHdr(bufHdr, buf_state);
 
            /*
             * Emit the log message if recovery conflict on buffer pin was
             * resolved but the startup process waited longer than
             * deadlock_timeout for it.
             */
            if (logged_recovery_conflict)
                LogRecoveryConflict(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN,
                                    waitStart, GetCurrentTimestamp(),
                                    NULL, false);
 
            if (waiting)
            {
                /* reset ps display to remove the suffix if we added one */
                set_ps_display_remove_suffix();
                waiting = false;
            }
            return;
        }
        /* Failed, so mark myself as waiting for pincount 1 */
        if (buf_state & BM_PIN_COUNT_WAITER)
        {
            UnlockBufHdr(bufHdr, buf_state);
            LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
            elog(ERROR, "multiple backends attempting to wait for pincount 1");
        }
        bufHdr->wait_backend_pgprocno = MyProc->pgprocno;
        PinCountWaitBuf = bufHdr;
        buf_state |= BM_PIN_COUNT_WAITER;
        UnlockBufHdr(bufHdr, buf_state);
        LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
        /* Wait to be signaled by UnpinBuffer() */
        if (InHotStandby)
        {
            if (!waiting)
            {
                /* adjust the process title to indicate that it's waiting */
                set_ps_display_suffix("waiting");
                waiting = true;
            }
 
            /*
             * Emit the log message if the startup process is waiting longer
             * than deadlock_timeout for recovery conflict on buffer pin.
             *
             * Skip this if first time through because the startup process has
             * not started waiting yet in this case. So, the wait start
             * timestamp is set after this logic.
             */
            if (waitStart != 0 && !logged_recovery_conflict)
            {
                TimestampTz now = GetCurrentTimestamp();
 
                if (TimestampDifferenceExceeds(waitStart, now,
                                               DeadlockTimeout))
                {
                    LogRecoveryConflict(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN,
                                        waitStart, now, NULL, true);
                    logged_recovery_conflict = true;
                }
            }
 
            /*
             * Set the wait start timestamp if logging is enabled and first
             * time through.
             */
            if (log_recovery_conflict_waits && waitStart == 0)
                waitStart = GetCurrentTimestamp();
 
            /* Publish the bufid that Startup process waits on */
            SetStartupBufferPinWaitBufId(buffer - 1);
            /* Set alarm and then wait to be signaled by UnpinBuffer() */
            ResolveRecoveryConflictWithBufferPin();
            /* Reset the published bufid */
            SetStartupBufferPinWaitBufId(-1);
        }
        else
            ProcWaitForSignal(WAIT_EVENT_BUFFER_PIN);
 
        /*
         * Remove flag marking us as waiter. Normally this will not be set
         * anymore, but ProcWaitForSignal() can return for other signals as
         * well.  We take care to only reset the flag if we're the waiter, as
         * theoretically another backend could have started waiting. That's
         * impossible with the current usages due to table level locking, but
         * better be safe.
         */
        buf_state = LockBufHdr(bufHdr);
        if ((buf_state & BM_PIN_COUNT_WAITER) != 0 &&
            bufHdr->wait_backend_pgprocno == MyProc->pgprocno)
            buf_state &= ~BM_PIN_COUNT_WAITER;
        UnlockBufHdr(bufHdr, buf_state);
 
        PinCountWaitBuf = NULL;
        /* Loop back and try again */
    }
}

References Assert(), BM_PIN_COUNT_WAITER, BUF_STATE_GET_REFCOUNT, PrivateRefCountEntry::buffer, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferIsLocal, BufferIsPinned, CheckBufferIsPinnedOnce(), DeadlockTimeout, elog(), ERROR, GetBufferDescriptor(), GetCurrentTimestamp(), InHotStandby, LockBuffer(), LockBufHdr(), log_recovery_conflict_waits, LogRecoveryConflict(), MyProc, now(), PGPROC::pgprocno, PinCountWaitBuf, PROCSIG_RECOVERY_CONFLICT_BUFFERPIN, ProcWaitForSignal(), ResolveRecoveryConflictWithBufferPin(), set_ps_display_remove_suffix(), set_ps_display_suffix(), SetStartupBufferPinWaitBufId(), TimestampDifferenceExceeds(), UnlockBufHdr(), BufferDesc::wait_backend_pgprocno, and waiting.

Referenced by _bt_upgradelockbufcleanup(), ginVacuumPostingTree(), hashbulkdelete(), heap_force_common(), lazy_scan_heap(), ReadBuffer_common(), and XLogReadBufferForRedoExtended().

LockBufHdr()

uint32 LockBufHdr

(

BufferDesc *

desc

)

Definition at line 5300 of file bufmgr.c.

{
    SpinDelayStatus delayStatus;
    uint32      old_buf_state;
 
    Assert(!BufferIsLocal(BufferDescriptorGetBuffer(desc)));
 
    init_local_spin_delay(&delayStatus);
 
    while (true)
    {
        /* set BM_LOCKED flag */
        old_buf_state = pg_atomic_fetch_or_u32(&desc->state, BM_LOCKED);
        /* if it wasn't set before we're OK */
        if (!(old_buf_state & BM_LOCKED))
            break;
        perform_spin_delay(&delayStatus);
    }
    finish_spin_delay(&delayStatus);
    return old_buf_state | BM_LOCKED;
}

References Assert(), BM_LOCKED, BufferDescriptorGetBuffer(), BufferIsLocal, finish_spin_delay(), init_local_spin_delay, perform_spin_delay(), pg_atomic_fetch_or_u32(), and BufferDesc::state.

Referenced by AbortBufferIO(), apw_dump_now(), BufferAlloc(), BufferGetLSNAtomic(), BufferSync(), ConditionalLockBufferForCleanup(), DropDatabaseBuffers(), DropRelationBuffers(), DropRelationsAllBuffers(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), FlushBuffer(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetBufferFromRing(), GetVictimBuffer(), InvalidateBuffer(), InvalidateVictimBuffer(), IsBufferCleanupOK(), LockBufferForCleanup(), MarkBufferDirtyHint(), pg_buffercache_pages(), ReadRecentBuffer(), StartBufferIO(), StrategyGetBuffer(), SyncOneBuffer(), TerminateBufferIO(), UnlockBuffers(), UnpinBuffer(), and WaitIO().

MarkBufferDirty()

void MarkBufferDirty

(

Buffer

buffer

)

Definition at line 2111 of file bufmgr.c.

{
    BufferDesc *bufHdr;
    uint32      buf_state;
    uint32      old_buf_state;
 
    if (!BufferIsValid(buffer))
        elog(ERROR, "bad buffer ID: %d", buffer);
 
    if (BufferIsLocal(buffer))
    {
        MarkLocalBufferDirty(buffer);
        return;
    }
 
    bufHdr = GetBufferDescriptor(buffer - 1);
 
    Assert(BufferIsPinned(buffer));
    Assert(LWLockHeldByMeInMode(BufferDescriptorGetContentLock(bufHdr),
                                LW_EXCLUSIVE));
 
    old_buf_state = pg_atomic_read_u32(&bufHdr->state);
    for (;;)
    {
        if (old_buf_state & BM_LOCKED)
            old_buf_state = WaitBufHdrUnlocked(bufHdr);
 
        buf_state = old_buf_state;
 
        Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
        buf_state |= BM_DIRTY | BM_JUST_DIRTIED;
 
        if (pg_atomic_compare_exchange_u32(&bufHdr->state, &old_buf_state,
                                           buf_state))
            break;
    }
 
    /*
     * If the buffer was not dirty already, do vacuum accounting.
     */
    if (!(old_buf_state & BM_DIRTY))
    {
        VacuumPageDirty++;
        pgBufferUsage.shared_blks_dirtied++;
        if (VacuumCostActive)
            VacuumCostBalance += VacuumCostPageDirty;
    }
}

References Assert(), BM_DIRTY, BM_JUST_DIRTIED, BM_LOCKED, BUF_STATE_GET_REFCOUNT, PrivateRefCountEntry::buffer, BufferDescriptorGetContentLock(), BufferIsLocal, BufferIsPinned, BufferIsValid(), elog(), ERROR, GetBufferDescriptor(), LW_EXCLUSIVE, LWLockHeldByMeInMode(), MarkLocalBufferDirty(), pg_atomic_compare_exchange_u32(), pg_atomic_read_u32(), pgBufferUsage, BufferUsage::shared_blks_dirtied, BufferDesc::state, VacuumCostActive, VacuumCostBalance, VacuumCostPageDirty, VacuumPageDirty, and WaitBufHdrUnlocked().

Referenced by _bt_clear_incomplete_split(), _bt_dedup_pass(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_newlevel(), _bt_restore_meta(), _bt_set_cleanup_info(), _bt_split(), _bt_unlink_halfdead_page(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_freeovflpage(), _hash_init(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addLeafTuple(), brin_doinsert(), brin_doupdate(), brin_initialize_empty_new_buffer(), brin_xlog_createidx(), brin_xlog_desummarize_page(), brin_xlog_insert_update(), brin_xlog_revmap_extend(), brin_xlog_samepage_update(), brin_xlog_update(), brinbuild(), brinbuildempty(), brinRevmapDesummarizeRange(), btbuildempty(), btree_xlog_dedup(), btree_xlog_delete(), btree_xlog_insert(), btree_xlog_mark_page_halfdead(), btree_xlog_newroot(), btree_xlog_split(), btree_xlog_unlink_page(), btree_xlog_vacuum(), createPostingTree(), do_setval(), doPickSplit(), fill_seq_fork_with_data(), FreeSpaceMapPrepareTruncateRel(), generic_redo(), GenericXLogFinish(), ginbuild(), ginbuildempty(), ginbulkdelete(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginRedoClearIncompleteSplit(), ginRedoCreatePTree(), ginRedoDeleteListPages(), ginRedoDeletePage(), ginRedoInsert(), ginRedoInsertListPage(), ginRedoUpdateMetapage(), ginRedoVacuumDataLeafPage(), ginUpdateStats(), ginVacuumPostingTreeLeaf(), gistbuild(), gistbuildempty(), gistdeletepage(), gistplacetopage(), gistprunepage(), gistRedoClearFollowRight(), gistRedoDeleteRecord(), gistRedoPageDelete(), gistRedoPageSplitRecord(), gistRedoPageUpdateRecord(), gistvacuumpage(), hash_xlog_add_ovfl_page(), hash_xlog_delete(), hash_xlog_init_bitmap_page(), hash_xlog_init_meta_page(), hash_xlog_insert(), hash_xlog_move_page_contents(), hash_xlog_split_allocate_page(), hash_xlog_split_cleanup(), hash_xlog_split_complete(), hash_xlog_squeeze_page(), hash_xlog_update_meta_page(), hash_xlog_vacuum_one_page(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_finish_speculative(), heap_force_common(), heap_freeze_execute_prepared(), heap_inplace_update(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_page_prune(), heap_update(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_freeze_page(), heap_xlog_inplace(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_prune(), heap_xlog_update(), heap_xlog_vacuum(), heap_xlog_visible(), lazy_scan_heap(), lazy_scan_new_or_empty(), lazy_vacuum_heap_page(), log_newpage_range(), moveLeafs(), nextval_internal(), RelationAddBlocks(), RelationCopyStorageUsingBuffer(), RelationGetBufferForTuple(), revmap_physical_extend(), saveNodeLink(), seq_redo(), shiftList(), spgAddNodeAction(), spgbuild(), spgbuildempty(), SpGistUpdateMetaPage(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoSplitTuple(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgRedoVacuumRoot(), spgSplitNodeAction(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), visibilitymap_clear(), visibilitymap_prepare_truncate(), visibilitymap_set(), writeListPage(), and XLogReadBufferForRedoExtended().

MarkBufferDirtyHint()

void MarkBufferDirtyHint	(	Buffer	buffer,
		bool	buffer_std
	)

Definition at line 4544 of file bufmgr.c.

{
    BufferDesc *bufHdr;
    Page        page = BufferGetPage(buffer);
 
    if (!BufferIsValid(buffer))
        elog(ERROR, "bad buffer ID: %d", buffer);
 
    if (BufferIsLocal(buffer))
    {
        MarkLocalBufferDirty(buffer);
        return;
    }
 
    bufHdr = GetBufferDescriptor(buffer - 1);
 
    Assert(GetPrivateRefCount(buffer) > 0);
    /* here, either share or exclusive lock is OK */
    Assert(LWLockHeldByMe(BufferDescriptorGetContentLock(bufHdr)));
 
    /*
     * This routine might get called many times on the same page, if we are
     * making the first scan after commit of an xact that added/deleted many
     * tuples. So, be as quick as we can if the buffer is already dirty.  We
     * do this by not acquiring spinlock if it looks like the status bits are
     * already set.  Since we make this test unlocked, there's a chance we
     * might fail to notice that the flags have just been cleared, and failed
     * to reset them, due to memory-ordering issues.  But since this function
     * is only intended to be used in cases where failing to write out the
     * data would be harmless anyway, it doesn't really matter.
     */
    if ((pg_atomic_read_u32(&bufHdr->state) & (BM_DIRTY | BM_JUST_DIRTIED)) !=
        (BM_DIRTY | BM_JUST_DIRTIED))
    {
        XLogRecPtr  lsn = InvalidXLogRecPtr;
        bool        dirtied = false;
        bool        delayChkptFlags = false;
        uint32      buf_state;
 
        /*
         * If we need to protect hint bit updates from torn writes, WAL-log a
         * full page image of the page. This full page image is only necessary
         * if the hint bit update is the first change to the page since the
         * last checkpoint.
         *
         * We don't check full_page_writes here because that logic is included
         * when we call XLogInsert() since the value changes dynamically.
         */
        if (XLogHintBitIsNeeded() &&
            (pg_atomic_read_u32(&bufHdr->state) & BM_PERMANENT))
        {
            /*
             * If we must not write WAL, due to a relfilelocator-specific
             * condition or being in recovery, don't dirty the page.  We can
             * set the hint, just not dirty the page as a result so the hint
             * is lost when we evict the page or shutdown.
             *
             * See src/backend/storage/page/README for longer discussion.
             */
            if (RecoveryInProgress() ||
                RelFileLocatorSkippingWAL(BufTagGetRelFileLocator(&bufHdr->tag)))
                return;
 
            /*
             * If the block is already dirty because we either made a change
             * or set a hint already, then we don't need to write a full page
             * image.  Note that aggressive cleaning of blocks dirtied by hint
             * bit setting would increase the call rate. Bulk setting of hint
             * bits would reduce the call rate...
             *
             * We must issue the WAL record before we mark the buffer dirty.
             * Otherwise we might write the page before we write the WAL. That
             * causes a race condition, since a checkpoint might occur between
             * writing the WAL record and marking the buffer dirty. We solve
             * that with a kluge, but one that is already in use during
             * transaction commit to prevent race conditions. Basically, we
             * simply prevent the checkpoint WAL record from being written
             * until we have marked the buffer dirty. We don't start the
             * checkpoint flush until we have marked dirty, so our checkpoint
             * must flush the change to disk successfully or the checkpoint
             * never gets written, so crash recovery will fix.
             *
             * It's possible we may enter here without an xid, so it is
             * essential that CreateCheckPoint waits for virtual transactions
             * rather than full transactionids.
             */
            Assert((MyProc->delayChkptFlags & DELAY_CHKPT_START) == 0);
            MyProc->delayChkptFlags |= DELAY_CHKPT_START;
            delayChkptFlags = true;
            lsn = XLogSaveBufferForHint(buffer, buffer_std);
        }
 
        buf_state = LockBufHdr(bufHdr);
 
        Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
 
        if (!(buf_state & BM_DIRTY))
        {
            dirtied = true;     /* Means "will be dirtied by this action" */
 
            /*
             * Set the page LSN if we wrote a backup block. We aren't supposed
             * to set this when only holding a share lock but as long as we
             * serialise it somehow we're OK. We choose to set LSN while
             * holding the buffer header lock, which causes any reader of an
             * LSN who holds only a share lock to also obtain a buffer header
             * lock before using PageGetLSN(), which is enforced in
             * BufferGetLSNAtomic().
             *
             * If checksums are enabled, you might think we should reset the
             * checksum here. That will happen when the page is written
             * sometime later in this checkpoint cycle.
             */
            if (!XLogRecPtrIsInvalid(lsn))
                PageSetLSN(page, lsn);
        }
 
        buf_state |= BM_DIRTY | BM_JUST_DIRTIED;
        UnlockBufHdr(bufHdr, buf_state);
 
        if (delayChkptFlags)
            MyProc->delayChkptFlags &= ~DELAY_CHKPT_START;
 
        if (dirtied)
        {
            VacuumPageDirty++;
            pgBufferUsage.shared_blks_dirtied++;
            if (VacuumCostActive)
                VacuumCostBalance += VacuumCostPageDirty;
        }
    }
}

References Assert(), BM_DIRTY, BM_JUST_DIRTIED, BM_PERMANENT, BUF_STATE_GET_REFCOUNT, PrivateRefCountEntry::buffer, BufferDescriptorGetContentLock(), BufferGetPage(), BufferIsLocal, BufferIsValid(), BufTagGetRelFileLocator(), DELAY_CHKPT_START, PGPROC::delayChkptFlags, elog(), ERROR, GetBufferDescriptor(), GetPrivateRefCount(), InvalidXLogRecPtr, LockBufHdr(), LWLockHeldByMe(), MarkLocalBufferDirty(), MyProc, PageSetLSN(), pg_atomic_read_u32(), pgBufferUsage, RecoveryInProgress(), RelFileLocatorSkippingWAL(), BufferUsage::shared_blks_dirtied, BufferDesc::state, BufferDesc::tag, UnlockBufHdr(), VacuumCostActive, VacuumCostBalance, VacuumCostPageDirty, VacuumPageDirty, XLogHintBitIsNeeded, XLogRecPtrIsInvalid, and XLogSaveBufferForHint().

Referenced by _bt_check_unique(), _bt_killitems(), _hash_kill_items(), brin_start_evacuating_page(), btvacuumpage(), fsm_search_avail(), fsm_set_and_search(), fsm_vacuum_page(), gistkillitems(), heap_page_prune(), read_seq_tuple(), SetHintBits(), and XLogRecordPageWithFreeSpace().

NewPrivateRefCountEntry()

static PrivateRefCountEntry * NewPrivateRefCountEntry ( Buffer  buffer )

static

Definition at line 280 of file bufmgr.c.

{
    PrivateRefCountEntry *res;
 
    /* only allowed to be called when a reservation has been made */
    Assert(ReservedRefCountEntry != NULL);
 
    /* use up the reserved entry */
    res = ReservedRefCountEntry;
    ReservedRefCountEntry = NULL;
 
    /* and fill it */
    res->buffer = buffer;
    res->refcount = 0;
 
    return res;
}

References Assert(), PrivateRefCountEntry::buffer, res, and ReservedRefCountEntry.

Referenced by PinBuffer(), and PinBuffer_Locked().

PinBuffer()

static bool PinBuffer ( BufferDesc *  buf, BufferAccessStrategy  strategy  )

static

Definition at line 2231 of file bufmgr.c.

{
    Buffer      b = BufferDescriptorGetBuffer(buf);
    bool        result;
    PrivateRefCountEntry *ref;
 
    Assert(!BufferIsLocal(b));
 
    ref = GetPrivateRefCountEntry(b, true);
 
    if (ref == NULL)
    {
        uint32      buf_state;
        uint32      old_buf_state;
 
        ReservePrivateRefCountEntry();
        ref = NewPrivateRefCountEntry(b);
 
        old_buf_state = pg_atomic_read_u32(&buf->state);
        for (;;)
        {
            if (old_buf_state & BM_LOCKED)
                old_buf_state = WaitBufHdrUnlocked(buf);
 
            buf_state = old_buf_state;
 
            /* increase refcount */
            buf_state += BUF_REFCOUNT_ONE;
 
            if (strategy == NULL)
            {
                /* Default case: increase usagecount unless already max. */
                if (BUF_STATE_GET_USAGECOUNT(buf_state) < BM_MAX_USAGE_COUNT)
                    buf_state += BUF_USAGECOUNT_ONE;
            }
            else
            {
                /*
                 * Ring buffers shouldn't evict others from pool.  Thus we
                 * don't make usagecount more than 1.
                 */
                if (BUF_STATE_GET_USAGECOUNT(buf_state) == 0)
                    buf_state += BUF_USAGECOUNT_ONE;
            }
 
            if (pg_atomic_compare_exchange_u32(&buf->state, &old_buf_state,
                                               buf_state))
            {
                result = (buf_state & BM_VALID) != 0;
 
                /*
                 * Assume that we acquired a buffer pin for the purposes of
                 * Valgrind buffer client checks (even in !result case) to
                 * keep things simple.  Buffers that are unsafe to access are
                 * not generally guaranteed to be marked undefined or
                 * non-accessible in any case.
                 */
                VALGRIND_MAKE_MEM_DEFINED(BufHdrGetBlock(buf), BLCKSZ);
                break;
            }
        }
    }
    else
    {
        /*
         * If we previously pinned the buffer, it must surely be valid.
         *
         * Note: We deliberately avoid a Valgrind client request here.
         * Individual access methods can optionally superimpose buffer page
         * client requests on top of our client requests to enforce that
         * buffers are only accessed while locked (and pinned).  It's possible
         * that the buffer page is legitimately non-accessible here.  We
         * cannot meddle with that.
         */
        result = true;
    }
 
    ref->refcount++;
    Assert(ref->refcount > 0);
    ResourceOwnerRememberBuffer(CurrentResourceOwner, b);
    return result;
}

References Assert(), b, BM_LOCKED, BM_MAX_USAGE_COUNT, BM_VALID, buf, BUF_REFCOUNT_ONE, BUF_STATE_GET_USAGECOUNT, BUF_USAGECOUNT_ONE, BufferDescriptorGetBuffer(), BufferIsLocal, BufHdrGetBlock, CurrentResourceOwner, GetPrivateRefCountEntry(), NewPrivateRefCountEntry(), pg_atomic_compare_exchange_u32(), pg_atomic_read_u32(), PrivateRefCountEntry::refcount, ReservePrivateRefCountEntry(), ResourceOwnerRememberBuffer(), VALGRIND_MAKE_MEM_DEFINED, and WaitBufHdrUnlocked().

Referenced by BufferAlloc(), ExtendBufferedRelShared(), and ReadRecentBuffer().

PinBuffer_Locked()

static void PinBuffer_Locked ( BufferDesc *  buf )

static

Definition at line 2336 of file bufmgr.c.

{
    Buffer      b;
    PrivateRefCountEntry *ref;
    uint32      buf_state;
 
    /*
     * As explained, We don't expect any preexisting pins. That allows us to
     * manipulate the PrivateRefCount after releasing the spinlock
     */
    Assert(GetPrivateRefCountEntry(BufferDescriptorGetBuffer(buf), false) == NULL);
 
    /*
     * Buffer can't have a preexisting pin, so mark its page as defined to
     * Valgrind (this is similar to the PinBuffer() case where the backend
     * doesn't already have a buffer pin)
     */
    VALGRIND_MAKE_MEM_DEFINED(BufHdrGetBlock(buf), BLCKSZ);
 
    /*
     * Since we hold the buffer spinlock, we can update the buffer state and
     * release the lock in one operation.
     */
    buf_state = pg_atomic_read_u32(&buf->state);
    Assert(buf_state & BM_LOCKED);
    buf_state += BUF_REFCOUNT_ONE;
    UnlockBufHdr(buf, buf_state);
 
    b = BufferDescriptorGetBuffer(buf);
 
    ref = NewPrivateRefCountEntry(b);
    ref->refcount++;
 
    ResourceOwnerRememberBuffer(CurrentResourceOwner, b);
}

References Assert(), b, BM_LOCKED, buf, BUF_REFCOUNT_ONE, BufferDescriptorGetBuffer(), BufHdrGetBlock, CurrentResourceOwner, GetPrivateRefCountEntry(), NewPrivateRefCountEntry(), pg_atomic_read_u32(), PrivateRefCountEntry::refcount, ResourceOwnerRememberBuffer(), UnlockBufHdr(), and VALGRIND_MAKE_MEM_DEFINED.

Referenced by FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetVictimBuffer(), ReadRecentBuffer(), and SyncOneBuffer().

PrefetchBuffer()

PrefetchBufferResult PrefetchBuffer	(	Relation	reln,
		ForkNumber	forkNum,
		BlockNumber	blockNum
	)

Definition at line 601 of file bufmgr.c.

{
    Assert(RelationIsValid(reln));
    Assert(BlockNumberIsValid(blockNum));
 
    if (RelationUsesLocalBuffers(reln))
    {
        /* see comments in ReadBufferExtended */
        if (RELATION_IS_OTHER_TEMP(reln))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot access temporary tables of other sessions")));
 
        /* pass it off to localbuf.c */
        return PrefetchLocalBuffer(RelationGetSmgr(reln), forkNum, blockNum);
    }
    else
    {
        /* pass it to the shared buffer version */
        return PrefetchSharedBuffer(RelationGetSmgr(reln), forkNum, blockNum);
    }
}

References Assert(), BlockNumberIsValid(), ereport, errcode(), errmsg(), ERROR, PrefetchLocalBuffer(), PrefetchSharedBuffer(), RELATION_IS_OTHER_TEMP, RelationGetSmgr(), RelationIsValid, and RelationUsesLocalBuffers.

Referenced by acquire_sample_rows(), BitmapPrefetch(), count_nondeletable_pages(), and pg_prewarm().

PrefetchSharedBuffer()

PrefetchBufferResult PrefetchSharedBuffer	(	SMgrRelation	smgr_reln,
		ForkNumber	forkNum,
		BlockNumber	blockNum
	)

Definition at line 511 of file bufmgr.c.

{
    PrefetchBufferResult result = {InvalidBuffer, false};
    BufferTag   newTag;         /* identity of requested block */
    uint32      newHash;        /* hash value for newTag */
    LWLock     *newPartitionLock;   /* buffer partition lock for it */
    int         buf_id;
 
    Assert(BlockNumberIsValid(blockNum));
 
    /* create a tag so we can lookup the buffer */
    InitBufferTag(&newTag, &smgr_reln->smgr_rlocator.locator,
                  forkNum, blockNum);
 
    /* determine its hash code and partition lock ID */
    newHash = BufTableHashCode(&newTag);
    newPartitionLock = BufMappingPartitionLock(newHash);
 
    /* see if the block is in the buffer pool already */
    LWLockAcquire(newPartitionLock, LW_SHARED);
    buf_id = BufTableLookup(&newTag, newHash);
    LWLockRelease(newPartitionLock);
 
    /* If not in buffers, initiate prefetch */
    if (buf_id < 0)
    {
#ifdef USE_PREFETCH
        /*
         * Try to initiate an asynchronous read.  This returns false in
         * recovery if the relation file doesn't exist.
         */
        if ((io_direct_flags & IO_DIRECT_DATA) == 0 &&
            smgrprefetch(smgr_reln, forkNum, blockNum))
        {
            result.initiated_io = true;
        }
#endif                          /* USE_PREFETCH */
    }
    else
    {
        /*
         * Report the buffer it was in at that time.  The caller may be able
         * to avoid a buffer table lookup, but it's not pinned and it must be
         * rechecked!
         */
        result.recent_buffer = buf_id + 1;
    }
 
    /*
     * If the block *is* in buffers, we do nothing.  This is not really ideal:
     * the block might be just about to be evicted, which would be stupid
     * since we know we are going to need it soon.  But the only easy answer
     * is to bump the usage_count, which does not seem like a great solution:
     * when the caller does ultimately touch the block, usage_count would get
     * bumped again, resulting in too much favoritism for blocks that are
     * involved in a prefetch sequence. A real fix would involve some
     * additional per-buffer state, and it's not clear that there's enough of
     * a problem to justify that.
     */
 
    return result;
}

References Assert(), BlockNumberIsValid(), BufMappingPartitionLock(), BufTableHashCode(), BufTableLookup(), InitBufferTag(), PrefetchBufferResult::initiated_io, InvalidBuffer, IO_DIRECT_DATA, io_direct_flags, RelFileLocatorBackend::locator, LW_SHARED, LWLockAcquire(), LWLockRelease(), PrefetchBufferResult::recent_buffer, SMgrRelationData::smgr_rlocator, and smgrprefetch().

Referenced by PrefetchBuffer(), and XLogPrefetcherNextBlock().

PrintBufferLeakWarning()

void PrintBufferLeakWarning

(

Buffer

buffer

)

Definition at line 3232 of file bufmgr.c.

{
    BufferDesc *buf;
    int32       loccount;
    char       *path;
    BackendId   backend;
    uint32      buf_state;
 
    Assert(BufferIsValid(buffer));
    if (BufferIsLocal(buffer))
    {
        buf = GetLocalBufferDescriptor(-buffer - 1);
        loccount = LocalRefCount[-buffer - 1];
        backend = MyBackendId;
    }
    else
    {
        buf = GetBufferDescriptor(buffer - 1);
        loccount = GetPrivateRefCount(buffer);
        backend = InvalidBackendId;
    }
 
    /* theoretically we should lock the bufhdr here */
    path = relpathbackend(BufTagGetRelFileLocator(&buf->tag), backend,
                          BufTagGetForkNum(&buf->tag));
    buf_state = pg_atomic_read_u32(&buf->state);
    elog(WARNING,
         "buffer refcount leak: [%03d] "
         "(rel=%s, blockNum=%u, flags=0x%x, refcount=%u %d)",
         buffer, path,
         buf->tag.blockNum, buf_state & BUF_FLAG_MASK,
         BUF_STATE_GET_REFCOUNT(buf_state), loccount);
    pfree(path);
}

References Assert(), buf, BUF_FLAG_MASK, BUF_STATE_GET_REFCOUNT, PrivateRefCountEntry::buffer, BufferIsLocal, BufferIsValid(), BufTagGetForkNum(), BufTagGetRelFileLocator(), elog(), GetBufferDescriptor(), GetLocalBufferDescriptor(), GetPrivateRefCount(), InvalidBackendId, LocalRefCount, MyBackendId, pfree(), pg_atomic_read_u32(), relpathbackend, and WARNING.

Referenced by CheckForBufferLeaks(), CheckForLocalBufferLeaks(), and ResourceOwnerReleaseInternal().

ReadBuffer()

Buffer ReadBuffer	(	Relation	reln,
		BlockNumber	blockNum
	)

Definition at line 708 of file bufmgr.c.

{
    return ReadBufferExtended(reln, MAIN_FORKNUM, blockNum, RBM_NORMAL, NULL);
}

References MAIN_FORKNUM, RBM_NORMAL, and ReadBufferExtended().

Referenced by _bt_allocbuf(), _bt_getbuf(), _bt_search_insert(), _hash_getbuf(), _hash_getbuf_with_condlock_cleanup(), blbulkdelete(), blinsert(), BloomNewBuffer(), brin_getinsertbuffer(), brinGetStats(), brinGetTupleForHeapBlock(), brinRevmapDesummarizeRange(), brinRevmapInitialize(), bt_metap(), bt_multi_page_stats(), bt_page_items_internal(), bt_page_stats_internal(), ginFindLeafPage(), ginFindParents(), ginGetStats(), ginHeapTupleFastInsert(), ginInsertCleanup(), GinNewBuffer(), ginStepRight(), ginUpdateStats(), gistBufferingFindCorrectParent(), gistbufferinginserttuples(), gistdoinsert(), gistFindCorrectParent(), gistFindPath(), gistfixsplit(), gistGetMaxLevel(), gistkillitems(), gistNewBuffer(), gistProcessItup(), gistScanPage(), heap_abort_speculative(), heap_delete(), heap_fetch(), heap_finish_speculative(), heap_force_common(), heap_get_latest_tid(), heap_index_delete_tuples(), heap_inplace_update(), heap_lock_tuple(), heap_update(), initBloomState(), pg_visibility(), pgstatginindex_internal(), read_seq_tuple(), RelationGetBufferForTuple(), ReleaseAndReadBuffer(), revmap_get_buffer(), revmap_physical_extend(), scanGetCandidate(), scanPendingInsert(), shiftList(), spgdoinsert(), spgGetCache(), SpGistGetBuffer(), SpGistNewBuffer(), SpGistUpdateMetaPage(), and spgWalk().

ReadBuffer_common()

static Buffer ReadBuffer_common ( SMgrRelation  smgr, char  relpersistence, ForkNumber  forkNum, BlockNumber  blockNum, ReadBufferMode  mode, BufferAccessStrategy  strategy, bool *  hit  )

static

Definition at line 992 of file bufmgr.c.

{
    BufferDesc *bufHdr;
    Block       bufBlock;
    bool        found;
    IOContext   io_context;
    IOObject    io_object;
    bool        isLocalBuf = SmgrIsTemp(smgr);
 
    *hit = false;
 
    /*
     * Backward compatibility path, most code should use ExtendBufferedRel()
     * instead, as acquiring the extension lock inside ExtendBufferedRel()
     * scales a lot better.
     */
    if (unlikely(blockNum == P_NEW))
    {
        uint32      flags = EB_SKIP_EXTENSION_LOCK;
 
        /*
         * Since no-one else can be looking at the page contents yet, there is
         * no difference between an exclusive lock and a cleanup-strength
         * lock.
         */
        if (mode == RBM_ZERO_AND_LOCK || mode == RBM_ZERO_AND_CLEANUP_LOCK)
            flags |= EB_LOCK_FIRST;
 
        return ExtendBufferedRel(BMR_SMGR(smgr, relpersistence),
                                 forkNum, strategy, flags);
    }
 
    /* Make sure we will have room to remember the buffer pin */
    ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
 
    TRACE_POSTGRESQL_BUFFER_READ_START(forkNum, blockNum,
                                       smgr->smgr_rlocator.locator.spcOid,
                                       smgr->smgr_rlocator.locator.dbOid,
                                       smgr->smgr_rlocator.locator.relNumber,
                                       smgr->smgr_rlocator.backend);
 
    if (isLocalBuf)
    {
        /*
         * We do not use a BufferAccessStrategy for I/O of temporary tables.
         * However, in some cases, the "strategy" may not be NULL, so we can't
         * rely on IOContextForStrategy() to set the right IOContext for us.
         * This may happen in cases lik