Add support to lock manager for conditionally locking a lock (ie,

return without waiting if we can't get the lock immediately).
Not used yet, but will be needed for concurrent VACUUM.

Author: tglsfdc

contrib/userlock/README.user_locks

@@ -5,9 +5,8 @@ This software is distributed under the GNU General Public License
 either version 2, or (at your option) any later version.
 
 
-This loadable module, together with my user-lock.patch applied to the
-backend, provides support for user-level long-term cooperative locks.
-For example one can write:
+This loadable module provides support for user-level long-term cooperative
+locks.  For example one can write:
 
   select some_fields, user_write_lock_oid(oid) from table where id='key';
 
@@ -26,14 +25,14 @@ After you have finished your work on that item you can do:
 You can also ignore the failure and go ahead but this could produce conflicts
 or inconsistent data in your application. User locks require a cooperative
 behavior between users. User locks don't interfere with the normal locks
-used by postgres for transaction processing.
+used by Postgres for transaction processing.
 
 This could also be done by setting a flag in the record itself but in
 this case you have the overhead of the updates to the records and there
 could be some locks not released if the backend or the application crashes
 before resetting the lock flag.
 It could also be done with a begin/end block but in this case the entire
-table would be locked by postgres and it is not acceptable to do this for
+table would be locked by Postgres and it is not acceptable to do this for
 a long period because other transactions would block completely.
 
 The generic user locks use two values, group and id, to identify a lock,
@@ -44,12 +43,12 @@ use a group equal to 0.
 
 The meaning of group and id is defined by the application. The user
 lock code just takes two numbers and tells you if the corresponding
-entity has been succesfully locked. What this mean is up to you.
+entity has been successfully locked. What this means is up to you.
 
-My succestion is that you use the group to identify an area of your
+My suggestion is that you use the group to identify an area of your
 application and the id to identify an object in this area.
 Or you can just lock the oid of the tuples which are by definition unique.
 
 Note also that a process can acquire more than one lock on the same entity
 and it must release the lock the corresponding number of times. This can
-be done calling the unlock funtion until it returns 0.
+be done by calling the unlock function until it returns 0.

contrib/userlock/user_locks.c

@@ -1,27 +1,23 @@
 /*
  * user_locks.c --
  *
- * This loadable module, together with my user-lock.patch applied to the
- * backend, provides support for user-level long-term cooperative locks.
+ * This loadable module provides support for user-level long-term
+ * cooperative locks.
  *
  * Copyright (C) 1999, Massimo Dal Zotto <dz@cs.unitn.it>
  *
  * This software is distributed under the GNU General Public License
  * either version 2, or (at your option) any later version.
  */
-
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
 #include "postgres.h"
+
 #include "miscadmin.h"
 #include "storage/lmgr.h"
 #include "storage/proc.h"
-#include "utils/elog.h"
 
 #include "user_locks.h"
 
+
 int
 user_lock(uint32 id1, uint32 id2, LOCKMODE lockmode)
 {
@@ -33,7 +29,8 @@ user_lock(uint32 id1, uint32 id2, LOCKMODE lockmode)
 	tag.objId.blkno = (BlockNumber) id2;
 	tag.offnum = (OffsetNumber) (id1 & 0xffff);
 
-	return LockAcquire(USER_LOCKMETHOD, &tag, InvalidTransactionId, lockmode);
+	return LockAcquire(USER_LOCKMETHOD, &tag, InvalidTransactionId,
+					   lockmode, true);
 }
 
 int

src/backend/storage/lmgr/lmgr.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.47 2001/06/19 19:42:16 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.48 2001/06/22 00:04:59 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -24,45 +24,52 @@
 
 
 static LOCKMASK LockConflicts[] = {
-	(int) NULL,
+	0,
 
-/* AccessShareLock */
+	/* AccessShareLock */
 	(1 << AccessExclusiveLock),
 
-/* RowShareLock */
+	/* RowShareLock */
 	(1 << ExclusiveLock) | (1 << AccessExclusiveLock),
 
-/* RowExclusiveLock */
+	/* RowExclusiveLock */
 	(1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) | (1 << ShareLock) |
 	(1 << AccessExclusiveLock),
 
-/* ShareLock */
+	/* ShareLock */
 	(1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) |
 	(1 << RowExclusiveLock) | (1 << AccessExclusiveLock),
 
-/* ShareRowExclusiveLock */
+	/* ShareRowExclusiveLock */
 	(1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) |
 	(1 << ShareLock) | (1 << RowExclusiveLock) | (1 << AccessExclusiveLock),
 
-/* ExclusiveLock */
+	/* ExclusiveLock */
 	(1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) | (1 << ShareLock) |
 	(1 << RowExclusiveLock) | (1 << RowShareLock) | (1 << AccessExclusiveLock),
 
-/* AccessExclusiveLock */
+	/* AccessExclusiveLock */
 	(1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) | (1 << ShareLock) |
-	(1 << RowExclusiveLock) | (1 << RowShareLock) | (1 << AccessExclusiveLock) |
-	(1 << AccessShareLock),
+	(1 << RowExclusiveLock) | (1 << RowShareLock) |
+	(1 << AccessExclusiveLock) | (1 << AccessShareLock)
 
 };
 
 static int	LockPrios[] = {
-	(int) NULL,
+	0,
+	/* AccessShareLock */
 	1,
+	/* RowShareLock */
 	2,
+	/* RowExclusiveLock */
 	3,
+	/* ShareLock */
 	4,
+	/* ShareRowExclusiveLock */
 	5,
+	/* ExclusiveLock */
 	6,
+	/* AccessExclusiveLock */
 	7
 };
 
@@ -134,7 +141,8 @@ LockRelation(Relation relation, LOCKMODE lockmode)
 	tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
 	tag.objId.blkno = InvalidBlockNumber;
 
-	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(), lockmode))
+	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
+					 lockmode, false))
 		elog(ERROR, "LockRelation: LockAcquire failed");
 
 	/*
@@ -148,6 +156,45 @@ LockRelation(Relation relation, LOCKMODE lockmode)
 	RelationDecrementReferenceCount(relation);
 }
 
+/*
+ *		ConditionalLockRelation
+ *
+ * As above, but only lock if we can get the lock without blocking.
+ * Returns TRUE iff the lock was acquired.
+ *
+ * NOTE: we do not currently need conditional versions of the other
+ * LockXXX routines in this file, but they could easily be added if needed.
+ */
+bool
+ConditionalLockRelation(Relation relation, LOCKMODE lockmode)
+{
+	LOCKTAG		tag;
+
+	if (LockingDisabled())
+		return true;
+
+	MemSet(&tag, 0, sizeof(tag));
+	tag.relId = relation->rd_lockInfo.lockRelId.relId;
+	tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
+	tag.objId.blkno = InvalidBlockNumber;
+
+	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
+					 lockmode, true))
+		return false;
+
+	/*
+	 * Check to see if the relcache entry has been invalidated while we
+	 * were waiting to lock it.  If so, rebuild it, or elog() trying.
+	 * Increment the refcount to ensure that RelationFlushRelation will
+	 * rebuild it and not just delete it.
+	 */
+	RelationIncrementReferenceCount(relation);
+	AcceptInvalidationMessages();
+	RelationDecrementReferenceCount(relation);
+
+	return true;
+}
+
 /*
  *		UnlockRelation
  */
