#include "postgres.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "catalog/namespace.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "pageinspect.h"
#include "storage/bufmgr.h"
#include "storage/checksum.h"
#include "utils/builtins.h"
#include "utils/pg_lsn.h"
#include "utils/rel.h"
#include "utils/varlena.h"

Include dependency graph for rawpage.c:

Functions
static bytea *	get_raw_page_internal (text *relname, ForkNumber forknum, BlockNumber blkno)

	PG_FUNCTION_INFO_V1 (get_raw_page_1_9)

Datum	get_raw_page_1_9 (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (get_raw_page)

Datum	get_raw_page (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (get_raw_page_fork_1_9)

Datum	get_raw_page_fork_1_9 (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (get_raw_page_fork)

Datum	get_raw_page_fork (PG_FUNCTION_ARGS)

Page	get_page_from_raw (bytea *raw_page)

	PG_FUNCTION_INFO_V1 (page_header)

Datum	page_header (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (page_checksum_1_9)

	PG_FUNCTION_INFO_V1 (page_checksum)

static Datum	page_checksum_internal (PG_FUNCTION_ARGS, enum pageinspect_version ext_version)

Datum	page_checksum_1_9 (PG_FUNCTION_ARGS)

Datum	page_checksum (PG_FUNCTION_ARGS)

Variables
	PG_MODULE_MAGIC

Function Documentation

◆ get_page_from_raw()

Page get_page_from_raw ( bytea * raw_page )

Definition at line 215 of file rawpage.c.

References ereport, errcode(), errdetail(), errmsg(), ERROR, page_header(), palloc(), PG_FUNCTION_INFO_V1(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), gist_page_items(), gist_page_items_bytea(), gist_page_opaque_info(), and verify_hash_page().

 {
     Page        page;
     int         raw_page_size;
 
     raw_page_size = VARSIZE_ANY_EXHDR(raw_page);
 
     if (raw_page_size != BLCKSZ)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("invalid page size"),
                  errdetail("Expected %d bytes, got %d.",
                            BLCKSZ, raw_page_size)));
 
     page = palloc(raw_page_size);
 
     memcpy(page, VARDATA_ANY(raw_page), raw_page_size);
 
     return page;
 }

◆ get_raw_page()

Datum get_raw_page ( PG_FUNCTION_ARGS )

Definition at line 68 of file rawpage.c.

References ereport, errhint(), errmsg(), ERROR, get_raw_page_fork_1_9(), get_raw_page_internal(), MAIN_FORKNUM, PG_FUNCTION_INFO_V1(), PG_GETARG_TEXT_PP, PG_GETARG_UINT32, PG_NARGS, PG_RETURN_BYTEA_P, and relname.

Referenced by get_raw_page_1_9().

 {
     text       *relname = PG_GETARG_TEXT_PP(0);
     uint32      blkno = PG_GETARG_UINT32(1);
     bytea      *raw_page;
 
     /*
      * We don't normally bother to check the number of arguments to a C
      * function, but here it's needed for safety because early 8.4 beta
      * releases mistakenly redefined get_raw_page() as taking three arguments.
      */
     if (PG_NARGS() != 2)
         ereport(ERROR,
                 (errmsg("wrong number of arguments to get_raw_page()"),
                  errhint("Run the updated pageinspect.sql script.")));
 
     raw_page = get_raw_page_internal(relname, MAIN_FORKNUM, blkno);
 
     PG_RETURN_BYTEA_P(raw_page);
 }

◆ get_raw_page_1_9()

Datum get_raw_page_1_9 ( PG_FUNCTION_ARGS )

Definition at line 46 of file rawpage.c.

References ereport, errcode(), errmsg(), ERROR, get_raw_page(), get_raw_page_internal(), MAIN_FORKNUM, MaxBlockNumber, PG_FUNCTION_INFO_V1(), PG_GETARG_INT64, PG_GETARG_TEXT_PP, PG_RETURN_BYTEA_P, and relname.

 {
     text       *relname = PG_GETARG_TEXT_PP(0);
     int64       blkno = PG_GETARG_INT64(1);
     bytea      *raw_page;
 
     if (blkno < 0 || blkno > MaxBlockNumber)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("invalid block number")));
 
     raw_page = get_raw_page_internal(relname, MAIN_FORKNUM, blkno);
 
     PG_RETURN_BYTEA_P(raw_page);
 }

