rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Back out LOCKTAG changes by Rod Taylor, pending code review. Sorry.

This commit is contained in:
Bruce Momjian 2003-02-19 23:41:15 +00:00
parent e2a618fe25
commit 69c049cef4
10 changed files with 73 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
src/backend/commands/typecmds.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.31 2003/02/19 04:02:53 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.32 2003/02/19 23:41:15 momjian Exp $
* *
* DESCRIPTION * DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the * The "DefineFoo" routines take the parse tree and pick out the
@ -353,12 +353,6 @@ RemoveType(List *names, DropBehavior behavior)
elog(ERROR, "Type \"%s\" does not exist", elog(ERROR, "Type \"%s\" does not exist",
TypeNameToString(typename)); TypeNameToString(typename));
/*
* Grab an exclusive lock on the type id, the SearchSysCache confirms
* the type still exists after locking
*/
LockObject(typeoid, RelOid_pg_type, AccessExclusiveLock);
tup = SearchSysCache(TYPEOID, tup = SearchSysCache(TYPEOID,
ObjectIdGetDatum(typeoid), ObjectIdGetDatum(typeoid),
0, 0, 0); 0, 0, 0);
@ -382,9 +376,6 @@ RemoveType(List *names, DropBehavior behavior)
object.objectSubId = 0; object.objectSubId = 0;
performDeletion(&object, behavior); performDeletion(&object, behavior);
/* Hold the lock until the end of the transaction */
UnlockObject(typeoid, RelOid_pg_type, NoLock);
} }
@ -689,7 +680,7 @@ void
RemoveDomain(List *names, DropBehavior behavior) RemoveDomain(List *names, DropBehavior behavior)
{ {
TypeName *typename; TypeName *typename;
Oid domainoid; Oid typeoid;
HeapTuple tup; HeapTuple tup;
char typtype; char typtype;
ObjectAddress object; ObjectAddress object;
@ -701,26 +692,20 @@ RemoveDomain(List *names, DropBehavior behavior)
typename->arrayBounds = NIL; typename->arrayBounds = NIL;
/* Use LookupTypeName here so that shell types can be removed. */ /* Use LookupTypeName here so that shell types can be removed. */
domainoid = LookupTypeName(typename); typeoid = LookupTypeName(typename);
if (!OidIsValid(domainoid)) if (!OidIsValid(typeoid))
elog(ERROR, "Type \"%s\" does not exist", elog(ERROR, "Type \"%s\" does not exist",
TypeNameToString(typename)); TypeNameToString(typename));
/*
* Lock the domain. The SearchSysCache confirms the domain still exists
* after locking
*/
LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
tup = SearchSysCache(TYPEOID, tup = SearchSysCache(TYPEOID,
ObjectIdGetDatum(domainoid), ObjectIdGetDatum(typeoid),
0, 0, 0); 0, 0, 0);
if (!HeapTupleIsValid(tup)) if (!HeapTupleIsValid(tup))
elog(ERROR, "RemoveDomain: type \"%s\" does not exist", elog(ERROR, "RemoveDomain: type \"%s\" does not exist",
TypeNameToString(typename)); TypeNameToString(typename));
/* Permission check: must own type or its namespace */ /* Permission check: must own type or its namespace */
if (!pg_type_ownercheck(domainoid, GetUserId()) && if (!pg_type_ownercheck(typeoid, GetUserId()) &&
!pg_namespace_ownercheck(((Form_pg_type) GETSTRUCT(tup))->typnamespace, !pg_namespace_ownercheck(((Form_pg_type) GETSTRUCT(tup))->typnamespace,
GetUserId())) GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, TypeNameToString(typename)); aclcheck_error(ACLCHECK_NOT_OWNER, TypeNameToString(typename));
@ -738,13 +723,10 @@ RemoveDomain(List *names, DropBehavior behavior)
* Do the deletion * Do the deletion
*/ */
object.classId = RelOid_pg_type; object.classId = RelOid_pg_type;
object.objectId = domainoid; object.objectId = typeoid;
object.objectSubId = 0; object.objectSubId = 0;
performDeletion(&object, behavior); performDeletion(&object, behavior);
/* Hold the lock until the end of the transaction */
UnlockObject(domainoid, RelOid_pg_type, NoLock);
} }
@ -959,12 +941,6 @@ AlterDomainDefault(List *names, Node *defaultRaw)
elog(ERROR, "Type \"%s\" does not exist", elog(ERROR, "Type \"%s\" does not exist",
TypeNameToString(typename)); TypeNameToString(typename));
/*
* Lock the domain. The SearchSysCacheCopy confirms the type
* still exists after locking
*/
LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
tup = SearchSysCacheCopy(TYPEOID, tup = SearchSysCacheCopy(TYPEOID,
ObjectIdGetDatum(domainoid), ObjectIdGetDatum(domainoid),
0, 0, 0); 0, 0, 0);
@ -1049,7 +1025,6 @@ AlterDomainDefault(List *names, Node *defaultRaw)
/* Clean up */ /* Clean up */
heap_close(rel, NoLock); heap_close(rel, NoLock);
heap_freetuple(newtuple); heap_freetuple(newtuple);
UnlockObject(domainoid, RelOid_pg_type, NoLock);
}; };
/* /*
@ -1081,12 +1056,6 @@ AlterDomainNotNull(List *names, bool notNull)
elog(ERROR, "Type \"%s\" does not exist", elog(ERROR, "Type \"%s\" does not exist",
TypeNameToString(typename)); TypeNameToString(typename));
/*
* Lock the domain. The SearchSysCacheCopy confirms the domain
* still exists after locking
*/
LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
tup = SearchSysCacheCopy(TYPEOID, tup = SearchSysCacheCopy(TYPEOID,
ObjectIdGetDatum(domainoid), ObjectIdGetDatum(domainoid),
0, 0, 0); 0, 0, 0);
@ -1168,7 +1137,6 @@ AlterDomainNotNull(List *names, bool notNull)
/* Clean up */ /* Clean up */
heap_freetuple(tup); heap_freetuple(tup);
heap_close(typrel, RowExclusiveLock); heap_close(typrel, RowExclusiveLock);
UnlockObject(domainoid, RelOid_pg_type, NoLock);
} }
/* /*
@ -1204,12 +1172,6 @@ AlterDomainDropConstraint(List *names, const char *constrName, DropBehavior beha
elog(ERROR, "Type \"%s\" does not exist", elog(ERROR, "Type \"%s\" does not exist",
TypeNameToString(typename)); TypeNameToString(typename));
/*
* Lock the domain. The SearchSysCacheCopy confirms the type still
* exists after locking.
*/
LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
tup = SearchSysCacheCopy(TYPEOID, tup = SearchSysCacheCopy(TYPEOID,
ObjectIdGetDatum(domainoid), ObjectIdGetDatum(domainoid),
0, 0, 0); 0, 0, 0);
@ -1257,7 +1219,6 @@ AlterDomainDropConstraint(List *names, const char *constrName, DropBehavior beha
heap_close(conrel, RowExclusiveLock); heap_close(conrel, RowExclusiveLock);
heap_close(rel, NoLock); heap_close(rel, NoLock);
UnlockObject(domainoid, RelOid_pg_type, NoLock);
}; };
/* /*
@ -1298,12 +1259,6 @@ AlterDomainAddConstraint(List *names, Node *newConstraint)
elog(ERROR, "Type \"%s\" does not exist", elog(ERROR, "Type \"%s\" does not exist",
TypeNameToString(typename)); TypeNameToString(typename));
/*
* Lock the domain. The SearchSysCacheCopy confirms the domain
* still exists after locking.
*/
LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
tup = SearchSysCacheCopy(TYPEOID, tup = SearchSysCacheCopy(TYPEOID,
ObjectIdGetDatum(domainoid), ObjectIdGetDatum(domainoid),
0, 0, 0); 0, 0, 0);
@ -1438,7 +1393,6 @@ AlterDomainAddConstraint(List *names, Node *newConstraint)
/* Clean up */ /* Clean up */
heap_close(typrel, RowExclusiveLock); heap_close(typrel, RowExclusiveLock);
UnlockObject(domainoid, RelOid_pg_type, NoLock);
} }
/* /*
@ -1742,10 +1696,7 @@ GetDomainConstraints(Oid typeOid)
Form_pg_type typTup; Form_pg_type typTup;
ScanKeyData key[1]; ScanKeyData key[1];
SysScanDesc scan; SysScanDesc scan;
/* Lock the domain */
LockObject(typeOid, RelOid_pg_type, AccessShareLock);
tup = SearchSysCache(TYPEOID, tup = SearchSysCache(TYPEOID,
ObjectIdGetDatum(typeOid), ObjectIdGetDatum(typeOid),
0, 0, 0); 0, 0, 0);
@ -1873,12 +1824,6 @@ AlterTypeOwner(List *names, AclId newOwnerSysId)
elog(ERROR, "Type \"%s\" does not exist", elog(ERROR, "Type \"%s\" does not exist",
TypeNameToString(typename)); TypeNameToString(typename));
/*
* Lock the type. The SearchSysCacheCopy serves to confirm the
* domain still exists after locking
*/
LockObject(typeOid, RelOid_pg_type, AccessExclusiveLock);
tup = SearchSysCacheCopy(TYPEOID, tup = SearchSysCacheCopy(TYPEOID,
ObjectIdGetDatum(typeOid), ObjectIdGetDatum(typeOid),
0, 0, 0); 0, 0, 0);
@ -1901,5 +1846,4 @@ AlterTypeOwner(List *names, AclId newOwnerSysId)
/* Clean up */ /* Clean up */
heap_close(rel, RowExclusiveLock); heap_close(rel, RowExclusiveLock);
UnlockObject(typeOid, RelOid_pg_type, NoLock);
} }

