Lock before setting relhassubclass on RELKIND_PARTITIONED_INDEX.

Commit 5b562644fec696977df4a82790064e8287927891 added a comment that
SetRelationHasSubclass() callers must hold this lock.  When commit
17f206fbc824d2b4b14480199ca9ff7dea417eda extended use of this column to
partitioned indexes, it didn't take the lock.  As the latter commit
message mentioned, we currently never reset a partitioned index to
relhassubclass=f.  That largely avoids harm from the lock omission.  The
cause for fixing this now is to unblock introducing a rule about locks
required to heap_update() a pg_class row.  This might cause more
deadlocks.  It gives minor user-visible benefits:

- If an ALTER INDEX SET TABLESPACE runs concurrently with ALTER TABLE
  ATTACH PARTITION or CREATE PARTITION OF, one transaction blocks
  instead of failing with "tuple concurrently updated".  (Many cases of
  DDL concurrency still fail that way.)

- Match ALTER INDEX ATTACH PARTITION in choosing to lock the index.

While not user-visible today, we'll need this if we ever make something
set the flag to false for a partitioned index, like ANALYZE does today
for tables.  Back-patch to v12 (all supported versions), the plan for
the commit relying on the new rule.  In back branches, add
LockOrStrongerHeldByMe() instead of adding a LockHeldByMe() parameter.

Reviewed (in an earlier version) by Robert Haas.

Discussion: https://postgr.es/m/20240611024525[email protected]

diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 4334cd7499c6e76e2dd4eea3b0cda8d648c72eed..96aade9abd472927ff3630de8055749bc86ccbae 100644 (file)
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -1005,6 +1005,7 @@ index_create(Relation heapRelation,
    if (OidIsValid(parentIndexRelid))
    {
        StoreSingleInheritance(indexRelationId, parentIndexRelid, 1);
+       LockRelationOid(parentIndexRelid, ShareUpdateExclusiveLock);
        SetRelationHasSubclass(parentIndexRelid, true);
    }
 

diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index c02bdade0ebdbf291c954b3cd16e84559d96e89f..5f533dbcbcc1e640db96dcba59a2ac06bae64202 100644 (file)
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -3727,7 +3727,10 @@ IndexSetParentIndex(Relation partitionIdx, Oid parentOid)
 
    /* set relhassubclass if an index partition has been added to the parent */
    if (OidIsValid(parentOid))
+   {
+       LockRelationOid(parentOid, ShareUpdateExclusiveLock);
        SetRelationHasSubclass(parentOid, true);
+   }
 
    /* set relispartition correctly on the partition */
    update_relispartition(partRelid, OidIsValid(parentOid));

diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 7642334b376971e18a67bb939795e86758bc2816..c0c707ca03bd4522192cecf6713de936160c1d88 100644 (file)
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2975,8 +2975,15 @@ findAttrByName(const char *attributeName, List *schema)
  * SetRelationHasSubclass
  *     Set the value of the relation's relhassubclass field in pg_class.
  *
- * NOTE: caller must be holding an appropriate lock on the relation.
- * ShareUpdateExclusiveLock is sufficient.
+ * It's always safe to set this field to true, because all SQL commands are
+ * ready to see true and then find no children.  On the other hand, commands
+ * generally assume zero children if this is false.
+ *
+ * Caller must hold any self-exclusive lock until end of transaction.  If the
+ * new value is false, caller must have acquired that lock before reading the
+ * evidence that justified the false value.  That way, it properly waits if
+ * another backend is simultaneously concluding no need to change the tuple
+ * (new and old values are true).
  *
  * NOTE: an important side-effect of this operation is that an SI invalidation
  * message is sent out to all backends --- including me --- causing plans
@@ -2991,6 +2998,11 @@ SetRelationHasSubclass(Oid relationId, bool relhassubclass)
    HeapTuple   tuple;
    Form_pg_class classtuple;
 
+   Assert(CheckRelationOidLockedByMe(relationId,
+                                     ShareUpdateExclusiveLock, false) ||
+          CheckRelationOidLockedByMe(relationId,
+                                     ShareRowExclusiveLock, true));
+
    /*
     * Fetch a modifiable copy of the tuple, modify it, update pg_class.
     */

diff --git a/src/backend/storage/lmgr/lmgr.c b/src/backend/storage/lmgr/lmgr.c
index cf3eccdff3bfbcb386a90864ddd51bd2d7c670b7..e50ca530700a80149bdde5673d4c29378990a3a9 100644 (file)
--- a/src/backend/storage/lmgr/lmgr.c
+++ b/src/backend/storage/lmgr/lmgr.c
@@ -307,32 +307,26 @@ CheckRelationLockedByMe(Relation relation, LOCKMODE lockmode, bool orstronger)
                         relation->rd_lockInfo.lockRelId.dbId,
                         relation->rd_lockInfo.lockRelId.relId);
 
-   if (LockHeldByMe(&tag, lockmode))
-       return true;
+   return (orstronger ?
+           LockOrStrongerHeldByMe(&tag, lockmode) :
+           LockHeldByMe(&tag, lockmode));
+}
 