◆ get_raw_page_fork()

Datum get_raw_page_fork ( PG_FUNCTION_ARGS )

Definition at line 123 of file rawpage.c.

References forkname_to_number(), get_raw_page_internal(), PG_GETARG_TEXT_PP, PG_GETARG_UINT32, PG_RETURN_BYTEA_P, relname, and text_to_cstring().

Referenced by get_raw_page_fork_1_9().

 {
     text       *relname = PG_GETARG_TEXT_PP(0);
     text       *forkname = PG_GETARG_TEXT_PP(1);
     uint32      blkno = PG_GETARG_UINT32(2);
     bytea      *raw_page;
     ForkNumber  forknum;
 
     forknum = forkname_to_number(text_to_cstring(forkname));
 
     raw_page = get_raw_page_internal(relname, forknum, blkno);
 
     PG_RETURN_BYTEA_P(raw_page);
 }

◆ get_raw_page_fork_1_9()

Datum get_raw_page_fork_1_9 ( PG_FUNCTION_ARGS )

Definition at line 97 of file rawpage.c.

References ereport, errcode(), errmsg(), ERROR, forkname_to_number(), get_raw_page_fork(), get_raw_page_internal(), MaxBlockNumber, PG_FUNCTION_INFO_V1(), PG_GETARG_INT64, PG_GETARG_TEXT_PP, PG_RETURN_BYTEA_P, relname, and text_to_cstring().

Referenced by get_raw_page().

 {
     text       *relname = PG_GETARG_TEXT_PP(0);
     text       *forkname = PG_GETARG_TEXT_PP(1);
     int64       blkno = PG_GETARG_INT64(2);
     bytea      *raw_page;
     ForkNumber  forknum;
 
     forknum = forkname_to_number(text_to_cstring(forkname));
 
     if (blkno < 0 || blkno > MaxBlockNumber)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("invalid block number")));
 
     raw_page = get_raw_page_internal(relname, forknum, blkno);
 
     PG_RETURN_BYTEA_P(raw_page);
 }

◆ get_raw_page_internal()

static bytea * get_raw_page_internal	(	text *	relname,
		ForkNumber	forknum,
		BlockNumber	blkno
	)

static

Definition at line 142 of file rawpage.c.

References AccessShareLock, buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage, ereport, errcode(), errdetail_relkind_not_supported(), errmsg(), ERROR, LockBuffer(), makeRangeVarFromNameList(), palloc(), RBM_NORMAL, RelationData::rd_rel, ReadBufferExtended(), relation_close(), RELATION_IS_OTHER_TEMP, relation_openrv(), RelationGetNumberOfBlocksInFork(), RelationGetRelationName, ReleaseBuffer(), SET_VARSIZE, superuser(), textToQualifiedNameList(), VARDATA, and VARHDRSZ.

Referenced by get_raw_page(), get_raw_page_1_9(), get_raw_page_fork(), and get_raw_page_fork_1_9().

 {
     bytea      *raw_page;
     RangeVar   *relrv;
     Relation    rel;
     char       *raw_page_data;
     Buffer      buf;
 
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser to use raw page functions")));
 
     relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
     rel = relation_openrv(relrv, AccessShareLock);
 
     if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("cannot get raw page from relation \"%s\"",
                         RelationGetRelationName(rel)),
                  errdetail_relkind_not_supported(rel->rd_rel->relkind)));
 
     /*
      * Reject attempts to read non-local temporary relations; we would be
      * likely to get wrong data since we have no visibility into the owning
      * session's local buffers.
      */
     if (RELATION_IS_OTHER_TEMP(rel))
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("cannot access temporary tables of other sessions")));
 
     if (blkno >= RelationGetNumberOfBlocksInFork(rel, forknum))
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("block number %u is out of range for relation \"%s\"",
                         blkno, RelationGetRelationName(rel))));
 
     /* Initialize buffer to copy to */
     raw_page = (bytea *) palloc(BLCKSZ + VARHDRSZ);
     SET_VARSIZE(raw_page, BLCKSZ + VARHDRSZ);
     raw_page_data = VARDATA(raw_page);
 
     /* Take a verbatim copy of the page */
 
     buf = ReadBufferExtended(rel, forknum, blkno, RBM_NORMAL, NULL);
     LockBuffer(buf, BUFFER_LOCK_SHARE);
 
     memcpy(raw_page_data, BufferGetPage(buf), BLCKSZ);
 
     LockBuffer(buf, BUFFER_LOCK_UNLOCK);
     ReleaseBuffer(buf);
 
     relation_close(rel, AccessShareLock);
 
     return raw_page;
 }

