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

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

数据库系统

开发平台：

Unix_Linux

multi.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * multi.c
  4.  *   multi level lock table manager
  5.  *
  6.  *   Standard multi-level lock manager as per the Gray paper
  7.  *   (at least, that is what it is supposed to be).  We implement
  8.  *   three levels -- RELN, PAGE, TUPLE.  Tuple is actually TID
  9.  *   a physical record pointer.  It isn't an object id.
  10.  *
  11.  * Copyright (c) 1994, Regents of the University of California
  12.  *
  13.  *
  14.  * IDENTIFICATION
  15.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/storage/lmgr/multi.c,v 1.29 1999/05/25 16:11:22 momjian Exp $
  16.  *
  17.  * NOTES:
  18.  *  (1) The lock.c module assumes that the caller here is doing
  19.  *  two phase locking.
  20.  *
  21.  *-------------------------------------------------------------------------
  22.  */
  23. #include <stdio.h>
  24. #include <string.h>
  25. #include "postgres.h"
  26. #include "storage/lmgr.h"
  27. #include "storage/multilev.h"
  29. #include "utils/rel.h"
  30. #include "miscadmin.h" /* MyDatabaseId */
  32. static bool MultiAcquire(LOCKMETHOD lockmethod, LOCKTAG *tag,
  33.  LOCKMODE lockmode, PG_LOCK_LEVEL level);
  34. static bool MultiRelease(LOCKMETHOD lockmethod, LOCKTAG *tag,
  35.  LOCKMODE lockmode, PG_LOCK_LEVEL level);
  37. /*
  38.  * INTENT indicates to higher level that a lower level lock has been
  39.  * set.  For example, a write lock on a tuple conflicts with a write
  40.  * lock on a relation. This conflict is detected as a WRITE_INTENT/
  41.  * WRITE conflict between the tuple's intent lock and the relation's
  42.  * write lock.
  43.  */
  44. static MASK MultiConflicts[] = {
  45. (int) NULL,
  46. /* All reads and writes at any level conflict with a write lock */
  47. (1 << WRITE_LOCK) | (1 << WRITE_INTENT) | (1 << READ_LOCK) | (1 << READ_INTENT),
  48. /* read locks conflict with write locks at curr and lower levels */
  49. (1 << WRITE_LOCK) | (1 << WRITE_INTENT),
  50. /* write intent locks */
  51. (1 << READ_LOCK) | (1 << WRITE_LOCK),
  52. /* read intent locks */
  53. (1 << WRITE_LOCK),
  55. /*
  56.  * extend locks for archive storage manager conflict only w/extend
  57.  * locks
  58.  */
  59. (1 << EXTEND_LOCK)
  60. };
  62. /*
  63.  * write locks have higher priority than read locks and extend locks.  May
  64.  * want to treat INTENT locks differently.
  65.  */
  66. static int MultiPrios[] = {
  67. (int) NULL,
  68. 2,
  69. 1,
  70. 2,
  71. 1,
  72. 1
  73. };
  75. /*
  76.  * Lock table identifier for this lock table.  The multi-level
  77.  * lock table is ONE lock table, not three.
  78.  */
  79. LOCKMETHOD MultiTableId = (LOCKMETHOD) NULL;
  80. LOCKMETHOD LongTermTableId = (LOCKMETHOD) NULL;
  82. #ifdef NOT_USED
  83. LOCKMETHOD ShortTermTableId = (LOCKMETHOD) NULL;
  85. #endif
  87. /*
  88.  * Create the lock table described by MultiConflicts and Multiprio.
  89.  */
  90. LOCKMETHOD
  91. InitMultiLevelLocks()
  92. {
  93. int lockmethod;
  95. lockmethod = LockMethodTableInit("MultiLevelLockTable",
  96.   MultiConflicts, MultiPrios, MAX_LOCKMODES - 1);
  97. MultiTableId = lockmethod;
  98. if (!(MultiTableId))
  99. elog(ERROR, "InitMultiLocks: couldnt initialize lock table");
  100. /* -----------------------
  101.  * No short term lock table for now.  -Jeff 15 July 1991
  102.  *
  103.  * ShortTermTableId = LockMethodTableRename(lockmethod);
  104.  * if (! (ShortTermTableId)) {
  105.  *  elog(ERROR,"InitMultiLocks: couldnt rename lock table");
  106.  * }
  107.  * -----------------------
  108.  */
  110. #ifdef USER_LOCKS
  112. /*
  113.  * Allocate another tableId for long-term locks
  114.  */
  115. LongTermTableId = LockMethodTableRename(MultiTableId);
  116. if (!(LongTermTableId))
  117. {
  118. elog(ERROR,
  119.  "InitMultiLevelLocks: couldn't rename long-term lock table");
  120. }
  121. #endif
  123. return MultiTableId;
  124. }
  126. /*
  127.  * MultiLockReln -- lock a relation
  128.  *
  129.  * Returns: TRUE if the lock can be set, FALSE otherwise.
  130.  */
  131. bool
  132. MultiLockReln(LockInfo lockinfo, LOCKMODE lockmode)
  133. {
  134. LOCKTAG tag;
  136. /*
  137.  * LOCKTAG has two bytes of padding, unfortunately.  The hash function
  138.  * will return miss if the padding bytes aren't zero'd.
  139.  */
  140. MemSet(&tag, 0, sizeof(tag));
  141. tag.relId = lockinfo->lockRelId.relId;
  142. tag.dbId = lockinfo->lockRelId.dbId;
  143. return MultiAcquire(MultiTableId, &tag, lockmode, RELN_LEVEL);
  144. }
  146. #ifdef NOT_USED
  147. /*
  148.  * MultiLockTuple -- Lock the TID associated with a tuple
  149.  *
  150.  * Returns: TRUE if lock is set, FALSE otherwise.
  151.  *
  152.  * Side Effects: causes intention level locks to be set
  153.  * at the page and relation level.
  154.  */
  155. bool
  156. MultiLockTuple(LockInfo lockinfo, ItemPointer tidPtr, LOCKMODE lockmode)
  157. {
  158. LOCKTAG tag;
  160. /*
  161.  * LOCKTAG has two bytes of padding, unfortunately.  The hash function
  162.  * will return miss if the padding bytes aren't zero'd.
  163.  */
  164. MemSet(&tag, 0, sizeof(tag));
  166. tag.relId = lockinfo->lockRelId.relId;
  167. tag.dbId = lockinfo->lockRelId.dbId;
  169. /* not locking any valid Tuple, just the page */
  170. tag.tupleId = *tidPtr;
  171. return MultiAcquire(MultiTableId, &tag, lockmode, TUPLE_LEVEL);
  172. }
  174. #endif
  176. /*
  177.  * same as above at page level
  178.  */
  179. bool
  180. MultiLockPage(LockInfo lockinfo, ItemPointer tidPtr, LOCKMODE lockmode)
  181. {
  182. LOCKTAG tag;
  184. /*
  185.  * LOCKTAG has two bytes of padding, unfortunately.  The hash function
  186.  * will return miss if the padding bytes aren't zero'd.
  187.  */
  188. MemSet(&tag, 0, sizeof(tag));
  191. /* ----------------------------
  192.  * Now we want to set the page offset to be invalid
  193.  * and lock the block. There is some confusion here as to what
  194.  * a page is.  In Postgres a page is an 8k block, however this
  195.  * block may be partitioned into many subpages which are sometimes
  196.  * also called pages.  The term is overloaded, so don't be fooled
  197.  * when we say lock the page we mean the 8k block. -Jeff 16 July 1991
  198.  * ----------------------------
  199.  */
  200. tag.relId = lockinfo->lockRelId.relId;
  201. tag.dbId = lockinfo->lockRelId.dbId;
  202. BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
  203. return MultiAcquire(MultiTableId, &tag, lockmode, PAGE_LEVEL);
  204. }
  206. /*
  207.  * MultiAcquire -- acquire multi level lock at requested level
  208.  *
  209.  * Returns: TRUE if lock is set, FALSE if not
  210.  * Side Effects:
  211.  */
  212. static bool
  213. MultiAcquire(LOCKMETHOD lockmethod,
  214.  LOCKTAG *tag,
  215.  LOCKMODE lockmode,
  216.  PG_LOCK_LEVEL level)
  217. {
  218. LOCKMODE locks[N_LEVELS];
  219. int i,
  220. status;
  221. LOCKTAG xxTag,
  222.    *tmpTag = &xxTag;
  223. int retStatus = TRUE;
  225. /*
  226.  * Three levels implemented.  If we set a low level (e.g. Tuple) lock,
  227.  * we must set INTENT locks on the higher levels.  The intent lock
  228.  * detects conflicts between the low level lock and an existing high
  229.  * level lock. For example, setting a write lock on a tuple in a
  230.  * relation is disallowed if there is an existing read lock on the
  231.  * entire relation.  The write lock would set a WRITE + INTENT lock on
  232.  * the relation and that lock would conflict with the read.
  233.  */
  234. switch (level)
  235. {
  236. case RELN_LEVEL:
  237. locks[0] = lockmode;
  238. locks[1] = NO_LOCK;
  239. locks[2] = NO_LOCK;
  240. break;
  241. case PAGE_LEVEL:
  242. locks[0] = lockmode + INTENT;
  243. locks[1] = lockmode;
  244. locks[2] = NO_LOCK;
  245. break;
  246. case TUPLE_LEVEL:
  247. locks[0] = lockmode + INTENT;
  248. locks[1] = lockmode + INTENT;
  249. locks[2] = lockmode;
  250. break;
  251. default:
  252. elog(ERROR, "MultiAcquire: bad lock level");
  253. return FALSE;
  254. }
  256. /*
  257.  * construct a new tag as we go. Always loop through all levels, but
  258.  * if we arent' seting a low level lock, locks[i] is set to NO_LOCK
  259.  * for the lower levels.  Always start from the highest level and go
  260.  * to the lowest level.
  261.  */
  262. MemSet(tmpTag, 0, sizeof(*tmpTag));
  263. tmpTag->relId = tag->relId;
  264. tmpTag->dbId = tag->dbId;
  266. for (i = 0; i < N_LEVELS; i++)
  267. {
  268. if (locks[i] != NO_LOCK)
  269. {
  270. switch (i)
  271. {
  272. case RELN_LEVEL:
  273. /* -------------
  274.  * Set the block # and offset to invalid
  275.  * -------------
  276.  */
  277. BlockIdSet(&(tmpTag->tupleId.ip_blkid), InvalidBlockNumber);
  278. tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
  279. break;
  280. case PAGE_LEVEL:
  281. /* -------------
  282.  * Copy the block #, set the offset to invalid
  283.  * -------------
  284.  */
  285. BlockIdCopy(&(tmpTag->tupleId.ip_blkid),
  286. &(tag->tupleId.ip_blkid));
  287. tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
  288. break;
  289. case TUPLE_LEVEL:
  290. /* --------------
  291.  * Copy the entire tuple id.
  292.  * --------------
  293.  */
  294. ItemPointerCopy(&tmpTag->tupleId, &tag->tupleId);
  295. break;
  296. }
  298. status = LockAcquire(lockmethod, tmpTag, locks[i]);
  299. if (!status)
  300. {
  302. /*
  303.  * failed for some reason. Before returning we have to
  304.  * release all of the locks we just acquired.
  305.  * MultiRelease(xx,xx,xx, i) means release starting from
  306.  * the last level lock we successfully acquired
  307.  */
  308. retStatus = FALSE;
  309. MultiRelease(lockmethod, tag, lockmode, i);
  310. /* now leave the loop. Don't try for any more locks */
  311. break;
  312. }
  313. }
  314. }
  315. return retStatus;
  316. }
  318. /* ------------------
  319.  * Release a page in the multi-level lock table
  320.  * ------------------
  321.  */
  322. #ifdef NOT_USED
  323. bool
  324. MultiReleasePage(LockInfo lockinfo, ItemPointer tidPtr, LOCKMODE lockmode)
  325. {
  326. LOCKTAG tag;
  328. /* ------------------
  329.  * LOCKTAG has two bytes of padding, unfortunately.  The
  330.  * hash function will return miss if the padding bytes aren't
  331.  * zero'd.
  332.  * ------------------
  333.  */
  334. MemSet(&tag, 0, sizeof(LOCKTAG));
  336. tag.relId = lockinfo->lockRelId.relId;
  337. tag.dbId = lockinfo->lockRelId.dbId;
  338. BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
  340. return MultiRelease(MultiTableId, &tag, lockmode, PAGE_LEVEL);
  341. }
  343. #endif
  345. /* ------------------
  346.  * Release a relation in the multi-level lock table
  347.  * ------------------
  348.  */
  349. bool
  350. MultiReleaseReln(LockInfo lockinfo, LOCKMODE lockmode)
  351. {
  352. LOCKTAG tag;
  354. /* ------------------
  355.  * LOCKTAG has two bytes of padding, unfortunately.  The
  356.  * hash function will return miss if the padding bytes aren't
  357.  * zero'd.
  358.  * ------------------
  359.  */
  360. MemSet(&tag, 0, sizeof(LOCKTAG));
  361. tag.relId = lockinfo->lockRelId.relId;
  362. tag.dbId = lockinfo->lockRelId.dbId;
  364. return MultiRelease(MultiTableId, &tag, lockmode, RELN_LEVEL);
  365. }
  367. /*
  368.  * MultiRelease -- release a multi-level lock
  369.  *
  370.  * Returns: TRUE if successful, FALSE otherwise.
  371.  */
  372. static bool
  373. MultiRelease(LOCKMETHOD lockmethod,
  374.  LOCKTAG *tag,
  375.  LOCKMODE lockmode,
  376.  PG_LOCK_LEVEL level)
  377. {
  378. LOCKMODE locks[N_LEVELS];
  379. int i,
  380. status;
  381. LOCKTAG xxTag,
  382.    *tmpTag = &xxTag;
  384. /*
  385.  * same level scheme as MultiAcquire().
  386.  */
  387. switch (level)
  388. {
  389. case RELN_LEVEL:
  390. locks[0] = lockmode;
  391. locks[1] = NO_LOCK;
  392. locks[2] = NO_LOCK;
  393. break;
  394. case PAGE_LEVEL:
  395. locks[0] = lockmode + INTENT;
  396. locks[1] = lockmode;
  397. locks[2] = NO_LOCK;
  398. break;
  399. case TUPLE_LEVEL:
  400. locks[0] = lockmode + INTENT;
  401. locks[1] = lockmode + INTENT;
  402. locks[2] = lockmode;
  403. break;
  404. default:
  405. elog(ERROR, "MultiRelease: bad lockmode");
  406. }
  408. /*
  409.  * again, construct the tag on the fly.  This time, however, we
  410.  * release the locks in the REVERSE order -- from lowest level to
  411.  * highest level.
  412.  *
  413.  * Must zero out the tag to set padding byes to zero and ensure hashing
  414.  * consistency.
  415.  */
  416. MemSet(tmpTag, 0, sizeof(*tmpTag));
  417. tmpTag->relId = tag->relId;
  418. tmpTag->dbId = tag->dbId;
  420. for (i = (N_LEVELS - 1); i >= 0; i--)
  421. {
  422. if (locks[i] != NO_LOCK)
  423. {
  424. switch (i)
  425. {
  426. case RELN_LEVEL:
  427. /* -------------
  428.  * Set the block # and offset to invalid
  429.  * -------------
  430.  */
  431. BlockIdSet(&(tmpTag->tupleId.ip_blkid), InvalidBlockNumber);
  432. tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
  433. break;
  434. case PAGE_LEVEL:
  435. /* -------------
  436.  * Copy the block #, set the offset to invalid
  437.  * -------------
  438.  */
  439. BlockIdCopy(&(tmpTag->tupleId.ip_blkid),
  440. &(tag->tupleId.ip_blkid));
  441. tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
  442. break;
  443. case TUPLE_LEVEL:
  444. ItemPointerCopy(&tmpTag->tupleId, &tag->tupleId);
  445. break;
  446. }
  447. status = LockRelease(lockmethod, tmpTag, locks[i]);
  448. if (!status)
  449. elog(ERROR, "MultiRelease: couldn't release after error");
  450. }
  451. }
  452. /* shouldn't reach here */
  453. return false;
  454. }