buf_internals.h File Reference

#include "pgstat.h"
#include "port/atomics.h"
#include "storage/aio_types.h"
#include "storage/buf.h"
#include "storage/bufmgr.h"
#include "storage/condition_variable.h"
#include "storage/lwlock.h"
#include "storage/procnumber.h"
#include "storage/shmem.h"
#include "storage/smgr.h"
#include "storage/spin.h"
#include "utils/relcache.h"
#include "utils/resowner.h"

Include dependency graph for buf_internals.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	buftag
struct	BufferDesc
union	BufferDescPadded
struct	PendingWriteback
struct	WritebackContext
struct	CkptSortItem

Macros
#define	BUF_REFCOUNT_BITS   18
#define	BUF_USAGECOUNT_BITS   4
#define	BUF_FLAG_BITS   10
#define	BUF_REFCOUNT_ONE   1
#define	BUF_REFCOUNT_MASK   ((1U << BUF_REFCOUNT_BITS) - 1)
#define	BUF_USAGECOUNT_MASK   (((1U << BUF_USAGECOUNT_BITS) - 1) << (BUF_REFCOUNT_BITS))
#define	BUF_USAGECOUNT_ONE   (1U << BUF_REFCOUNT_BITS)
#define	BUF_USAGECOUNT_SHIFT   BUF_REFCOUNT_BITS
#define	BUF_FLAG_MASK   (((1U << BUF_FLAG_BITS) - 1) << (BUF_REFCOUNT_BITS + BUF_USAGECOUNT_BITS))
#define	BUF_STATE_GET_REFCOUNT(state)   ((state) & BUF_REFCOUNT_MASK)
#define	BUF_STATE_GET_USAGECOUNT(state)   (((state) & BUF_USAGECOUNT_MASK) >> BUF_USAGECOUNT_SHIFT)
#define	BM_LOCKED   (1U << 22) /* buffer header is locked */
#define	BM_DIRTY   (1U << 23) /* data needs writing */
#define	BM_VALID   (1U << 24) /* data is valid */
#define	BM_TAG_VALID   (1U << 25) /* tag is assigned */
#define	BM_IO_IN_PROGRESS   (1U << 26) /* read or write in progress */
#define	BM_IO_ERROR   (1U << 27) /* previous I/O failed */
#define	BM_JUST_DIRTIED   (1U << 28) /* dirtied since write started */
#define	BM_PIN_COUNT_WAITER   (1U << 29) /* have waiter for sole pin */
#define	BM_CHECKPOINT_NEEDED   (1U << 30) /* must write for checkpoint */
#define	BM_PERMANENT
#define	BM_MAX_USAGE_COUNT   5
#define	BUFFERDESC_PAD_TO_SIZE   (SIZEOF_VOID_P == 8 ? 64 : 1)

Typedefs
typedef struct buftag	BufferTag
typedef struct BufferDesc	BufferDesc
typedef union BufferDescPadded	BufferDescPadded
typedef struct PendingWriteback	PendingWriteback
typedef struct WritebackContext	WritebackContext
typedef struct CkptSortItem	CkptSortItem

Functions
	StaticAssertDecl (BUF_REFCOUNT_BITS+BUF_USAGECOUNT_BITS+BUF_FLAG_BITS==32, "parts of buffer state space need to equal 32")
	StaticAssertDecl (BM_MAX_USAGE_COUNT<(1<< BUF_USAGECOUNT_BITS), "BM_MAX_USAGE_COUNT doesn't fit in BUF_USAGECOUNT_BITS bits")
	StaticAssertDecl (MAX_BACKENDS_BITS<=BUF_REFCOUNT_BITS, "MAX_BACKENDS_BITS needs to be <= BUF_REFCOUNT_BITS")
static RelFileNumber	BufTagGetRelNumber (const BufferTag *tag)
static ForkNumber	BufTagGetForkNum (const BufferTag *tag)
static void	BufTagSetRelForkDetails (BufferTag *tag, RelFileNumber relnumber, ForkNumber forknum)
static RelFileLocator	BufTagGetRelFileLocator (const BufferTag *tag)
static void	ClearBufferTag (BufferTag *tag)
static void	InitBufferTag (BufferTag *tag, const RelFileLocator *rlocator, ForkNumber forkNum, BlockNumber blockNum)
static bool	BufferTagsEqual (const BufferTag *tag1, const BufferTag *tag2)
static bool	BufTagMatchesRelFileLocator (const BufferTag *tag, const RelFileLocator *rlocator)
static uint32	BufTableHashPartition (uint32 hashcode)
static LWLock *	BufMappingPartitionLock (uint32 hashcode)
static LWLock *	BufMappingPartitionLockByIndex (uint32 index)
static BufferDesc *	GetBufferDescriptor (uint32 id)
static BufferDesc *	GetLocalBufferDescriptor (uint32 id)
static Buffer	BufferDescriptorGetBuffer (const BufferDesc *bdesc)
static ConditionVariable *	BufferDescriptorGetIOCV (const BufferDesc *bdesc)
static LWLock *	BufferDescriptorGetContentLock (const BufferDesc *bdesc)
uint32	LockBufHdr (BufferDesc *desc)
static void	UnlockBufHdr (BufferDesc *desc)
static uint32	UnlockBufHdrExt (BufferDesc *desc, uint32 old_buf_state, uint32 set_bits, uint32 unset_bits, int refcount_change)
uint32	WaitBufHdrUnlocked (BufferDesc *buf)
static void	ResourceOwnerRememberBuffer (ResourceOwner owner, Buffer buffer)
static void	ResourceOwnerForgetBuffer (ResourceOwner owner, Buffer buffer)
static void	ResourceOwnerRememberBufferIO (ResourceOwner owner, Buffer buffer)
static void	ResourceOwnerForgetBufferIO (ResourceOwner owner, Buffer buffer)
void	WritebackContextInit (WritebackContext *context, int *max_pending)
void	IssuePendingWritebacks (WritebackContext *wb_context, IOContext io_context)
void	ScheduleBufferTagForWriteback (WritebackContext *wb_context, IOContext io_context, BufferTag *tag)
void	TrackNewBufferPin (Buffer buf)
bool	StartBufferIO (BufferDesc *buf, bool forInput, bool nowait)
void	TerminateBufferIO (BufferDesc *buf, bool clear_dirty, uint32 set_flag_bits, bool forget_owner, bool release_aio)
IOContext	IOContextForStrategy (BufferAccessStrategy strategy)
BufferDesc *	StrategyGetBuffer (BufferAccessStrategy strategy, uint32 *buf_state, bool *from_ring)
bool	StrategyRejectBuffer (BufferAccessStrategy strategy, BufferDesc *buf, bool from_ring)
int	StrategySyncStart (uint32 *complete_passes, uint32 *num_buf_alloc)
void	StrategyNotifyBgWriter (int bgwprocno)
Size	StrategyShmemSize (void)
void	StrategyInitialize (bool init)
Size	BufTableShmemSize (int size)
void	InitBufTable (int size)
uint32	BufTableHashCode (BufferTag *tagPtr)
int	BufTableLookup (BufferTag *tagPtr, uint32 hashcode)
int	BufTableInsert (BufferTag *tagPtr, uint32 hashcode, int buf_id)
void	BufTableDelete (BufferTag *tagPtr, uint32 hashcode)
bool	PinLocalBuffer (BufferDesc *buf_hdr, bool adjust_usagecount)
void	UnpinLocalBuffer (Buffer buffer)
void	UnpinLocalBufferNoOwner (Buffer buffer)
PrefetchBufferResult	PrefetchLocalBuffer (SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum)
BufferDesc *	LocalBufferAlloc (SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum, bool *foundPtr)
BlockNumber	ExtendBufferedRelLocal (BufferManagerRelation bmr, ForkNumber fork, uint32 flags, uint32 extend_by, BlockNumber extend_upto, Buffer *buffers, uint32 *extended_by)
void	MarkLocalBufferDirty (Buffer buffer)
void	TerminateLocalBufferIO (BufferDesc *bufHdr, bool clear_dirty, uint32 set_flag_bits, bool release_aio)
bool	StartLocalBufferIO (BufferDesc *bufHdr, bool forInput, bool nowait)
void	FlushLocalBuffer (BufferDesc *bufHdr, SMgrRelation reln)
void	InvalidateLocalBuffer (BufferDesc *bufHdr, bool check_unreferenced)
void	DropRelationLocalBuffers (RelFileLocator rlocator, ForkNumber *forkNum, int nforks, BlockNumber *firstDelBlock)
void	DropRelationAllLocalBuffers (RelFileLocator rlocator)
void	AtEOXact_LocalBuffers (bool isCommit)

Variables
PGDLLIMPORT BufferDescPadded *	BufferDescriptors
PGDLLIMPORT ConditionVariableMinimallyPadded *	BufferIOCVArray
PGDLLIMPORT WritebackContext	BackendWritebackContext
PGDLLIMPORT BufferDesc *	LocalBufferDescriptors
PGDLLIMPORT CkptSortItem *	CkptBufferIds
PGDLLIMPORT const ResourceOwnerDesc	buffer_io_resowner_desc
PGDLLIMPORT const ResourceOwnerDesc	buffer_pin_resowner_desc

Macro Definition Documentation

BM_CHECKPOINT_NEEDED

#define BM_CHECKPOINT_NEEDED   (1U << 30) /* must write for checkpoint */

Definition at line 76 of file buf_internals.h.

BM_DIRTY

#define BM_DIRTY   (1U << 23) /* data needs writing */

Definition at line 69 of file buf_internals.h.

BM_IO_ERROR

#define BM_IO_ERROR   (1U << 27) /* previous I/O failed */

Definition at line 73 of file buf_internals.h.

BM_IO_IN_PROGRESS

#define BM_IO_IN_PROGRESS   (1U << 26) /* read or write in progress */

Definition at line 72 of file buf_internals.h.

BM_JUST_DIRTIED

#define BM_JUST_DIRTIED   (1U << 28) /* dirtied since write started */

Definition at line 74 of file buf_internals.h.

BM_LOCKED

#define BM_LOCKED   (1U << 22) /* buffer header is locked */

Definition at line 68 of file buf_internals.h.

BM_MAX_USAGE_COUNT

#define BM_MAX_USAGE_COUNT   5

Definition at line 86 of file buf_internals.h.

BM_PERMANENT

#define BM_PERMANENT

Value:

                                             (1U << 31) /* permanent buffer (not unlogged,
                                             * or init fork) */

Definition at line 77 of file buf_internals.h.

BM_PIN_COUNT_WAITER

#define BM_PIN_COUNT_WAITER   (1U << 29) /* have waiter for sole pin */

