112#define BootstrapTimeLineID 1
141bool XLOG_DEBUG =
false;
151#define NUM_XLOGINSERT_LOCKS 8
174#ifdef HAVE_FSYNC_WRITETHROUGH
580#define INSERT_FREESPACE(endptr) \
581 (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))
584#define NextBufIdx(idx) \
585 (((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
591#define XLogRecPtrToBufIdx(recptr) \
592 (((recptr) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
597#define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)
603#define ConvertToXSegs(x, segsize) XLogMBVarToSegs((x), (segsize))
620#define RefreshXLogWriteResult(_target) \
622 _target.Flush = pg_atomic_read_u64(&XLogCtl->logFlushResult); \
624 _target.Write = pg_atomic_read_u64(&XLogCtl->logWriteResult); \
752 bool topxid_included)
779 elog(
ERROR,
"cannot make new WAL entries during recovery");
849 (!prevDoPageWrites ||
913 rdata_crc = rechdr->
xl_crc;
916 rechdr->
xl_crc = rdata_crc;
924 StartPos, EndPos, insertTLI);
966 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
983 TRACE_POSTGRESQL_WAL_SWITCH();
994 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
998 if (offset == EndPos % XLOG_BLCKSZ)
1014 char *errormsg = NULL;
1028 for (; rdata != NULL; rdata = rdata->
next)
1039 .segment_open = NULL,
1040 .segment_close = NULL),
1053 errormsg ? errormsg :
"no error message");
1059 debug_reader->
record = decoded;
1061 debug_reader->
record = NULL;
1136 startbytepos =
Insert->CurrBytePos;
1137 endbytepos = startbytepos + size;
1138 prevbytepos =
Insert->PrevBytePos;
1139 Insert->CurrBytePos = endbytepos;
1140 Insert->PrevBytePos = startbytepos;
1185 startbytepos =
Insert->CurrBytePos;
1191 *EndPos = *StartPos = ptr;
1195 endbytepos = startbytepos + size;
1196 prevbytepos =
Insert->PrevBytePos;
1208 Insert->CurrBytePos = endbytepos;
1209 Insert->PrevBytePos = startbytepos;
1253 while (rdata != NULL)
1255 const char *rdata_data = rdata->
data;
1256 int rdata_len = rdata->
len;
1258 while (rdata_len > freespace)
1264 memcpy(currpos, rdata_data, freespace);
1265 rdata_data += freespace;
1266 rdata_len -= freespace;
1267 written += freespace;
1268 CurrPos += freespace;
1299 memcpy(currpos, rdata_data, rdata_len);
1300 currpos += rdata_len;
1301 CurrPos += rdata_len;
1302 freespace -= rdata_len;
1303 written += rdata_len;
1305 rdata = rdata->
next;
1307 Assert(written == write_len);
1323 CurrPos += freespace;
1331 while (CurrPos < EndPos)
1355 CurrPos += XLOG_BLCKSZ;
1364 if (CurrPos != EndPos)
1367 errmsg_internal(
"space reserved for WAL record does not match what was written"));
1389 static int lockToTry = -1;
1391 if (lockToTry == -1)
1517 elog(
PANIC,
"cannot wait without a PGPROC structure");
1524 if (upto <= inserted)
1529 bytepos =
Insert->CurrBytePos;
1541 if (upto > reservedUpto)
1544 errmsg(
"request to flush past end of generated WAL; request %X/%08X, current position %X/%08X",
1546 upto = reservedUpto;
1558 finishedUpto = reservedUpto;
1590 insertingat, &insertingat))
1601 }
while (insertingat < upto);
1604 finishedUpto = insertingat;
1615 return finishedUpto;
1639 static uint64 cachedPage = 0;
1640 static char *cachedPos = NULL;
1647 if (ptr / XLOG_BLCKSZ == cachedPage)
1651 return cachedPos + ptr % XLOG_BLCKSZ;
1674 expectedEndPtr = ptr;
1675 expectedEndPtr += XLOG_BLCKSZ - ptr % XLOG_BLCKSZ;
1678 if (expectedEndPtr != endptr)
1703 initializedUpto = ptr;
1710 if (expectedEndPtr != endptr)
1711 elog(
PANIC,
"could not find WAL buffer for %X/%08X",
1727 cachedPage = ptr / XLOG_BLCKSZ;
1733 return cachedPos + ptr % XLOG_BLCKSZ;
1754 char *pdst = dstbuf;
1757 Size nbytes = count;
1769 if (startptr + count > inserted)
1771 errmsg(
"cannot read past end of generated WAL: requested %X/%08X, current position %X/%08X",
1791 uint32 offset = recptr % XLOG_BLCKSZ;
1803 expectedEndPtr = recptr + (XLOG_BLCKSZ - offset);
1810 if (expectedEndPtr != endptr)
1819 psrc = page + offset;
1820 npagebytes =
Min(nbytes, XLOG_BLCKSZ - offset);
1829 memcpy(pdst, psrc, npagebytes);
1842 if (expectedEndPtr != endptr)
1846 recptr += npagebytes;
1847 nbytes -= npagebytes;
1850 Assert(pdst - dstbuf <= count);
1852 return pdst - dstbuf;
1880 seg_offset = XLOG_BLCKSZ;
1923 seg_offset = XLOG_BLCKSZ;
1930 seg_offset += fullpages * XLOG_BLCKSZ + bytesleft;
1954 offset = ptr % XLOG_BLCKSZ;
2058 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
2059 WriteRqst.
Write = OldPageRqstPtr;
2060 WriteRqst.
Flush = 0;
2064 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
2083 NewPageEndPtr = NewPageBeginPtr + XLOG_BLCKSZ;
2101 MemSet(NewPage, 0, XLOG_BLCKSZ);
2127 if (
Insert->runningBackups == 0)
2158 if (XLOG_DEBUG && npages > 0)
2160 elog(
DEBUG1,
"initialized %d pages, up to %X/%08X",
2218 GUC_check_errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.");
2259 recycleSegNo = (
XLogSegNo) ceil(((
double) lastredoptr + distance) /
2262 if (recycleSegNo < minSegNo)
2263 recycleSegNo = minSegNo;
2264 if (recycleSegNo > maxSegNo)
2265 recycleSegNo = maxSegNo;
2267 return recycleSegNo;
2307 bool last_iteration;
2352 elog(
PANIC,
"xlog write request %X/%08X is past end of log %X/%08X",
2407 finishing_seg = !ispartialpage &&
2410 if (last_iteration ||
2422 nbytes = npages * (
Size) XLOG_BLCKSZ;
2454 errmsg(
"could not write to log file \"%s\" at offset %u, length %zu: %m",
2455 xlogfname, startoffset, nleft)));
2459 startoffset += written;
2460 }
while (nleft > 0);
2517 if (flexible && npages == 0)
2582#ifdef USE_ASSERT_CHECKING
2627 if (asyncXactLSN <= prevAsyncXactLSN)
2750 if (!force && newMinRecoveryPoint < lsn)
2752 "xlog min recovery request %X/%08X is past current point %X/%08X",
2765 errmsg_internal(
"updated min recovery point to %X/%08X on timeline %u",
2767 newMinRecoveryPointTLI));
2805 elog(
LOG,
"xlog flush request %X/%08X; write %X/%08X; flush %X/%08X",
2822 WriteRqstPtr = record;
2842 if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write)
2900 WriteRqst.
Write = insertpos;
2901 WriteRqst.
Flush = insertpos;
2938 "xlog flush request %X/%08X is not satisfied --- flushed only to %X/%08X",
2978 bool flexible =
true;
3000 WriteRqst.
Write -= WriteRqst.
Write % XLOG_BLCKSZ;
3067 WriteRqst.
Flush = 0;
3072 elog(
LOG,
"xlog bg flush request write %X/%08X; flush: %X/%08X, current is write %X/%08X; flush %X/%08X",
3088 XLogWrite(WriteRqst, insertTLI, flexible);
3206 bool *added,
char *path)
3213 int open_flags = O_RDWR | O_CREAT | O_EXCL |
PG_BINARY;
3228 if (errno != ENOENT)
3231 errmsg(
"could not open file \"%s\": %m", path)));
3242 elog(
DEBUG2,
"creating and filling new WAL file");
3256 errmsg(
"could not create file \"%s\": %m", tmppath)));
3291 save_errno = errno ? errno : ENOSPC;
3317 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3331 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3341 errmsg(
"could not close file \"%s\": %m", tmppath)));
3348 installed_segno = logsegno;
3364 elog(
DEBUG2,
"done creating and filling new WAL file");
3411 errmsg(
"could not open file \"%s\": %m", path)));
3450 errmsg(
"could not open file \"%s\": %m", path)));
3464 errmsg(
"could not create file \"%s\": %m", tmppath)));
3473 nread = upto - nbytes;
3479 if (nread <
sizeof(buffer))
3480 memset(buffer.
data, 0,
sizeof(buffer));
3486 if (nread >
sizeof(buffer))
3487 nread =
sizeof(buffer);
3489 r =
read(srcfd, buffer.
data, nread);
3495 errmsg(
"could not read file \"%s\": %m",
3500 errmsg(
"could not read file \"%s\": read %d of %zu",
3501 path, r, (
Size) nread)));
3507 if ((
int)
write(
fd, buffer.
data,
sizeof(buffer)) != (
int)
sizeof(buffer))
3509 int save_errno = errno;
3516 errno = save_errno ? save_errno : ENOSPC;
3520 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3529 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3535 errmsg(
"could not close file \"%s\": %m", tmppath)));
3540 errmsg(
"could not close file \"%s\": %m", path)));
3546 elog(
ERROR,
"InstallXLogFileSegment should not have failed");
3580 struct stat stat_buf;
3601 while (
stat(path, &stat_buf) == 0)
3603 if ((*segno) >= max_segno)
3643 errmsg(
"could not open file \"%s\": %m", path)));
3662#if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
3664 (void) posix_fadvise(
openLogFile, 0, 0, POSIX_FADV_DONTNEED);
3670 int save_errno = errno;
3676 errmsg(
"could not close file \"%s\": %m", xlogfname)));
3742 int save_errno = errno;
3749 if (segno <= lastRemovedSegNo)
3757 errmsg(
"requested WAL segment %s has already been removed",
3779 return lastRemovedSegNo;
3808 if (tli != file_tli)
3812 if (oldest_segno == 0 || file_segno < oldest_segno)
3813 oldest_segno = file_segno;
3817 return oldest_segno;
3850 elog(
DEBUG2,
"removing all temporary WAL segments");
3857 if (strncmp(xlde->
d_name,
"xlogtemp.", 9) != 0)
3862 elog(
DEBUG2,
"removed temporary WAL segment \"%s\"", path);
3898 elog(
DEBUG2,
"attempting to remove WAL segments older than log file %s",
3921 if (strcmp(xlde->
d_name + 8, lastoff + 8) <= 0)
3968 recycleSegNo = endLogSegNo + 10;
3975 elog(
DEBUG2,
"attempting to remove WAL segments newer than log file %s",
3991 if (strncmp(xlde->
d_name, switchseg, 8) < 0 &&
3992 strcmp(xlde->
d_name + 8, switchseg + 8) > 0)
4030 const char *segname = segment_de->
d_name;
4040 *endlogSegNo <= recycleSegNo &&
4044 true, recycleSegNo, insertTLI))
4075 if (rename(path, newpath) != 0)
4079 errmsg(
"could not rename file \"%s\": %m",
4115 struct stat stat_buf;
4122 errmsg(
"required WAL directory \"%s\" does not exist",
4127 if (
stat(path, &stat_buf) == 0)
4133 errmsg(
"required WAL directory \"%s\" does not exist",
4139 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4143 errmsg(
"could not create missing directory \"%s\": %m",
4149 if (
stat(path, &stat_buf) == 0)
4154 (
errmsg(
"required WAL directory \"%s\" does not exist",
4160 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4163 (
errmsg(
"could not create missing directory \"%s\": %m",
4188 elog(
DEBUG2,
"removing WAL backup history file \"%s\"",
4229 (
errcode(ERRCODE_INTERNAL_ERROR),
4230 errmsg(
"could not generate secret authorization token")));
4328 errmsg(
"could not create file \"%s\": %m",
4340 errmsg(
"could not write to file \"%s\": %m",
4349 errmsg(
"could not fsync file \"%s\": %m",
4356 errmsg(
"could not close file \"%s\": %m",
4365 char wal_segsz_str[20];
4376 errmsg(
"could not open file \"%s\": %m",
4386 errmsg(
"could not read file \"%s\": %m",
4391 errmsg(
"could not read file \"%s\": read %d of %zu",
4407 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4408 errmsg(
"database files are incompatible with server"),
4409 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x),"
4410 " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
4413 errhint(
"This could be a problem of mismatched byte ordering. It looks like you need to initdb.")));
4417 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4418 errmsg(
"database files are incompatible with server"),
4419 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d,"
4420 " but the server was compiled with PG_CONTROL_VERSION %d.",
4422 errhint(
"It looks like you need to initdb.")));
4433 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4434 errmsg(
"incorrect checksum in control file")));
4443 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4444 errmsg(
"database files are incompatible with server"),
4446 errdetail(
"The database cluster was initialized with %s %d,"
4447 " but the server was compiled with %s %d.",
4450 errhint(
"It looks like you need to initdb.")));
4453 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4454 errmsg(
"database files are incompatible with server"),
4456 errdetail(
"The database cluster was initialized with %s %d,"
4457 " but the server was compiled with %s %d.",
4459 "MAXALIGN", MAXIMUM_ALIGNOF),
4460 errhint(
"It looks like you need to initdb.")));
4463 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4464 errmsg(
"database files are incompatible with server"),
4465 errdetail(
"The database cluster appears to use a different floating-point number format than the server executable."),
4466 errhint(
"It looks like you need to initdb.")));
4469 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4470 errmsg(
"database files are incompatible with server"),
4472 errdetail(
"The database cluster was initialized with %s %d,"
4473 " but the server was compiled with %s %d.",
4476 errhint(
"It looks like you need to recompile or initdb.")));
4479 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4480 errmsg(
"database files are incompatible with server"),
4482 errdetail(
"The database cluster was initialized with %s %d,"
4483 " but the server was compiled with %s %d.",
4485 "RELSEG_SIZE", RELSEG_SIZE),
4486 errhint(
"It looks like you need to recompile or initdb.")));
4489 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4490 errmsg(
"database files are incompatible with server"),
4492 errdetail(
"The database cluster was initialized with %s %d,"
4493 " but the server was compiled with %s %d.",
4495 "XLOG_BLCKSZ", XLOG_BLCKSZ),
4496 errhint(
"It looks like you need to recompile or initdb.")));
4499 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4500 errmsg(
"database files are incompatible with server"),
4502 errdetail(
"The database cluster was initialized with %s %d,"
4503 " but the server was compiled with %s %d.",
4506 errhint(
"It looks like you need to recompile or initdb.")));
4509 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4510 errmsg(
"database files are incompatible with server"),
4512 errdetail(
"The database cluster was initialized with %s %d,"
4513 " but the server was compiled with %s %d.",
4516 errhint(
"It looks like you need to recompile or initdb.")));
4519 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4520 errmsg(
"database files are incompatible with server"),
4522 errdetail(
"The database cluster was initialized with %s %d,"
4523 " but the server was compiled with %s %d.",
4526 errhint(
"It looks like you need to recompile or initdb.")));
4529 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4530 errmsg(
"database files are incompatible with server"),
4532 errdetail(
"The database cluster was initialized with %s %d,"
4533 " but the server was compiled with %s %d.",
4536 errhint(
"It looks like you need to recompile or initdb.")));
4544 errmsg_plural(
"invalid WAL segment size in control file (%d byte)",
4545 "invalid WAL segment size in control file (%d bytes)",
4548 errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.")));
4558 errmsg(
"\"%s\" must be at least twice \"%s\"",
4559 "min_wal_size",
"wal_segment_size")));
4564 errmsg(
"\"%s\" must be at least twice \"%s\"",
4565 "max_wal_size",
"wal_segment_size")));
4732 foreach(l, elemlist)
4734 char *tok = (
char *)
lfirst(l);
4740 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4742 newwalconsistency[rmid] =
true;
4749 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4754 newwalconsistency[rmid] =
true;
4788 memcpy(*extra, newwalconsistency, (
RM_MAX_ID + 1) *
sizeof(
bool));
4854 return "(disabled)";
4972 if (walDebugCxt == NULL)
4989 if (foundCFile || foundXLog)
4992 Assert(foundCFile && foundXLog);
4997 if (localControlFile)
4998 pfree(localControlFile);
5007 if (localControlFile)
5010 pfree(localControlFile);
5046 allocptr = (
char *)
TYPEALIGN(XLOG_BLCKSZ, allocptr);
5100 sysidentifier = ((
uint64) tv.tv_sec) << 32;
5101 sysidentifier |= ((
uint64) tv.tv_usec) << 12;
5102 sysidentifier |= getpid() & 0xFFF;
5105 buffer = (
char *)
palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
5107 memset(page, 0, XLOG_BLCKSZ);
5165 *(recptr++) =
sizeof(checkPoint);
5166 memcpy(recptr, &checkPoint,
sizeof(checkPoint));
5167 recptr +=
sizeof(checkPoint);
5195 errmsg(
"could not write bootstrap write-ahead log file: %m")));
5203 errmsg(
"could not fsync bootstrap write-ahead log file: %m")));
5209 errmsg(
"could not close bootstrap write-ahead log file: %m")));
5241 "%Y-%m-%d %H:%M:%S %Z",
5258 Assert(endTLI != newTLI);
5280 if (endLogSegNo == startLogSegNo)
5304 int save_errno = errno;
5310 errmsg(
"could not close file \"%s\": %m", xlogfname)));
5334 "recovery_end_command",
5336 WAIT_EVENT_RECOVERY_END_COMMAND);
5431 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5432 errmsg(
"WAL was generated with \"wal_level=minimal\", cannot continue recovering"),
5433 errdetail(
"This happens if you temporarily set \"wal_level=minimal\" on the server."),
5434 errhint(
"Use a backup taken after setting \"wal_level\" to higher than \"minimal\".")));
5473 bool haveBackupLabel;
5477 bool performedWalRecovery;
5482 bool promoted =
false;
5500 errmsg(
"control file contains invalid checkpoint location")));
5511 (
errmsg(
"database system was shut down at %s",
5513 timebuf,
sizeof(timebuf)))));
5518 (
errmsg(
"database system was shut down in recovery at %s",
5520 timebuf,
sizeof(timebuf)))));
5525 (
errmsg(
"database system shutdown was interrupted; last known up at %s",
5527 timebuf,
sizeof(timebuf)))));
5532 (
errmsg(
"database system was interrupted while in recovery at %s",
5534 timebuf,
sizeof(timebuf))),
5535 errhint(
"This probably means that some data is corrupted and"
5536 " you will have to use the last backup for recovery.")));
5541 (
errmsg(
"database system was interrupted while in recovery at log time %s",
5543 timebuf,
sizeof(timebuf))),
5544 errhint(
"If this has occurred more than once some data might be corrupted"
5545 " and you might need to choose an earlier recovery target.")));
5550 (
errmsg(
"database system was interrupted; last known up at %s",
5552 timebuf,
sizeof(timebuf)))));
5558 errmsg(
"control file contains invalid database cluster state")));
5562#ifdef XLOG_REPLAY_DELAY
5612 &haveBackupLabel, &haveTblspcMap);
5764 if (haveBackupLabel)
5873 running.
xcnt = nxids;
5882 running.
xids = xids;
5892 performedWalRecovery =
true;
5895 performedWalRecovery =
false;
5901 EndOfLog = endOfRecoveryInfo->
endOfLog;
5944 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5945 errmsg(
"WAL ends before end of online backup"),
5946 errhint(
"All WAL generated while online backup was taken must be available at recovery.")));
5949 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5950 errmsg(
"WAL ends before consistent recovery point")));
5996 (
errmsg(
"selected new timeline ID: %u", newTLI)));
6029 (
errmsg(
"archive recovery complete")));
6072 if (EndOfLog % XLOG_BLCKSZ != 0)
6085 memset(page +
len, 0, XLOG_BLCKSZ -
len);
6175 if (performedWalRecovery)
6198 pfree(endOfRecoveryInfo);
6335 bool promoted =
false;
6477 return oldXLogAllowed;
6623 if (res < last_important)
6624 res = last_important;
6664 (
errmsg(
"shutting down")));
6703 (
errmsg(
"restartpoint starting:%s%s%s%s%s%s%s%s",
6715 (
errmsg(
"checkpoint starting:%s%s%s%s%s%s%s%s",
6737 uint64 average_sync_time;
6767 average_sync_time = 0;
6771 average_msecs = (long) ((average_sync_time + 999) / 1000);
6780 (
errmsg(
"restartpoint complete: wrote %d buffers (%.1f%%), "
6781 "wrote %d SLRU buffers; %d WAL file(s) added, "
6782 "%d removed, %d recycled; write=%ld.%03d s, "
6783 "sync=%ld.%03d s, total=%ld.%03d s; sync files=%d, "
6784 "longest=%ld.%03d s, average=%ld.%03d s; distance=%d kB, "
6785 "estimate=%d kB; lsn=%X/%08X, redo lsn=%X/%08X",
6792 write_msecs / 1000, (
int) (write_msecs % 1000),
6793 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6794 total_msecs / 1000, (
int) (total_msecs % 1000),
6796 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6797 average_msecs / 1000, (
int) (average_msecs % 1000),
6804 (
errmsg(
"checkpoint complete: wrote %d buffers (%.1f%%), "
6805 "wrote %d SLRU buffers; %d WAL file(s) added, "
6806 "%d removed, %d recycled; write=%ld.%03d s, "
6807 "sync=%ld.%03d s, total=%ld.%03d s; sync files=%d, "
6808 "longest=%ld.%03d s, average=%ld.%03d s; distance=%d kB, "
6809 "estimate=%d kB; lsn=%X/%08X, redo lsn=%X/%08X",
6816 write_msecs / 1000, (
int) (write_msecs % 1000),
6817 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6818 total_msecs / 1000, (
int) (total_msecs % 1000),
6820 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6821 average_msecs / 1000, (
int) (average_msecs % 1000),
6889 char activitymsg[128];
6891 snprintf(activitymsg,
sizeof(activitymsg),
"performing %s%s%s",
6894 restartpoint ?
"restartpoint" :
"checkpoint");
6950 int oldXLogAllowed = 0;
6963 elog(
ERROR,
"can't create a checkpoint during recovery");
6997 MemSet(&checkPoint, 0,
sizeof(checkPoint));
7073 checkPoint.
redo = curInsert;
7136 TRACE_POSTGRESQL_CHECKPOINT_START(flags);
7290 (
errmsg(
"concurrent write-ahead log activity while database system is shutting down")));
7428 elog(
ERROR,
"can only be used to end recovery");
7496 elog(
ERROR,
"can only be used at end of recovery");
7497 if (pagePtr % XLOG_BLCKSZ != 0)
7498 elog(
ERROR,
"invalid position for missing continuation record %X/%08X",
7508 if (recptr != startPos)
7509 elog(
ERROR,
"invalid WAL insert position %X/%08X for OVERWRITE_CONTRECORD",
7539 elog(
ERROR,
"OVERWRITE_CONTRECORD was inserted to unexpected position %X/%08X",
7565 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_START(flags);
7575 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_SYNC_START();
7579 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_DONE();
7608 "could not record restart point at %X/%08X because there are unresolved references to invalid pages",
7666 (
errmsg_internal(
"skipping restartpoint, recovery has already ended")));
7688 errmsg_internal(
"skipping restartpoint, already performed at %X/%08X",
7817 endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
7873 errmsg(
"recovery restart point at %X/%08X",
7875 xtime ?
errdetail(
"Last completed transaction was at log time %s.",
7883 "archive_cleanup_command",
7885 WAIT_EVENT_ARCHIVE_CLEANUP_COMMAND);
7950 if (currSeg > keepSegs)
7951 oldestSegMaxWalSize = currSeg - keepSegs;
7953 oldestSegMaxWalSize = 1;
7962 if (targetSeg >= oldestSlotSeg)
7965 if (targetSeg >= oldestSegMaxWalSize)
7973 if (targetSeg >= oldestSeg)
8026 if (currSegNo - segno > slot_keep_segs)
8027 segno = currSegNo - slot_keep_segs;
8041 if (unsummarized_segno < segno)
8042 segno = unsummarized_segno;
8051 if (currSegNo - segno < keep_segs)
8054 if (currSegNo <= keep_segs)
8057 segno = currSegNo - keep_segs;
8062 if (segno < *logSegNo)
8114 if (mark_unimportant)
8139 errmsg(
"restore point \"%s\" created at %X/%08X",
8216 bool recoveryInProgress;
8247 Insert->fullPageWrites =
true;
8266 Insert->fullPageWrites =
false;
8346 (
errmsg(
"online backup was canceled, recovery cannot continue")));
8373 running.
xcnt = nxids;
8382 running.
xids = xids;
8399 (
errmsg(
"unexpected timeline ID %u (should be %u) in shutdown checkpoint record",
8460 (
errmsg(
"unexpected timeline ID %u (should be %u) in online checkpoint record",
8497 (
errmsg(
"unexpected timeline ID %u (should be %u) in end-of-recovery record",
8537 elog(
ERROR,
"XLOG_FPI record did not contain a full-page image");
8542 elog(
ERROR,
"unexpected XLogReadBufferForRedo result when restoring backup block");
8648 int o_direct_flag = 0;
8661 return o_direct_flag;
8674 return o_direct_flag;
8677 return O_SYNC | o_direct_flag;
8681 return O_DSYNC | o_direct_flag;
8685 elog(
ERROR,
"unrecognized \"wal_sync_method\": %d", method);
8718 errmsg(
"could not fsync file \"%s\": %m", xlogfname)));
8762 msg =
_(
"could not fsync file \"%s\": %m");
8764#ifdef HAVE_FSYNC_WRITETHROUGH
8767 msg =
_(
"could not fsync write-through file \"%s\": %m");
8772 msg =
_(
"could not fdatasync file \"%s\": %m");
8781 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8790 int save_errno = errno;
8796 errmsg(msg, xlogfname)));
8847 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8848 errmsg(
"WAL level not sufficient for making an online backup"),
8849 errhint(
"\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
8853 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8854 errmsg(
"backup label too long (max %d bytes)",
8891 bool gotUniqueStartpoint =
false;
8972 if (!checkpointfpw ||
state->startpoint <= recptr)
8974 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8975 errmsg(
"WAL generated with \"full_page_writes=off\" was replayed "
8976 "since last restartpoint"),
8977 errhint(
"This means that the backup being taken on the standby "
8978 "is corrupt and should not be used. "
8979 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
8980 "and then try an online backup again.")));
8989 gotUniqueStartpoint =
true;
9007 gotUniqueStartpoint =
true;
9010 }
while (!gotUniqueStartpoint);
9015 datadirpathlen = strlen(
DataDir);
9040 tsoid = strtoul(de->
d_name, &badp, 10);
9041 if (*badp !=
'\0' || errno == EINVAL || errno == ERANGE)
9053 rllen =
readlink(fullpath, linkpath,
sizeof(linkpath));
9057 (
errmsg(
"could not read symbolic link \"%s\": %m",
9061 else if (rllen >=
sizeof(linkpath))
9064 (
errmsg(
"symbolic link \"%s\" target is too long",
9068 linkpath[rllen] =
'\0';
9075 if (rllen > datadirpathlen &&
9076 strncmp(linkpath,
DataDir, datadirpathlen) == 0 &&
9085 for (s = linkpath; *s; s++)
9087 if (*s ==
'\n' || *s ==
'\r' || *s ==
'\\')
9105 snprintf(linkpath,
sizeof(linkpath),
"%s/%s",
9122 *tablespaces =
lappend(*tablespaces, ti);
9163 bool backup_stopped_in_recovery =
false;
9169 int seconds_before_warning;
9171 bool reported_waiting =
false;
9183 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9184 errmsg(
"WAL level not sufficient for making an online backup"),
9185 errhint(
"\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
9220 if (
state->started_in_recovery && !backup_stopped_in_recovery)
9222 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9223 errmsg(
"the standby was promoted during online backup"),
9224 errhint(
"This means that the backup being taken is corrupt "
9225 "and should not be used. "
9226 "Try taking another online backup.")));
9256 if (backup_stopped_in_recovery)
9268 if (
state->startpoint <= recptr)
9270 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9271 errmsg(
"WAL generated with \"full_page_writes=off\" was replayed "
9272 "during online backup"),
9273 errhint(
"This means that the backup being taken on the standby "
9274 "is corrupt and should not be used. "
9275 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
9276 "and then try an online backup again.")));
9293 sizeof(
state->startpoint));
9320 errmsg(
"could not create file \"%s\": %m",
9325 fprintf(fp,
"%s", history_file);
9326 pfree(history_file);
9328 if (fflush(fp) || ferror(fp) ||
FreeFile(fp))
9331 errmsg(
"could not write file \"%s\": %m",
9364 if (waitforarchive &&
9376 seconds_before_warning = 60;
9384 if (!reported_waiting && waits > 5)
9387 (
errmsg(
"base backup done, waiting for required WAL segments to be archived")));
9388 reported_waiting =
true;
9394 WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
9397 if (++waits >= seconds_before_warning)
9399 seconds_before_warning *= 2;
9401 (
errmsg(
"still waiting for all required WAL segments to be archived (%d seconds elapsed)",
9403 errhint(
"Check that your \"archive_command\" is executing properly. "
9404 "You can safely cancel this backup, "
9405 "but the database backup will not be usable without all the WAL segments.")));
9410 (
errmsg(
"all required WAL segments have been archived")));
9412 else if (waitforarchive)
9414 (
errmsg(
"WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
9451 if (!during_backup_start)
9453 errmsg(
"aborting backup due to backend exiting before pg_backup_stop was called"));
9464 static bool already_done =
false;
9469 already_done =
true;
9482 current_bytepos =
Insert->CurrBytePos;
Datum idx(PG_FUNCTION_ARGS)
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
#define pg_memory_barrier()
#define pg_read_barrier()
static uint64 pg_atomic_read_membarrier_u64(volatile pg_atomic_uint64 *ptr)
#define pg_write_barrier()
static uint64 pg_atomic_monotonic_advance_u64(volatile pg_atomic_uint64 *ptr, uint64 target)
static uint64 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
static void pg_atomic_write_membarrier_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
TimeLineID findNewestTimeLine(TimeLineID startTLI)
void restoreTimeLineHistoryFiles(TimeLineID begin, TimeLineID end)
void writeTimeLineHistory(TimeLineID newTLI, TimeLineID parentTLI, XLogRecPtr switchpoint, char *reason)
void startup_progress_timeout_handler(void)
long TimestampDifferenceMilliseconds(TimestampTz start_time, TimestampTz stop_time)
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
TimestampTz GetCurrentTimestamp(void)
const char * timestamptz_to_str(TimestampTz t)
Datum now(PG_FUNCTION_ARGS)
static bool backup_started_in_recovery
void CheckPointBuffers(int flags)
void UnlockReleaseBuffer(Buffer buffer)
#define pg_attribute_unused()
#define TYPEALIGN(ALIGNVAL, LEN)
#define pg_attribute_always_inline
#define MemSet(start, val, len)
#define CATALOG_VERSION_NO
void AbsorbSyncRequests(void)
double CheckPointCompletionTarget
void RequestCheckpoint(int flags)
void CheckPointCLOG(void)
void StartupCommitTs(void)
void CommitTsParameterChange(bool newvalue, bool oldvalue)
bool track_commit_timestamp
void CompleteCommitTsInitialization(void)
void BootStrapCommitTs(void)
void SetCommitTsLimit(TransactionId oldestXact, TransactionId newestXact)
void CheckPointCommitTs(void)
void update_controlfile(const char *DataDir, ControlFileData *ControlFile, bool do_sync)
#define fprintf(file, fmt, msg)
int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
int errmsg_internal(const char *fmt,...)
int errcode_for_file_access(void)
int errdetail(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
struct pg_atomic_uint64 pg_atomic_uint64
int MakePGDirectory(const char *directoryName)
int pg_fsync_no_writethrough(int fd)
int durable_rename(const char *oldfile, const char *newfile, int elevel)
int CloseTransientFile(int fd)
int BasicOpenFile(const char *fileName, int fileFlags)
int pg_fsync_writethrough(int fd)
void ReleaseExternalFD(void)
int data_sync_elevel(int elevel)
static void Insert(File file)
DIR * AllocateDir(const char *dirname)
int durable_unlink(const char *fname, int elevel)
void ReserveExternalFD(void)
struct dirent * ReadDir(DIR *dir, const char *dirname)
FILE * AllocateFile(const char *name, const char *mode)
int OpenTransientFile(const char *fileName, int fileFlags)
void SyncDataDirectory(void)
#define IO_DIRECT_WAL_INIT
ssize_t pg_pwrite_zeros(int fd, size_t size, off_t offset)
PGFileType get_dirent_type(const char *path, const struct dirent *de, bool look_through_symlinks, int elevel)
volatile uint32 CritSectionCount
bool IsPostmasterEnvironment
int set_config_option_ext(const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
void * guc_malloc(int elevel, size_t size)
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
#define GUC_check_errdetail
Assert(PointerIsAligned(start, uint64))
#define TOAST_MAX_CHUNK_SIZE
#define INJECTION_POINT(name, arg)
void before_shmem_exit(pg_on_exit_callback function, Datum arg)
#define PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg)
#define PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg)
if(TABLE==NULL||TABLE_index==NULL)
void SetLatch(Latch *latch)
void ResetLatch(Latch *latch)
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
List * lappend(List *list, void *datum)
void list_free(List *list)
void LWLockUpdateVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
void LWLockReleaseClearVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
bool LWLockWaitForVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval)
void LWLockRelease(LWLock *lock)
void LWLockInitialize(LWLock *lock, int tranche_id)
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
bool LWLockAcquireOrWait(LWLock *lock, LWLockMode mode)
char * pstrdup(const char *in)
void pfree(void *pointer)
MemoryContext TopMemoryContext
void MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
#define AllocSetContextCreate
#define ALLOCSET_DEFAULT_SIZES
#define IsBootstrapProcessingMode()
#define START_CRIT_SECTION()
#define CHECK_FOR_INTERRUPTS()
#define END_CRIT_SECTION()
#define AmWalReceiverProcess()
bool process_shared_preload_libraries_done
BackendType MyBackendType
void MultiXactSetNextMXact(MultiXactId nextMulti, MultiXactOffset nextMultiOffset)
void MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB)
void MultiXactGetCheckptMulti(bool is_shutdown, MultiXactId *nextMulti, MultiXactOffset *nextMultiOffset, MultiXactId *oldestMulti, Oid *oldestMultiDB)
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)
void CheckPointMultiXact(void)
void MultiXactAdvanceNextMXact(MultiXactId minMulti, MultiXactOffset minMultiOffset)
void BootStrapMultiXact(void)
void StartupMultiXact(void)
void StartupReplicationOrigin(void)
void CheckPointReplicationOrigin(void)
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
#define ERRCODE_DATA_CORRUPTED
#define DEFAULT_XLOG_SEG_SIZE
#define PG_CACHE_LINE_SIZE
#define FLOATFORMAT_VALUE
#define XLOG_RESTORE_POINT
#define XLOG_CHECKPOINT_REDO
#define PG_CONTROL_VERSION
#define XLOG_OVERWRITE_CONTRECORD
#define XLOG_FPI_FOR_HINT
#define MOCK_AUTH_NONCE_LEN
@ DB_SHUTDOWNED_IN_RECOVERY
#define XLOG_CHECKPOINT_SHUTDOWN
#define PG_CONTROL_FILE_SIZE
#define XLOG_PARAMETER_CHANGE
#define XLOG_CHECKPOINT_ONLINE
#define XLOG_END_OF_RECOVERY
#define COMP_CRC32C(crc, data, len)
#define EQ_CRC32C(c1, c2)
static rewind_source * source
void pgstat_restore_stats(void)
void pgstat_discard_stats(void)
PgStat_CheckpointerStats PendingCheckpointerStats
instr_time pgstat_prepare_io_time(bool track_io_guc)
void pgstat_count_io_op_time(IOObject io_object, IOContext io_context, IOOp io_op, instr_time start_time, uint32 cnt, uint64 bytes)
size_t pg_strftime(char *s, size_t maxsize, const char *format, const struct pg_tm *t)
struct pg_tm * pg_localtime(const pg_time_t *timep, const pg_tz *tz)
PGDLLIMPORT pg_tz * log_timezone
bool pg_strong_random(void *buf, size_t len)
int pg_strcasecmp(const char *s1, const char *s2)
size_t strlcpy(char *dst, const char *src, size_t siz)
static bool DatumGetBool(Datum X)
static Datum BoolGetDatum(bool X)
void CheckPointPredicate(void)
static int fd(const char *x, int i)
#define GetPGProcByNumber(n)
#define DELAY_CHKPT_START
#define DELAY_CHKPT_COMPLETE
bool MinimumActiveBackends(int min)
TransactionId GetOldestTransactionIdConsideredRunning(void)
bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids, int type)
void ProcArrayApplyRecoveryInfo(RunningTransactions running)
TransactionId GetOldestActiveTransactionId(bool inCommitOnly, bool allDbs)
void ProcArrayInitRecovery(TransactionId initializedUptoXID)
VirtualTransactionId * GetVirtualXIDsDelayingChkpt(int *nvxids, int type)
#define INVALID_PROC_NUMBER
static void set_ps_display(const char *activity)
void ResetUnloggedRelations(int op)
#define UNLOGGED_RELATION_INIT
#define UNLOGGED_RELATION_CLEANUP
void RelationCacheInitFileRemove(void)
void CheckPointRelationMap(void)
#define relpath(rlocator, forknum)
void StartupReorderBuffer(void)
ResourceOwner CurrentResourceOwner
ResourceOwner AuxProcessResourceOwner
void CheckPointLogicalRewriteHeap(void)
Size add_size(Size s1, Size s2)
Size mul_size(Size s1, Size s2)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
void pg_usleep(long microsec)
void CheckPointReplicationSlots(bool is_shutdown)
void StartupReplicationSlots(void)
bool InvalidateObsoleteReplicationSlots(uint32 possible_causes, XLogSegNo oldestSegno, Oid dboid, TransactionId snapshotConflictHorizon)
void smgrdestroyall(void)
void CheckPointSnapBuild(void)
void DeleteAllExportedSnapshotFiles(void)
#define SpinLockInit(lock)
#define SpinLockRelease(lock)
#define SpinLockAcquire(lock)
XLogRecPtr LogStandbySnapshot(void)
void InitRecoveryTransactionEnvironment(void)
void ShutdownRecoveryTransactionEnvironment(void)
void appendStringInfo(StringInfo str, const char *fmt,...)
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
void appendStringInfoString(StringInfo str, const char *s)
void appendStringInfoChar(StringInfo str, char ch)
void initStringInfo(StringInfo str)
MultiXactOffset nextMultiOffset
TransactionId newestCommitTsXid
TimeLineID PrevTimeLineID
TimeLineID ThisTimeLineID
TransactionId oldestActiveXid
FullTransactionId nextXid
TransactionId oldestCommitTsXid
uint64 ckpt_agg_sync_time
TimestampTz ckpt_sync_end_t
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN]
uint32 pg_control_version
XLogRecPtr backupStartPoint
bool track_commit_timestamp
CheckPoint checkPointCopy
XLogRecPtr backupEndPoint
XLogRecPtr minRecoveryPoint
uint32 data_checksum_version
bool default_char_signedness
uint32 catalog_version_no
TimeLineID minRecoveryPointTLI
uint32 toast_max_chunk_size
bool standby_signal_file_found
XLogRecPtr lastPageBeginPtr
char * recoveryStopReason
XLogRecPtr missingContrecPtr
bool recovery_signal_file_found
PgStat_Counter write_time
void(* rm_mask)(char *pagedata, BlockNumber blkno)
TransactionId oldestRunningXid
TransactionId latestCompletedXid
subxids_array_status subxid_status
TransactionId oldestCommitTsXid
TransactionId newestCommitTsXid
FullTransactionId latestCompletedXid
FullTransactionId nextXid
pg_atomic_uint64 insertingAt
XLogRecPtr lastImportantAt
CheckPoint lastCheckPoint
XLogRecPtr InitializedUpTo
pg_time_t lastSegSwitchTime
XLogRecPtr replicationSlotMinLSN
RecoveryState SharedRecoveryState
TimeLineID InsertTimeLineID
XLogRecPtr lastSegSwitchLSN
XLogSegNo lastRemovedSegNo
pg_atomic_uint64 * xlblocks
pg_atomic_uint64 logWriteResult
XLogRecPtr lastCheckPointRecPtr
XLogRecPtr lastFpwDisableRecPtr
bool InstallXLogFileSegmentActive
XLogRecPtr lastCheckPointEndPtr
pg_atomic_uint64 logFlushResult
pg_atomic_uint64 logInsertResult
TimeLineID PrevTimeLineID
pg_atomic_uint64 unloggedLSN
WALInsertLockPadded * WALInsertLocks
char pad[PG_CACHE_LINE_SIZE]
XLogRecPtr lastBackupStart
DecodedXLogRecord * record
struct XLogRecData * next
TimeLineID PrevTimeLineID
TimeLineID ThisTimeLineID
TimestampTz overwrite_time
XLogRecPtr overwritten_lsn
bool track_commit_timestamp
char rp_name[MAXFNAMELEN]
void StartupSUBTRANS(TransactionId oldestActiveXID)
void CheckPointSUBTRANS(void)
void BootStrapSUBTRANS(void)
void TruncateSUBTRANS(TransactionId oldestXact)
void ProcessSyncRequests(void)
void SyncPreCheckpoint(void)
void SyncPostCheckpoint(void)
TimeoutId RegisterTimeout(TimeoutId id, timeout_handler_proc handler)
@ STARTUP_PROGRESS_TIMEOUT
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
#define TransactionIdRetreat(dest)
#define InvalidTransactionId
static void FullTransactionIdRetreat(FullTransactionId *dest)
#define XidFromFullTransactionId(x)
#define FirstGenbkiObjectId
#define FirstNormalTransactionId
#define TransactionIdIsValid(xid)
static FullTransactionId FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)
#define TransactionIdIsNormal(xid)
#define FullTransactionIdPrecedes(a, b)
void RecoverPreparedTransactions(void)
void restoreTwoPhaseData(void)
TransactionId PrescanPreparedTransactions(TransactionId **xids_p, int *nxids_p)
void StandbyRecoverPreparedTransactions(void)
void CheckPointTwoPhase(XLogRecPtr redo_horizon)
char pad[PG_CACHE_LINE_SIZE]
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
void SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
TransamVariablesData * TransamVariables
static void pgstat_report_wait_start(uint32 wait_event_info)
static void pgstat_report_wait_end(void)
#define WL_EXIT_ON_PM_DEATH
static TimestampTz wakeup[NUM_WALRCV_WAKEUPS]
XLogRecPtr GetWalRcvFlushRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI)
void ShutdownWalRcv(void)
void WalSndWakeup(bool physical, bool logical)
void WalSndInitStopping(void)
void WalSndWaitStopping(void)
static void WalSndWakeupProcessRequests(bool physical, bool logical)
#define WalSndWakeupRequest()
void WaitForWalSummarization(XLogRecPtr lsn)
void WakeupWalSummarizer(void)
XLogRecPtr GetOldestUnsummarizedLSN(TimeLineID *tli, bool *lsn_is_exact)
#define readlink(path, buf, size)
int gettimeofday(struct timeval *tp, void *tzp)
void MarkSubxactTopXidLogged(void)
void MarkCurrentTransactionIdLoggedIfAny(void)
int XLogFileInit(XLogSegNo logsegno, TimeLineID logtli)
void assign_wal_sync_method(int new_wal_sync_method, void *extra)
static void CreateEndOfRecoveryRecord(void)
uint64 GetSystemIdentifier(void)
int wal_decode_buffer_size
XLogRecPtr ProcLastRecPtr
static XLogCtlData * XLogCtl
void UpdateFullPageWrites(void)
bool RecoveryInProgress(void)
static void CleanupBackupHistory(void)
void GetFullPageWriteInfo(XLogRecPtr *RedoRecPtr_p, bool *doPageWrites_p)
TimeLineID GetWALInsertionTimeLine(void)
XLogRecPtr RequestXLogSwitch(bool mark_unimportant)
void do_pg_abort_backup(int code, Datum arg)
XLogSegNo XLogGetLastRemovedSegno(void)
char * XLogArchiveCommand
struct XLogCtlInsert XLogCtlInsert
Size WALReadFromBuffers(char *dstbuf, XLogRecPtr startptr, Size count, TimeLineID tli)
static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto)
static void WALInsertLockRelease(void)
static XLogRecPtr XLogBytePosToRecPtr(uint64 bytepos)
static void WALInsertLockUpdateInsertingAt(XLogRecPtr insertingAt)
XLogRecPtr GetRedoRecPtr(void)
void assign_wal_consistency_checking(const char *newval, void *extra)
static void InitControlFile(uint64 sysidentifier, uint32 data_checksum_version)
void SetInstallXLogFileSegmentActive(void)
static void AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli, bool opportunistic)
static void WALInsertLockAcquireExclusive(void)
static void UpdateControlFile(void)
bool IsInstallXLogFileSegmentActive(void)
void BootStrapXLOG(uint32 data_checksum_version)
XLogRecPtr XactLastRecEnd
bool CreateRestartPoint(int flags)
static void ValidateXLOGDirectoryStructure(void)
static void RemoveOldXlogFiles(XLogSegNo segno, XLogRecPtr lastredoptr, XLogRecPtr endptr, TimeLineID insertTLI)
static XLogRecPtr CreateOverwriteContrecordRecord(XLogRecPtr aborted_lsn, XLogRecPtr pagePtr, TimeLineID newTLI)
XLogRecPtr GetInsertRecPtr(void)
static void CalculateCheckpointSegments(void)
SessionBackupState get_backup_status(void)
static void XLogReportParameters(void)
#define RefreshXLogWriteResult(_target)
void CheckXLogRemoved(XLogSegNo segno, TimeLineID tli)
static void LogCheckpointStart(int flags, bool restartpoint)
static XLogRecPtr RedoRecPtr
void assign_checkpoint_completion_target(double newval, void *extra)
static XLogRecPtr XLogGetReplicationSlotMinimumLSN(void)
XLogRecPtr XLogInsertRecord(XLogRecData *rdata, XLogRecPtr fpw_lsn, uint8 flags, int num_fpi, bool topxid_included)
static bool InstallXLogFileSegment(XLogSegNo *segno, char *tmppath, bool find_free, XLogSegNo max_segno, TimeLineID tli)
static void WriteControlFile(void)
struct XLogwrtResult XLogwrtResult
WALAvailability GetWALAvailability(XLogRecPtr targetLSN)
const char * show_archive_command(void)
#define UsableBytesInPage
void ShutdownXLOG(int code, Datum arg)
bool DataChecksumsEnabled(void)
static bool PerformRecoveryXLogAction(void)
RecoveryState GetRecoveryState(void)
static void CleanupAfterArchiveRecovery(TimeLineID EndOfLogTLI, XLogRecPtr EndOfLog, TimeLineID newTLI)
#define ConvertToXSegs(x, segsize)
static void RemoveXlogFile(const struct dirent *segment_de, XLogSegNo recycleSegNo, XLogSegNo *endlogSegNo, TimeLineID insertTLI)
pg_time_t GetLastSegSwitchData(XLogRecPtr *lastSwitchLSN)
static int XLOGChooseNumBuffers(void)
static XLogRecPtr XLogBytePosToEndRecPtr(uint64 bytepos)
static int get_sync_bit(int method)
static XLogwrtResult LogwrtResult
void XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn)
static void LogCheckpointEnd(bool restartpoint)
union WALInsertLockPadded WALInsertLockPadded
void SwitchIntoArchiveRecovery(XLogRecPtr EndRecPtr, TimeLineID replayTLI)
static bool lastFullPageWrites
char * wal_consistency_checking_string
static void WALInsertLockAcquire(void)
static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch, XLogRecData *rdata, XLogRecPtr StartPos, XLogRecPtr EndPos, TimeLineID tli)
bool GetDefaultCharSignedness(void)
static double CheckPointDistanceEstimate
static uint64 XLogRecPtrToBytePos(XLogRecPtr ptr)
const char * show_in_hot_standby(void)
XLogRecPtr GetXLogInsertRecPtr(void)
void SetWalWriterSleeping(bool sleeping)
static void XLogInitNewTimeline(TimeLineID endTLI, XLogRecPtr endOfLog, TimeLineID newTLI)
static void CheckRequiredParameterValues(void)
#define XLogRecPtrToBufIdx(recptr)
int XLogFileOpen(XLogSegNo segno, TimeLineID tli)
int max_slot_wal_keep_size_mb
XLogRecPtr GetFlushRecPtr(TimeLineID *insertTLI)
static void PreallocXlogFiles(XLogRecPtr endptr, TimeLineID tli)
static bool holdingAllLocks
static TimeLineID openLogTLI
XLogRecPtr XactLastCommitEnd
WalLevel GetActiveWalLevelOnStandby(void)
static void KeepLogSeg(XLogRecPtr recptr, XLogSegNo *logSegNo)
static void XLogWrite(XLogwrtRqst WriteRqst, TimeLineID tli, bool flexible)
void InitializeWalConsistencyChecking(void)
static void UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force)
static int LocalSetXLogInsertAllowed(void)
void assign_max_wal_size(int newval, void *extra)
void RemoveNonParentXlogFiles(XLogRecPtr switchpoint, TimeLineID newTLI)
XLogRecPtr GetLastImportantRecPtr(void)
void xlog_redo(XLogReaderState *record)
static void RecoveryRestartPoint(const CheckPoint *checkPoint, XLogReaderState *record)
bool XLogNeedsFlush(XLogRecPtr record)
void register_persistent_abort_backup_handler(void)
static double PrevCheckPointDistance
void ReachedEndOfBackup(XLogRecPtr EndRecPtr, TimeLineID tli)
void LocalProcessControlFile(bool reset)
static void XLogFileClose(void)
static void UpdateCheckPointDistanceEstimate(uint64 nbytes)
static bool LocalRecoveryInProgress
XLogSegNo XLogGetOldestSegno(TimeLineID tli)
XLogRecPtr GetXLogWriteRecPtr(void)
static WALInsertLockPadded * WALInsertLocks
static XLogSegNo openLogSegNo
#define INSERT_FREESPACE(endptr)
int wal_retrieve_retry_interval
bool XLogBackgroundFlush(void)
const struct config_enum_entry archive_mode_options[]
void GetOldestRestartPoint(XLogRecPtr *oldrecptr, TimeLineID *oldtli)
char * GetMockAuthenticationNonce(void)
static XLogSegNo XLOGfileslop(XLogRecPtr lastredoptr)
static int UsableBytesInSegment
static char * GetXLogBuffer(XLogRecPtr ptr, TimeLineID tli)
@ WALINSERT_SPECIAL_SWITCH
@ WALINSERT_SPECIAL_CHECKPOINT
bool XLogInsertAllowed(void)
void do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces, BackupState *state, StringInfo tblspcmapfile)
static ControlFileData * ControlFile
bool check_wal_segment_size(int *newval, void **extra, GucSource source)
static void XLogFileCopy(TimeLineID destTLI, XLogSegNo destsegno, TimeLineID srcTLI, XLogSegNo srcsegno, int upto)
static int LocalXLogInsertAllowed
static void RemoveTempXlogFiles(void)
XLogRecPtr XLogRestorePoint(const char *rpName)
static XLogRecPtr LocalMinRecoveryPoint
#define NUM_XLOGINSERT_LOCKS
struct XLogwrtRqst XLogwrtRqst
TimeLineID GetWALInsertionTimeLineIfSet(void)
void do_pg_backup_stop(BackupState *state, bool waitforarchive)
bool check_wal_consistency_checking(char **newval, void **extra, GucSource source)
const struct config_enum_entry wal_sync_method_options[]
bool CreateCheckPoint(int flags)
#define BootstrapTimeLineID
CheckpointStatsData CheckpointStats
bool check_wal_buffers(int *newval, void **extra, GucSource source)
XLogRecPtr GetFakeLSNForUnloggedRel(void)
static char * str_time(pg_time_t tnow, char *buf, size_t bufsize)
void XLogPutNextOid(Oid nextOid)
void XLogFlush(XLogRecPtr record)
static void ReadControlFile(void)
static SessionBackupState sessionBackupState
static void CheckPointGuts(XLogRecPtr checkPointRedo, int flags)
static bool updateMinRecoveryPoint
static bool check_wal_consistency_checking_deferred
static void ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr)
void XLogShutdownWalRcv(void)
static void UpdateLastRemovedPtr(char *filename)
static TimeLineID LocalMinRecoveryPointTLI
void issue_xlog_fsync(int fd, XLogSegNo segno, TimeLineID tli)
struct XLogCtlData XLogCtlData
static bool ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr)
void XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN)
bool XLogCheckpointNeeded(XLogSegNo new_segno)
bool * wal_consistency_checking
static int XLogFileInitInternal(XLogSegNo logsegno, TimeLineID logtli, bool *added, char *path)
static void update_checkpoint_display(int flags, bool restartpoint, bool reset)
#define XLogArchivingActive()
#define TABLESPACE_MAP_OLD
#define XLOG_MARK_UNIMPORTANT
#define CHECKPOINT_FLUSH_UNLOGGED
#define STANDBY_SIGNAL_FILE
#define CHECKPOINT_CAUSE_XLOG
#define CHECKPOINT_END_OF_RECOVERY
#define BACKUP_LABEL_FILE
#define CHECKPOINT_CAUSE_TIME
#define RECOVERY_SIGNAL_FILE
#define CHECKPOINT_IS_SHUTDOWN
#define XLogArchivingAlways()
@ WAL_SYNC_METHOD_FDATASYNC
@ WAL_SYNC_METHOD_FSYNC_WRITETHROUGH
@ WAL_SYNC_METHOD_OPEN_DSYNC
#define XLogStandbyInfoActive()
#define XLP_FIRST_IS_CONTRECORD
static RmgrData GetRmgr(RmgrId rmid)
#define IsValidWalSegSize(size)
XLogLongPageHeaderData * XLogLongPageHeader
#define XLP_FIRST_IS_OVERWRITE_CONTRECORD
#define XLOG_CONTROL_FILE
#define XLogSegmentOffset(xlogptr, wal_segsz_bytes)
static bool IsXLogFileName(const char *fname)
static void XLogFromFileName(const char *fname, TimeLineID *tli, XLogSegNo *logSegNo, int wal_segsz_bytes)
#define XLByteToPrevSeg(xlrp, logSegNo, wal_segsz_bytes)
#define XLogSegNoOffsetToRecPtr(segno, offset, wal_segsz_bytes, dest)
XLogPageHeaderData * XLogPageHeader
static bool IsBackupHistoryFileName(const char *fname)
#define XLP_BKP_REMOVABLE
#define XLByteToSeg(xlrp, logSegNo, wal_segsz_bytes)
static void BackupHistoryFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
static void XLogFilePath(char *path, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
#define XRecOffIsValid(xlrp)
#define SizeOfXLogShortPHD
#define SizeOfXLogLongPHD
static void XLogFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
static void BackupHistoryFilePath(char *path, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
static bool RmgrIdExists(RmgrId rmid)
#define XLByteInPrevSeg(xlrp, logSegNo, wal_segsz_bytes)
static bool IsPartialXLogFileName(const char *fname)
bool XLogArchiveIsReadyOrDone(const char *xlog)
bool XLogArchiveIsBusy(const char *xlog)
bool XLogArchiveIsReady(const char *xlog)
void XLogArchiveNotifySeg(XLogSegNo segno, TimeLineID tli)
void ExecuteRecoveryCommand(const char *command, const char *commandName, bool failOnSignal, uint32 wait_event_info)
bool XLogArchiveCheckDone(const char *xlog)
void XLogArchiveNotify(const char *xlog)
void XLogArchiveCleanup(const char *xlog)
char * build_backup_content(BackupState *state, bool ishistoryfile)
#define LSN_FORMAT_ARGS(lsn)
#define FirstNormalUnloggedLSN
#define XLogRecPtrIsInvalid(r)
#define InvalidXLogRecPtr
#define DEFAULT_WAL_SYNC_METHOD
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
void XLogRegisterData(const void *data, uint32 len)
void XLogSetRecordFlags(uint8 flags)
void XLogBeginInsert(void)
XLogReaderState * XLogReaderAllocate(int wal_segment_size, const char *waldir, XLogReaderRoutine *routine, void *private_data)
bool DecodeXLogRecord(XLogReaderState *state, DecodedXLogRecord *decoded, XLogRecord *record, XLogRecPtr lsn, char **errormsg)
size_t DecodeXLogRecordRequiredSpace(size_t xl_tot_len)
#define XLogRecGetInfo(decoder)
#define XLogRecGetData(decoder)
#define XLogRecMaxBlockId(decoder)
#define XLogRecHasBlockImage(decoder, block_id)
#define XLogRecHasAnyBlockRefs(decoder)
#define SizeOfXLogRecordDataHeaderShort
#define XLR_BLOCK_ID_DATA_SHORT
void ShutdownWalRecovery(void)
bool ArchiveRecoveryRequested
void RecoveryRequiresIntParameter(const char *param_name, int currValue, int minValue)
void PerformWalRecovery(void)
char * archiveCleanupCommand
XLogRecPtr GetCurrentReplayRecPtr(TimeLineID *replayEndTLI)
void xlog_outdesc(StringInfo buf, XLogReaderState *record)
bool PromoteIsTriggered(void)
static XLogRecPtr missingContrecPtr
XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI)
static XLogRecPtr abortedRecPtr
EndOfWalRecoveryInfo * FinishWalRecovery(void)
void InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr, bool *haveBackupLabel_ptr, bool *haveTblspcMap_ptr)
char * recoveryEndCommand
TimeLineID recoveryTargetTLI
TimestampTz GetLatestXTime(void)
bool XLogHaveInvalidPages(void)
XLogRedoAction XLogReadBufferForRedo(XLogReaderState *record, uint8 block_id, Buffer *buf)
HotStandbyState standbyState