12
src/backend/parser/parse_type.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.52 2003/02/19 04:02:53 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.53 2003/02/19 23:41:15 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -23,7 +23,6 @@
#include "parser/parser.h" #include "parser/parser.h"
#include "parser/parse_expr.h" #include "parser/parse_expr.h"
#include "parser/parse_type.h" #include "parser/parse_type.h"
#include "storage/lmgr.h"
#include "utils/builtins.h" #include "utils/builtins.h"
#include "utils/lsyscache.h" #include "utils/lsyscache.h"
#include "utils/syscache.h" #include "utils/syscache.h"
@ -128,15 +127,6 @@ LookupTypeName(const TypeName *typename)
} }
} }
/*
* Lock the type as having been read for remainder of the transaction
*
* XXX: There is a small time between the above and now when the type
* could dissapear. We *should* recheck to confirm the type still
* exists, but won't for speed.
*/
LockObject(restype, RelOid_pg_type, AccessShareLock);
return restype; return restype;
} }

13
src/backend/storage/lmgr/deadlock.c
View File

@ -12,7 +12,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.18 2003/02/19 04:02:53 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.19 2003/02/19 23:41:15 momjian Exp $
* *
* Interface: * Interface:
* *
@ -855,25 +855,22 @@ DeadLockReport(void)
else else
nextpid = deadlockDetails[0].pid; nextpid = deadlockDetails[0].pid;
if (info->locktag.objId == InvalidOid if (info->locktag.relId == XactLockTableId && info->locktag.dbId == 0)
&& info->locktag.classId == XactLockTableId
&& info->locktag.dbId == InvalidOid)
{ {
/* Lock is for transaction ID */ /* Lock is for transaction ID */
elog(NOTICE, "Proc %d waits for %s on transaction %u; blocked by %d", elog(NOTICE, "Proc %d waits for %s on transaction %u; blocked by %d",
info->pid, info->pid,
GetLockmodeName(info->lockmode), GetLockmodeName(info->lockmode),
info->locktag.objsubId.xid, info->locktag.objId.xid,
nextpid); nextpid);
} }
else else
{ {
/* Lock is for a relation */ /* Lock is for a relation */
elog(NOTICE, "Proc %d waits for %s on object %u class %u database %u; blocked by %d", elog(NOTICE, "Proc %d waits for %s on relation %u database %u; blocked by %d",
info->pid, info->pid,
GetLockmodeName(info->lockmode), GetLockmodeName(info->lockmode),
info->locktag.objId, info->locktag.relId,
info->locktag.classId,
info->locktag.dbId, info->locktag.dbId,
nextpid); nextpid);
} }