Definition at line 75 of file buf_internals.h.

BM_TAG_VALID

#define BM_TAG_VALID   (1U << 25) /* tag is assigned */

Definition at line 71 of file buf_internals.h.

BM_VALID

#define BM_VALID   (1U << 24) /* data is valid */

Definition at line 70 of file buf_internals.h.

BUF_FLAG_BITS

#define BUF_FLAG_BITS   10

Definition at line 46 of file buf_internals.h.

BUF_FLAG_MASK

#define BUF_FLAG_MASK   (((1U << BUF_FLAG_BITS) - 1) << (BUF_REFCOUNT_BITS + BUF_USAGECOUNT_BITS))

Definition at line 56 of file buf_internals.h.

BUF_REFCOUNT_BITS

#define BUF_REFCOUNT_BITS   18

Definition at line 44 of file buf_internals.h.

BUF_REFCOUNT_MASK

#define BUF_REFCOUNT_MASK   ((1U << BUF_REFCOUNT_BITS) - 1)

Definition at line 52 of file buf_internals.h.

BUF_REFCOUNT_ONE

#define BUF_REFCOUNT_ONE   1

Definition at line 51 of file buf_internals.h.

BUF_STATE_GET_REFCOUNT

#define BUF_STATE_GET_REFCOUNT

(

state

)

((state) & BUF_REFCOUNT_MASK)

Definition at line 59 of file buf_internals.h.

BUF_STATE_GET_USAGECOUNT

#define BUF_STATE_GET_USAGECOUNT

(

state

)

(((state) & BUF_USAGECOUNT_MASK) >> BUF_USAGECOUNT_SHIFT)

Definition at line 60 of file buf_internals.h.

BUF_USAGECOUNT_BITS

#define BUF_USAGECOUNT_BITS   4

Definition at line 45 of file buf_internals.h.

BUF_USAGECOUNT_MASK

#define BUF_USAGECOUNT_MASK   (((1U << BUF_USAGECOUNT_BITS) - 1) << (BUF_REFCOUNT_BITS))

Definition at line 53 of file buf_internals.h.

BUF_USAGECOUNT_ONE

#define BUF_USAGECOUNT_ONE   (1U << BUF_REFCOUNT_BITS)

Definition at line 54 of file buf_internals.h.

BUF_USAGECOUNT_SHIFT

#define BUF_USAGECOUNT_SHIFT   BUF_REFCOUNT_BITS

Definition at line 55 of file buf_internals.h.

BUFFERDESC_PAD_TO_SIZE

#define BUFFERDESC_PAD_TO_SIZE   (SIZEOF_VOID_P == 8 ? 64 : 1)

Definition at line 314 of file buf_internals.h.

Typedef Documentation

BufferDesc

typedef struct BufferDesc BufferDesc

BufferDescPadded

typedef union BufferDescPadded BufferDescPadded

BufferTag

typedef struct buftag BufferTag

CkptSortItem

typedef struct CkptSortItem CkptSortItem

PendingWriteback

typedef struct PendingWriteback PendingWriteback

WritebackContext

typedef struct WritebackContext WritebackContext

Function Documentation

AtEOXact_LocalBuffers()

void AtEOXact_LocalBuffers

(

bool

isCommit

)

Definition at line 1003 of file localbuf.c.

{
    CheckForLocalBufferLeaks();
}

References CheckForLocalBufferLeaks().

Referenced by AtEOXact_Buffers().

BufferDescriptorGetBuffer()

static Buffer BufferDescriptorGetBuffer ( const BufferDesc *  bdesc )

inlinestatic

Definition at line 367 of file buf_internals.h.

