Header And Logo

PostgreSQL
| The world's most advanced open source database.

Data Structures | Defines | Functions | Variables

pg_buffercache_pages.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "storage/buf_internals.h"
#include "storage/bufmgr.h"
Include dependency graph for pg_buffercache_pages.c:

Go to the source code of this file.

Data Structures

struct  BufferCachePagesRec
struct  BufferCachePagesContext

Defines

#define NUM_BUFFERCACHE_PAGES_ELEM   8

Functions

Datum pg_buffercache_pages (PG_FUNCTION_ARGS)
 PG_FUNCTION_INFO_V1 (pg_buffercache_pages)

Variables

 PG_MODULE_MAGIC

Define Documentation

#define NUM_BUFFERCACHE_PAGES_ELEM   8

Definition at line 18 of file pg_buffercache_pages.c.

Referenced by pg_buffercache_pages().


Function Documentation

Datum pg_buffercache_pages ( PG_FUNCTION_ARGS   ) 

Definition at line 59 of file pg_buffercache_pages.c.

References BlessTupleDesc(), buftag::blockNum, BufferCachePagesRec::blocknum, BM_DIRTY, BM_TAG_VALID, BM_VALID, BoolGetDatum, BOOLOID, BufferDescriptorGetBuffer, BufferDescriptors, BufferCachePagesRec::bufferid, FuncCallContext::call_cntr, CreateTemplateTupleDesc(), RelFileNode::dbNode, FirstBufMappingLock, sbufdesc::flags, buftag::forkNum, BufferCachePagesRec::forknum, heap_form_tuple(), HeapTupleGetDatum, i, Int16GetDatum, INT2OID, Int32GetDatum, INT4OID, Int64GetDatum(), INT8OID, InvalidBlockNumber, BufferCachePagesRec::isdirty, BufferCachePagesRec::isvalid, LockBufHdr, LW_SHARED, LWLockAcquire(), LWLockRelease(), FuncCallContext::max_calls, MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, NBuffers, NUM_BUFFERCACHE_PAGES_ELEM, ObjectIdGetDatum, OIDOID, palloc(), BufferCachePagesContext::record, BufferCachePagesRec::reldatabase, BufferCachePagesRec::relfilenode, RelFileNode::relNode, BufferCachePagesRec::reltablespace, buftag::rnode, RelFileNode::spcNode, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, sbufdesc::tag, BufferCachePagesContext::tupdesc, TupleDescInitEntry(), UnlockBufHdr, sbufdesc::usage_count, BufferCachePagesRec::usagecount, FuncCallContext::user_fctx, and values.

