开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
lock.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：55k
源码类别：

数据库系统

开发平台：

Unix_Linux

lock.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * lock.c
  4.  *   simple lock acquisition
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.55 1999/05/29 06:14:42 vadim Exp $
  11.  *
  12.  * NOTES
  13.  *   Outside modules can create a lock table and acquire/release
  14.  *   locks.  A lock table is a shared memory hash table.  When
  15.  *   a process tries to acquire a lock of a type that conflictRs
  16.  *   with existing locks, it is put to sleep using the routines
  17.  *   in storage/lmgr/proc.c.
  18.  *
  19.  * Interface:
  20.  *
  21.  * LockAcquire(), LockRelease(), LockMethodTableInit(),
  22.  * LockMethodTableRename(), LockReleaseAll, LockOwners()
  23.  * LockResolveConflicts(), GrantLock()
  24.  *
  25.  * NOTE: This module is used to define new lock tables.  The
  26.  * multi-level lock table (multi.c) used by the heap
  27.  * access methods calls these routines.  See multi.c for
  28.  * examples showing how to use this interface.
  29.  *
  30.  *-------------------------------------------------------------------------
  31.  */
  32. #include <stdio.h> /* for sprintf() */
  33. #include <string.h>
  34. #include <sys/types.h>
  35. #include <unistd.h>
  36. #include <signal.h>
  38. #include "postgres.h"
  39. #include "miscadmin.h"
  40. #include "storage/shmem.h"
  41. #include "storage/sinvaladt.h"
  42. #include "storage/spin.h"
  43. #include "storage/proc.h"
  44. #include "storage/lock.h"
  45. #include "utils/hsearch.h"
  46. #include "utils/memutils.h"
  47. #include "utils/palloc.h"
  48. #include "access/xact.h"
  49. #include "access/transam.h"
  50. #include "utils/trace.h"
  51. #include "utils/ps_status.h"
  53. static int WaitOnLock(LOCKMETHOD lockmethod, LOCK *lock, LOCKMODE lockmode);
  55. /*
  56.  * lockDebugRelation can be used to trace unconditionally a single relation,
  57.  * for example pg_listener, if you suspect there are locking problems.
  58.  *
  59.  * lockDebugOidMin is is used to avoid tracing postgres relations, which
  60.  * would produce a lot of output. Unfortunately most system relations are
  61.  * created after bootstrap and have oid greater than BootstrapObjectIdData.
  62.  * If you are using tprintf you should specify a value greater than the max
  63.  * oid of system relations, which can be found with the following query:
  64.  *
  65.  *  select max(int4in(int4out(oid))) from pg_class where relname ~ '^pg_';
  66.  *
  67.  * To get a useful lock trace you can use the following pg_options:
  68.  *
  69.  *  -T "verbose,query,locks,userlocks,lock_debug_oidmin=17500"
  70.  */
  71. #define LOCKDEBUG(lockmethod) (pg_options[TRACE_SHORTLOCKS+lockmethod])
  72. #define lockDebugRelation (pg_options[TRACE_LOCKRELATION])
  73. #define lockDebugOidMin (pg_options[TRACE_LOCKOIDMIN])
  74. #define lockReadPriority (pg_options[OPT_LOCKREADPRIORITY])
  76. #ifdef LOCK_MGR_DEBUG
  77. #define LOCK_PRINT(where,lock,type) 
  78. if (((LOCKDEBUG(LOCK_LOCKMETHOD(*(lock))) >= 1) 
  79.  && (lock->tag.relId >= lockDebugOidMin)) 
  80. || 
  81. (lockDebugRelation && (lock->tag.relId == lockDebugRelation))) 
  82. LOCK_PRINT_AUX(where,lock,type)
  84. #define LOCK_PRINT_AUX(where,lock,type) 
  85. TPRINTF(TRACE_ALL, 
  86.  "%s: lock(%x) tbl(%d) rel(%u) db(%u) obj(%u) mask(%x) " 
  87.  "hold(%d,%d,%d,%d,%d,%d,%d)=%d " 
  88.  "act(%d,%d,%d,%d,%d,%d,%d)=%d wait(%d) type(%s)", 
  89.  where, 
  90.  MAKE_OFFSET(lock), 
  91.  lock->tag.lockmethod, 
  92.  lock->tag.relId, 
  93.  lock->tag.dbId, 
  94.  lock->tag.objId.blkno, 
  95.  lock->mask, 
  96.  lock->holders[1], 
  97.  lock->holders[2], 
  98.  lock->holders[3], 
  99.  lock->holders[4], 
  100.  lock->holders[5], 
  101.  lock->holders[6], 
  102.  lock->holders[7], 
  103.  lock->nHolding, 
  104.  lock->activeHolders[1], 
  105.  lock->activeHolders[2], 
  106.  lock->activeHolders[3], 
  107.  lock->activeHolders[4], 
  108.  lock->activeHolders[5], 
  109.  lock->activeHolders[6], 
  110.  lock->activeHolders[7], 
  111.  lock->nActive, 
  112.  lock->waitProcs.size, 
  113.  lock_types[type])
  115. #define XID_PRINT(where,xidentP) 
  116. if (((LOCKDEBUG(XIDENT_LOCKMETHOD(*(xidentP))) >= 1) 
  117.  && (((LOCK *)MAKE_PTR(xidentP->tag.lock))->tag.relId 
  118.  >= lockDebugOidMin)) 
  119. || (lockDebugRelation && 
  120. (((LOCK *)MAKE_PTR(xidentP->tag.lock))->tag.relId 
  121.  == lockDebugRelation))) 
  122. XID_PRINT_AUX(where,xidentP)
  124. #define XID_PRINT_AUX(where,xidentP) 
  125. TPRINTF(TRACE_ALL, 
  126.  "%s: xid(%x) lock(%x) tbl(%d) pid(%d) xid(%u) " 
  127.  "hold(%d,%d,%d,%d,%d,%d,%d)=%d", 
  128.  where, 
  129.  MAKE_OFFSET(xidentP), 
  130.  xidentP->tag.lock, 
  131.  XIDENT_LOCKMETHOD(*(xidentP)), 
  132.  xidentP->tag.pid, 
  133.  xidentP->tag.xid, 
  134.  xidentP->holders[1], 
  135.  xidentP->holders[2], 
  136.  xidentP->holders[3], 
  137.  xidentP->holders[4], 
  138.  xidentP->holders[5], 
  139.  xidentP->holders[6], 
  140.  xidentP->holders[7], 
  141.  xidentP->nHolding)
  143. #else /* !LOCK_MGR_DEBUG */
  144. #define LOCK_PRINT(where,lock,type)
  145. #define LOCK_PRINT_AUX(where,lock,type)
  146. #define XID_PRINT(where,xidentP)
  147. #define XID_PRINT_AUX(where,xidentP)
  148. #endif  /* !LOCK_MGR_DEBUG */
  150. static char *lock_types[] = {
  151. "INVALID",
  152. "AccessShareLock",
  153. "RowShareLock",
  154. "RowExclusiveLock",
  155. "ShareLock",
  156. "ShareRowExclusiveLock",
  157. "ExclusiveLock",
  158. "AccessExclusiveLock"
  159. };
  161. SPINLOCK LockMgrLock; /* in Shmem or created in
  162.  * CreateSpinlocks() */
  164. /* This is to simplify/speed up some bit arithmetic */
  166. static MASK BITS_OFF[MAX_LOCKMODES];
  167. static MASK BITS_ON[MAX_LOCKMODES];
  169. /* -----------------
  170.  * XXX Want to move this to this file
  171.  * -----------------
  172.  */
  173. static bool LockingIsDisabled;
  175. /* -------------------
  176.  * map from lockmethod to the lock table structure
  177.  * -------------------
  178.  */
  179. static LOCKMETHODTABLE *LockMethodTable[MAX_LOCK_METHODS];
  181. static int NumLockMethods;
  183. /* -------------------
  184.  * InitLocks -- Init the lock module.  Create a private data
  185.  * structure for constructing conflict masks.
  186.  * -------------------
  187.  */
  188. void
  189. InitLocks()
  190. {
  191. int i;
  192. int bit;
  194. bit = 1;
  195. /* -------------------
  196.  * remember 0th lockmode is invalid
  197.  * -------------------
  198.  */
  199. for (i = 0; i < MAX_LOCKMODES; i++, bit <<= 1)
  200. {
  201. BITS_ON[i] = bit;
  202. BITS_OFF[i] = ~bit;
  203. }
  205. #ifdef LOCK_MGR_DEBUG
  207. /*
  208.  * If lockDebugOidMin value has not been specified in pg_options set a
  209.  * default value.
  210.  */
  211. if (!lockDebugOidMin)
  212. lockDebugOidMin = BootstrapObjectIdData;
  213. #endif
  214. }
  216. /* -------------------
  217.  * LockDisable -- sets LockingIsDisabled flag to TRUE or FALSE.
  218.  * ------------------
  219.  */
  220. void
  221. LockDisable(int status)
  222. {
  223. LockingIsDisabled = status;
  224. }
  227. /*
  228.  * LockMethodInit -- initialize the lock table's lock type
  229.  * structures
  230.  *
  231.  * Notes: just copying.  Should only be called once.
  232.  */
  233. static void
  234. LockMethodInit(LOCKMETHODTABLE *lockMethodTable,
  235.    MASK *conflictsP,
  236.    int *prioP,
  237.    int numModes)
  238. {
  239. int i;
  241. lockMethodTable->ctl->numLockModes = numModes;
  242. numModes++;
  243. for (i = 0; i < numModes; i++, prioP++, conflictsP++)
  244. {
  245. lockMethodTable->ctl->conflictTab[i] = *conflictsP;
  246. lockMethodTable->ctl->prio[i] = *prioP;
  247. }
  248. }
  250. /*
  251.  * LockMethodTableInit -- initialize a lock table structure
  252.  *
  253.  * Notes:
  254.  * (a) a lock table has four separate entries in the shmem index
  255.  * table. This is because every shared hash table and spinlock
  256.  * has its name stored in the shmem index at its creation.  It
  257.  * is wasteful, in this case, but not much space is involved.
  258.  *
  259.  */
  260. LOCKMETHOD
  261. LockMethodTableInit(char *tabName,
  262. MASK *conflictsP,
  263. int *prioP,
  264. int numModes)
  265. {
  266. LOCKMETHODTABLE *lockMethodTable;
  267. char    *shmemName;
  268. HASHCTL info;
  269. int hash_flags;
  270. bool found;
  271. int status = TRUE;
  273. if (numModes > MAX_LOCKMODES)
  274. {
  275. elog(NOTICE, "LockMethodTableInit: too many lock types %d greater than %d",
  276.  numModes, MAX_LOCKMODES);
  277. return INVALID_LOCKMETHOD;
  278. }
  280. /* allocate a string for the shmem index table lookup */
  281. shmemName = (char *) palloc((unsigned) (strlen(tabName) + 32));
  282. if (!shmemName)
  283. {
  284. elog(NOTICE, "LockMethodTableInit: couldn't malloc string %s n", tabName);
  285. return INVALID_LOCKMETHOD;
  286. }
  288. /* each lock table has a non-shared header */
  289. lockMethodTable = (LOCKMETHODTABLE *) palloc((unsigned) sizeof(LOCKMETHODTABLE));
  290. if (!lockMethodTable)
  291. {
  292. elog(NOTICE, "LockMethodTableInit: couldn't malloc lock table %sn", tabName);
  293. pfree(shmemName);
  294. return INVALID_LOCKMETHOD;
  295. }
  297. /* ------------------------
  298.  * find/acquire the spinlock for the table
  299.  * ------------------------
  300.  */
  301. SpinAcquire(LockMgrLock);
  304. /* -----------------------
  305.  * allocate a control structure from shared memory or attach to it
  306.  * if it already exists.
  307.  * -----------------------
  308.  */
  309. sprintf(shmemName, "%s (ctl)", tabName);
  310. lockMethodTable->ctl = (LOCKMETHODCTL *)
  311. ShmemInitStruct(shmemName, (unsigned) sizeof(LOCKMETHODCTL), &found);
  313. if (!lockMethodTable->ctl)
  314. {
  315. elog(FATAL, "LockMethodTableInit: couldn't initialize %s", tabName);
  316. status = FALSE;
  317. }
  319. /* -------------------
  320.  * no zero-th table
  321.  * -------------------
  322.  */
  323. NumLockMethods = 1;
  325. /* ----------------
  326.  * we're first - initialize
  327.  * ----------------
  328.  */
  329. if (!found)
  330. {
  331. MemSet(lockMethodTable->ctl, 0, sizeof(LOCKMETHODCTL));
  332. lockMethodTable->ctl->masterLock = LockMgrLock;
  333. lockMethodTable->ctl->lockmethod = NumLockMethods;
  334. }
  336. /* --------------------
  337.  * other modules refer to the lock table by a lockmethod
  338.  * --------------------
  339.  */
  340. LockMethodTable[NumLockMethods] = lockMethodTable;
  341. NumLockMethods++;
  342. Assert(NumLockMethods <= MAX_LOCK_METHODS);
  344. /* ----------------------
  345.  * allocate a hash table for the lock tags.  This is used
  346.  * to find the different locks.
  347.  * ----------------------
  348.  */
  349. info.keysize = SHMEM_LOCKTAB_KEYSIZE;
  350. info.datasize = SHMEM_LOCKTAB_DATASIZE;
  351. info.hash = tag_hash;
  352. hash_flags = (HASH_ELEM | HASH_FUNCTION);
  354. sprintf(shmemName, "%s (lock hash)", tabName);
  355. lockMethodTable->lockHash = (HTAB *) ShmemInitHash(shmemName,
  356.  INIT_TABLE_SIZE, MAX_TABLE_SIZE,
  357.    &info, hash_flags);
  359. Assert(lockMethodTable->lockHash->hash == tag_hash);
  360. if (!lockMethodTable->lockHash)
  361. {
  362. elog(FATAL, "LockMethodTableInit: couldn't initialize %s", tabName);
  363. status = FALSE;
  364. }
  366. /* -------------------------
  367.  * allocate an xid table.  When different transactions hold
  368.  * the same lock, additional information must be saved (locks per tx).
  369.  * -------------------------
  370.  */
  371. info.keysize = SHMEM_XIDTAB_KEYSIZE;
  372. info.datasize = SHMEM_XIDTAB_DATASIZE;
  373. info.hash = tag_hash;
  374. hash_flags = (HASH_ELEM | HASH_FUNCTION);
  376. sprintf(shmemName, "%s (xid hash)", tabName);
  377. lockMethodTable->xidHash = (HTAB *) ShmemInitHash(shmemName,
  378.  INIT_TABLE_SIZE, MAX_TABLE_SIZE,
  379.   &info, hash_flags);
  381. if (!lockMethodTable->xidHash)
  382. {
  383. elog(FATAL, "LockMethodTableInit: couldn't initialize %s", tabName);
  384. status = FALSE;
  385. }
  387. /* init ctl data structures */
  388. LockMethodInit(lockMethodTable, conflictsP, prioP, numModes);
  390. SpinRelease(LockMgrLock);
  392. pfree(shmemName);
  394. if (status)
  395. return lockMethodTable->ctl->lockmethod;
  396. else
  397. return INVALID_LOCKMETHOD;
  398. }
  400. /*
  401.  * LockMethodTableRename -- allocate another lockmethod to the same
  402.  * lock table.
  403.  *
  404.  * NOTES: Both the lock module and the lock chain (lchain.c)
  405.  * module use table id's to distinguish between different
  406.  * kinds of locks.  Short term and long term locks look
  407.  * the same to the lock table, but are handled differently
  408.  * by the lock chain manager. This function allows the
  409.  * client to use different lockmethods when acquiring/releasing
  410.  * short term and long term locks.
  411.  */
  413. LOCKMETHOD
  414. LockMethodTableRename(LOCKMETHOD lockmethod)
  415. {
  416. LOCKMETHOD newLockMethod;
  418. if (NumLockMethods >= MAX_LOCK_METHODS)
  419. return INVALID_LOCKMETHOD;
  420. if (LockMethodTable[lockmethod] == INVALID_LOCKMETHOD)
  421. return INVALID_LOCKMETHOD;
  423. /* other modules refer to the lock table by a lockmethod */
  424. newLockMethod = NumLockMethods;
  425. NumLockMethods++;
  427. LockMethodTable[newLockMethod] = LockMethodTable[lockmethod];
  428. return newLockMethod;
  429. }
  431. /*
  432.  * LockAcquire -- Check for lock conflicts, sleep if conflict found,
  433.  * set lock if/when no conflicts.
  434.  *
  435.  * Returns: TRUE if parameters are correct, FALSE otherwise.
  436.  *
  437.  * Side Effects: The lock is always acquired.  No way to abort
  438.  * a lock acquisition other than aborting the transaction.
  439.  * Lock is recorded in the lkchain.
  440.  *
  441. #ifdef USER_LOCKS
  442.  *
  443.  * Note on User Locks:
  444.  *
  445.  * User locks are handled totally on the application side as
  446.  * long term cooperative locks which extend beyond the normal
  447.  * transaction boundaries.  Their purpose is to indicate to an
  448.  * application that someone is `working' on an item.  So it is
  449.  * possible to put an user lock on a tuple's oid, retrieve the
  450.  * tuple, work on it for an hour and then update it and remove
  451.  * the lock.  While the lock is active other clients can still
  452.  * read and write the tuple but they can be aware that it has
  453.  * been locked at the application level by someone.
  454.  * User locks use lock tags made of an uint16 and an uint32, for
  455.  * example 0 and a tuple oid, or any other arbitrary pair of
  456.  * numbers following a convention established by the application.
  457.  * In this sense tags don't refer to tuples or database entities.
  458.  * User locks and normal locks are completely orthogonal and
  459.  * they don't interfere with each other, so it is possible
  460.  * to acquire a normal lock on an user-locked tuple or user-lock
  461.  * a tuple for which a normal write lock already exists.
  462.  * User locks are always non blocking, therefore they are never
  463.  * acquired if already held by another process.  They must be
  464.  * released explicitly by the application but they are released
  465.  * automatically when a backend terminates.
  466.  * They are indicated by a lockmethod 2 which is an alias for the
  467.  * normal lock table, and are distinguished from normal locks
  468.  * for the following differences:
  469.  *
  470.  * normal lock user lock
  471.  *
  472.  * lockmethod 1 2
  473.  * tag.relId rel oid 0
  474.  * tag.ItemPointerData.ip_blkid block id lock id2
  475.  * tag.ItemPointerData.ip_posid tuple offset lock id1
  476.  * xid.pid 0 backend pid
  477.  * xid.xid xid or 0 0
  478.  * persistence transaction user or backend
  479.  *
  480.  * The lockmode parameter can have the same values for normal locks
  481.  * although probably only WRITE_LOCK can have some practical use.
  482.  *
  483.  * DZ - 22 Nov 1997
  484. #endif
  485.  */
  487. bool
  488. LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag, LOCKMODE lockmode)
  489. {
  490. XIDLookupEnt *result,
  491. item;
  492. HTAB    *xidTable;
  493. bool found;
  494. LOCK    *lock = NULL;
  495. SPINLOCK masterLock;
  496. LOCKMETHODTABLE *lockMethodTable;
  497. int status;
  498. TransactionId xid;
  500. #ifdef USER_LOCKS
  501. int is_user_lock;
  503. is_user_lock = (lockmethod == USER_LOCKMETHOD);
  504. if (is_user_lock)
  505. {
  506. #ifdef USER_LOCKS_DEBUG
  507. TPRINTF(TRACE_USERLOCKS, "LockAcquire: user lock [%u] %s",
  508. locktag->objId.blkno,
  509. lock_types[lockmode]);
  510. #endif
  511. }
  512. #endif
  514. /* ???????? This must be changed when short term locks will be used */
  515. locktag->lockmethod = lockmethod;
  517. Assert(lockmethod < NumLockMethods);
  518. lockMethodTable = LockMethodTable[lockmethod];
  519. if (!lockMethodTable)
  520. {
  521. elog(NOTICE, "LockAcquire: bad lock table %d", lockmethod);
  522. return FALSE;
  523. }
  525. if (LockingIsDisabled)
  526. return TRUE;
  528. masterLock = lockMethodTable->ctl->masterLock;
  530. SpinAcquire(masterLock);
  532. /*
  533.  * Find or create a lock with this tag
  534.  */
  535. Assert(lockMethodTable->lockHash->hash == tag_hash);
  536. lock = (LOCK *) hash_search(lockMethodTable->lockHash, (Pointer) locktag,
  537. HASH_ENTER, &found);
  538. if (!lock)
  539. {
  540. SpinRelease(masterLock);
  541. elog(FATAL, "LockAcquire: lock table %d is corrupted", lockmethod);
  542. return FALSE;
  543. }
  545. /* --------------------
  546.  * if there was nothing else there, complete initialization
  547.  * --------------------
  548.  */
  549. if (!found)
  550. {
  551. lock->mask = 0;
  552. lock->nHolding = 0;
  553. lock->nActive = 0;
  554. MemSet((char *) lock->holders, 0, sizeof(int) * MAX_LOCKMODES);
  555. MemSet((char *) lock->activeHolders, 0, sizeof(int) * MAX_LOCKMODES);
  556. ProcQueueInit(&(lock->waitProcs));
  557. Assert(lock->tag.objId.blkno == locktag->objId.blkno);
  558. LOCK_PRINT("LockAcquire: new", lock, lockmode);
  559. }
  560. else
  561. {
  562. LOCK_PRINT("LockAcquire: found", lock, lockmode);
  563. Assert((lock->nHolding > 0) && (lock->holders[lockmode] >= 0));
  564. Assert((lock->nActive > 0) && (lock->activeHolders[lockmode] >= 0));
  565. Assert(lock->nActive <= lock->nHolding);
  566. }
  568. /* ------------------
  569.  * add an element to the lock queue so that we can clear the
  570.  * locks at end of transaction.
  571.  * ------------------
  572.  */
  573. xidTable = lockMethodTable->xidHash;
  575. /* ------------------
  576.  * Zero out all of the tag bytes (this clears the padding bytes for long
  577.  * word alignment and ensures hashing consistency).
  578.  * ------------------
  579.  */
  580. MemSet(&item, 0, XID_TAGSIZE); /* must clear padding, needed */
  581. item.tag.lock = MAKE_OFFSET(lock);
  582. #ifdef USE_XIDTAG_LOCKMETHOD
  583. item.tag.lockmethod = lockmethod;
  584. #endif
  585. #ifdef USER_LOCKS
  586. if (is_user_lock)
  587. {
  588. item.tag.pid = MyProcPid;
  589. item.tag.xid = xid = 0;
  590. }
  591. else
  592. {
  593. xid = GetCurrentTransactionId();
  594. TransactionIdStore(xid, &item.tag.xid);
  595. }
  596. #else
  597. xid = GetCurrentTransactionId();
  598. TransactionIdStore(xid, &item.tag.xid);
  599. #endif
  601. /*
  602.  * Find or create an xid entry with this tag
  603.  */
  604. result = (XIDLookupEnt *) hash_search(xidTable, (Pointer) &item,
  605.   HASH_ENTER, &found);
  606. if (!result)
  607. {
  608. elog(NOTICE, "LockAcquire: xid table corrupted");
  609. return STATUS_ERROR;
  610. }
  612. /*
  613.  * If not found initialize the new entry
  614.  */
  615. if (!found)
  616. {
  617. result->nHolding = 0;
  618. MemSet((char *) result->holders, 0, sizeof(int) * MAX_LOCKMODES);
  619. ProcAddLock(&result->queue);
  620. XID_PRINT("LockAcquire: new", result);
  621. }
  622. else
  623. {
  624. XID_PRINT("LockAcquire: found", result);
  625. Assert((result->nHolding > 0) && (result->holders[lockmode] >= 0));
  626. Assert(result->nHolding <= lock->nActive);
  627. }
  629. /* ----------------
  630.  * lock->nholding tells us how many processes have _tried_ to
  631.  * acquire this lock,  Regardless of whether they succeeded or
  632.  * failed in doing so.
  633.  * ----------------
  634.  */
  635. lock->nHolding++;
  636. lock->holders[lockmode]++;
  637. Assert((lock->nHolding > 0) && (lock->holders[lockmode] > 0));
  639. /* --------------------
  640.  * If I'm the only one holding a lock, then there
  641.  * cannot be a conflict. The same is true if we already
  642.  * hold this lock.
  643.  * --------------------
  644.  */
  645. if (result->nHolding == lock->nActive || result->holders[lockmode] != 0)
  646. {
  647. result->holders[lockmode]++;
  648. result->nHolding++;
  649. XID_PRINT("LockAcquire: owning", result);
  650. Assert((result->nHolding > 0) && (result->holders[lockmode] > 0));
  651. GrantLock(lock, lockmode);
  652. SpinRelease(masterLock);
  653. return TRUE;
  654. }
  656. /*
  657.  * If lock requested conflicts with locks requested by waiters...
  658.  */
  659. if (lockMethodTable->ctl->conflictTab[lockmode] & lock->waitMask)
  660. {
  661. int i = 1;
  663. /*
  664.  * If I don't hold locks or my locks don't conflict with waiters
  665.  * then force to sleep.
  666.  */
  667. if (result->nHolding > 0)
  668. {
  669. for (; i <= lockMethodTable->ctl->numLockModes; i++)
  670. {
  671. if (result->holders[i] > 0 &&
  672. lockMethodTable->ctl->conflictTab[i] & lock->waitMask)
  673. break; /* conflict */
  674. }
  675. }
  677. if (result->nHolding == 0 || i > lockMethodTable->ctl->numLockModes)
  678. {
  679. XID_PRINT("LockAcquire: higher priority proc waiting",
  680.   result);
  681. status = STATUS_FOUND;
  682. }
  683. else
  684. status = LockResolveConflicts(lockmethod, lock, lockmode, xid, result);
  685. }
  686. else
  687. status = LockResolveConflicts(lockmethod, lock, lockmode, xid, result);
  689. if (status == STATUS_OK)
  690. GrantLock(lock, lockmode);
  691. else if (status == STATUS_FOUND)
  692. {
  693. #ifdef USER_LOCKS
  695. /*
  696.  * User locks are non blocking. If we can't acquire a lock we must
  697.  * remove the xid entry and return FALSE without waiting.
  698.  */
  699. if (is_user_lock)
  700. {
  701. if (!result->nHolding)
  702. {
  703. SHMQueueDelete(&result->queue);
  704. result = (XIDLookupEnt *) hash_search(xidTable,
  705.   (Pointer) result,
  706. HASH_REMOVE, &found);
  707. if (!result || !found)
  708. elog(NOTICE, "LockAcquire: remove xid, table corrupted");
  709. }
  710. else
  711. XID_PRINT_AUX("LockAcquire: NHOLDING", result);
  712. lock->nHolding--;
  713. lock->holders[lockmode]--;
  714. LOCK_PRINT("LockAcquire: user lock failed", lock, lockmode);
  715. Assert((lock->nHolding > 0) && (lock->holders[lockmode] >= 0));
  716. Assert(lock->nActive <= lock->nHolding);
  717. SpinRelease(masterLock);
  718. return FALSE;
  719. }
  720. #endif
  722. /*
  723.  * Construct bitmask of locks we hold before going to sleep.
  724.  */
  725. MyProc->holdLock = 0;
  726. if (result->nHolding > 0)
  727. {
  728. int i,
  729. tmpMask = 2;
  731. for (i = 1; i <= lockMethodTable->ctl->numLockModes;
  732.  i++, tmpMask <<= 1)
  733. {
  734. if (result->holders[i] > 0)
  735. MyProc->holdLock |= tmpMask;
  736. }
  737. Assert(MyProc->holdLock != 0);
  738. }
  740. status = WaitOnLock(lockmethod, lock, lockmode);
  742. /*
  743.  * Check the xid entry status, in case something in the ipc
  744.  * communication doesn't work correctly.
  745.  */
  746. if (!((result->nHolding > 0) && (result->holders[lockmode] > 0)))
  747. {
  748. XID_PRINT_AUX("LockAcquire: INCONSISTENT ", result);
  749. LOCK_PRINT_AUX("LockAcquire: INCONSISTENT ", lock, lockmode);
  750. /* Should we retry ? */
  751. return FALSE;
  752. }
  753. XID_PRINT("LockAcquire: granted", result);
  754. LOCK_PRINT("LockAcquire: granted", lock, lockmode);
  755. }
  757. SpinRelease(masterLock);
  759. return status == STATUS_OK;
  760. }
  762. /* ----------------------------
  763.  * LockResolveConflicts -- test for lock conflicts
  764.  *
  765.  * NOTES:
  766.  * Here's what makes this complicated: one transaction's
  767.  * locks don't conflict with one another.  When many processes
  768.  * hold locks, each has to subtract off the other's locks when
  769.  * determining whether or not any new lock acquired conflicts with
  770.  * the old ones.
  771.  *
  772.  * ----------------------------
  773.  */
  774. int
  775. LockResolveConflicts(LOCKMETHOD lockmethod,
  776.  LOCK *lock,
  777.  LOCKMODE lockmode,
  778.  TransactionId xid,
  779.  XIDLookupEnt *xidentP) /* xident ptr or NULL */
  780. {
  781. XIDLookupEnt *result,
  782. item;
  783. int    *myHolders;
  784. int numLockModes;
  785. HTAB    *xidTable;
  786. bool found;
  787. int bitmask;
  788. int i,
  789. tmpMask;
  791. #ifdef USER_LOCKS
  792. int is_user_lock;
  794. #endif
  796. numLockModes = LockMethodTable[lockmethod]->ctl->numLockModes;
  797. xidTable = LockMethodTable[lockmethod]->xidHash;
  799. if (xidentP)
  800. {
  802. /*
  803.  * A pointer to the xid entry was supplied from the caller.
  804.  * Actually only LockAcquire can do it.
  805.  */
  806. result = xidentP;
  807. }
  808. else
  809. {
  810. /* ---------------------
  811.  * read my own statistics from the xid table.  If there
  812.  * isn't an entry, then we'll just add one.
  813.  *
  814.  * Zero out the tag, this clears the padding bytes for long
  815.  * word alignment and ensures hashing consistency.
  816.  * ------------------
  817.  */
  818. MemSet(&item, 0, XID_TAGSIZE);
  819. item.tag.lock = MAKE_OFFSET(lock);
  820. #ifdef USE_XIDTAG_LOCKMETHOD
  821. item.tag.lockmethod = lockmethod;
  822. #endif
  823. #ifdef USER_LOCKS
  824. is_user_lock = (lockmethod == 2);
  825. if (is_user_lock)
  826. {
  827. item.tag.pid = MyProcPid;
  828. item.tag.xid = 0;
  829. }
  830. else
  831. TransactionIdStore(xid, &item.tag.xid);
  832. #else
  833. TransactionIdStore(xid, &item.tag.xid);
  834. #endif
  836. /*
  837.  * Find or create an xid entry with this tag
  838.  */
  839. result = (XIDLookupEnt *) hash_search(xidTable, (Pointer) &item,
  840.   HASH_ENTER, &found);
  841. if (!result)
  842. {
  843. elog(NOTICE, "LockResolveConflicts: xid table corrupted");
  844. return STATUS_ERROR;
  845. }
  847. /*
  848.  * If not found initialize the new entry. THIS SHOULD NEVER
  849.  * HAPPEN, if we are trying to resolve a conflict we must already
  850.  * have allocated an xid entry for this lock.  dz 21-11-1997
  851.  */
  852. if (!found)
  853. {
  854. /* ---------------
  855.  * we're not holding any type of lock yet.  Clear
  856.  * the lock stats.
  857.  * ---------------
  858.  */
  859. MemSet(result->holders, 0, numLockModes * sizeof(*(lock->holders)));
  860. result->nHolding = 0;
  861. XID_PRINT_AUX("LockResolveConflicts: NOT FOUND", result);
  862. }
  863. else
  864. XID_PRINT("LockResolveConflicts: found", result);
  865. }
  866. Assert((result->nHolding >= 0) && (result->holders[lockmode] >= 0));
  868. /* ----------------------------
  869.  * first check for global conflicts: If no locks conflict
  870.  * with mine, then I get the lock.
  871.  *
  872.  * Checking for conflict: lock->mask represents the types of
  873.  * currently held locks.  conflictTable[lockmode] has a bit
  874.  * set for each type of lock that conflicts with mine. Bitwise
  875.  * compare tells if there is a conflict.
  876.  * ----------------------------
  877.  */
  878. if (!(LockMethodTable[lockmethod]->ctl->conflictTab[lockmode] & lock->mask))
  879. {
  880. result->holders[lockmode]++;
  881. result->nHolding++;
  882. XID_PRINT("LockResolveConflicts: no conflict", result);
  883. Assert((result->nHolding > 0) && (result->holders[lockmode] > 0));
  884. return STATUS_OK;
  885. }
  887. /* ------------------------
  888.  * Rats.  Something conflicts. But it could still be my own
  889.  * lock.  We have to construct a conflict mask
  890.  * that does not reflect our own locks.
  891.  * ------------------------
  892.  */
  893. myHolders = result->holders;
  894. bitmask = 0;
  895. tmpMask = 2;
  896. for (i = 1; i <= numLockModes; i++, tmpMask <<= 1)
  897. {
  898. if (lock->activeHolders[i] != myHolders[i])
  899. bitmask |= tmpMask;
  900. }
  902. /* ------------------------
  903.  * now check again for conflicts.  'bitmask' describes the types
  904.  * of locks held by other processes.  If one of these
  905.  * conflicts with the kind of lock that I want, there is a
  906.  * conflict and I have to sleep.
  907.  * ------------------------
  908.  */
  909. if (!(LockMethodTable[lockmethod]->ctl->conflictTab[lockmode] & bitmask))
  910. {
  911. /* no conflict. Get the lock and go on */
  912. result->holders[lockmode]++;
  913. result->nHolding++;
  914. XID_PRINT("LockResolveConflicts: resolved", result);
  915. Assert((result->nHolding > 0) && (result->holders[lockmode] > 0));
  916. return STATUS_OK;
  917. }
  919. XID_PRINT("LockResolveConflicts: conflicting", result);
  920. return STATUS_FOUND;
  921. }
  923. /*
  924.  * GrantLock -- update the lock data structure to show
  925.  * the new lock holder.
  926.  */
  927. void
  928. GrantLock(LOCK *lock, LOCKMODE lockmode)
  929. {
  930. lock->nActive++;
  931. lock->activeHolders[lockmode]++;
  932. lock->mask |= BITS_ON[lockmode];
  933. LOCK_PRINT("GrantLock", lock, lockmode);
  934. Assert((lock->nActive > 0) && (lock->activeHolders[lockmode] > 0));
  935. Assert(lock->nActive <= lock->nHolding);
  936. }
  938. static int
  939. WaitOnLock(LOCKMETHOD lockmethod, LOCK *lock, LOCKMODE lockmode)
  940. {
  941. PROC_QUEUE *waitQueue = &(lock->waitProcs);
  942. LOCKMETHODTABLE *lockMethodTable = LockMethodTable[lockmethod];
  943. char old_status[64],
  944. new_status[64];
  946. Assert(lockmethod < NumLockMethods);
  948. /*
  949.  * the waitqueue is ordered by priority. I insert myself according to
  950.  * the priority of the lock I am acquiring.
  951.  *
  952.  * SYNC NOTE: I am assuming that the lock table spinlock is sufficient
  953.  * synchronization for this queue. That will not be true if/when
  954.  * people can be deleted from the queue by a SIGINT or something.
  955.  */
  956. LOCK_PRINT_AUX("WaitOnLock: sleeping on lock", lock, lockmode);
  957. strcpy(old_status, PS_STATUS);
  958. strcpy(new_status, PS_STATUS);
  959. strcat(new_status, " waiting");
  960. PS_SET_STATUS(new_status);
  961. if (ProcSleep(waitQueue,
  962.   lockMethodTable->ctl,
  963.   lockmode,
  964.   lock) != NO_ERROR)
  965. {
  966. /* -------------------
  967.  * This could have happend as a result of a deadlock,
  968.  * see HandleDeadLock().
  969.  * Decrement the lock nHolding and holders fields as
  970.  * we are no longer waiting on this lock.
  971.  * -------------------
  972.  */
  973. lock->nHolding--;
  974. lock->holders[lockmode]--;
  975. LOCK_PRINT_AUX("WaitOnLock: aborting on lock", lock, lockmode);
  976. Assert((lock->nHolding >= 0) && (lock->holders[lockmode] >= 0));
  977. Assert(lock->nActive <= lock->nHolding);
  978. if (lock->activeHolders[lockmode] == lock->holders[lockmode])
  979. lock->waitMask &= BITS_OFF[lockmode];
  980. SpinRelease(lockMethodTable->ctl->masterLock);
  981. elog(ERROR, "WaitOnLock: error on wakeup - Aborting this transaction");
  983. /* not reached */
  984. }
  986. if (lock->activeHolders[lockmode] == lock->holders[lockmode])
  987. lock->waitMask &= BITS_OFF[lockmode];
  988. PS_SET_STATUS(old_status);
  989. LOCK_PRINT_AUX("WaitOnLock: wakeup on lock", lock, lockmode);
  990. return STATUS_OK;
  991. }
  993. /*
  994.  * LockRelease -- look up 'locktag' in lock table 'lockmethod' and
  995.  * release it.
  996.  *
  997.  * Side Effects: if the lock no longer conflicts with the highest
  998.  * priority waiting process, that process is granted the lock
  999.  * and awoken. (We have to grant the lock here to avoid a
  1000.  * race between the waking process and any new process to
  1001.  * come along and request the lock).
  1002.  */
  1003. bool
  1004. LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag, LOCKMODE lockmode)
  1005. {
  1006. LOCK    *lock = NULL;
  1007. SPINLOCK masterLock;
  1008. bool found;
  1009. LOCKMETHODTABLE *lockMethodTable;
  1010. XIDLookupEnt *result,
  1011. item;
  1012. HTAB    *xidTable;
  1013. TransactionId xid;
  1014. bool wakeupNeeded = true;
  1015. int trace_flag;
  1017. #ifdef USER_LOCKS
  1018. int is_user_lock;
  1020. is_user_lock = (lockmethod == USER_LOCKMETHOD);
  1021. if (is_user_lock)
  1022. {
  1023. TPRINTF(TRACE_USERLOCKS, "LockRelease: user lock tag [%u] %d",
  1024. locktag->objId.blkno,
  1025. lockmode);
  1026. }
  1027. #endif
  1029. /* ???????? This must be changed when short term locks will be used */
  1030. locktag->lockmethod = lockmethod;
  1032. #ifdef USER_LOCKS
  1033. trace_flag = 
  1034. (lockmethod == USER_LOCKMETHOD) ? TRACE_USERLOCKS : TRACE_LOCKS;
  1035. #else
  1036. trace_flag = TRACE_LOCKS;
  1037. #endif
  1039. Assert(lockmethod < NumLockMethods);
  1040. lockMethodTable = LockMethodTable[lockmethod];
  1041. if (!lockMethodTable)
  1042. {
  1043. elog(NOTICE, "lockMethodTable is null in LockRelease");
  1044. return FALSE;
  1045. }
  1047. if (LockingIsDisabled)
  1048. return TRUE;
  1050. masterLock = lockMethodTable->ctl->masterLock;
  1051. SpinAcquire(masterLock);
  1053. /*
  1054.  * Find a lock with this tag
  1055.  */
  1056. Assert(lockMethodTable->lockHash->hash == tag_hash);
  1057. lock = (LOCK *) hash_search(lockMethodTable->lockHash, (Pointer) locktag,
  1058. HASH_FIND, &found);
  1060. /*
  1061.  * let the caller print its own error message, too. Do not
  1062.  * elog(ERROR).
  1063.  */
  1064. if (!lock)
  1065. {
  1066. SpinRelease(masterLock);
  1067. elog(NOTICE, "LockRelease: locktable corrupted");
  1068. return FALSE;
  1069. }
  1071. if (!found)
  1072. {
  1073. SpinRelease(masterLock);
  1074. #ifdef USER_LOCKS
  1075. if (is_user_lock)
  1076. {
  1077. TPRINTF(TRACE_USERLOCKS, "LockRelease: no lock with this tag");
  1078. return FALSE;
  1079. }
  1080. #endif
  1081. elog(NOTICE, "LockRelease: locktable lookup failed, no lock");
  1082. return FALSE;
  1083. }
  1084. LOCK_PRINT("LockRelease: found", lock, lockmode);
  1085. Assert((lock->nHolding > 0) && (lock->holders[lockmode] >= 0));
  1086. Assert((lock->nActive > 0) && (lock->activeHolders[lockmode] >= 0));
  1087. Assert(lock->nActive <= lock->nHolding);
  1090. /* ------------------
  1091.  * Zero out all of the tag bytes (this clears the padding bytes for long
  1092.  * word alignment and ensures hashing consistency).
  1093.  * ------------------
  1094.  */
  1095. MemSet(&item, 0, XID_TAGSIZE);
  1096. item.tag.lock = MAKE_OFFSET(lock);
  1097. #ifdef USE_XIDTAG_LOCKMETHOD
  1098. item.tag.lockmethod = lockmethod;
  1099. #endif
  1100. #ifdef USER_LOCKS
  1101. if (is_user_lock)
  1102. {
  1103. item.tag.pid = MyProcPid;
  1104. item.tag.xid = xid = 0;
  1105. }
  1106. else
  1107. {
  1108. xid = GetCurrentTransactionId();
  1109. TransactionIdStore(xid, &item.tag.xid);
  1110. }
  1111. #else
  1112. xid = GetCurrentTransactionId();
  1113. TransactionIdStore(xid, &item.tag.xid);
  1114. #endif
  1116. /*
  1117.  * Find an xid entry with this tag
  1118.  */
  1119. xidTable = lockMethodTable->xidHash;
  1120. result = (XIDLookupEnt *) hash_search(xidTable, (Pointer) &item,
  1121.   HASH_FIND_SAVE, &found);
  1122. if (!result || !found)
  1123. {
  1124. SpinRelease(masterLock);
  1125. #ifdef USER_LOCKS
  1126. if (!found && is_user_lock)
  1127. TPRINTF(TRACE_USERLOCKS, "LockRelease: no lock with this tag");
  1128. else
  1129. #endif
  1130. elog(NOTICE, "LockReplace: xid table corrupted");
  1131. return FALSE;
  1132. }
  1133. XID_PRINT("LockRelease: found", result);
  1134. Assert(result->tag.lock == MAKE_OFFSET(lock));
  1136. /*
  1137.  * Check that we are actually holding a lock of the type we want to
  1138.  * release.
  1139.  */
  1140. if (!(result->holders[lockmode] > 0))
  1141. {
  1142. SpinRelease(masterLock);
  1143. XID_PRINT_AUX("LockAcquire: WRONGTYPE", result);
  1144. elog(NOTICE, "LockRelease: you don't own a lock of type %s",
  1145.  lock_types[lockmode]);
  1146. Assert(result->holders[lockmode] >= 0);
  1147. return FALSE;
  1148. }
  1149. Assert(result->nHolding > 0);
  1151. /*
  1152.  * fix the general lock stats
  1153.  */
  1154. lock->nHolding--;
  1155. lock->holders[lockmode]--;
  1156. lock->nActive--;
  1157. lock->activeHolders[lockmode]--;
  1159. #ifdef NOT_USED
  1160. /* --------------------------
  1161.  * If there are still active locks of the type I just released, no one
  1162.  * should be woken up. Whoever is asleep will still conflict
  1163.  * with the remaining locks.
  1164.  * --------------------------
  1165.  */
  1166. if (lock->activeHolders[lockmode])
  1167. wakeupNeeded = false;
  1168. else
  1169. #endif
  1171. /*
  1172.  * Above is not valid any more (due to MVCC lock modes). Actually
  1173.  * we should compare activeHolders[lockmode] with number of
  1174.  * waiters holding lock of this type and try to wakeup only if
  1175.  * these numbers are equal (and lock released conflicts with locks
  1176.  * requested by waiters). For the moment we only check the last
  1177.  * condition.
  1178.  */
  1179. if (lockMethodTable->ctl->conflictTab[lockmode] & lock->waitMask)
  1180. wakeupNeeded = true;
  1182. if (!(lock->activeHolders[lockmode]))
  1183. {
  1184. /* change the conflict mask.  No more of this lock type. */
  1185. lock->mask &= BITS_OFF[lockmode];
  1186. }
  1188. LOCK_PRINT("LockRelease: updated", lock, lockmode);
  1189. Assert((lock->nHolding >= 0) && (lock->holders[lockmode] >= 0));
  1190. Assert((lock->nActive >= 0) && (lock->activeHolders[lockmode] >= 0));
  1191. Assert(lock->nActive <= lock->nHolding);
  1193. if (!lock->nHolding)
  1194. {
  1195. /* ------------------
  1196.  * if there's no one waiting in the queue,
  1197.  * we just released the last lock.
  1198.  * Delete it from the lock table.
  1199.  * ------------------
  1200.  */
  1201. Assert(lockMethodTable->lockHash->hash == tag_hash);
  1202. lock = (LOCK *) hash_search(lockMethodTable->lockHash,
  1203. (Pointer) &(lock->tag),
  1204. HASH_REMOVE,
  1205. &found);
  1206. Assert(lock && found);
  1207. wakeupNeeded = false;
  1208. }
  1210. /*
  1211.  * now check to see if I have any private locks.  If I do, decrement
  1212.  * the counts associated with them.
  1213.  */
  1214. result->holders[lockmode]--;
  1215. result->nHolding--;
  1216. XID_PRINT("LockRelease: updated", result);
  1217. Assert((result->nHolding >= 0) && (result->holders[lockmode] >= 0));
  1219. /*
  1220.  * If this was my last hold on this lock, delete my entry in the XID
  1221.  * table.
  1222.  */
  1223. if (!result->nHolding)
  1224. {
  1225. if (result->queue.prev == INVALID_OFFSET)
  1226. elog(NOTICE, "LockRelease: xid.prev == INVALID_OFFSET");
  1227. if (result->queue.next == INVALID_OFFSET)
  1228. elog(NOTICE, "LockRelease: xid.next == INVALID_OFFSET");
  1229. if (result->queue.next != INVALID_OFFSET)
  1230. SHMQueueDelete(&result->queue);
  1231. XID_PRINT("LockRelease: deleting", result);
  1232. result = (XIDLookupEnt *) hash_search(xidTable, (Pointer) &result,
  1233.   HASH_REMOVE_SAVED, &found);
  1234. if (!result || !found)
  1235. {
  1236. SpinRelease(masterLock);
  1237. elog(NOTICE, "LockRelease: remove xid, table corrupted");
  1238. return FALSE;
  1239. }
  1240. }
  1242. if (wakeupNeeded)
  1243. ProcLockWakeup(&(lock->waitProcs), lockmethod, lock);
  1244. else
  1245. {
  1246. if (((LOCKDEBUG(LOCK_LOCKMETHOD(*(lock))) >= 1) 
  1247.  &&(lock->tag.relId >= lockDebugOidMin)) 
  1248. ||
  1249. (lockDebugRelation && (lock->tag.relId == lockDebugRelation)))
  1250. TPRINTF(TRACE_ALL, "LockRelease: no wakeup needed");
  1251. }
  1253. SpinRelease(masterLock);
  1254. return TRUE;
  1255. }
  1257. /*
  1258.  * LockReleaseAll -- Release all locks in a process lock queue.
  1259.  */
  1260. bool
  1261. LockReleaseAll(LOCKMETHOD lockmethod, SHM_QUEUE *lockQueue)
  1262. {
  1263. PROC_QUEUE *waitQueue;
  1264. int done;
  1265. XIDLookupEnt *xidLook = NULL;
  1266. XIDLookupEnt *tmp = NULL;
  1267. XIDLookupEnt *result;
  1268. SHMEM_OFFSET end = MAKE_OFFSET(lockQueue);
  1269. SPINLOCK masterLock;
  1270. LOCKMETHODTABLE *lockMethodTable;
  1271. int i,
  1272. numLockModes;
  1273. LOCK    *lock;
  1274. bool found;
  1275. int trace_flag;
  1276. int xidtag_lockmethod;
  1278. #ifdef USER_LOCKS
  1279. int is_user_lock_table,
  1280. count,
  1281. nleft;
  1283. count = nleft = 0;
  1285. is_user_lock_table = (lockmethod == USER_LOCKMETHOD);
  1286. trace_flag = (lockmethod == 2) ? TRACE_USERLOCKS : TRACE_LOCKS;
  1287. #else
  1288. trace_flag = TRACE_LOCKS;
  1289. #endif
  1290. TPRINTF(trace_flag, "LockReleaseAll: lockmethod=%d, pid=%d",
  1291. lockmethod, MyProcPid);
  1293. Assert(lockmethod < NumLockMethods);
  1294. lockMethodTable = LockMethodTable[lockmethod];
  1295. if (!lockMethodTable)
  1296. {
  1297. elog(NOTICE, "LockAcquire: bad lockmethod %d", lockmethod);
  1298. return FALSE;
  1299. }
  1301. if (SHMQueueEmpty(lockQueue))
  1302. return TRUE;
  1304. numLockModes = lockMethodTable->ctl->numLockModes;
  1305. masterLock = lockMethodTable->ctl->masterLock;
  1307. SpinAcquire(masterLock);
  1308. SHMQueueFirst(lockQueue, (Pointer *) &xidLook, &xidLook->queue);
  1310. for (;;)
  1311. {
  1312. bool wakeupNeeded = false;
  1314. /*
  1315.  * Sometimes the queue appears to be messed up.
  1316.  */
  1317. if (count++ > 1000)
  1318. {
  1319. elog(NOTICE, "LockReleaseAll: xid loop detected, giving up");
  1320. nleft = 0;
  1321. break;
  1322. }
  1324. /* ---------------------------
  1325.  * XXX Here we assume the shared memory queue is circular and
  1326.  * that we know its internal structure.  Should have some sort of
  1327.  * macros to allow one to walk it. mer 20 July 1991
  1328.  * ---------------------------
  1329.  */
  1330. done = (xidLook->queue.next == end);
  1331. lock = (LOCK *) MAKE_PTR(xidLook->tag.lock);
  1333. xidtag_lockmethod = XIDENT_LOCKMETHOD(*xidLook);
  1334. if ((xidtag_lockmethod == lockmethod) && pg_options[trace_flag])
  1335. {
  1336. XID_PRINT("LockReleaseAll", xidLook);
  1337. LOCK_PRINT("LockReleaseAll", lock, 0);
  1338. }
  1340. #ifdef USE_XIDTAG_LOCKMETHOD
  1341. if (xidtag_lockmethod != LOCK_LOCKMETHOD(*lock))
  1342. elog(NOTICE, "LockReleaseAll: xid/lock method mismatch: %d != %d",
  1343.  xidtag_lockmethod, lock->tag.lockmethod);
  1344. #endif
  1345. if ((xidtag_lockmethod != lockmethod) && (trace_flag >= 2))
  1346. {
  1347. TPRINTF(trace_flag, "LockReleaseAll: skipping other table");
  1348. nleft++;
  1349. goto next_item;
  1350. }
  1352. Assert(lock->nHolding > 0);
  1353. Assert(lock->nActive > 0);
  1354. Assert(lock->nActive <= lock->nHolding);
  1355. Assert(xidLook->nHolding >= 0);
  1356. Assert(xidLook->nHolding <= lock->nHolding);
  1358. #ifdef USER_LOCKS
  1359. if (is_user_lock_table)
  1360. {
  1361. if ((xidLook->tag.pid == 0) || (xidLook->tag.xid != 0))
  1362. {
  1363. TPRINTF(TRACE_USERLOCKS,
  1364. "LockReleaseAll: skiping normal lock [%d,%d,%d]",
  1365.   xidLook->tag.lock, xidLook->tag.pid, xidLook->tag.xid);
  1366. nleft++;
  1367. goto next_item;
  1368. }
  1369. if (xidLook->tag.pid != MyProcPid)
  1370. {
  1371. /* Should never happen */
  1372. elog(NOTICE,
  1373.  "LockReleaseAll: INVALID PID: [%u] [%d,%d,%d]",
  1374.  lock->tag.objId.blkno,
  1375.   xidLook->tag.lock, xidLook->tag.pid, xidLook->tag.xid);
  1376. nleft++;
  1377. goto next_item;
  1378. }
  1379. TPRINTF(TRACE_USERLOCKS,
  1380. "LockReleaseAll: releasing user lock [%u] [%d,%d,%d]",
  1381. lock->tag.objId.blkno,
  1382.   xidLook->tag.lock, xidLook->tag.pid, xidLook->tag.xid);
  1383. }
  1384. else
  1385. {
  1387. /*
  1388.  * Can't check xidLook->tag.xid, can be 0 also for normal
  1389.  * locks
  1390.  */
  1391. if (xidLook->tag.pid != 0)
  1392. {
  1393. TPRINTF(TRACE_LOCKS,
  1394.  "LockReleaseAll: skiping user lock [%u] [%d,%d,%d]",
  1395. lock->tag.objId.blkno,
  1396.   xidLook->tag.lock, xidLook->tag.pid, xidLook->tag.xid);
  1397. nleft++;
  1398. goto next_item;
  1399. }
  1400. }
  1401. #endif
  1403. /* ------------------
  1404.  * fix the general lock stats
  1405.  * ------------------
  1406.  */
  1407. if (lock->nHolding != xidLook->nHolding)
  1408. {
  1409. for (i = 1; i <= numLockModes; i++)
  1410. {
  1411. Assert(xidLook->holders[i] >= 0);
  1412. lock->holders[i] -= xidLook->holders[i];
  1413. lock->activeHolders[i] -= xidLook->holders[i];
  1414. Assert((lock->holders[i] >= 0) 
  1415.    &&(lock->activeHolders[i] >= 0));
  1416. if (!lock->activeHolders[i])
  1417. lock->mask &= BITS_OFF[i];
  1419. /*
  1420.  * Read comments in LockRelease
  1421.  */
  1422. if (!wakeupNeeded && xidLook->holders[i] > 0 &&
  1423. lockMethodTable->ctl->conflictTab[i] & lock->waitMask)
  1424. wakeupNeeded = true;
  1425. }
  1426. lock->nHolding -= xidLook->nHolding;
  1427. lock->nActive -= xidLook->nHolding;
  1428. Assert((lock->nHolding >= 0) && (lock->nActive >= 0));
  1429. Assert(lock->nActive <= lock->nHolding);
  1430. }
  1431. else
  1432. {
  1433. /* --------------
  1434.  * set nHolding to zero so that we can garbage collect the lock
  1435.  * down below...
  1436.  * --------------
  1437.  */
  1438. lock->nHolding = 0;
  1439. /* Fix the lock status, just for next LOCK_PRINT message. */
  1440. for (i = 1; i <= numLockModes; i++)
  1441. {
  1442. Assert(lock->holders[i] == lock->activeHolders[i]);
  1443. lock->holders[i] = lock->activeHolders[i] = 0;
  1444. }
  1445. }
  1446. LOCK_PRINT("LockReleaseAll: updated", lock, 0);
  1448. /*
  1449.  * Remove the xid from the process lock queue
  1450.  */
  1451. SHMQueueDelete(&xidLook->queue);
  1453. /* ----------------
  1454.  * always remove the xidLookup entry, we're done with it now
  1455.  * ----------------
  1456.  */
  1458. XID_PRINT("LockReleaseAll: deleting", xidLook);
  1459. result = (XIDLookupEnt *) hash_search(lockMethodTable->xidHash,
  1460.   (Pointer) xidLook,
  1461.   HASH_REMOVE,
  1462.   &found);
  1463. if (!result || !found)
  1464. {
  1465. SpinRelease(masterLock);
  1466. elog(NOTICE, "LockReleaseAll: xid table corrupted");
  1467. return FALSE;
  1468. }
  1470. if (!lock->nHolding)
  1471. {
  1472. /* --------------------
  1473.  * if there's no one waiting in the queue, we've just released
  1474.  * the last lock.
  1475.  * --------------------
  1476.  */
  1477. LOCK_PRINT("LockReleaseAll: deleting", lock, 0);
  1478. Assert(lockMethodTable->lockHash->hash == tag_hash);
  1479. lock = (LOCK *) hash_search(lockMethodTable->lockHash,
  1480. (Pointer) &(lock->tag),
  1481. HASH_REMOVE, &found);
  1482. if ((!lock) || (!found))
  1483. {
  1484. SpinRelease(masterLock);
  1485. elog(NOTICE, "LockReleaseAll: cannot remove lock from HTAB");
  1486. return FALSE;
  1487. }
  1488. }
  1489. else if (wakeupNeeded)
  1490. {
  1491. waitQueue = &(lock->waitProcs);
  1492. ProcLockWakeup(waitQueue, lockmethod, lock);
  1493. }
  1495. #ifdef USER_LOCKS
  1496. next_item:
  1497. #endif
  1498. if (done)
  1499. break;
  1500. SHMQueueFirst(&xidLook->queue, (Pointer *) &tmp, &tmp->queue);
  1501. xidLook = tmp;
  1502. }
  1504. /*
  1505.  * Reinitialize the queue only if nothing has been left in.
  1506.  */
  1507. if (nleft == 0)
  1508. {
  1509. TPRINTF(trace_flag, "LockReleaseAll: reinitializing lockQueue");
  1510. SHMQueueInit(lockQueue);
  1511. }
  1513. SpinRelease(masterLock);
  1514. TPRINTF(trace_flag, "LockReleaseAll: done");
  1516. return TRUE;
  1517. }
  1519. int
  1520. LockShmemSize(int maxBackends)
  1521. {
  1522. int size = 0;
  1524. size += MAXALIGN(sizeof(PROC_HDR)); /* ProcGlobal */
  1525. size += MAXALIGN(maxBackends * sizeof(PROC)); /* each MyProc */
  1526. size += MAXALIGN(maxBackends * sizeof(LOCKMETHODCTL)); /* each
  1527.  * lockMethodTable->ctl */
  1529. /* lockHash table */
  1530. size += hash_estimate_size(NLOCKENTS(maxBackends),
  1531.    SHMEM_LOCKTAB_KEYSIZE,
  1532.    SHMEM_LOCKTAB_DATASIZE);
  1534. /* xidHash table */
  1535. size += hash_estimate_size(NLOCKENTS(maxBackends),
  1536.    SHMEM_XIDTAB_KEYSIZE,
  1537.    SHMEM_XIDTAB_DATASIZE);
  1539. /*
  1540.  * Since the lockHash entry count above is only an estimate, add 10%
  1541.  * safety margin.
  1542.  */
  1543. size += size / 10;
  1545. return size;
  1546. }
  1548. /* -----------------
  1549.  * Boolean function to determine current locking status
  1550.  * -----------------
  1551.  */
  1552. bool
  1553. LockingDisabled()
  1554. {
  1555. return LockingIsDisabled;
  1556. }
  1558. /*
  1559.  * DeadlockCheck -- Checks for deadlocks for a given process
  1560.  *
  1561.  * We can't block on user locks, so no sense testing for deadlock
  1562.  * because there is no blocking, and no timer for the block.
  1563.  *
  1564.  * This code takes a list of locks a process holds, and the lock that
  1565.  * the process is sleeping on, and tries to find if any of the processes
  1566.  * waiting on its locks hold the lock it is waiting for.  If no deadlock
  1567.  * is found, it goes on to look at all the processes waiting on their locks.
  1568.  *
  1569.  * We have already locked the master lock before being called.
  1570.  */
  1571. bool
  1572. DeadLockCheck(void *proc, LOCK *findlock)
  1573. {
  1574. XIDLookupEnt *xidLook = NULL;
  1575. XIDLookupEnt *tmp = NULL;
  1576. PROC    *thisProc = (PROC *) proc,
  1577.    *waitProc;
  1578. SHM_QUEUE  *lockQueue = &(thisProc->lockQueue);
  1579. SHMEM_OFFSET end = MAKE_OFFSET(lockQueue);
  1580. LOCK    *lock;
  1581. PROC_QUEUE *waitQueue;
  1582. int i,
  1583. j;
  1584. bool first_run = (thisProc == MyProc),
  1585. done;
  1587. static PROC *checked_procs[MAXBACKENDS];
  1588. static int nprocs;
  1590. /* initialize at start of recursion */
  1591. if (first_run)
  1592. {
  1593. checked_procs[0] = MyProc;
  1594. nprocs = 1;
  1595. }
  1597. if (SHMQueueEmpty(lockQueue))
  1598. return false;
  1600. SHMQueueFirst(lockQueue, (Pointer *) &xidLook, &xidLook->queue);
  1602. XID_PRINT("DeadLockCheck", xidLook);
  1604. for (;;)
  1605. {
  1606. done = (xidLook->queue.next == end);
  1607. lock = (LOCK *) MAKE_PTR(xidLook->tag.lock);
  1609. LOCK_PRINT("DeadLockCheck", lock, 0);
  1611. if (lock->tag.relId == 0) /* user' lock */
  1612. goto nxtl;
  1614. /*
  1615.  * waitLock is always in lockQueue of waiting proc, if !first_run
  1616.  * then upper caller will handle waitProcs queue of waitLock.
  1617.  */
  1618. if (thisProc->waitLock == lock && !first_run)
  1619. goto nxtl;
  1621. /*
  1622.  * If we found proc holding findlock and sleeping on some my other
  1623.  * lock then we have to check does it block me or another waiters.
  1624.  */
  1625. if (lock == findlock && !first_run)
  1626. {
  1627. LOCKMETHODCTL *lockctl =
  1628. LockMethodTable[DEFAULT_LOCKMETHOD]->ctl;
  1629. int lm;
  1631. Assert(xidLook->nHolding > 0);
  1632. for (lm = 1; lm <= lockctl->numLockModes; lm++)
  1633. {
  1634. if (xidLook->holders[lm] > 0 &&
  1635. lockctl->conflictTab[lm] & findlock->waitMask)
  1636. return true;
  1637. }
  1639. /*
  1640.  * Else - get the next lock from thisProc's lockQueue
  1641.  */
  1642. goto nxtl;
  1643. }
  1645. waitQueue = &(lock->waitProcs);
  1646. waitProc = (PROC *) MAKE_PTR(waitQueue->links.prev);
  1648. for (i = 0; i < waitQueue->size; i++)
  1649. {
  1650. if (waitProc == thisProc)
  1651. {
  1652. Assert(waitProc->waitLock == lock);
  1653. Assert(waitProc == MyProc);
  1654. waitProc = (PROC *) MAKE_PTR(waitProc->links.prev);
  1655. continue;
  1656. }
  1657. if (lock == findlock) /* first_run also true */
  1658. {
  1659. LOCKMETHODCTL *lockctl =
  1660. LockMethodTable[DEFAULT_LOCKMETHOD]->ctl;
  1662. /*
  1663.  * If me blocked by his holdlock...
  1664.  */
  1665. if (lockctl->conflictTab[MyProc->token] & waitProc->holdLock)
  1666. {
  1667. /* and he blocked by me -> deadlock */
  1668. if (lockctl->conflictTab[waitProc->token] & MyProc->holdLock)
  1669. return true;
  1670. /* we shouldn't look at lockQueue of our blockers */
  1671. waitProc = (PROC *) MAKE_PTR(waitProc->links.prev);
  1672. continue;
  1673. }
  1675. /*
  1676.  * If he isn't blocked by me and we request
  1677.  * non-conflicting lock modes - no deadlock here because
  1678.  * of he isn't blocked by me in any sence (explicitle or
  1679.  * implicitly). Note that we don't do like test if
  1680.  * !first_run (when thisProc is holder and non-waiter on
  1681.  * lock) and so we call DeadLockCheck below for every
  1682.  * waitProc in thisProc->lockQueue, even for waitProc-s
  1683.  * un-blocked by thisProc. Should we? This could save us
  1684.  * some time...
  1685.  */
  1686. if (!(lockctl->conflictTab[waitProc->token] & MyProc->holdLock) &&
  1687. !(lockctl->conflictTab[waitProc->token] & (1 << MyProc->token)))
  1688. {
  1689. waitProc = (PROC *) MAKE_PTR(waitProc->links.prev);
  1690. continue;
  1691. }
  1692. }
  1694. /*
  1695.  * Look in lockQueue of this waitProc, if didn't do this
  1696.  * before.
  1697.  */
  1698. for (j = 0; j < nprocs; j++)
  1699. {
  1700. if (checked_procs[j] == waitProc)
  1701. break;
  1702. }
  1703. if (j >= nprocs)
  1704. {
  1705. Assert(nprocs < MAXBACKENDS);
  1706. checked_procs[nprocs++] = waitProc;
  1708. if (DeadLockCheck(waitProc, findlock))
  1709. {
  1710. LOCKMETHODCTL *lockctl =
  1711. LockMethodTable[DEFAULT_LOCKMETHOD]->ctl;
  1712. int holdLock;
  1714. /*
  1715.  * Ok, but is waitProc waiting for me (thisProc) ?
  1716.  */
  1717. if (thisProc->waitLock == lock)
  1718. {
  1719. Assert(first_run);
  1720. holdLock = thisProc->holdLock;
  1721. }
  1722. else
  1723. /* should we cache holdLock ? */
  1724. {
  1725. int lm,
  1726. tmpMask = 2;
  1728. Assert(xidLook->nHolding > 0);
  1729. for (holdLock = 0, lm = 1;
  1730.  lm <= lockctl->numLockModes;
  1731.  lm++, tmpMask <<= 1)
  1732. {
  1733. if (xidLook->holders[lm] > 0)
  1734. holdLock |= tmpMask;
  1735. }
  1736. Assert(holdLock != 0);
  1737. }
  1738. if (lockctl->conflictTab[waitProc->token] & holdLock)
  1739. {
  1741. /*
  1742.  * Last attempt to avoid deadlock - try to wakeup
  1743.  * myself.
  1744.  */
  1745. if (first_run)
  1746. {
  1747. if (LockResolveConflicts(DEFAULT_LOCKMETHOD,
  1748.  MyProc->waitLock,
  1749.  MyProc->token,
  1750.  MyProc->xid,
  1751.  NULL) == STATUS_OK)
  1752. {
  1753. GrantLock(MyProc->waitLock, MyProc->token);
  1754. (MyProc->waitLock->waitProcs.size)--;
  1755. ProcWakeup(MyProc, NO_ERROR);
  1756. return false;
  1757. }
  1758. }
  1759. return true;
  1760. }
  1762. /*
  1763.  * Hell! Is he blocked by any (other) holder ?
  1764.  */
  1765. if (LockResolveConflicts(DEFAULT_LOCKMETHOD,
  1766.  lock,
  1767.  waitProc->token,
  1768.  waitProc->xid,
  1769.  NULL) != STATUS_OK)
  1770. {
  1772. /*
  1773.  * Blocked by others - no deadlock...
  1774.  */
  1775. #ifdef DEADLOCK_DEBUG
  1776. LOCK_PRINT("DeadLockCheck: blocked by others",
  1777.    lock, waitProc->token);
  1778. #endif
  1779. waitProc = (PROC *) MAKE_PTR(waitProc->links.prev);
  1780. continue;
  1781. }
  1783. /*
  1784.  * Well - wakeup this guy! This is the case of
  1785.  * implicit blocking: thisProc blocked someone who
  1786.  * blocked waitProc by the fact that he/someone is
  1787.  * already waiting for lock.  We do this for
  1788.  * anti-starving.
  1789.  */
  1790. GrantLock(lock, waitProc->token);
  1791. waitQueue->size--;
  1792. waitProc = ProcWakeup(waitProc, NO_ERROR);
  1793. continue;
  1794. }
  1795. }
  1796. waitProc = (PROC *) MAKE_PTR(waitProc->links.prev);
  1797. }
  1799. nxtl: ;
  1800. if (done)
  1801. break;
  1802. SHMQueueFirst(&xidLook->queue, (Pointer *) &tmp, &tmp->queue);
  1803. xidLook = tmp;
  1804. }
  1806. /* if we got here, no deadlock */
  1807. return false;
  1808. }
  1810. #ifdef NOT_USED
  1811. /*
  1812.  * Return an array with the pids of all processes owning a lock.
  1813.  * This works only for user locks because normal locks have no
  1814.  * pid information in the corresponding XIDLookupEnt.
  1815.  */
  1816. ArrayType  *
  1817. LockOwners(LOCKMETHOD lockmethod, LOCKTAG *locktag)
  1818. {
  1819. XIDLookupEnt *xidLook = NULL;
  1820. SPINLOCK masterLock;
  1821. LOCK    *lock;
  1822. SHMEM_OFFSET lock_offset;
  1823. int count = 0;
  1824. LOCKMETHODTABLE *lockMethodTable;
  1825. HTAB    *xidTable;
  1826. bool found;
  1827. int ndims,
  1828. nitems,
  1829. hdrlen,
  1830. size;
  1831. int lbounds[1],
  1832. hbounds[1];
  1833. ArrayType  *array;
  1834. int    *data_ptr;
  1836. /* Assume that no one will modify the result */
  1837. static int empty_array[] = {20, 1, 0, 0, 0};
  1839. #ifdef USER_LOCKS
  1840. int is_user_lock;
  1842. is_user_lock = (lockmethod == USER_LOCKMETHOD);
  1843. if (is_user_lock)
  1844. {
  1845. TPRINTF(TRACE_USERLOCKS, "LockOwners: user lock tag [%u]",
  1846. locktag->objId.blkno);
  1847. }
  1848. #endif
  1850. /* This must be changed when short term locks will be used */
  1851. locktag->lockmethod = lockmethod;
  1853. Assert((lockmethod >= MIN_LOCKMETHOD) && (lockmethod < NumLockMethods));
  1854. lockMethodTable = LockMethodTable[lockmethod];
  1855. if (!lockMethodTable)
  1856. {
  1857. elog(NOTICE, "lockMethodTable is null in LockOwners");
  1858. return (ArrayType *) &empty_array;
  1859. }
  1861. if (LockingIsDisabled)
  1862. return (ArrayType *) &empty_array;
  1864. masterLock = lockMethodTable->ctl->masterLock;
  1865. SpinAcquire(masterLock);
  1867. /*
  1868.  * Find a lock with this tag
  1869.  */
  1870. Assert(lockMethodTable->lockHash->hash == tag_hash);
  1871. lock = (LOCK *) hash_search(lockMethodTable->lockHash, (Pointer) locktag,
  1872. HASH_FIND, &found);
  1874. /*
  1875.  * let the caller print its own error message, too. Do not elog(WARN).
  1876.  */
  1877. if (!lock)
  1878. {
  1879. SpinRelease(masterLock);
  1880. elog(NOTICE, "LockOwners: locktable corrupted");
  1881. return (ArrayType *) &empty_array;
  1882. }
  1884. if (!found)
  1885. {
  1886. SpinRelease(masterLock);
  1887. #ifdef USER_LOCKS
  1888. if (is_user_lock)
  1889. {
  1890. TPRINTF(TRACE_USERLOCKS, "LockOwners: no lock with this tag");
  1891. return (ArrayType *) &empty_array;
  1892. }
  1893. #endif
  1894. elog(NOTICE, "LockOwners: locktable lookup failed, no lock");
  1895. return (ArrayType *) &empty_array;
  1896. }
  1897. LOCK_PRINT("LockOwners: found", lock, 0);
  1898. Assert((lock->nHolding > 0) && (lock->nActive > 0));
  1899. Assert(lock->nActive <= lock->nHolding);
  1900. lock_offset = MAKE_OFFSET(lock);
  1902. /* Construct a 1-dimensional array */
  1903. ndims = 1;
  1904. hdrlen = ARR_OVERHEAD(ndims);
  1905. lbounds[0] = 0;
  1906. hbounds[0] = lock->nActive;
  1907. size = hdrlen + sizeof(int) * hbounds[0];
  1908. array = (ArrayType *) palloc(size);
  1909. MemSet(array, 0, size);
  1910. memmove((char *) array, (char *) &size, sizeof(int));
  1911. memmove((char *) ARR_NDIM_PTR(array), (char *) &ndims, sizeof(int));
  1912. memmove((char *) ARR_DIMS(array), (char *) hbounds, ndims * sizeof(int));
  1913. memmove((char *) ARR_LBOUND(array), (char *) lbounds, ndims * sizeof(int));
  1914. SET_LO_FLAG(false, array);
  1915. data_ptr = (int *) ARR_DATA_PTR(array);
  1917. xidTable = lockMethodTable->xidHash;
  1918. hash_seq(NULL);
  1919. nitems = 0;
  1920. while ((xidLook = (XIDLookupEnt *) hash_seq(xidTable)) &&
  1921.    (xidLook != (XIDLookupEnt *) TRUE))
  1922. {
  1923. if (count++ > 1000)
  1924. {
  1925. elog(NOTICE, "LockOwners: possible loop, giving up");
  1926. break;
  1927. }
  1929. if (xidLook->tag.pid == 0)
  1930. {
  1931. XID_PRINT("LockOwners: no pid", xidLook);
  1932. continue;
  1933. }
  1935. if (!xidLook->tag.lock)
  1936. {
  1937. XID_PRINT("LockOwners: NULL LOCK", xidLook);
  1938. continue;
  1939. }
  1941. if (xidLook->tag.lock != lock_offset)
  1942. {
  1943. XID_PRINT("LockOwners: different lock", xidLook);
  1944. continue;
  1945. }
  1947. if (LOCK_LOCKMETHOD(*lock) != lockmethod)
  1948. {
  1949. XID_PRINT("LockOwners: other table", xidLook);
  1950. continue;
  1951. }
  1953. if (xidLook->nHolding <= 0)
  1954. {
  1955. XID_PRINT("LockOwners: not holding", xidLook);
  1956. continue;
  1957. }
  1959. if (nitems >= hbounds[0])
  1960. {
  1961. elog(NOTICE, "LockOwners: array size exceeded");
  1962. break;
  1963. }
  1965. /*
  1966.  * Check that the holding process is still alive by sending him an
  1967.  * unused (ignored) signal. If the kill fails the process is not
  1968.  * alive.
  1969.  */
  1970. if ((xidLook->tag.pid != MyProcPid) 
  1971. &&(kill(xidLook->tag.pid, SIGCHLD)) != 0)
  1972. {
  1973. /* Return a negative pid to signal that process is dead */
  1974. data_ptr[nitems++] = -(xidLook->tag.pid);
  1975. XID_PRINT("LockOwners: not alive", xidLook);
  1976. /* XXX - TODO: remove this entry and update lock stats */
  1977. continue;
  1978. }
  1980. /* Found a process holding the lock */
  1981. XID_PRINT("LockOwners: holding", xidLook);
  1982. data_ptr[nitems++] = xidLook->tag.pid;
  1983. }
  1985. SpinRelease(masterLock);
  1987. /* Adjust the actual size of the array */
  1988. hbounds[0] = nitems;
  1989. size = hdrlen + sizeof(int) * hbounds[0];
  1990. memmove((char *) array, (char *) &size, sizeof(int));
  1991. memmove((char *) ARR_DIMS(array), (char *) hbounds, ndims * sizeof(int));
  1993. return array;
  1994. }
  1996. #endif
  1998. #ifdef DEADLOCK_DEBUG
  1999. /*
  2000.  * Dump all locks in the proc->lockQueue. Must have already acquired
  2001.  * the masterLock.
  2002.  */
  2003. void
  2004. DumpLocks()
  2005. {
  2006. SHMEM_OFFSET location;
  2007. PROC    *proc;
  2008. SHM_QUEUE  *lockQueue;
  2009. int done;
  2010. XIDLookupEnt *xidLook = NULL;
  2011. XIDLookupEnt *tmp = NULL;
  2012. SHMEM_OFFSET end;
  2013. SPINLOCK masterLock;
  2014. int numLockModes;
  2015. LOCK    *lock;
  2016. int count = 0;
  2017. int lockmethod = DEFAULT_LOCKMETHOD;
  2018. LOCKMETHODTABLE *lockMethodTable;
  2020. ShmemPIDLookup(MyProcPid, &location);
  2021. if (location == INVALID_OFFSET)
  2022. return;
  2023. proc = (PROC *) MAKE_PTR(location);
  2024. if (proc != MyProc)
  2025. return;
  2026. lockQueue = &proc->lockQueue;
  2028. Assert(lockmethod < NumLockMethods);
  2029. lockMethodTable = LockMethodTable[lockmethod];
  2030. if (!lockMethodTable)
  2031. return;
  2033. numLockModes = lockMethodTable->ctl->numLockModes;
  2034. masterLock = lockMethodTable->ctl->masterLock;
  2036. if (SHMQueueEmpty(lockQueue))
  2037. return;
  2039. SHMQueueFirst(lockQueue, (Pointer *) &xidLook, &xidLook->queue);
  2040. end = MAKE_OFFSET(lockQueue);
  2042. if (MyProc->waitLock)
  2043. LOCK_PRINT_AUX("DumpLocks: waiting on", MyProc->waitLock, 0);
  2045. for (;;)
  2046. {
  2047. if (count++ > 2000)
  2048. {
  2049. elog(NOTICE, "DumpLocks: xid loop detected, giving up");
  2050. break;
  2051. }
  2053. /* ---------------------------
  2054.  * XXX Here we assume the shared memory queue is circular and
  2055.  * that we know its internal structure.  Should have some sort of
  2056.  * macros to allow one to walk it. mer 20 July 1991
  2057.  * ---------------------------
  2058.  */
  2059. done = (xidLook->queue.next == end);
  2060. lock = (LOCK *) MAKE_PTR(xidLook->tag.lock);
  2062. XID_PRINT_AUX("DumpLocks", xidLook);
  2063. LOCK_PRINT_AUX("DumpLocks", lock, 0);
  2065. if (done)
  2066. break;
  2068. SHMQueueFirst(&xidLook->queue, (Pointer *) &tmp, &tmp->queue);
  2069. xidLook = tmp;
  2070. }
  2071. }
  2073. /*
  2074.  * Dump all postgres locks. Must have already acquired the masterLock.
  2075.  */
  2076. void
  2077. DumpAllLocks()
  2078. {
  2079. SHMEM_OFFSET location;
  2080. PROC    *proc;
  2081. XIDLookupEnt *xidLook = NULL;
  2082. LOCK    *lock;
  2083. int pid;
  2084. int count = 0;
  2085. int lockmethod = DEFAULT_LOCKMETHOD;
  2086. LOCKMETHODTABLE *lockMethodTable;
  2087. HTAB    *xidTable;
  2089. pid = getpid();
  2090. ShmemPIDLookup(pid, &location);
  2091. if (location == INVALID_OFFSET)
  2092. return;
  2093. proc = (PROC *) MAKE_PTR(location);
  2094. if (proc != MyProc)
  2095. return;
  2097. Assert(lockmethod < NumLockMethods);
  2098. lockMethodTable = LockMethodTable[lockmethod];
  2099. if (!lockMethodTable)
  2100. return;
  2102. xidTable = lockMethodTable->xidHash;
  2104. if (MyProc->waitLock)
  2105. LOCK_PRINT_AUX("DumpAllLocks: waiting on", MyProc->waitLock, 0);
  2107. hash_seq(NULL);
  2108. while ((xidLook = (XIDLookupEnt *) hash_seq(xidTable)) &&
  2109.    (xidLook != (XIDLookupEnt *) TRUE))
  2110. {
  2111. XID_PRINT_AUX("DumpAllLocks", xidLook);
  2113. if (xidLook->tag.lock)
  2114. {
  2115. lock = (LOCK *) MAKE_PTR(xidLook->tag.lock);
  2116. LOCK_PRINT_AUX("DumpAllLocks", lock, 0);
  2117. }
  2118. else
  2119. elog(DEBUG, "DumpAllLocks: xidLook->tag.lock = NULL");
  2121. if (count++ > 2000)
  2122. {
  2123. elog(NOTICE, "DumpAllLocks: possible loop, giving up");
  2124. break;
  2125. }
  2126. }
  2127. }
  2129. #endif