◆ page_checksum()

Datum page_checksum ( PG_FUNCTION_ARGS )

Definition at line 391 of file rawpage.c.

References page_checksum_internal(), and PAGEINSPECT_V1_8.

Referenced by page_header().

 {
     return page_checksum_internal(fcinfo, PAGEINSPECT_V1_8);
 }

◆ page_checksum_1_9()

Datum page_checksum_1_9 ( PG_FUNCTION_ARGS )

Definition at line 382 of file rawpage.c.

References page_checksum_internal(), and PAGEINSPECT_V1_9.

Referenced by page_header().

 {
     return page_checksum_internal(fcinfo, PAGEINSPECT_V1_9);
 }

◆ page_checksum_internal()

static Datum page_checksum_internal	(	PG_FUNCTION_ARGS	,
		enum pageinspect_version	ext_version
	)

static

Definition at line 349 of file rawpage.c.

References ereport, errcode(), errmsg(), ERROR, MaxBlockNumber, PAGEINSPECT_V1_8, pg_checksum_page(), PG_GETARG_BYTEA_P, PG_GETARG_INT64, PG_GETARG_UINT32, PG_RETURN_INT16, superuser(), VARDATA, VARHDRSZ, and VARSIZE.

Referenced by page_checksum(), and page_checksum_1_9().

 {
     bytea      *raw_page = PG_GETARG_BYTEA_P(0);
     int64       blkno = (ext_version == PAGEINSPECT_V1_8 ? PG_GETARG_UINT32(1) : PG_GETARG_INT64(1));
     int         raw_page_size;
     PageHeader  page;
 
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser to use raw page functions")));
 
     if (blkno < 0 || blkno > MaxBlockNumber)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("invalid block number")));
 
     raw_page_size = VARSIZE(raw_page) - VARHDRSZ;
 
     /*
      * Check that the supplied page is of the right size.
      */
     if (raw_page_size != BLCKSZ)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("incorrect size of input page (%d bytes)", raw_page_size)));
 
     page = (PageHeader) VARDATA(raw_page);
 
     PG_RETURN_INT16(pg_checksum_page((char *) page, blkno));
 }

◆ page_header()

Datum page_header ( PG_FUNCTION_ARGS )

Definition at line 246 of file rawpage.c.

References Assert, CStringGetTextDatum, elog, ereport, errcode(), errmsg(), ERROR, get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum, Int32GetDatum, LSN_FORMAT_ARGS, LSNGetDatum, page_checksum(), page_checksum_1_9(), PageGetLSN, PageGetPageLayoutVersion, PageGetPageSize, PageHeaderData::pd_checksum, PageHeaderData::pd_flags, PageHeaderData::pd_lower, PageHeaderData::pd_prune_xid, PageHeaderData::pd_special, PageHeaderData::pd_upper, PG_FUNCTION_INFO_V1(), PG_GETARG_BYTEA_P, PG_RETURN_DATUM, SizeOfPageHeaderData, snprintf, superuser(), TransactionIdGetDatum, TupleDescAttr, TYPEFUNC_COMPOSITE, UInt16GetDatum, values, VARDATA, VARHDRSZ, and VARSIZE.

