pg_buffercache_pages.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "port/pg_numa.h"
#include "storage/buf_internals.h"
#include "storage/bufmgr.h"
#include "utils/rel.h"
#include "utils/tuplestore.h"

Include dependency graph for pg_buffercache_pages.c:

Go to the source code of this file.

Data Structures
struct	BufferCacheOsPagesRec
struct	BufferCacheOsPagesContext

Macros
#define	NUM_BUFFERCACHE_PAGES_MIN_ELEM   8
#define	NUM_BUFFERCACHE_PAGES_ELEM   9
#define	NUM_BUFFERCACHE_SUMMARY_ELEM   5
#define	NUM_BUFFERCACHE_USAGE_COUNTS_ELEM   4
#define	NUM_BUFFERCACHE_EVICT_ELEM   2
#define	NUM_BUFFERCACHE_EVICT_RELATION_ELEM   3
#define	NUM_BUFFERCACHE_EVICT_ALL_ELEM   3
#define	NUM_BUFFERCACHE_MARK_DIRTY_ELEM   2
#define	NUM_BUFFERCACHE_MARK_DIRTY_RELATION_ELEM   3
#define	NUM_BUFFERCACHE_MARK_DIRTY_ALL_ELEM   3
#define	NUM_BUFFERCACHE_OS_PAGES_ELEM   3

Functions
	PG_MODULE_MAGIC_EXT (.name="pg_buffercache",.version=PG_VERSION)
	PG_FUNCTION_INFO_V1 (pg_buffercache_pages)
	PG_FUNCTION_INFO_V1 (pg_buffercache_os_pages)
	PG_FUNCTION_INFO_V1 (pg_buffercache_numa_pages)
	PG_FUNCTION_INFO_V1 (pg_buffercache_summary)
	PG_FUNCTION_INFO_V1 (pg_buffercache_usage_counts)
	PG_FUNCTION_INFO_V1 (pg_buffercache_evict)
	PG_FUNCTION_INFO_V1 (pg_buffercache_evict_relation)
	PG_FUNCTION_INFO_V1 (pg_buffercache_evict_all)
	PG_FUNCTION_INFO_V1 (pg_buffercache_mark_dirty)
	PG_FUNCTION_INFO_V1 (pg_buffercache_mark_dirty_relation)
	PG_FUNCTION_INFO_V1 (pg_buffercache_mark_dirty_all)
Datum	pg_buffercache_pages (PG_FUNCTION_ARGS)
static Datum	pg_buffercache_os_pages_internal (FunctionCallInfo fcinfo, bool include_numa)
Datum	pg_buffercache_os_pages (PG_FUNCTION_ARGS)
Datum	pg_buffercache_numa_pages (PG_FUNCTION_ARGS)
Datum	pg_buffercache_summary (PG_FUNCTION_ARGS)
Datum	pg_buffercache_usage_counts (PG_FUNCTION_ARGS)
static void	pg_buffercache_superuser_check (char *func_name)
Datum	pg_buffercache_evict (PG_FUNCTION_ARGS)
Datum	pg_buffercache_evict_relation (PG_FUNCTION_ARGS)
Datum	pg_buffercache_evict_all (PG_FUNCTION_ARGS)
Datum	pg_buffercache_mark_dirty (PG_FUNCTION_ARGS)
Datum	pg_buffercache_mark_dirty_relation (PG_FUNCTION_ARGS)
Datum	pg_buffercache_mark_dirty_all (PG_FUNCTION_ARGS)

Variables
static bool	firstNumaTouch = true

Macro Definition Documentation

NUM_BUFFERCACHE_EVICT_ALL_ELEM

#define NUM_BUFFERCACHE_EVICT_ALL_ELEM   3

Definition at line 28 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_EVICT_ELEM

#define NUM_BUFFERCACHE_EVICT_ELEM   2

Definition at line 26 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_EVICT_RELATION_ELEM

#define NUM_BUFFERCACHE_EVICT_RELATION_ELEM   3

Definition at line 27 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_MARK_DIRTY_ALL_ELEM

#define NUM_BUFFERCACHE_MARK_DIRTY_ALL_ELEM   3

Definition at line 31 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_MARK_DIRTY_ELEM

#define NUM_BUFFERCACHE_MARK_DIRTY_ELEM   2

Definition at line 29 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_MARK_DIRTY_RELATION_ELEM

#define NUM_BUFFERCACHE_MARK_DIRTY_RELATION_ELEM   3

Definition at line 30 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_OS_PAGES_ELEM

#define NUM_BUFFERCACHE_OS_PAGES_ELEM   3

Definition at line 33 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_PAGES_ELEM

#define NUM_BUFFERCACHE_PAGES_ELEM   9

Definition at line 23 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_PAGES_MIN_ELEM

#define NUM_BUFFERCACHE_PAGES_MIN_ELEM   8

Definition at line 22 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_SUMMARY_ELEM

#define NUM_BUFFERCACHE_SUMMARY_ELEM   5