103
src/backend/storage/lmgr/lmgr.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.55 2003/02/19 04:02:53 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.56 2003/02/19 23:41:15 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -126,10 +126,9 @@ LockRelation(Relation relation, LOCKMODE lockmode)
LOCKTAG tag; LOCKTAG tag;
MemSet(&tag, 0, sizeof(tag)); MemSet(&tag, 0, sizeof(tag));
tag.objId = relation->rd_lockInfo.lockRelId.relId; tag.relId = relation->rd_lockInfo.lockRelId.relId;
tag.classId = RelOid_pg_class;
tag.dbId = relation->rd_lockInfo.lockRelId.dbId; tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
tag.objsubId.blkno = InvalidBlockNumber; tag.objId.blkno = InvalidBlockNumber;
if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(), if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
lockmode, false)) lockmode, false))
@ -161,10 +160,9 @@ ConditionalLockRelation(Relation relation, LOCKMODE lockmode)
LOCKTAG tag; LOCKTAG tag;
MemSet(&tag, 0, sizeof(tag)); MemSet(&tag, 0, sizeof(tag));
tag.objId = relation->rd_lockInfo.lockRelId.relId; tag.relId = relation->rd_lockInfo.lockRelId.relId;
tag.classId = RelOid_pg_class;
tag.dbId = relation->rd_lockInfo.lockRelId.dbId; tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
tag.objsubId.blkno = InvalidBlockNumber; tag.objId.blkno = InvalidBlockNumber;
if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(), if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
lockmode, true)) lockmode, true))
@ -192,10 +190,9 @@ UnlockRelation(Relation relation, LOCKMODE lockmode)
LOCKTAG tag; LOCKTAG tag;
MemSet(&tag, 0, sizeof(tag)); MemSet(&tag, 0, sizeof(tag));
tag.objId = relation->rd_lockInfo.lockRelId.relId; tag.relId = relation->rd_lockInfo.lockRelId.relId;
tag.classId = RelOid_pg_class;
tag.dbId = relation->rd_lockInfo.lockRelId.dbId; tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
tag.objsubId.blkno = InvalidBlockNumber; tag.objId.blkno = InvalidBlockNumber;
LockRelease(LockTableId, &tag, GetCurrentTransactionId(), lockmode); LockRelease(LockTableId, &tag, GetCurrentTransactionId(), lockmode);
} }
@ -218,10 +215,9 @@ LockRelationForSession(LockRelId *relid, LOCKMODE lockmode)
LOCKTAG tag; LOCKTAG tag;
MemSet(&tag, 0, sizeof(tag)); MemSet(&tag, 0, sizeof(tag));
tag.objId = relid->relId; tag.relId = relid->relId;
tag.classId = RelOid_pg_class;
tag.dbId = relid->dbId; tag.dbId = relid->dbId;
tag.objsubId.blkno = InvalidBlockNumber; tag.objId.blkno = InvalidBlockNumber;
if (!LockAcquire(LockTableId, &tag, InvalidTransactionId, if (!LockAcquire(LockTableId, &tag, InvalidTransactionId,
lockmode, false)) lockmode, false))
@ -237,10 +233,9 @@ UnlockRelationForSession(LockRelId *relid, LOCKMODE lockmode)
LOCKTAG tag; LOCKTAG tag;
MemSet(&tag, 0, sizeof(tag)); MemSet(&tag, 0, sizeof(tag));
tag.objId = relid->relId; tag.relId = relid->relId;
tag.classId = RelOid_pg_class;
tag.dbId = relid->dbId; tag.dbId = relid->dbId;
tag.objsubId.blkno = InvalidBlockNumber; tag.objId.blkno = InvalidBlockNumber;
LockRelease(LockTableId, &tag, InvalidTransactionId, lockmode); LockRelease(LockTableId, &tag, InvalidTransactionId, lockmode);
} }
@ -258,10 +253,9 @@ LockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)
LOCKTAG tag; LOCKTAG tag;
MemSet(&tag, 0, sizeof(tag)); MemSet(&tag, 0, sizeof(tag));
tag.objId = relation->rd_lockInfo.lockRelId.relId; tag.relId = relation->rd_lockInfo.lockRelId.relId;
tag.classId = RelOid_pg_class;
tag.dbId = relation->rd_lockInfo.lockRelId.dbId; tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
tag.objsubId.blkno = blkno; tag.objId.blkno = blkno;
if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(), if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
lockmode, false)) lockmode, false))
@ -277,10 +271,9 @@ UnlockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)
LOCKTAG tag; LOCKTAG tag;
MemSet(&tag, 0, sizeof(tag)); MemSet(&tag, 0, sizeof(tag));
tag.objId = relation->rd_lockInfo.lockRelId.relId; tag.relId = relation->rd_lockInfo.lockRelId.relId;
tag.classId = RelOid_pg_class;
tag.dbId = relation->rd_lockInfo.lockRelId.dbId; tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
tag.objsubId.blkno = blkno; tag.objId.blkno = blkno;
LockRelease(LockTableId, &tag, GetCurrentTransactionId(), lockmode); LockRelease(LockTableId, &tag, GetCurrentTransactionId(), lockmode);
} }
@ -301,10 +294,9 @@ XactLockTableInsert(TransactionId xid)
LOCKTAG tag; LOCKTAG tag;
MemSet(&tag, 0, sizeof(tag)); MemSet(&tag, 0, sizeof(tag));
tag.objId = InvalidOid; tag.relId = XactLockTableId;
tag.classId = XactLockTableId;
tag.dbId = InvalidOid; /* xids are globally unique */ tag.dbId = InvalidOid; /* xids are globally unique */
tag.objsubId.xid = xid; tag.objId.xid = xid;
if (!LockAcquire(LockTableId, &tag, xid, if (!LockAcquire(LockTableId, &tag, xid,
ExclusiveLock, false)) ExclusiveLock, false))
@ -325,10 +317,9 @@ XactLockTableWait(TransactionId xid)
Assert(!TransactionIdEquals(xid, myxid)); Assert(!TransactionIdEquals(xid, myxid));
MemSet(&tag, 0, sizeof(tag)); MemSet(&tag, 0, sizeof(tag));
tag.objId = InvalidOid; tag.relId = XactLockTableId;
tag.classId = XactLockTableId;
tag.dbId = InvalidOid; tag.dbId = InvalidOid;
tag.objsubId.xid = xid; tag.objId.xid = xid;
if (!LockAcquire(LockTableId, &tag, myxid, if (!LockAcquire(LockTableId, &tag, myxid,
ShareLock, false)) ShareLock, false))
@ -343,59 +334,3 @@ XactLockTableWait(TransactionId xid)
if (!TransactionIdDidCommit(xid) && !TransactionIdDidAbort(xid)) if (!TransactionIdDidCommit(xid) && !TransactionIdDidAbort(xid))
TransactionIdAbort(xid); TransactionIdAbort(xid);
} }
/*
* LockObject
*
* Lock an arbitrary database object. A standard relation lock would lock the
* classId of RelOid_pg_class and objId of the relations OID within the pg_class
* table. LockObject allows classId to be specified by the caller, thus allowing
* locks on any row in any system table.
*
* If classId is NOT a system table (protected from removal), an additional lock
* should be held on the relation to prevent it from being dropped.
*/
void
LockObject(Oid objId, Oid classId, LOCKMODE lockmode)
{
LOCKTAG tag;
MemSet(&tag, 0, sizeof(tag));
tag.objId = objId;
tag.classId = classId;
tag.dbId = MyDatabaseId;
tag.objsubId.blkno = InvalidBlockNumber;
/* Only two reasonable lock types */
Assert(lockmode == AccessShareLock || lockmode == AccessExclusiveLock);
if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
lockmode, false))
elog(ERROR, "LockObject: LockAcquire failed");
}
/*
* UnlockObject
*/
void
UnlockObject(Oid objId, Oid classId, LOCKMODE lockmode)
{
LOCKTAG tag;
/* NoLock is a no-op */
if (lockmode == NoLock)
return;
MemSet(&tag, 0, sizeof(tag));
tag.objId = objId;
tag.classId = classId;
tag.dbId = MyDatabaseId;
tag.objsubId.blkno = InvalidBlockNumber;
/* Only two reasonable lock types */
Assert(lockmode == AccessShareLock
|| lockmode == AccessExclusiveLock);
LockRelease(LockTableId, &tag, GetCurrentTransactionId(), lockmode);
}

