*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/heap/hio.c,v 1.55 2005/04/29 22:28:23 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/heap/hio.c,v 1.56 2005/05/07 21:32:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
buffer = ReadBuffer(relation, P_NEW);
- /*
- * Release the file-extension lock; it's now OK for someone else to
- * extend the relation some more.
- */
- if (needLock)
- UnlockRelationForExtension(relation, ExclusiveLock);
-
/*
* We can be certain that locking the otherBuffer first is OK, since
* it must have a lower page number.
LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);
/*
- * We need to initialize the empty new page.
+ * Now acquire lock on the new page.
*/
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+
+ /*
+ * Release the file-extension lock; it's now OK for someone else to
+ * extend the relation some more. Note that we cannot release this
+ * lock before we have buffer lock on the new page, or we risk a
+ * race condition against vacuumlazy.c --- see comments therein.
+ */
+ if (needLock)
+ UnlockRelationForExtension(relation, ExclusiveLock);
+
+ /*
+ * We need to initialize the empty new page.
+ */
pageHeader = (Page) BufferGetPage(buffer);
Assert(PageIsNew((PageHeader) pageHeader));
PageInit(pageHeader, BufferGetPageSize(buffer), 0);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtpage.c,v 1.83 2005/04/29 22:28:24 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtpage.c,v 1.84 2005/05/07 21:32:23 tgl Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
buf = ReadBuffer(rel, P_NEW);
+ /* Acquire buffer lock on new page */
+ LockBuffer(buf, BT_WRITE);
+
/*
- * Release the file-extension lock; it's now OK for someone else
- * to extend the relation some more.
+ * Release the file-extension lock; it's now OK for someone else to
+ * extend the relation some more. Note that we cannot release this
+ * lock before we have buffer lock on the new page, or we risk a
+ * race condition against btvacuumcleanup --- see comments therein.
*/
if (needLock)
UnlockRelationForExtension(rel, ExclusiveLock);
- /* Acquire appropriate buffer lock on new page */
- LockBuffer(buf, access);
-
/* Initialize the new page before returning it */
page = BufferGetPage(buf);
+ Assert(PageIsNew((PageHeader) page));
_bt_pageinit(page, BufferGetPageSize(buf));
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtree.c,v 1.128 2005/05/06 17:24:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtree.c,v 1.129 2005/05/07 21:32:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
BlockNumber pages_deleted = 0;
MemoryContext mycontext;
MemoryContext oldcontext;
+ bool needLock;
Assert(stats != NULL);
+ /*
+ * First find out the number of pages in the index. We must acquire
+ * the relation-extension lock while doing this to avoid a race
+ * condition: if someone else is extending the relation, there is
+ * a window where bufmgr/smgr have created a new all-zero page but
+ * it hasn't yet been write-locked by _bt_getbuf(). If we manage to
+ * scan such a page here, we'll improperly assume it can be recycled.
+ * Taking the lock synchronizes things enough to prevent a problem:
+ * either num_pages won't include the new page, or _bt_getbuf already
+ * has write lock on the buffer and it will be fully initialized before
+ * we can examine it. (See also vacuumlazy.c, which has the same issue.)
+ *
+ * We can skip locking for new or temp relations,
+ * however, since no one else could be accessing them.
+ */
+ needLock = !RELATION_IS_LOCAL(rel);
+
+ if (needLock)
+ LockRelationForExtension(rel, ExclusiveLock);
+
num_pages = RelationGetNumberOfBlocks(rel);
+ if (needLock)
+ UnlockRelationForExtension(rel, ExclusiveLock);
+
/* No point in remembering more than MaxFSMPages pages */
maxFreePages = MaxFSMPages;
if ((BlockNumber) maxFreePages > num_pages)
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/vacuumlazy.c,v 1.52 2005/03/25 22:51:31 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/vacuumlazy.c,v 1.53 2005/05/07 21:32:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
if (PageIsNew(page))
{
- /* Not sure we still need to handle this case, but... */
+ /*
+ * An all-zeroes page could be left over if a backend extends
+ * the relation but crashes before initializing the page.
+ * Reclaim such pages for use.
+ *
+ * We have to be careful here because we could be looking at
+ * a page that someone has just added to the relation and not
+ * yet been able to initialize (see RelationGetBufferForTuple).
+ * To interlock against that, release the buffer read lock
+ * (which we must do anyway) and grab the relation extension
+ * lock before re-locking in exclusive mode. If the page is
+ * still uninitialized by then, it must be left over from a
+ * crashed backend, and we can initialize it.
+ *
+ * We don't really need the relation lock when this is a new
+ * or temp relation, but it's probably not worth the code space
+ * to check that, since this surely isn't a critical path.
+ *
+ * Note: the comparable code in vacuum.c need not do all this
+ * because it's got exclusive lock on the whole relation.
+ */
LockBuffer(buf, BUFFER_LOCK_UNLOCK);
+ LockRelationForExtension(onerel, ExclusiveLock);
+ UnlockRelationForExtension(onerel, ExclusiveLock);
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
if (PageIsNew(page))
{
projects / postgresql / commitdiff