Definition at line 24 of file pg_buffercache_pages.c.

NUM_BUFFERCACHE_USAGE_COUNTS_ELEM

#define NUM_BUFFERCACHE_USAGE_COUNTS_ELEM   4

Definition at line 25 of file pg_buffercache_pages.c.

Function Documentation

pg_buffercache_evict()

Datum pg_buffercache_evict

(

PG_FUNCTION_ARGS

)

Definition at line 647 of file pg_buffercache_pages.c.

{
    Datum       result;
    TupleDesc   tupledesc;
    HeapTuple   tuple;
    Datum       values[NUM_BUFFERCACHE_EVICT_ELEM];
    bool        nulls[NUM_BUFFERCACHE_EVICT_ELEM] = {0};
 
    Buffer      buf = PG_GETARG_INT32(0);
    bool        buffer_flushed;
 
    if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    pg_buffercache_superuser_check("pg_buffercache_evict");
 
    if (buf < 1 || buf > NBuffers)
        elog(ERROR, "bad buffer ID: %d", buf);
 
    values[0] = BoolGetDatum(EvictUnpinnedBuffer(buf, &buffer_flushed));
    values[1] = BoolGetDatum(buffer_flushed);
 
    tuple = heap_form_tuple(tupledesc, values, nulls);
    result = HeapTupleGetDatum(tuple);
 
    PG_RETURN_DATUM(result);
}

References BoolGetDatum(), buf, elog, ERROR, EvictUnpinnedBuffer(), fb(), get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), NBuffers, NUM_BUFFERCACHE_EVICT_ELEM, pg_buffercache_superuser_check(), PG_GETARG_INT32, PG_RETURN_DATUM, result, TYPEFUNC_COMPOSITE, and values.

pg_buffercache_evict_all()

Datum pg_buffercache_evict_all

(

PG_FUNCTION_ARGS

)

Definition at line 729 of file pg_buffercache_pages.c.

{
    Datum       result;
    TupleDesc   tupledesc;
    HeapTuple   tuple;
    Datum       values[NUM_BUFFERCACHE_EVICT_ALL_ELEM];
    bool        nulls[NUM_BUFFERCACHE_EVICT_ALL_ELEM] = {0};
 
    int32       buffers_evicted = 0;
    int32       buffers_flushed = 0;
    int32       buffers_skipped = 0;
 
    if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    pg_buffercache_superuser_check("pg_buffercache_evict_all");
 
    EvictAllUnpinnedBuffers(&buffers_evicted, &buffers_flushed,
                            &buffers_skipped);
 
    values[0] = Int32GetDatum(buffers_evicted);
    values[1] = Int32GetDatum(buffers_flushed);
    values[2] = Int32GetDatum(buffers_skipped);
 
    tuple = heap_form_tuple(tupledesc, values, nulls);
    result = HeapTupleGetDatum(tuple);
 
    PG_RETURN_DATUM(result);
}

References elog, ERROR, EvictAllUnpinnedBuffers(), fb(), get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), Int32GetDatum(), NUM_BUFFERCACHE_EVICT_ALL_ELEM, pg_buffercache_superuser_check(), PG_RETURN_DATUM, result, TYPEFUNC_COMPOSITE, and values.

pg_buffercache_evict_relation()

Datum pg_buffercache_evict_relation

(

PG_FUNCTION_ARGS

)

Definition at line 679 of file pg_buffercache_pages.c.

{
    Datum       result;
    TupleDesc   tupledesc;
    HeapTuple   tuple;
    Datum       values[NUM_BUFFERCACHE_EVICT_RELATION_ELEM];
    bool        nulls[NUM_BUFFERCACHE_EVICT_RELATION_ELEM] = {0};
 
    Oid         relOid;
    Relation    rel;
 
    int32       buffers_evicted = 0;
    int32       buffers_flushed = 0;
    int32       buffers_skipped = 0;
 
    if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    pg_buffercache_superuser_check("pg_buffercache_evict_relation");
 
    relOid = PG_GETARG_OID(0);
 
    rel = relation_open(relOid, AccessShareLock);
 
    if (RelationUsesLocalBuffers(rel))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("relation uses local buffers, %s() is intended to be used for shared buffers only",
                        "pg_buffercache_evict_relation")));
 
    EvictRelUnpinnedBuffers(rel, &buffers_evicted, &buffers_flushed,
                            &buffers_skipped);
 
    relation_close(rel, AccessShareLock);
 
    values[0] = Int32GetDatum(buffers_evicted);
    values[1] = Int32GetDatum(buffers_flushed);
    values[2] = Int32GetDatum(buffers_skipped);
 
    tuple = heap_form_tuple(tupledesc, values, nulls);
    result = HeapTupleGetDatum(tuple);
 
    PG_RETURN_DATUM(result);
}

