-$Header: /cvsroot/pgsql/src/backend/storage/lmgr/README,v 1.1.1.1 1996/07/09 06:21:55 scrappy Exp $
+$Header: /cvsroot/pgsql/src/backend/storage/lmgr/README,v 1.2 1998/01/28 02:29:26 momjian Exp $
This file is an attempt to save me (and future code maintainers) some
time and a lot of headaches. The existing lock manager code at the time
holders, summing the values of activeHolders should total to the value
of nActive.
+---------------------------------------------------------------------------
-This is all I had the stomach for right now..... I will get back to this
-someday. -mer 17 June 1992 12:00 am
+Locks are accessed in two ways. Each PROC structure has a lockQueue,
+that is a circular linked list of LOCK pointers that this process holds
+or is waiting on.
+
+Second, there is a hash table that can do a lookup by combined LOCK
+address and transaction id(xid) which allows a process to see what
+type of locks it holds on that table.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.23 1998/01/27 15:34:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.24 1998/01/28 02:29:27 momjian Exp $
*
* NOTES
* Outside modules can create a lock table and acquire/release
tmpMask = 2;
for (i = 1; i <= nLockTypes; i++, tmpMask <<= 1)
{
- if (lock->activeHolders[i] - myHolders[i])
+ if (lock->activeHolders[i] != myHolders[i])
{
bitmask |= tmpMask;
}
XIDLookupEnt *tmp = NULL;
SHMEM_OFFSET end = MAKE_OFFSET(lockQueue);
LOCK *lock;
- static PROC* checked_procs[MaxBackendId];
- static int nprocs;
+ LOCKTAB *ltable;
+ XIDLookupEnt *result,
+ item;
+ HTAB *xidTable;
+ bool found;
+
+ static PROC* checked_procs[MaxBackendId];
+ static int nprocs;
+ static bool MyNHolding;
+
+ /* initialize at start of recursion */
if (skip_check)
{
- /* initialize at start of recursion */
checked_procs[0] = MyProc;
nprocs = 1;
+
+ ltable = AllTables[1];
+ xidTable = ltable->xidHash;
+
+ MemSet(&item, 0, XID_TAGSIZE);
+ TransactionIdStore(MyProc->xid, &item.tag.xid);
+ item.tag.lock = MAKE_OFFSET(findlock);
+#if 0
+ item.tag.pid = pid;
+#endif
+
+ if ((result = (XIDLookupEnt *)
+ hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) && found)
+ MyNHolding = result->nHolding;
+ else
+ MyNHolding = 0;
}
if (SHMQueueEmpty(lockQueue))
if (lock == findlock && !skip_check)
return true;
- /*
- * No sense in looking at the wait queue of the lock we are
- * looking for as it is MyProc's lock entry.
- * If lock == findlock, and I got here, skip_check must be true.
- */
- if (lock != findlock)
- {
+ {
PROC_QUEUE *waitQueue = &(lock->waitProcs);
PROC *proc;
int i;
proc = (PROC *) MAKE_PTR(waitQueue->links.prev);
for (i = 0; i < waitQueue->size; i++)
{
- for (j = 0; j < nprocs; j++)
- if (checked_procs[j] == proc)
- break;
- if (j >= nprocs)
+ if (proc != MyProc &&
+ lock == findlock && /* skip_check also true */
+ MyNHolding) /* I already hold some lock on it */
+ {
+ /*
+ * For findlock's wait queue, we are interested in
+ * procs who are blocked waiting for a write-lock on the
+ * table we are waiting on, and already hold a lock on it.
+ * We first check to see if there is an escalation
+ * deadlock, where we hold a readlock and want a
+ * writelock, and someone else holds readlock on
+ * the same table, and wants a writelock.
+ *
+ * Basically, the test is, "Do we both hold some lock
+ * on findlock, and we are both waiting in the lock
+ * queue?"
+ */
+
+ Assert(skip_check);
+ Assert(MyProc->prio == 2);
+
+ ltable = AllTables[1];
+ xidTable = ltable->xidHash;
+
+ MemSet(&item, 0, XID_TAGSIZE);
+ TransactionIdStore(proc->xid, &item.tag.xid);
+ item.tag.lock = MAKE_OFFSET(findlock);
+#if 0
+ item.tag.pid = pid;
+#endif
+
+ if ((result = (XIDLookupEnt *)
+ hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) && found)
+ {
+ if (result->nHolding)
+ return true;
+ }
+ }
+ /*
+ * No sense in looking at the wait queue of the lock we are
+ * looking for.
+ * If lock == findlock, and I got here, skip_check must be
+ * true too.
+ */
+ if (lock != findlock)
{
- checked_procs[nprocs++] = proc;
- Assert(nprocs <= MaxBackendId);
- /* If we found a deadlock, we can stop right now */
- if (DeadLockCheck(&(proc->lockQueue), findlock, false))
- return true;
+ for (j = 0; j < nprocs; j++)
+ if (checked_procs[j] == proc)
+ break;
+ if (j >= nprocs && lock != findlock)
+ {
+ checked_procs[nprocs++] = proc;
+ Assert(nprocs <= MaxBackendId);
+ /*
+ * For non-MyProc entries, we are looking only waiters,
+ * not necessarily people who already hold locks and are
+ * waiting.
+ * Now we check for cases where we have two or more
+ * tables in a deadlock. We do this by continuing
+ * to search for someone holding a lock
+ */
+ if (DeadLockCheck(&(proc->lockQueue), findlock, false))
+ return true;
+ }
}
proc = (PROC *) MAKE_PTR(proc->links.prev);
}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pqcomm.h,v 1.21 1998/01/27 15:35:22 momjian Exp $
+ * $Id: pqcomm.h,v 1.22 1998/01/28 02:29:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define UNIXSOCK_PATH(sun,port) \
(sprintf((sun).sun_path, "/tmp/.s.PGSQL.%d", (port)) + \
- + 1 + sizeof ((sun).sun_family))
+ offsetof(struct sockaddr_un, sun_path))
/*
- * + 1 is for BSD-specific sizeof((sun).sun_len)
- * We never actually set sun_len, and I can't think of a
+ * We do this because sun_len is in BSD's struct, while others don't.
+ * We never actually set BSD's sun_len, and I can't think of a
* platform-safe way of doing it, but the code still works. bjm
*/
projects / postgresql.git / commitdiff