Referenced by get_page_from_raw().

 {
     bytea      *raw_page = PG_GETARG_BYTEA_P(0);
     int         raw_page_size;
 
     TupleDesc   tupdesc;
 
     Datum       result;
     HeapTuple   tuple;
     Datum       values[9];
     bool        nulls[9];
 
     PageHeader  page;
     XLogRecPtr  lsn;
 
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser to use raw page functions")));
 
     raw_page_size = VARSIZE(raw_page) - VARHDRSZ;
 
     /*
      * Check that enough data was supplied, so that we don't try to access
      * fields outside the supplied buffer.
      */
     if (raw_page_size < SizeOfPageHeaderData)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("input page too small (%d bytes)", raw_page_size)));
 
     page = (PageHeader) VARDATA(raw_page);
 
     /* Build a tuple descriptor for our result type */
     if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
         elog(ERROR, "return type must be a row type");
 
     /* Extract information from the page header */
 
     lsn = PageGetLSN(page);
 
     /* pageinspect >= 1.2 uses pg_lsn instead of text for the LSN field. */
     if (TupleDescAttr(tupdesc, 0)->atttypid == TEXTOID)
     {
         char        lsnchar[64];
 
         snprintf(lsnchar, sizeof(lsnchar), "%X/%X", LSN_FORMAT_ARGS(lsn));
         values[0] = CStringGetTextDatum(lsnchar);
     }
     else
         values[0] = LSNGetDatum(lsn);
     values[1] = UInt16GetDatum(page->pd_checksum);
     values[2] = UInt16GetDatum(page->pd_flags);
 
     /* pageinspect >= 1.10 uses int4 instead of int2 for those fields */
     switch (TupleDescAttr(tupdesc, 3)->atttypid)
     {
         case INT2OID:
             Assert(TupleDescAttr(tupdesc, 4)->atttypid == INT2OID &&
                    TupleDescAttr(tupdesc, 5)->atttypid == INT2OID &&
                    TupleDescAttr(tupdesc, 6)->atttypid == INT2OID);
             values[3] = UInt16GetDatum(page->pd_lower);
             values[4] = UInt16GetDatum(page->pd_upper);
             values[5] = UInt16GetDatum(page->pd_special);
             values[6] = UInt16GetDatum(PageGetPageSize(page));
             break;
         case INT4OID:
             Assert(TupleDescAttr(tupdesc, 4)->atttypid == INT4OID &&
                    TupleDescAttr(tupdesc, 5)->atttypid == INT4OID &&
                    TupleDescAttr(tupdesc, 6)->atttypid == INT4OID);
             values[3] = Int32GetDatum(page->pd_lower);
             values[4] = Int32GetDatum(page->pd_upper);
             values[5] = Int32GetDatum(page->pd_special);
             values[6] = Int32GetDatum(PageGetPageSize(page));
             break;
         default:
             elog(ERROR, "incorrect output types");
             break;
     }
 
     values[7] = UInt16GetDatum(PageGetPageLayoutVersion(page));
     values[8] = TransactionIdGetDatum(page->pd_prune_xid);
 
     /* Build and return the tuple. */
 
     memset(nulls, 0, sizeof(nulls));
 
     tuple = heap_form_tuple(tupdesc, values, nulls);
     result = HeapTupleGetDatum(tuple);
 
     PG_RETURN_DATUM(result);
 }

◆ PG_FUNCTION_INFO_V1() [1/7]

PG_FUNCTION_INFO_V1 ( get_raw_page_1_9 )

Referenced by get_page_from_raw(), get_raw_page(), get_raw_page_1_9(), get_raw_page_fork_1_9(), and page_header().

◆ PG_FUNCTION_INFO_V1() [2/7]

PG_FUNCTION_INFO_V1 ( get_raw_page )

◆ PG_FUNCTION_INFO_V1() [3/7]

PG_FUNCTION_INFO_V1 ( get_raw_page_fork_1_9 )

◆ PG_FUNCTION_INFO_V1() [4/7]

PG_FUNCTION_INFO_V1 ( get_raw_page_fork )

◆ PG_FUNCTION_INFO_V1() [5/7]

PG_FUNCTION_INFO_V1 ( page_header )

◆ PG_FUNCTION_INFO_V1() [6/7]

PG_FUNCTION_INFO_V1 ( page_checksum_1_9 )

◆ PG_FUNCTION_INFO_V1() [7/7]

PG_FUNCTION_INFO_V1 ( page_checksum )

Variable Documentation

◆ PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 32 of file rawpage.c.

Functions

Variables