31
src/backend/storage/lmgr/lock.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.121 2003/02/19 04:02:53 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.122 2003/02/19 23:41:15 momjian Exp $
* *
* NOTES * NOTES
* Outside modules can create a lock table and acquire/release * Outside modules can create a lock table and acquire/release
@ -97,8 +97,8 @@ LOCK_DEBUG_ENABLED(const LOCK *lock)
return return
(((LOCK_LOCKMETHOD(*lock) == DEFAULT_LOCKMETHOD && Trace_locks) (((LOCK_LOCKMETHOD(*lock) == DEFAULT_LOCKMETHOD && Trace_locks)
|| (LOCK_LOCKMETHOD(*lock) == USER_LOCKMETHOD && Trace_userlocks)) || (LOCK_LOCKMETHOD(*lock) == USER_LOCKMETHOD && Trace_userlocks))
&& (lock->tag.objId >= (Oid) Trace_lock_oidmin)) && (lock->tag.relId >= (Oid) Trace_lock_oidmin))
|| (Trace_lock_table && (lock->tag.objId == Trace_lock_table)); || (Trace_lock_table && (lock->tag.relId == Trace_lock_table));
} }
@ -107,12 +107,12 @@ LOCK_PRINT(const char *where, const LOCK *lock, LOCKMODE type)
{ {
if (LOCK_DEBUG_ENABLED(lock)) if (LOCK_DEBUG_ENABLED(lock))
elog(LOG, elog(LOG,
"%s: lock(%lx) tbl(%d) obj(%u) class(%u) db(%u) objsub(%u) grantMask(%x) " "%s: lock(%lx) tbl(%d) rel(%u) db(%u) obj(%u) grantMask(%x) "
"req(%d,%d,%d,%d,%d,%d,%d)=%d " "req(%d,%d,%d,%d,%d,%d,%d)=%d "
"grant(%d,%d,%d,%d,%d,%d,%d)=%d wait(%d) type(%s)", "grant(%d,%d,%d,%d,%d,%d,%d)=%d wait(%d) type(%s)",
where, MAKE_OFFSET(lock), where, MAKE_OFFSET(lock),
lock->tag.lockmethod, lock->tag.objId, lock->tag.classId, lock->tag.dbId, lock->tag.lockmethod, lock->tag.relId, lock->tag.dbId,
lock->tag.objsubId.blkno, lock->grantMask, lock->tag.objId.blkno, lock->grantMask,
lock->requested[1], lock->requested[2], lock->requested[3], lock->requested[1], lock->requested[2], lock->requested[3],
lock->requested[4], lock->requested[5], lock->requested[6], lock->requested[4], lock->requested[5], lock->requested[6],
lock->requested[7], lock->nRequested, lock->requested[7], lock->nRequested,
@ -129,16 +129,16 @@ PROCLOCK_PRINT(const char *where, const PROCLOCK *proclockP)
if ( if (
(((PROCLOCK_LOCKMETHOD(*proclockP) == DEFAULT_LOCKMETHOD && Trace_locks) (((PROCLOCK_LOCKMETHOD(*proclockP) == DEFAULT_LOCKMETHOD && Trace_locks)
|| (PROCLOCK_LOCKMETHOD(*proclockP) == USER_LOCKMETHOD && Trace_userlocks)) || (PROCLOCK_LOCKMETHOD(*proclockP) == USER_LOCKMETHOD && Trace_userlocks))
&& (((LOCK *) MAKE_PTR(proclockP->tag.lock))->tag.objId >= (Oid) Trace_lock_oidmin)) && (((LOCK *) MAKE_PTR(proclockP->tag.lock))->tag.relId >= (Oid) Trace_lock_oidmin))
|| (Trace_lock_table && (((LOCK *) MAKE_PTR(proclockP->tag.lock))->tag.objId == Trace_lock_table)) || (Trace_lock_table && (((LOCK *) MAKE_PTR(proclockP->tag.lock))->tag.relId == Trace_lock_table))
) )
elog(LOG, elog(LOG,
"%s: proclock(%lx) lock(%lx) tbl(%d) proc(%lx) xid(%u) hold(%d,%d,%d,%d,%d,%d,%d)=%d", "%s: proclock(%lx) lock(%lx) tbl(%d) proc(%lx) xid(%u) hold(%d,%d,%d,%d,%d,%d,%d)=%d",
where, MAKE_OFFSET(proclockP), proclockP->tag.lock, where, MAKE_OFFSET(proclockP), proclockP->tag.lock,
PROCLOCK_LOCKMETHOD(*(proclockP)), PROCLOCK_LOCKMETHOD(*(proclockP)),
proclockP->tag.proc, proclockP->tag.xid, proclockP->tag.proc, proclockP->tag.xid,
proclockP->holding[1], proclockP->holding[2], proclockP->holding[3], proclockP->holding[1], proclockP->holding[2], proclockP->holding[3],
proclockP->holding[4], proclockP->holding[5], proclockP->holding[6], proclockP->holding[4], proclockP->holding[5], proclockP->holding[6],
proclockP->holding[7], proclockP->nHolding); proclockP->holding[7], proclockP->nHolding);
} }
@ -417,9 +417,8 @@ LockMethodTableRename(LOCKMETHOD lockmethod)
* *
* lockmethod 1 2 * lockmethod 1 2
* tag.dbId database oid database oid * tag.dbId database oid database oid
* tag.classId class oid 0 * tag.relId rel oid or 0 0
* tag.objId rel oid or 0 0 * tag.objId block id lock id2
* tag.objsubId block id lock id2
* or xact id * or xact id
* tag.offnum 0 lock id1 * tag.offnum 0 lock id1
* proclock.xid xid or 0 0 * proclock.xid xid or 0 0
@ -450,7 +449,7 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
#ifdef LOCK_DEBUG #ifdef LOCK_DEBUG
if (lockmethod == USER_LOCKMETHOD && Trace_userlocks) if (lockmethod == USER_LOCKMETHOD && Trace_userlocks)
elog(LOG, "LockAcquire: user lock [%u] %s", elog(LOG, "LockAcquire: user lock [%u] %s",
locktag->objsubId.blkno, lock_mode_names[lockmode]); locktag->objId.blkno, lock_mode_names[lockmode]);
#endif #endif
/* ???????? This must be changed when short term locks will be used */ /* ???????? This must be changed when short term locks will be used */
@ -573,7 +572,7 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
elog(LOG, "Deadlock risk: raising lock level" elog(LOG, "Deadlock risk: raising lock level"
" from %s to %s on object %u/%u/%u", " from %s to %s on object %u/%u/%u",
lock_mode_names[i], lock_mode_names[lockmode], lock_mode_names[i], lock_mode_names[lockmode],
lock->tag.objId, lock->tag.dbId, lock->tag.objsubId.blkno); lock->tag.relId, lock->tag.dbId, lock->tag.objId.blkno);
break; break;
} }
} }
@ -994,7 +993,7 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
#ifdef LOCK_DEBUG #ifdef LOCK_DEBUG
if (lockmethod == USER_LOCKMETHOD && Trace_userlocks) if (lockmethod == USER_LOCKMETHOD && Trace_userlocks)
elog(LOG, "LockRelease: user lock tag [%u] %d", locktag->objsubId.blkno, lockmode); elog(LOG, "LockRelease: user lock tag [%u] %d", locktag->objId.blkno, lockmode);
#endif #endif
/* ???????? This must be changed when short term locks will be used */ /* ???????? This must be changed when short term locks will be used */