References AccessShareLock, elog, ereport, errcode(), errmsg, ERROR, EvictRelUnpinnedBuffers(), fb(), get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), Int32GetDatum(), NUM_BUFFERCACHE_EVICT_RELATION_ELEM, pg_buffercache_superuser_check(), PG_GETARG_OID, PG_RETURN_DATUM, relation_close(), relation_open(), RelationUsesLocalBuffers, result, TYPEFUNC_COMPOSITE, and values.

pg_buffercache_mark_dirty()

Datum pg_buffercache_mark_dirty

(

PG_FUNCTION_ARGS

)

Definition at line 763 of file pg_buffercache_pages.c.

{
 
    Datum       result;
    TupleDesc   tupledesc;
    HeapTuple   tuple;
    Datum       values[NUM_BUFFERCACHE_MARK_DIRTY_ELEM];
    bool        nulls[NUM_BUFFERCACHE_MARK_DIRTY_ELEM] = {0};
 
    Buffer      buf = PG_GETARG_INT32(0);
    bool        buffer_already_dirty;
 
    if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    pg_buffercache_superuser_check("pg_buffercache_mark_dirty");
 
    if (buf < 1 || buf > NBuffers)
        elog(ERROR, "bad buffer ID: %d", buf);
 
    values[0] = BoolGetDatum(MarkDirtyUnpinnedBuffer(buf, &buffer_already_dirty));
    values[1] = BoolGetDatum(buffer_already_dirty);
 
    tuple = heap_form_tuple(tupledesc, values, nulls);
    result = HeapTupleGetDatum(tuple);
 
    PG_RETURN_DATUM(result);
}

References BoolGetDatum(), buf, elog, ERROR, fb(), get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), MarkDirtyUnpinnedBuffer(), NBuffers, NUM_BUFFERCACHE_MARK_DIRTY_ELEM, pg_buffercache_superuser_check(), PG_GETARG_INT32, PG_RETURN_DATUM, result, TYPEFUNC_COMPOSITE, and values.

pg_buffercache_mark_dirty_all()

Datum pg_buffercache_mark_dirty_all

(

PG_FUNCTION_ARGS

)

Definition at line 845 of file pg_buffercache_pages.c.

{
    Datum       result;
    TupleDesc   tupledesc;
    HeapTuple   tuple;
    Datum       values[NUM_BUFFERCACHE_MARK_DIRTY_ALL_ELEM];
    bool        nulls[NUM_BUFFERCACHE_MARK_DIRTY_ALL_ELEM] = {0};
 
    int32       buffers_already_dirty = 0;
    int32       buffers_dirtied = 0;
    int32       buffers_skipped = 0;
 
    if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    pg_buffercache_superuser_check("pg_buffercache_mark_dirty_all");
 
    MarkDirtyAllUnpinnedBuffers(&buffers_dirtied, &buffers_already_dirty,
                                &buffers_skipped);
 
    values[0] = Int32GetDatum(buffers_dirtied);
    values[1] = Int32GetDatum(buffers_already_dirty);
    values[2] = Int32GetDatum(buffers_skipped);
 
    tuple = heap_form_tuple(tupledesc, values, nulls);
    result = HeapTupleGetDatum(tuple);
 
    PG_RETURN_DATUM(result);
}

References elog, ERROR, fb(), get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), Int32GetDatum(), MarkDirtyAllUnpinnedBuffers(), NUM_BUFFERCACHE_MARK_DIRTY_ALL_ELEM, pg_buffercache_superuser_check(), PG_RETURN_DATUM, result, TYPEFUNC_COMPOSITE, and values.

pg_buffercache_mark_dirty_relation()

Datum pg_buffercache_mark_dirty_relation

(

PG_FUNCTION_ARGS

)

Definition at line 796 of file pg_buffercache_pages.c.

{
    Datum       result;
    TupleDesc   tupledesc;
    HeapTuple   tuple;
    Datum       values[NUM_BUFFERCACHE_MARK_DIRTY_RELATION_ELEM];
    bool        nulls[NUM_BUFFERCACHE_MARK_DIRTY_RELATION_ELEM] = {0};
 
    Oid         relOid;
    Relation    rel;
 
    int32       buffers_already_dirty = 0;
    int32       buffers_dirtied = 0;
    int32       buffers_skipped = 0;
 
    if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    pg_buffercache_superuser_check("pg_buffercache_mark_dirty_relation");
 
    relOid = PG_GETARG_OID(0);
 
    rel = relation_open(relOid, AccessShareLock);
 
    if (RelationUsesLocalBuffers(rel))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("relation uses local buffers, %s() is intended to be used for shared buffers only",
                        "pg_buffercache_mark_dirty_relation")));
 
    MarkDirtyRelUnpinnedBuffers(rel, &buffers_dirtied, &buffers_already_dirty,
                                &buffers_skipped);
 
    relation_close(rel, AccessShareLock);
 
    values[0] = Int32GetDatum(buffers_dirtied);
    values[1] = Int32GetDatum(buffers_already_dirty);
    values[2] = Int32GetDatum(buffers_skipped);
 
    tuple = heap_form_tuple(tupledesc, values, nulls);
    result = HeapTupleGetDatum(tuple);
 
    PG_RETURN_DATUM(result);
}

