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

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

数据库系统

开发平台：

Unix_Linux

bufmgr.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * bufmgr.c
  4.  *   buffer manager interface routines
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.56 1999/06/29 04:54:47 vadim Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. /*
  15.  *
  16.  * BufferAlloc() -- lookup a buffer in the buffer table.  If
  17.  * it isn't there add it, but do not read it into memory.
  18.  * This is used when we are about to reinitialize the
  19.  * buffer so don't care what the current disk contents are.
  20.  * BufferAlloc() pins the new buffer in memory.
  21.  *
  22.  * ReadBuffer() -- same as BufferAlloc() but reads the data
  23.  * on a buffer cache miss.
  24.  *
  25.  * ReleaseBuffer() -- unpin the buffer
  26.  *
  27.  * WriteNoReleaseBuffer() -- mark the buffer contents as "dirty"
  28.  * but don't unpin.  The disk IO is delayed until buffer
  29.  * replacement if WriteMode is BUFFER_LATE_WRITE.
  30.  *
  31.  * WriteBuffer() -- WriteNoReleaseBuffer() + ReleaseBuffer()
  32.  *
  33.  * FlushBuffer() -- as above but never delayed write.
  34.  *
  35.  * BufferSync() -- flush all dirty buffers in the buffer pool.
  36.  *
  37.  * InitBufferPool() -- Init the buffer module.
  38.  *
  39.  * See other files:
  40.  * freelist.c -- chooses victim for buffer replacement
  41.  * buf_table.c -- manages the buffer lookup table
  42.  */
  43. #include <sys/types.h>
  44. #include <sys/file.h>
  45. #include <stdio.h>
  46. #include <string.h>
  47. #include <math.h>
  48. #include <signal.h>
  50. #include "postgres.h"
  52. /* declarations split between these three files */
  53. #include "storage/buf.h"
  54. #include "storage/buf_internals.h"
  55. #include "storage/bufmgr.h"
  57. #include "storage/fd.h"
  58. #include "storage/ipc.h"
  59. #include "storage/s_lock.h"
  60. #include "storage/shmem.h"
  61. #include "storage/spin.h"
  62. #include "storage/smgr.h"
  63. #include "storage/lmgr.h"
  64. #include "miscadmin.h"
  65. #include "utils/builtins.h"
  66. #include "utils/hsearch.h"
  67. #include "utils/palloc.h"
  68. #include "utils/memutils.h"
  69. #include "utils/relcache.h"
  70. #include "executor/execdebug.h" /* for NDirectFileRead */
  71. #include "catalog/catalog.h"
  73. extern SPINLOCK BufMgrLock;
  74. extern long int ReadBufferCount;
  75. extern long int ReadLocalBufferCount;
  76. extern long int BufferHitCount;
  77. extern long int LocalBufferHitCount;
  78. extern long int BufferFlushCount;
  79. extern long int LocalBufferFlushCount;
  81. /*
  82.  * It's used to avoid disk writes for read-only transactions
  83.  * (i.e. when no one shared buffer was changed by transaction).
  84.  * We set it to true in WriteBuffer/WriteNoReleaseBuffer when
  85.  * marking shared buffer as dirty. We set it to false in xact.c
  86.  * after transaction is committed/aborted.
  87.  */
  88. bool SharedBufferChanged = false;
  90. static int WriteMode = BUFFER_LATE_WRITE; /* Delayed write is
  91.  * default */
  93. static void WaitIO(BufferDesc *buf, SPINLOCK spinlock);
  95. #ifndef HAS_TEST_AND_SET
  96. static void SignalIO(BufferDesc *buf);
  97. extern long *NWaitIOBackendP; /* defined in buf_init.c */
  99. #endif  /* HAS_TEST_AND_SET */
  101. static Buffer ReadBufferWithBufferLock(Relation relation, BlockNumber blockNum,
  102.  bool bufferLockHeld);
  103. static BufferDesc *BufferAlloc(Relation reln, BlockNumber blockNum,
  104. bool *foundPtr, bool bufferLockHeld);
  105. static int FlushBuffer(Buffer buffer, bool release);
  106. static void BufferSync(void);
  107. static int BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld);
  108. void PrintBufferDescs(void);
  110. /* not static but used by vacuum only ... */
  111. int BlowawayRelationBuffers(Relation rel, BlockNumber block);
  113. /* ---------------------------------------------------
  114.  * RelationGetBufferWithBuffer
  115.  * see if the given buffer is what we want
  116.  * if yes, we don't need to bother the buffer manager
  117.  * ---------------------------------------------------
  118.  */
  119. Buffer
  120. RelationGetBufferWithBuffer(Relation relation,
  121. BlockNumber blockNumber,
  122. Buffer buffer)
  123. {
  124. BufferDesc *bufHdr;
  126. if (BufferIsValid(buffer))
  127. {
  128. if (!BufferIsLocal(buffer))
  129. {
  130. LockRelId  *lrelId = &(((LockInfo) (relation->lockInfo))->lockRelId);
  132. bufHdr = &BufferDescriptors[buffer - 1];
  133. SpinAcquire(BufMgrLock);
  134. if (bufHdr->tag.blockNum == blockNumber &&
  135. bufHdr->tag.relId.relId == lrelId->relId &&
  136. bufHdr->tag.relId.dbId == lrelId->dbId)
  137. {
  138. SpinRelease(BufMgrLock);
  139. return buffer;
  140. }
  141. return ReadBufferWithBufferLock(relation, blockNumber, true);
  142. }
  143. else
  144. {
  145. bufHdr = &LocalBufferDescriptors[-buffer - 1];
  146. if (bufHdr->tag.relId.relId == RelationGetRelid(relation) &&
  147. bufHdr->tag.blockNum == blockNumber)
  148. return buffer;
  149. }
  150. }
  151. return ReadBuffer(relation, blockNumber);
  152. }
  154. /*
  155.  * ReadBuffer -- returns a buffer containing the requested
  156.  * block of the requested relation.  If the blknum
  157.  * requested is P_NEW, extend the relation file and
  158.  * allocate a new block.
  159.  *
  160.  * Returns: the buffer number for the buffer containing
  161.  * the block read or NULL on an error.
  162.  *
  163.  * Assume when this function is called, that reln has been
  164.  * opened already.
  165.  */
  167. extern int ShowPinTrace;
  170. #undef ReadBuffer /* conflicts with macro when BUFMGR_DEBUG
  171.  * defined */
  173. /*
  174.  * ReadBuffer
  175.  *
  176.  */
  177. Buffer
  178. ReadBuffer(Relation reln, BlockNumber blockNum)
  179. {
  180. return ReadBufferWithBufferLock(reln, blockNum, false);
  181. }
  183. /*
  184.  * is_userbuffer
  185.  *
  186.  * XXX caller must have already acquired BufMgrLock
  187.  */
  188. #ifdef NOT_USED
  189. static bool
  190. is_userbuffer(Buffer buffer)
  191. {
  192. BufferDesc *buf = &BufferDescriptors[buffer - 1];
  194. if (IsSystemRelationName(buf->sb_relname))
  195. return false;
  196. return true;
  197. }
  199. #endif
  201. #ifdef NOT_USED
  202. Buffer
  203. ReadBuffer_Debug(char *file,
  204.  int line,
  205.  Relation reln,
  206.  BlockNumber blockNum)
  207. {
  208. Buffer buffer;
  210. buffer = ReadBufferWithBufferLock(reln, blockNum, false);
  211. if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer))
  212. {
  213. BufferDesc *buf = &BufferDescriptors[buffer - 1];
  215. fprintf(stderr, "PIN(RD) %ld relname = %s, blockNum = %d, 
  216. refcount = %ld, file: %s, line: %dn",
  217. buffer, buf->sb_relname, buf->tag.blockNum,
  218. PrivateRefCount[buffer - 1], file, line);
  219. }
  220. return buffer;
  221. }
  223. #endif
  225. /*
  226.  * ReadBufferWithBufferLock -- does the work of
  227.  * ReadBuffer() but with the possibility that
  228.  * the buffer lock has already been held. this
  229.  * is yet another effort to reduce the number of
  230.  * semops in the system.
  231.  */
  232. static Buffer
  233. ReadBufferWithBufferLock(Relation reln,
  234.  BlockNumber blockNum,
  235.  bool bufferLockHeld)
  236. {
  237. BufferDesc *bufHdr;
  238. int extend; /* extending the file by one block */
  239. int status;
  240. bool found;
  241. bool isLocalBuf;
  243. extend = (blockNum == P_NEW);
  244. isLocalBuf = reln->rd_myxactonly;
  246. if (isLocalBuf)
  247. {
  248. ReadLocalBufferCount++;
  249. bufHdr = LocalBufferAlloc(reln, blockNum, &found);
  250. if (found)
  251. LocalBufferHitCount++;
  252. }
  253. else
  254. {
  255. ReadBufferCount++;
  257. /*
  258.  * lookup the buffer.  IO_IN_PROGRESS is set if the requested
  259.  * block is not currently in memory.
  260.  */
  261. bufHdr = BufferAlloc(reln, blockNum, &found, bufferLockHeld);
  262. if (found)
  263. BufferHitCount++;
  264. }
  266. if (!bufHdr)
  267. return InvalidBuffer;
  269. /* if its already in the buffer pool, we're done */
  270. if (found)
  271. {
  273. /*
  274.  * This happens when a bogus buffer was returned previously and is
  275.  * floating around in the buffer pool. A routine calling this
  276.  * would want this extended.
  277.  */
  278. if (extend)
  279. {
  280. /* new buffers are zero-filled */
  281. MemSet((char *) MAKE_PTR(bufHdr->data), 0, BLCKSZ);
  282. smgrextend(DEFAULT_SMGR, reln,
  283.    (char *) MAKE_PTR(bufHdr->data));
  284. }
  285. return BufferDescriptorGetBuffer(bufHdr);
  287. }
  289. /*
  290.  * if we have gotten to this point, the reln pointer must be ok and
  291.  * the relation file must be open.
  292.  */
  293. if (extend)
  294. {
  295. /* new buffers are zero-filled */
  296. MemSet((char *) MAKE_PTR(bufHdr->data), 0, BLCKSZ);
  297. status = smgrextend(DEFAULT_SMGR, reln,
  298. (char *) MAKE_PTR(bufHdr->data));
  299. }
  300. else
  301. {
  302. status = smgrread(DEFAULT_SMGR, reln, blockNum,
  303.   (char *) MAKE_PTR(bufHdr->data));
  304. }
  306. if (isLocalBuf)
  307. return BufferDescriptorGetBuffer(bufHdr);
  309. /* lock buffer manager again to update IO IN PROGRESS */
  310. SpinAcquire(BufMgrLock);
  312. if (status == SM_FAIL)
  313. {
  314. /* IO Failed.  cleanup the data structures and go home */
  316. if (!BufTableDelete(bufHdr))
  317. {
  318. SpinRelease(BufMgrLock);
  319. elog(FATAL, "BufRead: buffer table broken after IO errorn");
  320. }
  321. /* remember that BufferAlloc() pinned the buffer */
  322. UnpinBuffer(bufHdr);
  324. /*
  325.  * Have to reset the flag so that anyone waiting for the buffer
  326.  * can tell that the contents are invalid.
  327.  */
  328. bufHdr->flags |= BM_IO_ERROR;
  329. bufHdr->flags &= ~BM_IO_IN_PROGRESS;
  330. }
  331. else
  332. {
  333. /* IO Succeeded.  clear the flags, finish buffer update */
  335. bufHdr->flags &= ~(BM_IO_ERROR | BM_IO_IN_PROGRESS);
  336. }
  338. /* If anyone was waiting for IO to complete, wake them up now */
  339. #ifdef HAS_TEST_AND_SET
  340. S_UNLOCK(&(bufHdr->io_in_progress_lock));
  341. #else
  342. if (bufHdr->refcount > 1)
  343. SignalIO(bufHdr);
  344. #endif
  346. SpinRelease(BufMgrLock);
  348. if (status == SM_FAIL)
  349. return InvalidBuffer;
  351. return BufferDescriptorGetBuffer(bufHdr);
  352. }
  354. /*
  355.  * BufferAlloc -- Get a buffer from the buffer pool but dont
  356.  * read it.
  357.  *
  358.  * Returns: descriptor for buffer
  359.  *
  360.  * When this routine returns, the BufMgrLock is guaranteed NOT be held.
  361.  */
  362. static BufferDesc *
  363. BufferAlloc(Relation reln,
  364. BlockNumber blockNum,
  365. bool *foundPtr,
  366. bool bufferLockHeld)
  367. {
  368. BufferDesc *buf,
  369.    *buf2;
  370. BufferTag newTag; /* identity of requested block */
  371. bool inProgress; /* buffer undergoing IO */
  372. bool newblock = FALSE;
  374. /* create a new tag so we can lookup the buffer */
  375. /* assume that the relation is already open */
  376. if (blockNum == P_NEW)
  377. {
  378. newblock = TRUE;
  379. blockNum = smgrnblocks(DEFAULT_SMGR, reln);
  380. }
  382. INIT_BUFFERTAG(&newTag, reln, blockNum);
  384. if (!bufferLockHeld)
  385. SpinAcquire(BufMgrLock);
  387. /* see if the block is in the buffer pool already */
  388. buf = BufTableLookup(&newTag);
  389. if (buf != NULL)
  390. {
  392. /*
  393.  * Found it.  Now, (a) pin the buffer so no one steals it from the
  394.  * buffer pool, (b) check IO_IN_PROGRESS, someone may be faulting
  395.  * the buffer into the buffer pool.
  396.  */
  398. PinBuffer(buf);
  399. inProgress = (buf->flags & BM_IO_IN_PROGRESS);
  401. *foundPtr = TRUE;
  402. if (inProgress)
  403. {
  404. WaitIO(buf, BufMgrLock);
  405. if (buf->flags & BM_IO_ERROR)
  406. {
  408. /*
  409.  * wierd race condition:
  410.  *
  411.  * We were waiting for someone else to read the buffer. While
  412.  * we were waiting, the reader boof'd in some way, so the
  413.  * contents of the buffer are still invalid.  By saying
  414.  * that we didn't find it, we can make the caller
  415.  * reinitialize the buffer.  If two processes are waiting
  416.  * for this block, both will read the block.  The second
  417.  * one to finish may overwrite any updates made by the
  418.  * first.  (Assume higher level synchronization prevents
  419.  * this from happening).
  420.  *
  421.  * This is never going to happen, don't worry about it.
  422.  */
  423. *foundPtr = FALSE;
  424. }
  425. }
  426. #ifdef BMTRACE
  427. _bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), RelationGetRelid(reln), blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCFND);
  428. #endif  /* BMTRACE */
  430. SpinRelease(BufMgrLock);
  432. return buf;
  433. }
  435. *foundPtr = FALSE;
  437. /*
  438.  * Didn't find it in the buffer pool.  We'll have to initialize a new
  439.  * buffer. First, grab one from the free list.  If it's dirty, flush
  440.  * it to disk. Remember to unlock BufMgr spinlock while doing the IOs.
  441.  */
  442. inProgress = FALSE;
  443. for (buf = (BufferDesc *) NULL; buf == (BufferDesc *) NULL;)
  444. {
  446. /* GetFreeBuffer will abort if it can't find a free buffer */
  447. buf = GetFreeBuffer();
  449. /*
  450.  * But it can return buf == NULL if we are in aborting transaction
  451.  * now and so elog(ERROR,...) in GetFreeBuffer will not abort
  452.  * again.
  453.  */
  454. if (buf == NULL)
  455. return NULL;
  457. /*
  458.  * There should be exactly one pin on the buffer after it is
  459.  * allocated -- ours.  If it had a pin it wouldn't have been on
  460.  * the free list.  No one else could have pinned it between
  461.  * GetFreeBuffer and here because we have the BufMgrLock.
  462.  */
  463. Assert(buf->refcount == 0);
  464. buf->refcount = 1;
  465. PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 1;
  467. if (buf->flags & BM_DIRTY)
  468. {
  469. bool smok;
  471. /*
  472.  * Set BM_IO_IN_PROGRESS to keep anyone from doing anything
  473.  * with the contents of the buffer while we write it out. We
  474.  * don't really care if they try to read it, but if they can
  475.  * complete a BufferAlloc on it they can then scribble into
  476.  * it, and we'd really like to avoid that while we are
  477.  * flushing the buffer.  Setting this flag should block them
  478.  * in WaitIO until we're done.
  479.  */
  480. inProgress = TRUE;
  481. buf->flags |= BM_IO_IN_PROGRESS;
  482. #ifdef HAS_TEST_AND_SET
  484. /*
  485.  * All code paths that acquire this lock pin the buffer first;
  486.  * since no one had it pinned (it just came off the free
  487.  * list), no one else can have this lock.
  488.  */
  489. Assert(S_LOCK_FREE(&(buf->io_in_progress_lock)));
  490. S_LOCK(&(buf->io_in_progress_lock));
  491. #endif  /* HAS_TEST_AND_SET */
  493. /*
  494.  * Write the buffer out, being careful to release BufMgrLock
  495.  * before starting the I/O.
  496.  *
  497.  * This #ifndef is here because a few extra semops REALLY kill
  498.  * you on machines that don't have spinlocks.  If you don't
  499.  * operate with much concurrency, well...
  500.  */
  501. smok = BufferReplace(buf, true);
  502. #ifndef OPTIMIZE_SINGLE
  503. SpinAcquire(BufMgrLock);
  504. #endif  /* OPTIMIZE_SINGLE */
  506. if (smok == FALSE)
  507. {
  508. elog(NOTICE, "BufferAlloc: cannot write block %u for %s/%s",
  509.  buf->tag.blockNum, buf->sb_dbname, buf->sb_relname);
  510. inProgress = FALSE;
  511. buf->flags |= BM_IO_ERROR;
  512. buf->flags &= ~BM_IO_IN_PROGRESS;
  513. #ifdef HAS_TEST_AND_SET
  514. S_UNLOCK(&(buf->io_in_progress_lock));
  515. #else /* !HAS_TEST_AND_SET */
  516. if (buf->refcount > 1)
  517. SignalIO(buf);
  518. #endif  /* !HAS_TEST_AND_SET */
  519. PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
  520. buf->refcount--;
  521. if (buf->refcount == 0)
  522. {
  523. AddBufferToFreelist(buf);
  524. buf->flags |= BM_FREE;
  525. }
  526. buf = (BufferDesc *) NULL;
  527. }
  528. else
  529. {
  531. /*
  532.  * BM_JUST_DIRTIED cleared by BufferReplace and shouldn't
  533.  * be setted by anyone. - vadim 01/17/97
  534.  */
  535. if (buf->flags & BM_JUST_DIRTIED)
  536. {
  537. elog(FATAL, "BufferAlloc: content of block %u (%s) changed while flushing",
  538.  buf->tag.blockNum, buf->sb_relname);
  539. }
  540. else
  541. buf->flags &= ~BM_DIRTY;
  542. }
  544. /*
  545.  * Somebody could have pinned the buffer while we were doing
  546.  * the I/O and had given up the BufMgrLock (though they would
  547.  * be waiting for us to clear the BM_IO_IN_PROGRESS flag).
  548.  * That's why this is a loop -- if so, we need to clear the
  549.  * I/O flags, remove our pin and start all over again.
  550.  *
  551.  * People may be making buffers free at any time, so there's no
  552.  * reason to think that we have an immediate disaster on our
  553.  * hands.
  554.  */
  555. if (buf && buf->refcount > 1)
  556. {
  557. inProgress = FALSE;
  558. buf->flags &= ~BM_IO_IN_PROGRESS;
  559. #ifdef HAS_TEST_AND_SET
  560. S_UNLOCK(&(buf->io_in_progress_lock));
  561. #else /* !HAS_TEST_AND_SET */
  562. if (buf->refcount > 1)
  563. SignalIO(buf);
  564. #endif  /* !HAS_TEST_AND_SET */
  565. PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
  566. buf->refcount--;
  567. buf = (BufferDesc *) NULL;
  568. }
  570. /*
  571.  * Somebody could have allocated another buffer for the same
  572.  * block we are about to read in. (While we flush out the
  573.  * dirty buffer, we don't hold the lock and someone could have
  574.  * allocated another buffer for the same block. The problem is
  575.  * we haven't gotten around to insert the new tag into the
  576.  * buffer table. So we need to check here. -ay 3/95
  577.  */
  578. buf2 = BufTableLookup(&newTag);
  579. if (buf2 != NULL)
  580. {
  582. /*
  583.  * Found it. Someone has already done what we're about to
  584.  * do. We'll just handle this as if it were found in the
  585.  * buffer pool in the first place.
  586.  */
  587. if (buf != NULL)
  588. {
  589. #ifdef HAS_TEST_AND_SET
  590. S_UNLOCK(&(buf->io_in_progress_lock));
  591. #else /* !HAS_TEST_AND_SET */
  592. if (buf->refcount > 1)
  593. SignalIO(buf);
  594. #endif  /* !HAS_TEST_AND_SET */
  595. /* give up the buffer since we don't need it any more */
  596. buf->refcount--;
  597. PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
  598. AddBufferToFreelist(buf);
  599. buf->flags |= BM_FREE;
  600. buf->flags &= ~BM_IO_IN_PROGRESS;
  601. }
  603. PinBuffer(buf2);
  604. inProgress = (buf2->flags & BM_IO_IN_PROGRESS);
  606. *foundPtr = TRUE;
  607. if (inProgress)
  608. {
  609. WaitIO(buf2, BufMgrLock);
  610. if (buf2->flags & BM_IO_ERROR)
  611. *foundPtr = FALSE;
  612. }
  614. SpinRelease(BufMgrLock);
  616. return buf2;
  617. }
  618. }
  619. }
  621. /*
  622.  * At this point we should have the sole pin on a non-dirty buffer and
  623.  * we may or may not already have the BM_IO_IN_PROGRESS flag set.
  624.  */
  626. /*
  627.  * Change the name of the buffer in the lookup table:
  628.  *
  629.  * Need to update the lookup table before the read starts. If someone
  630.  * comes along looking for the buffer while we are reading it in, we
  631.  * don't want them to allocate a new buffer.  For the same reason, we
  632.  * didn't want to erase the buf table entry for the buffer we were
  633.  * writing back until now, either.
  634.  */
  636. if (!BufTableDelete(buf))
  637. {
  638. SpinRelease(BufMgrLock);
  639. elog(FATAL, "buffer wasn't in the buffer tablen");
  641. }
  643. /* record the database name and relation name for this buffer */
  644. strcpy(buf->sb_relname, reln->rd_rel->relname.data);
  645. strcpy(buf->sb_dbname, DatabaseName);
  647. INIT_BUFFERTAG(&(buf->tag), reln, blockNum);
  648. if (!BufTableInsert(buf))
  649. {
  650. SpinRelease(BufMgrLock);
  651. elog(FATAL, "Buffer in lookup table twice n");
  652. }
  654. /*
  655.  * Buffer contents are currently invalid.  Have to mark IO IN PROGRESS
  656.  * so no one fiddles with them until the read completes.  If this
  657.  * routine has been called simply to allocate a buffer, no io will be
  658.  * attempted, so the flag isnt set.
  659.  */
  660. if (!inProgress)
  661. {
  662. buf->flags |= BM_IO_IN_PROGRESS;
  663. #ifdef HAS_TEST_AND_SET
  664. Assert(S_LOCK_FREE(&(buf->io_in_progress_lock)));
  665. S_LOCK(&(buf->io_in_progress_lock));
  666. #endif  /* HAS_TEST_AND_SET */
  667. }
  669. #ifdef BMTRACE
  670. _bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), RelationGetRelid(reln), blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCNOTFND);
  671. #endif  /* BMTRACE */
  673. SpinRelease(BufMgrLock);
  675. return buf;
  676. }
  678. /*
  679.  * WriteBuffer
  680.  *
  681.  * Pushes buffer contents to disk if WriteMode is BUFFER_FLUSH_WRITE.
  682.  * Otherwise, marks contents as dirty.
  683.  *
  684.  * Assume that buffer is pinned.  Assume that reln is
  685.  * valid.
  686.  *
  687.  * Side Effects:
  688.  * Pin count is decremented.
  689.  */
  691. #undef WriteBuffer
  693. int
  694. WriteBuffer(Buffer buffer)
  695. {
  696. BufferDesc *bufHdr;
  698. if (WriteMode == BUFFER_FLUSH_WRITE)
  699. return FlushBuffer(buffer, TRUE);
  700. else
  701. {
  703. if (BufferIsLocal(buffer))
  704. return WriteLocalBuffer(buffer, TRUE);
  706. if (BAD_BUFFER_ID(buffer))
  707. return FALSE;
  709. bufHdr = &BufferDescriptors[buffer - 1];
  711. SharedBufferChanged = true;
  713. SpinAcquire(BufMgrLock);
  714. Assert(bufHdr->refcount > 0);
  715. bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
  716. UnpinBuffer(bufHdr);
  717. SpinRelease(BufMgrLock);
  718. CommitInfoNeedsSave[buffer - 1] = 0;
  719. }
  720. return TRUE;
  721. }
  723. #ifdef NOT_USED
  724. void
  725. WriteBuffer_Debug(char *file, int line, Buffer buffer)
  726. {
  727. WriteBuffer(buffer);
  728. if (ShowPinTrace && BufferIsLocal(buffer) && is_userbuffer(buffer))
  729. {
  730. BufferDesc *buf;
  732. buf = &BufferDescriptors[buffer - 1];
  733. fprintf(stderr, "UNPIN(WR) %ld relname = %s, blockNum = %d, 
  734. refcount = %ld, file: %s, line: %dn",
  735. buffer, buf->sb_relname, buf->tag.blockNum,
  736. PrivateRefCount[buffer - 1], file, line);
  737. }
  738. }
  740. #endif
  742. /*
  743.  * DirtyBufferCopy() -- For a given dbid/relid/blockno, if the buffer is
  744.  * in the cache and is dirty, mark it clean and copy
  745.  * it to the requested location.  This is a logical
  746.  * write, and has been installed to support the cache
  747.  * management code for write-once storage managers.
  748.  *
  749.  * DirtyBufferCopy() -- Copy a given dirty buffer to the requested
  750.  *  destination.
  751.  *
  752.  * We treat this as a write.  If the requested buffer is in the pool
  753.  * and is dirty, we copy it to the location requested and mark it
  754.  * clean. This routine supports the Sony jukebox storage manager,
  755.  * which agrees to take responsibility for the data once we mark
  756.  * it clean.
  757.  *
  758.  * NOTE: used by sony jukebox code in postgres 4.2   - ay 2/95
  759.  */
  760. #ifdef NOT_USED
  761. void
  762. DirtyBufferCopy(Oid dbid, Oid relid, BlockNumber blkno, char *dest)
  763. {
  764. BufferDesc *buf;
  765. BufferTag btag;
  767. btag.relId.relId = relid;
  768. btag.relId.dbId = dbid;
  769. btag.blockNum = blkno;
  771. SpinAcquire(BufMgrLock);
  772. buf = BufTableLookup(&btag);
  774. if (buf == (BufferDesc *) NULL
  775. || !(buf->flags & BM_DIRTY)
  776. || !(buf->flags & BM_VALID))
  777. {
  778. SpinRelease(BufMgrLock);
  779. return;
  780. }
  782. /*
  783.  * hate to do this holding the lock, but release and reacquire is
  784.  * slower
  785.  */
  786. memmove(dest, (char *) MAKE_PTR(buf->data), BLCKSZ);
  788. buf->flags &= ~BM_DIRTY;
  790. SpinRelease(BufMgrLock);
  791. }
  793. #endif
  795. /*
  796.  * FlushBuffer -- like WriteBuffer, but force the page to disk.
  797.  *
  798.  * 'buffer' is known to be dirty/pinned, so there should not be a
  799.  * problem reading the BufferDesc members without the BufMgrLock
  800.  * (nobody should be able to change tags, flags, etc. out from under
  801.  * us).
  802.  */
  803. static int
  804. FlushBuffer(Buffer buffer, bool release)
  805. {
  806. BufferDesc *bufHdr;
  807. Oid bufdb;
  808. Relation bufrel;
  809. int status;
  811. if (BufferIsLocal(buffer))
  812. return FlushLocalBuffer(buffer, release);
  814. if (BAD_BUFFER_ID(buffer))
  815. return STATUS_ERROR;
  817. bufHdr = &BufferDescriptors[buffer - 1];
  818. bufdb = bufHdr->tag.relId.dbId;
  820. Assert(bufdb == MyDatabaseId || bufdb == (Oid) NULL);
  821. bufrel = RelationIdCacheGetRelation(bufHdr->tag.relId.relId);
  822. Assert(bufrel != (Relation) NULL);
  824. SharedBufferChanged = true;
  826. /* To check if block content changed while flushing. - vadim 01/17/97 */
  827. SpinAcquire(BufMgrLock);
  828. bufHdr->flags &= ~BM_JUST_DIRTIED;
  829. SpinRelease(BufMgrLock);
  831. status = smgrflush(DEFAULT_SMGR, bufrel, bufHdr->tag.blockNum,
  832.    (char *) MAKE_PTR(bufHdr->data));
  834. RelationDecrementReferenceCount(bufrel);
  836. if (status == SM_FAIL)
  837. {
  838. elog(ERROR, "FlushBuffer: cannot flush block %u of the relation %s",
  839.  bufHdr->tag.blockNum, bufHdr->sb_relname);
  840. return STATUS_ERROR;
  841. }
  842. BufferFlushCount++;
  844. SpinAcquire(BufMgrLock);
  846. /*
  847.  * If this buffer was marked by someone as DIRTY while we were
  848.  * flushing it out we must not clear DIRTY flag - vadim 01/17/97
  849.  */
  850. if (bufHdr->flags & BM_JUST_DIRTIED)
  851. {
  852. elog(NOTICE, "FlusfBuffer: content of block %u (%s) changed while flushing",
  853.  bufHdr->tag.blockNum, bufHdr->sb_relname);
  854. }
  855. else
  856. bufHdr->flags &= ~BM_DIRTY;
  857. if (release)
  858. UnpinBuffer(bufHdr);
  859. SpinRelease(BufMgrLock);
  860. CommitInfoNeedsSave[buffer - 1] = 0;
  862. return STATUS_OK;
  863. }
  865. /*
  866.  * WriteNoReleaseBuffer -- like WriteBuffer, but do not unpin the buffer
  867.  *    when the operation is complete.
  868.  *
  869.  * We know that the buffer is for a relation in our private cache,
  870.  * because this routine is called only to write out buffers that
  871.  * were changed by the executing backend.
  872.  */
  873. int
  874. WriteNoReleaseBuffer(Buffer buffer)
  875. {
  876. BufferDesc *bufHdr;
  878. if (WriteMode == BUFFER_FLUSH_WRITE)
  879. return FlushBuffer(buffer, FALSE);
  880. else
  881. {
  883. if (BufferIsLocal(buffer))
  884. return WriteLocalBuffer(buffer, FALSE);
  886. if (BAD_BUFFER_ID(buffer))
  887. return STATUS_ERROR;
  889. bufHdr = &BufferDescriptors[buffer - 1];
  891. SharedBufferChanged = true;
  893. SpinAcquire(BufMgrLock);
  894. bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
  895. SpinRelease(BufMgrLock);
  896. CommitInfoNeedsSave[buffer - 1] = 0;
  897. }
  898. return STATUS_OK;
  899. }
  902. #undef ReleaseAndReadBuffer
  903. /*
  904.  * ReleaseAndReadBuffer -- combine ReleaseBuffer() and ReadBuffer()
  905.  * so that only one semop needs to be called.
  906.  *
  907.  */
  908. Buffer
  909. ReleaseAndReadBuffer(Buffer buffer,
  910.  Relation relation,
  911.  BlockNumber blockNum)
  912. {
  913. BufferDesc *bufHdr;
  914. Buffer retbuf;
  916. if (BufferIsLocal(buffer))
  917. {
  918. Assert(LocalRefCount[-buffer - 1] > 0);
  919. LocalRefCount[-buffer - 1]--;
  920. }
  921. else
  922. {
  923. if (BufferIsValid(buffer))
  924. {
  925. bufHdr = &BufferDescriptors[buffer - 1];
  926. Assert(PrivateRefCount[buffer - 1] > 0);
  927. PrivateRefCount[buffer - 1]--;
  928. if (PrivateRefCount[buffer - 1] == 0 &&
  929. LastRefCount[buffer - 1] == 0)
  930. {
  932. /*
  933.  * only release buffer if it is not pinned in previous
  934.  * ExecMain level
  935.  */
  936. SpinAcquire(BufMgrLock);
  937. bufHdr->refcount--;
  938. if (bufHdr->refcount == 0)
  939. {
  940. AddBufferToFreelist(bufHdr);
  941. bufHdr->flags |= BM_FREE;
  942. }
  943. if (CommitInfoNeedsSave[buffer - 1])
  944. {
  945. bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
  946. CommitInfoNeedsSave[buffer - 1] = 0;
  947. }
  948. retbuf = ReadBufferWithBufferLock(relation, blockNum, true);
  949. return retbuf;
  950. }
  951. }
  952. }
  954. return ReadBuffer(relation, blockNum);
  955. }
  957. /*
  958.  * BufferSync -- Flush all dirty buffers in the pool.
  959.  *
  960.  * This is called at transaction commit time. It does the wrong thing,
  961.  * right now. We should flush only our own changes to stable storage,
  962.  * and we should obey the lock protocol on the buffer manager metadata
  963.  * as we do it.  Also, we need to be sure that no other transaction is
  964.  * modifying the page as we flush it. This is only a problem for objects
  965.  * that use a non-two-phase locking protocol, like btree indices. For
  966.  * those objects, we would like to set a write lock for the duration of
  967.  * our IO.  Another possibility is to code updates to btree pages
  968.  * carefully, so that writing them out out of order cannot cause
  969.  * any unrecoverable errors.
  970.  *
  971.  * I don't want to think hard about this right now, so I will try
  972.  * to come back to it later.
  973.  */
  974. static void
  975. BufferSync()
  976. {
  977. int i;
  978. Oid bufdb;
  979. Oid bufrel;
  980. Relation reln;
  981. BufferDesc *bufHdr;
  982. int status;
  984. SpinAcquire(BufMgrLock);
  985. for (i = 0, bufHdr = BufferDescriptors; i < NBuffers; i++, bufHdr++)
  986. {
  987. if ((bufHdr->flags & BM_VALID) && (bufHdr->flags & BM_DIRTY))
  988. {
  989. bufdb = bufHdr->tag.relId.dbId;
  990. bufrel = bufHdr->tag.relId.relId;
  991. if (bufdb == MyDatabaseId || bufdb == (Oid) 0)
  992. {
  993. reln = RelationIdCacheGetRelation(bufrel);
  995. /*
  996.  * We have to pin buffer to keep anyone from stealing it
  997.  * from the buffer pool while we are flushing it or
  998.  * waiting in WaitIO. It's bad for GetFreeBuffer in
  999.  * BufferAlloc, but there is no other way to prevent
  1000.  * writing into disk block data from some other buffer,
  1001.  * getting smgr status of some other block and clearing
  1002.  * BM_DIRTY of ...   - VAdim 09/16/96
  1003.  */
  1004. PinBuffer(bufHdr);
  1005. if (bufHdr->flags & BM_IO_IN_PROGRESS)
  1006. {
  1007. WaitIO(bufHdr, BufMgrLock);
  1008. UnpinBuffer(bufHdr);
  1009. if (bufHdr->flags & BM_IO_ERROR)
  1010. {
  1011. elog(ERROR, "BufferSync: write error %u for %s",
  1012.  bufHdr->tag.blockNum, bufHdr->sb_relname);
  1013. }
  1014. if (reln != (Relation) NULL)
  1015. RelationDecrementReferenceCount(reln);
  1016. continue;
  1017. }
  1019. /*
  1020.  * To check if block content changed while flushing (see
  1021.  * below). - vadim 01/17/97
  1022.  */
  1023. bufHdr->flags &= ~BM_JUST_DIRTIED;
  1025. /*
  1026.  * If we didn't have the reldesc in our local cache, flush
  1027.  * this page out using the 'blind write' storage manager
  1028.  * routine.  If we did find it, use the standard
  1029.  * interface.
  1030.  */
  1032. #ifndef OPTIMIZE_SINGLE
  1033. SpinRelease(BufMgrLock);
  1034. #endif  /* OPTIMIZE_SINGLE */
  1035. if (reln == (Relation) NULL)
  1036. {
  1037. status = smgrblindwrt(DEFAULT_SMGR, bufHdr->sb_dbname,
  1038.    bufHdr->sb_relname, bufdb, bufrel,
  1039.   bufHdr->tag.blockNum,
  1040. (char *) MAKE_PTR(bufHdr->data));
  1041. }
  1042. else
  1043. {
  1044. status = smgrwrite(DEFAULT_SMGR, reln,
  1045.    bufHdr->tag.blockNum,
  1046.    (char *) MAKE_PTR(bufHdr->data));
  1047. }
  1048. #ifndef OPTIMIZE_SINGLE
  1049. SpinAcquire(BufMgrLock);
  1050. #endif  /* OPTIMIZE_SINGLE */
  1052. UnpinBuffer(bufHdr);
  1053. if (status == SM_FAIL)
  1054. {
  1055. bufHdr->flags |= BM_IO_ERROR;
  1056. elog(ERROR, "BufferSync: cannot write %u for %s",
  1057.  bufHdr->tag.blockNum, bufHdr->sb_relname);
  1058. }
  1059. BufferFlushCount++;
  1061. /*
  1062.  * If this buffer was marked by someone as DIRTY while we
  1063.  * were flushing it out we must not clear DIRTY flag -
  1064.  * vadim 01/17/97
  1065.  */
  1066. if (!(bufHdr->flags & BM_JUST_DIRTIED))
  1067. bufHdr->flags &= ~BM_DIRTY;
  1068. if (reln != (Relation) NULL)
  1069. RelationDecrementReferenceCount(reln);
  1070. }
  1071. }
  1072. }
  1073. SpinRelease(BufMgrLock);
  1075. LocalBufferSync();
  1076. }
  1079. /*
  1080.  * WaitIO -- Block until the IO_IN_PROGRESS flag on 'buf'
  1081.  * is cleared.  Because IO_IN_PROGRESS conflicts are
  1082.  * expected to be rare, there is only one BufferIO
  1083.  * lock in the entire system. All processes block
  1084.  * on this semaphore when they try to use a buffer
  1085.  * that someone else is faulting in.  Whenever a
  1086.  * process finishes an IO and someone is waiting for
  1087.  * the buffer, BufferIO is signaled (SignalIO).  All
  1088.  * waiting processes then wake up and check to see
  1089.  * if their buffer is now ready.  This implementation
  1090.  * is simple, but efficient enough if WaitIO is
  1091.  * rarely called by multiple processes simultaneously.
  1092.  *
  1093.  * ProcSleep atomically releases the spinlock and goes to
  1094.  * sleep.
  1095.  *
  1096.  * Note: there is an easy fix if the queue becomes long.
  1097.  * save the id of the buffer we are waiting for in
  1098.  * the queue structure.  That way signal can figure
  1099.  * out which proc to wake up.
  1100.  */
  1101. #ifdef HAS_TEST_AND_SET
  1102. static void
  1103. WaitIO(BufferDesc *buf, SPINLOCK spinlock)
  1104. {
  1105. SpinRelease(spinlock);
  1106. S_LOCK(&(buf->io_in_progress_lock));
  1107. S_UNLOCK(&(buf->io_in_progress_lock));
  1108. SpinAcquire(spinlock);
  1109. }
  1111. #else /* HAS_TEST_AND_SET */
  1112. IpcSemaphoreId WaitIOSemId;
  1113. IpcSemaphoreId WaitCLSemId;
  1115. static void
  1116. WaitIO(BufferDesc *buf, SPINLOCK spinlock)
  1117. {
  1118. bool inProgress;
  1120. for (;;)
  1121. {
  1123. /* wait until someone releases IO lock */
  1124. (*NWaitIOBackendP)++;
  1125. SpinRelease(spinlock);
  1126. IpcSemaphoreLock(WaitIOSemId, 0, 1);
  1127. SpinAcquire(spinlock);
  1128. inProgress = (buf->flags & BM_IO_IN_PROGRESS);
  1129. if (!inProgress)
  1130. break;
  1131. }
  1132. }
  1134. /*
  1135.  * SignalIO
  1136.  */
  1137. static void
  1138. SignalIO(BufferDesc *buf)
  1139. {
  1140. /* somebody better be waiting. */
  1141. Assert(buf->refcount > 1);
  1142. IpcSemaphoreUnlock(WaitIOSemId, 0, *NWaitIOBackendP);
  1143. *NWaitIOBackendP = 0;
  1144. }
  1146. #endif  /* HAS_TEST_AND_SET */
  1148. long NDirectFileRead; /* some I/O's are direct file access.
  1149.  * bypass bufmgr */
  1150. long NDirectFileWrite; /* e.g., I/O in psort and hashjoin. */
  1152. void
  1153. PrintBufferUsage(FILE *statfp)
  1154. {
  1155. float hitrate;
  1156. float localhitrate;
  1158. if (ReadBufferCount == 0)
  1159. hitrate = 0.0;
  1160. else
  1161. hitrate = (float) BufferHitCount *100.0 / ReadBufferCount;
  1163. if (ReadLocalBufferCount == 0)
  1164. localhitrate = 0.0;
  1165. else
  1166. localhitrate = (float) LocalBufferHitCount *100.0 / ReadLocalBufferCount;
  1168. fprintf(statfp, "!tShared blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%n",
  1169. ReadBufferCount - BufferHitCount, BufferFlushCount, hitrate);
  1170. fprintf(statfp, "!tLocal  blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%n",
  1171. ReadLocalBufferCount - LocalBufferHitCount, LocalBufferFlushCount, localhitrate);
  1172. fprintf(statfp, "!tDirect blocks: %10ld read, %10ld writtenn",
  1173. NDirectFileRead, NDirectFileWrite);
  1174. }
  1176. void
  1177. ResetBufferUsage()
  1178. {
  1179. BufferHitCount = 0;
  1180. ReadBufferCount = 0;
  1181. BufferFlushCount = 0;
  1182. LocalBufferHitCount = 0;
  1183. ReadLocalBufferCount = 0;
  1184. LocalBufferFlushCount = 0;
  1185. NDirectFileRead = 0;
  1186. NDirectFileWrite = 0;
  1187. }
  1189. /* ----------------------------------------------
  1190.  * ResetBufferPool
  1191.  *
  1192.  * this routine is supposed to be called when a transaction aborts.
  1193.  * it will release all the buffer pins held by the transaciton.
  1194.  *
  1195.  * ----------------------------------------------
  1196.  */
  1197. void
  1198. ResetBufferPool()
  1199. {
  1200. int i;
  1202. for (i = 1; i <= NBuffers; i++)
  1203. {
  1204. CommitInfoNeedsSave[i - 1] = 0;
  1205. if (BufferIsValid(i))
  1206. {
  1207. while (PrivateRefCount[i - 1] > 0)
  1208. ReleaseBuffer(i);
  1209. }
  1210. LastRefCount[i - 1] = 0;
  1211. }
  1213. ResetLocalBufferPool();
  1214. }
  1216. /* -----------------------------------------------
  1217.  * BufferPoolCheckLeak
  1218.  *
  1219.  * check if there is buffer leak
  1220.  *
  1221.  * -----------------------------------------------
  1222.  */
  1223. int
  1224. BufferPoolCheckLeak()
  1225. {
  1226. int i;
  1227. int result = 0;
  1229. for (i = 1; i <= NBuffers; i++)
  1230. {
  1231. if (BufferIsValid(i))
  1232. {
  1233. BufferDesc *buf = &(BufferDescriptors[i - 1]);
  1235. elog(NOTICE,
  1236.  "Buffer Leak: [%03d] (freeNext=%d, freePrev=%d, 
  1237. relname=%s, blockNum=%d, flags=0x%x, refcount=%d %d)",
  1238.  i - 1, buf->freeNext, buf->freePrev,
  1239.  buf->sb_relname, buf->tag.blockNum, buf->flags,
  1240.  buf->refcount, PrivateRefCount[i - 1]);
  1241. result = 1;
  1242. }
  1243. }
  1244. return (result);
  1245. }
  1247. /* ------------------------------------------------
  1248.  * FlushBufferPool
  1249.  *
  1250.  * flush all dirty blocks in buffer pool to disk
  1251.  *
  1252.  * ------------------------------------------------
  1253.  */
  1254. void
  1255. FlushBufferPool(int StableMainMemoryFlag)
  1256. {
  1257. if (!StableMainMemoryFlag)
  1258. {
  1259. BufferSync();
  1260. smgrcommit();
  1261. }
  1262. }
  1264. /*
  1265.  * BufferGetBlockNumber
  1266.  * Returns the block number associated with a buffer.
  1267.  *
  1268.  * Note:
  1269.  * Assumes that the buffer is valid.
  1270.  */
  1271. BlockNumber
  1272. BufferGetBlockNumber(Buffer buffer)
  1273. {
  1274. Assert(BufferIsValid(buffer));
  1276. /* XXX should be a critical section */
  1277. if (BufferIsLocal(buffer))
  1278. return LocalBufferDescriptors[-buffer - 1].tag.blockNum;
  1279. else
  1280. return BufferDescriptors[buffer - 1].tag.blockNum;
  1281. }
  1283. #ifdef NOT_USED
  1284. /*
  1285.  * BufferGetRelation
  1286.  * Returns the relation desciptor associated with a buffer.
  1287.  *
  1288.  * Note:
  1289.  * Assumes buffer is valid.
  1290.  */
  1291. Relation
  1292. BufferGetRelation(Buffer buffer)
  1293. {
  1294. Relation relation;
  1295. Oid relid;
  1297. Assert(BufferIsValid(buffer));
  1298. Assert(!BufferIsLocal(buffer)); /* not supported for local buffers */
  1300. /* XXX should be a critical section */
  1301. relid = BufferDescriptors[buffer - 1].tag.relId.relId;
  1302. relation = RelationIdGetRelation(relid);
  1304. RelationDecrementReferenceCount(relation);
  1306. if (RelationHasReferenceCountZero(relation))
  1307. {
  1309. /*
  1310.  * elog(NOTICE, "BufferGetRelation: 0->1");
  1311.  */
  1313. RelationIncrementReferenceCount(relation);
  1314. }
  1316. return relation;
  1317. }
  1319. #endif
  1321. /*
  1322.  * BufferReplace
  1323.  *
  1324.  * Flush the buffer corresponding to 'bufHdr'
  1325.  *
  1326.  */
  1327. static int
  1328. BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld)
  1329. {
  1330. Relation reln;
  1331. Oid bufdb,
  1332. bufrel;
  1333. int status;
  1335. if (!bufferLockHeld)
  1336. SpinAcquire(BufMgrLock);
  1338. /*
  1339.  * first try to find the reldesc in the cache, if no luck, don't
  1340.  * bother to build the reldesc from scratch, just do a blind write.
  1341.  */
  1343. bufdb = bufHdr->tag.relId.dbId;
  1344. bufrel = bufHdr->tag.relId.relId;
  1346. if (bufdb == MyDatabaseId || bufdb == (Oid) NULL)
  1347. reln = RelationIdCacheGetRelation(bufrel);
  1348. else
  1349. reln = (Relation) NULL;
  1351. /* To check if block content changed while flushing. - vadim 01/17/97 */
  1352. bufHdr->flags &= ~BM_JUST_DIRTIED;
  1354. SpinRelease(BufMgrLock);
  1356. if (reln != (Relation) NULL)
  1357. {
  1358. status = smgrflush(DEFAULT_SMGR, reln, bufHdr->tag.blockNum,
  1359.    (char *) MAKE_PTR(bufHdr->data));
  1360. }
  1361. else
  1362. {
  1364. /* blind write always flushes */
  1365. status = smgrblindwrt(DEFAULT_SMGR, bufHdr->sb_dbname,
  1366.   bufHdr->sb_relname, bufdb, bufrel,
  1367.   bufHdr->tag.blockNum,
  1368.   (char *) MAKE_PTR(bufHdr->data));
  1369. }
  1371. if (reln != (Relation) NULL)
  1372. RelationDecrementReferenceCount(reln);
  1374. if (status == SM_FAIL)
  1375. return FALSE;
  1377. BufferFlushCount++;
  1379. return TRUE;
  1380. }
  1382. /*
  1383.  * RelationGetNumberOfBlocks
  1384.  * Returns the buffer descriptor associated with a page in a relation.
  1385.  *
  1386.  * Note:
  1387.  * XXX may fail for huge relations.
  1388.  * XXX should be elsewhere.
  1389.  * XXX maybe should be hidden
  1390.  */
  1391. BlockNumber
  1392. RelationGetNumberOfBlocks(Relation relation)
  1393. {
  1394. return ((relation->rd_myxactonly) ? relation->rd_nblocks :
  1395. smgrnblocks(DEFAULT_SMGR, relation));
  1396. }
  1398. /* ---------------------------------------------------------------------
  1399.  * ReleaseRelationBuffers
  1400.  *
  1401.  * this function unmarks all the dirty pages of a relation
  1402.  * in the buffer pool so that at the end of transaction
  1403.  * these pages will not be flushed.
  1404.  * XXX currently it sequentially searches the buffer pool, should be
  1405.  * changed to more clever ways of searching.
  1406.  * --------------------------------------------------------------------
  1407.  */
  1408. void
  1409. ReleaseRelationBuffers(Relation rel)
  1410. {
  1411. int i;
  1412. int holding = 0;
  1413. BufferDesc *buf;
  1415. if (rel->rd_myxactonly)
  1416. {
  1417. for (i = 0; i < NLocBuffer; i++)
  1418. {
  1419. buf = &LocalBufferDescriptors[i];
  1420. if ((buf->flags & BM_DIRTY) &&
  1421. (buf->tag.relId.relId == RelationGetRelid(rel)))
  1422. buf->flags &= ~BM_DIRTY;
  1423. }
  1424. return;
  1425. }
  1427. for (i = 1; i <= NBuffers; i++)
  1428. {
  1429. buf = &BufferDescriptors[i - 1];
  1430. if (!holding)
  1431. {
  1432. SpinAcquire(BufMgrLock);
  1433. holding = 1;
  1434. }
  1435. if ((buf->flags & BM_DIRTY) &&
  1436. (buf->tag.relId.dbId == MyDatabaseId) &&
  1437. (buf->tag.relId.relId == RelationGetRelid(rel)))
  1438. {
  1439. buf->flags &= ~BM_DIRTY;
  1440. if (!(buf->flags & BM_FREE))
  1441. {
  1442. SpinRelease(BufMgrLock);
  1443. holding = 0;
  1444. ReleaseBuffer(i);
  1445. }
  1446. }
  1447. }
  1448. if (holding)
  1449. SpinRelease(BufMgrLock);
  1450. }
  1452. /* ---------------------------------------------------------------------
  1453.  * DropBuffers
  1454.  *
  1455.  * This function marks all the buffers in the buffer cache for a
  1456.  * particular database as clean.  This is used when we destroy a
  1457.  * database, to avoid trying to flush data to disk when the directory
  1458.  * tree no longer exists.
  1459.  *
  1460.  * This is an exceedingly non-public interface.
  1461.  * --------------------------------------------------------------------
  1462.  */
  1463. void
  1464. DropBuffers(Oid dbid)
  1465. {
  1466. int i;
  1467. BufferDesc *buf;
  1469. SpinAcquire(BufMgrLock);
  1470. for (i = 1; i <= NBuffers; i++)
  1471. {
  1472. buf = &BufferDescriptors[i - 1];
  1473. if ((buf->tag.relId.dbId == dbid) && (buf->flags & BM_DIRTY))
  1474. buf->flags &= ~BM_DIRTY;
  1475. }
  1476. SpinRelease(BufMgrLock);
  1477. }
  1479. /* -----------------------------------------------------------------
  1480.  * PrintBufferDescs
  1481.  *
  1482.  * this function prints all the buffer descriptors, for debugging
  1483.  * use only.
  1484.  * -----------------------------------------------------------------
  1485.  */
  1486. void
  1487. PrintBufferDescs()
  1488. {
  1489. int i;
  1490. BufferDesc *buf = BufferDescriptors;
  1492. if (IsUnderPostmaster)
  1493. {
  1494. SpinAcquire(BufMgrLock);
  1495. for (i = 0; i < NBuffers; ++i, ++buf)
  1496. {
  1497. elog(DEBUG, "[%02d] (freeNext=%d, freePrev=%d, relname=%s, 
  1498. blockNum=%d, flags=0x%x, refcount=%d %d)",
  1499.  i, buf->freeNext, buf->freePrev,
  1500.  buf->sb_relname, buf->tag.blockNum, buf->flags,
  1501.  buf->refcount, PrivateRefCount[i]);
  1502. }
  1503. SpinRelease(BufMgrLock);
  1504. }
  1505. else
  1506. {
  1507. /* interactive backend */
  1508. for (i = 0; i < NBuffers; ++i, ++buf)
  1509. {
  1510. printf("[%-2d] (%s, %d) flags=0x%x, refcnt=%d %ld)n",
  1511.    i, buf->sb_relname, buf->tag.blockNum,
  1512.    buf->flags, buf->refcount, PrivateRefCount[i]);
  1513. }
  1514. }
  1515. }
  1517. void
  1518. PrintPinnedBufs()
  1519. {
  1520. int i;
  1521. BufferDesc *buf = BufferDescriptors;
  1523. SpinAcquire(BufMgrLock);
  1524. for (i = 0; i < NBuffers; ++i, ++buf)
  1525. {
  1526. if (PrivateRefCount[i] > 0)
  1527. elog(NOTICE, "[%02d] (freeNext=%d, freePrev=%d, relname=%s, 
  1528. blockNum=%d, flags=0x%x, refcount=%d %d)n",
  1529.  i, buf->freeNext, buf->freePrev, buf->sb_relname,
  1530.  buf->tag.blockNum, buf->flags,
  1531.  buf->refcount, PrivateRefCount[i]);
  1532. }
  1533. SpinRelease(BufMgrLock);
  1534. }
  1536. /*
  1537.  * BufferPoolBlowaway
  1538.  *
  1539.  * this routine is solely for the purpose of experiments -- sometimes
  1540.  * you may want to blowaway whatever is left from the past in buffer
  1541.  * pool and start measuring some performance with a clean empty buffer
  1542.  * pool.
  1543.  */
  1544. #ifdef NOT_USED
  1545. void
  1546. BufferPoolBlowaway()
  1547. {
  1548. int i;
  1550. BufferSync();
  1551. for (i = 1; i <= NBuffers; i++)
  1552. {
  1553. if (BufferIsValid(i))
  1554. {
  1555. while (BufferIsValid(i))
  1556. ReleaseBuffer(i);
  1557. }
  1558. BufTableDelete(&BufferDescriptors[i - 1]);
  1559. }
  1560. }
  1562. #endif
  1564. /* ---------------------------------------------------------------------
  1565.  * BlowawayRelationBuffers
  1566.  *
  1567.  * This function blowaway all the pages with blocknumber >= passed
  1568.  * of a relation in the buffer pool. Used by vacuum before truncation...
  1569.  *
  1570.  * Returns: 0 - Ok, -1 - DIRTY, -2 - PINNED
  1571.  *
  1572.  * XXX currently it sequentially searches the buffer pool, should be
  1573.  * changed to more clever ways of searching.
  1574.  * --------------------------------------------------------------------
  1575.  */
  1576. int
  1577. BlowawayRelationBuffers(Relation rel, BlockNumber block)
  1578. {
  1579. int i;
  1580. BufferDesc *buf;
  1582. if (rel->rd_myxactonly)
  1583. {
  1584. for (i = 0; i < NLocBuffer; i++)
  1585. {
  1586. buf = &LocalBufferDescriptors[i];
  1587. if (buf->tag.relId.relId == RelationGetRelid(rel) &&
  1588. buf->tag.blockNum >= block)
  1589. {
  1590. if (buf->flags & BM_DIRTY)
  1591. {
  1592. elog(NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is dirty",
  1593. rel->rd_rel->relname.data, block, buf->tag.blockNum);
  1594. return -1;
  1595. }
  1596. if (LocalRefCount[i] > 0)
  1597. {
  1598. elog(NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is referenced (%d)",
  1599.  rel->rd_rel->relname.data, block,
  1600.  buf->tag.blockNum, LocalRefCount[i]);
  1601. return -2;
  1602. }
  1603. buf->tag.relId.relId = InvalidOid;
  1604. }
  1605. }
  1606. return 0;
  1607. }
  1609. SpinAcquire(BufMgrLock);
  1610. for (i = 0; i < NBuffers; i++)
  1611. {
  1612. buf = &BufferDescriptors[i];
  1613. if (buf->tag.relId.dbId == MyDatabaseId &&
  1614. buf->tag.relId.relId == RelationGetRelid(rel) &&
  1615. buf->tag.blockNum >= block)
  1616. {
  1617. if (buf->flags & BM_DIRTY)
  1618. {
  1619. elog(NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is dirty (private %d, last %d, global %d)",
  1620.  buf->sb_relname, block, buf->tag.blockNum,
  1621.  PrivateRefCount[i], LastRefCount[i], buf->refcount);
  1622. SpinRelease(BufMgrLock);
  1623. return -1;
  1624. }
  1625. if (!(buf->flags & BM_FREE))
  1626. {
  1627. elog(NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is referenced (private %d, last %d, global %d)",
  1628.  buf->sb_relname, block, buf->tag.blockNum,
  1629.  PrivateRefCount[i], LastRefCount[i], buf->refcount);
  1630. SpinRelease(BufMgrLock);
  1631. return -2;
  1632. }
  1633. BufTableDelete(buf);
  1634. }
  1635. }
  1636. SpinRelease(BufMgrLock);
  1637. return 0;
  1638. }
  1640. #undef ReleaseBuffer
  1642. /*
  1643.  * ReleaseBuffer -- remove the pin on a buffer without
  1644.  * marking it dirty.
  1645.  *
  1646.  */
  1647. int
  1648. ReleaseBuffer(Buffer buffer)
  1649. {
  1650. BufferDesc *bufHdr;
  1652. if (BufferIsLocal(buffer))
  1653. {
  1654. Assert(LocalRefCount[-buffer - 1] > 0);
  1655. LocalRefCount[-buffer - 1]--;
  1656. return STATUS_OK;
  1657. }
  1659. if (BAD_BUFFER_ID(buffer))
  1660. return STATUS_ERROR;
  1662. bufHdr = &BufferDescriptors[buffer - 1];
  1664. Assert(PrivateRefCount[buffer - 1] > 0);
  1665. PrivateRefCount[buffer - 1]--;
  1666. if (PrivateRefCount[buffer - 1] == 0 && LastRefCount[buffer - 1] == 0)
  1667. {
  1669. /*
  1670.  * only release buffer if it is not pinned in previous ExecMain
  1671.  * levels
  1672.  */
  1673. SpinAcquire(BufMgrLock);
  1674. bufHdr->refcount--;
  1675. if (bufHdr->refcount == 0)
  1676. {
  1677. AddBufferToFreelist(bufHdr);
  1678. bufHdr->flags |= BM_FREE;
  1679. }
  1680. if (CommitInfoNeedsSave[buffer - 1])
  1681. {
  1682. bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
  1683. CommitInfoNeedsSave[buffer - 1] = 0;
  1684. }
  1685. SpinRelease(BufMgrLock);
  1686. }
  1688. return STATUS_OK;
  1689. }
  1691. #ifdef NOT_USED
  1692. void
  1693. IncrBufferRefCount_Debug(char *file, int line, Buffer buffer)
  1694. {
  1695. IncrBufferRefCount(buffer);
  1696. if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer))
  1697. {
  1698. BufferDesc *buf = &BufferDescriptors[buffer - 1];
  1700. fprintf(stderr, "PIN(Incr) %ld relname = %s, blockNum = %d, 
  1701. refcount = %ld, file: %s, line: %dn",
  1702. buffer, buf->sb_relname, buf->tag.blockNum,
  1703. PrivateRefCount[buffer - 1], file, line);
  1704. }
  1705. }
  1707. #endif
  1709. #ifdef NOT_USED
  1710. void
  1711. ReleaseBuffer_Debug(char *file, int line, Buffer buffer)
  1712. {
  1713. ReleaseBuffer(buffer);
  1714. if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer))
  1715. {
  1716. BufferDesc *buf = &BufferDescriptors[buffer - 1];
  1718. fprintf(stderr, "UNPIN(Rel) %ld relname = %s, blockNum = %d, 
  1719. refcount = %ld, file: %s, line: %dn",
  1720. buffer, buf->sb_relname, buf->tag.blockNum,
  1721. PrivateRefCount[buffer - 1], file, line);
  1722. }
  1723. }
  1725. #endif
  1727. #ifdef NOT_USED
  1728. int
  1729. ReleaseAndReadBuffer_Debug(char *file,
  1730.    int line,
  1731.    Buffer buffer,
  1732.    Relation relation,
  1733.    BlockNumber blockNum)
  1734. {
  1735. bool bufferValid;
  1736. Buffer b;
  1738. bufferValid = BufferIsValid(buffer);
  1739. b = ReleaseAndReadBuffer(buffer, relation, blockNum);
  1740. if (ShowPinTrace && bufferValid && BufferIsLocal(buffer)
  1741. && is_userbuffer(buffer))
  1742. {
  1743. BufferDesc *buf = &BufferDescriptors[buffer - 1];
  1745. fprintf(stderr, "UNPIN(Rel&Rd) %ld relname = %s, blockNum = %d, 
  1746. refcount = %ld, file: %s, line: %dn",
  1747. buffer, buf->sb_relname, buf->tag.blockNum,
  1748. PrivateRefCount[buffer - 1], file, line);
  1749. }
  1750. if (ShowPinTrace && BufferIsLocal(buffer) && is_userbuffer(buffer))
  1751. {
  1752. BufferDesc *buf = &BufferDescriptors[b - 1];
  1754. fprintf(stderr, "PIN(Rel&Rd) %ld relname = %s, blockNum = %d, 
  1755. refcount = %ld, file: %s, line: %dn",
  1756. b, buf->sb_relname, buf->tag.blockNum,
  1757. PrivateRefCount[b - 1], file, line);
  1758. }
  1759. return b;
  1760. }
  1762. #endif
  1764. #ifdef BMTRACE
  1766. /*
  1767.  * trace allocations and deallocations in a circular buffer in
  1768.  * shared memory. check the buffer before doing the allocation,
  1769.  * and die if there's anything fishy.
  1770.  */
  1772. _bm_trace(Oid dbId, Oid relId, int blkNo, int bufNo, int allocType)
  1773. {
  1774. long start,
  1775. cur;
  1776. bmtrace    *tb;
  1778. start = *CurTraceBuf;
  1780. if (start > 0)
  1781. cur = start - 1;
  1782. else
  1783. cur = BMT_LIMIT - 1;
  1785. for (;;)
  1786. {
  1787. tb = &TraceBuf[cur];
  1788. if (tb->bmt_op != BMT_NOTUSED)
  1789. {
  1790. if (tb->bmt_buf == bufNo)
  1791. {
  1792. if ((tb->bmt_op == BMT_DEALLOC)
  1793. || (tb->bmt_dbid == dbId && tb->bmt_relid == relId
  1794. && tb->bmt_blkno == blkNo))
  1795. goto okay;
  1797. /* die holding the buffer lock */
  1798. _bm_die(dbId, relId, blkNo, bufNo, allocType, start, cur);
  1799. }
  1800. }
  1802. if (cur == start)
  1803. goto okay;
  1805. if (cur == 0)
  1806. cur = BMT_LIMIT - 1;
  1807. else
  1808. cur--;
  1809. }
  1811. okay:
  1812. tb = &TraceBuf[start];
  1813. tb->bmt_pid = MyProcPid;
  1814. tb->bmt_buf = bufNo;
  1815. tb->bmt_dbid = dbId;
  1816. tb->bmt_relid = relId;
  1817. tb->bmt_blkno = blkNo;
  1818. tb->bmt_op = allocType;
  1820. *CurTraceBuf = (start + 1) % BMT_LIMIT;
  1821. }
  1823. _bm_die(Oid dbId, Oid relId, int blkNo, int bufNo,
  1824. int allocType, long start, long cur)
  1825. {
  1826. FILE    *fp;
  1827. bmtrace    *tb;
  1828. int i;
  1830. tb = &TraceBuf[cur];
  1832. if ((fp = AllocateFile("/tmp/death_notice", "w")) == NULL)
  1833. elog(FATAL, "buffer alloc trace error and can't open log file");
  1835. fprintf(fp, "buffer alloc trace detected the following error:nn");
  1836. fprintf(fp, "    buffer %d being %s inconsistently with a previous %snn",
  1837.  bufNo, (allocType == BMT_DEALLOC ? "deallocated" : "allocated"),
  1838. (tb->bmt_op == BMT_DEALLOC ? "deallocation" : "allocation"));
  1840. fprintf(fp, "the trace buffer contains:n");
  1842. i = start;
  1843. for (;;)
  1844. {
  1845. tb = &TraceBuf[i];
  1846. if (tb->bmt_op != BMT_NOTUSED)
  1847. {
  1848. fprintf(fp, "     [%3d]%spid %d buf %2d for <%d,%u,%d> ",
  1849. i, (i == cur ? " ---> " : "t"),
  1850. tb->bmt_pid, tb->bmt_buf,
  1851. tb->bmt_dbid, tb->bmt_relid, tb->bmt_blkno);
  1853. switch (tb->bmt_op)
  1854. {
  1855. case BMT_ALLOCFND:
  1856. fprintf(fp, "allocate (found)n");
  1857. break;
  1859. case BMT_ALLOCNOTFND:
  1860. fprintf(fp, "allocate (not found)n");
  1861. break;
  1863. case BMT_DEALLOC:
  1864. fprintf(fp, "deallocaten");
  1865. break;
  1867. default:
  1868. fprintf(fp, "unknown op type %dn", tb->bmt_op);
  1869. break;
  1870. }
  1871. }
  1873. i = (i + 1) % BMT_LIMIT;
  1874. if (i == start)
  1875. break;
  1876. }
  1878. fprintf(fp, "noperation causing error:n");
  1879. fprintf(fp, "tpid %d buf %d for <%d,%u,%d> ",
  1880. getpid(), bufNo, dbId, relId, blkNo);
  1882. switch (allocType)
  1883. {
  1884. case BMT_ALLOCFND:
  1885. fprintf(fp, "allocate (found)n");
  1886. break;
  1888. case BMT_ALLOCNOTFND:
  1889. fprintf(fp, "allocate (not found)n");
  1890. break;
  1892. case BMT_DEALLOC:
  1893. fprintf(fp, "deallocaten");
  1894. break;
  1896. default:
  1897. fprintf(fp, "unknown op type %dn", allocType);
  1898. break;
  1899. }
  1901. FreeFile(fp);
  1903. kill(getpid(), SIGILL);
  1904. }
  1906. #endif  /* BMTRACE */
  1908. void
  1909. BufferRefCountReset(int *refcountsave)
  1910. {
  1911. int i;
  1913. for (i = 0; i < NBuffers; i++)
  1914. {
  1915. refcountsave[i] = PrivateRefCount[i];
  1916. LastRefCount[i] += PrivateRefCount[i];
  1917. PrivateRefCount[i] = 0;
  1918. }
  1919. }
  1921. void
  1922. BufferRefCountRestore(int *refcountsave)
  1923. {
  1924. int i;
  1926. for (i = 0; i < NBuffers; i++)
  1927. {
  1928. PrivateRefCount[i] = refcountsave[i];
  1929. LastRefCount[i] -= refcountsave[i];
  1930. refcountsave[i] = 0;
  1931. }
  1932. }
  1934. int
  1935. SetBufferWriteMode(int mode)
  1936. {
  1937. int old;
  1939. old = WriteMode;
  1940. WriteMode = mode;
  1941. return old;
  1942. }
  1944. void
  1945. SetBufferCommitInfoNeedsSave(Buffer buffer)
  1946. {
  1947. if (!BufferIsLocal(buffer))
  1948. CommitInfoNeedsSave[buffer - 1]++;
  1949. }
  1951. void
  1952. UnlockBuffers()
  1953. {
  1954. BufferDesc *buf;
  1955. int i;
  1957. for (i = 0; i < NBuffers; i++)
  1958. {
  1959. if (BufferLocks[i] == 0)
  1960. continue;
  1962. Assert(BufferIsValid(i + 1));
  1963. buf = &(BufferDescriptors[i]);
  1965. #ifdef HAS_TEST_AND_SET
  1966. S_LOCK(&(buf->cntx_lock));
  1967. #else
  1968. IpcSemaphoreLock(WaitCLSemId, 0, IpcExclusiveLock);
  1969. #endif
  1971. if (BufferLocks[i] & BL_R_LOCK)
  1972. {
  1973. Assert(buf->r_locks > 0);
  1974. (buf->r_locks)--;
  1975. }
  1976. if (BufferLocks[i] & BL_RI_LOCK)
  1977. {
  1978. /* 
  1979.  * Someone else could remove our RI lock when acquiring
  1980.  * W lock. This is possible if we came here from elog(ERROR)
  1981.  * from IpcSemaphore{Lock|Unlock}(WaitCLSemId). And so we
  1982.  * don't do Assert(buf->ri_lock) here.
  1983.  */
  1984. buf->ri_lock = false;
  1985. }
  1986. if (BufferLocks[i] & BL_W_LOCK)
  1987. {
  1988. Assert(buf->w_lock);
  1989. buf->w_lock = false;
  1990. }
  1991. #ifdef HAS_TEST_AND_SET
  1992. S_UNLOCK(&(buf->cntx_lock));
  1993. #else
  1994. IpcSemaphoreUnlock(WaitCLSemId, 0, IpcExclusiveLock);
  1995. #endif
  1996. BufferLocks[i] = 0;
  1997. }
  1998. }
  2000. void
  2001. LockBuffer(Buffer buffer, int mode)
  2002. {
  2003. BufferDesc *buf;
  2005. Assert(BufferIsValid(buffer));
  2006. if (BufferIsLocal(buffer))
  2007. return;
  2009. buf = &(BufferDescriptors[buffer - 1]);
  2011. #ifdef HAS_TEST_AND_SET
  2012. S_LOCK(&(buf->cntx_lock));
  2013. #else
  2014. IpcSemaphoreLock(WaitCLSemId, 0, IpcExclusiveLock);
  2015. #endif
  2017. if (mode == BUFFER_LOCK_UNLOCK)
  2018. {
  2019. if (BufferLocks[buffer - 1] & BL_R_LOCK)
  2020. {
  2021. Assert(buf->r_locks > 0);
  2022. Assert(!(buf->w_lock));
  2023. Assert(!(BufferLocks[buffer - 1] & (BL_W_LOCK | BL_RI_LOCK)))
  2024. (buf->r_locks)--;
  2025. BufferLocks[buffer - 1] &= ~BL_R_LOCK;
  2026. }
  2027. else if (BufferLocks[buffer - 1] & BL_W_LOCK)
  2028. {
  2029. Assert(buf->w_lock);
  2030. Assert(buf->r_locks == 0);
  2031. Assert(!(BufferLocks[buffer - 1] & (BL_R_LOCK | BL_RI_LOCK)))
  2032. buf->w_lock = false;
  2033. BufferLocks[buffer - 1] &= ~BL_W_LOCK;
  2034. }
  2035. else
  2036. elog(ERROR, "UNLockBuffer: buffer %u is not locked", buffer);
  2037. }
  2038. else if (mode == BUFFER_LOCK_SHARE)
  2039. {
  2040. unsigned i = 0;
  2042. Assert(!(BufferLocks[buffer - 1] & (BL_R_LOCK | BL_W_LOCK | BL_RI_LOCK)));
  2043. while (buf->ri_lock || buf->w_lock)
  2044. {
  2045. #ifdef HAS_TEST_AND_SET
  2046. S_UNLOCK(&(buf->cntx_lock));
  2047. s_lock_sleep(i++);
  2048. S_LOCK(&(buf->cntx_lock));
  2049. #else
  2050. IpcSemaphoreUnlock(WaitCLSemId, 0, IpcExclusiveLock);
  2051. s_lock_sleep(i++);
  2052. IpcSemaphoreLock(WaitCLSemId, 0, IpcExclusiveLock);
  2053. #endif
  2054. }
  2055. (buf->r_locks)++;
  2056. BufferLocks[buffer - 1] |= BL_R_LOCK;
  2057. }
  2058. else if (mode == BUFFER_LOCK_EXCLUSIVE)
  2059. {
  2060. unsigned i = 0;
  2062. Assert(!(BufferLocks[buffer - 1] & (BL_R_LOCK | BL_W_LOCK | BL_RI_LOCK)));
  2063. while (buf->r_locks > 0 || buf->w_lock)
  2064. {
  2065. if (buf->r_locks > 3 || (BufferLocks[buffer - 1] & BL_RI_LOCK))
  2066. {
  2067. /*
  2068.  * Our RI lock might be removed by concurrent W lock
  2069.  * acquiring (see what we do with RI locks below
  2070.  * when our own W acquiring succeeded) and so
  2071.  * we set RI lock again if we already did this.
  2072.  */
  2073. BufferLocks[buffer - 1] |= BL_RI_LOCK;
  2074. buf->ri_lock = true;
  2075. }
  2076. #ifdef HAS_TEST_AND_SET
  2077. S_UNLOCK(&(buf->cntx_lock));
  2078. s_lock_sleep(i++);
  2079. S_LOCK(&(buf->cntx_lock));
  2080. #else
  2081. IpcSemaphoreUnlock(WaitCLSemId, 0, IpcExclusiveLock);
  2082. s_lock_sleep(i++);
  2083. IpcSemaphoreLock(WaitCLSemId, 0, IpcExclusiveLock);
  2084. #endif
  2085. }
  2086. buf->w_lock = true;
  2087. BufferLocks[buffer - 1] |= BL_W_LOCK;
  2088. if (BufferLocks[buffer - 1] & BL_RI_LOCK)
  2089. {
  2090. /*
  2091.  * It's possible to remove RI locks acquired by another
  2092.  * W lockers here, but they'll take care about it.
  2093.  */
  2094. buf->ri_lock = false;
  2095. BufferLocks[buffer - 1] &= ~BL_RI_LOCK;
  2096. }
  2097. }
  2098. else
  2099. elog(ERROR, "LockBuffer: unknown lock mode %d", mode);
  2101. #ifdef HAS_TEST_AND_SET
  2102. S_UNLOCK(&(buf->cntx_lock));
  2103. #else
  2104. IpcSemaphoreUnlock(WaitCLSemId, 0, IpcExclusiveLock);
  2105. #endif
  2107. }