@@ -192,7 +239,8 @@ LockRelationForSession(LockRelId *relid, LOCKMODE lockmode)
 	tag.dbId = relid->dbId;
 	tag.objId.blkno = InvalidBlockNumber;
 
-	if (!LockAcquire(LockTableId, &tag, InvalidTransactionId, lockmode))
+	if (!LockAcquire(LockTableId, &tag, InvalidTransactionId,
+					 lockmode, false))
 		elog(ERROR, "LockRelationForSession: LockAcquire failed");
 }
 
@@ -231,7 +279,8 @@ LockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)
 	tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
 	tag.objId.blkno = blkno;
 
-	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(), lockmode))
+	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
+					 lockmode, false))
 		elog(ERROR, "LockPage: LockAcquire failed");
 }
 
@@ -267,7 +316,8 @@ XactLockTableInsert(TransactionId xid)
 	tag.dbId = InvalidOid;		/* xids are globally unique */
 	tag.objId.xid = xid;
 
-	if (!LockAcquire(LockTableId, &tag, xid, ExclusiveLock))
+	if (!LockAcquire(LockTableId, &tag, xid,
+					 ExclusiveLock, false))
 		elog(ERROR, "XactLockTableInsert: LockAcquire failed");
 }
 
@@ -303,7 +353,8 @@ XactLockTableWait(TransactionId xid)
 	tag.dbId = InvalidOid;
 	tag.objId.xid = xid;
 
-	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(), ShareLock))
+	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
+					 ShareLock, false))
 		elog(ERROR, "XactLockTableWait: LockAcquire failed");
 
 	LockRelease(LockTableId, &tag, GetCurrentTransactionId(), ShareLock);