42
src/backend/utils/adt/lockfuncs.c
View File

@ -6,7 +6,7 @@
* Copyright (c) 2002, PostgreSQL Global Development Group * Copyright (c) 2002, PostgreSQL Global Development Group
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/lockfuncs.c,v 1.9 2003/02/19 04:02:54 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/utils/adt/lockfuncs.c,v 1.10 2003/02/19 23:41:15 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -53,20 +53,18 @@ pg_lock_status(PG_FUNCTION_ARGS)
/* build tupdesc for result tuples */ /* build tupdesc for result tuples */
/* this had better match pg_locks view in initdb.sh */ /* this had better match pg_locks view in initdb.sh */
tupdesc = CreateTemplateTupleDesc(7, false); tupdesc = CreateTemplateTupleDesc(6, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "object", TupleDescInitEntry(tupdesc, (AttrNumber) 1, "relation",
OIDOID, -1, 0, false); OIDOID, -1, 0, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "class", TupleDescInitEntry(tupdesc, (AttrNumber) 2, "database",
OIDOID, -1, 0, false); OIDOID, -1, 0, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 3, "database", TupleDescInitEntry(tupdesc, (AttrNumber) 3, "transaction",
OIDOID, -1, 0, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 4, "transaction",
XIDOID, -1, 0, false); XIDOID, -1, 0, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 5, "pid", TupleDescInitEntry(tupdesc, (AttrNumber) 4, "pid",
INT4OID, -1, 0, false); INT4OID, -1, 0, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 6, "mode", TupleDescInitEntry(tupdesc, (AttrNumber) 5, "mode",
TEXTOID, -1, 0, false); TEXTOID, -1, 0, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 7, "granted", TupleDescInitEntry(tupdesc, (AttrNumber) 6, "granted",
BOOLOID, -1, 0, false); BOOLOID, -1, 0, false);
funcctx->slot = TupleDescGetSlot(tupdesc); funcctx->slot = TupleDescGetSlot(tupdesc);
@ -95,8 +93,8 @@ pg_lock_status(PG_FUNCTION_ARGS)
PGPROC *proc; PGPROC *proc;
bool granted; bool granted;
LOCKMODE mode; LOCKMODE mode;
Datum values[7]; Datum values[6];
char nulls[7]; char nulls[6];
HeapTuple tuple; HeapTuple tuple;
Datum result; Datum result;
@ -154,30 +152,26 @@ pg_lock_status(PG_FUNCTION_ARGS)
MemSet(values, 0, sizeof(values)); MemSet(values, 0, sizeof(values));
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, ' ', sizeof(nulls));
if (lock->tag.objId == InvalidOid if (lock->tag.relId == XactLockTableId && lock->tag.dbId == 0)
&& lock->tag.classId == XactLockTableId
&& lock->tag.dbId == InvalidOid)
{ {
/* Lock is for transaction ID */ /* Lock is for transaction ID */
nulls[0] = 'n'; nulls[0] = 'n';
nulls[1] = 'n'; nulls[1] = 'n';
nulls[2] = 'n'; values[2] = TransactionIdGetDatum(lock->tag.objId.xid);
values[3] = TransactionIdGetDatum(lock->tag.objsubId.xid);
} }
else else
{ {
/* Lock is for a relation */ /* Lock is for a relation */
values[0] = ObjectIdGetDatum(lock->tag.objId); values[0] = ObjectIdGetDatum(lock->tag.relId);
values[1] = ObjectIdGetDatum(lock->tag.classId); values[1] = ObjectIdGetDatum(lock->tag.dbId);
values[2] = ObjectIdGetDatum(lock->tag.dbId); nulls[2] = 'n';
nulls[3] = 'n';
} }
values[4] = Int32GetDatum(proc->pid); values[3] = Int32GetDatum(proc->pid);
values[5] = DirectFunctionCall1(textin, values[4] = DirectFunctionCall1(textin,
CStringGetDatum(GetLockmodeName(mode))); CStringGetDatum(GetLockmodeName(mode)));
values[6] = BoolGetDatum(granted); values[5] = BoolGetDatum(granted);
tuple = heap_formtuple(funcctx->slot->ttc_tupleDescriptor, tuple = heap_formtuple(funcctx->slot->ttc_tupleDescriptor,
values, nulls); values, nulls);