References AccessShareLock, elog, ereport, errcode(), errmsg, ERROR, fb(), get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), Int32GetDatum(), MarkDirtyRelUnpinnedBuffers(), NUM_BUFFERCACHE_MARK_DIRTY_RELATION_ELEM, pg_buffercache_superuser_check(), PG_GETARG_OID, PG_RETURN_DATUM, relation_close(), relation_open(), RelationUsesLocalBuffers, result, TYPEFUNC_COMPOSITE, and values.

pg_buffercache_numa_pages()

Datum pg_buffercache_numa_pages

(

PG_FUNCTION_ARGS

)

Definition at line 514 of file pg_buffercache_pages.c.

{
    /* Call internal function with include_numa=true */
    return pg_buffercache_os_pages_internal(fcinfo, true);
}

References pg_buffercache_os_pages_internal().

pg_buffercache_os_pages()

Datum pg_buffercache_os_pages

(

PG_FUNCTION_ARGS

)

Definition at line 502 of file pg_buffercache_pages.c.

{
    bool        include_numa;
 
    /* Get the boolean parameter that controls the NUMA behavior. */
    include_numa = PG_GETARG_BOOL(0);
 
    return pg_buffercache_os_pages_internal(fcinfo, include_numa);
}

References pg_buffercache_os_pages_internal(), and PG_GETARG_BOOL.

pg_buffercache_os_pages_internal()

static Datum pg_buffercache_os_pages_internal ( FunctionCallInfo  fcinfo, bool  include_numa  )

static

Definition at line 230 of file pg_buffercache_pages.c.

