Fix pageinspect failures on hash indexes.

Make every page in a hash index which isn't all-zeroes have a valid
special space, so that tools like pageinspect don't error out.

Also, make pageinspect cope with all-zeroes pages, because
_hash_alloc_buckets can leave behind large numbers of those until
they're consumed by splits.

Ashutosh Sharma and Robert Haas, reviewed by Amit Kapila.
Original trouble report from Jeff Janes.

Discussion: http://postgr.es/m/CAMkU=1y6NjKmqbJ8wLMhr=F74WzcMALYWcVFhEpm7i=mV=XsOg@mail.gmail.com

diff --git a/contrib/pageinspect/hashfuncs.c b/contrib/pageinspect/hashfuncs.c
index 812a03f12145c6eacb919cd7cbd66421ff4bf169..dd00aaa81a6941f05bf8a35f7cda3bbed24f96bc 100644 (file)
--- a/contrib/pageinspect/hashfuncs.c
+++ b/contrib/pageinspect/hashfuncs.c
@@ -56,31 +56,33 @@ static Page
 verify_hash_page(bytea *raw_page, int flags)
 {
        Page            page = get_page_from_raw(raw_page);
-       int                     pagetype;
-       HashPageOpaque pageopaque;
+       int                     pagetype = LH_UNUSED_PAGE;
 
-       if (PageIsNew(page))
-               ereport(ERROR,
-                               (errcode(ERRCODE_INDEX_CORRUPTED),
-                                errmsg("index table contains zero page")));
+       /* Treat new pages as unused. */
+       if (!PageIsNew(page))
+       {
+               HashPageOpaque pageopaque;
 
-       if (PageGetSpecialSize(page) != MAXALIGN(sizeof(HashPageOpaqueData)))
-               ereport(ERROR,
-                               (errcode(ERRCODE_INDEX_CORRUPTED),
-                                errmsg("index table contains corrupted page")));
+               if (PageGetSpecialSize(page) != MAXALIGN(sizeof(HashPageOpaqueData)))
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_INDEX_CORRUPTED),
+                                        errmsg("index table contains corrupted page")));
 
-       pageopaque = (HashPageOpaque) PageGetSpecialPointer(page);
-       if (pageopaque->hasho_page_id != HASHO_PAGE_ID)
-               ereport(ERROR,
-                               (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-                                errmsg("page is not a hash page"),
-                                errdetail("Expected %08x, got %08x.",
-                                                  HASHO_PAGE_ID, pageopaque->hasho_page_id)));
+               pageopaque = (HashPageOpaque) PageGetSpecialPointer(page);
+               if (pageopaque->hasho_page_id != HASHO_PAGE_ID)
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+                                        errmsg("page is not a hash page"),
+                                        errdetail("Expected %08x, got %08x.",
+                                                          HASHO_PAGE_ID, pageopaque->hasho_page_id)));
+
+               pagetype = pageopaque->hasho_flag & LH_PAGE_TYPE;
+       }
 
        /* Check that page type is sane. */
-       pagetype = pageopaque->hasho_flag & LH_PAGE_TYPE;
        if (pagetype != LH_OVERFLOW_PAGE && pagetype != LH_BUCKET_PAGE &&
-               pagetype != LH_BITMAP_PAGE && pagetype != LH_META_PAGE)
+               pagetype != LH_BITMAP_PAGE && pagetype != LH_META_PAGE &&
+               pagetype != LH_UNUSED_PAGE)
                ereport(ERROR,
                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 errmsg("invalid hash page type %08x", pagetype)));
@@ -190,19 +192,25 @@ hash_page_type(PG_FUNCTION_ARGS)
                                 (errmsg("must be superuser to use raw page functions"))));
 
        page = verify_hash_page(raw_page, 0);
-       opaque = (HashPageOpaque) PageGetSpecialPointer(page);
-
-       /* page type (flags) */
-       if (opaque->hasho_flag & LH_META_PAGE)
-               type = "metapage";
-       else if (opaque->hasho_flag & LH_OVERFLOW_PAGE)
-               type = "overflow";
-       else if (opaque->hasho_flag & LH_BUCKET_PAGE)
-               type = "bucket";
-       else if (opaque->hasho_flag & LH_BITMAP_PAGE)
-               type = "bitmap";
-       else
+
+       if (PageIsNew(page))
                type = "unused";
+       else
+       {
+               opaque = (HashPageOpaque) PageGetSpecialPointer(page);
+
+               /* page type (flags) */
+               if (opaque->hasho_flag & LH_META_PAGE)
+                       type = "metapage";
+               else if (opaque->hasho_flag & LH_OVERFLOW_PAGE)
+                       type = "overflow";
+               else if (opaque->hasho_flag & LH_BUCKET_PAGE)
+                       type = "bucket";
+               else if (opaque->hasho_flag & LH_BITMAP_PAGE)
+                       type = "bitmap";
+               else
+                       type = "unused";
+       }
 
        PG_RETURN_TEXT_P(cstring_to_text(type));
 }