{
    FuncCallContext *funcctx;
    Datum       result;
    MemoryContext oldcontext;
    BufferCachePagesContext *fctx;      /* User function context. */
    TupleDesc   tupledesc;
    HeapTuple   tuple;

    if (SRF_IS_FIRSTCALL())
    {
        int         i;
        volatile BufferDesc *bufHdr;

        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 = (BufferCachePagesContext *) palloc(sizeof(BufferCachePagesContext));

        /* Construct a tuple descriptor for the result rows. */
        tupledesc = CreateTemplateTupleDesc(NUM_BUFFERCACHE_PAGES_ELEM, false);
        TupleDescInitEntry(tupledesc, (AttrNumber) 1, "bufferid",
                           INT4OID, -1, 0);
        TupleDescInitEntry(tupledesc, (AttrNumber) 2, "relfilenode",
                           OIDOID, -1, 0);
        TupleDescInitEntry(tupledesc, (AttrNumber) 3, "reltablespace",
                           OIDOID, -1, 0);
        TupleDescInitEntry(tupledesc, (AttrNumber) 4, "reldatabase",
                           OIDOID, -1, 0);
        TupleDescInitEntry(tupledesc, (AttrNumber) 5, "relforknumber",
                           INT2OID, -1, 0);
        TupleDescInitEntry(tupledesc, (AttrNumber) 6, "relblocknumber",
                           INT8OID, -1, 0);
        TupleDescInitEntry(tupledesc, (AttrNumber) 7, "isdirty",
                           BOOLOID, -1, 0);
        TupleDescInitEntry(tupledesc, (AttrNumber) 8, "usage_count",
                           INT2OID, -1, 0);

        fctx->tupdesc = BlessTupleDesc(tupledesc);

        /* Allocate NBuffers worth of BufferCachePagesRec records. */
        fctx->record = (BufferCachePagesRec *) palloc(sizeof(BufferCachePagesRec) * NBuffers);

        /* Set max calls and remember the user function context. */
        funcctx->max_calls = NBuffers;
        funcctx->user_fctx = fctx;

        /* Return to original context when allocating transient memory */
        MemoryContextSwitchTo(oldcontext);

        /*
         * To get a consistent picture of the buffer state, we must lock all
         * partitions of the buffer map.  Needless to say, this is horrible
         * for concurrency.  Must grab locks in increasing order to avoid
         * possible deadlocks.
         */
        for (i = 0; i < NUM_BUFFER_PARTITIONS; i++)
            LWLockAcquire(FirstBufMappingLock + i, LW_SHARED);

        /*
         * Scan though all the buffers, saving the relevant fields in the
         * fctx->record structure.
         */
        for (i = 0, bufHdr = BufferDescriptors; i < NBuffers; i++, bufHdr++)
        {
            /* Lock each buffer header before inspecting. */
            LockBufHdr(bufHdr);

            fctx->record[i].bufferid = BufferDescriptorGetBuffer(bufHdr);
            fctx->record[i].relfilenode = bufHdr->tag.rnode.relNode;
            fctx->record[i].reltablespace = bufHdr->tag.rnode.spcNode;
            fctx->record[i].reldatabase = bufHdr->tag.rnode.dbNode;
            fctx->record[i].forknum = bufHdr->tag.forkNum;
            fctx->record[i].blocknum = bufHdr->tag.blockNum;
            fctx->record[i].usagecount = bufHdr->usage_count;

            if (bufHdr->flags & BM_DIRTY)
                fctx->record[i].isdirty = true;
            else
                fctx->record[i].isdirty = false;

            /* Note if the buffer is valid, and has storage created */
            if ((bufHdr->flags & BM_VALID) && (bufHdr->flags & BM_TAG_VALID))
                fctx->record[i].isvalid = true;
            else
                fctx->record[i].isvalid = false;

            UnlockBufHdr(bufHdr);
        }

        /*
         * And release locks.  We do this in reverse order for two reasons:
         * (1) Anyone else who needs more than one of the locks will be trying
         * to lock them in increasing order; we don't want to release the
         * other process until it can get all the locks it needs. (2) This
         * avoids O(N^2) behavior inside LWLockRelease.
         */
        for (i = NUM_BUFFER_PARTITIONS; --i >= 0;)
            LWLockRelease(FirstBufMappingLock + i);
    }

    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_PAGES_ELEM];
        bool        nulls[NUM_BUFFERCACHE_PAGES_ELEM];

        values[0] = Int32GetDatum(fctx->record[i].bufferid);
        nulls[0] = false;

        /*
         * Set all fields except the bufferid to null if the buffer is unused
         * or not valid.
         */
        if (fctx->record[i].blocknum == InvalidBlockNumber ||
            fctx->record[i].isvalid == false)
        {
            nulls[1] = true;
            nulls[2] = true;
            nulls[3] = true;
            nulls[4] = true;
            nulls[5] = true;
            nulls[6] = true;
            nulls[7] = true;
        }
        else
        {
            values[1] = ObjectIdGetDatum(fctx->record[i].relfilenode);
            nulls[1] = false;
            values[2] = ObjectIdGetDatum(fctx->record[i].reltablespace);
            nulls[2] = false;
            values[3] = ObjectIdGetDatum(fctx->record[i].reldatabase);
            nulls[3] = false;
            values[4] = ObjectIdGetDatum(fctx->record[i].forknum);
            nulls[4] = false;
            values[5] = Int64GetDatum((int64) fctx->record[i].blocknum);
            nulls[5] = false;
            values[6] = BoolGetDatum(fctx->record[i].isdirty);
            nulls[6] = false;
            values[7] = Int16GetDatum(fctx->record[i].usagecount);
            nulls[7] = false;
        }

        /* 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);
}

PG_FUNCTION_INFO_V1 ( pg_buffercache_pages   ) 

Variable Documentation

Definition at line 20 of file pg_buffercache_pages.c.