home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / storage / buffer / bufmgr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  43.2 KB  |  1,735 lines
  1. /*
  2.  * bufmgr.c -- buffer manager interface routines
  3.  *
  4.  * Identification:
  5.  *    $Header: /private/postgres/src/storage/buffer/RCS/bufmgr.c,v 1.74 1992/07/13 17:37:28 hong Exp $
  6.  *
  7.  * BufferAlloc() -- lookup a buffer in the buffer table.  If
  8.  *    it isn't there add it, but do not read it into memory.
  9.  *    This is used when we are about to reinitialize the
  10.  *    buffer so don't care what the current disk contents are.
  11.  *    BufferAlloc() pins the new buffer in memory.
  12.  *
  13.  * ReadBuffer() -- same as BufferAlloc() but reads the data
  14.  *    on a buffer cache miss.
  15.  *
  16.  * ReleaseBuffer() -- unpin the buffer
  17.  *
  18.  * WriteNoReleaseBuffer() -- mark the buffer contents as "dirty"
  19.  *    but don't unpin.  The disk IO is delayed until buffer
  20.  *    replacement if LateWrite flag is set.
  21.  *
  22.  * WriteBuffer() -- WriteNoReleaseBuffer() + ReleaseBuffer() 
  23.  *
  24.  * DirtyBufferCopy() -- For a given dbid/relid/blockno, if the buffer is
  25.  *            in the cache and is dirty, mark it clean and copy
  26.  *            it to the requested location.  This is a logical
  27.  *            write, and has been installed to support the cache
  28.  *            management code for write-once storage managers.
  29.  *
  30.  * FlushBuffer() -- as above but never delayed write.
  31.  *
  32.  * BufferSync() -- flush all dirty buffers in the buffer pool.
  33.  * 
  34.  * InitBufferPool() -- Init the buffer module.
  35.  *
  36.  * See other files:  
  37.  *     freelist.c -- chooses victim for buffer replacement 
  38.  *    buf_table.c -- manages the buffer lookup table
  39.  */
  40. #include <sys/file.h>
  41. #include <stdio.h>
  42. #include <math.h>
  43. #include <signal.h>
  44.  
  45. #include "storage/buf_internals.h"
  46. #include "storage/bufmgr.h"
  47.  
  48. #include "storage/fd.h"
  49. #include "storage/ipc.h"
  50. #include "storage/ipci.h"
  51. #include "storage/shmem.h"
  52. #include "storage/spin.h"
  53. #include "storage/smgr.h"
  54. #include "storage/lmgr.h"
  55. #include "tmp/miscadmin.h"
  56. #include "utils/hsearch.h"
  57. #include "utils/log.h"
  58.  
  59. /*
  60.  *  if BMTRACE is defined, we trace the last 200 buffer allocations and
  61.  *  deallocations in a circular buffer in shared memory.
  62.  */
  63. #ifdef    BMTRACE
  64. bmtrace    *TraceBuf;
  65. int    *CurTraceBuf;
  66. #define    BMT_LIMIT    200
  67. #endif /* BMTRACE */
  68.  
  69. int        NBuffers = NDBUFS;  /* NDBUFS defined in miscadmin.h */
  70. int        Data_Descriptors;
  71. int        Free_List_Descriptor;
  72. int        Lookup_List_Descriptor;
  73. int        Num_Descriptors;
  74.  
  75. BufferDesc     *BufferDescriptors;
  76. BufferBlock     BufferBlocks;
  77. #ifndef HAS_TEST_AND_SET
  78. static int    *NWaitIOBackendP;
  79. #endif
  80.  
  81. Buffer           BufferDescriptorGetBuffer();
  82.  
  83. int    *PrivateRefCount;
  84. int    *LastRefCount;  /* refcounts of last ExecMain level */
  85.  
  86. /*
  87.  * Data Structures:
  88.  *      buffers live in a freelist and a lookup data structure.
  89.  *    
  90.  *
  91.  * Buffer Lookup:
  92.  *    Two important notes.  First, the buffer has to be
  93.  *    available for lookup BEFORE an IO begins.  Otherwise
  94.  *    a second process trying to read the buffer will 
  95.  *    allocate its own copy and the buffeer pool will 
  96.  *    become inconsistent.
  97.  *
  98.  * Buffer Replacement:
  99.  *    see freelist.c.  A buffer cannot be replaced while in
  100.  *    use either by data manager or during IO.
  101.  *
  102.  * WriteBufferBack:
  103.  *    currently, a buffer is only written back at the time
  104.  *    it is selected for replacement.  It should 
  105.  *    be done sooner if possible to reduce latency of 
  106.  *    BufferAlloc().  Maybe there should be a daemon process.
  107.  *
  108.  * Synchronization/Locking:
  109.  *
  110.  * BufMgrLock lock -- must be acquired before manipulating the 
  111.  *     buffer queues (lookup/freelist).  Must be released 
  112.  *     before exit and before doing any IO.  
  113.  *
  114.  * IO_IN_PROGRESS -- this is a flag in the buffer descriptor.
  115.  *      It must be set when an IO is initiated and cleared at
  116.  *      the end of  the IO.  It is there to make sure that one
  117.  *    process doesn't start to use a buffer while another is
  118.  *    faulting it in.  see IOWait/IOSignal.
  119.  *
  120.  * refcount --  A buffer is pinned during IO and immediately
  121.  *    after a BufferAlloc().  A buffer is always either pinned
  122.  *    or on the freelist but never both.  The buffer must be
  123.  *    released, written, or flushed before the end of 
  124.  *     transaction.
  125.  *
  126.  * PrivateRefCount -- Each buffer also has a private refcount the keeps
  127.  *    track of the number of times the buffer is pinned in the current
  128.  *    processes.  This is used for two purposes, first, if we pin a
  129.  *    a buffer more than once, we only need to change the shared refcount
  130.  *    once, thus only lock the buffer pool once, second, when a transaction
  131.  *    aborts, it should only unpin the buffers exactly the number of times it
  132.  *    has pinned them, so that it will not blow away buffers of another
  133.  *    backend.
  134.  *
  135.  */
  136.  
  137. SPINLOCK BufMgrLock;
  138.  
  139. /* delayed write: TRUE on, FALSE off */
  140. int LateWrite = TRUE;
  141.  
  142. int ReadBufferCount;
  143. int BufferHitCount;
  144. int BufferFlushCount;
  145.  
  146. /* ---------------------------------------------------
  147.  * RelationGetBufferWithBuffer
  148.  *    see if the given buffer is what we want
  149.  *    if yes, we don't need to bother the buffer manager
  150.  * ---------------------------------------------------
  151.  */
  152. Buffer
  153. RelationGetBufferWithBuffer(relation, blockNumber, buffer)
  154. Relation relation;
  155. BlockNumber blockNumber;
  156. Buffer buffer;
  157. {
  158.     BufferDesc *bufHdr;
  159.     LRelId lrelId;
  160.  
  161.     if (BufferIsValid(buffer)) {
  162.         bufHdr = BufferGetBufferDescriptor(buffer);
  163.     lrelId = RelationGetLRelId(relation);
  164.     if (bufHdr->tag.blockNum == blockNumber &&
  165.         bufHdr->tag.relId.relId == lrelId.relId &&
  166.         bufHdr->tag.relId.dbId == lrelId.dbId)
  167.         return buffer;
  168.       }
  169.     return(ReadBuffer(relation,blockNumber));
  170. }
  171.  
  172. /*
  173.  * ReadBuffer -- returns a buffer containing the requested
  174.  *    block of the requested relation.  If the blknum
  175.  *    requested is NEW_BLOCK, extend the relation file and
  176.  *    allocate a new block.
  177.  *
  178.  * Returns: the buffer number for the buffer containing
  179.  *    the block read or NULL on an error.
  180.  *
  181.  * Assume when this function is called, that reln has been
  182.  *    opened already.
  183.  */
  184.  
  185. extern int ShowPinTrace;
  186. #undef ReadBuffer
  187.  
  188. Buffer
  189. ReadBuffer(reln, blockNum)
  190. Relation    reln;
  191. BlockNumber    blockNum;
  192. {
  193.     return ReadBufferWithBufferLock(reln, blockNum, false);
  194. }
  195.  
  196. bool
  197. is_userbuffer(buffer)
  198. Buffer buffer;
  199. {
  200.     BufferDesc *buf;
  201.     buf = BufferGetBufferDescriptor(buffer);
  202.     if (strncmp(&buf->sb_relname, "pg_", 3) == 0)
  203.     return false;
  204.     else
  205.     return true;
  206. }
  207.  
  208. Buffer
  209. ReadBuffer_Debug(file, line, reln, blockNum)
  210. String file;
  211. int line;
  212. Relation reln;
  213. BlockNumber blockNum;
  214. {
  215.     Buffer buffer;
  216.  
  217.     buffer = ReadBufferWithBufferLock(reln, blockNum, false);
  218.     if (ShowPinTrace && is_userbuffer(buffer)) {
  219.     BufferDesc *buf;
  220.     buf = BufferGetBufferDescriptor(buffer);
  221.     fprintf(stderr, "PIN(RD) %d relname = %s, blockNum = %d, refcount = %d, file: %s, line: %d\n", buffer, &(buf->sb_relname), buf->tag.blockNum, PrivateRefCount[buffer - 1], file, line);
  222.       }
  223.     return buffer;
  224. }
  225.  
  226. /*
  227.  * ReadBufferWithBufferLock -- does the work of 
  228.  *    ReadBuffer() but with the possibility that
  229.  *    the buffer lock has already been held. this
  230.  *    is yet another effort to reduce the number of
  231.  *    semops in the system.
  232.  *
  233.  *  This routine locks the buffer pool before calling BufferAlloc to
  234.  *  avoid two semops.
  235.  */
  236.  
  237. Buffer
  238. ReadBufferWithBufferLock(reln,blockNum, bufferLockHeld)
  239. Relation     reln;
  240. BlockNumber     blockNum;
  241. bool        bufferLockHeld;
  242. {
  243.   BufferDesc *    bufHdr;      
  244.   int        extend;   /* extending the file by one block */
  245.   int        status;
  246.   Boolean    found;
  247.  
  248.   ReadBufferCount++;
  249.   extend = (blockNum == NEW_BLOCK);
  250.   /* lookup the buffer.  IO_IN_PROGRESS is set if the requested
  251.    * block is not currently in memory.
  252.    */
  253.   bufHdr = BufferAlloc(reln, blockNum, &found, bufferLockHeld);
  254.   if (! bufHdr) {
  255.     return(InvalidBuffer);
  256.   }
  257.  
  258.   /* if its already in the buffer pool, we're done */
  259.   if (found) {
  260.     /*
  261.      * This happens when a bogus buffer was returned previously and is
  262.      * floating around in the buffer pool.  A routine calling this would
  263.      * want this extended.
  264.      */
  265.     if (extend) {
  266.       (void) smgrextend(bufHdr->bufsmgr, reln,
  267.             (char *) MAKE_PTR(bufHdr->data));
  268.     }
  269.     BufferHitCount++;
  270.     return(BufferDescriptorGetBuffer(bufHdr));
  271.   }
  272.  
  273.   /* 
  274.    * if we have gotten to this point, the reln pointer must be ok
  275.    * and the relation file must be open.
  276.    */
  277.  
  278.   if (extend) {
  279.     status = smgrextend(bufHdr->bufsmgr, reln,
  280.             (char *) MAKE_PTR(bufHdr->data));
  281.   } else {
  282.     status = smgrread(bufHdr->bufsmgr, reln, blockNum,
  283.               (char *) MAKE_PTR(bufHdr->data));
  284.   }
  285.  
  286.   /* lock buffer manager again to update IO IN PROGRESS */
  287.   SpinAcquire(BufMgrLock);
  288.  
  289.   if (status == SM_FAIL) {
  290.     /* IO Failed.  cleanup the data structures and go home */
  291.  
  292.     if (! BufTableDelete(bufHdr)) {
  293.       SpinRelease(BufMgrLock);
  294.       elog(FATAL,"BufRead: buffer table broken after IO error\n");
  295.     }
  296.     /* remember that BufferAlloc() pinned the buffer */
  297.     UnpinBuffer(bufHdr);
  298.  
  299.     /* 
  300.      * Have to reset the flag so that anyone waiting for
  301.      * the buffer can tell that the contents are invalid.
  302.      */
  303.     bufHdr->flags |= BM_IO_ERROR;
  304.  
  305.   } else {
  306.     /* IO Succeeded.  clear the flags, finish buffer update */
  307.  
  308.     bufHdr->flags &= ~(BM_IO_ERROR | BM_IO_IN_PROGRESS);
  309.   }
  310.  
  311.   /* If anyone was waiting for IO to complete, wake them up now */
  312. #ifdef HAS_TEST_AND_SET
  313.   S_UNLOCK(&(bufHdr->io_in_progress_lock));
  314. #else
  315.   if (bufHdr->refcount > 1)
  316.     SignalIO(bufHdr);
  317. #endif
  318.  
  319.   SpinRelease(BufMgrLock);
  320.     
  321.   return(BufferDescriptorGetBuffer(bufHdr));
  322. }
  323.  
  324. /*
  325.  * BufferAlloc -- Get a buffer from the buffer pool but dont
  326.  *    read it.
  327.  *
  328.  * Returns: descriptor for buffer
  329.  */
  330. BufferDesc *
  331. BufferAlloc(reln, blockNum, foundPtr, bufferLockHeld)
  332. Relation    reln;
  333. BlockNumber    blockNum;
  334. Boolean        *foundPtr;
  335. bool        bufferLockHeld;
  336. {
  337.   BufferDesc         *buf;      
  338.   BufferTag         newTag;     /* identity of requested block */
  339.   Boolean        inProgress; /* buffer undergoing IO */
  340.   int            status;
  341.   Boolean        newblock = FALSE;
  342.   BufferDesc        oldbufdesc;
  343.  
  344.  
  345.     /* create a new tag so we can lookup the buffer */
  346.     /* assume that the relation is already open */
  347.   if (blockNum == NEW_BLOCK) {
  348.       newblock = TRUE;
  349.       blockNum = smgrnblocks(reln->rd_rel->relsmgr, reln);
  350.   }
  351.  
  352.   INIT_BUFFERTAG(&newTag,reln,blockNum);
  353.  
  354.   if (!bufferLockHeld)
  355.       SpinAcquire(BufMgrLock);
  356.  
  357.   /* see if the block is in the buffer pool already */
  358.   buf = BufTableLookup(&newTag);
  359.   if (buf != NULL) {
  360.     /* Found it.  Now, (a) pin the buffer so no
  361.      * one steals it from the buffer pool, 
  362.      * (b) check IO_IN_PROGRESS, someone may be
  363.      * faulting the buffer into the buffer pool.
  364.      */
  365.  
  366.     PinBuffer(buf);
  367.     inProgress = (buf->flags & BM_IO_IN_PROGRESS);
  368.     
  369.     *foundPtr = TRUE;
  370.     if (inProgress) {
  371.       WaitIO(buf, BufMgrLock);
  372.       if (buf->flags & BM_IO_ERROR) {
  373.     /* wierd race condition: 
  374.      *
  375.      * We were waiting for someone else to read the buffer.  
  376.      * While we were waiting, the reader boof'd in some
  377.      *  way, so the contents of the buffer are still
  378.      * invalid.  By saying that we didn't find it, we can
  379.      * make the caller reinitialize the buffer.  If two
  380.      * processes are waiting for this block, both will
  381.      * read the block.  The second one to finish may overwrite 
  382.      * any updates made by the first.  (Assume higher level
  383.      * synchronization prevents this from happening).
  384.      *
  385.      * This is never going to happen, don't worry about it.
  386.      */
  387.     *foundPtr = FALSE;
  388.       }
  389.     }
  390. #ifdef BMTRACE
  391.     _bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), reln->rd_id, blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCFND);
  392. #endif BMTRACE
  393.  
  394.     SpinRelease(BufMgrLock);
  395.   
  396.     return(buf);
  397.   }
  398.  
  399.   *foundPtr = FALSE;
  400.  
  401.   /* Didn't find it in the buffer pool.  We'll have
  402.    * to initialize a new buffer.  First, grab one from
  403.    * the free list.  If it's dirty, flush it to disk.
  404.    * Remember to unlock BufMgr spinloc while doing the IOs.
  405.    */
  406.   buf = GetFreeBuffer();
  407.   if (! buf) {
  408.     /* out of free buffers.  In trouble now. */
  409.      SpinRelease(BufMgrLock);
  410.      return(NULL);
  411.    }
  412.  
  413.    /* There should be exactly one pin on the buffer
  414.     * after it is allocated.  It isnt in the buffer
  415.     * table yet so no one but us should have a pin.
  416.     */
  417.  
  418.    Assert(buf->refcount == 0);
  419.    buf->refcount = 1;           
  420.    PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 1;
  421.  
  422.   /* 
  423.    * Change the name of the buffer in the lookup table:
  424.    *  
  425.    * Need to update the lookup table before the read starts.
  426.    * If someone comes along looking for the buffer while
  427.    * we are reading it in, we don't want them to allocate
  428.    * a new buffer.  For the same reason, we didn't want
  429.    * to erase the buf table entry for the buffer we were
  430.    * writing back until now, either.
  431.    */
  432.  
  433.   if (! BufTableDelete(buf)) {
  434.     SpinRelease(BufMgrLock);
  435.     elog(FATAL,"buffer wasn't in the buffer table\n");
  436.   }
  437.  
  438.   /* save the old buffer descriptor */
  439.   oldbufdesc = *buf;
  440.   if (buf->flags & BM_DIRTY) {
  441.       /* must clear flag first because of wierd race 
  442.        * condition described below.  
  443.        */
  444.       buf->flags &= ~BM_DIRTY;
  445.     }
  446.  
  447.   /* record the database name and relation name for this buffer */
  448.   strncpy((char *)&(buf->sb_relname),
  449.           (char *)&(reln->rd_rel->relname),
  450.       sizeof (NameData));
  451.   strncpy((char *)&(buf->sb_dbname), MyDatabaseName, sizeof (NameData));
  452.  
  453.   /* remember which storage manager is responsible for it */
  454.   buf->bufsmgr = reln->rd_rel->relsmgr;
  455.  
  456.   INIT_BUFFERTAG(&(buf->tag),reln,blockNum);
  457.   if (! BufTableInsert(buf)) {
  458.     SpinRelease(BufMgrLock);
  459.     elog(FATAL,"Buffer in lookup table twice \n");
  460.   } 
  461.  
  462.   /* Buffer contents are currently invalid.  Have
  463.    * to mark IO IN PROGRESS so no one fiddles with
  464.    * them until the read completes.  If this routine
  465.    * has been called simply to allocate a buffer, no
  466.    * io will be attempted, so the flag isnt set.
  467.    */
  468.   buf->flags |= BM_IO_IN_PROGRESS; 
  469. #ifdef HAS_TEST_AND_SET
  470.   /* lock the io_in_progress_lock before the read so that
  471.    * other process will wait on it
  472.    */
  473.   Assert(!buf->io_in_progress_lock);
  474.   S_LOCK(&(buf->io_in_progress_lock));
  475. #endif
  476.  
  477. #ifdef BMTRACE
  478.   _bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), reln->rd_id, blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCNOTFND);
  479. #endif BMTRACE
  480.  
  481.   SpinRelease(BufMgrLock);
  482.  
  483.   /* XXX mao what is this? XXX */
  484.   if (oldbufdesc.flags & BM_DIRTY) {
  485.      (void) BufferReplace(&oldbufdesc);
  486.      BufferFlushCount++;
  487.   }
  488.   return (buf);
  489. }
  490.  
  491. /*
  492.  * WriteBuffer--
  493.  *
  494.  *    Pushes buffer contents to disk if LateWrite is
  495.  * not set.  Otherwise, marks contents as dirty.  
  496.  *
  497.  * Assume that buffer is pinned.  Assume that reln is
  498.  *    valid.
  499.  *
  500.  * Side Effects:
  501.  *        Pin count is decremented.
  502.  */
  503.  
  504. #undef WriteBuffer
  505.  
  506. WriteBuffer(buffer)
  507. Buffer    buffer;
  508. {
  509.   BufferDesc    *bufHdr;
  510.   
  511.   if (! LateWrite) {
  512.     return(FlushBuffer(buffer));
  513.   } else {
  514.  
  515.     if (BAD_BUFFER_ID(buffer)) {
  516.       return(FALSE);
  517.     }
  518.     bufHdr = BufferGetBufferDescriptor(buffer);
  519.  
  520.     Assert(bufHdr->refcount > 0);
  521.     SpinAcquire(BufMgrLock);
  522.     bufHdr->flags |= BM_DIRTY; 
  523.     UnpinBuffer(bufHdr);
  524.     SpinRelease(BufMgrLock);
  525.   }
  526.   return(TRUE);
  527. } 
  528.  
  529. WriteBuffer_Debug(file, line, buffer)
  530. String file;
  531. int line;
  532. Buffer buffer;
  533. {
  534.     WriteBuffer(buffer);
  535.     if (ShowPinTrace && is_userbuffer(buffer)) {
  536.     BufferDesc *buf;
  537.     buf = BufferGetBufferDescriptor(buffer);
  538.     fprintf(stderr, "UNPIN(WR) %d relname = %s, blockNum = %d, refcount = %d, file: %s, line: %d\n", buffer, &(buf->sb_relname), buf->tag.blockNum, PrivateRefCount[buffer - 1], file, line);
  539.       }
  540. }
  541.  
  542. /*
  543.  *  DirtyBufferCopy() -- Copy a given dirty buffer to the requested
  544.  *             destination.
  545.  *
  546.  *    We treat this as a write.  If the requested buffer is in the pool
  547.  *    and is dirty, we copy it to the location requested and mark it
  548.  *    clean.  This routine supports the Sony jukebox storage manager,
  549.  *    which agrees to take responsibility for the data once we mark
  550.  *    it clean.
  551.  */
  552.  
  553. DirtyBufferCopy(dbid, relid, blkno, dest)
  554.   ObjectId dbid;
  555.   ObjectId relid;
  556.   BlockNumber blkno;
  557.   char *dest;
  558. {
  559.   BufferDesc *buf;
  560.   BufferTag btag;
  561.  
  562.   btag.relId.relId = relid;
  563.   btag.relId.dbId = dbid;
  564.   btag.blockNum = blkno;
  565.  
  566.   SpinAcquire(BufMgrLock);
  567.   buf = BufTableLookup(&btag);
  568.  
  569.   if (buf == (BufferDesc *) NULL
  570.       || !(buf->flags & BM_DIRTY)
  571.       || !(buf->flags & BM_VALID)) {
  572.     SpinRelease(BufMgrLock);
  573.     return;
  574.   }
  575.  
  576.   /* hate to do this holding the lock, but release and reacquire is slower */
  577.   (void) bcopy((char *) MAKE_PTR(buf->data), dest, BLCKSZ);
  578.  
  579.   buf->flags &= ~BM_DIRTY;
  580.  
  581.   SpinRelease(BufMgrLock);
  582. }
  583.  
  584. /*
  585.  * BufferRewrite -- special version of WriteBuffer for
  586.  *    BufCopyCommit().  We want to write without
  587.  *    looking up the relation if possible.
  588.  */
  589. Boolean
  590. BufferRewrite(buffer)
  591. Buffer    buffer;
  592. {
  593.   BufferDesc    *bufHdr;
  594.   
  595.   if (BAD_BUFFER_ID(buffer)) {
  596.     return(STATUS_ERROR);
  597.   }
  598.   bufHdr = BufferGetBufferDescriptor(buffer);
  599.   Assert(bufHdr->refcount > 0);
  600.  
  601.   if (LateWrite) {
  602.     SpinAcquire(BufMgrLock); 
  603.     bufHdr->flags |= BM_DIRTY; 
  604.     UnpinBuffer(bufHdr);
  605.     SpinRelease(BufMgrLock); 
  606.   } else {
  607.     BufferReplace(bufHdr);
  608.   }
  609.  
  610.  
  611.   return(STATUS_OK);
  612. } 
  613.  
  614.  
  615. /*
  616.  * FlushBuffer -- like WriteBuffer, but force the page to disk.
  617.  */
  618. FlushBuffer(buffer)
  619. Buffer    buffer;
  620. {
  621.   BufferDesc    *bufHdr;
  622.   OID        bufdb;
  623.   OID        bufrel;
  624.   Relation    reln;
  625.   int        status;
  626.  
  627.  
  628.   if (BAD_BUFFER_ID(buffer)) {
  629.     return(STATUS_ERROR);
  630.   }
  631.  
  632.   bufHdr = BufferGetBufferDescriptor(buffer);
  633.  
  634.   /*
  635.    *  If the relation is not in our private cache, we don't bother trying
  636.    *  to instantiate it.  Instead, we call the storage manager routine that
  637.    *  does a blind write.  If we can get the reldesc, then we use the standard
  638.    *  write routine interface.
  639.    */
  640.  
  641.   bufdb = bufHdr->tag.relId.dbId;
  642.   bufrel = bufHdr->tag.relId.relId;
  643.  
  644.   if (bufdb == MyDatabaseId || bufdb == (OID) NULL)
  645.       reln = RelationIdCacheGetRelation(bufrel);
  646.   else
  647.       reln = (Relation) NULL;
  648.  
  649.   if (reln != (Relation) NULL) {
  650.       status = smgrflush(bufHdr->bufsmgr, reln, bufHdr->tag.blockNum,
  651.              (char *) MAKE_PTR(bufHdr->data));
  652.   } else {
  653.  
  654.       /* blind write always flushes */
  655.       status = smgrblindwrt(bufHdr->bufsmgr, &bufHdr->sb_dbname,
  656.                 &bufHdr->sb_relname, bufdb, bufrel,
  657.                 bufHdr->tag.blockNum,
  658.                 (char *) MAKE_PTR(bufHdr->data));
  659.   }
  660.  
  661.   if (status == SM_FAIL) {
  662.       elog(WARN, "FlushBuffer: cannot flush %d for %16s", bufHdr->tag.blockNum,
  663.          reln->rd_rel->relname);
  664.       /* NOTREACHED */
  665.       return (STATUS_ERROR);
  666.   }
  667.  
  668.   SpinAcquire(BufMgrLock);
  669.   bufHdr->flags &= ~BM_DIRTY; 
  670.   UnpinBuffer(bufHdr);
  671.   SpinRelease(BufMgrLock);
  672.  
  673.   return(STATUS_OK);
  674. }
  675.  
  676. /*
  677.  * WriteNoReleaseBuffer -- like WriteBuffer, but do not unpin the buffer
  678.  *                when the operation is complete.
  679.  *
  680.  *    We know that the buffer is for a relation in our private cache,
  681.  *    because this routine is called only to write out buffers that
  682.  *    were changed by the executing backend.
  683.  */
  684.  
  685. WriteNoReleaseBuffer(buffer)
  686. Buffer    buffer;
  687. {
  688.   BufferDesc    *bufHdr;
  689.   Relation    reln;
  690.  
  691.   if (! LateWrite) {
  692.     return(FlushBuffer(buffer));
  693.   } else {
  694.  
  695.     if (BAD_BUFFER_ID(buffer)){
  696.       return(STATUS_ERROR);
  697.     }
  698.     bufHdr = BufferGetBufferDescriptor(buffer);
  699.  
  700.     SpinAcquire(BufMgrLock);
  701.     bufHdr->flags |= BM_DIRTY; 
  702.     SpinRelease(BufMgrLock);
  703.   }
  704.   return(STATUS_OK);
  705. }
  706.  
  707.  
  708. #undef ReleaseAndReadBuffer
  709. /*
  710.  * ReleaseAndReadBuffer -- combine ReleaseBuffer() and ReadBuffer()
  711.  *     so that only one semop needs to be called.
  712.  *
  713.  */
  714. Buffer
  715. ReleaseAndReadBuffer(buffer, relation, blockNum)
  716. Buffer buffer;
  717. Relation relation;
  718. BlockNumber blockNum;
  719. {
  720.     BufferDesc    *bufHdr;
  721.     Buffer retbuf;
  722.     if (BufferIsValid(buffer)) {
  723.     bufHdr = BufferGetBufferDescriptor(buffer);
  724.     PrivateRefCount[buffer - 1]--;
  725.     if (PrivateRefCount[buffer - 1] == 0 && LastRefCount[buffer - 1] == 0) {
  726.     /* only release buffer if it is not pinned in previous ExecMain level */
  727.         SpinAcquire(BufMgrLock);
  728.         bufHdr->refcount--;
  729.         if (bufHdr->refcount == 0) {
  730.         AddBufferToFreelist(bufHdr);
  731.         bufHdr->flags |= BM_FREE;
  732.           }
  733.         retbuf = ReadBufferWithBufferLock(relation, blockNum, true);
  734.         return retbuf;
  735.      }
  736.       }
  737.     return(ReadBuffer(relation, blockNum));
  738. }
  739.  
  740. /*
  741.  * AcquireBuffer -- Pin a buffer that we know is valid.
  742.  *
  743.  * ---There is a race condition.  This routine doesnt make
  744.  * any sense.  We never really know the buffer is valid.
  745.  */
  746. BufferAcquire(bufHdr)
  747. BufferDesc    *bufHdr;
  748. {
  749.  
  750.   SpinAcquire(BufMgrLock);
  751.   PinBuffer(bufHdr);
  752.   SpinRelease(BufMgrLock);
  753.   return (TRUE);
  754. }
  755.  
  756. /*
  757.  * BufferRepin -- get a second pin on an already pinned buffer
  758.  */
  759. BufferRepin(buffer)
  760. Buffer    buffer;
  761. {
  762.   BufferDesc    *bufHdr;
  763.  
  764.   if (BAD_BUFFER_ID(buffer)) {
  765.     return(FALSE);
  766.   }
  767.   bufHdr = BufferGetBufferDescriptor(buffer);
  768.  
  769.   /* like we said -- already pinned */
  770.   Assert(bufHdr->refcount);
  771.  
  772.   SpinAcquire(BufMgrLock);
  773.   PinBuffer(bufHdr);
  774.   SpinRelease(BufMgrLock);
  775.   return (TRUE);
  776. }
  777.  
  778. /*
  779.  * BufferSync -- Flush all dirty buffers in the pool.
  780.  *
  781.  *    This is called at transaction commit time.  It does the wrong thing,
  782.  *    right now.  We should flush only our own changes to stable storage,
  783.  *    and we should obey the lock protocol on the buffer manager metadata
  784.  *    as we do it.  Also, we need to be sure that no other transaction is
  785.  *    modifying the page as we flush it.  This is only a problem for objects
  786.  *    that use a non-two-phase locking protocol, like btree indices.  For
  787.  *    those objects, we would like to set a write lock for the duration of
  788.  *    our IO.  Another possibility is to code updates to btree pages
  789.  *    carefully, so that writing them out out of order cannot cause
  790.  *    any unrecoverable errors.
  791.  *
  792.  *    I don't want to think hard about this right now, so I will try
  793.  *    to come back to it later.
  794.  */
  795. void
  796. BufferSync()
  797. { 
  798.   int i;
  799.   OID bufdb;
  800.   OID bufrel;
  801.   Relation reln;
  802.   BufferDesc *bufHdr;
  803.   int status;
  804.  
  805.   for (i=0, bufHdr = BufferDescriptors; i < NBuffers; i++, bufHdr++) {
  806.       if ((bufHdr->flags & BM_VALID) && (bufHdr->flags & BM_DIRTY)) {
  807.       bufdb = bufHdr->tag.relId.dbId;
  808.       bufrel = bufHdr->tag.relId.relId;
  809.       if (bufdb == MyDatabaseId || bufdb == (OID) 0) {
  810.           reln = RelationIdCacheGetRelation(bufrel);
  811.  
  812.           /*
  813.            *  If we didn't have the reldesc in our local cache, flush this
  814.            *  page out using the 'blind write' storage manager routine.  If
  815.            *  we did find it, use the standard interface.
  816.            */
  817.  
  818.           if (reln == (Relation) NULL) {
  819.           status = smgrblindwrt(bufHdr->bufsmgr, &bufHdr->sb_dbname,
  820.                     &bufHdr->sb_relname, bufdb, bufrel,
  821.                     bufHdr->tag.blockNum,
  822.                     (char *) MAKE_PTR(bufHdr->data));
  823.           } else {
  824.           status = smgrwrite(bufHdr->bufsmgr, reln,
  825.                      bufHdr->tag.blockNum,
  826.                      (char *) MAKE_PTR(bufHdr->data));
  827.           }
  828.  
  829.           if (status == SM_FAIL) {
  830.           elog(WARN, "cannot write %d for %16s",
  831.                bufHdr->tag.blockNum, bufHdr->sb_relname);
  832.           }
  833.  
  834.           bufHdr->flags &= ~BM_DIRTY;
  835.           if (reln != (Relation)NULL)
  836.           RelationDecrementReferenceCount(reln);
  837.       }
  838.       }
  839.   }
  840. }
  841.  
  842.  
  843. /*
  844.  * WaitIO -- Block until the IO_IN_PROGRESS flag on 'buf'
  845.  *     is cleared.  Because IO_IN_PROGRESS conflicts are
  846.  *    expected to be rare, there is only one BufferIO
  847.  *    lock in the entire system.  All processes block
  848.  *    on this semaphore when they try to use a buffer
  849.  *    that someone else is faulting in.  Whenever a
  850.  *    process finishes an IO and someone is waiting for
  851.  *    the buffer, BufferIO is signaled (SignalIO).  All
  852.  *    waiting processes then wake up and check to see
  853.  *    if their buffer is now ready.  This implementation
  854.  *    is simple, but efficient enough if WaitIO is
  855.  *    rarely called by multiple processes simultaneously.
  856.  *
  857.  *  ProcSleep atomically releases the spinlock and goes to
  858.  *    sleep.
  859.  *
  860.  *  Note: there is an easy fix if the queue becomes long.
  861.  *    save the id of the buffer we are waiting for in
  862.  *    the queue structure.  That way signal can figure
  863.  *    out which proc to wake up.
  864.  */
  865. #ifdef HAS_TEST_AND_SET
  866. WaitIO(buf, spinlock)
  867. BufferDesc *buf;
  868. SPINLOCK spinlock;
  869. {
  870.     SpinRelease(spinlock);
  871.     S_LOCK(&(buf->io_in_progress_lock));
  872.     S_UNLOCK(&(buf->io_in_progress_lock));
  873.     SpinAcquire(spinlock);
  874. }
  875.  
  876. #else /* HAS_TEST_AND_SET */
  877. static IpcSemaphoreId    WaitIOSemId;
  878.  
  879. WaitIO(buf,spinlock)
  880. BufferDesc *buf;
  881. SPINLOCK spinlock;
  882. {
  883.   Boolean     inProgress;
  884.  
  885.   for (;;) {
  886.  
  887.     /* wait until someone releases IO lock */
  888.     (*NWaitIOBackendP)++;
  889.     SpinRelease(spinlock);
  890.     IpcSemaphoreLock(WaitIOSemId, 0, 1);
  891.     SpinAcquire(spinlock);
  892.     inProgress = (buf->flags & BM_IO_IN_PROGRESS);
  893.     if (!inProgress) break;
  894.   }
  895. }
  896.  
  897. /*
  898.  * SignalIO --
  899.  */
  900. SignalIO(buf)
  901. BufferDesc *buf;
  902. {
  903.   /* somebody better be waiting. */
  904.   Assert( buf->refcount > 1);
  905.   IpcSemaphoreUnlock(WaitIOSemId, 0, *NWaitIOBackendP);
  906.   *NWaitIOBackendP = 0;
  907. }
  908. #endif /* HAS_TEST_AND_SET */
  909.  
  910. /*
  911.  * Initialize module:
  912.  *
  913.  * should calculate size of pool dynamically based on the
  914.  * amount of available memory.
  915.  */
  916. InitBufferPool(key)
  917. IPCKey key;
  918. {
  919.   Boolean foundBufs,foundDescs,foundNWaitIO;
  920.   int i;
  921.   int status;
  922.  
  923.  
  924.   Data_Descriptors = NBuffers;
  925.   Free_List_Descriptor = Data_Descriptors;
  926.   Lookup_List_Descriptor = Data_Descriptors + 1;
  927.   Num_Descriptors = Data_Descriptors + 1;
  928.  
  929.   SpinAcquire(BufMgrLock);
  930.  
  931. #ifdef BMTRACE
  932.   CurTraceBuf = (int *) ShmemInitStruct("Buffer trace",
  933.                 (BMT_LIMIT * sizeof(bmtrace)) + sizeof(int),
  934.                 &foundDescs);
  935.   if (!foundDescs)
  936.       bzero(CurTraceBuf, (BMT_LIMIT * sizeof(bmtrace)) + sizeof(int));
  937.  
  938.   TraceBuf = (bmtrace *) &(CurTraceBuf[1]);
  939. #endif
  940.  
  941.   BufferDescriptors = (BufferDesc *)
  942.     ShmemInitStruct("Buffer Descriptors",
  943.             Num_Descriptors*sizeof(BufferDesc),&foundDescs);
  944.  
  945.   BufferBlocks = (BufferBlock)
  946.     ShmemInitStruct("Buffer Blocks",
  947.             NBuffers*BLOCK_SIZE,&foundBufs);
  948.  
  949. #ifndef HAS_TEST_AND_SET
  950.   NWaitIOBackendP = (int*)ShmemInitStruct("#Backends Waiting IO",
  951.                       sizeof(int),
  952.                       &foundNWaitIO);
  953.   if (!foundNWaitIO)
  954.       *NWaitIOBackendP = 0;
  955. #endif
  956.  
  957.   if (foundDescs || foundBufs) {
  958.  
  959.     /* both should be present or neither */
  960.     Assert(foundDescs && foundBufs);
  961.  
  962.   } else {
  963.     BufferDesc *buf;
  964.     unsigned int block;
  965.  
  966.     buf = BufferDescriptors;
  967.     block = (unsigned int) BufferBlocks;
  968.  
  969.     /*
  970.      * link the buffers into a circular, doubly-linked list to
  971.      * initialize free list.  Still don't know anything about
  972.      * replacement strategy in this file.
  973.      */
  974.     for (i = 0; i < Data_Descriptors; block+=BLOCK_SIZE,buf++,i++) {
  975.       Assert(ShmemIsValid((unsigned int)block));
  976.  
  977.       buf->freeNext = i+1;
  978.       buf->freePrev = i-1;
  979.  
  980.       CLEAR_BUFFERTAG(&(buf->tag));
  981.       buf->data = MAKE_OFFSET(block);
  982.       buf->flags = (BM_DELETED | BM_FREE | BM_VALID);
  983.       buf->refcount = 0;
  984.       buf->id = i;
  985. #ifdef HAS_TEST_AND_SET
  986.       S_INIT_LOCK(&(buf->io_in_progress_lock));
  987. #endif
  988.     }
  989.  
  990.     /* close the circular queue */
  991.     BufferDescriptors[0].freePrev = Data_Descriptors-1;
  992.     BufferDescriptors[Data_Descriptors-1].freeNext = 0;
  993.   }
  994.  
  995.   /* Init the rest of the module */
  996.   InitBufTable();
  997.   InitFreeList(!foundDescs);
  998.  
  999.   SpinRelease(BufMgrLock);
  1000.  
  1001. #ifndef HAS_TEST_AND_SET
  1002.   WaitIOSemId = IpcSemaphoreCreate(IPCKeyGetWaitIOSemaphoreKey(key),
  1003.                    1, IPCProtection, 0, &status);
  1004. #endif
  1005.   PrivateRefCount = (int*)malloc(NBuffers * sizeof(int));
  1006.   LastRefCount = (int*)malloc(NBuffers * sizeof(int));
  1007.   for (i = 0; i < NBuffers; i++) {
  1008.       PrivateRefCount[i] = 0;
  1009.       LastRefCount[i] = 0;
  1010.     }
  1011. }
  1012.  
  1013. int NDirectFileRead;    /* some I/O's are direct file access.  bypass bufmgr */
  1014. int NDirectFileWrite;   /* e.g., I/O in psort and hashjoin.             */
  1015.  
  1016. void
  1017. PrintBufferUsage(statfp)
  1018. FILE *statfp;
  1019. {
  1020.     float hitrate;
  1021.  
  1022.     if (ReadBufferCount==0)
  1023.         hitrate = 0.0;
  1024.     else
  1025.         hitrate = (float)BufferHitCount * 100.0/ReadBufferCount;
  1026.  
  1027.     fprintf(statfp, "!\t%d blocks read, %d blocks written, buffer hit rate = %.2f%%\n", 
  1028.         ReadBufferCount - BufferHitCount + NDirectFileRead,
  1029.         BufferFlushCount + NDirectFileWrite,
  1030.         hitrate);
  1031. }
  1032.  
  1033. void
  1034. ResetBufferUsage()
  1035. {
  1036.     BufferHitCount = 0;
  1037.     ReadBufferCount = 0;
  1038.     BufferFlushCount = 0;
  1039.     NDirectFileRead = 0;
  1040.     NDirectFileWrite = 0;
  1041. }
  1042.  
  1043. /* ----------------------------------------------
  1044.  *    ResetBufferPool
  1045.  *
  1046.  *    this routine is supposed to be called when a transaction aborts.
  1047.  *    it will release all the buffer pins held by the transaciton.
  1048.  *
  1049.  * ----------------------------------------------
  1050.  */
  1051. void
  1052. ResetBufferPool()
  1053. {
  1054.     register int i;
  1055.     for (i=1; i<=NBuffers; i++) {
  1056.     if (BufferIsValid(i)) {
  1057.         while(PrivateRefCount[i - 1] > 0) {
  1058.         ReleaseBuffer(i);
  1059.           }
  1060.       }
  1061.     LastRefCount[i - 1] = 0;
  1062.       }
  1063. }
  1064.  
  1065. /* -----------------------------------------------
  1066.  *    BufferPoolCheckLeak
  1067.  *
  1068.  *    check if there is buffer leak
  1069.  *
  1070.  * -----------------------------------------------
  1071.  */
  1072. int
  1073. BufferPoolCheckLeak()
  1074. {
  1075.     register int i;
  1076.     for (i=1; i<=NBuffers; i++) {
  1077.     if (BufferIsValid(i)) {
  1078.         elog(DEBUG, "BUFFER LEAK!!! send mail to wei.");
  1079.         return(1);
  1080.       }
  1081.       }
  1082.     return(0);
  1083. }
  1084.  
  1085. /* ------------------------------------------------
  1086.  *    FlushBufferPool
  1087.  *
  1088.  *    flush all dirty blocks in buffer pool to disk
  1089.  *
  1090.  * ------------------------------------------------
  1091.  */
  1092. void
  1093. FlushBufferPool(StableMainMemoryFlag)
  1094. int StableMainMemoryFlag;
  1095. {
  1096.     if (!StableMainMemoryFlag) {
  1097.         BufferSync();
  1098.     smgrcommit();
  1099.     }
  1100. }
  1101.  
  1102. /**************************************************
  1103.   BufferDescriptorIsValid
  1104.  
  1105.  **************************************************/
  1106.  
  1107. bool
  1108. BufferDescriptorIsValid(bufdesc)
  1109.      BufferDesc *bufdesc;
  1110. {
  1111.     int temp;
  1112.     
  1113.     Assert(PointerIsValid(bufdesc));
  1114.     
  1115.     temp = (bufdesc-BufferDescriptors)/sizeof(BufferDesc);
  1116.     if (temp >= 0 && temp<NBuffers)
  1117.         return(true);
  1118.     else
  1119.         return(false);
  1120.     
  1121. } /*BufferDescriptorIsValid*/
  1122.  
  1123. /**************************************************
  1124.   BufferIsValid
  1125.   returns true iff the refcnt of the local
  1126.   buffer is > 0
  1127.  **************************************************/
  1128. bool
  1129. BufferIsValid(bufnum)
  1130.     Buffer bufnum;
  1131. {
  1132.     if (BAD_BUFFER_ID(bufnum)) {
  1133.         return(false);
  1134.     }
  1135.     return((bool)(PrivateRefCount[bufnum - 1] > 0));
  1136. } /* BufferIsValid */
  1137.  
  1138. BlockSize
  1139. BufferGetBlockSize(buffer)
  1140.     Buffer      buffer;
  1141. {
  1142.     Assert(BufferIsValid(buffer));
  1143.   /* Apparently, POSTGRES was supposed to have variable
  1144.    * sized buffer blocks.  Current buffer manager will need
  1145.    * extensive redesign if that is ever to come to pass, so
  1146.    * for now hardwire it to BLCKSZ
  1147.    */
  1148.     return (BLCKSZ);
  1149. }
  1150.  
  1151. BlockNumber
  1152. BufferGetBlockNumber(buffer)
  1153.     Buffer      buffer;
  1154. {
  1155.     Assert(BufferIsValid(buffer));
  1156.     return (BufferGetBufferDescriptor(buffer)->tag.blockNum);
  1157. }
  1158.  
  1159. Relation
  1160. BufferGetRelation(buffer)
  1161.     Buffer      buffer;
  1162. {
  1163.     Relation    relation;
  1164.  
  1165.     Assert(BufferIsValid(buffer));
  1166.  
  1167.     relation = RelationIdGetRelation(LRelIdGetRelationId
  1168.                 (BufferGetBufferDescriptor(buffer)->tag.relId));
  1169.  
  1170.     RelationDecrementReferenceCount(relation);
  1171.  
  1172.     if (RelationHasReferenceCountZero(relation)) {
  1173.        /*
  1174.         elog(NOTICE, "BufferGetRelation: 0->1");
  1175.     */
  1176.  
  1177.         RelationIncrementReferenceCount(relation);
  1178.     }
  1179.  
  1180.     return (relation);
  1181. }
  1182.  
  1183. /**************************************************
  1184.   BufferDescriptorGetBuffer
  1185.  
  1186.  **************************************************/
  1187.  
  1188.  
  1189. Buffer
  1190. BufferDescriptorGetBuffer(descriptor)
  1191.     BufferDesc *descriptor;
  1192. {
  1193.     Assert(BufferDescriptorIsValid(descriptor));
  1194.  
  1195.     return(1+descriptor - BufferDescriptors);
  1196. }
  1197.  
  1198. BufferReplace(bufHdr)
  1199.     BufferDesc     *bufHdr;
  1200. {
  1201.     int        blockSize;
  1202.     int        blockNum;
  1203.     LRelId    *relIdPtr;
  1204.     Relation     reln;
  1205.     ObjectId    bufdb, bufrel;
  1206.     int        status;
  1207.  
  1208.     blockSize = BLOCKSZ(bufHdr);
  1209.     blockNum = bufHdr->tag.blockNum;
  1210.  
  1211.     /*
  1212.      * first try to find the reldesc in the cache, if no luck,
  1213.      * don't bother to build the reldesc from scratch, just do
  1214.      * a blind write.
  1215.      */
  1216.  
  1217.     bufdb = bufHdr->tag.relId.dbId;
  1218.     bufrel = bufHdr->tag.relId.relId;
  1219.  
  1220.     if (bufdb == MyDatabaseId || bufdb == (OID) NULL)
  1221.     reln = RelationIdCacheGetRelation(bufrel);
  1222.     else
  1223.     reln = (Relation) NULL;
  1224.  
  1225.     if (reln != (Relation) NULL) {
  1226.     status = smgrflush(bufHdr->bufsmgr, reln, bufHdr->tag.blockNum,
  1227.                (char *) MAKE_PTR(bufHdr->data));
  1228.     } else {
  1229.  
  1230.     /* blind write always flushes */
  1231.     status = smgrblindwrt(bufHdr->bufsmgr, &bufHdr->sb_dbname,
  1232.                   &bufHdr->sb_relname, bufdb, bufrel,
  1233.                   bufHdr->tag.blockNum,
  1234.                   (char *) MAKE_PTR(bufHdr->data));
  1235.     }
  1236.  
  1237.     if (status == SM_FAIL)
  1238.     return (FALSE);
  1239.  
  1240.     return (TRUE);
  1241. }
  1242.  
  1243. /**************************************************
  1244.   BufferIsDirty
  1245.  
  1246.  **************************************************/
  1247.  
  1248. bool
  1249. BufferIsDirty(buffer)
  1250.     Buffer buffer;
  1251. {
  1252.     return (bool)
  1253.         (BufferGetBufferDescriptor(buffer)->flags & BM_DIRTY);
  1254. }
  1255.  
  1256.  
  1257. /**************************************************
  1258.   BufferIsInvalid
  1259.  
  1260.  **************************************************/
  1261. bool
  1262. BufferIsInvalid(buffer)
  1263.         Buffer  buffer;
  1264. {
  1265.     return (bool)
  1266.         (buffer == InvalidBuffer);
  1267. }
  1268.  
  1269.  
  1270. /**************************************************
  1271.   BufferIsUnknown
  1272.  
  1273.  **************************************************/
  1274. bool
  1275. BufferIsUnknown(buffer)
  1276.     Buffer      buffer;
  1277. {
  1278.     return (bool)
  1279.         (buffer == UnknownBuffer);
  1280. }
  1281.  
  1282. /***************************************************
  1283.  * RelationGetNumberOfPages --
  1284.  *      Returns number of pages in an open relation.
  1285.  *
  1286.  * Note:
  1287.  *      XXX may fail for huge relations.
  1288.  *      XXX should be elsewhere.
  1289.  *      XXX maybe should be hidden
  1290.  ***************************************************
  1291.  */
  1292.  
  1293. BlockNumber
  1294. RelationGetNumberOfBlocks(relation)
  1295. Relation        relation;
  1296. {
  1297.      return (smgrnblocks(relation->rd_rel->relsmgr, relation));
  1298. }
  1299.  
  1300. /**************************************************
  1301.   BufferGetBlock
  1302.  
  1303.  **************************************************/
  1304.  
  1305. Block
  1306. BufferGetBlock(buffer)
  1307.         Buffer  buffer;
  1308. {
  1309.     Assert(BufferIsValid(buffer));
  1310.  
  1311.     return((Block)MAKE_PTR(BufferDescriptors[buffer-1].data));
  1312. }
  1313.  
  1314. /* ---------------------------------------------------------------------
  1315.  *      ReleaseTmpRelBuffers
  1316.  *
  1317.  *      this function unmarks all the dirty pages of a temporary
  1318.  *      relation in the buffer pool so that at the end of transaction
  1319.  *      these pages will not be flushed.
  1320.  *      XXX currently it sequentially searches the buffer pool, should be
  1321.  *      changed to more clever ways of searching.
  1322.  * --------------------------------------------------------------------
  1323.  */
  1324. void
  1325. ReleaseTmpRelBuffers(tempreldesc)
  1326. Relation tempreldesc;
  1327. {
  1328.     register int i;
  1329.     BufferDesc *buf;
  1330.  
  1331.     for (i=1; i<=NBuffers; i++) {
  1332.     buf = BufferGetBufferDescriptor(i);
  1333.         if (BufferIsDirty(i) &&
  1334.             (buf->tag.relId.dbId == MyDatabaseId) &&
  1335.             (buf->tag.relId.relId == tempreldesc->rd_id)) {
  1336.             buf->flags &= ~BM_DIRTY;
  1337.             if (!(buf->flags & BM_FREE))
  1338.                ReleaseBuffer(i);
  1339.         }
  1340.      }
  1341. }
  1342.  
  1343. /* ---------------------------------------------------------------------
  1344.  *      DropBuffers
  1345.  *
  1346.  *    This function marks all the buffers in the buffer cache for a
  1347.  *    particular database as clean.  This is used when we destroy a
  1348.  *    database, to avoid trying to flush data to disk when the directory
  1349.  *    tree no longer exists.
  1350.  *
  1351.  *    This is an exceedingly non-public interface.
  1352.  * --------------------------------------------------------------------
  1353.  */
  1354.  
  1355. void
  1356. DropBuffers(dbid)
  1357. ObjectId dbid;
  1358. {
  1359.     register int i;
  1360.     BufferDesc *buf;
  1361.  
  1362.     for (i=1; i<=NBuffers; i++) {
  1363.     buf = BufferGetBufferDescriptor(i);
  1364.         if ((buf->tag.relId.dbId == dbid) && (buf->flags & BM_DIRTY)) {
  1365.             buf->flags &= ~BM_DIRTY;
  1366.         }
  1367.      }
  1368. }
  1369.  
  1370. /* -----------------------------------------------------------------
  1371.  *    PrintBufferDescs
  1372.  *
  1373.  *    this function prints all the buffer descriptors, for debugging
  1374.  *    use only.
  1375.  * -----------------------------------------------------------------
  1376.  */
  1377.  
  1378. void
  1379. PrintBufferDescs()
  1380. {
  1381.     register int i;
  1382.     BufferDesc *buf;
  1383.  
  1384.     for (i=0; i<NBuffers; i++) {
  1385.     buf = &(BufferDescriptors[i]);
  1386.     printf("(freeNext=%d, freePrev=%d, relname=%s, blockNum=%d, flags=0x%x, refcount=%d %d)\n", buf->freeNext, buf->freePrev, &(buf->sb_relname), buf->tag.blockNum, buf->flags, buf->refcount, PrivateRefCount[i]);
  1387.      }
  1388. }
  1389.  
  1390. void
  1391. PrintPinnedBufs()
  1392. {
  1393.     register int i;
  1394.     BufferDesc *buf;
  1395.  
  1396.     for (i=0; i<NBuffers; i++) {
  1397.     buf = &(BufferDescriptors[i]);
  1398.     if (PrivateRefCount[i] > 0)
  1399.         printf("(freeNext=%d, freePrev=%d, relname=%s, blockNum=%d, flags=0x%x, refcount=%d %d)\n", buf->freeNext, buf->freePrev, &(buf->sb_relname), buf->tag.blockNum, buf->flags, buf->refcount, PrivateRefCount[i]);
  1400.      }
  1401. }
  1402.  
  1403. /* -----------------------------------------------------
  1404.  * BufferShmemSize
  1405.  *
  1406.  * compute the size of shared memory for the buffer pool including
  1407.  * data pages, buffer descriptors, hash tables, etc.
  1408.  * ----------------------------------------------------
  1409.  */
  1410.  
  1411. int
  1412. BufferShmemSize()
  1413. {
  1414.     int size;
  1415.     int nbuckets;
  1416.     int nsegs;
  1417.     int tmp;
  1418.  
  1419.     nbuckets = 1 << (int)my_log2((NBuffers - 1) / DEF_FFACTOR + 1);
  1420.     nsegs = 1 << (int)my_log2((nbuckets - 1) / DEF_SEGSIZE + 1);
  1421.     size =  /* size of shmem binding table */
  1422.         my_log2(BTABLE_SIZE) + sizeof(HHDR);
  1423.     size += DEF_SEGSIZE * sizeof(SEGMENT) + BUCKET_ALLOC_INCR * 
  1424.         (sizeof(BUCKET_INDEX) + BTABLE_KEYSIZE + BTABLE_DATASIZE);
  1425.          /* size of buffer descriptors */
  1426.     size += (NBuffers + 1) * sizeof(BufferDesc);
  1427.         /* size of data pages */
  1428.     size += NBuffers * BLOCK_SIZE;
  1429.         /* size of buffer hash table */
  1430.     size += my_log2(NBuffers) + sizeof(HHDR);
  1431.     size += nsegs * DEF_SEGSIZE * sizeof(SEGMENT);
  1432.     tmp = (int)ceil((double)NBuffers/BUCKET_ALLOC_INCR);
  1433.     size += tmp * BUCKET_ALLOC_INCR * 
  1434.         (sizeof(BUCKET_INDEX) + sizeof(BufferTag) + sizeof(Buffer));
  1435.         /* extra space, just to make sure there is enough  */
  1436.     size += NBuffers * 4 + 4096;
  1437.  
  1438. #ifdef BMTRACE
  1439.     size += (BMT_LIMIT * sizeof(bmtrace)) + sizeof(int);
  1440. #endif
  1441.     return size;
  1442. }
  1443.  
  1444. /*
  1445.  * BufferPoolBlowaway
  1446.  *
  1447.  * this routine is solely for the purpose of experiments -- sometimes
  1448.  * you may want to blowaway whatever is left from the past in buffer
  1449.  * pool and start measuring some performance with a clean empty buffer
  1450.  * pool.
  1451.  */
  1452. void
  1453. BufferPoolBlowaway()
  1454. {
  1455.     register int i;
  1456.     
  1457.     BufferSync();
  1458.     for (i=1; i<=NBuffers; i++) {
  1459.         if (BufferIsValid(i)) {
  1460.             while(BufferIsValid(i))
  1461.                 ReleaseBuffer(i);
  1462.         }
  1463.         BufTableDelete(BufferGetBufferDescriptor(i));
  1464.     }
  1465. }
  1466.  
  1467. #undef IncrBufferRefCount
  1468. #undef ReleaseBuffer
  1469.  
  1470. IncrBufferRefCount(buffer)
  1471. Buffer buffer;
  1472. {
  1473.     PrivateRefCount[buffer - 1]++;
  1474. }
  1475.  
  1476. /*
  1477.  * ReleaseBuffer -- remove the pin on a buffer without
  1478.  *     marking it dirty.
  1479.  *
  1480.  */
  1481.  
  1482. ReleaseBuffer(buffer)
  1483. Buffer    buffer;
  1484. {
  1485.   BufferDesc    *bufHdr;
  1486.  
  1487.   if (BAD_BUFFER_ID(buffer)) {
  1488.     return(STATUS_ERROR);
  1489.   }
  1490.   bufHdr = BufferGetBufferDescriptor(buffer);
  1491.  
  1492.   Assert(PrivateRefCount[buffer - 1] > 0);
  1493.   PrivateRefCount[buffer - 1]--;
  1494.   if (PrivateRefCount[buffer - 1] == 0 && LastRefCount[buffer - 1] == 0) {
  1495.       /* only release buffer if it is not pinned in previous ExecMain levels */
  1496.       SpinAcquire(BufMgrLock);
  1497.       bufHdr->refcount--;
  1498.       if (bufHdr->refcount == 0) {
  1499.       AddBufferToFreelist(bufHdr);
  1500.       bufHdr->flags |= BM_FREE;
  1501.       }
  1502.       SpinRelease(BufMgrLock);
  1503.   }
  1504.  
  1505.   return(STATUS_OK);
  1506. }
  1507.  
  1508. int ShowPinTrace = 0;
  1509.  
  1510. IncrBufferRefCount_Debug(file, line, buffer)
  1511. String file;
  1512. int line;
  1513. Buffer buffer;
  1514. {
  1515.     IncrBufferRefCount(buffer);
  1516.     if (ShowPinTrace && is_userbuffer(buffer)) {
  1517.         BufferDesc *buf;
  1518.         buf = BufferGetBufferDescriptor(buffer);
  1519.         fprintf(stderr, "PIN(Incr) %d relname = %s, blockNum = %d, refcount = %d, file: %s, line: %d\n", buffer, &(buf->sb_relname), buf->tag.blockNum, PrivateRefCount[buffer - 1], file, line);
  1520.       }
  1521. }
  1522.  
  1523. ReleaseBuffer_Debug(file, line, buffer)
  1524. String file;
  1525. int line;
  1526. Buffer buffer;
  1527. {
  1528.     ReleaseBuffer(buffer);
  1529.     if (ShowPinTrace && is_userbuffer(buffer)) {
  1530.         BufferDesc *buf;
  1531.     buf = BufferGetBufferDescriptor(buffer);
  1532.         fprintf(stderr, "UNPIN(Rel) %d relname = %s, blockNum = %d, refcount = %d, file: %s, line: %d\n", buffer, &(buf->sb_relname), buf->tag.blockNum, PrivateRefCount[buffer - 1], file, line);
  1533.       }
  1534. }
  1535.  
  1536. ReleaseAndReadBuffer_Debug(file, line, buffer, relation, blockNum)
  1537. String file;
  1538. int line;
  1539. Buffer buffer;
  1540. Relation relation;
  1541. BlockNumber blockNum;
  1542. {
  1543.     bool bufferValid;
  1544.     Buffer b;
  1545.  
  1546.     bufferValid = BufferIsValid(buffer);
  1547.     b = ReleaseAndReadBuffer(buffer, relation, blockNum);
  1548.     if (ShowPinTrace && bufferValid && is_userbuffer(buffer)) {
  1549.     BufferDesc *buf;
  1550.     buf = BufferGetBufferDescriptor(buffer);
  1551.         fprintf(stderr, "UNPIN(Rel&Rd) %d relname = %s, blockNum = %d, refcount = %d, file: %s, line: %d\n", buffer, &(buf->sb_relname), buf->tag.blockNum, PrivateRefCount[buffer - 1], file, line);
  1552.       }
  1553.     if (ShowPinTrace && is_userbuffer(buffer)) {
  1554.     BufferDesc *buf;
  1555.     buf = BufferGetBufferDescriptor(b);
  1556.         fprintf(stderr, "PIN(Rel&Rd) %d relname = %s, blockNum = %d, refcount = %d, file: %s, line: %d\n", b, &(buf->sb_relname), buf->tag.blockNum, PrivateRefCount[b - 1], file, line);
  1557.       }
  1558.     return b;
  1559. }
  1560.  
  1561. #ifdef BMTRACE
  1562.  
  1563. /*
  1564.  *  trace allocations and deallocations in a circular buffer in
  1565.  *  shared memory.  check the buffer before doing the allocation,
  1566.  *  and die if there's anything fishy.
  1567.  */
  1568.  
  1569. _bm_trace(dbId, relId, blkNo, bufNo, allocType)
  1570.     long dbId;
  1571.     long relId;
  1572.     int blkNo;
  1573.     int bufNo;
  1574.     int allocType;
  1575. {
  1576.     static int mypid = 0;
  1577.     int start, cur;
  1578.     bmtrace *tb;
  1579.  
  1580.     if (mypid == 0)
  1581.     mypid = getpid();
  1582.  
  1583.     start = *CurTraceBuf;
  1584.  
  1585.     if (start > 0)
  1586.     cur = start - 1;
  1587.     else
  1588.     cur = BMT_LIMIT - 1;
  1589.  
  1590.     for (;;) {
  1591.     tb = &TraceBuf[cur];
  1592.     if (tb->bmt_op != BMT_NOTUSED) {
  1593.         if (tb->bmt_buf == bufNo) {
  1594.         if ((tb->bmt_op == BMT_DEALLOC)
  1595.             || (tb->bmt_dbid == dbId && tb->bmt_relid == relId
  1596.             && tb->bmt_blkno == blkNo))
  1597.             goto okay;
  1598.  
  1599.         /* die holding the buffer lock */
  1600.         _bm_die(dbId, relId, blkNo, bufNo, allocType, start, cur);
  1601.         }
  1602.     }
  1603.  
  1604.     if (cur == start)
  1605.         goto okay;
  1606.  
  1607.     if (cur == 0)
  1608.         cur = BMT_LIMIT - 1;
  1609.     else
  1610.         cur--;
  1611.     }
  1612.  
  1613. okay:
  1614.     tb = &TraceBuf[start];
  1615.     tb->bmt_pid = mypid;
  1616.     tb->bmt_buf = bufNo;
  1617.     tb->bmt_dbid = dbId;
  1618.     tb->bmt_relid = relId;
  1619.     tb->bmt_blkno = blkNo;
  1620.     tb->bmt_op = allocType;
  1621.  
  1622.     *CurTraceBuf = (start + 1) % BMT_LIMIT;
  1623. }
  1624.  
  1625. _bm_die(dbId, relId, blkNo, bufNo, allocType, start, cur)
  1626.     long dbId;
  1627.     long relId;
  1628.     int blkNo;
  1629.     int bufNo;
  1630.     int allocType;
  1631.     int start;
  1632.     int cur;
  1633. {
  1634.     FILE *fp;
  1635.     bmtrace *tb;
  1636.     int i;
  1637.  
  1638.     tb = &TraceBuf[cur];
  1639.  
  1640.     if ((fp = fopen("/tmp/death_notice", "w")) == (FILE *) NULL)
  1641.     elog(FATAL, "buffer alloc trace error and can't open log file");
  1642.  
  1643.     fprintf(fp, "buffer alloc trace detected the following error:\n\n");
  1644.     fprintf(fp, "    buffer %d being %s inconsistently with a previous %s\n\n",
  1645.         bufNo, (allocType == BMT_DEALLOC ? "deallocated" : "allocated"),
  1646.         (tb->bmt_op == BMT_DEALLOC ? "deallocation" : "allocation"));
  1647.  
  1648.     fprintf(fp, "the trace buffer contains:\n");
  1649.  
  1650.     i = start;
  1651.     for (;;) {
  1652.     tb = &TraceBuf[i];
  1653.     if (tb->bmt_op != BMT_NOTUSED) {
  1654.         fprintf(fp, "     [%3d]%spid %d buf %2d for <%d,%d,%d> ",
  1655.             i, (i == cur ? " ---> " : "\t"),
  1656.             tb->bmt_pid, tb->bmt_buf,
  1657.             tb->bmt_dbid, tb->bmt_relid, tb->bmt_blkno);
  1658.  
  1659.         switch (tb->bmt_op) {
  1660.           case BMT_ALLOCFND:
  1661.         fprintf(fp, "allocate (found)\n");
  1662.         break;
  1663.  
  1664.           case BMT_ALLOCNOTFND:
  1665.         fprintf(fp, "allocate (not found)\n");
  1666.         break;
  1667.  
  1668.           case BMT_DEALLOC:
  1669.         fprintf(fp, "deallocate\n");
  1670.         break;
  1671.  
  1672.           default:
  1673.         fprintf(fp, "unknown op type %d\n", tb->bmt_op);
  1674.         break;
  1675.         }
  1676.     }
  1677.  
  1678.     i = (i + 1) % BMT_LIMIT;
  1679.     if (i == start)
  1680.         break;
  1681.     }
  1682.  
  1683.     fprintf(fp, "\noperation causing error:\n");
  1684.     fprintf(fp, "\tpid %d buf %d for <%d,%d,%d> ",
  1685.         getpid(), bufNo, dbId, relId, blkNo);
  1686.  
  1687.     switch (allocType) {
  1688.       case BMT_ALLOCFND:
  1689.     fprintf(fp, "allocate (found)\n");
  1690.     break;
  1691.  
  1692.       case BMT_ALLOCNOTFND:
  1693.     fprintf(fp, "allocate (not found)\n");
  1694.     break;
  1695.  
  1696.       case BMT_DEALLOC:
  1697.     fprintf(fp, "deallocate\n");
  1698.     break;
  1699.  
  1700.       default:
  1701.     fprintf(fp, "unknown op type %d\n", allocType);
  1702.     break;
  1703.     }
  1704.  
  1705.     (void) fclose(fp);
  1706.  
  1707.     kill(getpid(), SIGILL);
  1708. }
  1709.  
  1710. #endif /* BMTRACE */
  1711.  
  1712. void
  1713. BufferRefCountReset(refcountsave)
  1714. int *refcountsave;
  1715. {
  1716.     int i;
  1717.     for (i=0; i<NBuffers; i++) {
  1718.     refcountsave[i] = PrivateRefCount[i];
  1719.     LastRefCount[i] += PrivateRefCount[i];
  1720.     PrivateRefCount[i] = 0;
  1721.       }
  1722. }
  1723.  
  1724. void
  1725. BufferRefCountRestore(refcountsave)
  1726. int *refcountsave;
  1727. {
  1728.     int i;
  1729.     for (i=0; i<NBuffers; i++) {
  1730.     PrivateRefCount[i] = refcountsave[i];
  1731.     LastRefCount[i] -= PrivateRefCount[i];
  1732.     refcountsave[i] = 0;
  1733.       }
  1734. }
  1735.