Fixing possible losing data changes:

1. New flag - BM_JUST_DIRTIED - added for BufferDesc;
2. All data "dirtiers" (WriteBuffer and WriteNoReleaseBuffer)
   set this flag (and BM_DIRTY too);
3. All data "flushers" (FlushBuffer, BufferSync and BufferReplace)
   turn this flag off just before calling smgr[blind]write/smgrflush
   and check this flag after flushing buffer: if it turned ON then
   BM_DIRTY will stay ON.

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 419e8865477042e8be8e74d4a9bcad5466ad2e1c..edb88596927167ec54c19415dad705c49587f12b 100644 (file)
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *    $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.8 1997/01/16 08:11:41 vadim Exp $
+ *    $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.9 1997/01/20 04:36:48 vadim Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -474,7 +474,19 @@ BufferAlloc(Relation reln,
        else
        {
        BufferFlushCount++;
-       buf->flags &= ~BM_DIRTY;
+       /*
+        * BM_JUST_DIRTIED cleared by BufferReplace and shouldn't
+        * be setted by anyone.     - vadim 01/17/97
+        */
+       if ( buf->flags & BM_JUST_DIRTIED )
+       {
+           elog (FATAL, "BufferAlloc: content of block %u (%s) changed while flushing",
+            buf->tag.blockNum, buf->sb_relname);
+       }
+       else
+       {
+           buf->flags &= ~BM_DIRTY;
+       }
        }
        
        /*
@@ -488,7 +500,8 @@ BufferAlloc(Relation reln,
         * no reason to think that we have an immediate disaster on
         * our hands.
         */
-       if (buf && buf->refcount > 1) {
+       if ( buf && buf->refcount > 1 )
+       {
        inProgress = FALSE;
        buf->flags &= ~BM_IO_IN_PROGRESS;
 #ifdef HAS_TEST_AND_SET
@@ -643,7 +656,7 @@ WriteBuffer(Buffer buffer)
    
    SpinAcquire(BufMgrLock);
    Assert(bufHdr->refcount > 0);
-   bufHdr->flags |= BM_DIRTY; 
+   bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
    UnpinBuffer(bufHdr);
    SpinRelease(BufMgrLock);
     }
@@ -733,19 +746,36 @@ FlushBuffer(Buffer buffer, bool release)
     bufrel = RelationIdCacheGetRelation (bufHdr->tag.relId.relId);
     Assert (bufrel != (Relation) NULL);
 
+    /* To check if block content changed while flushing. - vadim 01/17/97 */
+    SpinAcquire(BufMgrLock); 
+    bufHdr->flags &= ~BM_JUST_DIRTIED; 
+    SpinRelease(BufMgrLock);
+
     status = smgrflush(bufHdr->bufsmgr, bufrel, bufHdr->tag.blockNum,
               (char *) MAKE_PTR(bufHdr->data));
     
     if (status == SM_FAIL)
     {
-   elog(WARN, "FlushBuffer: cannot flush block %u of the relation %.*s", 
-           bufHdr->tag.blockNum, 
-           NAMEDATALEN, bufrel->rd_rel->relname.data);
+   elog(WARN, "FlushBuffer: cannot flush block %u of the relation %s", 
+           bufHdr->tag.blockNum, bufHdr->sb_relname);
    return (STATUS_ERROR);
     }
     
     SpinAcquire(BufMgrLock); 
-    bufHdr->flags &= ~BM_DIRTY; 
+    /*
+     * If this buffer was marked by someone as DIRTY while
+     * we were flushing it out we must not clear DIRTY flag
+     *  - vadim 01/17/97
+     */
+    if ( bufHdr->flags & BM_JUST_DIRTIED )
+    {
+   elog (NOTICE, "FlusfBuffer: content of block %u (%s) changed while flushing",
+           bufHdr->tag.blockNum, bufHdr->sb_relname);
+    }
+    else
+    {
+       bufHdr->flags &= ~BM_DIRTY;
+    }
     if ( release )
        UnpinBuffer(bufHdr);
     SpinRelease(BufMgrLock);
@@ -779,7 +809,7 @@ WriteNoReleaseBuffer(Buffer buffer)
    bufHdr = &BufferDescriptors[buffer-1];
    
    SpinAcquire(BufMgrLock);
-   bufHdr->flags |= BM_DIRTY; 
+   bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
    SpinRelease(BufMgrLock);
     }
     return(STATUS_OK);
@@ -878,13 +908,19 @@ BufferSync()
            UnpinBuffer(bufHdr);
            if (bufHdr->flags & BM_IO_ERROR)
            {
-           elog(WARN, "cannot write %u for %s",
+           elog(WARN, "BufferSync: write error %u for %s",
                bufHdr->tag.blockNum, bufHdr->sb_relname);
            }
            if (reln != (Relation)NULL)
            RelationDecrementReferenceCount(reln);
            continue;
        }
+       
+       /*
+        * To check if block content changed while flushing
+        * (see below). - vadim 01/17/97
+        */
+       bufHdr->flags &= ~BM_JUST_DIRTIED;
 
        /*
         *  If we didn't have the reldesc in our local cache, flush this
@@ -912,15 +948,23 @@ BufferSync()
        UnpinBuffer(bufHdr);
        if (status == SM_FAIL) {
            bufHdr->flags |= BM_IO_ERROR;
-           elog(WARN, "cannot write %u for %s",
+           elog(WARN, "BufferSync: cannot write %u for %s",
             bufHdr->tag.blockNum, bufHdr->sb_relname);
        }
        /*
-        * What if someone has marked this buffer as DIRTY after
-        * smgr[blind]write but before SpinAcquire(BufMgrLock)
-        * ??? - vadim 01/16/97
+        * If this buffer was marked by someone as DIRTY while
+        * we were flushing it out we must not clear DIRTY flag
+        *  - vadim 01/17/97
         */
-       bufHdr->flags &= ~BM_DIRTY;
+       if ( bufHdr->flags & BM_JUST_DIRTIED )
+       {
+           elog (NOTICE, "BufferSync: content of block %u (%s) changed while flushing",
+            bufHdr->tag.blockNum, bufHdr->sb_relname);
+       }
+       else
+       {
+           bufHdr->flags &= ~BM_DIRTY;
+       }
        if (reln != (Relation)NULL)
            RelationDecrementReferenceCount(reln);
        }
@@ -1189,6 +1233,9 @@ BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld)
    reln = RelationIdCacheGetRelation(bufrel);
     else
    reln = (Relation) NULL;
+
+    /* To check if block content changed while flushing. - vadim 01/17/97 */
+    bufHdr->flags &= ~BM_JUST_DIRTIED;
     
     SpinRelease(BufMgrLock);