2007-05-17 21:11:25 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* rawpage.c
|
|
|
|
* Functions to extract a raw page as bytea and inspect it
|
|
|
|
*
|
|
|
|
* Access-method specific inspection functions are in separate files.
|
|
|
|
*
|
2021-01-02 19:06:25 +01:00
|
|
|
* Copyright (c) 2007-2021, PostgreSQL Global Development Group
|
2007-05-17 21:11:25 +02:00
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2010-09-20 22:08:53 +02:00
|
|
|
* contrib/pageinspect/rawpage.c
|
2007-05-17 21:11:25 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "postgres.h"
|
|
|
|
|
2012-08-30 22:15:44 +02:00
|
|
|
#include "access/htup_details.h"
|
2019-01-21 19:18:20 +01:00
|
|
|
#include "access/relation.h"
|
2007-05-17 21:11:25 +02:00
|
|
|
#include "catalog/namespace.h"
|
2014-03-03 13:14:31 +01:00
|
|
|
#include "catalog/pg_type.h"
|
2008-05-12 02:00:54 +02:00
|
|
|
#include "funcapi.h"
|
2007-05-17 21:11:25 +02:00
|
|
|
#include "miscadmin.h"
|
2019-10-23 05:56:22 +02:00
|
|
|
#include "pageinspect.h"
|
2008-05-12 02:00:54 +02:00
|
|
|
#include "storage/bufmgr.h"
|
2017-03-17 14:49:10 +01:00
|
|
|
#include "storage/checksum.h"
|
2008-05-12 02:00:54 +02:00
|
|
|
#include "utils/builtins.h"
|
2014-03-03 13:14:31 +01:00
|
|
|
#include "utils/pg_lsn.h"
|
2011-02-23 18:18:09 +01:00
|
|
|
#include "utils/rel.h"
|
2017-01-21 02:29:53 +01:00
|
|
|
#include "utils/varlena.h"
|
2007-05-17 21:11:25 +02:00
|
|
|
|
|
|
|
PG_MODULE_MAGIC;
|
|
|
|
|
2009-06-08 18:22:44 +02:00
|
|
|
static bytea *get_raw_page_internal(text *relname, ForkNumber forknum,
|
2019-05-22 19:04:48 +02:00
|
|
|
BlockNumber blkno);
|
2009-06-08 18:22:44 +02:00
|
|
|
|
|
|
|
|
2007-05-17 21:11:25 +02:00
|
|
|
/*
|
|
|
|
* get_raw_page
|
|
|
|
*
|
|
|
|
* Returns a copy of a page from shared buffers as a bytea
|
|
|
|
*/
|
2021-01-19 10:28:05 +01:00
|
|
|
PG_FUNCTION_INFO_V1(get_raw_page_1_9);
|
|
|
|
|
|
|
|
Datum
|
|
|
|
get_raw_page_1_9(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* entry point for old extension version
|
|
|
|
*/
|
2007-05-17 21:11:25 +02:00
|
|
|
PG_FUNCTION_INFO_V1(get_raw_page);
|
|
|
|
|
|
|
|
Datum
|
|
|
|
get_raw_page(PG_FUNCTION_ARGS)
|
2009-06-08 18:22:44 +02:00
|
|
|
{
|
2017-03-13 00:35:34 +01:00
|
|
|
text *relname = PG_GETARG_TEXT_PP(0);
|
2009-06-08 18:22:44 +02:00
|
|
|
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_fork
|
|
|
|
*
|
|
|
|
* Same, for any fork
|
|
|
|
*/
|
2021-01-19 10:28:05 +01:00
|
|
|
PG_FUNCTION_INFO_V1(get_raw_page_fork_1_9);
|
|
|
|
|
|
|
|
Datum
|
|
|
|
get_raw_page_fork_1_9(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Entry point for old extension version
|
|
|
|
*/
|
2009-06-08 18:22:44 +02:00
|
|
|
PG_FUNCTION_INFO_V1(get_raw_page_fork);
|
|
|
|
|
|
|
|
Datum
|
|
|
|
get_raw_page_fork(PG_FUNCTION_ARGS)
|
2007-05-17 21:11:25 +02:00
|
|
|
{
|
2017-03-13 00:35:34 +01:00
|
|
|
text *relname = PG_GETARG_TEXT_PP(0);
|
|
|
|
text *forkname = PG_GETARG_TEXT_PP(1);
|
2008-09-30 12:52:14 +02:00
|
|
|
uint32 blkno = PG_GETARG_UINT32(2);
|
2009-06-08 18:22:44 +02:00
|
|
|
bytea *raw_page;
|
2008-10-06 16:13:17 +02:00
|
|
|
ForkNumber forknum;
|
2007-05-17 21:11:25 +02:00
|
|
|
|
2009-06-08 18:22:44 +02:00
|
|
|
forknum = forkname_to_number(text_to_cstring(forkname));
|
|
|
|
|
|
|
|
raw_page = get_raw_page_internal(relname, forknum, blkno);
|
|
|
|
|
|
|
|
PG_RETURN_BYTEA_P(raw_page);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* workhorse
|
|
|
|
*/
|
|
|
|
static bytea *
|
|
|
|
get_raw_page_internal(text *relname, ForkNumber forknum, BlockNumber blkno)
|
|
|
|
{
|
2007-11-15 22:14:46 +01:00
|
|
|
bytea *raw_page;
|
2009-06-08 18:22:44 +02:00
|
|
|
RangeVar *relrv;
|
|
|
|
Relation rel;
|
2007-11-15 22:14:46 +01:00
|
|
|
char *raw_page_data;
|
2007-05-17 21:11:25 +02:00
|
|
|
Buffer buf;
|
|
|
|
|
|
|
|
if (!superuser())
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
2020-01-30 17:32:04 +01:00
|
|
|
errmsg("must be superuser to use raw page functions")));
|
2007-05-17 21:11:25 +02:00
|
|
|
|
|
|
|
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
|
|
|
|
rel = relation_openrv(relrv, AccessShareLock);
|
|
|
|
|
Improve error messages about mismatching relkind
Most error messages about a relkind that was not supported or
appropriate for the command was of the pattern
"relation \"%s\" is not a table, foreign table, or materialized view"
This style can become verbose and tedious to maintain. Moreover, it's
not very helpful: If I'm trying to create a comment on a TOAST table,
which is not supported, then the information that I could have created
a comment on a materialized view is pointless.
Instead, write the primary error message shorter and saying more
directly that what was attempted is not possible. Then, in the detail
message, explain that the operation is not supported for the relkind
the object was. To simplify that, add a new function
errdetail_relkind_not_supported() that does this.
In passing, make use of RELKIND_HAS_STORAGE() where appropriate,
instead of listing out the relkinds individually.
Reviewed-by: Michael Paquier <michael@paquier.xyz>
Reviewed-by: Alvaro Herrera <alvherre@alvh.no-ip.org>
Discussion: https://www.postgresql.org/message-id/flat/dc35a398-37d0-75ce-07ea-1dd71d98f8ec@2ndquadrant.com
2021-07-08 09:38:52 +02:00
|
|
|
if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
|
2007-05-17 21:11:25 +02:00
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
Improve error messages about mismatching relkind
Most error messages about a relkind that was not supported or
appropriate for the command was of the pattern
"relation \"%s\" is not a table, foreign table, or materialized view"
This style can become verbose and tedious to maintain. Moreover, it's
not very helpful: If I'm trying to create a comment on a TOAST table,
which is not supported, then the information that I could have created
a comment on a materialized view is pointless.
Instead, write the primary error message shorter and saying more
directly that what was attempted is not possible. Then, in the detail
message, explain that the operation is not supported for the relkind
the object was. To simplify that, add a new function
errdetail_relkind_not_supported() that does this.
In passing, make use of RELKIND_HAS_STORAGE() where appropriate,
instead of listing out the relkinds individually.
Reviewed-by: Michael Paquier <michael@paquier.xyz>
Reviewed-by: Alvaro Herrera <alvherre@alvh.no-ip.org>
Discussion: https://www.postgresql.org/message-id/flat/dc35a398-37d0-75ce-07ea-1dd71d98f8ec@2ndquadrant.com
2021-07-08 09:38:52 +02:00
|
|
|
errmsg("cannot get raw page from relation \"%s\"",
|
|
|
|
RelationGetRelationName(rel)),
|
|
|
|
errdetail_relkind_not_supported(rel->rd_rel->relkind)));
|
2007-05-17 21:11:25 +02:00
|
|
|
|
2009-04-01 00:54:31 +02:00
|
|
|
/*
|
2009-06-11 16:49:15 +02:00
|
|
|
* 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.
|
2009-04-01 00:54:31 +02:00
|
|
|
*/
|
|
|
|
if (RELATION_IS_OTHER_TEMP(rel))
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
|
|
errmsg("cannot access temporary tables of other sessions")));
|
|
|
|
|
2014-07-22 17:45:46 +02:00
|
|
|
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))));
|
2007-05-17 21:11:25 +02:00
|
|
|
|
|
|
|
/* 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 */
|
|
|
|
|
Unite ReadBufferWithFork, ReadBufferWithStrategy, and ZeroOrReadBuffer
functions into one ReadBufferExtended function, that takes the strategy
and mode as argument. There's three modes, RBM_NORMAL which is the default
used by plain ReadBuffer(), RBM_ZERO, which replaces ZeroOrReadBuffer, and
a new mode RBM_ZERO_ON_ERROR, which allows callers to read corrupt pages
without throwing an error. The FSM needs the new mode to recover from
corrupt pages, which could happend if we crash after extending an FSM file,
and the new page is "torn".
Add fork number to some error messages in bufmgr.c, that still lacked it.
2008-10-31 16:05:00 +01:00
|
|
|
buf = ReadBufferExtended(rel, forknum, blkno, RBM_NORMAL, NULL);
|
2007-05-17 21:11:25 +02:00
|
|
|
LockBuffer(buf, BUFFER_LOCK_SHARE);
|
|
|
|
|
2016-04-20 15:31:19 +02:00
|
|
|
memcpy(raw_page_data, BufferGetPage(buf), BLCKSZ);
|
2007-05-17 21:11:25 +02:00
|
|
|
|
|
|
|
LockBuffer(buf, BUFFER_LOCK_UNLOCK);
|
|
|
|
ReleaseBuffer(buf);
|
|
|
|
|
|
|
|
relation_close(rel, AccessShareLock);
|
|
|
|
|
2009-06-08 18:22:44 +02:00
|
|
|
return raw_page;
|
2007-05-17 21:11:25 +02:00
|
|
|
}
|
|
|
|
|
2017-02-03 17:34:41 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* get_page_from_raw
|
|
|
|
*
|
|
|
|
* Get a palloc'd, maxalign'ed page image from the result of get_raw_page()
|
|
|
|
*
|
|
|
|
* On machines with MAXALIGN = 8, the payload of a bytea is not maxaligned,
|
|
|
|
* since it will start 4 bytes into a palloc'd value. On alignment-picky
|
|
|
|
* machines, this will cause failures in accesses to 8-byte-wide values
|
|
|
|
* within the page. We don't need to worry if accessing only 4-byte or
|
|
|
|
* smaller fields, but when examining a struct that contains 8-byte fields,
|
|
|
|
* use this function for safety.
|
|
|
|
*/
|
|
|
|
Page
|
|
|
|
get_page_from_raw(bytea *raw_page)
|
|
|
|
{
|
|
|
|
Page page;
|
|
|
|
int raw_page_size;
|
|
|
|
|
2017-03-13 00:35:34 +01:00
|
|
|
raw_page_size = VARSIZE_ANY_EXHDR(raw_page);
|
2017-02-03 17:34:41 +01:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2017-03-13 00:35:34 +01:00
|
|
|
memcpy(page, VARDATA_ANY(raw_page), raw_page_size);
|
2017-02-03 17:34:41 +01:00
|
|
|
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-05-17 21:11:25 +02:00
|
|
|
/*
|
|
|
|
* page_header
|
|
|
|
*
|
|
|
|
* Allows inspection of page header fields of a raw page
|
|
|
|
*/
|
|
|
|
|
|
|
|
PG_FUNCTION_INFO_V1(page_header);
|
|
|
|
|
|
|
|
Datum
|
|
|
|
page_header(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
bytea *raw_page = PG_GETARG_BYTEA_P(0);
|
|
|
|
int raw_page_size;
|
|
|
|
|
|
|
|
TupleDesc tupdesc;
|
|
|
|
|
|
|
|
Datum result;
|
|
|
|
HeapTuple tuple;
|
2007-09-21 23:25:42 +02:00
|
|
|
Datum values[9];
|
|
|
|
bool nulls[9];
|
2007-05-17 21:11:25 +02:00
|
|
|
|
|
|
|
PageHeader page;
|
|
|
|
XLogRecPtr lsn;
|
|
|
|
|
|
|
|
if (!superuser())
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
2020-01-30 17:32:04 +01:00
|
|
|
errmsg("must be superuser to use raw page functions")));
|
2007-05-17 21:11:25 +02:00
|
|
|
|
|
|
|
raw_page_size = VARSIZE(raw_page) - VARHDRSZ;
|
|
|
|
|
|
|
|
/*
|
2007-11-15 22:14:46 +01:00
|
|
|
* Check that enough data was supplied, so that we don't try to access
|
|
|
|
* fields outside the supplied buffer.
|
2007-05-17 21:11:25 +02:00
|
|
|
*/
|
2015-02-20 06:11:42 +01:00
|
|
|
if (raw_page_size < SizeOfPageHeaderData)
|
2007-11-15 22:14:46 +01:00
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("input page too small (%d bytes)", raw_page_size)));
|
2007-05-17 21:11:25 +02:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2014-03-03 13:14:31 +01:00
|
|
|
/* pageinspect >= 1.2 uses pg_lsn instead of text for the LSN field. */
|
2017-08-20 20:19:07 +02:00
|
|
|
if (TupleDescAttr(tupdesc, 0)->atttypid == TEXTOID)
|
2014-03-03 13:14:31 +01:00
|
|
|
{
|
2014-05-06 18:12:18 +02:00
|
|
|
char lsnchar[64];
|
|
|
|
|
2021-02-23 10:14:38 +01:00
|
|
|
snprintf(lsnchar, sizeof(lsnchar), "%X/%X", LSN_FORMAT_ARGS(lsn));
|
2014-03-03 13:14:31 +01:00
|
|
|
values[0] = CStringGetTextDatum(lsnchar);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
values[0] = LSNGetDatum(lsn);
|
2013-03-18 14:46:42 +01:00
|
|
|
values[1] = UInt16GetDatum(page->pd_checksum);
|
2007-05-17 21:11:25 +02:00
|
|
|
values[2] = UInt16GetDatum(page->pd_flags);
|
2021-07-12 04:05:27 +02:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2007-05-17 21:11:25 +02:00
|
|
|
values[7] = UInt16GetDatum(PageGetPageLayoutVersion(page));
|
2007-09-21 23:25:42 +02:00
|
|
|
values[8] = TransactionIdGetDatum(page->pd_prune_xid);
|
2007-05-17 21:11:25 +02:00
|
|
|
|
2007-11-15 22:14:46 +01:00
|
|
|
/* Build and return the tuple. */
|
2007-05-17 21:11:25 +02:00
|
|
|
|
|
|
|
memset(nulls, 0, sizeof(nulls));
|
|
|
|
|
2007-11-15 22:14:46 +01:00
|
|
|
tuple = heap_form_tuple(tupdesc, values, nulls);
|
|
|
|
result = HeapTupleGetDatum(tuple);
|
2007-05-17 21:11:25 +02:00
|
|
|
|
|
|
|
PG_RETURN_DATUM(result);
|
|
|
|
}
|
2017-03-17 14:49:10 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* page_checksum
|
|
|
|
*
|
|
|
|
* Compute checksum of a raw page
|
|
|
|
*/
|
|
|
|
|
2021-01-19 10:28:05 +01:00
|
|
|
PG_FUNCTION_INFO_V1(page_checksum_1_9);
|
2017-03-17 14:49:10 +01:00
|
|
|
PG_FUNCTION_INFO_V1(page_checksum);
|
|
|
|
|
2021-01-19 10:28:05 +01:00
|
|
|
static Datum
|
|
|
|
page_checksum_internal(PG_FUNCTION_ARGS, enum pageinspect_version ext_version)
|
2017-03-17 14:49:10 +01:00
|
|
|
{
|
|
|
|
bytea *raw_page = PG_GETARG_BYTEA_P(0);
|
2021-01-19 10:28:05 +01:00
|
|
|
int64 blkno = (ext_version == PAGEINSPECT_V1_8 ? PG_GETARG_UINT32(1) : PG_GETARG_INT64(1));
|
2017-03-17 14:49:10 +01:00
|
|
|
int raw_page_size;
|
|
|
|
PageHeader page;
|
|
|
|
|
|
|
|
if (!superuser())
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
2020-01-30 17:32:04 +01:00
|
|
|
errmsg("must be superuser to use raw page functions")));
|
2017-03-17 14:49:10 +01:00
|
|
|
|
2021-01-19 10:28:05 +01:00
|
|
|
if (blkno < 0 || blkno > MaxBlockNumber)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("invalid block number")));
|
|
|
|
|
2017-03-17 14:49:10 +01:00
|
|
|
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),
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
errmsg("incorrect size of input page (%d bytes)", raw_page_size)));
|
2017-03-17 14:49:10 +01:00
|
|
|
|
|
|
|
page = (PageHeader) VARDATA(raw_page);
|
|
|
|
|
2017-05-17 22:31:56 +02:00
|
|
|
PG_RETURN_INT16(pg_checksum_page((char *) page, blkno));
|
2017-03-17 14:49:10 +01:00
|
|
|
}
|
2021-01-19 10:28:05 +01:00
|
|
|
|
|
|
|
Datum
|
|
|
|
page_checksum_1_9(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
return page_checksum_internal(fcinfo, PAGEINSPECT_V1_9);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Entry point for old extension version
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
page_checksum(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
return page_checksum_internal(fcinfo, PAGEINSPECT_V1_8);
|
|
|
|
}
|