opensourcemirror
/
postgresql
mirror of git://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Rename locking structure names to be clearer. Add narrative to 

backend flowchart.
This commit is contained in:
Bruce Momjian 1998-06-30 02:33:34 +00:00
parent f21fa6a773
commit 2584029e31
9 changed files with 324 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.31 1998/06/28 21:17:34 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.32 1998/06/30 02:33:31 momjian Exp $
*
* NOTES
* Outside modules can create a lock table and acquire/release
@ -18,7 +18,7 @@
*
* Interface:
*
* LockAcquire(), LockRelease(), LockTableInit().
* LockAcquire(), LockRelease(), LockMethodTableInit().
*
* LockReplace() is called only within this module and by the
* lkchain module. It releases a lock without looking
@ -51,8 +51,7 @@
#include "access/transam.h"
static int
WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock,
LOCKTYPE locktype);
WaitOnLock(LOCKMETHOD lockmethod, LOCK *lock, LOCKMODE lockmode);
/*#define LOCK_MGR_DEBUG*/
@ -134,8 +133,8 @@ SPINLOCK LockMgrLock; /* in Shmem or created in
/* This is to simplify/speed up some bit arithmetic */
static MASK BITS_OFF[MAX_LOCKTYPES];
static MASK BITS_ON[MAX_LOCKTYPES];
static MASK BITS_OFF[MAX_LOCKMODES];
static MASK BITS_ON[MAX_LOCKMODES];
/* -----------------
* XXX Want to move this to this file
@ -144,16 +143,12 @@ static MASK BITS_ON[MAX_LOCKTYPES];
static bool LockingIsDisabled;
/* -------------------
* map from tableId to the lock table structure
* map from lockmethod to the lock table structure
* -------------------
*/
static LOCKTAB *AllTables[MAX_TABLES];
static LOCKMETHODTABLE *LockMethodTable[MAX_LOCK_METHODS];
/* -------------------
* no zero-th table
* -------------------
*/
static int NumTables;
static int NumLockMethods;
/* -------------------
* InitLocks -- Init the lock module. Create a private data
@ -168,10 +163,10 @@ InitLocks()
bit = 1;
/* -------------------
* remember 0th locktype is invalid
* remember 0th lockmode is invalid
* -------------------
*/
for (i = 0; i < MAX_LOCKTYPES; i++, bit <<= 1)
for (i = 0; i < MAX_LOCKMODES; i++, bit <<= 1)
{
BITS_ON[i] = bit;
BITS_OFF[i] = ~bit;
@ -190,30 +185,30 @@ LockDisable(int status)
/*
* LockTypeInit -- initialize the lock table's lock type
* LockMethodInit -- initialize the lock table's lock type
* structures
*
* Notes: just copying. Should only be called once.
*/
static void
LockTypeInit(LOCKTAB *ltable,
LockMethodInit(LOCKMETHODTABLE *lockMethodTable,
MASK *conflictsP,
int *prioP,
int ntypes)
int numModes)
{
int i;
ltable->ctl->nLockTypes = ntypes;
ntypes++;
for (i = 0; i < ntypes; i++, prioP++, conflictsP++)
lockMethodTable->ctl->numLockModes = numModes;
numModes++;
for (i = 0; i < numModes; i++, prioP++, conflictsP++)
{
ltable->ctl->conflictTab[i] = *conflictsP;
ltable->ctl->prio[i] = *prioP;
lockMethodTable->ctl->conflictTab[i] = *conflictsP;
lockMethodTable->ctl->prio[i] = *prioP;
}
}
/*
* LockTableInit -- initialize a lock table structure
* LockMethodTableInit -- initialize a lock table structure
*
* Notes:
* (a) a lock table has four separate entries in the shmem index
@ -222,23 +217,23 @@ LockTypeInit(LOCKTAB *ltable,
* is wasteful, in this case, but not much space is involved.
*
*/
LockTableId
LockTableInit(char *tabName,
LOCKMETHOD
LockMethodTableInit(char *tabName,
MASK *conflictsP,
int *prioP,
int ntypes)
int numModes)
{
LOCKTAB *ltable;
LOCKMETHODTABLE *lockMethodTable;
char *shmemName;
HASHCTL info;
int hash_flags;
bool found;
int status = TRUE;
if (ntypes > MAX_LOCKTYPES)
if (numModes > MAX_LOCKMODES)
{
elog(NOTICE, "LockTableInit: too many lock types %d greater than %d",
ntypes, MAX_LOCKTYPES);
elog(NOTICE, "LockMethodTableInit: too many lock types %d greater than %d",
numModes, MAX_LOCKMODES);
return (INVALID_TABLEID);
}
@ -246,15 +241,15 @@ LockTableInit(char *tabName,
shmemName = (char *) palloc((unsigned) (strlen(tabName) + 32));
if (!shmemName)
{
elog(NOTICE, "LockTableInit: couldn't malloc string %s \n", tabName);
elog(NOTICE, "LockMethodTableInit: couldn't malloc string %s \n", tabName);
return (INVALID_TABLEID);
}
/* each lock table has a non-shared header */
ltable = (LOCKTAB *) palloc((unsigned) sizeof(LOCKTAB));
if (!ltable)
lockMethodTable = (LOCKMETHODTABLE *) palloc((unsigned) sizeof(LOCKMETHODTABLE));
if (!lockMethodTable)
{
elog(NOTICE, "LockTableInit: couldn't malloc lock table %s\n", tabName);
elog(NOTICE, "LockMethodTableInit: couldn't malloc lock table %s\n", tabName);
pfree(shmemName);
return (INVALID_TABLEID);
}
@ -272,16 +267,20 @@ LockTableInit(char *tabName,
* -----------------------
*/
sprintf(shmemName, "%s (ctl)", tabName);
ltable->ctl = (LOCKCTL *)
ShmemInitStruct(shmemName, (unsigned) sizeof(LOCKCTL), &found);
lockMethodTable->ctl = (LOCKMETHODCTL *)
ShmemInitStruct(shmemName, (unsigned) sizeof(LOCKMETHODCTL), &found);
if (!ltable->ctl)
if (!lockMethodTable->ctl)
{
elog(FATAL, "LockTableInit: couldn't initialize %s", tabName);
elog(FATAL, "LockMethodTableInit: couldn't initialize %s", tabName);
status = FALSE;
}
NumTables = 1;
/* -------------------
* no zero-th table
* -------------------
*/
NumLockMethods = 1;
/* ----------------
* we're first - initialize
@ -289,18 +288,18 @@ LockTableInit(char *tabName,
*/
if (!found)
{
MemSet(ltable->ctl, 0, sizeof(LOCKCTL));
ltable->ctl->masterLock = LockMgrLock;
ltable->ctl->tableId = NumTables;
MemSet(lockMethodTable->ctl, 0, sizeof(LOCKMETHODCTL));
lockMethodTable->ctl->masterLock = LockMgrLock;
lockMethodTable->ctl->lockmethod = NumLockMethods;
}
/* --------------------
* other modules refer to the lock table by a tableId
* other modules refer to the lock table by a lockmethod
* --------------------
*/
AllTables[NumTables] = ltable;
NumTables++;
Assert(NumTables <= MAX_TABLES);
LockMethodTable[NumLockMethods] = lockMethodTable;
NumLockMethods++;
Assert(NumLockMethods <= MAX_LOCK_METHODS);
/* ----------------------
* allocate a hash table for the lock tags. This is used
@ -313,14 +312,14 @@ LockTableInit(char *tabName,
hash_flags = (HASH_ELEM | HASH_FUNCTION);
sprintf(shmemName, "%s (lock hash)", tabName);
ltable->lockHash = (HTAB *) ShmemInitHash(shmemName,
lockMethodTable->lockHash = (HTAB *) ShmemInitHash(shmemName,
INIT_TABLE_SIZE, MAX_TABLE_SIZE,
&info, hash_flags);
Assert(ltable->lockHash->hash == tag_hash);
if (!ltable->lockHash)
Assert(lockMethodTable->lockHash->hash == tag_hash);
if (!lockMethodTable->lockHash)
{
elog(FATAL, "LockTableInit: couldn't initialize %s", tabName);
elog(FATAL, "LockMethodTableInit: couldn't initialize %s", tabName);
status = FALSE;
}
@ -335,31 +334,31 @@ LockTableInit(char *tabName,
hash_flags = (HASH_ELEM | HASH_FUNCTION);
sprintf(shmemName, "%s (xid hash)", tabName);
ltable->xidHash = (HTAB *) ShmemInitHash(shmemName,
lockMethodTable->xidHash = (HTAB *) ShmemInitHash(shmemName,
INIT_TABLE_SIZE, MAX_TABLE_SIZE,
&info, hash_flags);
if (!ltable->xidHash)
if (!lockMethodTable->xidHash)
{
elog(FATAL, "LockTableInit: couldn't initialize %s", tabName);
elog(FATAL, "LockMethodTableInit: couldn't initialize %s", tabName);
status = FALSE;
}
/* init ctl data structures */
LockTypeInit(ltable, conflictsP, prioP, ntypes);
LockMethodInit(lockMethodTable, conflictsP, prioP, numModes);
SpinRelease(LockMgrLock);
pfree(shmemName);
if (status)
return (ltable->ctl->tableId);
return (lockMethodTable->ctl->lockmethod);
else
return (INVALID_TABLEID);
}
/*
* LockTableRename -- allocate another tableId to the same
* LockMethodTableRename -- allocate another lockmethod to the same
* lock table.
*
* NOTES: Both the lock module and the lock chain (lchain.c)
@ -367,28 +366,27 @@ LockTableInit(char *tabName,
* kinds of locks. Short term and long term locks look
* the same to the lock table, but are handled differently
* by the lock chain manager. This function allows the
* client to use different tableIds when acquiring/releasing
* client to use different lockmethods when acquiring/releasing
* short term and long term locks.
*/
#ifdef NOT_USED
LockTableId
LockTableRename(LockTableId tableId)
LOCKMETHOD
LockMethodTableRename(LOCKMETHOD lockmethod)
{
LockTableId newTableId;
LOCKMETHOD newLockMethod;
if (NumTables >= MAX_TABLES)
if (NumLockMethods >= MAX_LOCK_METHODS)
return (INVALID_TABLEID);
if (AllTables[tableId] == INVALID_TABLEID)
if (LockMethodTable[lockmethod] == INVALID_TABLEID)
return (INVALID_TABLEID);
/* other modules refer to the lock table by a tableId */
newTableId = NumTables;
NumTables++;
/* other modules refer to the lock table by a lockmethod */
newLockMethod = NumLockMethods;
NumLockMethods++;
AllTables[newTableId] = AllTables[tableId];
return (newTableId);
LockMethodTable[newLockMethod] = LockMethodTable[lockmethod];
return (newLockMethod);
}
#endif
/*
@ -423,13 +421,13 @@ LockTableRename(LockTableId tableId)
* acquired if already held by another process. They must be
* released explicitly by the application but they are released
* automatically when a backend terminates.
* They are indicated by a dummy tableId 0 which doesn't have
* They are indicated by a dummy lockmethod 0 which doesn't have
* any table allocated but uses the normal lock table, and are
* distinguished from normal locks for the following differences:
*
* normal lock user lock
*
* tableId 1 0
* lockmethod 1 0
* tag.relId rel oid 0
* tag.ItemPointerData.ip_blkid block id lock id2
* tag.ItemPointerData.ip_posid tuple offset lock id1
@ -437,7 +435,7 @@ LockTableRename(LockTableId tableId)
* xid.xid current xid 0
* persistence transaction user or backend
*
* The locktype parameter can have the same values for normal locks
* The lockmode parameter can have the same values for normal locks
* although probably only WRITE_LOCK can have some practical use.
*
* DZ - 4 Oct 1996
@ -445,7 +443,7 @@ LockTableRename(LockTableId tableId)
*/
bool
LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag, LOCKMODE lockmode)
{
XIDLookupEnt *result,
item;
@ -453,50 +451,50 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
bool found;
LOCK *lock = NULL;
SPINLOCK masterLock;
LOCKTAB *ltable;
LOCKMETHODTABLE *lockMethodTable;
int status;
TransactionId myXid;
#ifdef USER_LOCKS
int is_user_lock;
is_user_lock = (tableId == 0);
is_user_lock = (lockmethod == 0);
if (is_user_lock)
{
tableId = 1;
lockmethod = 1;
#ifdef USER_LOCKS_DEBUG
elog(NOTICE, "LockAcquire: user lock tag [%u,%u] %d",
lockName->tupleId.ip_posid,
((lockName->tupleId.ip_blkid.bi_hi << 16) +
lockName->tupleId.ip_blkid.bi_lo),
locktype);
locktag->tupleId.ip_posid,
((locktag->tupleId.ip_blkid.bi_hi << 16) +
locktag->tupleId.ip_blkid.bi_lo),
lockmode);
#endif
}
#endif
Assert(tableId < NumTables);
ltable = AllTables[tableId];
if (!ltable)
Assert(lockmethod < NumLockMethods);
lockMethodTable = LockMethodTable[lockmethod];
if (!lockMethodTable)
{
elog(NOTICE, "LockAcquire: bad lock table %d", tableId);
elog(NOTICE, "LockAcquire: bad lock table %d", lockmethod);
return (FALSE);
}
if (LockingIsDisabled)
return (TRUE);
LOCK_PRINT("Acquire", lockName, locktype);
masterLock = ltable->ctl->masterLock;
LOCK_PRINT("Acquire", locktag, lockmode);
masterLock = lockMethodTable->ctl->masterLock;
SpinAcquire(masterLock);
Assert(ltable->lockHash->hash == tag_hash);
lock = (LOCK *) hash_search(ltable->lockHash, (Pointer) lockName, HASH_ENTER, &found);
Assert(lockMethodTable->lockHash->hash == tag_hash);
lock = (LOCK *) hash_search(lockMethodTable->lockHash, (Pointer) locktag, HASH_ENTER, &found);
if (!lock)
{
SpinRelease(masterLock);
elog(FATAL, "LockAcquire: lock table %d is corrupted", tableId);
elog(FATAL, "LockAcquire: lock table %d is corrupted", lockmethod);
return (FALSE);
}
@ -508,13 +506,13 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
{
lock->mask = 0;
ProcQueueInit(&(lock->waitProcs));
MemSet((char *) lock->holders, 0, sizeof(int) * MAX_LOCKTYPES);
MemSet((char *) lock->activeHolders, 0, sizeof(int) * MAX_LOCKTYPES);
MemSet((char *) lock->holders, 0, sizeof(int) * MAX_LOCKMODES);
MemSet((char *) lock->activeHolders, 0, sizeof(int) * MAX_LOCKMODES);
lock->nHolding = 0;
lock->nActive = 0;
Assert(BlockIdEquals(&(lock->tag.tupleId.ip_blkid),
&(lockName->tupleId.ip_blkid)));
&(locktag->tupleId.ip_blkid)));
}
@ -523,7 +521,7 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* locks at end of transaction.
* ------------------
*/
xidTable = ltable->xidHash;
xidTable = lockMethodTable->xidHash;
myXid = GetCurrentTransactionId();
/* ------------------
@ -561,7 +559,7 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
XID_PRINT("LockAcquire: queueing XidEnt", result);
ProcAddLock(&result->queue);
result->nHolding = 0;
MemSet((char *) result->holders, 0, sizeof(int) * MAX_LOCKTYPES);
MemSet((char *) result->holders, 0, sizeof(int) * MAX_LOCKMODES);
}
/* ----------------
@ -571,7 +569,7 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* ----------------
*/
lock->nHolding++;
lock->holders[locktype]++;
lock->holders[lockmode]++;
/* --------------------
* If I'm the only one holding a lock, then there
@ -582,19 +580,19 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
*/
if (result->nHolding == lock->nActive)
{
result->holders[locktype]++;
result->holders[lockmode]++;
result->nHolding++;
GrantLock(lock, locktype);
GrantLock(lock, lockmode);
SpinRelease(masterLock);
return (TRUE);
}
Assert(result->nHolding <= lock->nActive);
status = LockResolveConflicts(ltable, lock, locktype, myXid);
status = LockResolveConflicts(lockmethod, lock, lockmode, myXid);
if (status == STATUS_OK)
GrantLock(lock, locktype);
GrantLock(lock, lockmode);
else if (status == STATUS_FOUND)
{
#ifdef USER_LOCKS
@ -611,7 +609,7 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
hash_search(xidTable, (Pointer) &item, HASH_REMOVE, &found);
}
lock->nHolding--;
lock->holders[locktype]--;
lock->holders[lockmode]--;
SpinRelease(masterLock);
#ifdef USER_LOCKS_DEBUG
elog(NOTICE, "LockAcquire: user lock failed");
@ -619,7 +617,7 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
return (FALSE);
}
#endif
status = WaitOnLock(ltable, tableId, lock, locktype);
status = WaitOnLock(lockmethod, lock, lockmode);
XID_PRINT("Someone granted me the lock", result);
}
@ -645,23 +643,23 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* ----------------------------
*/
int
LockResolveConflicts(LOCKTAB *ltable,
LockResolveConflicts(LOCKMETHOD lockmethod,
LOCK *lock,
LOCKTYPE locktype,
LOCKMODE lockmode,
TransactionId xid)
{
XIDLookupEnt *result,
item;
int *myHolders;
int nLockTypes;
int numLockModes;
HTAB *xidTable;
bool found;
int bitmask;
int i,
tmpMask;
nLockTypes = ltable->ctl->nLockTypes;
xidTable = ltable->xidHash;
numLockModes = LockMethodTable[lockmethod]->ctl->numLockModes;
xidTable = LockMethodTable[lockmethod]->xidHash;
/* ---------------------
* read my own statistics from the xid table. If there
@ -693,7 +691,7 @@ LockResolveConflicts(LOCKTAB *ltable,
* the lock stats.
* ---------------
*/
MemSet(result->holders, 0, nLockTypes * sizeof(*(lock->holders)));
MemSet(result->holders, 0, numLockModes * sizeof(*(lock->holders)));
result->nHolding = 0;
}
@ -703,7 +701,7 @@ LockResolveConflicts(LOCKTAB *ltable,
* do not continue and share the lock, even if we can. bjm
* ------------------------
*/
int myprio = ltable->ctl->prio[locktype];
int myprio = LockMethodTable[lockmethod]->ctl->prio[lockmode];
PROC_QUEUE *waitQueue = &(lock->waitProcs);
PROC *topproc = (PROC *) MAKE_PTR(waitQueue->links.prev);
@ -716,15 +714,15 @@ LockResolveConflicts(LOCKTAB *ltable,
* with mine, then I get the lock.
*
* Checking for conflict: lock->mask represents the types of
* currently held locks. conflictTable[locktype] has a bit
* currently held locks. conflictTable[lockmode] has a bit
* set for each type of lock that conflicts with mine. Bitwise
* compare tells if there is a conflict.
* ----------------------------
*/
if (!(ltable->ctl->conflictTab[locktype] & lock->mask))
if (!(LockMethodTable[lockmethod]->ctl->conflictTab[lockmode] & lock->mask))
{
result->holders[locktype]++;
result->holders[lockmode]++;
result->nHolding++;
XID_PRINT("Conflict Resolved: updated xid entry stats", result);
@ -740,7 +738,7 @@ LockResolveConflicts(LOCKTAB *ltable,
*/
bitmask = 0;
tmpMask = 2;
for (i = 1; i <= nLockTypes; i++, tmpMask <<= 1)
for (i = 1; i <= numLockModes; i++, tmpMask <<= 1)
{
if (lock->activeHolders[i] != myHolders[i])
bitmask |= tmpMask;
@ -753,12 +751,12 @@ LockResolveConflicts(LOCKTAB *ltable,
* conflict and I have to sleep.
* ------------------------
*/
if (!(ltable->ctl->conflictTab[locktype] & bitmask))
if (!(LockMethodTable[lockmethod]->ctl->conflictTab[lockmode] & bitmask))
{
/* no conflict. Get the lock and go on */
result->holders[locktype]++;
result->holders[lockmode]++;
result->nHolding++;
XID_PRINT("Conflict Resolved: updated xid entry stats", result);
@ -771,11 +769,13 @@ LockResolveConflicts(LOCKTAB *ltable,
}
static int
WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock, LOCKTYPE locktype)
WaitOnLock(LOCKMETHOD lockmethod, LOCK *lock, LOCKMODE lockmode)
{
PROC_QUEUE *waitQueue = &(lock->waitProcs);
LOCKMETHODTABLE *lockMethodTable = LockMethodTable[lockmethod];
int prio = lockMethodTable->ctl->prio[lockmode];
int prio = ltable->ctl->prio[locktype];
Assert(lockmethod < NumLockMethods);
/*
* the waitqueue is ordered by priority. I insert myself according to
@ -785,10 +785,10 @@ WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock, LOCKTYPE locktype)
* synchronization for this queue. That will not be true if/when
* people can be deleted from the queue by a SIGINT or something.
*/
LOCK_DUMP_AUX("WaitOnLock: sleeping on lock", lock, locktype);
LOCK_DUMP_AUX("WaitOnLock: sleeping on lock", lock, lockmode);
if (ProcSleep(waitQueue,
ltable->ctl->masterLock,
locktype,
lockMethodTable->ctl->masterLock,
lockmode,
prio,
lock) != NO_ERROR)
{
@ -799,18 +799,18 @@ WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock, LOCKTYPE locktype)
* -------------------
*/
lock->nHolding--;
lock->holders[locktype]--;
LOCK_DUMP_AUX("WaitOnLock: aborting on lock", lock, locktype);
SpinRelease(ltable->ctl->masterLock);
lock->holders[lockmode]--;
LOCK_DUMP_AUX("WaitOnLock: aborting on lock", lock, lockmode);
SpinRelease(lockMethodTable->ctl->masterLock);
elog(ERROR, "WaitOnLock: error on wakeup - Aborting this transaction");
}
LOCK_DUMP_AUX("WaitOnLock: wakeup on lock", lock, locktype);
LOCK_DUMP_AUX("WaitOnLock: wakeup on lock", lock, lockmode);
return (STATUS_OK);
}
/*
* LockRelease -- look up 'lockName' in lock table 'tableId' and
* LockRelease -- look up 'locktag' in lock table 'lockmethod' and
* release it.
*
* Side Effects: if the lock no longer conflicts with the highest
@ -820,12 +820,12 @@ WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock, LOCKTYPE locktype)
* come along and request the lock).
*/
bool
LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag, LOCKMODE lockmode)
{
LOCK *lock = NULL;
SPINLOCK masterLock;
bool found;
LOCKTAB *ltable;
LOCKMETHODTABLE *lockMethodTable;
XIDLookupEnt *result,
item;
HTAB *xidTable;
@ -834,41 +834,41 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
#ifdef USER_LOCKS
int is_user_lock;
is_user_lock = (tableId == 0);
is_user_lock = (lockmethod == 0);
if (is_user_lock)
{
tableId = 1;
lockmethod = 1;
#ifdef USER_LOCKS_DEBUG
elog(NOTICE, "LockRelease: user lock tag [%u,%u] %d",
lockName->tupleId.ip_posid,
((lockName->tupleId.ip_blkid.bi_hi << 16) +
lockName->tupleId.ip_blkid.bi_lo),
locktype);
locktag->tupleId.ip_posid,
((locktag->tupleId.ip_blkid.bi_hi << 16) +
locktag->tupleId.ip_blkid.bi_lo),
lockmode);
#endif
}
#endif
Assert(tableId < NumTables);
ltable = AllTables[tableId];
if (!ltable)
Assert(lockmethod < NumLockMethods);
lockMethodTable = LockMethodTable[lockmethod];
if (!lockMethodTable)
{
elog(NOTICE, "ltable is null in LockRelease");
elog(NOTICE, "lockMethodTable is null in LockRelease");
return (FALSE);
}
if (LockingIsDisabled)
return (TRUE);
LOCK_PRINT("Release", lockName, locktype);
LOCK_PRINT("Release", locktag, lockmode);
masterLock = ltable->ctl->masterLock;
xidTable = ltable->xidHash;
masterLock = lockMethodTable->ctl->masterLock;
xidTable = lockMethodTable->xidHash;
SpinAcquire(masterLock);
Assert(ltable->lockHash->hash == tag_hash);
Assert(lockMethodTable->lockHash->hash == tag_hash);
lock = (LOCK *)
hash_search(ltable->lockHash, (Pointer) lockName, HASH_FIND_SAVE, &found);
hash_search(lockMethodTable->lockHash, (Pointer) locktag, HASH_FIND_SAVE, &found);
#ifdef USER_LOCKS
@ -919,9 +919,9 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* fix the general lock stats
*/
lock->nHolding--;
lock->holders[locktype]--;
lock->holders[lockmode]--;
lock->nActive--;
lock->activeHolders[locktype]--;
lock->activeHolders[lockmode]--;
Assert(lock->nActive >= 0);
@ -933,8 +933,8 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* Delete it from the lock table.
* ------------------
*/
Assert(ltable->lockHash->hash == tag_hash);
lock = (LOCK *) hash_search(ltable->lockHash,
Assert(lockMethodTable->lockHash->hash == tag_hash);
lock = (LOCK *) hash_search(lockMethodTable->lockHash,
(Pointer) &(lock->tag),
HASH_REMOVE_SAVED,
&found);
@ -992,7 +992,7 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* now check to see if I have any private locks. If I do, decrement
* the counts associated with them.
*/
result->holders[locktype]--;
result->holders[lockmode]--;
result->nHolding--;
XID_PRINT("LockRelease updated xid stats", result);
@ -1038,9 +1038,9 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* fix the general lock stats
*/
lock->nHolding--;
lock->holders[locktype]--;
lock->holders[lockmode]--;
lock->nActive--;
lock->activeHolders[locktype]--;
lock->activeHolders[lockmode]--;
Assert(lock->nActive >= 0);
@ -1052,8 +1052,8 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* Delete it from the lock table.
* ------------------
*/
Assert(ltable->lockHash->hash == tag_hash);
lock = (LOCK *) hash_search(ltable->lockHash,
Assert(lockMethodTable->lockHash->hash == tag_hash);
lock = (LOCK *) hash_search(lockMethodTable->lockHash,
(Pointer) &(lock->tag),
HASH_REMOVE,
&found);
@ -1069,10 +1069,10 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* with the remaining locks.
* --------------------------
*/
if (!(lock->activeHolders[locktype]))
if (!(lock->activeHolders[lockmode]))
{
/* change the conflict mask. No more of this lock type. */
lock->mask &= BITS_OFF[locktype];
lock->mask &= BITS_OFF[lockmode];
}
if (wakeupNeeded)
@ -1083,7 +1083,7 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
* himself.
* --------------------------
*/
ProcLockWakeup(&(lock->waitProcs), (char *) ltable, (char *) lock);
ProcLockWakeup(&(lock->waitProcs), lockmethod, lock);
}
SpinRelease(masterLock);
@ -1091,15 +1091,15 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype)
}
/*
* GrantLock -- udpate the lock data structure to show
* GrantLock -- update the lock data structure to show
* the new lock holder.
*/
void
GrantLock(LOCK *lock, LOCKTYPE locktype)
GrantLock(LOCK *lock, LOCKMODE lockmode)
{
lock->nActive++;
lock->activeHolders[locktype]++;
lock->mask |= BITS_ON[locktype];
lock->activeHolders[lockmode]++;
lock->mask |= BITS_ON[lockmode];
}
#ifdef USER_LOCKS
@ -1110,12 +1110,12 @@ GrantLock(LOCK *lock, LOCKTYPE locktype)
* same queue of user locks which can't be removed from the
* normal lock queue at the end of a transaction. They must
* however be removed when the backend exits.
* A dummy tableId 0 is used to indicate that we are releasing
* A dummy lockmethod 0 is used to indicate that we are releasing
* the user locks, from the code added to ProcKill().
*/
#endif
bool
LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue)
LockReleaseAll(LOCKMETHOD lockmethod, SHM_QUEUE *lockQueue)
{
PROC_QUEUE *waitQueue;
int done;
@ -1123,9 +1123,9 @@ LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue)
XIDLookupEnt *tmp = NULL;
SHMEM_OFFSET end = MAKE_OFFSET(lockQueue);
SPINLOCK masterLock;
LOCKTAB *ltable;
LOCKMETHODTABLE *lockMethodTable;
int i,
nLockTypes;
numLockModes;
LOCK *lock;
bool found;
@ -1134,21 +1134,21 @@ LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue)
count,
nskip;
is_user_lock_table = (tableId == 0);
is_user_lock_table = (lockmethod == 0);
#ifdef USER_LOCKS_DEBUG
elog(NOTICE, "LockReleaseAll: tableId=%d, pid=%d", tableId, MyProcPid);
elog(NOTICE, "LockReleaseAll: lockmethod=%d, pid=%d", lockmethod, MyProcPid);
#endif
if (is_user_lock_table)
tableId = 1;
lockmethod = 1;
#endif
Assert(tableId < NumTables);
ltable = AllTables[tableId];
if (!ltable)
Assert(lockmethod < NumLockMethods);
lockMethodTable = LockMethodTable[lockmethod];
if (!lockMethodTable)
return (FALSE);
nLockTypes = ltable->ctl->nLockTypes;
masterLock = ltable->ctl->masterLock;
numLockModes = lockMethodTable->ctl->numLockModes;
masterLock = lockMethodTable->ctl->masterLock;
if (SHMQueueEmpty(lockQueue))
return TRUE;
@ -1254,7 +1254,7 @@ LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue)
lock->nHolding -= xidLook->nHolding;
lock->nActive -= xidLook->nHolding;
Assert(lock->nActive >= 0);
for (i = 1; i <= nLockTypes; i++)
for (i = 1; i <= numLockModes; i++)
{
lock->holders[i] -= xidLook->holders[i];
lock->activeHolders[i] -= xidLook->holders[i];
@ -1278,7 +1278,7 @@ LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue)
#ifdef USER_LOCKS
SHMQueueDelete(&xidLook->queue);
#endif
if ((!hash_search(ltable->xidHash, (Pointer) xidLook, HASH_REMOVE, &found))
if ((!hash_search(lockMethodTable->xidHash, (Pointer) xidLook, HASH_REMOVE, &found))
|| !found)
{
SpinRelease(masterLock);
@ -1294,9 +1294,9 @@ LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue)
* --------------------
*/
Assert(ltable->lockHash->hash == tag_hash);
Assert(lockMethodTable->lockHash->hash == tag_hash);
lock = (LOCK *)
hash_search(ltable->lockHash, (Pointer) &(lock->tag), HASH_REMOVE, &found);
hash_search(lockMethodTable->lockHash, (Pointer) &(lock->tag), HASH_REMOVE, &found);
if ((!lock) || (!found))
{
SpinRelease(masterLock);
@ -1313,7 +1313,7 @@ LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue)
* --------------------
*/
waitQueue = &(lock->waitProcs);
ProcLockWakeup(waitQueue, (char *) ltable, (char *) lock);
ProcLockWakeup(waitQueue, lockmethod, lock);
}
#ifdef USER_LOCKS
@ -1352,7 +1352,7 @@ LockShmemSize()
nXidSegs = 1 << (int) my_log2((nLockBuckets - 1) / DEF_SEGSIZE + 1);
size += MAXALIGN(NBACKENDS * sizeof(PROC)); /* each MyProc */
size += MAXALIGN(NBACKENDS * sizeof(LOCKCTL)); /* each ltable->ctl */
size += MAXALIGN(NBACKENDS * sizeof(LOCKMETHODCTL)); /* each lockMethodTable->ctl */
size += MAXALIGN(sizeof(PROC_HDR)); /* ProcGlobal */
size += MAXALIGN(my_log2(NLOCKENTS) * sizeof(void *));
@ -1404,7 +1404,7 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
SHMEM_OFFSET end = MAKE_OFFSET(lockQueue);
LOCK *lock;
LOCKTAB *ltable;
LOCKMETHODTABLE *lockMethodTable;
XIDLookupEnt *result,
item;
HTAB *xidTable;
@ -1420,8 +1420,8 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
checked_procs[0] = MyProc;
nprocs = 1;
ltable = AllTables[1];
xidTable = ltable->xidHash;
lockMethodTable = LockMethodTable[1];
xidTable = lockMethodTable->xidHash;
MemSet(&item, 0, XID_TAGSIZE);
TransactionIdStore(MyProc->xid, &item.tag.xid);
@ -1499,8 +1499,8 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
Assert(skip_check);
Assert(MyProc->prio == 2);
ltable = AllTables[1];
xidTable = ltable->xidHash;
lockMethodTable = LockMethodTable[1];
xidTable = lockMethodTable->xidHash;
MemSet(&item, 0, XID_TAGSIZE);
TransactionIdStore(proc->xid, &item.tag.xid);
@ -1575,12 +1575,12 @@ DumpLocks()
XIDLookupEnt *tmp = NULL;
SHMEM_OFFSET end;
SPINLOCK masterLock;
int nLockTypes;
int numLockModes;
LOCK *lock;
count;
int tableId = 1;
LOCKTAB *ltable;
int lockmethod = 1;
LOCKMETHODTABLE *lockMethodTable;
ShmemPIDLookup(MyProcPid, &location);
if (location == INVALID_OFFSET)
@ -1590,13 +1590,13 @@ DumpLocks()
return;
lockQueue = &proc->lockQueue;
Assert(tableId < NumTables);
ltable = AllTables[tableId];
if (!ltable)
Assert(lockmethod < NumLockMethods);
lockMethodTable = LockMethodTable[lockmethod];
if (!lockMethodTable)
return;
nLockTypes = ltable->ctl->nLockTypes;
masterLock = ltable->ctl->masterLock;
numLockModes = lockMethodTable->ctl->numLockModes;
masterLock = lockMethodTable->ctl->masterLock;
if (SHMQueueEmpty(lockQueue))
return;

86
src/backend/storage/lmgr/multi.c
View File

@ -12,7 +12,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/multi.c,v 1.18 1998/06/28 21:17:35 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/multi.c,v 1.19 1998/06/30 02:33:31 momjian Exp $
*
* NOTES:
* (1) The lock.c module assumes that the caller here is doing
@ -30,10 +30,10 @@
#include "miscadmin.h" /* MyDatabaseId */
static bool
MultiAcquire(LockTableId tableId, LOCKTAG *tag, LOCKTYPE locktype,
MultiAcquire(LOCKMETHOD lockmethod, LOCKTAG *tag, LOCKMODE lockmode,
PG_LOCK_LEVEL level);
static bool
MultiRelease(LockTableId tableId, LOCKTAG *tag, LOCKTYPE locktype,
MultiRelease(LOCKMETHOD lockmethod, LOCKTAG *tag, LOCKMODE lockmode,
PG_LOCK_LEVEL level);
/*
@ -78,25 +78,27 @@ static int MultiPrios[] = {
* Lock table identifier for this lock table. The multi-level
* lock table is ONE lock table, not three.
*/
LockTableId MultiTableId = (LockTableId) NULL;
LockTableId ShortTermTableId = (LockTableId) NULL;
LOCKMETHOD MultiTableId = (LOCKMETHOD) NULL;
#ifdef NOT_USED
LOCKMETHOD ShortTermTableId = (LOCKMETHOD) NULL;
#endif
/*
* Create the lock table described by MultiConflicts and Multiprio.
*/
LockTableId
LOCKMETHOD
InitMultiLevelLocks()
{
int tableId;
int lockmethod;
tableId = LockTableInit("LockTable", MultiConflicts, MultiPrios, 5);
MultiTableId = tableId;
lockmethod = LockMethodTableInit("MultiLevelLockTable", MultiConflicts, MultiPrios, 5);
MultiTableId = lockmethod;
if (!(MultiTableId))
elog(ERROR, "InitMultiLocks: couldnt initialize lock table");
/* -----------------------
* No short term lock table for now. -Jeff 15 July 1991
*
* ShortTermTableId = LockTableRename(tableId);
* ShortTermTableId = LockTableRename(lockmethod);
* if (! (ShortTermTableId)) {
* elog(ERROR,"InitMultiLocks: couldnt rename lock table");
* }
@ -111,7 +113,7 @@ InitMultiLevelLocks()
* Returns: TRUE if the lock can be set, FALSE otherwise.
*/
bool
MultiLockReln(LockInfo linfo, LOCKTYPE locktype)
MultiLockReln(LockInfo linfo, LOCKMODE lockmode)
{
LOCKTAG tag;
@ -122,7 +124,7 @@ MultiLockReln(LockInfo linfo, LOCKTYPE locktype)
MemSet(&tag, 0, sizeof(tag));
tag.relId = linfo->lRelId.relId;
tag.dbId = linfo->lRelId.dbId;
return (MultiAcquire(MultiTableId, &tag, locktype, RELN_LEVEL));
return (MultiAcquire(MultiTableId, &tag, lockmode, RELN_LEVEL));
}
/*
@ -134,7 +136,7 @@ MultiLockReln(LockInfo linfo, LOCKTYPE locktype)
* at the page and relation level.
*/
bool
MultiLockTuple(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype)
MultiLockTuple(LockInfo linfo, ItemPointer tidPtr, LOCKMODE lockmode)
{
LOCKTAG tag;
@ -149,14 +151,14 @@ MultiLockTuple(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype)
/* not locking any valid Tuple, just the page */
tag.tupleId = *tidPtr;
return (MultiAcquire(MultiTableId, &tag, locktype, TUPLE_LEVEL));
return (MultiAcquire(MultiTableId, &tag, lockmode, TUPLE_LEVEL));
}
/*
* same as above at page level
*/
bool
MultiLockPage(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype)
MultiLockPage(LockInfo linfo, ItemPointer tidPtr, LOCKMODE lockmode)
{
LOCKTAG tag;
@ -179,7 +181,7 @@ MultiLockPage(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype)
tag.relId = linfo->lRelId.relId;
tag.dbId = linfo->lRelId.dbId;
BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
return (MultiAcquire(MultiTableId, &tag, locktype, PAGE_LEVEL));
return (MultiAcquire(MultiTableId, &tag, lockmode, PAGE_LEVEL));
}
/*
@ -189,12 +191,12 @@ MultiLockPage(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype)
* Side Effects:
*/
static bool
MultiAcquire(LockTableId tableId,
MultiAcquire(LOCKMETHOD lockmethod,
LOCKTAG *tag,
LOCKTYPE locktype,
LOCKMODE lockmode,
PG_LOCK_LEVEL level)
{
LOCKTYPE locks[N_LEVELS];
LOCKMODE locks[N_LEVELS];
int i,
status;
LOCKTAG xxTag,
@ -213,19 +215,19 @@ MultiAcquire(LockTableId tableId,
switch (level)
{
case RELN_LEVEL:
locks[0] = locktype;
locks[0] = lockmode;
locks[1] = NO_LOCK;
locks[2] = NO_LOCK;
break;
case PAGE_LEVEL:
locks[0] = locktype + INTENT;
locks[1] = locktype;
locks[0] = lockmode + INTENT;
locks[1] = lockmode;
locks[2] = NO_LOCK;
break;
case TUPLE_LEVEL:
locks[0] = locktype + INTENT;
locks[1] = locktype + INTENT;
locks[2] = locktype;
locks[0] = lockmode + INTENT;
locks[1] = lockmode + INTENT;
locks[2] = lockmode;
break;
default:
elog(ERROR, "MultiAcquire: bad lock level");
@ -274,7 +276,7 @@ MultiAcquire(LockTableId tableId,
break;
}
status = LockAcquire(tableId, tmpTag, locks[i]);
status = LockAcquire(lockmethod, tmpTag, locks[i]);
if (!status)
{
@ -285,7 +287,7 @@ MultiAcquire(LockTableId tableId,
* the last level lock we successfully acquired
*/
retStatus = FALSE;
MultiRelease(tableId, tag, locktype, i);
MultiRelease(lockmethod, tag, lockmode, i);
/* now leave the loop. Don't try for any more locks */
break;
}
@ -300,7 +302,7 @@ MultiAcquire(LockTableId tableId,
*/
#ifdef NOT_USED
bool
MultiReleasePage(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype)
MultiReleasePage(LockInfo linfo, ItemPointer tidPtr, LOCKMODE lockmode)
{
LOCKTAG tag;
@ -316,7 +318,7 @@ MultiReleasePage(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype)
tag.dbId = linfo->lRelId.dbId;
BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
return (MultiRelease(MultiTableId, &tag, locktype, PAGE_LEVEL));
return (MultiRelease(MultiTableId, &tag, lockmode, PAGE_LEVEL));
}
#endif
@ -326,7 +328,7 @@ MultiReleasePage(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype)
* ------------------
*/
bool
MultiReleaseReln(LockInfo linfo, LOCKTYPE locktype)
MultiReleaseReln(LockInfo linfo, LOCKMODE lockmode)
{
LOCKTAG tag;
@ -340,7 +342,7 @@ MultiReleaseReln(LockInfo linfo, LOCKTYPE locktype)
tag.relId = linfo->lRelId.relId;
tag.dbId = linfo->lRelId.dbId;
return (MultiRelease(MultiTableId, &tag, locktype, RELN_LEVEL));
return (MultiRelease(MultiTableId, &tag, lockmode, RELN_LEVEL));
}
/*
@ -349,12 +351,12 @@ MultiReleaseReln(LockInfo linfo, LOCKTYPE locktype)
* Returns: TRUE if successful, FALSE otherwise.
*/
static bool
MultiRelease(LockTableId tableId,
MultiRelease(LOCKMETHOD lockmethod,
LOCKTAG *tag,
LOCKTYPE locktype,
LOCKMODE lockmode,
PG_LOCK_LEVEL level)
{
LOCKTYPE locks[N_LEVELS];
LOCKMODE locks[N_LEVELS];
int i,
status;
LOCKTAG xxTag,
@ -366,22 +368,22 @@ MultiRelease(LockTableId tableId,
switch (level)
{
case RELN_LEVEL:
locks[0] = locktype;
locks[0] = lockmode;
locks[1] = NO_LOCK;
locks[2] = NO_LOCK;
break;
case PAGE_LEVEL:
locks[0] = locktype + INTENT;
locks[1] = locktype;
locks[0] = lockmode + INTENT;
locks[1] = lockmode;
locks[2] = NO_LOCK;
break;
case TUPLE_LEVEL:
locks[0] = locktype + INTENT;
locks[1] = locktype + INTENT;
locks[2] = locktype;
locks[0] = lockmode + INTENT;
locks[1] = lockmode + INTENT;
locks[2] = lockmode;
break;
default:
elog(ERROR, "MultiRelease: bad locktype");
elog(ERROR, "MultiRelease: bad lockmode");
}
/*
@ -423,7 +425,7 @@ MultiRelease(LockTableId tableId,
ItemPointerCopy(&tmpTag->tupleId, &tag->tupleId);
break;
}
status = LockRelease(tableId, tmpTag, locks[i]);
status = LockRelease(lockmethod, tmpTag, locks[i]);
if (!status)
elog(ERROR, "MultiRelease: couldn't release after error");
}

12
src/backend/storage/lmgr/proc.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.38 1998/06/27 15:47:46 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.39 1998/06/30 02:33:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -46,7 +46,7 @@
* This is so that we can support more backends. (system-wide semaphore
* sets run out pretty fast.) -ay 4/95
*
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.38 1998/06/27 15:47:46 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.39 1998/06/30 02:33:32 momjian Exp $
*/
#include <sys/time.h>
#include <unistd.h>
@ -580,7 +580,7 @@ ProcWakeup(PROC *proc, int errType)
* released.
*/
int
ProcLockWakeup(PROC_QUEUE *queue, char *ltable, char *lock)
ProcLockWakeup(PROC_QUEUE *queue, LOCKMETHOD lockmethod, LOCK *lock)
{
PROC *proc;
int count;
@ -590,8 +590,8 @@ ProcLockWakeup(PROC_QUEUE *queue, char *ltable, char *lock)
proc = (PROC *) MAKE_PTR(queue->links.prev);
count = 0;
while ((LockResolveConflicts((LOCKTAB *) ltable,
(LOCK *) lock,
while ((LockResolveConflicts(lockmethod,
lock,
proc->token,
proc->xid) == STATUS_OK))
{
@ -602,7 +602,7 @@ ProcLockWakeup(PROC_QUEUE *queue, char *ltable, char *lock)
* between the time we release the lock master (spinlock) and the
* time that the awoken process begins executing again.
*/
GrantLock((LOCK *) lock, proc->token);
GrantLock(lock, proc->token);
queue->size--;
/*

14
src/backend/storage/lmgr/single.c
View File

@ -13,7 +13,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/single.c,v 1.6 1998/06/28 21:17:35 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/single.c,v 1.7 1998/06/30 02:33:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -32,7 +32,7 @@
* Returns: TRUE if the lock can be set, FALSE otherwise.
*/
bool
SingleLockReln(LockInfo linfo, LOCKTYPE locktype, int action)
SingleLockReln(LockInfo linfo, LOCKMODE lockmode, int action)
{
LOCKTAG tag;
@ -47,9 +47,9 @@ SingleLockReln(LockInfo linfo, LOCKTYPE locktype, int action)
tag.tupleId.ip_posid = InvalidOffsetNumber;
if (action == UNLOCK)
return (LockRelease(MultiTableId, &tag, locktype));
return (LockRelease(MultiTableId, &tag, lockmode));
else
return (LockAcquire(MultiTableId, &tag, locktype));
return (LockAcquire(MultiTableId, &tag, lockmode));
}
/*
@ -63,7 +63,7 @@ SingleLockReln(LockInfo linfo, LOCKTYPE locktype, int action)
bool
SingleLockPage(LockInfo linfo,
ItemPointer tidPtr,
LOCKTYPE locktype,
LOCKMODE lockmode,
int action)
{
LOCKTAG tag;
@ -80,7 +80,7 @@ SingleLockPage(LockInfo linfo,
if (action == UNLOCK)
return (LockRelease(MultiTableId, &tag, locktype));
return (LockRelease(MultiTableId, &tag, lockmode));
else
return (LockAcquire(MultiTableId, &tag, locktype));
return (LockAcquire(MultiTableId, &tag, lockmode));
}

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

@ -6,7 +6,7 @@
*
* Copyright (c) 1994, Regents of the University of California
*
* $Id: lmgr.h,v 1.11 1998/06/28 21:17:35 momjian Exp $
* $Id: lmgr.h,v 1.12 1998/06/30 02:33:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -72,10 +72,10 @@ extern void RelationSetWIntentLock(Relation relation);
extern void RelationUnsetWIntentLock(Relation relation);
/* single.c */
extern bool SingleLockReln(LockInfo linfo, LOCKTYPE locktype, int action);
extern bool SingleLockReln(LockInfo linfo, LOCKMODE lockmode, int action);
extern bool
SingleLockPage(LockInfo linfo, ItemPointer tidPtr,
LOCKTYPE locktype, int action);
LOCKMODE lockmode, int action);
/* proc.c */
extern void InitProcGlobal(IPCKey key);

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

@ -6,7 +6,7 @@
*
* Copyright (c) 1994, Regents of the University of California
*
* $Id: lock.h,v 1.14 1998/06/28 21:17:35 momjian Exp $
* $Id: lock.h,v 1.15 1998/06/30 02:33:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -36,26 +36,25 @@ typedef int MASK;
#define NLOCKS_PER_XACT 40
#define NLOCKENTS NLOCKS_PER_XACT*NBACKENDS
typedef int LOCK_TYPE;
typedef int LOCKTYPE;
typedef int LockTableId;
typedef int LOCKMODE;
typedef int LOCKMETHOD;
/* MAX_LOCKTYPES cannot be larger than the bits in MASK */
#define MAX_LOCKTYPES 6
/* MAX_LOCKMODES cannot be larger than the bits in MASK */
#define MAX_LOCKMODES 6
/*
* MAX_TABLES corresponds to the number of spin locks allocated in
* MAX_LOCK_METHODS corresponds to the number of spin locks allocated in
* CreateSpinLocks() or the number of shared memory locations allocated
* for lock table spin locks in the case of machines with TAS instructions.
*/
#define MAX_TABLES 2
#define MAX_LOCK_METHODS 2
#define INVALID_TABLEID 0
/*typedef struct LOCK LOCK; */
typedef struct ltag
typedef struct LTAG
{
Oid relId;
Oid dbId;
@ -67,31 +66,31 @@ typedef struct ltag
/* This is the control structure for a lock table. It
* lives in shared memory:
*
* tableID -- the handle used by the lock table's clients to
* refer to the table.
* lockmethod -- the handle used by the lock table's clients to
* refer to the type of lock table being used.
*
* nLockTypes -- number of lock types (READ,WRITE,etc) that
* numLockModes -- number of lock types (READ,WRITE,etc) that
* are defined on this lock table
*
* conflictTab -- this is an array of bitmasks showing lock
* type conflicts. conflictTab[i] is a mask with the j-th bit
* turned on if lock types i and j conflict.
*
* prio -- each locktype has a priority, so, for example, waiting
* prio -- each lockmode has a priority, so, for example, waiting
* writers can be given priority over readers (to avoid
* starvation).
*
* masterlock -- synchronizes access to the table
*
*/
typedef struct lockctl
typedef struct LOCKMETHODCTL
{
LockTableId tableId;
int nLockTypes;
int conflictTab[MAX_LOCKTYPES];
int prio[MAX_LOCKTYPES];
LOCKMETHOD lockmethod;
int numLockModes;
int conflictTab[MAX_LOCKMODES];
int prio[MAX_LOCKMODES];
SPINLOCK masterLock;
} LOCKCTL;
} LOCKMETHODCTL;
/*
* lockHash -- hash table on lock Ids,
@ -99,12 +98,12 @@ typedef struct lockctl
* multiple processes are holding the lock
* ctl - control structure described above.
*/
typedef struct ltable
typedef struct LOCKMETHODTABLE
{
HTAB *lockHash;
HTAB *xidHash;
LOCKCTL *ctl;
} LOCKTAB;
LOCKMETHODCTL *ctl;
} LOCKMETHODTABLE;
/* -----------------------
* A transaction never conflicts with its own locks. Hence, if
@ -148,7 +147,7 @@ typedef struct XIDLookupEnt
XIDTAG tag;
/* data */
int holders[MAX_LOCKTYPES];
int holders[MAX_LOCKMODES];
int nHolding;
SHM_QUEUE queue;
} XIDLookupEnt;
@ -156,7 +155,7 @@ typedef struct XIDLookupEnt
#define XID_TAGSIZE (sizeof(XIDTAG))
/* originally in procq.h */
typedef struct procQueue
typedef struct PROC_QUEUE
{
SHM_QUEUE links;
int size;
@ -174,7 +173,7 @@ typedef struct procQueue
* lock.
* nHolding -- total locks of all types.
*/
typedef struct Lock
typedef struct LOCK
{
/* hash key */
LOCKTAG tag;
@ -182,18 +181,18 @@ typedef struct Lock
/* data */
int mask;
PROC_QUEUE waitProcs;
int holders[MAX_LOCKTYPES];
int holders[MAX_LOCKMODES];
int nHolding;
int activeHolders[MAX_LOCKTYPES];
int activeHolders[MAX_LOCKMODES];
int nActive;
} LOCK;
#define LockGetLock_nHolders(l) l->nHolders
#define LockDecrWaitHolders(lock, locktype) \
#define LockDecrWaitHolders(lock, lockmode) \
( \
lock->nHolding--, \
lock->holders[locktype]-- \
lock->holders[lockmode]-- \
)
#define LockLockTable() SpinAcquire(LockMgrLock);
@ -206,16 +205,16 @@ extern SPINLOCK LockMgrLock;
*/
extern void InitLocks(void);
extern void LockDisable(int status);
extern LockTableId
LockTableInit(char *tabName, MASK *conflictsP, int *prioP,
int ntypes);
extern bool LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype);
extern LOCKMETHOD
LockMethodTableInit(char *tabName, MASK *conflictsP, int *prioP,
int numModes);
extern bool LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag, LOCKMODE lockmode);
extern int
LockResolveConflicts(LOCKTAB *ltable, LOCK *lock, LOCKTYPE locktype,
LockResolveConflicts(LOCKMETHOD lockmethod, LOCK *lock, LOCKMODE lockmode,
TransactionId xid);
extern bool LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKTYPE locktype);
extern void GrantLock(LOCK *lock, LOCKTYPE locktype);
extern bool LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue);
extern bool LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag, LOCKMODE lockmode);
extern void GrantLock(LOCK *lock, LOCKMODE lockmode);
extern bool LockReleaseAll(LOCKMETHOD lockmethod, SHM_QUEUE *lockQueue);
extern int LockShmemSize(void);
extern bool LockingDisabled(void);
extern bool DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check);

18
src/include/storage/multilev.h
View File

@ -7,7 +7,7 @@
*
* Copyright (c) 1994, Regents of the University of California
*
* $Id: multilev.h,v 1.9 1998/06/28 21:17:36 momjian Exp $
* $Id: multilev.h,v 1.10 1998/06/30 02:33:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -43,16 +43,18 @@ typedef int PG_LOCK_LEVEL;
/* multi.c */
extern LockTableId MultiTableId;
extern LockTableId ShortTermTableId;
extern LOCKMETHOD MultiTableId;
#ifdef NOT_USED
extern LOCKMETHOD ShortTermTableId;
#endif
/*
* function prototypes
*/
extern LockTableId InitMultiLevelLocks(void);
extern bool MultiLockReln(LockInfo linfo, LOCKTYPE locktype);
extern bool MultiLockTuple(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype);
extern bool MultiLockPage(LockInfo linfo, ItemPointer tidPtr, LOCKTYPE locktype);
extern bool MultiReleaseReln(LockInfo linfo, LOCKTYPE locktype);
extern LOCKMETHOD InitMultiLevelLocks(void);
extern bool MultiLockReln(LockInfo linfo, LOCKMODE lockmode);
extern bool MultiLockTuple(LockInfo linfo, ItemPointer tidPtr, LOCKMODE lockmode);
extern bool MultiLockPage(LockInfo linfo, ItemPointer tidPtr, LOCKMODE lockmode);
extern bool MultiReleaseReln(LockInfo linfo, LOCKMODE lockmode);
#endif /* MULTILEV_H */

4
src/include/storage/proc.h
View File

@ -6,7 +6,7 @@
*
* Copyright (c) 1994, Regents of the University of California
*
* $Id: proc.h,v 1.11 1998/02/26 04:43:31 momjian Exp $
* $Id: proc.h,v 1.12 1998/06/30 02:33:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -100,7 +100,7 @@ extern void ProcQueueInit(PROC_QUEUE *queue);
extern int
ProcSleep(PROC_QUEUE *queue, SPINLOCK spinlock, int token,
int prio, LOCK *lock);
extern int ProcLockWakeup(PROC_QUEUE *queue, char *ltable, char *lock);
extern int ProcLockWakeup(PROC_QUEUE *queue, LOCKMETHOD lockmethod, LOCK *lock);
extern void ProcAddLock(SHM_QUEUE *elem);
extern void ProcReleaseSpins(PROC *proc);
extern void ProcFreeAllSemaphores(void);

46
src/tools/backend/index.html
View File

@ -25,13 +25,13 @@ structure, like
The query is then identified as a <I>Utility</I> function or a more
complex query. A <I>Utility</I> query is processed by a
query-specific function in <A HREF="../../backend/commands">
commands.</A> A complex query, like <B>SELECT, UPDATE,</B> and
<B>DELETE</B> requires much more handling.
commands.</A> A complex query, like <CODE>SELECT, UPDATE,</CODE> and
<CODE>DELETE</CODE> requires much more handling.
<P>
The parser takes a complex query, and creates a
<A HREF="../../include/nodes/parsenodes.h">Query</A> structure that
contains all the elements used by complex queries. Query.qual holds the
<B>WHERE</B> clause qualification, which is filled in by
<CODE>WHERE</CODE> clause qualification, which is filled in by
<A HREF="../../backend/parser/parse_clause.c">transformWhereClause().</A>
Each table referenced in the query is represented by a <A
HREF="../../include/nodes/parsenodes.h"> RangeTableEntry,</A> and they
@ -39,19 +39,19 @@ are linked together to form the <I>range table</I> of the query, which is
generated by <A HREF="../../backend/parser/parse_clause.c">
makeRangeTable().</A> Query.rtable holds the queries range table.
<P>
Certain queries, like <B>SELECT,</B> return columns of data. Other
queries, like <B>INSERT</B> and <B>UPDATE,</B> specify the columns
Certain queries, like <CODE>SELECT,</CODE> return columns of data. Other
queries, like <CODE>INSERT</CODE> and <CODE>UPDATE,</CODE> specify the columns
modified by the query. These column references are converted to <A
HREF="../../include/nodes/primnodes.h">Resdom</A> entries, which are
linked together to make up the <I>target list</I> of the query. The
target list is stored in Query.targetList, which is generated by
<A HREF="../../backend/parser/parse_target.c">transformTargetList().</A>
<P>
Other query elements, like aggregates(<B>SUM()</B>), <B>GROUP BY,</B>
<B>ORDER BY</B> are also stored in their own Query fields.
Other query elements, like aggregates(<CODE>SUM()</CODE>), <CODE>GROUP BY,</CODE>
<CODE>ORDER BY</CODE> are also stored in their own Query fields.
<P>
The next step is for the Query to be modified by any <B>VIEWS</B> or
<B>RULES</B> that may apply to the query. This is performed by the <A
The next step is for the Query to be modified by any <CODE>VIEWS</CODE> or
<CODE>RULES</CODE> that may apply to the query. This is performed by the <A
HREF="../../backend/rewrite">rewrite</A> system.
<P>
The <A HREF="../../backend/optimizer">optimizer</A> takes the Query
@ -60,7 +60,7 @@ HREF="../..//include/nodes/plannodes.h">Plan,</A> which contains the
operations to be performed to execute the query. The <A
HREF="../../backend/optimizer/path">path</A> module determines the best
table join order and join type of each table in the RangeTable, using
Query.qual(<B>WHERE</B> clause) to consider optimal index usage.
Query.qual(<CODE>WHERE</CODE> clause) to consider optimal index usage.
<P>
The Plan is then passed to the <A
HREF="../../backend/executor">executor</A> for execution, and the result
@ -81,15 +81,25 @@ data/index buffer cache block
<LI>Shared Buf Lookup Table - lookup of buffer cache block address using
table name and block number(<A HREF="../../include/storage/buf_internals.h">
BufferTag</A>)
<LI><A HREF="../../include/storage/lock.h">LockTable (ctl)</A> - lock table
structure, specifiying table, lock types, and backends holding or
waiting on lock
<LI>LockTable (lock hash) - lookup of LockTable structures using relation,
database object ids
<LI>LockTable (xid hash) - lookup of LockTable structures using
transaction id, LockTable address
<LI>MultiLevelLockTable (ctl) - <A
HREF="../../include/storage/lock.h">LOCKCTL</A> control structure for
each locking method. Currently, only multi-level locking is used.
<LI>MultiLevelLockTable (lock hash) - the <A
HREF="../../include/storage/lock.h">LOCK</A> structure, looked up using
relation, database object ids(<A
HREF="../../include/storage/lock.h">LOCKTAG)</A>. The lock table structure contains the
lock modes(read, write) and circular linked list of backends (<A
HREF="../../include/storage/proc.h">PROC</A> structure pointers) waiting
on the lock.
<LI>MultiLevelLockTable (xid hash) - lookup of LOCK structure address
using transaction id, LOCK address. It is used to quickly check if the
current transaction already has any locks on a table, rather than having
to search through all the held locks. It also stores the modes
(read/write) of the locks held by the current transaction. The returned
<A HREF="../../include/storage/lock.h">XIDLookupEnt</A> structure also
contains a pointer to the backend's PROC.lockQueue.
<LI><A HREF="../../include/storage/proc.h">Proc Header</A> - information
about each backend, including locks held/waiting, indexed by process id
about each backend, including locks held/waiting, indexed by process id
</UL>
Each data structure is created by calling <A
HREF="../../backend/storage/ipc/shmem.c">ShmemInitStruct(),</A> and