4
src/bin/initdb/initdb.sh
View File

@ -27,7 +27,7 @@
# Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group # Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
# Portions Copyright (c) 1994, Regents of the University of California # Portions Copyright (c) 1994, Regents of the University of California
# #
# $Header: /cvsroot/pgsql/src/bin/initdb/Attic/initdb.sh,v 1.183 2003/02/19 04:02:54 momjian Exp $ # $Header: /cvsroot/pgsql/src/bin/initdb/Attic/initdb.sh,v 1.184 2003/02/19 23:41:15 momjian Exp $
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
@ -974,7 +974,7 @@ CREATE VIEW pg_stat_database AS \
CREATE VIEW pg_locks AS \ CREATE VIEW pg_locks AS \
SELECT * \ SELECT * \
FROM pg_lock_status() AS L(object oid, class oid, database oid, \ FROM pg_lock_status() AS L(relation oid, database oid, \
transaction xid, pid int4, mode text, granted boolean); transaction xid, pid int4, mode text, granted boolean);
CREATE VIEW pg_settings AS \ CREATE VIEW pg_settings AS \

6
src/include/storage/lmgr.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: lmgr.h,v 1.37 2003/02/19 04:02:54 momjian Exp $ * $Id: lmgr.h,v 1.38 2003/02/19 23:41:15 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -62,8 +62,4 @@ extern void UnlockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);
extern void XactLockTableInsert(TransactionId xid); extern void XactLockTableInsert(TransactionId xid);
extern void XactLockTableWait(TransactionId xid); extern void XactLockTableWait(TransactionId xid);
/* Lock an arbitrary database object in the current database */
extern void LockObject(Oid objId, Oid classId, LOCKMODE lockmode);
extern void UnlockObject(Oid objId, Oid classId, LOCKMODE lockmode);
#endif /* LMGR_H */ #endif /* LMGR_H */