diff --git a/src/backend/access/hash/hash_xlog.c b/src/backend/access/hash/hash_xlog.c
index d9ac42c3945b67e980c799cf2d658dde5facd878..2ccaf469e7850fba7beffbac31501f90f2cd56bc 100644 (file)
--- a/src/backend/access/hash/hash_xlog.c
+++ b/src/backend/access/hash/hash_xlog.c
@@ -697,11 +697,20 @@ hash_xlog_squeeze_page(XLogReaderState *record)
        if (XLogReadBufferForRedo(record, 2, &ovflbuf) == BLK_NEEDS_REDO)
        {
                Page            ovflpage;
+               HashPageOpaque ovflopaque;
 
                ovflpage = BufferGetPage(ovflbuf);
 
                _hash_pageinit(ovflpage, BufferGetPageSize(ovflbuf));
 
+               ovflopaque = (HashPageOpaque) PageGetSpecialPointer(ovflpage);
+
+               ovflopaque->hasho_prevblkno = InvalidBlockNumber;
+               ovflopaque->hasho_nextblkno = InvalidBlockNumber;
+               ovflopaque->hasho_bucket = -1;
+               ovflopaque->hasho_flag = LH_UNUSED_PAGE;
+               ovflopaque->hasho_page_id = HASHO_PAGE_ID;
+
                PageSetLSN(ovflpage, lsn);
                MarkBufferDirty(ovflbuf);
        }

diff --git a/src/backend/access/hash/hashovfl.c b/src/backend/access/hash/hashovfl.c
index 41ef654862f502edc19e50493004b2dacc0a4ccd..d5f502306830ee8a49c9280f88a05a9728116bcd 100644 (file)
--- a/src/backend/access/hash/hashovfl.c
+++ b/src/backend/access/hash/hashovfl.c
@@ -590,11 +590,22 @@ _hash_freeovflpage(Relation rel, Buffer bucketbuf, Buffer ovflbuf,
        }
 
        /*
-        * Initialize the freed overflow page.  Just zeroing the page won't work,
-        * because WAL replay routines expect pages to be initialized. See
-        * explanation of RBM_NORMAL mode atop XLogReadBufferExtended.
+        * Reinitialize the freed overflow page.  Just zeroing the page won't
+        * work, because WAL replay routines expect pages to be initialized. See
+        * explanation of RBM_NORMAL mode atop XLogReadBufferExtended.  We are
+        * careful to make the special space valid here so that tools like
+        * pageinspect won't get confused.
         */
        _hash_pageinit(ovflpage, BufferGetPageSize(ovflbuf));
+
+       ovflopaque = (HashPageOpaque) PageGetSpecialPointer(ovflpage);
+
+       ovflopaque->hasho_prevblkno = InvalidBlockNumber;
+       ovflopaque->hasho_nextblkno = InvalidBlockNumber;
+       ovflopaque->hasho_bucket = -1;
+       ovflopaque->hasho_flag = LH_UNUSED_PAGE;
+       ovflopaque->hasho_page_id = HASHO_PAGE_ID;
+
        MarkBufferDirty(ovflbuf);
 
        if (BufferIsValid(prevbuf))

diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
index b5a1c7ed28e503600bc7b20551ac2faf5e1b046b..3cd4daa32507bbbdedf84311cec1a348d973bddc 100644 (file)
--- a/src/backend/access/hash/hashpage.c
+++ b/src/backend/access/hash/hashpage.c
@@ -993,6 +993,7 @@ _hash_alloc_buckets(Relation rel, BlockNumber firstblock, uint32 nblocks)
        BlockNumber lastblock;
        char            zerobuf[BLCKSZ];
        Page            page;
+       HashPageOpaque ovflopaque;
 
        lastblock = firstblock + nblocks - 1;
 
@@ -1007,10 +1008,19 @@ _hash_alloc_buckets(Relation rel, BlockNumber firstblock, uint32 nblocks)
 
        /*
         * Initialize the page.  Just zeroing the page won't work; see
-        * _hash_freeovflpage for similar usage.
+        * _hash_freeovflpage for similar usage.  We take care to make the
+        * special space valid for the benefit of tools such as pageinspect.
         */
        _hash_pageinit(page, BLCKSZ);
 
+       ovflopaque = (HashPageOpaque) PageGetSpecialPointer(page);
+
+       ovflopaque->hasho_prevblkno = InvalidBlockNumber;
+       ovflopaque->hasho_nextblkno = InvalidBlockNumber;
+       ovflopaque->hasho_bucket = -1;
+       ovflopaque->hasho_flag = LH_UNUSED_PAGE;
+       ovflopaque->hasho_page_id = HASHO_PAGE_ID;
+
        if (RelationNeedsWAL(rel))
                log_newpage(&rel->rd_node,
                                        MAIN_FORKNUM,