LCOV - code coverage report
Current view: top level - contrib/pg_buffercache - pg_buffercache_pages.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 185 266 69.5 %
Date: 2025-04-24 12:15:10 Functions: 15 16 93.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * pg_buffercache_pages.c
       4             :  *    display some contents of the buffer cache
       5             :  *
       6             :  *    contrib/pg_buffercache/pg_buffercache_pages.c
       7             :  *-------------------------------------------------------------------------
       8             :  */
       9             : #include "postgres.h"
      10             : 
      11             : #include "access/htup_details.h"
      12             : #include "access/relation.h"
      13             : #include "catalog/pg_type.h"
      14             : #include "funcapi.h"
      15             : #include "port/pg_numa.h"
      16             : #include "storage/buf_internals.h"
      17             : #include "storage/bufmgr.h"
      18             : #include "utils/rel.h"
      19             : 
      20             : 
      21             : #define NUM_BUFFERCACHE_PAGES_MIN_ELEM  8
      22             : #define NUM_BUFFERCACHE_PAGES_ELEM  9
      23             : #define NUM_BUFFERCACHE_SUMMARY_ELEM 5
      24             : #define NUM_BUFFERCACHE_USAGE_COUNTS_ELEM 4
      25             : #define NUM_BUFFERCACHE_EVICT_ELEM 2
      26             : #define NUM_BUFFERCACHE_EVICT_RELATION_ELEM 3
      27             : #define NUM_BUFFERCACHE_EVICT_ALL_ELEM 3
      28             : 
      29             : #define NUM_BUFFERCACHE_NUMA_ELEM   3
      30             : 
      31           2 : PG_MODULE_MAGIC_EXT(
      32             :                     .name = "pg_buffercache",
      33             :                     .version = PG_VERSION
      34             : );
      35             : 
      36             : /*
      37             :  * Record structure holding the to be exposed cache data.
      38             :  */
      39             : typedef struct
      40             : {
      41             :     uint32      bufferid;
      42             :     RelFileNumber relfilenumber;
      43             :     Oid         reltablespace;
      44             :     Oid         reldatabase;
      45             :     ForkNumber  forknum;
      46             :     BlockNumber blocknum;
      47             :     bool        isvalid;
      48             :     bool        isdirty;
      49             :     uint16      usagecount;
      50             : 
      51             :     /*
      52             :      * An int32 is sufficiently large, as MAX_BACKENDS prevents a buffer from
      53             :      * being pinned by too many backends and each backend will only pin once
      54             :      * because of bufmgr.c's PrivateRefCount infrastructure.
      55             :      */
      56             :     int32       pinning_backends;
      57             : } BufferCachePagesRec;
      58             : 
      59             : 
      60             : /*
      61             :  * Function context for data persisting over repeated calls.
      62             :  */
      63             : typedef struct
      64             : {
      65             :     TupleDesc   tupdesc;
      66             :     BufferCachePagesRec *record;
      67             : } BufferCachePagesContext;
      68             : 
      69             : /*
      70             :  * Record structure holding the to be exposed cache data.
      71             :  */
      72             : typedef struct
      73             : {
      74             :     uint32      bufferid;
      75             :     int64       page_num;
      76             :     int32       numa_node;
      77             : } BufferCacheNumaRec;
      78             : 
      79             : /*
      80             :  * Function context for data persisting over repeated calls.
      81             :  */
      82             : typedef struct
      83             : {
      84             :     TupleDesc   tupdesc;
      85             :     int         buffers_per_page;
      86             :     int         pages_per_buffer;
      87             :     int         os_page_size;
      88             :     BufferCacheNumaRec *record;
      89             : } BufferCacheNumaContext;
      90             : 
      91             : 
      92             : /*
      93             :  * Function returning data from the shared buffer cache - buffer number,
      94             :  * relation node/tablespace/database/blocknum and dirty indicator.
      95             :  */
      96           4 : PG_FUNCTION_INFO_V1(pg_buffercache_pages);
      97           2 : PG_FUNCTION_INFO_V1(pg_buffercache_numa_pages);
      98           4 : PG_FUNCTION_INFO_V1(pg_buffercache_summary);
      99           4 : PG_FUNCTION_INFO_V1(pg_buffercache_usage_counts);
     100           6 : PG_FUNCTION_INFO_V1(pg_buffercache_evict);
     101           4 : PG_FUNCTION_INFO_V1(pg_buffercache_evict_relation);
     102           4 : PG_FUNCTION_INFO_V1(pg_buffercache_evict_all);
     103             : 
     104             : 
     105             : /* Only need to touch memory once per backend process lifetime */
     106             : static bool firstNumaTouch = true;
     107             : 
     108             : 
     109             : Datum
     110       65540 : pg_buffercache_pages(PG_FUNCTION_ARGS)
     111             : {
     112             :     FuncCallContext *funcctx;
     113             :     Datum       result;
     114             :     MemoryContext oldcontext;
     115             :     BufferCachePagesContext *fctx;  /* User function context. */
     116             :     TupleDesc   tupledesc;
     117             :     TupleDesc   expected_tupledesc;
     118             :     HeapTuple   tuple;
     119             : 
     120       65540 :     if (SRF_IS_FIRSTCALL())
     121             :     {
     122             :         int         i;
     123             : 
     124           4 :         funcctx = SRF_FIRSTCALL_INIT();
     125             : 
     126             :         /* Switch context when allocating stuff to be used in later calls */
     127           4 :         oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
     128             : 
     129             :         /* Create a user function context for cross-call persistence */
     130           4 :         fctx = (BufferCachePagesContext *) palloc(sizeof(BufferCachePagesContext));
     131             : 
     132             :         /*
     133             :          * To smoothly support upgrades from version 1.0 of this extension
     134             :          * transparently handle the (non-)existence of the pinning_backends
     135             :          * column. We unfortunately have to get the result type for that... -
     136             :          * we can't use the result type determined by the function definition
     137             :          * without potentially crashing when somebody uses the old (or even
     138             :          * wrong) function definition though.
     139             :          */
     140           4 :         if (get_call_result_type(fcinfo, NULL, &expected_tupledesc) != TYPEFUNC_COMPOSITE)
     141           0 :             elog(ERROR, "return type must be a row type");
     142             : 
     143           4 :         if (expected_tupledesc->natts < NUM_BUFFERCACHE_PAGES_MIN_ELEM ||
     144           4 :             expected_tupledesc->natts > NUM_BUFFERCACHE_PAGES_ELEM)
     145           0 :             elog(ERROR, "incorrect number of output arguments");
     146             : 
     147             :         /* Construct a tuple descriptor for the result rows. */
     148           4 :         tupledesc = CreateTemplateTupleDesc(expected_tupledesc->natts);
     149           4 :         TupleDescInitEntry(tupledesc, (AttrNumber) 1, "bufferid",
     150             :                            INT4OID, -1, 0);
     151           4 :         TupleDescInitEntry(tupledesc, (AttrNumber) 2, "relfilenode",
     152             :                            OIDOID, -1, 0);
     153           4 :         TupleDescInitEntry(tupledesc, (AttrNumber) 3, "reltablespace",
     154             :                            OIDOID, -1, 0);
     155           4 :         TupleDescInitEntry(tupledesc, (AttrNumber) 4, "reldatabase",
     156             :                            OIDOID, -1, 0);
     157           4 :         TupleDescInitEntry(tupledesc, (AttrNumber) 5, "relforknumber",
     158             :                            INT2OID, -1, 0);
     159           4 :         TupleDescInitEntry(tupledesc, (AttrNumber) 6, "relblocknumber",
     160             :                            INT8OID, -1, 0);
     161           4 :         TupleDescInitEntry(tupledesc, (AttrNumber) 7, "isdirty",
     162             :                            BOOLOID, -1, 0);
     163           4 :         TupleDescInitEntry(tupledesc, (AttrNumber) 8, "usage_count",
     164             :                            INT2OID, -1, 0);
     165             : 
     166           4 :         if (expected_tupledesc->natts == NUM_BUFFERCACHE_PAGES_ELEM)
     167           4 :             TupleDescInitEntry(tupledesc, (AttrNumber) 9, "pinning_backends",
     168             :                                INT4OID, -1, 0);
     169             : 
     170           4 :         fctx->tupdesc = BlessTupleDesc(tupledesc);
     171             : 
     172             :         /* Allocate NBuffers worth of BufferCachePagesRec records. */
     173           4 :         fctx->record = (BufferCachePagesRec *)
     174           4 :             MemoryContextAllocHuge(CurrentMemoryContext,
     175             :                                    sizeof(BufferCachePagesRec) * NBuffers);
     176             : 
     177             :         /* Set max calls and remember the user function context. */
     178           4 :         funcctx->max_calls = NBuffers;
     179           4 :         funcctx->user_fctx = fctx;
     180             : 
     181             :         /* Return to original context when allocating transient memory */
     182           4 :         MemoryContextSwitchTo(oldcontext);
     183             : 
     184             :         /*
     185             :          * Scan through all the buffers, saving the relevant fields in the
     186             :          * fctx->record structure.
     187             :          *
     188             :          * We don't hold the partition locks, so we don't get a consistent
     189             :          * snapshot across all buffers, but we do grab the buffer header
     190             :          * locks, so the information of each buffer is self-consistent.
     191             :          */
     192       65540 :         for (i = 0; i < NBuffers; i++)
     193             :         {
     194             :             BufferDesc *bufHdr;
     195             :             uint32      buf_state;
     196             : 
     197       65536 :             bufHdr = GetBufferDescriptor(i);
     198             :             /* Lock each buffer header before inspecting. */
     199       65536 :             buf_state = LockBufHdr(bufHdr);
     200             : 
     201       65536 :             fctx->record[i].bufferid = BufferDescriptorGetBuffer(bufHdr);
     202       65536 :             fctx->record[i].relfilenumber = BufTagGetRelNumber(&bufHdr->tag);
     203       65536 :             fctx->record[i].reltablespace = bufHdr->tag.spcOid;
     204       65536 :             fctx->record[i].reldatabase = bufHdr->tag.dbOid;
     205       65536 :             fctx->record[i].forknum = BufTagGetForkNum(&bufHdr->tag);
     206       65536 :             fctx->record[i].blocknum = bufHdr->tag.blockNum;
     207       65536 :             fctx->record[i].usagecount = BUF_STATE_GET_USAGECOUNT(buf_state);
     208       65536 :             fctx->record[i].pinning_backends = BUF_STATE_GET_REFCOUNT(buf_state);
     209             : 
     210       65536 :             if (buf_state & BM_DIRTY)
     211        3780 :                 fctx->record[i].isdirty = true;
     212             :             else
     213       61756 :                 fctx->record[i].isdirty = false;
     214             : 
     215             :             /* Note if the buffer is valid, and has storage created */
     216       65536 :             if ((buf_state & BM_VALID) && (buf_state & BM_TAG_VALID))
     217        7960 :                 fctx->record[i].isvalid = true;
     218             :             else
     219       57576 :                 fctx->record[i].isvalid = false;
     220             : 
     221       65536 :             UnlockBufHdr(bufHdr, buf_state);
     222             :         }
     223             :     }
     224             : 
     225       65540 :     funcctx = SRF_PERCALL_SETUP();
     226             : 
     227             :     /* Get the saved state */
     228       65540 :     fctx = funcctx->user_fctx;
     229             : 
     230       65540 :     if (funcctx->call_cntr < funcctx->max_calls)
     231             :     {
     232       65536 :         uint32      i = funcctx->call_cntr;
     233             :         Datum       values[NUM_BUFFERCACHE_PAGES_ELEM];
     234             :         bool        nulls[NUM_BUFFERCACHE_PAGES_ELEM];
     235             : 
     236       65536 :         values[0] = Int32GetDatum(fctx->record[i].bufferid);
     237       65536 :         nulls[0] = false;
     238             : 
     239             :         /*
     240             :          * Set all fields except the bufferid to null if the buffer is unused
     241             :          * or not valid.
     242             :          */
     243       65536 :         if (fctx->record[i].blocknum == InvalidBlockNumber ||
     244        7960 :             fctx->record[i].isvalid == false)
     245             :         {
     246       57576 :             nulls[1] = true;
     247       57576 :             nulls[2] = true;
     248       57576 :             nulls[3] = true;
     249       57576 :             nulls[4] = true;
     250       57576 :             nulls[5] = true;
     251       57576 :             nulls[6] = true;
     252       57576 :             nulls[7] = true;
     253             :             /* unused for v1.0 callers, but the array is always long enough */
     254       57576 :             nulls[8] = true;
     255             :         }
     256             :         else
     257             :         {
     258        7960 :             values[1] = ObjectIdGetDatum(fctx->record[i].relfilenumber);
     259        7960 :             nulls[1] = false;
     260        7960 :             values[2] = ObjectIdGetDatum(fctx->record[i].reltablespace);
     261        7960 :             nulls[2] = false;
     262        7960 :             values[3] = ObjectIdGetDatum(fctx->record[i].reldatabase);
     263        7960 :             nulls[3] = false;
     264        7960 :             values[4] = ObjectIdGetDatum(fctx->record[i].forknum);
     265        7960 :             nulls[4] = false;
     266        7960 :             values[5] = Int64GetDatum((int64) fctx->record[i].blocknum);
     267        7960 :             nulls[5] = false;
     268        7960 :             values[6] = BoolGetDatum(fctx->record[i].isdirty);
     269        7960 :             nulls[6] = false;
     270        7960 :             values[7] = Int16GetDatum(fctx->record[i].usagecount);
     271        7960 :             nulls[7] = false;
     272             :             /* unused for v1.0 callers, but the array is always long enough */
     273        7960 :             values[8] = Int32GetDatum(fctx->record[i].pinning_backends);
     274        7960 :             nulls[8] = false;
     275             :         }
     276             : 
     277             :         /* Build and return the tuple. */
     278       65536 :         tuple = heap_form_tuple(fctx->tupdesc, values, nulls);
     279       65536 :         result = HeapTupleGetDatum(tuple);
     280             : 
     281       65536 :         SRF_RETURN_NEXT(funcctx, result);
     282             :     }
     283             :     else
     284           4 :         SRF_RETURN_DONE(funcctx);
     285             : }
     286             : 
     287             : /*
     288             :  * Inquire about NUMA memory mappings for shared buffers.
     289             :  *
     290             :  * Returns NUMA node ID for each memory page used by the buffer. Buffers may
     291             :  * be smaller or larger than OS memory pages. For each buffer we return one
     292             :  * entry for each memory page used by the buffer (if the buffer is smaller,
     293             :  * it only uses a part of one memory page).
     294             :  *
     295             :  * We expect both sizes (for buffers and memory pages) to be a power-of-2, so
     296             :  * one is always a multiple of the other.
     297             :  *
     298             :  * In order to get reliable results we also need to touch memory pages, so
     299             :  * that the inquiry about NUMA memory node doesn't return -2 (which indicates
     300             :  * unmapped/unallocated pages).
     301             :  */
     302             : Datum
     303           0 : pg_buffercache_numa_pages(PG_FUNCTION_ARGS)
     304             : {
     305             :     FuncCallContext *funcctx;
     306             :     MemoryContext oldcontext;
     307             :     BufferCacheNumaContext *fctx;   /* User function context. */
     308             :     TupleDesc   tupledesc;
     309             :     TupleDesc   expected_tupledesc;
     310             :     HeapTuple   tuple;
     311             :     Datum       result;
     312             : 
     313           0 :     if (SRF_IS_FIRSTCALL())
     314             :     {
     315             :         int         i,
     316             :                     idx;
     317             :         Size        os_page_size;
     318             :         void      **os_page_ptrs;
     319             :         int        *os_page_status;
     320             :         uint64      os_page_count;
     321             :         int         pages_per_buffer;
     322             :         int         max_entries;
     323             :         volatile uint64 touch pg_attribute_unused();
     324             :         char       *startptr,
     325             :                    *endptr;
     326             : 
     327           0 :         if (pg_numa_init() == -1)
     328           0 :             elog(ERROR, "libnuma initialization failed or NUMA is not supported on this platform");
     329             : 
     330             :         /*
     331             :          * The database block size and OS memory page size are unlikely to be
     332             :          * the same. The block size is 1-32KB, the memory page size depends on
     333             :          * platform. On x86 it's usually 4KB, on ARM it's 4KB or 64KB, but
     334             :          * there are also features like THP etc. Moreover, we don't quite know
     335             :          * how the pages and buffers "align" in memory - the buffers may be
     336             :          * shifted in some way, using more memory pages than necessary.
     337             :          *
     338             :          * So we need to be careful about mapping buffers to memory pages. We
     339             :          * calculate the maximum number of pages a buffer might use, so that
     340             :          * we allocate enough space for the entries. And then we count the
     341             :          * actual number of entries as we scan the buffers.
     342             :          *
     343             :          * This information is needed before calling move_pages() for NUMA
     344             :          * node id inquiry.
     345             :          */
     346           0 :         os_page_size = pg_get_shmem_pagesize();
     347             : 
     348             :         /*
     349             :          * The pages and block size is expected to be 2^k, so one divides the
     350             :          * other (we don't know in which direction). This does not say
     351             :          * anything about relative alignment of pages/buffers.
     352             :          */
     353             :         Assert((os_page_size % BLCKSZ == 0) || (BLCKSZ % os_page_size == 0));
     354             : 
     355             :         /*
     356             :          * How many addresses we are going to query? Simply get the page for
     357             :          * the first buffer, and first page after the last buffer, and count
     358             :          * the pages from that.
     359             :          */
     360           0 :         startptr = (char *) TYPEALIGN_DOWN(os_page_size,
     361             :                                            BufferGetBlock(1));
     362           0 :         endptr = (char *) TYPEALIGN(os_page_size,
     363             :                                     (char *) BufferGetBlock(NBuffers) + BLCKSZ);
     364           0 :         os_page_count = (endptr - startptr) / os_page_size;
     365             : 
     366             :         /* Used to determine the NUMA node for all OS pages at once */
     367           0 :         os_page_ptrs = palloc0(sizeof(void *) * os_page_count);
     368           0 :         os_page_status = palloc(sizeof(uint64) * os_page_count);
     369             : 
     370             :         /* Fill pointers for all the memory pages. */
     371           0 :         idx = 0;
     372           0 :         for (char *ptr = startptr; ptr < endptr; ptr += os_page_size)
     373             :         {
     374           0 :             os_page_ptrs[idx++] = ptr;
     375             : 
     376             :             /* Only need to touch memory once per backend process lifetime */
     377           0 :             if (firstNumaTouch)
     378             :                 pg_numa_touch_mem_if_required(touch, ptr);
     379             :         }
     380             : 
     381             :         Assert(idx == os_page_count);
     382             : 
     383           0 :         elog(DEBUG1, "NUMA: NBuffers=%d os_page_count=" UINT64_FORMAT " "
     384             :              "os_page_size=%zu", NBuffers, os_page_count, os_page_size);
     385             : 
     386             :         /*
     387             :          * If we ever get 0xff back from kernel inquiry, then we probably have
     388             :          * bug in our buffers to OS page mapping code here.
     389             :          */
     390           0 :         memset(os_page_status, 0xff, sizeof(int) * os_page_count);
     391             : 
     392             :         /* Query NUMA status for all the pointers */
     393           0 :         if (pg_numa_query_pages(0, os_page_count, os_page_ptrs, os_page_status) == -1)
     394           0 :             elog(ERROR, "failed NUMA pages inquiry: %m");
     395             : 
     396             :         /* Initialize the multi-call context, load entries about buffers */
     397             : 
     398           0 :         funcctx = SRF_FIRSTCALL_INIT();
     399             : 
     400             :         /* Switch context when allocating stuff to be used in later calls */
     401           0 :         oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
     402             : 
     403             :         /* Create a user function context for cross-call persistence */
     404           0 :         fctx = (BufferCacheNumaContext *) palloc(sizeof(BufferCacheNumaContext));
     405             : 
     406           0 :         if (get_call_result_type(fcinfo, NULL, &expected_tupledesc) != TYPEFUNC_COMPOSITE)
     407           0 :             elog(ERROR, "return type must be a row type");
     408             : 
     409           0 :         if (expected_tupledesc->natts != NUM_BUFFERCACHE_NUMA_ELEM)
     410           0 :             elog(ERROR, "incorrect number of output arguments");
     411             : 
     412             :         /* Construct a tuple descriptor for the result rows. */
     413           0 :         tupledesc = CreateTemplateTupleDesc(expected_tupledesc->natts);
     414           0 :         TupleDescInitEntry(tupledesc, (AttrNumber) 1, "bufferid",
     415             :                            INT4OID, -1, 0);
     416           0 :         TupleDescInitEntry(tupledesc, (AttrNumber) 2, "os_page_num",
     417             :                            INT8OID, -1, 0);
     418           0 :         TupleDescInitEntry(tupledesc, (AttrNumber) 3, "numa_node",
     419             :                            INT4OID, -1, 0);
     420             : 
     421           0 :         fctx->tupdesc = BlessTupleDesc(tupledesc);
     422             : 
     423             :         /*
     424             :          * Each buffer needs at least one entry, but it might be offset in
     425             :          * some way, and use one extra entry. So we allocate space for the
     426             :          * maximum number of entries we might need, and then count the exact
     427             :          * number as we're walking buffers. That way we can do it in one pass,
     428             :          * without reallocating memory.
     429             :          */
     430           0 :         pages_per_buffer = Max(1, BLCKSZ / os_page_size) + 1;
     431           0 :         max_entries = NBuffers * pages_per_buffer;
     432             : 
     433             :         /* Allocate entries for BufferCachePagesRec records. */
     434           0 :         fctx->record = (BufferCacheNumaRec *)
     435           0 :             MemoryContextAllocHuge(CurrentMemoryContext,
     436             :                                    sizeof(BufferCacheNumaRec) * max_entries);
     437             : 
     438             :         /* Return to original context when allocating transient memory */
     439           0 :         MemoryContextSwitchTo(oldcontext);
     440             : 
     441           0 :         if (firstNumaTouch)
     442           0 :             elog(DEBUG1, "NUMA: page-faulting the buffercache for proper NUMA readouts");
     443             : 
     444             :         /*
     445             :          * Scan through all the buffers, saving the relevant fields in the
     446             :          * fctx->record structure.
     447             :          *
     448             :          * We don't hold the partition locks, so we don't get a consistent
     449             :          * snapshot across all buffers, but we do grab the buffer header
     450             :          * locks, so the information of each buffer is self-consistent.
     451             :          *
     452             :          * This loop touches and stores addresses into os_page_ptrs[] as input
     453             :          * to one big move_pages(2) inquiry system call. Basically we ask for
     454             :          * all memory pages for NBuffers.
     455             :          */
     456           0 :         startptr = (char *) TYPEALIGN_DOWN(os_page_size, (char *) BufferGetBlock(1));
     457           0 :         idx = 0;
     458           0 :         for (i = 0; i < NBuffers; i++)
     459             :         {
     460           0 :             char       *buffptr = (char *) BufferGetBlock(i + 1);
     461             :             BufferDesc *bufHdr;
     462             :             uint32      buf_state;
     463             :             uint32      bufferid;
     464             :             int32       page_num;
     465             :             char       *startptr_buff,
     466             :                        *endptr_buff;
     467             : 
     468           0 :             CHECK_FOR_INTERRUPTS();
     469             : 
     470           0 :             bufHdr = GetBufferDescriptor(i);
     471             : 
     472             :             /* Lock each buffer header before inspecting. */
     473           0 :             buf_state = LockBufHdr(bufHdr);
     474           0 :             bufferid = BufferDescriptorGetBuffer(bufHdr);
     475           0 :             UnlockBufHdr(bufHdr, buf_state);
     476             : 
     477             :             /* start of the first page of this buffer */
     478           0 :             startptr_buff = (char *) TYPEALIGN_DOWN(os_page_size, buffptr);
     479             : 
     480             :             /* end of the buffer (no need to align to memory page) */
     481           0 :             endptr_buff = buffptr + BLCKSZ;
     482             : 
     483             :             Assert(startptr_buff < endptr_buff);
     484             : 
     485             :             /* calculate ID of the first page for this buffer */
     486           0 :             page_num = (startptr_buff - startptr) / os_page_size;
     487             : 
     488             :             /* Add an entry for each OS page overlapping with this buffer. */
     489           0 :             for (char *ptr = startptr_buff; ptr < endptr_buff; ptr += os_page_size)
     490             :             {
     491           0 :                 fctx->record[idx].bufferid = bufferid;
     492           0 :                 fctx->record[idx].page_num = page_num;
     493           0 :                 fctx->record[idx].numa_node = os_page_status[page_num];
     494             : 
     495             :                 /* advance to the next entry/page */
     496           0 :                 ++idx;
     497           0 :                 ++page_num;
     498             :             }
     499             :         }
     500             : 
     501             :         Assert((idx >= os_page_count) && (idx <= max_entries));
     502             : 
     503             :         /* Set max calls and remember the user function context. */
     504           0 :         funcctx->max_calls = idx;
     505           0 :         funcctx->user_fctx = fctx;
     506             : 
     507             :         /* Remember this backend touched the pages */
     508           0 :         firstNumaTouch = false;
     509             :     }
     510             : 
     511           0 :     funcctx = SRF_PERCALL_SETUP();
     512             : 
     513             :     /* Get the saved state */
     514           0 :     fctx = funcctx->user_fctx;
     515             : 
     516           0 :     if (funcctx->call_cntr < funcctx->max_calls)
     517             :     {
     518           0 :         uint32      i = funcctx->call_cntr;
     519             :         Datum       values[NUM_BUFFERCACHE_NUMA_ELEM];
     520             :         bool        nulls[NUM_BUFFERCACHE_NUMA_ELEM];
     521             : 
     522           0 :         values[0] = Int32GetDatum(fctx->record[i].bufferid);
     523           0 :         nulls[0] = false;
     524             : 
     525           0 :         values[1] = Int64GetDatum(fctx->record[i].page_num);
     526           0 :         nulls[1] = false;
     527             : 
     528           0 :         values[2] = Int32GetDatum(fctx->record[i].numa_node);
     529           0 :         nulls[2] = false;
     530             : 
     531             :         /* Build and return the tuple. */
     532           0 :         tuple = heap_form_tuple(fctx->tupdesc, values, nulls);
     533           0 :         result = HeapTupleGetDatum(tuple);
     534             : 
     535           0 :         SRF_RETURN_NEXT(funcctx, result);
     536             :     }
     537             :     else
     538           0 :         SRF_RETURN_DONE(funcctx);
     539             : }
     540             : 
     541             : Datum
     542           4 : pg_buffercache_summary(PG_FUNCTION_ARGS)
     543             : {
     544             :     Datum       result;
     545             :     TupleDesc   tupledesc;
     546             :     HeapTuple   tuple;
     547             :     Datum       values[NUM_BUFFERCACHE_SUMMARY_ELEM];
     548             :     bool        nulls[NUM_BUFFERCACHE_SUMMARY_ELEM];
     549             : 
     550           4 :     int32       buffers_used = 0;
     551           4 :     int32       buffers_unused = 0;
     552           4 :     int32       buffers_dirty = 0;
     553           4 :     int32       buffers_pinned = 0;
     554           4 :     int64       usagecount_total = 0;
     555             : 
     556           4 :     if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
     557           0 :         elog(ERROR, "return type must be a row type");
     558             : 
     559       65540 :     for (int i = 0; i < NBuffers; i++)
     560             :     {
     561             :         BufferDesc *bufHdr;
     562             :         uint32      buf_state;
     563             : 
     564             :         /*
     565             :          * This function summarizes the state of all headers. Locking the
     566             :          * buffer headers wouldn't provide an improved result as the state of
     567             :          * the buffer can still change after we release the lock and it'd
     568             :          * noticeably increase the cost of the function.
     569             :          */
     570       65536 :         bufHdr = GetBufferDescriptor(i);
     571       65536 :         buf_state = pg_atomic_read_u32(&bufHdr->state);
     572             : 
     573       65536 :         if (buf_state & BM_VALID)
     574             :         {
     575        7960 :             buffers_used++;
     576        7960 :             usagecount_total += BUF_STATE_GET_USAGECOUNT(buf_state);
     577             : 
     578        7960 :             if (buf_state & BM_DIRTY)
     579        3780 :                 buffers_dirty++;
     580             :         }
     581             :         else
     582       57576 :             buffers_unused++;
     583             : 
     584       65536 :         if (BUF_STATE_GET_REFCOUNT(buf_state) > 0)
     585           0 :             buffers_pinned++;
     586             :     }
     587             : 
     588           4 :     memset(nulls, 0, sizeof(nulls));
     589           4 :     values[0] = Int32GetDatum(buffers_used);
     590           4 :     values[1] = Int32GetDatum(buffers_unused);
     591           4 :     values[2] = Int32GetDatum(buffers_dirty);
     592           4 :     values[3] = Int32GetDatum(buffers_pinned);
     593             : 
     594           4 :     if (buffers_used != 0)
     595           4 :         values[4] = Float8GetDatum((double) usagecount_total / buffers_used);
     596             :     else
     597           0 :         nulls[4] = true;
     598             : 
     599             :     /* Build and return the tuple. */
     600           4 :     tuple = heap_form_tuple(tupledesc, values, nulls);
     601           4 :     result = HeapTupleGetDatum(tuple);
     602             : 
     603           4 :     PG_RETURN_DATUM(result);
     604             : }
     605             : 
     606             : Datum
     607           4 : pg_buffercache_usage_counts(PG_FUNCTION_ARGS)
     608             : {
     609           4 :     ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
     610           4 :     int         usage_counts[BM_MAX_USAGE_COUNT + 1] = {0};
     611           4 :     int         dirty[BM_MAX_USAGE_COUNT + 1] = {0};
     612           4 :     int         pinned[BM_MAX_USAGE_COUNT + 1] = {0};
     613             :     Datum       values[NUM_BUFFERCACHE_USAGE_COUNTS_ELEM];
     614           4 :     bool        nulls[NUM_BUFFERCACHE_USAGE_COUNTS_ELEM] = {0};
     615             : 
     616           4 :     InitMaterializedSRF(fcinfo, 0);
     617             : 
     618       65540 :     for (int i = 0; i < NBuffers; i++)
     619             :     {
     620       65536 :         BufferDesc *bufHdr = GetBufferDescriptor(i);
     621       65536 :         uint32      buf_state = pg_atomic_read_u32(&bufHdr->state);
     622             :         int         usage_count;
     623             : 
     624       65536 :         usage_count = BUF_STATE_GET_USAGECOUNT(buf_state);
     625       65536 :         usage_counts[usage_count]++;
     626             : 
     627       65536 :         if (buf_state & BM_DIRTY)
     628        3780 :             dirty[usage_count]++;
     629             : 
     630       65536 :         if (BUF_STATE_GET_REFCOUNT(buf_state) > 0)
     631           0 :             pinned[usage_count]++;
     632             :     }
     633             : 
     634          28 :     for (int i = 0; i < BM_MAX_USAGE_COUNT + 1; i++)
     635             :     {
     636          24 :         values[0] = Int32GetDatum(i);
     637          24 :         values[1] = Int32GetDatum(usage_counts[i]);
     638          24 :         values[2] = Int32GetDatum(dirty[i]);
     639          24 :         values[3] = Int32GetDatum(pinned[i]);
     640             : 
     641          24 :         tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
     642             :     }
     643             : 
     644           4 :     return (Datum) 0;
     645             : }
     646             : 
     647             : /*
     648             :  * Helper function to check if the user has superuser privileges.
     649             :  */
     650             : static void
     651          20 : pg_buffercache_superuser_check(char *func_name)
     652             : {
     653          20 :     if (!superuser())
     654           6 :         ereport(ERROR,
     655             :                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
     656             :                  errmsg("must be superuser to use %s()",
     657             :                         func_name)));
     658          14 : }
     659             : 
     660             : /*
     661             :  * Try to evict a shared buffer.
     662             :  */
     663             : Datum
     664          10 : pg_buffercache_evict(PG_FUNCTION_ARGS)
     665             : {
     666             :     Datum       result;
     667             :     TupleDesc   tupledesc;
     668             :     HeapTuple   tuple;
     669             :     Datum       values[NUM_BUFFERCACHE_EVICT_ELEM];
     670          10 :     bool        nulls[NUM_BUFFERCACHE_EVICT_ELEM] = {0};
     671             : 
     672          10 :     Buffer      buf = PG_GETARG_INT32(0);
     673             :     bool        buffer_flushed;
     674             : 
     675          10 :     if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
     676           0 :         elog(ERROR, "return type must be a row type");
     677             : 
     678          10 :     pg_buffercache_superuser_check("pg_buffercache_evict");
     679             : 
     680           8 :     if (buf < 1 || buf > NBuffers)
     681           6 :         elog(ERROR, "bad buffer ID: %d", buf);
     682             : 
     683           2 :     values[0] = BoolGetDatum(EvictUnpinnedBuffer(buf, &buffer_flushed));
     684           2 :     values[1] = BoolGetDatum(buffer_flushed);
     685             : 
     686           2 :     tuple = heap_form_tuple(tupledesc, values, nulls);
     687           2 :     result = HeapTupleGetDatum(tuple);
     688             : 
     689           2 :     PG_RETURN_DATUM(result);
     690             : }
     691             : 
     692             : /*
     693             :  * Try to evict specified relation.
     694             :  */
     695             : Datum
     696           6 : pg_buffercache_evict_relation(PG_FUNCTION_ARGS)
     697             : {
     698             :     Datum       result;
     699             :     TupleDesc   tupledesc;
     700             :     HeapTuple   tuple;
     701             :     Datum       values[NUM_BUFFERCACHE_EVICT_RELATION_ELEM];
     702           6 :     bool        nulls[NUM_BUFFERCACHE_EVICT_RELATION_ELEM] = {0};
     703             : 
     704             :     Oid         relOid;
     705             :     Relation    rel;
     706             : 
     707           6 :     int32       buffers_evicted = 0;
     708           6 :     int32       buffers_flushed = 0;
     709           6 :     int32       buffers_skipped = 0;
     710             : 
     711           6 :     if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
     712           0 :         elog(ERROR, "return type must be a row type");
     713             : 
     714           6 :     pg_buffercache_superuser_check("pg_buffercache_evict_relation");
     715             : 
     716           4 :     relOid = PG_GETARG_OID(0);
     717             : 
     718           4 :     rel = relation_open(relOid, AccessShareLock);
     719             : 
     720           4 :     if (RelationUsesLocalBuffers(rel))
     721           2 :         ereport(ERROR,
     722             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     723             :                  errmsg("relation uses local buffers, %s() is intended to be used for shared buffers only",
     724             :                         "pg_buffercache_evict_relation")));
     725             : 
     726           2 :     EvictRelUnpinnedBuffers(rel, &buffers_evicted, &buffers_flushed,
     727             :                             &buffers_skipped);
     728             : 
     729           2 :     relation_close(rel, AccessShareLock);
     730             : 
     731           2 :     values[0] = Int32GetDatum(buffers_evicted);
     732           2 :     values[1] = Int32GetDatum(buffers_flushed);
     733           2 :     values[2] = Int32GetDatum(buffers_skipped);
     734             : 
     735           2 :     tuple = heap_form_tuple(tupledesc, values, nulls);
     736           2 :     result = HeapTupleGetDatum(tuple);
     737             : 
     738           2 :     PG_RETURN_DATUM(result);
     739             : }
     740             : 
     741             : 
     742             : /*
     743             :  * Try to evict all shared buffers.
     744             :  */
     745             : Datum
     746           4 : pg_buffercache_evict_all(PG_FUNCTION_ARGS)
     747             : {
     748             :     Datum       result;
     749             :     TupleDesc   tupledesc;
     750             :     HeapTuple   tuple;
     751             :     Datum       values[NUM_BUFFERCACHE_EVICT_ALL_ELEM];
     752           4 :     bool        nulls[NUM_BUFFERCACHE_EVICT_ALL_ELEM] = {0};
     753             : 
     754           4 :     int32       buffers_evicted = 0;
     755           4 :     int32       buffers_flushed = 0;
     756           4 :     int32       buffers_skipped = 0;
     757             : 
     758           4 :     if (get_call_result_type(fcinfo, NULL, &tupledesc) != TYPEFUNC_COMPOSITE)
     759           0 :         elog(ERROR, "return type must be a row type");
     760             : 
     761           4 :     pg_buffercache_superuser_check("pg_buffercache_evict_all");
     762             : 
     763           2 :     EvictAllUnpinnedBuffers(&buffers_evicted, &buffers_flushed,
     764             :                             &buffers_skipped);
     765             : 
     766           2 :     values[0] = Int32GetDatum(buffers_evicted);
     767           2 :     values[1] = Int32GetDatum(buffers_flushed);
     768           2 :     values[2] = Int32GetDatum(buffers_skipped);
     769             : 
     770           2 :     tuple = heap_form_tuple(tupledesc, values, nulls);
     771           2 :     result = HeapTupleGetDatum(tuple);
     772             : 
     773           2 :     PG_RETURN_DATUM(result);
     774             : }

Generated by: LCOV version 1.14