7
src/include/storage/lock.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: lock.h,v 1.70 2003/02/19 04:02:54 momjian Exp $ * $Id: lock.h,v 1.71 2003/02/19 23:41:15 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -100,14 +100,13 @@ typedef struct LOCKMETHODTABLE
*/ */
typedef struct LOCKTAG typedef struct LOCKTAG
{ {
Oid objId; Oid relId;
Oid classId;
Oid dbId; Oid dbId;
union union
{ {
BlockNumber blkno; BlockNumber blkno;
TransactionId xid; TransactionId xid;
} objsubId; } objId;
/* /*
* offnum should be part of objId.tupleId above, but would increase * offnum should be part of objId.tupleId above, but would increase

2
src/test/regress/expected/rules.out
View File

@ -1271,7 +1271,7 @@ SELECT viewname, definition FROM pg_views WHERE schemaname <> 'information_schem
--------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
iexit | SELECT ih.name, ih.thepath, interpt_pp(ih.thepath, r.thepath) AS exit FROM ihighway ih, ramp r WHERE (ih.thepath ## r.thepath); iexit | SELECT ih.name, ih.thepath, interpt_pp(ih.thepath, r.thepath) AS exit FROM ihighway ih, ramp r WHERE (ih.thepath ## r.thepath);
pg_indexes | SELECT n.nspname AS schemaname, c.relname AS tablename, i.relname AS indexname, pg_get_indexdef(i.oid) AS indexdef FROM (((pg_index x JOIN pg_class c ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE ((c.relkind = 'r'::"char") AND (i.relkind = 'i'::"char")); pg_indexes | SELECT n.nspname AS schemaname, c.relname AS tablename, i.relname AS indexname, pg_get_indexdef(i.oid) AS indexdef FROM (((pg_index x JOIN pg_class c ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE ((c.relkind = 'r'::"char") AND (i.relkind = 'i'::"char"));
pg_locks | SELECT l.object, l."class", l."database", l."transaction", l.pid, l."mode", l.granted FROM pg_lock_status() l(object oid, "class" oid, "database" oid, "transaction" xid, pid integer, "mode" text, granted boolean); pg_locks | SELECT l.relation, l."database", l."transaction", l.pid, l."mode", l.granted FROM pg_lock_status() l(relation oid, "database" oid, "transaction" xid, pid integer, "mode" text, granted boolean);
pg_rules | SELECT n.nspname AS schemaname, c.relname AS tablename, r.rulename, pg_get_ruledef(r.oid) AS definition FROM ((pg_rewrite r JOIN pg_class c ON ((c.oid = r.ev_class))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (r.rulename <> '_RETURN'::name); pg_rules | SELECT n.nspname AS schemaname, c.relname AS tablename, r.rulename, pg_get_ruledef(r.oid) AS definition FROM ((pg_rewrite r JOIN pg_class c ON ((c.oid = r.ev_class))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (r.rulename <> '_RETURN'::name);
pg_settings | SELECT a.name, a.setting FROM pg_show_all_settings() a(name text, setting text); pg_settings | SELECT a.name, a.setting FROM pg_show_all_settings() a(name text, setting text);
pg_stat_activity | SELECT d.oid AS datid, d.datname, pg_stat_get_backend_pid(s.backendid) AS procpid, pg_stat_get_backend_userid(s.backendid) AS usesysid, u.usename, pg_stat_get_backend_activity(s.backendid) AS current_query FROM pg_database d, (SELECT pg_stat_get_backend_idset() AS backendid) s, pg_shadow u WHERE ((pg_stat_get_backend_dbid(s.backendid) = d.oid) AND (pg_stat_get_backend_userid(s.backendid) = u.usesysid)); pg_stat_activity | SELECT d.oid AS datid, d.datname, pg_stat_get_backend_pid(s.backendid) AS procpid, pg_stat_get_backend_userid(s.backendid) AS usesysid, u.usename, pg_stat_get_backend_activity(s.backendid) AS current_query FROM pg_database d, (SELECT pg_stat_get_backend_idset() AS backendid) s, pg_shadow u WHERE ((pg_stat_get_backend_dbid(s.backendid) = d.oid) AND (pg_stat_get_backend_userid(s.backendid) = u.usesysid));