Code cleanup for heap_freeze_tuple.

It used to be case that lazy vacuum could call this function with only
a shared lock on the buffer, but neither lazy vacuum nor any other
code path does that any more.  Simplify the code accordingly and clean
up some related, obsolete comments.

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index c910863e27384f5775376d97e7f5263ca17125d4..3b7894e8f1a133680dbbc8520fe63f8077e8afe9 100644 (file)
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -3947,10 +3947,8 @@ heap_inplace_update(Relation relation, HeapTuple tuple)
  * because this function is applied during WAL recovery, when we don't have
  * access to any such state, and can't depend on the hint bits to be set.)
  *
- * In lazy VACUUM, we call this while initially holding only a shared lock
- * on the tuple's buffer.  If any change is needed, we trade that in for an
- * exclusive lock before making the change.  Caller should pass the buffer ID
- * if shared lock is held, InvalidBuffer if exclusive lock is already held.
+ * If the tuple is in a shared buffer, caller must hold an exclusive lock on
+ * that buffer.
  *
  * Note: it might seem we could make the changes without exclusive lock, since
  * TransactionId read/write is assumed atomic anyway.  However there is a race
@@ -3962,8 +3960,7 @@ heap_inplace_update(Relation relation, HeapTuple tuple)
  * infomask bits.
  */
 bool
-heap_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid,
-                                 Buffer buf)
+heap_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid)
 {
        bool            changed = false;
        TransactionId xid;
@@ -3972,13 +3969,6 @@ heap_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid,
        if (TransactionIdIsNormal(xid) &&
                TransactionIdPrecedes(xid, cutoff_xid))
        {
-               if (buf != InvalidBuffer)
-               {
-                       /* trade in share lock for exclusive lock */
-                       LockBuffer(buf, BUFFER_LOCK_UNLOCK);
-                       LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-                       buf = InvalidBuffer;
-               }
                HeapTupleHeaderSetXmin(tuple, FrozenTransactionId);
 
                /*
@@ -3990,28 +3980,12 @@ heap_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid,
                changed = true;
        }
 
-       /*
-        * When we release shared lock, it's possible for someone else to change
-        * xmax before we get the lock back, so repeat the check after acquiring
-        * exclusive lock.      (We don't need this pushup for xmin, because only
-        * VACUUM could be interested in changing an existing tuple's xmin, and
-        * there's only one VACUUM allowed on a table at a time.)
-        */
-recheck_xmax:
        if (!(tuple->t_infomask & HEAP_XMAX_IS_MULTI))
        {
                xid = HeapTupleHeaderGetXmax(tuple);
                if (TransactionIdIsNormal(xid) &&
                        TransactionIdPrecedes(xid, cutoff_xid))
                {
-                       if (buf != InvalidBuffer)
-                       {
-                               /* trade in share lock for exclusive lock */
-                               LockBuffer(buf, BUFFER_LOCK_UNLOCK);
-                               LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-                               buf = InvalidBuffer;
-                               goto recheck_xmax;              /* see comment above */
-                       }
                        HeapTupleHeaderSetXmax(tuple, InvalidTransactionId);
 
                        /*
@@ -4046,30 +4020,15 @@ recheck_xmax:
        }
 
        /*
-        * Although xvac per se could only be set by old-style VACUUM FULL, it
-        * shares physical storage space with cmax, and so could be wiped out by
-        * someone setting xmax.  Hence recheck after changing lock, same as for
-        * xmax itself.
-        *
         * Old-style VACUUM FULL is gone, but we have to keep this code as long as
         * we support having MOVED_OFF/MOVED_IN tuples in the database.
         */
-recheck_xvac:
        if (tuple->t_infomask & HEAP_MOVED)
        {
                xid = HeapTupleHeaderGetXvac(tuple);
                if (TransactionIdIsNormal(xid) &&
                        TransactionIdPrecedes(xid, cutoff_xid))
                {
-                       if (buf != InvalidBuffer)
-                       {
-                               /* trade in share lock for exclusive lock */
-                               LockBuffer(buf, BUFFER_LOCK_UNLOCK);
-                               LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-                               buf = InvalidBuffer;
-                               goto recheck_xvac;              /* see comment above */
-                       }
-
                        /*
                         * If a MOVED_OFF tuple is not dead, the xvac transaction must
                         * have failed; whereas a non-dead MOVED_IN tuple must mean the
@@ -4711,7 +4670,7 @@ heap_xlog_freeze(XLogRecPtr lsn, XLogRecord *record)
                        ItemId          lp = PageGetItemId(page, *offsets);
                        HeapTupleHeader tuple = (HeapTupleHeader) PageGetItem(page, lp);
 
-                       (void) heap_freeze_tuple(tuple, cutoff_xid, InvalidBuffer);
+                       (void) heap_freeze_tuple(tuple, cutoff_xid);
                        offsets++;
                }
        }

diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
index 31b2b678b6c22568e1cfcffe30341fe2b346f8f7..9a8f05d933168f919f968df1ebde25d2c23b819b 100644 (file)
--- a/src/backend/access/heap/rewriteheap.c
+++ b/src/backend/access/heap/rewriteheap.c
@@ -335,13 +335,8 @@ rewrite_heap_tuple(RewriteState state,
        /*
         * While we have our hands on the tuple, we may as well freeze any
         * very-old xmin or xmax, so that future VACUUM effort can be saved.
-        *
-        * Note we abuse heap_freeze_tuple() a bit here, since it's expecting to
-        * be given a pointer to a tuple in a disk buffer.      It happens though that
-        * we can get the right things to happen by passing InvalidBuffer for the
-        * buffer.
         */
-       heap_freeze_tuple(new_tuple->t_data, state->rs_freeze_xid, InvalidBuffer);
+       heap_freeze_tuple(new_tuple->t_data, state->rs_freeze_xid);
 
        /*
         * Invalid ctid means that ctid should point to the tuple itself. We'll

diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c
index 2fc749e63025ef17fe8d0fd91d311034c9b2c4a5..11e8da1fc1bd44c94272ae85be5a008a45814a14 100644 (file)
--- a/src/backend/commands/vacuumlazy.c
+++ b/src/backend/commands/vacuumlazy.c
@@ -784,8 +784,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
                                 * Each non-removable tuple must be checked to see if it needs
                                 * freezing.  Note we already have exclusive buffer lock.
                                 */
-                               if (heap_freeze_tuple(tuple.t_data, FreezeLimit,
-                                                                         InvalidBuffer))
+                               if (heap_freeze_tuple(tuple.t_data, FreezeLimit))
                                        frozen[nfrozen++] = offnum;
                        }
                }                                               /* scan along page */

diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index fa38803b249ffd2407d77f6efd4e0203975f2349..9d5da7fb3a5981cef1d9f60cb17271a27f186798 100644 (file)
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -111,8 +111,7 @@ extern HTSU_Result heap_lock_tuple(Relation relation, HeapTuple tuple,
                                TransactionId *update_xmax, CommandId cid,
                                LockTupleMode mode, bool nowait);
 extern void heap_inplace_update(Relation relation, HeapTuple tuple);
-extern bool heap_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid,
-                                 Buffer buf);
+extern bool heap_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid);
 extern bool heap_tuple_needs_freeze(HeapTupleHeader tuple, TransactionId cutoff_xid,
                                  Buffer buf);