From e2b6404c9a9ecb22eec41d010ce786cc27d73fc7 Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Wed, 15 Jun 2016 11:33:27 -0400 Subject: [PATCH] pg_visibility: Add pg_truncate_visibility_map function. This requires some core changes as well so that we can properly WAL-log the truncation. --- contrib/pg_visibility/pg_visibility--1.0--1.1.sql | 6 +++ contrib/pg_visibility/pg_visibility--1.1.sql | 8 ++++ contrib/pg_visibility/pg_visibility.c | 53 +++++++++++++++++++++++ doc/src/sgml/pgvisibility.sgml | 30 ++++++++++--- src/backend/access/rmgrdesc/smgrdesc.c | 3 +- src/backend/catalog/storage.c | 16 ++++--- src/include/catalog/storage_xlog.h | 8 ++++ 7 files changed, 112 insertions(+), 12 deletions(-) diff --git a/contrib/pg_visibility/pg_visibility--1.0--1.1.sql b/contrib/pg_visibility/pg_visibility--1.0--1.1.sql index 2c97dfd..9336b48 100644 --- a/contrib/pg_visibility/pg_visibility--1.0--1.1.sql +++ b/contrib/pg_visibility/pg_visibility--1.0--1.1.sql @@ -13,5 +13,11 @@ RETURNS SETOF tid AS 'MODULE_PATHNAME', 'pg_check_visible' LANGUAGE C STRICT; +CREATE FUNCTION pg_truncate_visibility_map(regclass) +RETURNS void +AS 'MODULE_PATHNAME', 'pg_truncate_visibility_map' +LANGUAGE C STRICT +PARALLEL UNSAFE; -- let's not make this any more dangerous + REVOKE ALL ON FUNCTION pg_check_frozen(regclass) FROM PUBLIC; REVOKE ALL ON FUNCTION pg_check_visible(regclass) FROM PUBLIC; diff --git a/contrib/pg_visibility/pg_visibility--1.1.sql b/contrib/pg_visibility/pg_visibility--1.1.sql index b49b644..0a29967 100644 --- a/contrib/pg_visibility/pg_visibility--1.1.sql +++ b/contrib/pg_visibility/pg_visibility--1.1.sql @@ -57,6 +57,13 @@ RETURNS SETOF tid AS 'MODULE_PATHNAME', 'pg_check_visible' LANGUAGE C STRICT; +-- Truncate the visibility map fork. +CREATE FUNCTION pg_truncate_visibility_map(regclass) +RETURNS void +AS 'MODULE_PATHNAME', 'pg_truncate_visibility_map' +LANGUAGE C STRICT +PARALLEL UNSAFE; -- let's not make this any more dangerous + -- Don't want these to be available to public. REVOKE ALL ON FUNCTION pg_visibility_map(regclass, bigint) FROM PUBLIC; REVOKE ALL ON FUNCTION pg_visibility(regclass, bigint) FROM PUBLIC; @@ -65,3 +72,4 @@ REVOKE ALL ON FUNCTION pg_visibility(regclass) FROM PUBLIC; REVOKE ALL ON FUNCTION pg_visibility_map_summary(regclass) FROM PUBLIC; REVOKE ALL ON FUNCTION pg_check_frozen(regclass) FROM PUBLIC; REVOKE ALL ON FUNCTION pg_check_visible(regclass) FROM PUBLIC; +REVOKE ALL ON FUNCTION pg_truncate_visibility_map(regclass) FROM PUBLIC; diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c index abb92f3..eb3b0ca 100644 --- a/contrib/pg_visibility/pg_visibility.c +++ b/contrib/pg_visibility/pg_visibility.c @@ -11,10 +11,12 @@ #include "access/htup_details.h" #include "access/visibilitymap.h" #include "catalog/pg_type.h" +#include "catalog/storage_xlog.h" #include "funcapi.h" #include "miscadmin.h" #include "storage/bufmgr.h" #include "storage/procarray.h" +#include "storage/smgr.h" #include "utils/rel.h" PG_MODULE_MAGIC; @@ -40,6 +42,7 @@ PG_FUNCTION_INFO_V1(pg_visibility_rel); PG_FUNCTION_INFO_V1(pg_visibility_map_summary); PG_FUNCTION_INFO_V1(pg_check_frozen); PG_FUNCTION_INFO_V1(pg_check_visible); +PG_FUNCTION_INFO_V1(pg_truncate_visibility_map); static TupleDesc pg_visibility_tupdesc(bool include_blkno, bool include_pd); static vbits *collect_visibility_data(Oid relid, bool include_pd); @@ -336,6 +339,56 @@ pg_check_visible(PG_FUNCTION_ARGS) } /* + * Remove the visibility map fork for a relation. If there turn out to be + * any bugs in the visibility map code that require rebuilding the VM, this + * provides users with a way to do it that is cleaner than shutting down the + * server and removing files by hand. + * + * This is a cut-down version of RelationTruncate. + */ +Datum +pg_truncate_visibility_map(PG_FUNCTION_ARGS) +{ + Oid relid = PG_GETARG_OID(0); + Relation rel; + + rel = relation_open(relid, AccessExclusiveLock); + + if (rel->rd_rel->relkind != RELKIND_RELATION && + rel->rd_rel->relkind != RELKIND_MATVIEW && + rel->rd_rel->relkind != RELKIND_TOASTVALUE) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("\"%s\" is not a table, materialized view, or TOAST table", + RelationGetRelationName(rel)))); + + RelationOpenSmgr(rel); + rel->rd_smgr->smgr_vm_nblocks = InvalidBlockNumber; + + visibilitymap_truncate(rel, 0); + + if (RelationNeedsWAL(rel)) + { + xl_smgr_truncate xlrec; + + xlrec.blkno = 0; + xlrec.rnode = rel->rd_node; + xlrec.flags = SMGR_TRUNCATE_VM; + + XLogBeginInsert(); + XLogRegisterData((char *) &xlrec, sizeof(xlrec)); + + XLogInsert(RM_SMGR_ID, XLOG_SMGR_TRUNCATE | XLR_SPECIAL_REL_UPDATE); + } + + /* Don't keep the relation locked any longer than necessary! */ + relation_close(rel, AccessExclusiveLock); + + /* Nothing to return. */ + PG_RETURN_VOID(); +} + +/* * Helper function to construct whichever TupleDesc we need for a particular * call. */ diff --git a/doc/src/sgml/pgvisibility.sgml b/doc/src/sgml/pgvisibility.sgml index 4cdca7d..44e83de 100644 --- a/doc/src/sgml/pgvisibility.sgml +++ b/doc/src/sgml/pgvisibility.sgml @@ -9,14 +9,16 @@ The pg_visibility module provides a means for examining the - visibility map (VM) and page-level visibility information. + visibility map (VM) and page-level visibility information. It also + provides functions to check the integrity of the visibility map and to + force it to be rebuilt. - These routines return information about three different bits. The - all-visible bit in the visibility map indicates that every tuple on - a given page of a relation is visible to every current transaction. The - all-frozen bit in the visibility map indicates that every tuple on the + Three different bits are used to store information about page-level + visibility. The all-visible bit in the visibility map indicates that every + tuple on a given page of a relation is visible to every current transaction. + The all-frozen bit in the visibility map indicates that every tuple on the page is frozen; that is, no future vacuum will need to modify the page until such time as a tuple is inserted, updated, deleted, or locked on that page. The page-level PD_ALL_VISIBLE bit has the @@ -25,7 +27,8 @@ will normally agree, but the page-level bit can sometimes be set while the visibility map bit is clear after a crash recovery; or they can disagree because of a change which occurs after pg_visibility examines - the visibility map and before it examines the data page. + the visibility map and before it examines the data page. Any event which + causes data corruption can also cause these bits to disagree. @@ -118,6 +121,21 @@ + + + pg_truncate_visibility_map(regclass) returns void + + + + Truncates the visibility map for the given relation. This function + is only expected to be useful if you suspect that the visibility map + for the indicated relation is corrupt and wish to rebuild it. The first + VACUUM executed on the given relation after this function + is executed will scan every page in the relation and rebuild the + visibility map. + + + diff --git a/src/backend/access/rmgrdesc/smgrdesc.c b/src/backend/access/rmgrdesc/smgrdesc.c index 0c6e583..242d79a 100644 --- a/src/backend/access/rmgrdesc/smgrdesc.c +++ b/src/backend/access/rmgrdesc/smgrdesc.c @@ -37,7 +37,8 @@ smgr_desc(StringInfo buf, XLogReaderState *record) xl_smgr_truncate *xlrec = (xl_smgr_truncate *) rec; char *path = relpathperm(xlrec->rnode, MAIN_FORKNUM); - appendStringInfo(buf, "%s to %u blocks", path, xlrec->blkno); + appendStringInfo(buf, "%s to %u blocks flags %d", path, + xlrec->blkno, xlrec->flags); pfree(path); } } diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index 67f1906..0d8311c 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -268,6 +268,7 @@ RelationTruncate(Relation rel, BlockNumber nblocks) xlrec.blkno = nblocks; xlrec.rnode = rel->rd_node; + xlrec.flags = SMGR_TRUNCATE_ALL; XLogBeginInsert(); XLogRegisterData((char *) &xlrec, sizeof(xlrec)); @@ -522,17 +523,22 @@ smgr_redo(XLogReaderState *record) */ XLogFlush(lsn); - smgrtruncate(reln, MAIN_FORKNUM, xlrec->blkno); + if ((xlrec->flags & SMGR_TRUNCATE_HEAP) != 0) + { + smgrtruncate(reln, MAIN_FORKNUM, xlrec->blkno); - /* Also tell xlogutils.c about it */ - XLogTruncateRelation(xlrec->rnode, MAIN_FORKNUM, xlrec->blkno); + /* Also tell xlogutils.c about it */ + XLogTruncateRelation(xlrec->rnode, MAIN_FORKNUM, xlrec->blkno); + } /* Truncate FSM and VM too */ rel = CreateFakeRelcacheEntry(xlrec->rnode); - if (smgrexists(reln, FSM_FORKNUM)) + if ((xlrec->flags & SMGR_TRUNCATE_FSM) != 0 && + smgrexists(reln, FSM_FORKNUM)) FreeSpaceMapTruncateRel(rel, xlrec->blkno); - if (smgrexists(reln, VISIBILITYMAP_FORKNUM)) + if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0 && + smgrexists(reln, VISIBILITYMAP_FORKNUM)) visibilitymap_truncate(rel, xlrec->blkno); FreeFakeRelcacheEntry(rel); diff --git a/src/include/catalog/storage_xlog.h b/src/include/catalog/storage_xlog.h index 7207e8b..500e663 100644 --- a/src/include/catalog/storage_xlog.h +++ b/src/include/catalog/storage_xlog.h @@ -36,10 +36,18 @@ typedef struct xl_smgr_create ForkNumber forkNum; } xl_smgr_create; +/* flags for xl_smgr_truncate */ +#define SMGR_TRUNCATE_HEAP 0x0001 +#define SMGR_TRUNCATE_VM 0x0002 +#define SMGR_TRUNCATE_FSM 0x0004 +#define SMGR_TRUNCATE_ALL \ + (SMGR_TRUNCATE_HEAP|SMGR_TRUNCATE_VM|SMGR_TRUNCATE_FSM) + typedef struct xl_smgr_truncate { BlockNumber blkno; RelFileNode rnode; + int flags; } xl_smgr_truncate; extern void log_smgrcreate(RelFileNode *rnode, ForkNumber forkNum); -- 2.5.4 (Apple Git-61)