{
    return (Buffer) (bdesc->buf_id + 1);

References BufferDesc::buf_id.

Referenced by AddBufferToRing(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushLocalBuffer(), FlushRelationBuffers(), GetBufferFromRing(), GetLocalVictimBuffer(), GetVictimBuffer(), InvalidateBuffer(), InvalidateLocalBuffer(), InvalidateVictimBuffer(), LockBufHdr(), pg_buffercache_os_pages_internal(), pg_buffercache_pages(), PinBuffer(), PinBuffer_Locked(), PinBufferForBlock(), PinLocalBuffer(), StartBufferIO(), StrategyGetBuffer(), StrategyRejectBuffer(), TerminateBufferIO(), UnpinBuffer(), and UnpinBufferNoOwner().

BufferDescriptorGetContentLock()

static LWLock * BufferDescriptorGetContentLock ( const BufferDesc *  bdesc )

inlinestatic

Definition at line 379 of file buf_internals.h.

{
    return (LWLock *) (&bdesc->content_lock);

References BufferDesc::content_lock.

Referenced by buffer_stage_common(), BufferIsLockedByMe(), BufferIsLockedByMeInMode(), BufferManagerShmemInit(), ConditionalLockBuffer(), FlushUnlockedBuffer(), GetVictimBuffer(), LockBuffer(), MarkDirtyUnpinnedBufferInternal(), and UnpinBufferNoOwner().

BufferDescriptorGetIOCV()

static ConditionVariable * BufferDescriptorGetIOCV ( const BufferDesc *  bdesc )

inlinestatic

Definition at line 373 of file buf_internals.h.

{
    return &(BufferIOCVArray[bdesc->buf_id]).cv;

References BufferDesc::buf_id, and BufferIOCVArray.

Referenced by BufferManagerShmemInit(), TerminateBufferIO(), and WaitIO().

BufferTagsEqual()

static bool BufferTagsEqual ( const BufferTag *  tag1, const BufferTag *  tag2  )

inlinestatic

Definition at line 166 of file buf_internals.h.

{
    return (tag1->spcOid == tag2->spcOid) &&
        (tag1->dbOid == tag2->dbOid) &&
        (tag1->relNumber == tag2->relNumber) &&
        (tag1->blockNum == tag2->blockNum) &&
        (tag1->forkNum == tag2->forkNum);

References buftag::blockNum, buftag::dbOid, buftag::forkNum, buftag::relNumber, and buftag::spcOid.

Referenced by InvalidateBuffer(), InvalidateVictimBuffer(), LocalBufferAlloc(), and ReadRecentBuffer().

BufMappingPartitionLock()

static LWLock * BufMappingPartitionLock ( uint32  hashcode )

inlinestatic

Definition at line 198 of file buf_internals.h.

{
    return &MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET +
                            BufTableHashPartition(hashcode)].lock;

References BUFFER_MAPPING_LWLOCK_OFFSET, BufTableHashPartition(), LWLockPadded::lock, and MainLWLockArray.

Referenced by BufferAlloc(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), InvalidateBuffer(), InvalidateVictimBuffer(), and PrefetchSharedBuffer().

BufMappingPartitionLockByIndex()

static LWLock * BufMappingPartitionLockByIndex ( uint32  index )

inlinestatic

Definition at line 205 of file buf_internals.h.

{
    return &MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + index].lock;

References BUFFER_MAPPING_LWLOCK_OFFSET, LWLockPadded::lock, and MainLWLockArray.

BufTableDelete()

void BufTableDelete	(	BufferTag *	tagPtr,
		uint32	hashcode
	)

Definition at line 148 of file buf_table.c.

{
    BufferLookupEnt *result;
 
    result = (BufferLookupEnt *)
        hash_search_with_hash_value(SharedBufHash,
                                    tagPtr,
                                    hashcode,
                                    HASH_REMOVE,
                                    NULL);
 
    if (!result)                /* shouldn't happen */
        elog(ERROR, "shared buffer hash table corrupted");
}

References elog, ERROR, HASH_REMOVE, hash_search_with_hash_value(), and SharedBufHash.

Referenced by InvalidateBuffer(), and InvalidateVictimBuffer().

BufTableHashCode()

uint32 BufTableHashCode

(

BufferTag *

tagPtr

)

Definition at line 78 of file buf_table.c.

{
    return get_hash_value(SharedBufHash, tagPtr);
}

References get_hash_value(), and SharedBufHash.

Referenced by BufferAlloc(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), InvalidateBuffer(), InvalidateVictimBuffer(), and PrefetchSharedBuffer().

BufTableHashPartition()

static uint32 BufTableHashPartition ( uint32  hashcode )

inlinestatic

Definition at line 192 of file buf_internals.h.

{
    return hashcode % NUM_BUFFER_PARTITIONS;

References NUM_BUFFER_PARTITIONS.

Referenced by BufMappingPartitionLock().

BufTableInsert()

int BufTableInsert	(	BufferTag *	tagPtr,
		uint32	hashcode,
		int	buf_id
	)

Definition at line 118 of file buf_table.c.

{
    BufferLookupEnt *result;
    bool        found;
 
    Assert(buf_id >= 0);        /* -1 is reserved for not-in-table */
    Assert(tagPtr->blockNum != P_NEW);  /* invalid tag */
 
    result = (BufferLookupEnt *)
        hash_search_with_hash_value(SharedBufHash,
                                    tagPtr,
                                    hashcode,
                                    HASH_ENTER,
                                    &found);
 
    if (found)                  /* found something already in the table */
        return result->id;
 
    result->id = buf_id;
 
    return -1;
}

References Assert(), buftag::blockNum, HASH_ENTER, hash_search_with_hash_value(), BufferLookupEnt::id, P_NEW, and SharedBufHash.

Referenced by BufferAlloc(), and ExtendBufferedRelShared().

BufTableLookup()

int BufTableLookup	(	BufferTag *	tagPtr,
		uint32	hashcode
	)

Definition at line 90 of file buf_table.c.

{
    BufferLookupEnt *result;
 
    result = (BufferLookupEnt *)
        hash_search_with_hash_value(SharedBufHash,
                                    tagPtr,
                                    hashcode,
                                    HASH_FIND,
                                    NULL);
 
    if (!result)
        return -1;
 
    return result->id;
}

References HASH_FIND, hash_search_with_hash_value(), BufferLookupEnt::id, and SharedBufHash.

Referenced by BufferAlloc(), FindAndDropRelationBuffers(), and PrefetchSharedBuffer().

BufTableShmemSize()

Size BufTableShmemSize

(

int

size

)

Definition at line 41 of file buf_table.c.

{
    return hash_estimate_size(size, sizeof(BufferLookupEnt));
}

References hash_estimate_size().

Referenced by StrategyShmemSize().

BufTagGetForkNum()

static ForkNumber BufTagGetForkNum ( const BufferTag *  tag )

inlinestatic

Definition at line 121 of file buf_internals.h.

{
    return tag->forkNum;

References buftag::forkNum.

Referenced by AbortBufferIO(), apw_dump_now(), BufferGetTag(), BufferSync(), buffertag_comparator(), DebugPrintBufferRefcount(), DropRelationBuffers(), DropRelationLocalBuffers(), FindAndDropRelationBuffers(), FlushBuffer(), FlushLocalBuffer(), InvalidateLocalBuffer(), IssuePendingWritebacks(), local_buffer_write_error_callback(), pg_buffercache_pages(), ReleaseAndReadBuffer(), and shared_buffer_write_error_callback().

BufTagGetRelFileLocator()

static RelFileLocator BufTagGetRelFileLocator ( const BufferTag *  tag )

inlinestatic

Definition at line 135 of file buf_internals.h.

{
    RelFileLocator rlocator;
 
    rlocator.spcOid = tag->spcOid;
    rlocator.dbOid = tag->dbOid;
    rlocator.relNumber = BufTagGetRelNumber(tag);
 
    return rlocator;

References BufTagGetRelNumber(), buftag::dbOid, RelFileLocator::dbOid, RelFileLocator::relNumber, buftag::spcOid, and RelFileLocator::spcOid.

Referenced by AbortBufferIO(), BufferGetTag(), buffertag_comparator(), DebugPrintBufferRefcount(), DropRelationsAllBuffers(), FlushBuffer(), FlushLocalBuffer(), FlushRelationsAllBuffers(), InvalidateLocalBuffer(), IssuePendingWritebacks(), local_buffer_write_error_callback(), MarkBufferDirtyHint(), and shared_buffer_write_error_callback().

BufTagGetRelNumber()

static RelFileNumber BufTagGetRelNumber ( const BufferTag *  tag )

inlinestatic

Definition at line 115 of file buf_internals.h.

{
    return tag->relNumber;

References buftag::relNumber.

Referenced by apw_dump_now(), BufferSync(), BufTagGetRelFileLocator(), BufTagMatchesRelFileLocator(), and pg_buffercache_pages().

BufTagMatchesRelFileLocator()

static bool BufTagMatchesRelFileLocator ( const BufferTag *  tag, const RelFileLocator *  rlocator  )

inlinestatic

Definition at line 176 of file buf_internals.h.

{
    return (tag->spcOid == rlocator->spcOid) &&
        (tag->dbOid == rlocator->dbOid) &&
        (BufTagGetRelNumber(tag) == rlocator->relNumber);

References BufTagGetRelNumber(), buftag::dbOid, RelFileLocator::dbOid, RelFileLocator::relNumber, buftag::spcOid, and RelFileLocator::spcOid.

Referenced by DropRelationAllLocalBuffers(), DropRelationBuffers(), DropRelationLocalBuffers(), DropRelationsAllBuffers(), EvictRelUnpinnedBuffers(), FindAndDropRelationBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), MarkDirtyRelUnpinnedBuffers(), and ReleaseAndReadBuffer().

BufTagSetRelForkDetails()

static void BufTagSetRelForkDetails ( BufferTag *  tag, RelFileNumber  relnumber, ForkNumber  forknum  )

inlinestatic

Definition at line 127 of file buf_internals.h.

{
    tag->relNumber = relnumber;
    tag->forkNum = forknum;

References buftag::forkNum, and buftag::relNumber.

Referenced by ClearBufferTag(), and InitBufferTag().

ClearBufferTag()

static void ClearBufferTag ( BufferTag *  tag )

inlinestatic

Definition at line 147 of file buf_internals.h.

{
    tag->spcOid = InvalidOid;
    tag->dbOid = InvalidOid;
    BufTagSetRelForkDetails(tag, InvalidRelFileNumber, InvalidForkNumber);
    tag->blockNum = InvalidBlockNumber;

References buftag::blockNum, BufTagSetRelForkDetails(), buftag::dbOid, InvalidBlockNumber, InvalidForkNumber, InvalidOid, InvalidRelFileNumber, and buftag::spcOid.

Referenced by BufferManagerShmemInit(), InvalidateBuffer(), InvalidateLocalBuffer(), and InvalidateVictimBuffer().

DropRelationAllLocalBuffers()

void DropRelationAllLocalBuffers

(

RelFileLocator

rlocator

)

Definition at line 702 of file localbuf.c.

{
    int         i;
 
    for (i = 0; i < NLocBuffer; i++)
    {
        BufferDesc *bufHdr = GetLocalBufferDescriptor(i);
        uint32      buf_state;
 
        buf_state = pg_atomic_read_u32(&bufHdr->state);
 
        if ((buf_state & BM_TAG_VALID) &&
            BufTagMatchesRelFileLocator(&bufHdr->tag, &rlocator))
        {
            InvalidateLocalBuffer(bufHdr, true);
        }
    }
}

References BM_TAG_VALID, BufTagMatchesRelFileLocator(), GetLocalBufferDescriptor(), i, InvalidateLocalBuffer(), NLocBuffer, pg_atomic_read_u32(), BufferDesc::state, and BufferDesc::tag.

Referenced by DropRelationsAllBuffers().

DropRelationLocalBuffers()

void DropRelationLocalBuffers	(	RelFileLocator	rlocator,
		ForkNumber *	forkNum,
		int	nforks,
		BlockNumber *	firstDelBlock
	)

Definition at line 665 of file localbuf.c.

{
    int         i;
    int         j;
 
    for (i = 0; i < NLocBuffer; i++)
    {
        BufferDesc *bufHdr = GetLocalBufferDescriptor(i);
        uint32      buf_state;
 
        buf_state = pg_atomic_read_u32(&bufHdr->state);
 
        if (!(buf_state & BM_TAG_VALID) ||
            !BufTagMatchesRelFileLocator(&bufHdr->tag, &rlocator))
            continue;
 
        for (j = 0; j < nforks; j++)
        {
            if (BufTagGetForkNum(&bufHdr->tag) == forkNum[j] &&
                bufHdr->tag.blockNum >= firstDelBlock[j])
            {
                InvalidateLocalBuffer(bufHdr, true);
                break;
            }
        }
    }
}

References buftag::blockNum, BM_TAG_VALID, BufTagGetForkNum(), BufTagMatchesRelFileLocator(), GetLocalBufferDescriptor(), i, InvalidateLocalBuffer(), j, NLocBuffer, pg_atomic_read_u32(), BufferDesc::state, and BufferDesc::tag.

Referenced by DropRelationBuffers().

ExtendBufferedRelLocal()

BlockNumber ExtendBufferedRelLocal	(	BufferManagerRelation	bmr,
		ForkNumber	fork,
		uint32	flags,
		uint32	extend_by,
		BlockNumber	extend_upto,
		Buffer *	buffers,
		uint32 *	extended_by
	)

Definition at line 346 of file localbuf.c.

{
    BlockNumber first_block;
    instr_time  io_start;
 
    /* Initialize local buffers if first request in this session */
    if (LocalBufHash == NULL)
        InitLocalBuffers();
 
    LimitAdditionalLocalPins(&extend_by);
 
    for (uint32 i = 0; i < extend_by; i++)
    {
        BufferDesc *buf_hdr;
        Block       buf_block;
 
        buffers[i] = GetLocalVictimBuffer();
        buf_hdr = GetLocalBufferDescriptor(-buffers[i] - 1);
        buf_block = LocalBufHdrGetBlock(buf_hdr);
 
        /* new buffers are zero-filled */
        MemSet(buf_block, 0, BLCKSZ);
    }
 
    first_block = smgrnblocks(BMR_GET_SMGR(bmr), fork);
 
    if (extend_upto != InvalidBlockNumber)
    {
        /*
         * In contrast to shared relations, nothing could change the relation
         * size concurrently. Thus we shouldn't end up finding that we don't
         * need to do anything.
         */
        Assert(first_block <= extend_upto);
 
        Assert((uint64) first_block + extend_by <= extend_upto);
    }
 
    /* 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_GET_SMGR(bmr)->smgr_rlocator, fork).str,
                        MaxBlockNumber)));
 
    for (uint32 i = 0; i < extend_by; i++)
    {
        int         victim_buf_id;
        BufferDesc *victim_buf_hdr;
        BufferTag   tag;
        LocalBufferLookupEnt *hresult;
        bool        found;
 
        victim_buf_id = -buffers[i] - 1;
        victim_buf_hdr = GetLocalBufferDescriptor(victim_buf_id);
 
        /* in case we need to pin an existing buffer below */
        ResourceOwnerEnlarge(CurrentResourceOwner);
 
        InitBufferTag(&tag, &BMR_GET_SMGR(bmr)->smgr_rlocator.locator, fork,
                      first_block + i);
 
        hresult = (LocalBufferLookupEnt *)
            hash_search(LocalBufHash, &tag, HASH_ENTER, &found);
        if (found)
        {
            BufferDesc *existing_hdr;
            uint32      buf_state;
 
            UnpinLocalBuffer(BufferDescriptorGetBuffer(victim_buf_hdr));
 
            existing_hdr = GetLocalBufferDescriptor(hresult->id);
            PinLocalBuffer(existing_hdr, false);
            buffers[i] = BufferDescriptorGetBuffer(existing_hdr);
 
            /*
             * Clear the BM_VALID bit, do StartLocalBufferIO() and proceed.
             */
            buf_state = pg_atomic_read_u32(&existing_hdr->state);
            Assert(buf_state & BM_TAG_VALID);
            Assert(!(buf_state & BM_DIRTY));
            buf_state &= ~BM_VALID;
            pg_atomic_unlocked_write_u32(&existing_hdr->state, buf_state);
 
            /* no need to loop for local buffers */
            StartLocalBufferIO(existing_hdr, true, false);
        }
        else
        {
            uint32      buf_state = pg_atomic_read_u32(&victim_buf_hdr->state);
 
            Assert(!(buf_state & (BM_VALID | BM_TAG_VALID | BM_DIRTY | BM_JUST_DIRTIED)));
 
            victim_buf_hdr->tag = tag;
 
            buf_state |= BM_TAG_VALID | BUF_USAGECOUNT_ONE;
 
            pg_atomic_unlocked_write_u32(&victim_buf_hdr->state, buf_state);
 
            hresult->id = victim_buf_id;
 
            StartLocalBufferIO(victim_buf_hdr, true, false);
        }
    }
 
    io_start = pgstat_prepare_io_time(track_io_timing);
 
    /* actually extend relation */
    smgrzeroextend(BMR_GET_SMGR(bmr), fork, first_block, extend_by, false);
 
    pgstat_count_io_op_time(IOOBJECT_TEMP_RELATION, IOCONTEXT_NORMAL, IOOP_EXTEND,
                            io_start, 1, extend_by * BLCKSZ);
 
    for (uint32 i = 0; i < extend_by; i++)
    {
        Buffer      buf = buffers[i];
        BufferDesc *buf_hdr;
        uint32      buf_state;
 
        buf_hdr = GetLocalBufferDescriptor(-buf - 1);
 
        buf_state = pg_atomic_read_u32(&buf_hdr->state);
        buf_state |= BM_VALID;
        pg_atomic_unlocked_write_u32(&buf_hdr->state, buf_state);
    }
 
    *extended_by = extend_by;
 
    pgBufferUsage.local_blks_written += extend_by;
 
    return first_block;
}

References Assert(), BM_DIRTY, BM_JUST_DIRTIED, BM_TAG_VALID, BM_VALID, BMR_GET_SMGR, buf, BUF_USAGECOUNT_ONE, BufferDescriptorGetBuffer(), CurrentResourceOwner, ereport, errcode(), errmsg(), ERROR, GetLocalBufferDescriptor(), GetLocalVictimBuffer(), HASH_ENTER, hash_search(), i, LocalBufferLookupEnt::id, InitBufferTag(), InitLocalBuffers(), InvalidBlockNumber, IOCONTEXT_NORMAL, IOOBJECT_TEMP_RELATION, IOOP_EXTEND, LimitAdditionalLocalPins(), BufferUsage::local_blks_written, LocalBufHash, LocalBufHdrGetBlock, MaxBlockNumber, MemSet, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), pgBufferUsage, pgstat_count_io_op_time(), pgstat_prepare_io_time(), PinLocalBuffer(), relpath, ResourceOwnerEnlarge(), smgrnblocks(), smgrzeroextend(), StartLocalBufferIO(), BufferDesc::state, str, BufferDesc::tag, track_io_timing, and UnpinLocalBuffer().

Referenced by ExtendBufferedRelCommon().

FlushLocalBuffer()

void FlushLocalBuffer	(	BufferDesc *	bufHdr,
		SMgrRelation	reln
	)

Definition at line 183 of file localbuf.c.

{
    instr_time  io_start;
    Page        localpage = (char *) LocalBufHdrGetBlock(bufHdr);
 
    Assert(LocalRefCount[-BufferDescriptorGetBuffer(bufHdr) - 1] > 0);
 
    /*
     * Try to start an I/O operation.  There currently are no reasons for
     * StartLocalBufferIO to return false, so we raise an error in that case.
     */
    if (!StartLocalBufferIO(bufHdr, false, false))
        elog(ERROR, "failed to start write IO on local buffer");
 
    /* Find smgr relation for buffer */
    if (reln == NULL)
        reln = smgropen(BufTagGetRelFileLocator(&bufHdr->tag),
                        MyProcNumber);
 
    PageSetChecksumInplace(localpage, bufHdr->tag.blockNum);
 
    io_start = pgstat_prepare_io_time(track_io_timing);
 
    /* And write... */
    smgrwrite(reln,
              BufTagGetForkNum(&bufHdr->tag),
              bufHdr->tag.blockNum,
              localpage,
              false);
 
    /* Temporary table I/O does not use Buffer Access Strategies */
    pgstat_count_io_op_time(IOOBJECT_TEMP_RELATION, IOCONTEXT_NORMAL,
                            IOOP_WRITE, io_start, 1, BLCKSZ);
 
    /* Mark not-dirty */
    TerminateLocalBufferIO(bufHdr, true, 0, false);
 
    pgBufferUsage.local_blks_written++;
}

References Assert(), buftag::blockNum, BufferDescriptorGetBuffer(), BufTagGetForkNum(), BufTagGetRelFileLocator(), elog, ERROR, IOCONTEXT_NORMAL, IOOBJECT_TEMP_RELATION, IOOP_WRITE, BufferUsage::local_blks_written, LocalBufHdrGetBlock, LocalRefCount, MyProcNumber, PageSetChecksumInplace(), pgBufferUsage, pgstat_count_io_op_time(), pgstat_prepare_io_time(), smgropen(), smgrwrite(), StartLocalBufferIO(), BufferDesc::tag, TerminateLocalBufferIO(), and track_io_timing.

Referenced by FlushRelationBuffers(), GetLocalVictimBuffer(), and invalidate_rel_block().

GetBufferDescriptor()

static BufferDesc * GetBufferDescriptor ( uint32  id )

inlinestatic

Definition at line 355 of file buf_internals.h.

{
    return &(BufferDescriptors[id]).bufferdesc;

References BufferDescriptors.

Referenced by AbortBufferIO(), apw_dump_now(), buffer_call_start_io(), buffer_call_terminate_io(), buffer_readv_complete_one(), buffer_stage_common(), BufferAlloc(), BufferGetBlockNumber(), BufferGetLSNAtomic(), BufferGetTag(), BufferIsDirty(), BufferIsLockedByMe(), BufferIsLockedByMeInMode(), BufferIsPermanent(), BufferManagerShmemInit(), BufferSync(), CheckReadBuffersOperation(), ConditionalLockBuffer(), ConditionalLockBufferForCleanup(), create_toy_buffer(), DebugPrintBufferRefcount(), DropDatabaseBuffers(), DropRelationBuffers(), DropRelationsAllBuffers(), EvictAllUnpinnedBuffers(), EvictRelUnpinnedBuffers(), EvictUnpinnedBuffer(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), FlushDatabaseBuffers(), FlushOneBuffer(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetBufferFromRing(), invalidate_rel_block(), IsBufferCleanupOK(), LockBuffer(), LockBufferForCleanup(), MarkBufferDirty(), MarkBufferDirtyHint(), MarkDirtyAllUnpinnedBuffers(), MarkDirtyRelUnpinnedBuffers(), MarkDirtyUnpinnedBuffer(), pg_buffercache_os_pages_internal(), pg_buffercache_pages(), pg_buffercache_summary(), read_rel_block_ll(), ReadBuffersCanStartIOOnce(), ReadRecentBuffer(), ReleaseAndReadBuffer(), ReleaseBuffer(), ResOwnerReleaseBufferPin(), StartReadBuffersImpl(), StrategyGetBuffer(), SyncOneBuffer(), TrackNewBufferPin(), and ZeroAndLockBuffer().

GetLocalBufferDescriptor()

static BufferDesc * GetLocalBufferDescriptor ( uint32  id )

inlinestatic

Definition at line 361 of file buf_internals.h.

{
    return &LocalBufferDescriptors[id];

References LocalBufferDescriptors.

Referenced by buffer_call_start_io(), buffer_call_terminate_io(), buffer_readv_complete_one(), buffer_stage_common(), BufferGetBlockNumber(), BufferGetTag(), BufferIsDirty(), CheckReadBuffersOperation(), create_toy_buffer(), DebugPrintBufferRefcount(), DropRelationAllLocalBuffers(), DropRelationLocalBuffers(), ExtendBufferedRelLocal(), FlushRelationBuffers(), GetLocalVictimBuffer(), InitLocalBuffers(), invalidate_rel_block(), LocalBufferAlloc(), MarkLocalBufferDirty(), modify_rel_block(), read_rel_block_ll(), ReadBuffersCanStartIOOnce(), ReadRecentBuffer(), ReleaseAndReadBuffer(), StartReadBuffersImpl(), UnpinLocalBufferNoOwner(), and ZeroAndLockBuffer().

InitBufferTag()

static void InitBufferTag ( BufferTag *  tag, const RelFileLocator *  rlocator, ForkNumber  forkNum, BlockNumber  blockNum  )

inlinestatic

Definition at line 156 of file buf_internals.h.

{
    tag->spcOid = rlocator->spcOid;
    tag->dbOid = rlocator->dbOid;
    BufTagSetRelForkDetails(tag, rlocator->relNumber, forkNum);
    tag->blockNum = blockNum;

References buftag::blockNum, BufTagSetRelForkDetails(), buftag::dbOid, RelFileLocator::dbOid, RelFileLocator::relNumber, buftag::spcOid, and RelFileLocator::spcOid.

Referenced by BufferAlloc(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), LocalBufferAlloc(), PrefetchLocalBuffer(), PrefetchSharedBuffer(), and ReadRecentBuffer().

InitBufTable()

void InitBufTable

(

int

size

)

Definition at line 51 of file buf_table.c.

{
    HASHCTL     info;
 
    /* assume no locking is needed yet */
 
    /* BufferTag maps to Buffer */
    info.keysize = sizeof(BufferTag);
    info.entrysize = sizeof(BufferLookupEnt);
    info.num_partitions = NUM_BUFFER_PARTITIONS;
 
    SharedBufHash = ShmemInitHash("Shared Buffer Lookup Table",
                                  size, size,
                                  &info,
                                  HASH_ELEM | HASH_BLOBS | HASH_PARTITION | HASH_FIXED_SIZE);
}

References HASHCTL::entrysize, HASH_BLOBS, HASH_ELEM, HASH_FIXED_SIZE, HASH_PARTITION, HASHCTL::keysize, NUM_BUFFER_PARTITIONS, HASHCTL::num_partitions, SharedBufHash, and ShmemInitHash().

Referenced by StrategyInitialize().

InvalidateLocalBuffer()

void InvalidateLocalBuffer	(	BufferDesc *	bufHdr,
		bool	check_unreferenced
	)

Definition at line 605 of file localbuf.c.

{
    Buffer      buffer = BufferDescriptorGetBuffer(bufHdr);
    int         bufid = -buffer - 1;
    uint32      buf_state;
    LocalBufferLookupEnt *hresult;
 
    /*
     * It's possible that we started IO on this buffer before e.g. aborting
     * the transaction that created a table. We need to wait for that IO to
     * complete before removing / reusing the buffer.
     */
    if (pgaio_wref_valid(&bufHdr->io_wref))
    {
        PgAioWaitRef iow = bufHdr->io_wref;
 
        pgaio_wref_wait(&iow);
        Assert(!pgaio_wref_valid(&bufHdr->io_wref));
    }
 
    buf_state = pg_atomic_read_u32(&bufHdr->state);
 
    /*
     * We need to test not just LocalRefCount[bufid] but also the BufferDesc
     * itself, as the latter is used to represent a pin by the AIO subsystem.
     * This can happen if AIO is initiated and then the query errors out.
     */
    if (check_unreferenced &&
        (LocalRefCount[bufid] != 0 || BUF_STATE_GET_REFCOUNT(buf_state) != 0))
        elog(ERROR, "block %u of %s is still referenced (local %d)",
             bufHdr->tag.blockNum,
             relpathbackend(BufTagGetRelFileLocator(&bufHdr->tag),
                            MyProcNumber,
                            BufTagGetForkNum(&bufHdr->tag)).str,
             LocalRefCount[bufid]);
 
    /* Remove entry from hashtable */
    hresult = (LocalBufferLookupEnt *)
        hash_search(LocalBufHash, &bufHdr->tag, HASH_REMOVE, NULL);
    if (!hresult)               /* shouldn't happen */
        elog(ERROR, "local buffer hash table corrupted");
    /* Mark buffer invalid */
    ClearBufferTag(&bufHdr->tag);
    buf_state &= ~BUF_FLAG_MASK;
    buf_state &= ~BUF_USAGECOUNT_MASK;
    pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
}

References Assert(), buftag::blockNum, BUF_STATE_GET_REFCOUNT, BufferDescriptorGetBuffer(), BufTagGetForkNum(), BufTagGetRelFileLocator(), ClearBufferTag(), elog, ERROR, HASH_REMOVE, hash_search(), BufferDesc::io_wref, LocalBufHash, LocalRefCount, MyProcNumber, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), pgaio_wref_valid(), pgaio_wref_wait(), relpathbackend, BufferDesc::state, and BufferDesc::tag.

Referenced by DropRelationAllLocalBuffers(), DropRelationLocalBuffers(), GetLocalVictimBuffer(), invalidate_rel_block(), and modify_rel_block().

IOContextForStrategy()

IOContext IOContextForStrategy

(

BufferAccessStrategy

strategy

)

Definition at line 747 of file freelist.c.

{
    if (!strategy)
        return IOCONTEXT_NORMAL;
 
    switch (strategy->btype)
    {
        case BAS_NORMAL:
 
            /*
             * Currently, GetAccessStrategy() returns NULL for
             * BufferAccessStrategyType BAS_NORMAL, so this case is
             * unreachable.
             */
            pg_unreachable();
            return IOCONTEXT_NORMAL;
        case BAS_BULKREAD:
            return IOCONTEXT_BULKREAD;
        case BAS_BULKWRITE:
            return IOCONTEXT_BULKWRITE;
        case BAS_VACUUM:
            return IOCONTEXT_VACUUM;
    }
 
    elog(ERROR, "unrecognized BufferAccessStrategyType: %d", strategy->btype);
    pg_unreachable();
}

References BAS_BULKREAD, BAS_BULKWRITE, BAS_NORMAL, BAS_VACUUM, BufferAccessStrategyData::btype, elog, ERROR, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, and pg_unreachable.

Referenced by AsyncReadBuffers(), ExtendBufferedRelShared(), PinBufferForBlock(), and WaitReadBuffers().

IssuePendingWritebacks()

void IssuePendingWritebacks	(	WritebackContext *	wb_context,
		IOContext	io_context
	)

Definition at line 6468 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(track_io_timing);
 
    /*
     * 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, INVALID_PROC_NUMBER);
        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, 0);
 
    wb_context->nr_pending = 0;
}

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

Referenced by BufferSync(), and ScheduleBufferTagForWriteback().

LocalBufferAlloc()

BufferDesc * LocalBufferAlloc	(	SMgrRelation	smgr,
		ForkNumber	forkNum,
		BlockNumber	blockNum,
		bool *	foundPtr
	)

Definition at line 119 of file localbuf.c.

{
    BufferTag   newTag;         /* identity of requested block */
    LocalBufferLookupEnt *hresult;
    BufferDesc *bufHdr;
    Buffer      victim_buffer;
    int         bufid;
    bool        found;
 
    InitBufferTag(&newTag, &smgr->smgr_rlocator.locator, forkNum, blockNum);
 
    /* Initialize local buffers if first request in this session */
    if (LocalBufHash == NULL)
        InitLocalBuffers();
 
    ResourceOwnerEnlarge(CurrentResourceOwner);
 
    /* See if the desired buffer already exists */
    hresult = (LocalBufferLookupEnt *)
        hash_search(LocalBufHash, &newTag, HASH_FIND, NULL);
 
    if (hresult)
    {
        bufid = hresult->id;
        bufHdr = GetLocalBufferDescriptor(bufid);
        Assert(BufferTagsEqual(&bufHdr->tag, &newTag));
 
        *foundPtr = PinLocalBuffer(bufHdr, true);
    }
    else
    {
        uint32      buf_state;
 
        victim_buffer = GetLocalVictimBuffer();
        bufid = -victim_buffer - 1;
        bufHdr = GetLocalBufferDescriptor(bufid);
 
        hresult = (LocalBufferLookupEnt *)
            hash_search(LocalBufHash, &newTag, HASH_ENTER, &found);
        if (found)              /* shouldn't happen */
            elog(ERROR, "local buffer hash table corrupted");
        hresult->id = bufid;
 
        /*
         * it's all ours now.
         */
        bufHdr->tag = newTag;
 
        buf_state = pg_atomic_read_u32(&bufHdr->state);
        buf_state &= ~(BUF_FLAG_MASK | BUF_USAGECOUNT_MASK);
        buf_state |= BM_TAG_VALID | BUF_USAGECOUNT_ONE;
        pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
 
        *foundPtr = false;
    }
 
    return bufHdr;
}

References Assert(), BM_TAG_VALID, BUF_FLAG_MASK, BUF_USAGECOUNT_MASK, BUF_USAGECOUNT_ONE, BufferTagsEqual(), CurrentResourceOwner, elog, ERROR, GetLocalBufferDescriptor(), GetLocalVictimBuffer(), HASH_ENTER, HASH_FIND, hash_search(), LocalBufferLookupEnt::id, InitBufferTag(), InitLocalBuffers(), LocalBufHash, RelFileLocatorBackend::locator, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), PinLocalBuffer(), ResourceOwnerEnlarge(), SMgrRelationData::smgr_rlocator, BufferDesc::state, and BufferDesc::tag.

Referenced by PinBufferForBlock().

LockBufHdr()

uint32 LockBufHdr

(

BufferDesc *

desc

)

Definition at line 6264 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(), buffer_stage_common(), BufferAlloc(), BufferGetLSNAtomic(), BufferSync(), ConditionalLockBufferForCleanup(), create_toy_buffer(), DropDatabaseBuffers(), DropRelationBuffers(), DropRelationsAllBuffers(), EvictAllUnpinnedBuffers(), EvictRelUnpinnedBuffers(), EvictUnpinnedBuffer(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), FlushBuffer(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetVictimBuffer(), InvalidateBuffer(), InvalidateVictimBuffer(), IsBufferCleanupOK(), LockBufferForCleanup(), MarkBufferDirtyHint(), MarkDirtyAllUnpinnedBuffers(), MarkDirtyRelUnpinnedBuffers(), MarkDirtyUnpinnedBuffer(), pg_buffercache_os_pages_internal(), pg_buffercache_pages(), StartBufferIO(), SyncOneBuffer(), TerminateBufferIO(), UnlockBuffers(), WaitIO(), and WakePinCountWaiter().

MarkLocalBufferDirty()

void MarkLocalBufferDirty

(

Buffer

buffer

)

Definition at line 491 of file localbuf.c.

{
    int         bufid;
    BufferDesc *bufHdr;
    uint32      buf_state;
 
    Assert(BufferIsLocal(buffer));
 
#ifdef LBDEBUG
    fprintf(stderr, "LB DIRTY %d\n", buffer);
#endif
 
    bufid = -buffer - 1;
 
    Assert(LocalRefCount[bufid] > 0);
 
    bufHdr = GetLocalBufferDescriptor(bufid);
 
    buf_state = pg_atomic_read_u32(&bufHdr->state);
 
    if (!(buf_state & BM_DIRTY))
        pgBufferUsage.local_blks_dirtied++;
 
    buf_state |= BM_DIRTY;
 
    pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
}

References Assert(), BM_DIRTY, BufferIsLocal, fprintf, GetLocalBufferDescriptor(), BufferUsage::local_blks_dirtied, LocalRefCount, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), pgBufferUsage, and BufferDesc::state.

Referenced by MarkBufferDirty(), and MarkBufferDirtyHint().

PinLocalBuffer()

bool PinLocalBuffer	(	BufferDesc *	buf_hdr,
		bool	adjust_usagecount
	)

Definition at line 805 of file localbuf.c.

{
    uint32      buf_state;
    Buffer      buffer = BufferDescriptorGetBuffer(buf_hdr);
    int         bufid = -buffer - 1;
 
    buf_state = pg_atomic_read_u32(&buf_hdr->state);
 
    if (LocalRefCount[bufid] == 0)
    {
        NLocalPinnedBuffers++;
        buf_state += BUF_REFCOUNT_ONE;
        if (adjust_usagecount &&
            BUF_STATE_GET_USAGECOUNT(buf_state) < BM_MAX_USAGE_COUNT)
        {
            buf_state += BUF_USAGECOUNT_ONE;
        }
        pg_atomic_unlocked_write_u32(&buf_hdr->state, buf_state);
 
        /*
         * See comment in PinBuffer().
         *
         * If the buffer isn't allocated yet, it'll be marked as defined in
         * GetLocalBufferStorage().
         */
        if (LocalBufHdrGetBlock(buf_hdr) != NULL)
            VALGRIND_MAKE_MEM_DEFINED(LocalBufHdrGetBlock(buf_hdr), BLCKSZ);
    }
    LocalRefCount[bufid]++;
    ResourceOwnerRememberBuffer(CurrentResourceOwner,
                                BufferDescriptorGetBuffer(buf_hdr));
 
    return buf_state & BM_VALID;
}

References BM_MAX_USAGE_COUNT, BM_VALID, BUF_REFCOUNT_ONE, BUF_STATE_GET_USAGECOUNT, BUF_USAGECOUNT_ONE, BufferDescriptorGetBuffer(), CurrentResourceOwner, LocalBufHdrGetBlock, LocalRefCount, NLocalPinnedBuffers, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), ResourceOwnerRememberBuffer(), BufferDesc::state, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by ExtendBufferedRelLocal(), FlushRelationBuffers(), GetLocalVictimBuffer(), LocalBufferAlloc(), and ReadRecentBuffer().

PrefetchLocalBuffer()

PrefetchBufferResult PrefetchLocalBuffer	(	SMgrRelation	smgr,
		ForkNumber	forkNum,
		BlockNumber	blockNum
	)

Definition at line 72 of file localbuf.c.

{
    PrefetchBufferResult result = {InvalidBuffer, false};
    BufferTag   newTag;         /* identity of requested block */
    LocalBufferLookupEnt *hresult;
 
    InitBufferTag(&newTag, &smgr->smgr_rlocator.locator, forkNum, blockNum);
 
    /* Initialize local buffers if first request in this session */
    if (LocalBufHash == NULL)
        InitLocalBuffers();
 
    /* See if the desired buffer already exists */
    hresult = (LocalBufferLookupEnt *)
        hash_search(LocalBufHash, &newTag, HASH_FIND, NULL);
 
    if (hresult)
    {
        /* Yes, so nothing to do */
        result.recent_buffer = -hresult->id - 1;
    }
    else
    {
#ifdef USE_PREFETCH
        /* Not in buffers, so initiate prefetch */
        if ((io_direct_flags & IO_DIRECT_DATA) == 0 &&
            smgrprefetch(smgr, forkNum, blockNum, 1))
        {
            result.initiated_io = true;
        }
#endif                          /* USE_PREFETCH */
    }
 
    return result;
}

References HASH_FIND, hash_search(), LocalBufferLookupEnt::id, InitBufferTag(), PrefetchBufferResult::initiated_io, InitLocalBuffers(), InvalidBuffer, IO_DIRECT_DATA, io_direct_flags, LocalBufHash, RelFileLocatorBackend::locator, PrefetchBufferResult::recent_buffer, SMgrRelationData::smgr_rlocator, and smgrprefetch().

Referenced by PrefetchBuffer().

ResourceOwnerForgetBuffer()

static void ResourceOwnerForgetBuffer ( ResourceOwner  owner, Buffer  buffer  )

inlinestatic

Definition at line 470 of file buf_internals.h.

{
    ResourceOwnerForget(owner, Int32GetDatum(buffer), &buffer_pin_resowner_desc);

References buffer_pin_resowner_desc, Int32GetDatum(), and ResourceOwnerForget().

Referenced by UnpinBuffer(), and UnpinLocalBuffer().

ResourceOwnerForgetBufferIO()

static void ResourceOwnerForgetBufferIO ( ResourceOwner  owner, Buffer  buffer  )

inlinestatic

Definition at line 480 of file buf_internals.h.

{
    ResourceOwnerForget(owner, Int32GetDatum(buffer), &buffer_io_resowner_desc);

References buffer_io_resowner_desc, Int32GetDatum(), and ResourceOwnerForget().

Referenced by buffer_call_start_io(), buffer_stage_common(), and TerminateBufferIO().

ResourceOwnerRememberBuffer()

static void ResourceOwnerRememberBuffer ( ResourceOwner  owner, Buffer  buffer  )

inlinestatic

Definition at line 465 of file buf_internals.h.

{
    ResourceOwnerRemember(owner, Int32GetDatum(buffer), &buffer_pin_resowner_desc);

References buffer_pin_resowner_desc, Int32GetDatum(), and ResourceOwnerRemember().

Referenced by IncrBufferRefCount(), PinBuffer(), PinLocalBuffer(), and TrackNewBufferPin().

ResourceOwnerRememberBufferIO()

static void ResourceOwnerRememberBufferIO ( ResourceOwner  owner, Buffer  buffer  )

inlinestatic

Definition at line 475 of file buf_internals.h.

{
    ResourceOwnerRemember(owner, Int32GetDatum(buffer), &buffer_io_resowner_desc);

References buffer_io_resowner_desc, Int32GetDatum(), and ResourceOwnerRemember().

Referenced by StartBufferIO().

ScheduleBufferTagForWriteback()

void ScheduleBufferTagForWriteback	(	WritebackContext *	wb_context,
		IOContext	io_context,
		BufferTag *	tag
	)

Definition at line 6418 of file bufmgr.c.

{
    PendingWriteback *pending;
 
    /*
     * As pg_flush_data() doesn't do anything with fsync disabled, there's no
     * point in tracking in that case.
     */
    if (io_direct_flags & IO_DIRECT_DATA ||
        !enableFsync)
        return;
 
    /*
     * Add buffer to the pending writeback array, unless writeback control is
     * disabled.
     */
    if (*wb_context->max_pending > 0)
    {
        Assert(*wb_context->max_pending <= WRITEBACK_MAX_PENDING_FLUSHES);
 
        pending = &wb_context->pending_writebacks[wb_context->nr_pending++];
 
        pending->tag = *tag;
    }
 
    /*
     * Perform pending flushes if the writeback limit is exceeded. This
     * includes the case where previously an item has been added, but control
     * is now disabled.
     */
    if (wb_context->nr_pending >= *wb_context->max_pending)
        IssuePendingWritebacks(wb_context, io_context);
}

References Assert(), enableFsync, IO_DIRECT_DATA, io_direct_flags, IssuePendingWritebacks(), WritebackContext::max_pending, WritebackContext::nr_pending, WritebackContext::pending_writebacks, PendingWriteback::tag, and WRITEBACK_MAX_PENDING_FLUSHES.

Referenced by GetVictimBuffer(), and SyncOneBuffer().

StartBufferIO()

bool StartBufferIO	(	BufferDesc *	buf,
		bool	forInput,
		bool	nowait
	)

Definition at line 6046 of file bufmgr.c.

{
    uint32      buf_state;
 
    ResourceOwnerEnlarge(CurrentResourceOwner);
 
    for (;;)
    {
        buf_state = LockBufHdr(buf);
 
        if (!(buf_state & BM_IO_IN_PROGRESS))
            break;
        UnlockBufHdr(buf);
        if (nowait)
            return false;
        WaitIO(buf);
    }
 
    /* Once we get here, there is definitely no I/O active on this buffer */
 
    /* Check if someone else already did the I/O */
    if (forInput ? (buf_state & BM_VALID) : !(buf_state & BM_DIRTY))
    {
        UnlockBufHdr(buf);
        return false;
    }
 
    UnlockBufHdrExt(buf, buf_state,
                    BM_IO_IN_PROGRESS, 0,
                    0);
 
    ResourceOwnerRememberBufferIO(CurrentResourceOwner,
                                  BufferDescriptorGetBuffer(buf));
 
    return true;
}

References BM_DIRTY, BM_IO_IN_PROGRESS, BM_VALID, buf, BufferDescriptorGetBuffer(), CurrentResourceOwner, LockBufHdr(), ResourceOwnerEnlarge(), ResourceOwnerRememberBufferIO(), UnlockBufHdr(), UnlockBufHdrExt(), and WaitIO().

Referenced by buffer_call_start_io(), ExtendBufferedRelShared(), FlushBuffer(), read_rel_block_ll(), ReadBuffersCanStartIOOnce(), and ZeroAndLockBuffer().

StartLocalBufferIO()

bool StartLocalBufferIO	(	BufferDesc *	bufHdr,
		bool	forInput,
		bool	nowait
	)

Definition at line 523 of file localbuf.c.

{
    uint32      buf_state;
 
    /*
     * With AIO the buffer could have IO in progress, e.g. when there are two
     * scans of the same relation. Either wait for the other IO or return
     * false.
     */
    if (pgaio_wref_valid(&bufHdr->io_wref))
    {
        PgAioWaitRef iow = bufHdr->io_wref;
 
        if (nowait)
            return false;
 
        pgaio_wref_wait(&iow);
    }
 
    /* Once we get here, there is definitely no I/O active on this buffer */
 
    /* Check if someone else already did the I/O */
    buf_state = pg_atomic_read_u32(&bufHdr->state);
    if (forInput ? (buf_state & BM_VALID) : !(buf_state & BM_DIRTY))
    {
        return false;
    }
 
    /* BM_IO_IN_PROGRESS isn't currently used for local buffers */
 
    /* local buffers don't track IO using resowners */
 
    return true;
}

References BM_DIRTY, BM_VALID, BufferDesc::io_wref, pg_atomic_read_u32(), pgaio_wref_valid(), pgaio_wref_wait(), and BufferDesc::state.

Referenced by buffer_call_start_io(), ExtendBufferedRelLocal(), FlushLocalBuffer(), read_rel_block_ll(), ReadBuffersCanStartIOOnce(), and ZeroAndLockBuffer().

StaticAssertDecl() [1/3]

StaticAssertDecl

(

)

StaticAssertDecl() [2/3]

StaticAssertDecl	(	BUF_REFCOUNT_BITS+BUF_USAGECOUNT_BITS+	BUF_FLAG_BITS = =32,
		"parts of buffer state space need to equal 32"
	)

StaticAssertDecl() [3/3]

StaticAssertDecl	(	MAX_BACKENDS_BITS<=	BUF_REFCOUNT_BITS,
		"MAX_BACKENDS_BITS needs to be <= BUF_REFCOUNT_BITS"
	)

StrategyGetBuffer()

BufferDesc * StrategyGetBuffer	(	BufferAccessStrategy	strategy,
		uint32 *	buf_state,
		bool *	from_ring
	)

Definition at line 174 of file freelist.c.

{
    BufferDesc *buf;
    int         bgwprocno;
    int         trycounter;
 
    *from_ring = false;
 
    /*
     * If given a strategy object, see whether it can select a buffer. We
     * assume strategy objects don't need buffer_strategy_lock.
     */
    if (strategy != NULL)
    {
        buf = GetBufferFromRing(strategy, buf_state);
        if (buf != NULL)
        {
            *from_ring = true;
            return buf;
        }
    }
 
    /*
     * If asked, we need to waken the bgwriter. Since we don't want to rely on
     * a spinlock for this we force a read from shared memory once, and then
     * set the latch based on that value. We need to go through that length
     * because otherwise bgwprocno might be reset while/after we check because
     * the compiler might just reread from memory.
     *
     * This can possibly set the latch of the wrong process if the bgwriter
     * dies in the wrong moment. But since PGPROC->procLatch is never
     * deallocated the worst consequence of that is that we set the latch of
     * some arbitrary process.
     */
    bgwprocno = INT_ACCESS_ONCE(StrategyControl->bgwprocno);
    if (bgwprocno != -1)
    {
        /* reset bgwprocno first, before setting the latch */
        StrategyControl->bgwprocno = -1;
 
        /*
         * Not acquiring ProcArrayLock here which is slightly icky. It's
         * actually fine because procLatch isn't ever freed, so we just can
         * potentially set the wrong process' (or no process') latch.
         */
        SetLatch(&ProcGlobal->allProcs[bgwprocno].procLatch);
    }
 
    /*
     * We count buffer allocation requests so that the bgwriter can estimate
     * the rate of buffer consumption.  Note that buffers recycled by a
     * strategy object are intentionally not counted here.
     */
    pg_atomic_fetch_add_u32(&StrategyControl->numBufferAllocs, 1);
 
    /* Use the "clock sweep" algorithm to find a free buffer */
    trycounter = NBuffers;
    for (;;)
    {
        uint32      old_buf_state;
        uint32      local_buf_state;
 
        buf = GetBufferDescriptor(ClockSweepTick());
 
        /*
         * Check whether the buffer can be used and pin it if so. Do this
         * using a CAS loop, to avoid having to lock the buffer header.
         */
        old_buf_state = pg_atomic_read_u32(&buf->state);
        for (;;)
        {
            local_buf_state = old_buf_state;
 
            /*
             * If the buffer is pinned or has a nonzero usage_count, we cannot
             * use it; decrement the usage_count (unless pinned) and keep
             * scanning.
             */
 
            if (BUF_STATE_GET_REFCOUNT(local_buf_state) != 0)
            {
                if (--trycounter == 0)
                {
                    /*
                     * We've scanned all the buffers without making any state
                     * changes, so all the buffers are pinned (or were when we
                     * looked at them). We could hope that someone will free
                     * one eventually, but it's probably better to fail than
                     * to risk getting stuck in an infinite loop.
                     */
                    elog(ERROR, "no unpinned buffers available");
                }
                break;
            }
 
            /* See equivalent code in PinBuffer() */
            if (unlikely(local_buf_state & BM_LOCKED))
            {
                old_buf_state = WaitBufHdrUnlocked(buf);
                continue;
            }
 
            if (BUF_STATE_GET_USAGECOUNT(local_buf_state) != 0)
            {
                local_buf_state -= BUF_USAGECOUNT_ONE;
 
                if (pg_atomic_compare_exchange_u32(&buf->state, &old_buf_state,
                                                   local_buf_state))
                {
                    trycounter = NBuffers;
                    break;
                }
            }
            else
            {
                /* pin the buffer if the CAS succeeds */
                local_buf_state += BUF_REFCOUNT_ONE;
 
                if (pg_atomic_compare_exchange_u32(&buf->state, &old_buf_state,
                                                   local_buf_state))
                {
                    /* Found a usable buffer */
                    if (strategy != NULL)
                        AddBufferToRing(strategy, buf);
                    *buf_state = local_buf_state;
 
                    TrackNewBufferPin(BufferDescriptorGetBuffer(buf));
 
                    return buf;
                }
            }
        }
    }
}

References AddBufferToRing(), PROC_HDR::allProcs, BufferStrategyControl::bgwprocno, BM_LOCKED, buf, BUF_REFCOUNT_ONE, BUF_STATE_GET_REFCOUNT, BUF_STATE_GET_USAGECOUNT, BUF_USAGECOUNT_ONE, BufferDescriptorGetBuffer(), ClockSweepTick(), elog, ERROR, GetBufferDescriptor(), GetBufferFromRing(), INT_ACCESS_ONCE, NBuffers, BufferStrategyControl::numBufferAllocs, pg_atomic_compare_exchange_u32(), pg_atomic_fetch_add_u32(), pg_atomic_read_u32(), ProcGlobal, PGPROC::procLatch, SetLatch(), StrategyControl, TrackNewBufferPin(), unlikely, and WaitBufHdrUnlocked().

Referenced by GetVictimBuffer().

StrategyInitialize()

void StrategyInitialize

(

bool

init

)

Definition at line 401 of file freelist.c.

{
    bool        found;
 
    /*
     * Initialize the shared buffer lookup hashtable.
     *
     * Since we can't tolerate running out of lookup table entries, we must be
     * sure to specify an adequate table size here.  The maximum steady-state
     * usage is of course NBuffers entries, but BufferAlloc() tries to insert
     * a new entry before deleting the old.  In principle this could be
     * happening in each partition concurrently, so we could need as many as
     * NBuffers + NUM_BUFFER_PARTITIONS entries.
     */
    InitBufTable(NBuffers + NUM_BUFFER_PARTITIONS);
 
    /*
     * Get or create the shared strategy control block
     */
    StrategyControl = (BufferStrategyControl *)
        ShmemInitStruct("Buffer Strategy Status",
                        sizeof(BufferStrategyControl),
                        &found);
 
    if (!found)
    {
        /*
         * Only done once, usually in postmaster
         */
        Assert(init);
 
        SpinLockInit(&StrategyControl->buffer_strategy_lock);
 
        /* Initialize the clock-sweep pointer */
        pg_atomic_init_u32(&StrategyControl->nextVictimBuffer, 0);
 
        /* Clear statistics */
        StrategyControl->completePasses = 0;
        pg_atomic_init_u32(&StrategyControl->numBufferAllocs, 0);
 
        /* No pending notification */
        StrategyControl->bgwprocno = -1;
    }
    else
        Assert(!init);
}

References Assert(), BufferStrategyControl::bgwprocno, BufferStrategyControl::buffer_strategy_lock, BufferStrategyControl::completePasses, init, InitBufTable(), NBuffers, BufferStrategyControl::nextVictimBuffer, NUM_BUFFER_PARTITIONS, BufferStrategyControl::numBufferAllocs, pg_atomic_init_u32(), ShmemInitStruct(), SpinLockInit, and StrategyControl.

Referenced by BufferManagerShmemInit().

StrategyNotifyBgWriter()

void StrategyNotifyBgWriter

(

int

bgwprocno

)

Definition at line 358 of file freelist.c.

{
    /*
     * We acquire buffer_strategy_lock just to ensure that the store appears
     * atomic to StrategyGetBuffer.  The bgwriter should call this rather
     * infrequently, so there's no performance penalty from being safe.
     */
    SpinLockAcquire(&StrategyControl->buffer_strategy_lock);
    StrategyControl->bgwprocno = bgwprocno;
    SpinLockRelease(&StrategyControl->buffer_strategy_lock);
}

References BufferStrategyControl::bgwprocno, BufferStrategyControl::buffer_strategy_lock, SpinLockAcquire, SpinLockRelease, and StrategyControl.

Referenced by BackgroundWriterMain().

StrategyRejectBuffer()

bool StrategyRejectBuffer	(	BufferAccessStrategy	strategy,
		BufferDesc *	buf,
		bool	from_ring
	)

Definition at line 787 of file freelist.c.

{
    /* We only do this in bulkread mode */
    if (strategy->btype != BAS_BULKREAD)
        return false;
 
    /* Don't muck with behavior of normal buffer-replacement strategy */
    if (!from_ring ||
        strategy->buffers[strategy->current] != BufferDescriptorGetBuffer(buf))
        return false;
 
    /*
     * Remove the dirty buffer from the ring; necessary to prevent infinite
     * loop if all ring members are dirty.
     */
    strategy->buffers[strategy->current] = InvalidBuffer;
 
    return true;
}

References BAS_BULKREAD, BufferAccessStrategyData::btype, buf, BufferDescriptorGetBuffer(), BufferAccessStrategyData::buffers, BufferAccessStrategyData::current, and InvalidBuffer.

Referenced by GetVictimBuffer().

StrategyShmemSize()

Size StrategyShmemSize

(

void

)

Definition at line 380 of file freelist.c.

{
    Size        size = 0;
 
    /* size of lookup hash table ... see comment in StrategyInitialize */
    size = add_size(size, BufTableShmemSize(NBuffers + NUM_BUFFER_PARTITIONS));
 
    /* size of the shared replacement strategy control block */
    size = add_size(size, MAXALIGN(sizeof(BufferStrategyControl)));
 
    return size;
}

References add_size(), BufTableShmemSize(), MAXALIGN, NBuffers, and NUM_BUFFER_PARTITIONS.

Referenced by BufferManagerShmemSize().

StrategySyncStart()

int StrategySyncStart	(	uint32 *	complete_passes,
		uint32 *	num_buf_alloc
	)

Definition at line 321 of file freelist.c.

{
    uint32      nextVictimBuffer;
    int         result;
 
    SpinLockAcquire(&StrategyControl->buffer_strategy_lock);
    nextVictimBuffer = pg_atomic_read_u32(&StrategyControl->nextVictimBuffer);
    result = nextVictimBuffer % NBuffers;
 
    if (complete_passes)
    {
        *complete_passes = StrategyControl->completePasses;
 
        /*
         * Additionally add the number of wraparounds that happened before
         * completePasses could be incremented. C.f. ClockSweepTick().
         */
        *complete_passes += nextVictimBuffer / NBuffers;
    }
 
    if (num_buf_alloc)
    {
        *num_buf_alloc = pg_atomic_exchange_u32(&StrategyControl->numBufferAllocs, 0);
    }
    SpinLockRelease(&StrategyControl->buffer_strategy_lock);
    return result;
}

References BufferStrategyControl::buffer_strategy_lock, BufferStrategyControl::completePasses, NBuffers, BufferStrategyControl::nextVictimBuffer, BufferStrategyControl::numBufferAllocs, pg_atomic_exchange_u32(), pg_atomic_read_u32(), SpinLockAcquire, SpinLockRelease, and StrategyControl.

Referenced by BgBufferSync().

TerminateBufferIO()

void TerminateBufferIO	(	BufferDesc *	buf,
		bool	clear_dirty,
		uint32	set_flag_bits,
		bool	forget_owner,
		bool	release_aio
	)

Definition at line 6104 of file bufmgr.c.

{
    uint32      buf_state;
    uint32      unset_flag_bits = 0;
    int         refcount_change = 0;
 
    buf_state = LockBufHdr(buf);
 
    Assert(buf_state & BM_IO_IN_PROGRESS);
    unset_flag_bits |= BM_IO_IN_PROGRESS;
 
    /* Clear earlier errors, if this IO failed, it'll be marked again */
    unset_flag_bits |= BM_IO_ERROR;
 
    if (clear_dirty && !(buf_state & BM_JUST_DIRTIED))
        unset_flag_bits |= BM_DIRTY | BM_CHECKPOINT_NEEDED;
 
    if (release_aio)
    {
        /* release ownership by the AIO subsystem */
        Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
        refcount_change = -1;
        pgaio_wref_clear(&buf->io_wref);
    }
 
    buf_state = UnlockBufHdrExt(buf, buf_state,
                                set_flag_bits, unset_flag_bits,
                                refcount_change);
 
    if (forget_owner)
        ResourceOwnerForgetBufferIO(CurrentResourceOwner,
                                    BufferDescriptorGetBuffer(buf));
 
    ConditionVariableBroadcast(BufferDescriptorGetIOCV(buf));
 
    /*
     * Support LockBufferForCleanup()
     *
     * We may have just released the last pin other than the waiter's. In most
     * cases, this backend holds another pin on the buffer. But, if, for
     * example, this backend is completing an IO issued by another backend, it
     * may be time to wake the waiter.
     */
    if (release_aio && (buf_state & BM_PIN_COUNT_WAITER))
        WakePinCountWaiter(buf);
}

References Assert(), BM_CHECKPOINT_NEEDED, BM_DIRTY, BM_IO_ERROR, BM_IO_IN_PROGRESS, BM_JUST_DIRTIED, BM_PIN_COUNT_WAITER, buf, BUF_STATE_GET_REFCOUNT, BufferDescriptorGetBuffer(), BufferDescriptorGetIOCV(), ConditionVariableBroadcast(), CurrentResourceOwner, LockBufHdr(), pgaio_wref_clear(), ResourceOwnerForgetBufferIO(), UnlockBufHdrExt(), and WakePinCountWaiter().

Referenced by AbortBufferIO(), buffer_call_terminate_io(), buffer_readv_complete_one(), ExtendBufferedRelShared(), FlushBuffer(), and ZeroAndLockBuffer().

TerminateLocalBufferIO()

void TerminateLocalBufferIO	(	BufferDesc *	bufHdr,
		bool	clear_dirty,
		uint32	set_flag_bits,
		bool	release_aio
	)

Definition at line 562 of file localbuf.c.

{
    /* Only need to adjust flags */
    uint32      buf_state = pg_atomic_read_u32(&bufHdr->state);
 
    /* BM_IO_IN_PROGRESS isn't currently used for local buffers */
 
    /* Clear earlier errors, if this IO failed, it'll be marked again */
    buf_state &= ~BM_IO_ERROR;
 
    if (clear_dirty)
        buf_state &= ~BM_DIRTY;
 
    if (release_aio)
    {
        /* release pin held by IO subsystem, see also buffer_stage_common() */
        Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
        buf_state -= BUF_REFCOUNT_ONE;
        pgaio_wref_clear(&bufHdr->io_wref);
    }
 
    buf_state |= set_flag_bits;
    pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
 
    /* local buffers don't track IO using resowners */
 
    /* local buffers don't use the IO CV, as no other process can see buffer */
 
    /* local buffers don't use BM_PIN_COUNT_WAITER, so no need to wake */
}

References Assert(), BUF_REFCOUNT_ONE, BUF_STATE_GET_REFCOUNT, BufferDesc::io_wref, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), pgaio_wref_clear(), and BufferDesc::state.

Referenced by buffer_call_terminate_io(), buffer_readv_complete_one(), FlushLocalBuffer(), and ZeroAndLockBuffer().

TrackNewBufferPin()

void TrackNewBufferPin ( Buffer  buf )

inline

Definition at line 3303 of file bufmgr.c.

{
    PrivateRefCountEntry *ref;
 
    ref = NewPrivateRefCountEntry(buf);
    ref->refcount++;
 
    ResourceOwnerRememberBuffer(CurrentResourceOwner, buf);
 
    /*
     * This is the first pin for this page by this backend, mark its page as
     * defined to valgrind. While the page contents might not actually be
     * valid yet, we don't currently guarantee that such pages are marked
     * undefined or non-accessible.
     *
     * It's not necessarily the prettiest to do this here, but otherwise we'd
     * need this block of code in multiple places.
     */
    VALGRIND_MAKE_MEM_DEFINED(BufHdrGetBlock(GetBufferDescriptor(buf - 1)),
                              BLCKSZ);
}

References buf, BufHdrGetBlock, CurrentResourceOwner, GetBufferDescriptor(), NewPrivateRefCountEntry(), PrivateRefCountEntry::refcount, ResourceOwnerRememberBuffer(), and VALGRIND_MAKE_MEM_DEFINED.

Referenced by GetBufferFromRing(), PinBuffer(), PinBuffer_Locked(), and StrategyGetBuffer().

UnlockBufHdr()

static void UnlockBufHdr ( BufferDesc *  desc )

inlinestatic

Definition at line 397 of file buf_internals.h.

{
    Assert(pg_atomic_read_u32(&desc->state) & BM_LOCKED);
 
    pg_atomic_fetch_sub_u32(&desc->state, BM_LOCKED);

References Assert(), BM_LOCKED, pg_atomic_fetch_sub_u32(), pg_atomic_read_u32(), and BufferDesc::state.

Referenced by AbortBufferIO(), apw_dump_now(), BufferGetLSNAtomic(), ConditionalLockBufferForCleanup(), DropDatabaseBuffers(), DropRelationBuffers(), DropRelationsAllBuffers(), EvictRelUnpinnedBuffers(), EvictUnpinnedBufferInternal(), FindAndDropRelationBuffers(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetVictimBuffer(), InvalidateBuffer(), InvalidateVictimBuffer(), IsBufferCleanupOK(), LockBufferForCleanup(), MarkDirtyRelUnpinnedBuffers(), MarkDirtyUnpinnedBufferInternal(), pg_buffercache_os_pages_internal(), pg_buffercache_pages(), StartBufferIO(), SyncOneBuffer(), WaitIO(), and WakePinCountWaiter().

UnlockBufHdrExt()

static uint32 UnlockBufHdrExt ( BufferDesc *  desc, uint32  old_buf_state, uint32  set_bits, uint32  unset_bits, int  refcount_change  )

inlinestatic

Definition at line 413 of file buf_internals.h.

{
    for (;;)
    {
        uint32      buf_state = old_buf_state;
 
        Assert(buf_state & BM_LOCKED);
 
        buf_state |= set_bits;
        buf_state &= ~unset_bits;
        buf_state &= ~BM_LOCKED;
 
        if (refcount_change != 0)
            buf_state += BUF_REFCOUNT_ONE * refcount_change;
 
        if (pg_atomic_compare_exchange_u32(&desc->state, &old_buf_state,
                                           buf_state))
        {
            return old_buf_state;
        }
    }

References Assert(), BM_LOCKED, BUF_REFCOUNT_ONE, pg_atomic_compare_exchange_u32(), and BufferDesc::state.

Referenced by buffer_stage_common(), BufferAlloc(), BufferSync(), create_toy_buffer(), ExtendBufferedRelShared(), FlushBuffer(), InvalidateBuffer(), InvalidateVictimBuffer(), LockBufferForCleanup(), MarkBufferDirtyHint(), PinBuffer_Locked(), StartBufferIO(), TerminateBufferIO(), UnlockBuffers(), and WakePinCountWaiter().

UnpinLocalBuffer()

void UnpinLocalBuffer

(

Buffer

buffer

)

Definition at line 841 of file localbuf.c.

{
    UnpinLocalBufferNoOwner(buffer);
    ResourceOwnerForgetBuffer(CurrentResourceOwner, buffer);
}

References CurrentResourceOwner, ResourceOwnerForgetBuffer(), and UnpinLocalBufferNoOwner().

Referenced by ExtendBufferedRelLocal(), FlushRelationBuffers(), ReleaseAndReadBuffer(), and ReleaseBuffer().

UnpinLocalBufferNoOwner()

void UnpinLocalBufferNoOwner

(

Buffer

buffer

)

Definition at line 848 of file localbuf.c.

{
    int         buffid = -buffer - 1;
 
    Assert(BufferIsLocal(buffer));
    Assert(LocalRefCount[buffid] > 0);
    Assert(NLocalPinnedBuffers > 0);
 
    if (--LocalRefCount[buffid] == 0)
    {
        BufferDesc *buf_hdr = GetLocalBufferDescriptor(buffid);
        uint32      buf_state;
 
        NLocalPinnedBuffers--;
 
        buf_state = pg_atomic_read_u32(&buf_hdr->state);
        Assert(BUF_STATE_GET_REFCOUNT(buf_state) > 0);
        buf_state -= BUF_REFCOUNT_ONE;
        pg_atomic_unlocked_write_u32(&buf_hdr->state, buf_state);
 
        /* see comment in UnpinBufferNoOwner */
        VALGRIND_MAKE_MEM_NOACCESS(LocalBufHdrGetBlock(buf_hdr), BLCKSZ);
    }
}

References Assert(), BUF_REFCOUNT_ONE, BUF_STATE_GET_REFCOUNT, BufferIsLocal, GetLocalBufferDescriptor(), LocalBufHdrGetBlock, LocalRefCount, NLocalPinnedBuffers, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), BufferDesc::state, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by ResOwnerReleaseBufferPin(), and UnpinLocalBuffer().

WaitBufHdrUnlocked()

uint32 WaitBufHdrUnlocked

(

BufferDesc *

buf

)

Definition at line 6294 of file bufmgr.c.

{
    SpinDelayStatus delayStatus;
    uint32      buf_state;
 
    init_local_spin_delay(&delayStatus);
 
    buf_state = pg_atomic_read_u32(&buf->state);
 
    while (buf_state & BM_LOCKED)
    {
        perform_spin_delay(&delayStatus);
        buf_state = pg_atomic_read_u32(&buf->state);
    }
 
    finish_spin_delay(&delayStatus);
 
    return buf_state;
}

References BM_LOCKED, buf, finish_spin_delay(), init_local_spin_delay, perform_spin_delay(), and pg_atomic_read_u32().

Referenced by GetBufferFromRing(), MarkBufferDirty(), PinBuffer(), and StrategyGetBuffer().

WritebackContextInit()

void WritebackContextInit	(	WritebackContext *	context,
		int *	max_pending
	)

Definition at line 6406 of file bufmgr.c.

{
    Assert(*max_pending <= WRITEBACK_MAX_PENDING_FLUSHES);
 
    context->max_pending = max_pending;
    context->nr_pending = 0;
}

References Assert(), WritebackContext::max_pending, WritebackContext::nr_pending, and WRITEBACK_MAX_PENDING_FLUSHES.

Referenced by BackgroundWriterMain(), BufferManagerShmemInit(), and BufferSync().

Variable Documentation

BackendWritebackContext

PGDLLIMPORT WritebackContext BackendWritebackContext

extern

Definition at line 24 of file buf_init.c.

Referenced by BufferManagerShmemInit(), and GetVictimBuffer().

buffer_io_resowner_desc

PGDLLIMPORT const ResourceOwnerDesc buffer_io_resowner_desc

extern

Definition at line 235 of file bufmgr.c.

Referenced by ResourceOwnerForgetBufferIO(), and ResourceOwnerRememberBufferIO().

buffer_pin_resowner_desc

PGDLLIMPORT const ResourceOwnerDesc buffer_pin_resowner_desc

extern

Definition at line 244 of file bufmgr.c.

Referenced by ResourceOwnerForgetBuffer(), and ResourceOwnerRememberBuffer().

BufferDescriptors

PGDLLIMPORT BufferDescPadded* BufferDescriptors

extern

Definition at line 21 of file buf_init.c.

Referenced by BufferManagerShmemInit(), and GetBufferDescriptor().

BufferIOCVArray

PGDLLIMPORT ConditionVariableMinimallyPadded* BufferIOCVArray

extern

Definition at line 23 of file buf_init.c.

Referenced by BufferDescriptorGetIOCV(), and BufferManagerShmemInit().

CkptBufferIds

PGDLLIMPORT CkptSortItem* CkptBufferIds

extern

Definition at line 25 of file buf_init.c.

Referenced by BufferManagerShmemInit(), and BufferSync().

LocalBufferDescriptors

PGDLLIMPORT BufferDesc* LocalBufferDescriptors

extern

Definition at line 47 of file localbuf.c.

Referenced by GetLocalBufferDescriptor(), and InitLocalBuffers().