{
    FuncCallContext *funcctx;
    MemoryContext oldcontext;
    BufferCacheOsPagesContext *fctx;    /* User function context. */
    TupleDesc   tupledesc;
    TupleDesc   expected_tupledesc;
    HeapTuple   tuple;
    Datum       result;
 
    if (SRF_IS_FIRSTCALL())
    {
        int         i,
                    idx;
        Size        os_page_size;
        int         pages_per_buffer;
        int        *os_page_status = NULL;
        uint64      os_page_count = 0;
        int         max_entries;
        char       *startptr,
                   *endptr;
 
        /* If NUMA information is requested, initialize NUMA support. */
        if (include_numa && pg_numa_init() == -1)
            elog(ERROR, "libnuma initialization failed or NUMA is not supported on this platform");
 
        /*
         * The database block size and OS memory page size are unlikely to be
         * the same. The block size is 1-32KB, the memory page size depends on
         * platform. On x86 it's usually 4KB, on ARM it's 4KB or 64KB, but
         * there are also features like THP etc. Moreover, we don't quite know
         * how the pages and buffers "align" in memory - the buffers may be
         * shifted in some way, using more memory pages than necessary.
         *
         * So we need to be careful about mapping buffers to memory pages. We
         * calculate the maximum number of pages a buffer might use, so that
         * we allocate enough space for the entries. And then we count the
         * actual number of entries as we scan the buffers.
         *
         * This information is needed before calling move_pages() for NUMA
         * node id inquiry.
         */
        os_page_size = pg_get_shmem_pagesize();
 
        /*
         * The pages and block size is expected to be 2^k, so one divides the
         * other (we don't know in which direction). This does not say
         * anything about relative alignment of pages/buffers.
         */
        Assert((os_page_size % BLCKSZ == 0) || (BLCKSZ % os_page_size == 0));
 
        if (include_numa)
        {
            void      **os_page_ptrs = NULL;
 
            /*
             * How many addresses we are going to query?  Simply get the page
             * for the first buffer, and first page after the last buffer, and
             * count the pages from that.
             */
            startptr = (char *) TYPEALIGN_DOWN(os_page_size,
                                               BufferGetBlock(1));
            endptr = (char *) TYPEALIGN(os_page_size,
                                        (char *) BufferGetBlock(NBuffers) + BLCKSZ);
            os_page_count = (endptr - startptr) / os_page_size;
 
            /* Used to determine the NUMA node for all OS pages at once */
            os_page_ptrs = palloc0_array(void *, os_page_count);
            os_page_status = palloc_array(int, os_page_count);
 
            /*
             * Fill pointers for all the memory pages.  This loop stores and
             * touches (if needed) addresses into os_page_ptrs[] as input to
             * one big move_pages(2) inquiry system call, as done in
             * pg_numa_query_pages().
             */
            idx = 0;
            for (char *ptr = startptr; ptr < endptr; ptr += os_page_size)
            {
                os_page_ptrs[idx++] = ptr;
 
                /* Only need to touch memory once per backend process lifetime */
                if (firstNumaTouch)
                    pg_numa_touch_mem_if_required(ptr);
            }
 
            Assert(idx == os_page_count);
 
            elog(DEBUG1, "NUMA: NBuffers=%d os_page_count=" UINT64_FORMAT " "
                 "os_page_size=%zu", NBuffers, os_page_count, os_page_size);
 
            /*
             * If we ever get 0xff back from kernel inquiry, then we probably
             * have bug in our buffers to OS page mapping code here.
             */
            memset(os_page_status, 0xff, sizeof(int) * os_page_count);
 
            /* Query NUMA status for all the pointers */
            if (pg_numa_query_pages(0, os_page_count, os_page_ptrs, os_page_status) == -1)
                elog(ERROR, "failed NUMA pages inquiry: %m");
        }
 
        /* Initialize the multi-call context, load entries about buffers */
 
        funcctx = SRF_FIRSTCALL_INIT();
 
        /* Switch context when allocating stuff to be used in later calls */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /* Create a user function context for cross-call persistence */
        fctx = palloc_object(BufferCacheOsPagesContext);
 
        if (get_call_result_type(fcinfo, NULL, &expected_tupledesc) != TYPEFUNC_COMPOSITE)
            elog(ERROR, "return type must be a row type");
 
        if (expected_tupledesc->natts != NUM_BUFFERCACHE_OS_PAGES_ELEM)
            elog(ERROR, "incorrect number of output arguments");
 
        /* Construct a tuple descriptor for the result rows. */
        tupledesc = CreateTemplateTupleDesc(expected_tupledesc->natts);
        TupleDescInitEntry(tupledesc, (AttrNumber) 1, "bufferid",
                           INT4OID, -1, 0);
        TupleDescInitEntry(tupledesc, (AttrNumber) 2, "os_page_num",
                           INT8OID, -1, 0);
        TupleDescInitEntry(tupledesc, (AttrNumber) 3, "numa_node",
                           INT4OID, -1, 0);
 
        TupleDescFinalize(tupledesc);
        fctx->tupdesc = BlessTupleDesc(tupledesc);
        fctx->include_numa = include_numa;
 
        /*
         * Each buffer needs at least one entry, but it might be offset in
         * some way, and use one extra entry. So we allocate space for the
         * maximum number of entries we might need, and then count the exact
         * number as we're walking buffers. That way we can do it in one pass,
         * without reallocating memory.
         */
        pages_per_buffer = Max(1, BLCKSZ / os_page_size) + 1;
        max_entries = NBuffers * pages_per_buffer;
 
        /* Allocate entries for BufferCacheOsPagesRec records. */
        fctx->record = (BufferCacheOsPagesRec *)
            MemoryContextAllocHuge(CurrentMemoryContext,
                                   sizeof(BufferCacheOsPagesRec) * max_entries);
 
        /* Return to original context when allocating transient memory */
        MemoryContextSwitchTo(oldcontext);
 
        if (include_numa && firstNumaTouch)
            elog(DEBUG1, "NUMA: page-faulting the buffercache for proper NUMA readouts");
 
        /*
         * Scan through all the buffers, saving the relevant fields in the
         * fctx->record structure.
         *
         * We don't hold the partition locks, so we don't get a consistent
         * snapshot across all buffers, but we do grab the buffer header
         * locks, so the information of each buffer is self-consistent.
         */
        startptr = (char *) TYPEALIGN_DOWN(os_page_size, (char *) BufferGetBlock(1));
        idx = 0;
        for (i = 0; i < NBuffers; i++)
        {
            char       *buffptr = (char *) BufferGetBlock(i + 1);
            BufferDesc *bufHdr;
            uint32      bufferid;
            int32       page_num;
            char       *startptr_buff,
                       *endptr_buff;
 
            CHECK_FOR_INTERRUPTS();
 
            bufHdr = GetBufferDescriptor(i);
 
            /* Lock each buffer header before inspecting. */
            LockBufHdr(bufHdr);
            bufferid = BufferDescriptorGetBuffer(bufHdr);
            UnlockBufHdr(bufHdr);
 
            /* start of the first page of this buffer */
            startptr_buff = (char *) TYPEALIGN_DOWN(os_page_size, buffptr);
 
            /* end of the buffer (no need to align to memory page) */
            endptr_buff = buffptr + BLCKSZ;
 
            Assert(startptr_buff < endptr_buff);
 
            /* calculate ID of the first page for this buffer */
            page_num = (startptr_buff - startptr) / os_page_size;
 
            /* Add an entry for each OS page overlapping with this buffer. */
            for (char *ptr = startptr_buff; ptr < endptr_buff; ptr += os_page_size)
            {
                fctx->record[idx].bufferid = bufferid;
                fctx->record[idx].page_num = page_num;
                fctx->record[idx].numa_node = include_numa ? os_page_status[page_num] : -1;
 
                /* advance to the next entry/page */
                ++idx;
                ++page_num;
            }
        }
 
        Assert(idx <= max_entries);
 
        if (include_numa)
            Assert(idx >= os_page_count);
 
        /* Set max calls and remember the user function context. */
        funcctx->max_calls = idx;
        funcctx->user_fctx = fctx;
 
        /* Remember this backend touched the pages (only relevant for NUMA) */
        if (include_numa)
            firstNumaTouch = false;
    }
 
    funcctx = SRF_PERCALL_SETUP();
 
    /* Get the saved state */
    fctx = funcctx->user_fctx;
 
    if (funcctx->call_cntr < funcctx->max_calls)
    {
        uint32      i = funcctx->call_cntr;
        Datum       values[NUM_BUFFERCACHE_OS_PAGES_ELEM];
        bool        nulls[NUM_BUFFERCACHE_OS_PAGES_ELEM];
 
        values[0] = Int32GetDatum(fctx->record[i].bufferid);
        nulls[0] = false;
 
        values[1] = Int64GetDatum(fctx->record[i].page_num);
        nulls[1] = false;
 
        if (fctx->include_numa)
        {
            /* status is valid node number */
            if (fctx->record[i].numa_node >= 0)
            {
                values[2] = Int32GetDatum(fctx->record[i].numa_node);
                nulls[2] = false;
            }
            else
            {
                /* some kind of error (e.g. pages moved to swap) */
                values[2] = (Datum) 0;
                nulls[2] = true;
            }
        }
        else
        {
            values[2] = (Datum) 0;
            nulls[2] = true;
        }
 
        /* Build and return the tuple. */
        tuple = heap_form_tuple(fctx->tupdesc, values, nulls);
        result = HeapTupleGetDatum(tuple);
 
        SRF_RETURN_NEXT(funcctx, result);
    }
    else
        SRF_RETURN_DONE(funcctx);
}

