When two base backups are started at the same time with pg_basebackup,

ensure that they use different checkpoints as the starting point. We use
the checkpoint redo location as a unique identifier for the base backup in
the end-of-backup record, and in the backup history file name.

Bug spotted by Fujii Masao.

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 45ba0013c8a2e21ba5ed645c37a88f022be3ab74..306ac058c365c15fd32deed7677aefe668bb6028 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -355,10 +355,13 @@ typedef struct XLogCtlInsert
     * exclusiveBackup is true if a backup started with pg_start_backup() is
     * in progress, and nonExclusiveBackups is a counter indicating the number
     * of streaming base backups currently in progress. forcePageWrites is
-    * set to true when either of these is non-zero.
+    * set to true when either of these is non-zero. lastBackupStart is the
+    * latest checkpoint redo location used as a starting point for an online
+    * backup.
     */
    bool        exclusiveBackup;
    int         nonExclusiveBackups;
+   XLogRecPtr  lastBackupStart;
 } XLogCtlInsert;
 
 /*
@@ -8808,6 +8811,19 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
                 errmsg("backup label too long (max %d bytes)",
                        MAXPGPATH)));
 
+   /*
+    * Force an XLOG file switch before the checkpoint, to ensure that the WAL
+    * segment the checkpoint is written to doesn't contain pages with old
+    * timeline IDs. That would otherwise happen if you called
+    * pg_start_backup() right after restoring from a PITR archive: the first
+    * WAL segment containing the startup checkpoint has pages in the
+    * beginning with the old timeline ID. That can cause trouble at recovery:
+    * we won't have a history file covering the old timeline if pg_xlog
+    * directory was not included in the base backup and the WAL archive was
+    * cleared too before starting the backup.
+    */
+   RequestXLogSwitch();
+
    /*
     * Mark backup active in shared memory.  We must do full-page WAL writes
     * during an on-line backup even if not doing so at other times, because
@@ -8843,43 +8859,54 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
    XLogCtl->Insert.forcePageWrites = true;
    LWLockRelease(WALInsertLock);
 
-   /*
-    * Force an XLOG file switch before the checkpoint, to ensure that the WAL
-    * segment the checkpoint is written to doesn't contain pages with old
-    * timeline IDs. That would otherwise happen if you called
-    * pg_start_backup() right after restoring from a PITR archive: the first
-    * WAL segment containing the startup checkpoint has pages in the
-    * beginning with the old timeline ID. That can cause trouble at recovery:
-    * we won't have a history file covering the old timeline if pg_xlog
-    * directory was not included in the base backup and the WAL archive was
-    * cleared too before starting the backup.
-    */
-   RequestXLogSwitch();
-
    /* Ensure we release forcePageWrites if fail below */
    PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
    {
-       /*
-        * Force a CHECKPOINT.  Aside from being necessary to prevent torn
-        * page problems, this guarantees that two successive backup runs will
-        * have different checkpoint positions and hence different history
-        * file names, even if nothing happened in between.
-        *
-        * We use CHECKPOINT_IMMEDIATE only if requested by user (via passing
-        * fast = true).  Otherwise this can take awhile.
-        */
-       RequestCheckpoint(CHECKPOINT_FORCE | CHECKPOINT_WAIT |
-                         (fast ? CHECKPOINT_IMMEDIATE : 0));
+       bool gotUniqueStartpoint = false;
+       do
+       {
+           /*
+            * Force a CHECKPOINT.  Aside from being necessary to prevent torn
+            * page problems, this guarantees that two successive backup runs will
+            * have different checkpoint positions and hence different history
+            * file names, even if nothing happened in between.
+            *
+            * We use CHECKPOINT_IMMEDIATE only if requested by user (via passing
+            * fast = true).  Otherwise this can take awhile.
+            */
+           RequestCheckpoint(CHECKPOINT_FORCE | CHECKPOINT_WAIT |
+                             (fast ? CHECKPOINT_IMMEDIATE : 0));
 
-       /*
-        * Now we need to fetch the checkpoint record location, and also its
-        * REDO pointer.  The oldest point in WAL that would be needed to
-        * restore starting from the checkpoint is precisely the REDO pointer.
-        */
-       LWLockAcquire(ControlFileLock, LW_SHARED);
-       checkpointloc = ControlFile->checkPoint;
-       startpoint = ControlFile->checkPointCopy.redo;
-       LWLockRelease(ControlFileLock);
+           /*
+            * Now we need to fetch the checkpoint record location, and also its
+            * REDO pointer.  The oldest point in WAL that would be needed to
+            * restore starting from the checkpoint is precisely the REDO pointer.
+            */
+           LWLockAcquire(ControlFileLock, LW_SHARED);
+           checkpointloc = ControlFile->checkPoint;
+           startpoint = ControlFile->checkPointCopy.redo;
+           LWLockRelease(ControlFileLock);
+
+           /*
+            * If two base backups are started at the same time (in WAL
+            * sender processes), we need to make sure that they use
+            * different checkpoints as starting locations, because we use
+            * the starting WAL location as a unique identifier for the base
+            * backup in the end-of-backup WAL record and when we write the
+            * backup history file. Perhaps it would be better generate a
+            * separate unique ID for each backup instead of forcing another
+            * checkpoint, but taking a checkpoint right after another is
+            * not that expensive either because only few buffers have been
+            * dirtied yet.
+            */
+           LWLockAcquire(WALInsertLock, LW_SHARED);
+           if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
+           {
+               XLogCtl->Insert.lastBackupStart = startpoint;
+               gotUniqueStartpoint = true;
+           }
+           LWLockRelease(WALInsertLock);
+       } while(!gotUniqueStartpoint);
 
        XLByteToSeg(startpoint, _logId, _logSeg);
        XLogFileName(xlogfilename, ThisTimeLineID, _logId, _logSeg);