diff options
Diffstat (limited to 'src/backend/access/transam/xlog.c')
| -rw-r--r-- | src/backend/access/transam/xlog.c | 318 |
1 files changed, 163 insertions, 155 deletions
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index 0f2678cfda0..bcb71c45b2a 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -344,10 +344,10 @@ typedef struct XLogCtlInsert /* * fullPageWrites is the master copy used by all backends to determine - * whether to write full-page to WAL, instead of using process-local - * one. This is required because, when full_page_writes is changed - * by SIGHUP, we must WAL-log it before it actually affects - * WAL-logging by backends. Checkpointer sets at startup or after SIGHUP. + * whether to write full-page to WAL, instead of using process-local one. + * This is required because, when full_page_writes is changed by SIGHUP, + * we must WAL-log it before it actually affects WAL-logging by backends. + * Checkpointer sets at startup or after SIGHUP. */ bool fullPageWrites; @@ -455,8 +455,11 @@ typedef struct XLogCtlData XLogRecPtr recoveryLastRecPtr; /* timestamp of last COMMIT/ABORT record replayed (or being replayed) */ TimestampTz recoveryLastXTime; - /* timestamp of when we started replaying the current chunk of WAL data, - * only relevant for replication or archive recovery */ + + /* + * timestamp of when we started replaying the current chunk of WAL data, + * only relevant for replication or archive recovery + */ TimestampTz currentChunkStartTime; /* end of the last record restored from the archive */ XLogRecPtr restoreLastRecPtr; @@ -580,7 +583,7 @@ static bool updateMinRecoveryPoint = true; * to replay all the WAL, so reachedConsistency is never set. During archive * recovery, the database is consistent once minRecoveryPoint is reached. */ -bool reachedConsistency = false; +bool reachedConsistency = false; static bool InRedo = false; @@ -750,8 +753,8 @@ XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata) * insert lock, but it seems better to avoid doing CRC calculations while * holding the lock. * - * We add entries for backup blocks to the chain, so that they don't - * need any special treatment in the critical section where the chunks are + * We add entries for backup blocks to the chain, so that they don't need + * any special treatment in the critical section where the chunks are * copied into the WAL buffers. Those entries have to be unlinked from the * chain if we have to loop back here. */ @@ -896,10 +899,10 @@ begin:; /* * Calculate CRC of the data, including all the backup blocks * - * Note that the record header isn't added into the CRC initially since - * we don't know the prev-link yet. Thus, the CRC will represent the CRC - * of the whole record in the order: rdata, then backup blocks, then - * record header. + * Note that the record header isn't added into the CRC initially since we + * don't know the prev-link yet. Thus, the CRC will represent the CRC of + * the whole record in the order: rdata, then backup blocks, then record + * header. */ INIT_CRC32(rdata_crc); for (rdt = rdata; rdt != NULL; rdt = rdt->next) @@ -948,10 +951,10 @@ begin:; } /* - * Also check to see if fullPageWrites or forcePageWrites was just turned on; - * if we weren't already doing full-page writes then go back and recompute. - * (If it was just turned off, we could recompute the record without full pages, - * but we choose not to bother.) + * Also check to see if fullPageWrites or forcePageWrites was just turned + * on; if we weren't already doing full-page writes then go back and + * recompute. (If it was just turned off, we could recompute the record + * without full pages, but we choose not to bother.) */ if ((Insert->fullPageWrites || Insert->forcePageWrites) && !doPageWrites) { @@ -1575,15 +1578,15 @@ AdvanceXLInsertBuffer(bool new_segment) * WAL records beginning in this page have removable backup blocks. This * allows the WAL archiver to know whether it is safe to compress archived * WAL data by transforming full-block records into the non-full-block - * format. It is sufficient to record this at the page level because we + * format. It is sufficient to record this at the page level because we * force a page switch (in fact a segment switch) when starting a backup, * so the flag will be off before any records can be written during the - * backup. At the end of a backup, the last page will be marked as all + * backup. At the end of a backup, the last page will be marked as all * unsafe when perhaps only part is unsafe, but at worst the archiver * would miss the opportunity to compress a few records. */ if (!Insert->forcePageWrites) - NewPage->xlp_info |= XLP_BKP_REMOVABLE; + NewPage ->xlp_info |= XLP_BKP_REMOVABLE; /* * If first page of an XLOG segment file, make it a long header. @@ -1827,11 +1830,11 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch) Write->lastSegSwitchTime = (pg_time_t) time(NULL); /* - * Request a checkpoint if we've consumed too - * much xlog since the last one. For speed, we first check - * using the local copy of RedoRecPtr, which might be out of - * date; if it looks like a checkpoint is needed, forcibly - * update RedoRecPtr and recheck. + * Request a checkpoint if we've consumed too much xlog since + * the last one. For speed, we first check using the local + * copy of RedoRecPtr, which might be out of date; if it looks + * like a checkpoint is needed, forcibly update RedoRecPtr and + * recheck. */ if (IsUnderPostmaster && XLogCheckpointNeeded(openLogId, openLogSeg)) @@ -1931,7 +1934,7 @@ XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN) /* * If the WALWriter is sleeping, we should kick it to make it come out of - * low-power mode. Otherwise, determine whether there's a full page of + * low-power mode. Otherwise, determine whether there's a full page of * WAL available to write. */ if (!sleeping) @@ -1945,9 +1948,9 @@ XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN) } /* - * Nudge the WALWriter: it has a full page of WAL to write, or we want - * it to come out of low-power mode so that this async commit will reach - * disk within the expected amount of time. + * Nudge the WALWriter: it has a full page of WAL to write, or we want it + * to come out of low-power mode so that this async commit will reach disk + * within the expected amount of time. */ if (ProcGlobal->walwriterLatch) SetLatch(ProcGlobal->walwriterLatch); @@ -2076,8 +2079,8 @@ XLogFlush(XLogRecPtr record) WriteRqstPtr = record; /* - * Now wait until we get the write lock, or someone else does the - * flush for us. + * Now wait until we get the write lock, or someone else does the flush + * for us. */ for (;;) { @@ -2182,7 +2185,7 @@ XLogFlush(XLogRecPtr record) * block, and flush through the latest one of those. Thus, if async commits * are not being used, we will flush complete blocks only. We can guarantee * that async commits reach disk after at most three cycles; normally only - * one or two. (When flushing complete blocks, we allow XLogWrite to write + * one or two. (When flushing complete blocks, we allow XLogWrite to write * "flexibly", meaning it can stop at the end of the buffer ring; this makes a * difference only with very high load or long wal_writer_delay, but imposes * one extra cycle for the worst case for async commits.) @@ -2273,7 +2276,8 @@ XLogBackgroundFlush(void) /* * If we wrote something then we have something to send to standbys also, - * otherwise the replication delay become around 7s with just async commit. + * otherwise the replication delay become around 7s with just async + * commit. */ if (wrote_something) WalSndWakeup(); @@ -2776,17 +2780,17 @@ XLogFileRead(uint32 log, uint32 seg, int emode, TimeLineID tli, } /* - * If the segment was fetched from archival storage, replace - * the existing xlog segment (if any) with the archival version. + * If the segment was fetched from archival storage, replace the existing + * xlog segment (if any) with the archival version. */ if (source == XLOG_FROM_ARCHIVE) { /* use volatile pointer to prevent code rearrangement */ volatile XLogCtlData *xlogctl = XLogCtl; - XLogRecPtr endptr; - char xlogfpath[MAXPGPATH]; - bool reload = false; - struct stat statbuf; + XLogRecPtr endptr; + char xlogfpath[MAXPGPATH]; + bool reload = false; + struct stat statbuf; XLogFilePath(xlogfpath, tli, log, seg); if (stat(xlogfpath, &statbuf) == 0) @@ -2801,9 +2805,9 @@ XLogFileRead(uint32 log, uint32 seg, int emode, TimeLineID tli, if (rename(path, xlogfpath) < 0) ereport(ERROR, - (errcode_for_file_access(), - errmsg("could not rename file \"%s\" to \"%s\": %m", - path, xlogfpath))); + (errcode_for_file_access(), + errmsg("could not rename file \"%s\" to \"%s\": %m", + path, xlogfpath))); /* * If the existing segment was replaced, since walsenders might have @@ -3812,7 +3816,7 @@ ReadRecord(XLogRecPtr *RecPtr, int emode, bool fetching_ckpt) RecPtr = &tmpRecPtr; /* - * RecPtr is pointing to end+1 of the previous WAL record. We must + * RecPtr is pointing to end+1 of the previous WAL record. We must * advance it if necessary to where the next record starts. First, * align to next page if no more records can fit on the current page. */ @@ -5389,10 +5393,10 @@ readRecoveryCommandFile(void) } if (rtli) ereport(DEBUG2, - (errmsg_internal("recovery_target_timeline = %u", rtli))); + (errmsg_internal("recovery_target_timeline = %u", rtli))); else ereport(DEBUG2, - (errmsg_internal("recovery_target_timeline = latest"))); + (errmsg_internal("recovery_target_timeline = latest"))); } else if (strcmp(item->name, "recovery_target_xid") == 0) { @@ -5404,7 +5408,7 @@ readRecoveryCommandFile(void) item->value))); ereport(DEBUG2, (errmsg_internal("recovery_target_xid = %u", - recoveryTargetXid))); + recoveryTargetXid))); recoveryTarget = RECOVERY_TARGET_XID; } else if (strcmp(item->name, "recovery_target_time") == 0) @@ -5428,7 +5432,7 @@ readRecoveryCommandFile(void) Int32GetDatum(-1))); ereport(DEBUG2, (errmsg_internal("recovery_target_time = '%s'", - timestamptz_to_str(recoveryTargetTime)))); + timestamptz_to_str(recoveryTargetTime)))); } else if (strcmp(item->name, "recovery_target_name") == 0) { @@ -5576,13 +5580,13 @@ exitArchiveRecovery(TimeLineID endTLI, uint32 endLogId, uint32 endLogSeg) } /* - * If we are establishing a new timeline, we have to copy data from - * the last WAL segment of the old timeline to create a starting WAL - * segment for the new timeline. + * If we are establishing a new timeline, we have to copy data from the + * last WAL segment of the old timeline to create a starting WAL segment + * for the new timeline. * - * Notify the archiver that the last WAL segment of the old timeline - * is ready to copy to archival storage. Otherwise, it is not archived - * for a while. + * Notify the archiver that the last WAL segment of the old timeline is + * ready to copy to archival storage. Otherwise, it is not archived for a + * while. */ if (endTLI != ThisTimeLineID) { @@ -5604,8 +5608,8 @@ exitArchiveRecovery(TimeLineID endTLI, uint32 endLogId, uint32 endLogSeg) XLogArchiveCleanup(xlogpath); /* - * Since there might be a partial WAL segment named RECOVERYXLOG, - * get rid of it. + * Since there might be a partial WAL segment named RECOVERYXLOG, get rid + * of it. */ snprintf(recoveryPath, MAXPGPATH, XLOGDIR "/RECOVERYXLOG"); unlink(recoveryPath); /* ignore any error */ @@ -6323,11 +6327,11 @@ StartupXLOG(void) /* * Set backupStartPoint if we're starting recovery from a base backup. * - * Set backupEndPoint and use minRecoveryPoint as the backup end location - * if we're starting recovery from a base backup which was taken from - * the standby. In this case, the database system status in pg_control must - * indicate DB_IN_ARCHIVE_RECOVERY. If not, which means that backup - * is corrupted, so we cancel recovery. + * Set backupEndPoint and use minRecoveryPoint as the backup end + * location if we're starting recovery from a base backup which was + * taken from the standby. In this case, the database system status in + * pg_control must indicate DB_IN_ARCHIVE_RECOVERY. If not, which + * means that backup is corrupted, so we cancel recovery. */ if (haveBackupLabel) { @@ -6340,7 +6344,7 @@ StartupXLOG(void) ereport(FATAL, (errmsg("backup_label contains inconsistent data with control file"), errhint("This means that the backup is corrupted and you will " - "have to use another backup for recovery."))); + "have to use another backup for recovery."))); ControlFile->backupEndPoint = ControlFile->minRecoveryPoint; } } @@ -6383,15 +6387,15 @@ StartupXLOG(void) /* * We're in recovery, so unlogged relations may be trashed and must be - * reset. This should be done BEFORE allowing Hot Standby connections, - * so that read-only backends don't try to read whatever garbage is - * left over from before. + * reset. This should be done BEFORE allowing Hot Standby + * connections, so that read-only backends don't try to read whatever + * garbage is left over from before. */ ResetUnloggedRelations(UNLOGGED_RELATION_CLEANUP); /* - * Likewise, delete any saved transaction snapshot files that got - * left behind by crashed backends. + * Likewise, delete any saved transaction snapshot files that got left + * behind by crashed backends. */ DeleteAllExportedSnapshotFiles(); @@ -6489,10 +6493,11 @@ StartupXLOG(void) /* * Let postmaster know we've started redo now, so that it can launch - * checkpointer to perform restartpoints. We don't bother during crash - * recovery as restartpoints can only be performed during archive - * recovery. And we'd like to keep crash recovery simple, to avoid - * introducing bugs that could affect you when recovering after crash. + * checkpointer to perform restartpoints. We don't bother during + * crash recovery as restartpoints can only be performed during + * archive recovery. And we'd like to keep crash recovery simple, to + * avoid introducing bugs that could affect you when recovering after + * crash. * * After this point, we can no longer assume that we're the only * process in addition to postmaster! Also, fsync requests are @@ -6649,8 +6654,8 @@ StartupXLOG(void) { /* * We have reached the end of base backup, the point where - * the minimum recovery point in pg_control indicates. - * The data on disk is now consistent. Reset backupStartPoint + * the minimum recovery point in pg_control indicates. The + * data on disk is now consistent. Reset backupStartPoint * and backupEndPoint. */ elog(DEBUG1, "end of backup reached"); @@ -6863,9 +6868,9 @@ StartupXLOG(void) oldestActiveXID = PrescanPreparedTransactions(NULL, NULL); /* - * Update full_page_writes in shared memory and write an - * XLOG_FPW_CHANGE record before resource manager writes cleanup - * WAL records or checkpoint record is written. + * Update full_page_writes in shared memory and write an XLOG_FPW_CHANGE + * record before resource manager writes cleanup WAL records or checkpoint + * record is written. */ Insert->fullPageWrites = lastFullPageWrites; LocalSetXLogInsertAllowed(); @@ -6954,8 +6959,8 @@ StartupXLOG(void) LWLockRelease(ProcArrayLock); /* - * Start up the commit log and subtrans, if not already done for - * hot standby. + * Start up the commit log and subtrans, if not already done for hot + * standby. */ if (standbyState == STANDBY_DISABLED) { @@ -7705,9 +7710,9 @@ CreateCheckPoint(int flags) checkPoint.time = (pg_time_t) time(NULL); /* - * For Hot Standby, derive the oldestActiveXid before we fix the redo pointer. - * This allows us to begin accumulating changes to assemble our starting - * snapshot of locks and transactions. + * For Hot Standby, derive the oldestActiveXid before we fix the redo + * pointer. This allows us to begin accumulating changes to assemble our + * starting snapshot of locks and transactions. */ if (!shutdown && XLogStandbyInfoActive()) checkPoint.oldestActiveXid = GetOldestActiveTransactionId(); @@ -8062,7 +8067,7 @@ RecoveryRestartPoint(const CheckPoint *checkPoint) volatile XLogCtlData *xlogctl = XLogCtl; /* - * Is it safe to restartpoint? We must ask each of the resource managers + * Is it safe to restartpoint? We must ask each of the resource managers * whether they have any partial state information that might prevent a * correct restart from this point. If so, we skip this opportunity, but * return at the next checkpoint record for another try. @@ -8082,10 +8087,11 @@ RecoveryRestartPoint(const CheckPoint *checkPoint) } /* - * Also refrain from creating a restartpoint if we have seen any references - * to non-existent pages. Restarting recovery from the restartpoint would - * not see the references, so we would lose the cross-check that the pages - * belonged to a relation that was dropped later. + * Also refrain from creating a restartpoint if we have seen any + * references to non-existent pages. Restarting recovery from the + * restartpoint would not see the references, so we would lose the + * cross-check that the pages belonged to a relation that was dropped + * later. */ if (XLogHaveInvalidPages()) { @@ -8098,8 +8104,8 @@ RecoveryRestartPoint(const CheckPoint *checkPoint) } /* - * Copy the checkpoint record to shared memory, so that checkpointer - * can work out the next time it wants to perform a restartpoint. + * Copy the checkpoint record to shared memory, so that checkpointer can + * work out the next time it wants to perform a restartpoint. */ SpinLockAcquire(&xlogctl->info_lck); XLogCtl->lastCheckPointRecPtr = ReadRecPtr; @@ -8493,8 +8499,8 @@ UpdateFullPageWrites(void) * Do nothing if full_page_writes has not been changed. * * It's safe to check the shared full_page_writes without the lock, - * because we assume that there is no concurrently running process - * which can update it. + * because we assume that there is no concurrently running process which + * can update it. */ if (fullPageWrites == Insert->fullPageWrites) return; @@ -8505,8 +8511,8 @@ UpdateFullPageWrites(void) * It's always safe to take full page images, even when not strictly * required, but not the other round. So if we're setting full_page_writes * to true, first set it true and then write the WAL record. If we're - * setting it to false, first write the WAL record and then set the - * global flag. + * setting it to false, first write the WAL record and then set the global + * flag. */ if (fullPageWrites) { @@ -8516,12 +8522,12 @@ UpdateFullPageWrites(void) } /* - * Write an XLOG_FPW_CHANGE record. This allows us to keep - * track of full_page_writes during archive recovery, if required. + * Write an XLOG_FPW_CHANGE record. This allows us to keep track of + * full_page_writes during archive recovery, if required. */ if (XLogStandbyInfoActive() && !RecoveryInProgress()) { - XLogRecData rdata; + XLogRecData rdata; rdata.data = (char *) (&fullPageWrites); rdata.len = sizeof(bool); @@ -8561,7 +8567,7 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record) /* * We used to try to take the maximum of ShmemVariableCache->nextOid * and the recorded nextOid, but that fails if the OID counter wraps - * around. Since no OID allocation should be happening during replay + * around. Since no OID allocation should be happening during replay * anyway, better to just believe the record exactly. We still take * OidGenLock while setting the variable, just in case. */ @@ -8597,7 +8603,7 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record) !XLogRecPtrIsInvalid(ControlFile->backupStartPoint) && XLogRecPtrIsInvalid(ControlFile->backupEndPoint)) ereport(PANIC, - (errmsg("online backup was canceled, recovery cannot continue"))); + (errmsg("online backup was canceled, recovery cannot continue"))); /* * If we see a shutdown checkpoint, we know that nothing was running @@ -8797,9 +8803,9 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record) memcpy(&fpw, XLogRecGetData(record), sizeof(bool)); /* - * Update the LSN of the last replayed XLOG_FPW_CHANGE record - * so that do_pg_start_backup() and do_pg_stop_backup() can check - * whether full_page_writes has been disabled during online backup. + * Update the LSN of the last replayed XLOG_FPW_CHANGE record so that + * do_pg_start_backup() and do_pg_stop_backup() can check whether + * full_page_writes has been disabled during online backup. */ if (!fpw) { @@ -8825,7 +8831,7 @@ xlog_desc(StringInfo buf, uint8 xl_info, char *rec) CheckPoint *checkpoint = (CheckPoint *) rec; appendStringInfo(buf, "checkpoint: redo %X/%X; " - "tli %u; fpw %s; xid %u/%u; oid %u; multi %u; offset %u; " + "tli %u; fpw %s; xid %u/%u; oid %u; multi %u; offset %u; " "oldest xid %u in DB %u; oldest running xid %u; %s", checkpoint->redo.xlogid, checkpoint->redo.xrecoff, checkpoint->ThisTimeLineID, @@ -9115,8 +9121,8 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) errhint("WAL control functions cannot be executed during recovery."))); /* - * During recovery, we don't need to check WAL level. Because, if WAL level - * is not sufficient, it's impossible to get here during recovery. + * During recovery, we don't need to check WAL level. Because, if WAL + * level is not sufficient, it's impossible to get here during recovery. */ if (!backup_started_in_recovery && !XLogIsNeeded()) ereport(ERROR, @@ -9179,7 +9185,7 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) * 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 + * 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. @@ -9202,17 +9208,18 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) bool checkpointfpw; /* - * Force a CHECKPOINT. Aside from being necessary to prevent torn + * 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. * - * During recovery, establish a restartpoint if possible. We use the last - * restartpoint as the backup starting checkpoint. This means that two - * successive backup runs can have same checkpoint positions. + * During recovery, establish a restartpoint if possible. We use + * the last restartpoint as the backup starting checkpoint. This + * means that two successive backup runs can have same checkpoint + * positions. * - * Since the fact that we are executing do_pg_start_backup() during - * recovery means that checkpointer is running, we can use + * Since the fact that we are executing do_pg_start_backup() + * during recovery means that checkpointer is running, we can use * RequestCheckpoint() to establish a restartpoint. * * We use CHECKPOINT_IMMEDIATE only if requested by user (via @@ -9237,12 +9244,12 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) { /* use volatile pointer to prevent code rearrangement */ volatile XLogCtlData *xlogctl = XLogCtl; - XLogRecPtr recptr; + XLogRecPtr recptr; /* - * Check to see if all WAL replayed during online backup (i.e., - * since last restartpoint used as backup starting checkpoint) - * contain full-page writes. + * Check to see if all WAL replayed during online backup + * (i.e., since last restartpoint used as backup starting + * checkpoint) contain full-page writes. */ SpinLockAcquire(&xlogctl->info_lck); recptr = xlogctl->lastFpwDisableRecPtr; @@ -9250,20 +9257,20 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) if (!checkpointfpw || XLByteLE(startpoint, recptr)) ereport(ERROR, - (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("WAL generated with full_page_writes=off was replayed " - "since last restartpoint"), - errhint("This means that the backup being taken on standby " - "is corrupt and should not be used. " - "Enable full_page_writes and run CHECKPOINT on the master, " - "and then try an online backup again."))); + (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), + errmsg("WAL generated with full_page_writes=off was replayed " + "since last restartpoint"), + errhint("This means that the backup being taken on standby " + "is corrupt and should not be used. " + "Enable full_page_writes and run CHECKPOINT on the master, " + "and then try an online backup again."))); /* * During recovery, since we don't use the end-of-backup WAL - * record and don't write the backup history file, the starting WAL - * location doesn't need to be unique. This means that two base - * backups started at the same time might use the same checkpoint - * as starting locations. + * record and don't write the backup history file, the + * starting WAL location doesn't need to be unique. This means + * that two base backups started at the same time might use + * the same checkpoint as starting locations. */ gotUniqueStartpoint = true; } @@ -9443,8 +9450,8 @@ do_pg_stop_backup(char *labelfile, bool waitforarchive) errhint("WAL control functions cannot be executed during recovery."))); /* - * During recovery, we don't need to check WAL level. Because, if WAL level - * is not sufficient, it's impossible to get here during recovery. + * During recovery, we don't need to check WAL level. Because, if WAL + * level is not sufficient, it's impossible to get here during recovery. */ if (!backup_started_in_recovery && !XLogIsNeeded()) ereport(ERROR, @@ -9537,9 +9544,9 @@ do_pg_stop_backup(char *labelfile, bool waitforarchive) remaining = strchr(labelfile, '\n') + 1; /* %n is not portable enough */ /* - * Parse the BACKUP FROM line. If we are taking an online backup from - * the standby, we confirm that the standby has not been promoted - * during the backup. + * Parse the BACKUP FROM line. If we are taking an online backup from the + * standby, we confirm that the standby has not been promoted during the + * backup. */ ptr = strstr(remaining, "BACKUP FROM:"); if (!ptr || sscanf(ptr, "BACKUP FROM: %19s\n", backupfrom) != 1) @@ -9555,30 +9562,30 @@ do_pg_stop_backup(char *labelfile, bool waitforarchive) "Try taking another online backup."))); /* - * During recovery, we don't write an end-of-backup record. We assume - * that pg_control was backed up last and its minimum recovery - * point can be available as the backup end location. Since we don't - * have an end-of-backup record, we use the pg_control value to check - * whether we've reached the end of backup when starting recovery from - * this backup. We have no way of checking if pg_control wasn't backed - * up last however. + * During recovery, we don't write an end-of-backup record. We assume that + * pg_control was backed up last and its minimum recovery point can be + * available as the backup end location. Since we don't have an + * end-of-backup record, we use the pg_control value to check whether + * we've reached the end of backup when starting recovery from this + * backup. We have no way of checking if pg_control wasn't backed up last + * however. * * We don't force a switch to new WAL file and wait for all the required - * files to be archived. This is okay if we use the backup to start - * the standby. But, if it's for an archive recovery, to ensure all the - * required files are available, a user should wait for them to be archived, - * or include them into the backup. + * files to be archived. This is okay if we use the backup to start the + * standby. But, if it's for an archive recovery, to ensure all the + * required files are available, a user should wait for them to be + * archived, or include them into the backup. * * We return the current minimum recovery point as the backup end * location. Note that it's would be bigger than the exact backup end - * location if the minimum recovery point is updated since the backup - * of pg_control. This is harmless for current uses. + * location if the minimum recovery point is updated since the backup of + * pg_control. This is harmless for current uses. * * XXX currently a backup history file is for informational and debug * purposes only. It's not essential for an online backup. Furthermore, * even if it's created, it will not be archived during recovery because - * an archiver is not invoked. So it doesn't seem worthwhile to write - * a backup history file during recovery. + * an archiver is not invoked. So it doesn't seem worthwhile to write a + * backup history file during recovery. */ if (backup_started_in_recovery) { @@ -9597,12 +9604,12 @@ do_pg_stop_backup(char *labelfile, bool waitforarchive) if (XLByteLE(startpoint, recptr)) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("WAL generated with full_page_writes=off was replayed " - "during online backup"), - errhint("This means that the backup being taken on standby " - "is corrupt and should not be used. " - "Enable full_page_writes and run CHECKPOINT on the master, " - "and then try an online backup again."))); + errmsg("WAL generated with full_page_writes=off was replayed " + "during online backup"), + errhint("This means that the backup being taken on standby " + "is corrupt and should not be used. " + "Enable full_page_writes and run CHECKPOINT on the master, " + "and then try an online backup again."))); LWLockAcquire(ControlFileLock, LW_SHARED); @@ -9905,10 +9912,11 @@ read_backup_label(XLogRecPtr *checkPointLoc, bool *backupEndRequired, ereport(FATAL, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("invalid data in file \"%s\"", BACKUP_LABEL_FILE))); + /* - * BACKUP METHOD and BACKUP FROM lines are new in 9.2. We can't - * restore from an older backup anyway, but since the information on it - * is not strictly required, don't error out if it's missing for some reason. + * BACKUP METHOD and BACKUP FROM lines are new in 9.2. We can't restore + * from an older backup anyway, but since the information on it is not + * strictly required, don't error out if it's missing for some reason. */ if (fscanf(lfp, "BACKUP METHOD: %19s\n", backuptype) == 1) { @@ -10050,8 +10058,8 @@ XLogPageRead(XLogRecPtr *RecPtr, int emode, bool fetching_ckpt, if (readFile >= 0 && !XLByteInSeg(*RecPtr, readId, readSeg)) { /* - * Request a restartpoint if we've replayed too much - * xlog since the last one. + * Request a restartpoint if we've replayed too much xlog since the + * last one. */ if (StandbyMode && bgwriterLaunched) { |