References Assert, BlessTupleDesc(), BufferDescriptorGetBuffer(), BufferGetBlock(), CHECK_FOR_INTERRUPTS, CreateTemplateTupleDesc(), CurrentMemoryContext, DEBUG1, elog, ERROR, fb(), firstNumaTouch, get_call_result_type(), GetBufferDescriptor(), heap_form_tuple(), HeapTupleGetDatum(), i, idx(), Int32GetDatum(), Int64GetDatum(), LockBufHdr(), Max, MemoryContextAllocHuge(), MemoryContextSwitchTo(), NBuffers, NUM_BUFFERCACHE_OS_PAGES_ELEM, palloc0_array, palloc_array, palloc_object, pg_get_shmem_pagesize(), pg_numa_init(), pg_numa_query_pages(), pg_numa_touch_mem_if_required, result, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, TupleDescFinalize(), TupleDescInitEntry(), TYPEALIGN, TYPEALIGN_DOWN, TYPEFUNC_COMPOSITE, UINT64_FORMAT, UnlockBufHdr(), and values.

Referenced by pg_buffercache_numa_pages(), and pg_buffercache_os_pages().

pg_buffercache_pages()

Datum pg_buffercache_pages

(

PG_FUNCTION_ARGS

)

Definition at line 85 of file pg_buffercache_pages.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    TupleDesc   expected_tupledesc;
    int         i;
 
    /*
     * To smoothly support upgrades from version 1.0 of this extension
     * transparently handle the (non-)existence of the pinning_backends
     * column. We unfortunately have to get the result type for that... - we
     * can't use the result type determined by the function definition without
     * potentially crashing when somebody uses the old (or even wrong)
     * function definition though.
     */
    if (get_call_result_type(fcinfo, NULL, &expected_tupledesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    if (expected_tupledesc->natts < NUM_BUFFERCACHE_PAGES_MIN_ELEM ||
        expected_tupledesc->natts > NUM_BUFFERCACHE_PAGES_ELEM)
        elog(ERROR, "incorrect number of output arguments");
 
    InitMaterializedSRF(fcinfo, 0);
 
    /*
     * Scan through all the buffers, adding one row for each of the buffers to
     * the tuplestore.
     *
     * We don't hold the partition locks, so we don't get a consistent
     * snapshot across all buffers, but we do grab the buffer header locks, so
     * the information of each buffer is self-consistent.
     */
    for (i = 0; i < NBuffers; i++)
    {
        BufferDesc *bufHdr;
        uint64      buf_state;
        uint32      bufferid;
        RelFileNumber relfilenumber;
        Oid         reltablespace;
        Oid         reldatabase;
        ForkNumber  forknum;
        BlockNumber blocknum;
        bool        isvalid;
        bool        isdirty;
        uint16      usagecount;
        int32       pinning_backends;
        Datum       values[NUM_BUFFERCACHE_PAGES_ELEM];
        bool        nulls[NUM_BUFFERCACHE_PAGES_ELEM];
 
        CHECK_FOR_INTERRUPTS();
 
        bufHdr = GetBufferDescriptor(i);
        /* Lock each buffer header before inspecting. */
        buf_state = LockBufHdr(bufHdr);
 
        bufferid = BufferDescriptorGetBuffer(bufHdr);
        relfilenumber = BufTagGetRelNumber(&bufHdr->tag);
        reltablespace = bufHdr->tag.spcOid;
        reldatabase = bufHdr->tag.dbOid;
        forknum = BufTagGetForkNum(&bufHdr->tag);
        blocknum = bufHdr->tag.blockNum;
        usagecount = BUF_STATE_GET_USAGECOUNT(buf_state);
        pinning_backends = BUF_STATE_GET_REFCOUNT(buf_state);
 
        if (buf_state & BM_DIRTY)
            isdirty = true;
        else
            isdirty = false;
 
        /* Note if the buffer is valid, and has storage created */
        if ((buf_state & BM_VALID) && (buf_state & BM_TAG_VALID))
            isvalid = true;
        else
            isvalid = false;
 
        UnlockBufHdr(bufHdr);
 
        /* Build the tuple and add it to tuplestore */
        values[0] = Int32GetDatum(bufferid);
        nulls[0] = false;
 
        /*
         * Set all fields except the bufferid to null if the buffer is unused
         * or not valid.
         */
        if (blocknum == InvalidBlockNumber || isvalid == false)
        {
            nulls[1] = true;
            nulls[2] = true;
            nulls[3] = true;
            nulls[4] = true;
            nulls[5] = true;
            nulls[6] = true;
            nulls[7] = true;
            /* unused for v1.0 callers, but the array is always long enough */
            nulls[8] = true;
        }
        else
        {
            values[1] = ObjectIdGetDatum(relfilenumber);
            nulls[1] = false;
            values[2] = ObjectIdGetDatum(reltablespace);
            nulls[2] = false;
            values[3] = ObjectIdGetDatum(reldatabase);
            nulls[3] = false;
            values[4] = Int16GetDatum(forknum);
            nulls[4] = false;
            values[5] = Int64GetDatum((int64) blocknum);
            nulls[5] = false;
            values[6] = BoolGetDatum(isdirty);
            nulls[6] = false;
            values[7] = UInt16GetDatum(usagecount);
            nulls[7] = false;
            /* unused for v1.0 callers, but the array is always long enough */
            values[8] = Int32GetDatum(pinning_backends);
            nulls[8] = false;
        }
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
    }
 
    return (Datum) 0;
}

References BM_DIRTY, BM_TAG_VALID, BM_VALID, BoolGetDatum(), BUF_STATE_GET_REFCOUNT, BUF_STATE_GET_USAGECOUNT, BufferDescriptorGetBuffer(), BufTagGetForkNum(), BufTagGetRelNumber(), CHECK_FOR_INTERRUPTS, elog, ERROR, fb(), get_call_result_type(), GetBufferDescriptor(), i, InitMaterializedSRF(), Int16GetDatum(), Int32GetDatum(), Int64GetDatum(), InvalidBlockNumber, LockBufHdr(), NBuffers, NUM_BUFFERCACHE_PAGES_ELEM, NUM_BUFFERCACHE_PAGES_MIN_ELEM, ObjectIdGetDatum(), tuplestore_putvalues(), TYPEFUNC_COMPOSITE, UInt16GetDatum(), UnlockBufHdr(), and values.

pg_buffercache_summary()

Datum pg_buffercache_summary

(

PG_FUNCTION_ARGS

)

Definition at line 521 of file pg_buffercache_pages.c.

{
    Datum       result;
    TupleDesc   tupledesc;
    HeapTuple   tuple;
    Datum       values[NUM_BUFFERCACHE_SUMMARY_ELEM];
    bool        nulls[NUM_BUFFERCACHE_SUMMARY_ELEM];
 
    int32       buffers_used = 0;
    int32       buffers_unused = 0;
    int32       buffers_dirty = 0;
    int32       buffers_pinned = 0;
    int64       usagecount_total = 0;
 
    if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    for (int i = 0; i < NBuffers; i++)
    {
        BufferDesc *bufHdr;
        uint64      buf_state;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * This function summarizes the state of all headers. Locking the
         * buffer headers wouldn't provide an improved result as the state of
         * the buffer can still change after we release the lock and it'd
         * noticeably increase the cost of the function.
         */
        bufHdr = GetBufferDescriptor(i);
        buf_state = pg_atomic_read_u64(&bufHdr->state);
 
        if (buf_state & BM_VALID)
        {
            buffers_used++;
            usagecount_total += BUF_STATE_GET_USAGECOUNT(buf_state);
 
            if (buf_state & BM_DIRTY)
                buffers_dirty++;
        }
        else
            buffers_unused++;
 
        if (BUF_STATE_GET_REFCOUNT(buf_state) > 0)
            buffers_pinned++;
    }
 
    memset(nulls, 0, sizeof(nulls));
    values[0] = Int32GetDatum(buffers_used);
    values[1] = Int32GetDatum(buffers_unused);
    values[2] = Int32GetDatum(buffers_dirty);
    values[3] = Int32GetDatum(buffers_pinned);
 
    if (buffers_used != 0)
        values[4] = Float8GetDatum((double) usagecount_total / buffers_used);
    else
        nulls[4] = true;
 
    /* Build and return the tuple. */
    tuple = heap_form_tuple(tupledesc, values, nulls);
    result = HeapTupleGetDatum(tuple);
 
    PG_RETURN_DATUM(result);
}

References BM_DIRTY, BM_VALID, BUF_STATE_GET_REFCOUNT, BUF_STATE_GET_USAGECOUNT, CHECK_FOR_INTERRUPTS, elog, ERROR, fb(), Float8GetDatum(), get_call_result_type(), GetBufferDescriptor(), heap_form_tuple(), HeapTupleGetDatum(), i, Int32GetDatum(), NBuffers, NUM_BUFFERCACHE_SUMMARY_ELEM, pg_atomic_read_u64(), PG_RETURN_DATUM, result, TYPEFUNC_COMPOSITE, and values.

pg_buffercache_superuser_check()

static void pg_buffercache_superuser_check ( char *  func_name )

static

Definition at line 634 of file pg_buffercache_pages.c.

{
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to use %s()",
                        func_name)));
}