-   if (orstronger)
-   {
-       LOCKMODE    slockmode;
+/*
+ *     CheckRelationOidLockedByMe
+ *
+ * Like the above, but takes an OID as argument.
+ */
+bool
+CheckRelationOidLockedByMe(Oid relid, LOCKMODE lockmode, bool orstronger)
+{
+   LOCKTAG     tag;
 
-       for (slockmode = lockmode + 1;
-            slockmode <= MaxLockMode;
-            slockmode++)
-       {
-           if (LockHeldByMe(&tag, slockmode))
-           {
-#ifdef NOT_USED
-               /* Sometimes this might be useful for debugging purposes */
-               elog(WARNING, "lock mode %s substituted for %s on relation %s",
-                    GetLockmodeName(tag.locktag_lockmethodid, slockmode),
-                    GetLockmodeName(tag.locktag_lockmethodid, lockmode),
-                    RelationGetRelationName(relation));
-#endif
-               return true;
-           }
-       }
-   }
+   SetLocktagRelationOid(&tag, relid);
 
-   return false;
+   return (orstronger ?
+           LockOrStrongerHeldByMe(&tag, lockmode) :
+           LockHeldByMe(&tag, lockmode));
 }
 
 /*

diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c
index c715e08c0ac1131ee11bf3b86d59c2a15b0f4ae7..5e36d91d6150ad77e4ccae90348752064b319f87 100644 (file)
--- a/src/backend/storage/lmgr/lock.c
+++ b/src/backend/storage/lmgr/lock.c
@@ -564,11 +564,17 @@ DoLockModesConflict(LOCKMODE mode1, LOCKMODE mode2)
 }
 
 /*
- * LockHeldByMe -- test whether lock 'locktag' is held with mode 'lockmode'
- *     by the current transaction
+ * LockHeldByMeExtended -- test whether lock 'locktag' is held by the current
+ *     transaction
+ *
+ * Returns true if current transaction holds a lock on 'tag' of mode
+ * 'lockmode'.  If 'orstronger' is true, a stronger lockmode is also OK.
+ * ("Stronger" is defined as "numerically higher", which is a bit
+ * semantically dubious but is OK for the purposes we use this for.)
  */
-bool
-LockHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode)
+static bool
+LockHeldByMeExtended(const LOCKTAG *locktag,
+                    LOCKMODE lockmode, bool orstronger)
 {
    LOCALLOCKTAG localtag;
    LOCALLOCK  *locallock;
@@ -584,7 +590,35 @@ LockHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode)
                                          (void *) &localtag,
                                          HASH_FIND, NULL);
 
-   return (locallock && locallock->nLocks > 0);
+   if (locallock && locallock->nLocks > 0)
+       return true;
+
+   if (orstronger)
+   {
+       LOCKMODE    slockmode;
+
+       for (slockmode = lockmode + 1;
+            slockmode <= MaxLockMode;
+            slockmode++)
+       {
+           if (LockHeldByMeExtended(locktag, slockmode, false))
+               return true;
+       }
+   }
+
+   return false;
+}
+
+bool
+LockHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode)
+{
+   return LockHeldByMeExtended(locktag, lockmode, false);
+}
+
+bool
+LockOrStrongerHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode)
+{
+   return LockHeldByMeExtended(locktag, lockmode, true);
 }
 
 /*

diff --git a/src/include/storage/lmgr.h b/src/include/storage/lmgr.h
index e87b0b5cbfc815a7112aa04d33e134d72349273e..820c2ad99d1cdb7bf90593383547e1a6b27f2ef7 100644 (file)
--- a/src/include/storage/lmgr.h
+++ b/src/include/storage/lmgr.h
@@ -47,6 +47,8 @@ extern bool ConditionalLockRelation(Relation relation, LOCKMODE lockmode);
 extern void UnlockRelation(Relation relation, LOCKMODE lockmode);
 extern bool CheckRelationLockedByMe(Relation relation, LOCKMODE lockmode,
                                    bool orstronger);
+extern bool CheckRelationOidLockedByMe(Oid relid, LOCKMODE lockmode,
+                                      bool orstronger);
 extern bool LockHasWaitersRelation(Relation relation, LOCKMODE lockmode);
 
 extern void LockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode);

diff --git a/src/include/storage/lock.h b/src/include/storage/lock.h
index 8772be203b117cc5b7be382f40ed78373d96cef0..304e2a5c949bcec4fd31a4cc8db122c2583502b9 100644 (file)
--- a/src/include/storage/lock.h
+++ b/src/include/storage/lock.h
@@ -557,6 +557,7 @@ extern void LockReleaseSession(LOCKMETHODID lockmethodid);
 extern void LockReleaseCurrentOwner(LOCALLOCK **locallocks, int nlocks);
 extern void LockReassignCurrentOwner(LOCALLOCK **locallocks, int nlocks);
 extern bool LockHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode);
+extern bool LockOrStrongerHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode);
 extern bool LockHasWaiters(const LOCKTAG *locktag,
                           LOCKMODE lockmode, bool sessionLock);
 extern VirtualTransactionId *GetLockConflicts(const LOCKTAG *locktag,