110 #define BootstrapTimeLineID 1
139 bool XLOG_DEBUG =
false;
149 #define NUM_XLOGINSERT_LOCKS 8
172 #ifdef HAVE_FSYNC_WRITETHROUGH
579 #define INSERT_FREESPACE(endptr) \
580 (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))
583 #define NextBufIdx(idx) \
584 (((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
590 #define XLogRecPtrToBufIdx(recptr) \
591 (((recptr) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
596 #define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)
602 #define ConvertToXSegs(x, segsize) XLogMBVarToSegs((x), (segsize))
619 #define RefreshXLogWriteResult(_target) \
621 _target.Flush = pg_atomic_read_u64(&XLogCtl->logFlushResult); \
623 _target.Write = pg_atomic_read_u64(&XLogCtl->logWriteResult); \
751 bool topxid_included)
778 elog(
ERROR,
"cannot make new WAL entries during recovery");
848 (!prevDoPageWrites ||
912 rdata_crc = rechdr->
xl_crc;
915 rechdr->
xl_crc = rdata_crc;
923 StartPos, EndPos, insertTLI);
965 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
982 TRACE_POSTGRESQL_WAL_SWITCH();
993 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
997 if (offset == EndPos % XLOG_BLCKSZ)
1013 char *errormsg = NULL;
1027 for (; rdata != NULL; rdata = rdata->
next)
1038 .segment_open = NULL,
1039 .segment_close = NULL),
1052 errormsg ? errormsg :
"no error message");
1058 debug_reader->
record = decoded;
1060 debug_reader->
record = NULL;
1111 uint64 startbytepos;
1132 startbytepos =
Insert->CurrBytePos;
1133 endbytepos = startbytepos +
size;
1134 prevbytepos =
Insert->PrevBytePos;
1135 Insert->CurrBytePos = endbytepos;
1136 Insert->PrevBytePos = startbytepos;
1166 uint64 startbytepos;
1181 startbytepos =
Insert->CurrBytePos;
1187 *EndPos = *StartPos = ptr;
1191 endbytepos = startbytepos +
size;
1192 prevbytepos =
Insert->PrevBytePos;
1204 Insert->CurrBytePos = endbytepos;
1205 Insert->PrevBytePos = startbytepos;
1249 while (rdata != NULL)
1251 const char *rdata_data = rdata->
data;
1252 int rdata_len = rdata->
len;
1254 while (rdata_len > freespace)
1260 memcpy(currpos, rdata_data, freespace);
1261 rdata_data += freespace;
1262 rdata_len -= freespace;
1263 written += freespace;
1264 CurrPos += freespace;
1295 memcpy(currpos, rdata_data, rdata_len);
1296 currpos += rdata_len;
1297 CurrPos += rdata_len;
1298 freespace -= rdata_len;
1299 written += rdata_len;
1301 rdata = rdata->
next;
1303 Assert(written == write_len);
1319 CurrPos += freespace;
1327 while (CurrPos < EndPos)
1351 CurrPos += XLOG_BLCKSZ;
1360 if (CurrPos != EndPos)
1363 errmsg_internal(
"space reserved for WAL record does not match what was written"));
1385 static int lockToTry = -1;
1387 if (lockToTry == -1)
1513 elog(
PANIC,
"cannot wait without a PGPROC structure");
1520 if (upto <= inserted)
1525 bytepos =
Insert->CurrBytePos;
1537 if (upto > reservedUpto)
1540 (
errmsg(
"request to flush past end of generated WAL; request %X/%X, current position %X/%X",
1542 upto = reservedUpto;
1554 finishedUpto = reservedUpto;
1586 insertingat, &insertingat))
1597 }
while (insertingat < upto);
1600 finishedUpto = insertingat;
1611 return finishedUpto;
1635 static uint64 cachedPage = 0;
1636 static char *cachedPos = NULL;
1643 if (ptr / XLOG_BLCKSZ == cachedPage)
1647 return cachedPos + ptr % XLOG_BLCKSZ;
1670 expectedEndPtr = ptr;
1671 expectedEndPtr += XLOG_BLCKSZ - ptr % XLOG_BLCKSZ;
1674 if (expectedEndPtr != endptr)
1699 initializedUpto = ptr;
1706 if (expectedEndPtr != endptr)
1707 elog(
PANIC,
"could not find WAL buffer for %X/%X",
1723 cachedPage = ptr / XLOG_BLCKSZ;
1729 return cachedPos + ptr % XLOG_BLCKSZ;
1750 char *pdst = dstbuf;
1753 Size nbytes = count;
1765 if (startptr + count > inserted)
1767 errmsg(
"cannot read past end of generated WAL: requested %X/%X, current position %X/%X",
1787 uint32 offset = recptr % XLOG_BLCKSZ;
1799 expectedEndPtr = recptr + (XLOG_BLCKSZ - offset);
1806 if (expectedEndPtr != endptr)
1815 psrc = page + offset;
1816 npagebytes =
Min(nbytes, XLOG_BLCKSZ - offset);
1825 memcpy(pdst, psrc, npagebytes);
1838 if (expectedEndPtr != endptr)
1842 recptr += npagebytes;
1843 nbytes -= npagebytes;
1846 Assert(pdst - dstbuf <= count);
1848 return pdst - dstbuf;
1876 seg_offset = XLOG_BLCKSZ;
1919 seg_offset = XLOG_BLCKSZ;
1926 seg_offset += fullpages * XLOG_BLCKSZ + bytesleft;
1950 offset = ptr % XLOG_BLCKSZ;
2054 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
2055 WriteRqst.
Write = OldPageRqstPtr;
2056 WriteRqst.
Flush = 0;
2060 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
2073 NewPageEndPtr = NewPageBeginPtr + XLOG_BLCKSZ;
2091 MemSet((
char *) NewPage, 0, XLOG_BLCKSZ);
2099 NewPage->xlp_tli = tli;
2100 NewPage->xlp_pageaddr = NewPageBeginPtr;
2117 if (
Insert->runningBackups == 0)
2148 if (XLOG_DEBUG && npages > 0)
2150 elog(
DEBUG1,
"initialized %d pages, up to %X/%X",
2208 GUC_check_errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.");
2227 "max_slot_wal_keep_size");
2268 recycleSegNo = (
XLogSegNo) ceil(((
double) lastredoptr + distance) /
2271 if (recycleSegNo < minSegNo)
2272 recycleSegNo = minSegNo;
2273 if (recycleSegNo > maxSegNo)
2274 recycleSegNo = maxSegNo;
2276 return recycleSegNo;
2316 bool last_iteration;
2361 elog(
PANIC,
"xlog write request %X/%X is past end of log %X/%X",
2416 finishing_seg = !ispartialpage &&
2419 if (last_iteration ||
2431 nbytes = npages * (
Size) XLOG_BLCKSZ;
2475 errmsg(
"could not write to log file \"%s\" at offset %u, length %zu: %m",
2476 xlogfname, startoffset, nleft)));
2480 startoffset += written;
2481 }
while (nleft > 0);
2538 if (flexible && npages == 0)
2603 #ifdef USE_ASSERT_CHECKING
2648 if (asyncXactLSN <= prevAsyncXactLSN)
2765 if (!force && newMinRecoveryPoint < lsn)
2767 "xlog min recovery request %X/%X is past current point %X/%X",
2780 (
errmsg_internal(
"updated min recovery point to %X/%X on timeline %u",
2782 newMinRecoveryPointTLI)));
2820 elog(
LOG,
"xlog flush request %X/%X; write %X/%X; flush %X/%X",
2837 WriteRqstPtr = record;
2857 if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write)
2915 WriteRqst.
Write = insertpos;
2916 WriteRqst.
Flush = insertpos;
2953 "xlog flush request %X/%X is not satisfied --- flushed only to %X/%X",
2986 bool flexible =
true;
3008 WriteRqst.
Write -= WriteRqst.
Write % XLOG_BLCKSZ;
3075 WriteRqst.
Flush = 0;
3080 elog(
LOG,
"xlog bg flush request write %X/%X; flush: %X/%X, current is write %X/%X; flush %X/%X",
3096 XLogWrite(WriteRqst, insertTLI, flexible);
3204 bool *added,
char *path)
3211 int open_flags = O_RDWR | O_CREAT | O_EXCL |
PG_BINARY;
3225 if (errno != ENOENT)
3228 errmsg(
"could not open file \"%s\": %m", path)));
3239 elog(
DEBUG2,
"creating and filling new WAL file");
3253 errmsg(
"could not create file \"%s\": %m", tmppath)));
3285 save_errno = errno ? errno : ENOSPC;
3303 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3314 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3321 errmsg(
"could not close file \"%s\": %m", tmppath)));
3328 installed_segno = logsegno;
3344 elog(
DEBUG2,
"done creating and filling new WAL file");
3391 errmsg(
"could not open file \"%s\": %m", path)));
3430 errmsg(
"could not open file \"%s\": %m", path)));
3444 errmsg(
"could not create file \"%s\": %m", tmppath)));
3453 nread = upto - nbytes;
3459 if (nread <
sizeof(buffer))
3460 memset(buffer.
data, 0,
sizeof(buffer));
3466 if (nread >
sizeof(buffer))
3467 nread =
sizeof(buffer);
3469 r =
read(srcfd, buffer.
data, nread);
3475 errmsg(
"could not read file \"%s\": %m",
3480 errmsg(
"could not read file \"%s\": read %d of %zu",
3481 path, r, (
Size) nread)));
3487 if ((
int)
write(
fd, buffer.
data,
sizeof(buffer)) != (
int)
sizeof(buffer))
3489 int save_errno = errno;
3496 errno = save_errno ? save_errno : ENOSPC;
3500 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3509 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3515 errmsg(
"could not close file \"%s\": %m", tmppath)));
3520 errmsg(
"could not close file \"%s\": %m", path)));
3526 elog(
ERROR,
"InstallXLogFileSegment should not have failed");
3560 struct stat stat_buf;
3581 while (
stat(path, &stat_buf) == 0)
3583 if ((*segno) >= max_segno)
3623 errmsg(
"could not open file \"%s\": %m", path)));
3642 #if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
3644 (void) posix_fadvise(
openLogFile, 0, 0, POSIX_FADV_DONTNEED);
3650 int save_errno = errno;
3656 errmsg(
"could not close file \"%s\": %m", xlogfname)));
3722 int save_errno = errno;
3729 if (segno <= lastRemovedSegNo)
3737 errmsg(
"requested WAL segment %s has already been removed",
3759 return lastRemovedSegNo;
3788 if (tli != file_tli)
3792 if (oldest_segno == 0 || file_segno < oldest_segno)
3793 oldest_segno = file_segno;
3797 return oldest_segno;
3830 elog(
DEBUG2,
"removing all temporary WAL segments");
3837 if (strncmp(xlde->
d_name,
"xlogtemp.", 9) != 0)
3842 elog(
DEBUG2,
"removed temporary WAL segment \"%s\"", path);
3878 elog(
DEBUG2,
"attempting to remove WAL segments older than log file %s",
3901 if (strcmp(xlde->
d_name + 8, lastoff + 8) <= 0)
3948 recycleSegNo = endLogSegNo + 10;
3955 elog(
DEBUG2,
"attempting to remove WAL segments newer than log file %s",
3971 if (strncmp(xlde->
d_name, switchseg, 8) < 0 &&
3972 strcmp(xlde->
d_name + 8, switchseg + 8) > 0)
4010 const char *segname = segment_de->
d_name;
4020 *endlogSegNo <= recycleSegNo &&
4024 true, recycleSegNo, insertTLI))
4055 if (rename(path, newpath) != 0)
4059 errmsg(
"could not rename file \"%s\": %m",
4095 struct stat stat_buf;
4102 errmsg(
"required WAL directory \"%s\" does not exist",
4107 if (
stat(path, &stat_buf) == 0)
4113 errmsg(
"required WAL directory \"%s\" does not exist",
4119 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4123 errmsg(
"could not create missing directory \"%s\": %m",
4129 if (
stat(path, &stat_buf) == 0)
4134 (
errmsg(
"required WAL directory \"%s\" does not exist",
4140 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4143 (
errmsg(
"could not create missing directory \"%s\": %m",
4168 elog(
DEBUG2,
"removing WAL backup history file \"%s\"",
4209 (
errcode(ERRCODE_INTERNAL_ERROR),
4210 errmsg(
"could not generate secret authorization token")));
4281 errmsg(
"could not create file \"%s\": %m",
4293 errmsg(
"could not write to file \"%s\": %m",
4302 errmsg(
"could not fsync file \"%s\": %m",
4309 errmsg(
"could not close file \"%s\": %m",
4318 char wal_segsz_str[20];
4329 errmsg(
"could not open file \"%s\": %m",
4339 errmsg(
"could not read file \"%s\": %m",
4344 errmsg(
"could not read file \"%s\": read %d of %zu",
4360 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4361 errmsg(
"database files are incompatible with server"),
4362 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x),"
4363 " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
4366 errhint(
"This could be a problem of mismatched byte ordering. It looks like you need to initdb.")));
4370 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4371 errmsg(
"database files are incompatible with server"),
4372 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d,"
4373 " but the server was compiled with PG_CONTROL_VERSION %d.",
4375 errhint(
"It looks like you need to initdb.")));
4386 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4387 errmsg(
"incorrect checksum in control file")));
4396 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4397 errmsg(
"database files are incompatible with server"),
4399 errdetail(
"The database cluster was initialized with %s %d,"
4400 " but the server was compiled with %s %d.",
4403 errhint(
"It looks like you need to initdb.")));
4406 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4407 errmsg(
"database files are incompatible with server"),
4409 errdetail(
"The database cluster was initialized with %s %d,"
4410 " but the server was compiled with %s %d.",
4412 "MAXALIGN", MAXIMUM_ALIGNOF),
4413 errhint(
"It looks like you need to initdb.")));
4416 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4417 errmsg(
"database files are incompatible with server"),
4418 errdetail(
"The database cluster appears to use a different floating-point number format than the server executable."),
4419 errhint(
"It looks like you need to initdb.")));
4422 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4423 errmsg(
"database files are incompatible with server"),
4425 errdetail(
"The database cluster was initialized with %s %d,"
4426 " but the server was compiled with %s %d.",
4429 errhint(
"It looks like you need to recompile or initdb.")));
4432 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4433 errmsg(
"database files are incompatible with server"),
4435 errdetail(
"The database cluster was initialized with %s %d,"
4436 " but the server was compiled with %s %d.",
4438 "RELSEG_SIZE", RELSEG_SIZE),
4439 errhint(
"It looks like you need to recompile or initdb.")));
4442 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4443 errmsg(
"database files are incompatible with server"),
4445 errdetail(
"The database cluster was initialized with %s %d,"
4446 " but the server was compiled with %s %d.",
4448 "XLOG_BLCKSZ", XLOG_BLCKSZ),
4449 errhint(
"It looks like you need to recompile or initdb.")));
4452 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4453 errmsg(
"database files are incompatible with server"),
4455 errdetail(
"The database cluster was initialized with %s %d,"
4456 " but the server was compiled with %s %d.",
4459 errhint(
"It looks like you need to recompile or initdb.")));
4462 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4463 errmsg(
"database files are incompatible with server"),
4465 errdetail(
"The database cluster was initialized with %s %d,"
4466 " but the server was compiled with %s %d.",
4469 errhint(
"It looks like you need to recompile or initdb.")));
4472 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4473 errmsg(
"database files are incompatible with server"),
4475 errdetail(
"The database cluster was initialized with %s %d,"
4476 " but the server was compiled with %s %d.",
4479 errhint(
"It looks like you need to recompile or initdb.")));
4482 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4483 errmsg(
"database files are incompatible with server"),
4485 errdetail(
"The database cluster was initialized with %s %d,"
4486 " but the server was compiled with %s %d.",
4489 errhint(
"It looks like you need to recompile or initdb.")));
4491 #ifdef USE_FLOAT8_BYVAL
4494 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4495 errmsg(
"database files are incompatible with server"),
4496 errdetail(
"The database cluster was initialized without USE_FLOAT8_BYVAL"
4497 " but the server was compiled with USE_FLOAT8_BYVAL."),
4498 errhint(
"It looks like you need to recompile or initdb.")));
4502 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4503 errmsg(
"database files are incompatible with server"),
4504 errdetail(
"The database cluster was initialized with USE_FLOAT8_BYVAL"
4505 " but the server was compiled without USE_FLOAT8_BYVAL."),
4506 errhint(
"It looks like you need to recompile or initdb.")));
4513 errmsg_plural(
"invalid WAL segment size in control file (%d byte)",
4514 "invalid WAL segment size in control file (%d bytes)",
4517 errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.")));
4527 errmsg(
"\"%s\" must be at least twice \"%s\"",
4528 "min_wal_size",
"wal_segment_size")));
4533 errmsg(
"\"%s\" must be at least twice \"%s\"",
4534 "max_wal_size",
"wal_segment_size")));
4688 foreach(l, elemlist)
4690 char *tok = (
char *)
lfirst(l);
4696 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4698 newwalconsistency[rmid] =
true;
4705 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4710 newwalconsistency[rmid] =
true;
4742 memcpy(*extra, newwalconsistency, (
RM_MAX_ID + 1) *
sizeof(
bool));
4808 return "(disabled)";
4926 if (walDebugCxt == NULL)
4943 if (foundCFile || foundXLog)
4946 Assert(foundCFile && foundXLog);
4951 if (localControlFile)
4952 pfree(localControlFile);
4961 if (localControlFile)
4964 pfree(localControlFile);
5000 allocptr = (
char *)
TYPEALIGN(XLOG_BLCKSZ, allocptr);
5034 uint64 sysidentifier;
5054 sysidentifier = ((uint64) tv.tv_sec) << 32;
5055 sysidentifier |= ((uint64) tv.tv_usec) << 12;
5056 sysidentifier |= getpid() & 0xFFF;
5059 buffer = (
char *)
palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
5061 memset(page, 0, XLOG_BLCKSZ);
5119 *(recptr++) =
sizeof(checkPoint);
5120 memcpy(recptr, &checkPoint,
sizeof(checkPoint));
5121 recptr +=
sizeof(checkPoint);
5149 errmsg(
"could not write bootstrap write-ahead log file: %m")));
5157 errmsg(
"could not fsync bootstrap write-ahead log file: %m")));
5163 errmsg(
"could not close bootstrap write-ahead log file: %m")));
5197 "%Y-%m-%d %H:%M:%S %Z",
5214 Assert(endTLI != newTLI);
5236 if (endLogSegNo == startLogSegNo)
5260 int save_errno = errno;
5266 errmsg(
"could not close file \"%s\": %m", xlogfname)));
5290 "recovery_end_command",
5292 WAIT_EVENT_RECOVERY_END_COMMAND);
5387 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5388 errmsg(
"WAL was generated with \"wal_level=minimal\", cannot continue recovering"),
5389 errdetail(
"This happens if you temporarily set \"wal_level=minimal\" on the server."),
5390 errhint(
"Use a backup taken after setting \"wal_level\" to higher than \"minimal\".")));
5429 bool haveBackupLabel;
5433 bool performedWalRecovery;
5438 bool promoted =
false;
5455 errmsg(
"control file contains invalid checkpoint location")));
5466 (
errmsg(
"database system was shut down at %s",
5472 (
errmsg(
"database system was shut down in recovery at %s",
5478 (
errmsg(
"database system shutdown was interrupted; last known up at %s",
5484 (
errmsg(
"database system was interrupted while in recovery at %s",
5486 errhint(
"This probably means that some data is corrupted and"
5487 " you will have to use the last backup for recovery.")));
5492 (
errmsg(
"database system was interrupted while in recovery at log time %s",
5494 errhint(
"If this has occurred more than once some data might be corrupted"
5495 " and you might need to choose an earlier recovery target.")));
5500 (
errmsg(
"database system was interrupted; last known up at %s",
5507 errmsg(
"control file contains invalid database cluster state")));
5511 #ifdef XLOG_REPLAY_DELAY
5561 &haveBackupLabel, &haveTblspcMap);
5714 if (haveBackupLabel)
5823 running.
xcnt = nxids;
5832 running.
xids = xids;
5842 performedWalRecovery =
true;
5845 performedWalRecovery =
false;
5851 EndOfLog = endOfRecoveryInfo->
endOfLog;
5894 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5895 errmsg(
"WAL ends before end of online backup"),
5896 errhint(
"All WAL generated while online backup was taken must be available at recovery.")));
5899 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5900 errmsg(
"WAL ends before consistent recovery point")));
5946 (
errmsg(
"selected new timeline ID: %u", newTLI)));
5979 (
errmsg(
"archive recovery complete")));
6022 if (EndOfLog % XLOG_BLCKSZ != 0)
6035 memset(page +
len, 0, XLOG_BLCKSZ -
len);
6125 if (performedWalRecovery)
6285 bool promoted =
false;
6427 return oldXLogAllowed;
6573 if (
res < last_important)
6574 res = last_important;
6614 (
errmsg(
"shutting down")));
6653 (
errmsg(
"restartpoint starting:%s%s%s%s%s%s%s%s",
6665 (
errmsg(
"checkpoint starting:%s%s%s%s%s%s%s%s",
6687 uint64 average_sync_time;
6717 average_sync_time = 0;
6721 average_msecs = (long) ((average_sync_time + 999) / 1000);
6730 (
errmsg(
"restartpoint complete: wrote %d buffers (%.1f%%), "
6731 "wrote %d SLRU buffers; %d WAL file(s) added, "
6732 "%d removed, %d recycled; write=%ld.%03d s, "
6733 "sync=%ld.%03d s, total=%ld.%03d s; sync files=%d, "
6734 "longest=%ld.%03d s, average=%ld.%03d s; distance=%d kB, "
6735 "estimate=%d kB; lsn=%X/%X, redo lsn=%X/%X",
6742 write_msecs / 1000, (
int) (write_msecs % 1000),
6743 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6744 total_msecs / 1000, (
int) (total_msecs % 1000),
6746 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6747 average_msecs / 1000, (
int) (average_msecs % 1000),
6754 (
errmsg(
"checkpoint complete: wrote %d buffers (%.1f%%), "
6755 "wrote %d SLRU buffers; %d WAL file(s) added, "
6756 "%d removed, %d recycled; write=%ld.%03d s, "
6757 "sync=%ld.%03d s, total=%ld.%03d s; sync files=%d, "
6758 "longest=%ld.%03d s, average=%ld.%03d s; distance=%d kB, "
6759 "estimate=%d kB; lsn=%X/%X, redo lsn=%X/%X",
6766 write_msecs / 1000, (
int) (write_msecs % 1000),
6767 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6768 total_msecs / 1000, (
int) (total_msecs % 1000),
6770 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6771 average_msecs / 1000, (
int) (average_msecs % 1000),
6839 char activitymsg[128];
6841 snprintf(activitymsg,
sizeof(activitymsg),
"performing %s%s%s",
6844 restartpoint ?
"restartpoint" :
"checkpoint");
6900 int oldXLogAllowed = 0;
6913 elog(
ERROR,
"can't create a checkpoint during recovery");
6947 MemSet(&checkPoint, 0,
sizeof(checkPoint));
7023 checkPoint.
redo = curInsert;
7086 TRACE_POSTGRESQL_CHECKPOINT_START(flags);
7240 (
errmsg(
"concurrent write-ahead log activity while database system is shutting down")));
7381 elog(
ERROR,
"can only be used to end recovery");
7449 elog(
ERROR,
"can only be used at end of recovery");
7450 if (pagePtr % XLOG_BLCKSZ != 0)
7451 elog(
ERROR,
"invalid position for missing continuation record %X/%X",
7461 if (recptr != startPos)
7462 elog(
ERROR,
"invalid WAL insert position %X/%X for OVERWRITE_CONTRECORD",
7492 elog(
ERROR,
"OVERWRITE_CONTRECORD was inserted to unexpected position %X/%X",
7518 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_START(flags);
7528 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_SYNC_START();
7532 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_DONE();
7561 "could not record restart point at %X/%X because there "
7562 "are unresolved references to invalid pages",
7620 (
errmsg_internal(
"skipping restartpoint, recovery has already ended")));
7771 endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
7827 (
errmsg(
"recovery restart point at %X/%X",
7829 xtime ?
errdetail(
"Last completed transaction was at log time %s.",
7837 "archive_cleanup_command",
7839 WAIT_EVENT_ARCHIVE_CLEANUP_COMMAND);
7904 if (currSeg > keepSegs)
7905 oldestSegMaxWalSize = currSeg - keepSegs;
7907 oldestSegMaxWalSize = 1;
7916 if (targetSeg >= oldestSlotSeg)
7919 if (targetSeg >= oldestSegMaxWalSize)
7927 if (targetSeg >= oldestSeg)
7973 uint64 slot_keep_segs;
7978 if (currSegNo - segno > slot_keep_segs)
7979 segno = currSegNo - slot_keep_segs;
7993 if (unsummarized_segno < segno)
7994 segno = unsummarized_segno;
8003 if (currSegNo - segno < keep_segs)
8006 if (currSegNo <= keep_segs)
8009 segno = currSegNo - keep_segs;
8014 if (segno < *logSegNo)
8066 if (mark_unimportant)
8091 (
errmsg(
"restore point \"%s\" created at %X/%X",
8168 bool recoveryInProgress;
8199 Insert->fullPageWrites =
true;
8218 Insert->fullPageWrites =
false;
8298 (
errmsg(
"online backup was canceled, recovery cannot continue")));
8325 running.
xcnt = nxids;
8334 running.
xids = xids;
8356 (
errmsg(
"unexpected timeline ID %u (should be %u) in shutdown checkpoint record",
8414 (
errmsg(
"unexpected timeline ID %u (should be %u) in online checkpoint record",
8443 (
errmsg(
"unexpected timeline ID %u (should be %u) in end-of-recovery record",
8483 elog(
ERROR,
"XLOG_FPI record did not contain a full-page image");
8488 elog(
ERROR,
"unexpected XLogReadBufferForRedo result when restoring backup block");
8594 int o_direct_flag = 0;
8607 return o_direct_flag;
8620 return o_direct_flag;
8623 return O_SYNC | o_direct_flag;
8627 return O_DSYNC | o_direct_flag;
8631 elog(
ERROR,
"unrecognized \"wal_sync_method\": %d", method);
8664 errmsg(
"could not fsync file \"%s\": %m", xlogfname)));
8709 msg =
_(
"could not fsync file \"%s\": %m");
8711 #ifdef HAVE_FSYNC_WRITETHROUGH
8714 msg =
_(
"could not fsync write-through file \"%s\": %m");
8719 msg =
_(
"could not fdatasync file \"%s\": %m");
8728 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8737 int save_errno = errno;
8743 errmsg(msg, xlogfname)));
8805 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8806 errmsg(
"WAL level not sufficient for making an online backup"),
8807 errhint(
"\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
8811 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8812 errmsg(
"backup label too long (max %d bytes)",
8849 bool gotUniqueStartpoint =
false;
8930 if (!checkpointfpw ||
state->startpoint <= recptr)
8932 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8933 errmsg(
"WAL generated with \"full_page_writes=off\" was replayed "
8934 "since last restartpoint"),
8935 errhint(
"This means that the backup being taken on the standby "
8936 "is corrupt and should not be used. "
8937 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
8938 "and then try an online backup again.")));
8947 gotUniqueStartpoint =
true;
8965 gotUniqueStartpoint =
true;
8968 }
while (!gotUniqueStartpoint);
8973 datadirpathlen = strlen(
DataDir);
8998 tsoid = strtoul(de->
d_name, &badp, 10);
8999 if (*badp !=
'\0' || errno == EINVAL || errno == ERANGE)
9011 rllen =
readlink(fullpath, linkpath,
sizeof(linkpath));
9015 (
errmsg(
"could not read symbolic link \"%s\": %m",
9019 else if (rllen >=
sizeof(linkpath))
9022 (
errmsg(
"symbolic link \"%s\" target is too long",
9026 linkpath[rllen] =
'\0';
9033 if (rllen > datadirpathlen &&
9034 strncmp(linkpath,
DataDir, datadirpathlen) == 0 &&
9043 for (s = linkpath; *s; s++)
9045 if (*s ==
'\n' || *s ==
'\r' || *s ==
'\\')
9063 snprintf(linkpath,
sizeof(linkpath),
"%s/%s",
9080 *tablespaces =
lappend(*tablespaces, ti);
9121 bool backup_stopped_in_recovery =
false;
9127 int seconds_before_warning;
9129 bool reported_waiting =
false;
9141 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9142 errmsg(
"WAL level not sufficient for making an online backup"),
9143 errhint(
"\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
9178 if (
state->started_in_recovery && !backup_stopped_in_recovery)
9180 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9181 errmsg(
"the standby was promoted during online backup"),
9182 errhint(
"This means that the backup being taken is corrupt "
9183 "and should not be used. "
9184 "Try taking another online backup.")));
9214 if (backup_stopped_in_recovery)
9226 if (
state->startpoint <= recptr)
9228 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9229 errmsg(
"WAL generated with \"full_page_writes=off\" was replayed "
9230 "during online backup"),
9231 errhint(
"This means that the backup being taken on the standby "
9232 "is corrupt and should not be used. "
9233 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
9234 "and then try an online backup again.")));
9251 sizeof(
state->startpoint));
9278 errmsg(
"could not create file \"%s\": %m",
9283 fprintf(fp,
"%s", history_file);
9284 pfree(history_file);
9289 errmsg(
"could not write file \"%s\": %m",
9322 if (waitforarchive &&
9334 seconds_before_warning = 60;
9342 if (!reported_waiting && waits > 5)
9345 (
errmsg(
"base backup done, waiting for required WAL segments to be archived")));
9346 reported_waiting =
true;
9352 WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
9355 if (++waits >= seconds_before_warning)
9357 seconds_before_warning *= 2;
9359 (
errmsg(
"still waiting for all required WAL segments to be archived (%d seconds elapsed)",
9361 errhint(
"Check that your \"archive_command\" is executing properly. "
9362 "You can safely cancel this backup, "
9363 "but the database backup will not be usable without all the WAL segments.")));
9368 (
errmsg(
"all required WAL segments have been archived")));
9370 else if (waitforarchive)
9372 (
errmsg(
"WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
9409 if (!during_backup_start)
9411 errmsg(
"aborting backup due to backend exiting before pg_backup_stop was called"));
9422 static bool already_done =
false;
9427 already_done =
true;
9437 uint64 current_bytepos;
9440 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)
Datum now(PG_FUNCTION_ARGS)
const char * timestamptz_to_str(TimestampTz t)
static bool backup_started_in_recovery
void CheckPointBuffers(int flags)
void UnlockReleaseBuffer(Buffer buffer)
#define pg_attribute_unused()
#define TYPEALIGN(ALIGNVAL, LEN)
#define Assert(condition)
#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)
static void PGresult * res
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
struct dirent * ReadDir(DIR *dir, const char *dirname)
int MakePGDirectory(const char *directoryName)
int pg_fsync_no_writethrough(int fd)
FILE * AllocateFile(const char *name, const char *mode)
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)
int durable_unlink(const char *fname, int elevel)
void ReserveExternalFD(void)
int OpenTransientFile(const char *fileName, int fileFlags)
void SyncDataDirectory(void)
DIR * AllocateDir(const char *dirname)
#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
void * guc_malloc(int elevel, size_t size)
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
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)
#define GUC_check_errdetail
#define TOAST_MAX_CHUNK_SIZE
#define INJECTION_POINT(name)
#define INSTR_TIME_SET_CURRENT(t)
#define INSTR_TIME_SET_ZERO(t)
#define INSTR_TIME_ACCUM_DIFF(x, y, z)
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)
#define WL_EXIT_ON_PM_DEATH
static void const char fflush(stdout)
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)
#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(XLogRecPtr redo)
void pgstat_discard_stats(void)
PgStat_CheckpointerStats PendingCheckpointerStats
PgStat_PendingWalStats PendingWalStats
struct pg_tm * pg_localtime(const pg_time_t *timep, const pg_tz *tz)
size_t pg_strftime(char *s, size_t maxsize, const char *format, const struct pg_tm *t)
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)
void CheckPointPredicate(void)
static int fd(const char *x, int i)
#define DELAY_CHKPT_START
#define DELAY_CHKPT_COMPLETE
VirtualTransactionId * GetVirtualXIDsDelayingChkpt(int *nvxids, int type)
bool MinimumActiveBackends(int min)
TransactionId GetOldestActiveTransactionId(void)
TransactionId GetOldestTransactionIdConsideredRunning(void)
bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids, int type)
void ProcArrayApplyRecoveryInfo(RunningTransactions running)
void ProcArrayInitRecovery(TransactionId initializedUptoXID)
static void set_ps_display(const char *activity)
MemoryContextSwitchTo(old_ctx)
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)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Size mul_size(Size s1, Size s2)
void pg_usleep(long microsec)
static pg_noinline void Size size
void CheckPointReplicationSlots(bool is_shutdown)
bool InvalidateObsoleteReplicationSlots(ReplicationSlotInvalidationCause cause, XLogSegNo oldestSegno, Oid dboid, TransactionId snapshotConflictHorizon)
void StartupReplicationSlots(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
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
PgStat_Counter wal_buffers_full
instr_time wal_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
FullTransactionId ckptFullXid
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)
void WaitLSNSetLatches(XLogRecPtr currentLSN)
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 SetWalSummarizerLatch(void)
void WaitForWalSummarization(XLogRecPtr lsn)
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)
bool check_max_slot_wal_keep_size(int *newval, void **extra, GucSource source)
const char * show_in_hot_standby(void)
XLogRecPtr RequestXLogSwitch(bool mark_unimportant)
void do_pg_abort_backup(int code, Datum arg)
XLogSegNo XLogGetLastRemovedSegno(void)
static char * str_time(pg_time_t tnow)
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)
#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)
char * GetMockAuthenticationNonce(void)
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)
static double CheckPointDistanceEstimate
static uint64 XLogRecPtrToBytePos(XLogRecPtr ptr)
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)
static XLogSegNo XLOGfileslop(XLogRecPtr lastredoptr)
static int UsableBytesInSegment
static char * GetXLogBuffer(XLogRecPtr ptr, TimeLineID tli)
const char * show_archive_command(void)
@ 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)
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 STANDBY_SIGNAL_FILE
#define CHECKPOINT_CAUSE_XLOG
#define CHECKPOINT_END_OF_RECOVERY
#define CHECKPOINT_FLUSH_ALL
#define BACKUP_LABEL_FILE
#define CHECKPOINT_CAUSE_TIME
#define RECOVERY_SIGNAL_FILE
#define CHECKPOINT_IS_SHUTDOWN
#define XLogArchivingAlways()
#define CHECKPOINT_IMMEDIATE
@ 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 XLogSetRecordFlags(uint8 flags)
void XLogRegisterData(const char *data, uint32 len)
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)
EndOfWalRecoveryInfo * FinishWalRecovery(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
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