References ereport, errcode(), errmsg, ERROR, fb(), and superuser().

Referenced by pg_buffercache_evict(), pg_buffercache_evict_all(), pg_buffercache_evict_relation(), pg_buffercache_mark_dirty(), pg_buffercache_mark_dirty_all(), and pg_buffercache_mark_dirty_relation().

pg_buffercache_usage_counts()

Datum pg_buffercache_usage_counts

(

PG_FUNCTION_ARGS

)

Definition at line 588 of file pg_buffercache_pages.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    int         usage_counts[BM_MAX_USAGE_COUNT + 1] = {0};
    int         dirty[BM_MAX_USAGE_COUNT + 1] = {0};
    int         pinned[BM_MAX_USAGE_COUNT + 1] = {0};
    Datum       values[NUM_BUFFERCACHE_USAGE_COUNTS_ELEM];
    bool        nulls[NUM_BUFFERCACHE_USAGE_COUNTS_ELEM] = {0};
 
    InitMaterializedSRF(fcinfo, 0);
 
    for (int i = 0; i < NBuffers; i++)
    {
        BufferDesc *bufHdr = GetBufferDescriptor(i);
        uint64      buf_state = pg_atomic_read_u64(&bufHdr->state);
        int         usage_count;
 
        CHECK_FOR_INTERRUPTS();
 
        usage_count = BUF_STATE_GET_USAGECOUNT(buf_state);
        usage_counts[usage_count]++;
 
        if (buf_state & BM_DIRTY)
            dirty[usage_count]++;
 
        if (BUF_STATE_GET_REFCOUNT(buf_state) > 0)
            pinned[usage_count]++;
    }
 
    for (int i = 0; i < BM_MAX_USAGE_COUNT + 1; i++)
    {
        values[0] = Int32GetDatum(i);
        values[1] = Int32GetDatum(usage_counts[i]);
        values[2] = Int32GetDatum(dirty[i]);
        values[3] = Int32GetDatum(pinned[i]);
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
    }
 
    return (Datum) 0;
}

References BM_DIRTY, BM_MAX_USAGE_COUNT, BUF_STATE_GET_REFCOUNT, BUF_STATE_GET_USAGECOUNT, CHECK_FOR_INTERRUPTS, fb(), GetBufferDescriptor(), i, InitMaterializedSRF(), Int32GetDatum(), NBuffers, NUM_BUFFERCACHE_USAGE_COUNTS_ELEM, pg_atomic_read_u64(), tuplestore_putvalues(), and values.

PG_FUNCTION_INFO_V1() [1/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_evict

)

PG_FUNCTION_INFO_V1() [2/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_evict_all

)

PG_FUNCTION_INFO_V1() [3/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_evict_relation

)

PG_FUNCTION_INFO_V1() [4/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_mark_dirty

)

PG_FUNCTION_INFO_V1() [5/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_mark_dirty_all

)

PG_FUNCTION_INFO_V1() [6/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_mark_dirty_relation

)

PG_FUNCTION_INFO_V1() [7/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_numa_pages

)

PG_FUNCTION_INFO_V1() [8/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_os_pages

)

PG_FUNCTION_INFO_V1() [9/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_pages

)

PG_FUNCTION_INFO_V1() [10/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_summary

)

PG_FUNCTION_INFO_V1() [11/11]

PG_FUNCTION_INFO_V1

(

pg_buffercache_usage_counts

)

PG_MODULE_MAGIC_EXT()

PG_MODULE_MAGIC_EXT	(	.	name = "pg_buffercache",
		.	version = PG_VERSION
	)

Variable Documentation

firstNumaTouch

bool firstNumaTouch = true

static

Definition at line 81 of file pg_buffercache_pages.c.

Referenced by pg_buffercache_os_pages_internal().