111 #define BootstrapTimeLineID 1
140 bool XLOG_DEBUG =
false;
150 #define NUM_XLOGINSERT_LOCKS 8
173 #ifdef HAVE_FSYNC_WRITETHROUGH
575 #define INSERT_FREESPACE(endptr) \
576 (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))
579 #define NextBufIdx(idx) \
580 (((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
586 #define XLogRecPtrToBufIdx(recptr) \
587 (((recptr) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
592 #define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)
598 #define ConvertToXSegs(x, segsize) XLogMBVarToSegs((x), (segsize))
615 #define RefreshXLogWriteResult(_target) \
617 _target.Flush = pg_atomic_read_u64(&XLogCtl->logFlushResult); \
619 _target.Write = pg_atomic_read_u64(&XLogCtl->logWriteResult); \
747 bool topxid_included)
774 elog(
ERROR,
"cannot make new WAL entries during recovery");
844 (!prevDoPageWrites ||
908 rdata_crc = rechdr->
xl_crc;
911 rechdr->
xl_crc = rdata_crc;
919 StartPos, EndPos, insertTLI);
961 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
978 TRACE_POSTGRESQL_WAL_SWITCH();
989 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
993 if (offset == EndPos % XLOG_BLCKSZ)
1009 char *errormsg = NULL;
1023 for (; rdata != NULL; rdata = rdata->
next)
1034 .segment_open = NULL,
1035 .segment_close = NULL),
1048 errormsg ? errormsg :
"no error message");
1054 debug_reader->
record = decoded;
1056 debug_reader->
record = NULL;
1107 uint64 startbytepos;
1128 startbytepos =
Insert->CurrBytePos;
1129 endbytepos = startbytepos +
size;
1130 prevbytepos =
Insert->PrevBytePos;
1131 Insert->CurrBytePos = endbytepos;
1132 Insert->PrevBytePos = startbytepos;
1162 uint64 startbytepos;
1177 startbytepos =
Insert->CurrBytePos;
1183 *EndPos = *StartPos = ptr;
1187 endbytepos = startbytepos +
size;
1188 prevbytepos =
Insert->PrevBytePos;
1200 Insert->CurrBytePos = endbytepos;
1201 Insert->PrevBytePos = startbytepos;
1245 while (rdata != NULL)
1247 char *rdata_data = rdata->
data;
1248 int rdata_len = rdata->
len;
1250 while (rdata_len > freespace)
1256 memcpy(currpos, rdata_data, freespace);
1257 rdata_data += freespace;
1258 rdata_len -= freespace;
1259 written += freespace;
1260 CurrPos += freespace;
1291 memcpy(currpos, rdata_data, rdata_len);
1292 currpos += rdata_len;
1293 CurrPos += rdata_len;
1294 freespace -= rdata_len;
1295 written += rdata_len;
1297 rdata = rdata->
next;
1299 Assert(written == write_len);
1315 CurrPos += freespace;
1323 while (CurrPos < EndPos)
1347 CurrPos += XLOG_BLCKSZ;
1356 if (CurrPos != EndPos)
1359 errmsg_internal(
"space reserved for WAL record does not match what was written"));
1381 static int lockToTry = -1;
1383 if (lockToTry == -1)
1509 elog(
PANIC,
"cannot wait without a PGPROC structure");
1516 if (upto <= inserted)
1521 bytepos =
Insert->CurrBytePos;
1533 if (upto > reservedUpto)
1536 (
errmsg(
"request to flush past end of generated WAL; request %X/%X, current position %X/%X",
1538 upto = reservedUpto;
1550 finishedUpto = reservedUpto;
1582 insertingat, &insertingat))
1593 }
while (insertingat < upto);
1596 finishedUpto = insertingat;
1607 return finishedUpto;
1631 static uint64 cachedPage = 0;
1632 static char *cachedPos = NULL;
1639 if (ptr / XLOG_BLCKSZ == cachedPage)
1643 return cachedPos + ptr % XLOG_BLCKSZ;
1666 expectedEndPtr = ptr;
1667 expectedEndPtr += XLOG_BLCKSZ - ptr % XLOG_BLCKSZ;
1670 if (expectedEndPtr != endptr)
1695 initializedUpto = ptr;
1702 if (expectedEndPtr != endptr)
1703 elog(
PANIC,
"could not find WAL buffer for %X/%X",
1719 cachedPage = ptr / XLOG_BLCKSZ;
1725 return cachedPos + ptr % XLOG_BLCKSZ;
1746 char *pdst = dstbuf;
1749 Size nbytes = count;
1761 if (startptr + count > inserted)
1763 errmsg(
"cannot read past end of generated WAL: requested %X/%X, current position %X/%X",
1783 uint32 offset = recptr % XLOG_BLCKSZ;
1795 expectedEndPtr = recptr + (XLOG_BLCKSZ - offset);
1802 if (expectedEndPtr != endptr)
1811 psrc = page + offset;
1812 npagebytes =
Min(nbytes, XLOG_BLCKSZ - offset);
1821 memcpy(pdst, psrc, npagebytes);
1834 if (expectedEndPtr != endptr)
1838 recptr += npagebytes;
1839 nbytes -= npagebytes;
1842 Assert(pdst - dstbuf <= count);
1844 return pdst - dstbuf;
1872 seg_offset = XLOG_BLCKSZ;
1915 seg_offset = XLOG_BLCKSZ;
1922 seg_offset += fullpages * XLOG_BLCKSZ + bytesleft;
1946 offset = ptr % XLOG_BLCKSZ;
2050 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
2051 WriteRqst.
Write = OldPageRqstPtr;
2052 WriteRqst.
Flush = 0;
2056 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
2069 NewPageEndPtr = NewPageBeginPtr + XLOG_BLCKSZ;
2087 MemSet((
char *) NewPage, 0, XLOG_BLCKSZ);
2095 NewPage->xlp_tli = tli;
2096 NewPage->xlp_pageaddr = NewPageBeginPtr;
2113 if (
Insert->runningBackups == 0)
2144 if (XLOG_DEBUG && npages > 0)
2146 elog(
DEBUG1,
"initialized %d pages, up to %X/%X",
2204 GUC_check_errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.");
2223 "max_slot_wal_keep_size");
2264 recycleSegNo = (
XLogSegNo) ceil(((
double) lastredoptr + distance) /
2267 if (recycleSegNo < minSegNo)
2268 recycleSegNo = minSegNo;
2269 if (recycleSegNo > maxSegNo)
2270 recycleSegNo = maxSegNo;
2272 return recycleSegNo;
2312 bool last_iteration;
2357 elog(
PANIC,
"xlog write request %X/%X is past end of log %X/%X",
2412 finishing_seg = !ispartialpage &&
2415 if (last_iteration ||
2427 nbytes = npages * (
Size) XLOG_BLCKSZ;
2471 errmsg(
"could not write to log file \"%s\" at offset %u, length %zu: %m",
2472 xlogfname, startoffset, nleft)));
2476 startoffset += written;
2477 }
while (nleft > 0);
2534 if (flexible && npages == 0)
2599 #ifdef USE_ASSERT_CHECKING
2644 if (asyncXactLSN <= prevAsyncXactLSN)
2761 if (!force && newMinRecoveryPoint < lsn)
2763 "xlog min recovery request %X/%X is past current point %X/%X",
2776 (
errmsg_internal(
"updated min recovery point to %X/%X on timeline %u",
2778 newMinRecoveryPointTLI)));
2816 elog(
LOG,
"xlog flush request %X/%X; write %X/%X; flush %X/%X",
2833 WriteRqstPtr = record;
2853 if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write)
2911 WriteRqst.
Write = insertpos;
2912 WriteRqst.
Flush = insertpos;
2949 "xlog flush request %X/%X is not satisfied --- flushed only to %X/%X",
2982 bool flexible =
true;
3004 WriteRqst.
Write -= WriteRqst.
Write % XLOG_BLCKSZ;
3071 WriteRqst.
Flush = 0;
3076 elog(
LOG,
"xlog bg flush request write %X/%X; flush: %X/%X, current is write %X/%X; flush %X/%X",
3092 XLogWrite(WriteRqst, insertTLI, flexible);
3200 bool *added,
char *path)
3207 int open_flags = O_RDWR | O_CREAT | O_EXCL |
PG_BINARY;
3221 if (errno != ENOENT)
3224 errmsg(
"could not open file \"%s\": %m", path)));
3235 elog(
DEBUG2,
"creating and filling new WAL file");
3249 errmsg(
"could not create file \"%s\": %m", tmppath)));
3281 save_errno = errno ? errno : ENOSPC;
3299 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3310 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3317 errmsg(
"could not close file \"%s\": %m", tmppath)));
3324 installed_segno = logsegno;
3340 elog(
DEBUG2,
"done creating and filling new WAL file");
3387 errmsg(
"could not open file \"%s\": %m", path)));
3426 errmsg(
"could not open file \"%s\": %m", path)));
3440 errmsg(
"could not create file \"%s\": %m", tmppath)));
3449 nread = upto - nbytes;
3455 if (nread <
sizeof(buffer))
3456 memset(buffer.
data, 0,
sizeof(buffer));
3462 if (nread >
sizeof(buffer))
3463 nread =
sizeof(buffer);
3465 r =
read(srcfd, buffer.
data, nread);
3471 errmsg(
"could not read file \"%s\": %m",
3476 errmsg(
"could not read file \"%s\": read %d of %zu",
3477 path, r, (
Size) nread)));
3483 if ((
int)
write(
fd, buffer.
data,
sizeof(buffer)) != (
int)
sizeof(buffer))
3485 int save_errno = errno;
3492 errno = save_errno ? save_errno : ENOSPC;
3496 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3505 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3511 errmsg(
"could not close file \"%s\": %m", tmppath)));
3516 errmsg(
"could not close file \"%s\": %m", path)));
3522 elog(
ERROR,
"InstallXLogFileSegment should not have failed");
3556 struct stat stat_buf;
3577 while (
stat(path, &stat_buf) == 0)
3579 if ((*segno) >= max_segno)
3619 errmsg(
"could not open file \"%s\": %m", path)));
3638 #if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
3640 (void) posix_fadvise(
openLogFile, 0, 0, POSIX_FADV_DONTNEED);
3646 int save_errno = errno;
3652 errmsg(
"could not close file \"%s\": %m", xlogfname)));
3718 int save_errno = errno;
3725 if (segno <= lastRemovedSegNo)
3733 errmsg(
"requested WAL segment %s has already been removed",
3755 return lastRemovedSegNo;
3784 if (tli != file_tli)
3788 if (oldest_segno == 0 || file_segno < oldest_segno)
3789 oldest_segno = file_segno;
3793 return oldest_segno;
3826 elog(
DEBUG2,
"removing all temporary WAL segments");
3833 if (strncmp(xlde->
d_name,
"xlogtemp.", 9) != 0)
3838 elog(
DEBUG2,
"removed temporary WAL segment \"%s\"", path);
3874 elog(
DEBUG2,
"attempting to remove WAL segments older than log file %s",
3897 if (strcmp(xlde->
d_name + 8, lastoff + 8) <= 0)
3944 recycleSegNo = endLogSegNo + 10;
3951 elog(
DEBUG2,
"attempting to remove WAL segments newer than log file %s",
3967 if (strncmp(xlde->
d_name, switchseg, 8) < 0 &&
3968 strcmp(xlde->
d_name + 8, switchseg + 8) > 0)
4006 const char *segname = segment_de->
d_name;
4016 *endlogSegNo <= recycleSegNo &&
4020 true, recycleSegNo, insertTLI))
4051 if (rename(path, newpath) != 0)
4055 errmsg(
"could not rename file \"%s\": %m",
4091 struct stat stat_buf;
4098 errmsg(
"required WAL directory \"%s\" does not exist",
4103 if (
stat(path, &stat_buf) == 0)
4109 errmsg(
"required WAL directory \"%s\" does not exist",
4115 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4119 errmsg(
"could not create missing directory \"%s\": %m",
4125 if (
stat(path, &stat_buf) == 0)
4130 (
errmsg(
"required WAL directory \"%s\" does not exist",
4136 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4139 (
errmsg(
"could not create missing directory \"%s\": %m",
4164 elog(
DEBUG2,
"removing WAL backup history file \"%s\"",
4205 (
errcode(ERRCODE_INTERNAL_ERROR),
4206 errmsg(
"could not generate secret authorization token")));
4277 errmsg(
"could not create file \"%s\": %m",
4289 errmsg(
"could not write to file \"%s\": %m",
4298 errmsg(
"could not fsync file \"%s\": %m",
4305 errmsg(
"could not close file \"%s\": %m",
4314 static char wal_segsz_str[20];
4325 errmsg(
"could not open file \"%s\": %m",
4335 errmsg(
"could not read file \"%s\": %m",
4340 errmsg(
"could not read file \"%s\": read %d of %zu",
4356 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4357 errmsg(
"database files are incompatible with server"),
4358 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x),"
4359 " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
4362 errhint(
"This could be a problem of mismatched byte ordering. It looks like you need to initdb.")));
4366 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4367 errmsg(
"database files are incompatible with server"),
4368 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d,"
4369 " but the server was compiled with PG_CONTROL_VERSION %d.",
4371 errhint(
"It looks like you need to initdb.")));
4382 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4383 errmsg(
"incorrect checksum in control file")));
4392 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4393 errmsg(
"database files are incompatible with server"),
4394 errdetail(
"The database cluster was initialized with CATALOG_VERSION_NO %d,"
4395 " but the server was compiled with CATALOG_VERSION_NO %d.",
4397 errhint(
"It looks like you need to initdb.")));
4400 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4401 errmsg(
"database files are incompatible with server"),
4402 errdetail(
"The database cluster was initialized with MAXALIGN %d,"
4403 " but the server was compiled with MAXALIGN %d.",
4405 errhint(
"It looks like you need to initdb.")));
4408 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4409 errmsg(
"database files are incompatible with server"),
4410 errdetail(
"The database cluster appears to use a different floating-point number format than the server executable."),
4411 errhint(
"It looks like you need to initdb.")));
4414 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4415 errmsg(
"database files are incompatible with server"),
4416 errdetail(
"The database cluster was initialized with BLCKSZ %d,"
4417 " but the server was compiled with BLCKSZ %d.",
4419 errhint(
"It looks like you need to recompile or initdb.")));
4422 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4423 errmsg(
"database files are incompatible with server"),
4424 errdetail(
"The database cluster was initialized with RELSEG_SIZE %d,"
4425 " but the server was compiled with RELSEG_SIZE %d.",
4427 errhint(
"It looks like you need to recompile or initdb.")));
4430 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4431 errmsg(
"database files are incompatible with server"),
4432 errdetail(
"The database cluster was initialized with XLOG_BLCKSZ %d,"
4433 " but the server was compiled with XLOG_BLCKSZ %d.",
4435 errhint(
"It looks like you need to recompile or initdb.")));
4438 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4439 errmsg(
"database files are incompatible with server"),
4440 errdetail(
"The database cluster was initialized with NAMEDATALEN %d,"
4441 " but the server was compiled with NAMEDATALEN %d.",
4443 errhint(
"It looks like you need to recompile or initdb.")));
4446 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4447 errmsg(
"database files are incompatible with server"),
4448 errdetail(
"The database cluster was initialized with INDEX_MAX_KEYS %d,"
4449 " but the server was compiled with INDEX_MAX_KEYS %d.",
4451 errhint(
"It looks like you need to recompile or initdb.")));
4454 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4455 errmsg(
"database files are incompatible with server"),
4456 errdetail(
"The database cluster was initialized with TOAST_MAX_CHUNK_SIZE %d,"
4457 " but the server was compiled with TOAST_MAX_CHUNK_SIZE %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"),
4464 errdetail(
"The database cluster was initialized with LOBLKSIZE %d,"
4465 " but the server was compiled with LOBLKSIZE %d.",
4467 errhint(
"It looks like you need to recompile or initdb.")));
4469 #ifdef USE_FLOAT8_BYVAL
4472 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4473 errmsg(
"database files are incompatible with server"),
4474 errdetail(
"The database cluster was initialized without USE_FLOAT8_BYVAL"
4475 " but the server was compiled with USE_FLOAT8_BYVAL."),
4476 errhint(
"It looks like you need to recompile or initdb.")));
4480 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4481 errmsg(
"database files are incompatible with server"),
4482 errdetail(
"The database cluster was initialized with USE_FLOAT8_BYVAL"
4483 " but the server was compiled without USE_FLOAT8_BYVAL."),
4484 errhint(
"It looks like you need to recompile or initdb.")));
4491 errmsg_plural(
"invalid WAL segment size in control file (%d byte)",
4492 "invalid WAL segment size in control file (%d bytes)",
4495 errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.")));
4504 errmsg(
"min_wal_size must be at least twice wal_segment_size")));
4508 errmsg(
"max_wal_size must be at least twice wal_segment_size")));
4662 foreach(l, elemlist)
4664 char *tok = (
char *)
lfirst(l);
4670 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4672 newwalconsistency[rmid] =
true;
4679 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4684 newwalconsistency[rmid] =
true;
4716 memcpy(*extra, newwalconsistency, (
RM_MAX_ID + 1) *
sizeof(
bool));
4782 return "(disabled)";
4900 if (walDebugCxt == NULL)
4917 if (foundCFile || foundXLog)
4920 Assert(foundCFile && foundXLog);
4925 if (localControlFile)
4926 pfree(localControlFile);
4935 if (localControlFile)
4938 pfree(localControlFile);
4974 allocptr = (
char *)
TYPEALIGN(XLOG_BLCKSZ, allocptr);
5008 uint64 sysidentifier;
5028 sysidentifier = ((uint64) tv.tv_sec) << 32;
5029 sysidentifier |= ((uint64) tv.tv_usec) << 12;
5030 sysidentifier |= getpid() & 0xFFF;
5033 buffer = (
char *)
palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
5035 memset(page, 0, XLOG_BLCKSZ);
5092 *(recptr++) =
sizeof(checkPoint);
5093 memcpy(recptr, &checkPoint,
sizeof(checkPoint));
5094 recptr +=
sizeof(checkPoint);
5122 errmsg(
"could not write bootstrap write-ahead log file: %m")));
5130 errmsg(
"could not fsync bootstrap write-ahead log file: %m")));
5136 errmsg(
"could not close bootstrap write-ahead log file: %m")));
5167 static char buf[128];
5170 "%Y-%m-%d %H:%M:%S %Z",
5187 Assert(endTLI != newTLI);
5209 if (endLogSegNo == startLogSegNo)
5233 int save_errno = errno;
5239 errmsg(
"could not close file \"%s\": %m", xlogfname)));
5263 "recovery_end_command",
5265 WAIT_EVENT_RECOVERY_END_COMMAND);
5353 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5354 errmsg(
"WAL was generated with wal_level=minimal, cannot continue recovering"),
5355 errdetail(
"This happens if you temporarily set wal_level=minimal on the server."),
5356 errhint(
"Use a backup taken after setting wal_level to higher than minimal.")));
5395 bool haveBackupLabel;
5399 bool performedWalRecovery;
5404 bool promoted =
false;
5421 errmsg(
"control file contains invalid checkpoint location")));
5432 (
errmsg(
"database system was shut down at %s",
5438 (
errmsg(
"database system was shut down in recovery at %s",
5444 (
errmsg(
"database system shutdown was interrupted; last known up at %s",
5450 (
errmsg(
"database system was interrupted while in recovery at %s",
5452 errhint(
"This probably means that some data is corrupted and"
5453 " you will have to use the last backup for recovery.")));
5458 (
errmsg(
"database system was interrupted while in recovery at log time %s",
5460 errhint(
"If this has occurred more than once some data might be corrupted"
5461 " and you might need to choose an earlier recovery target.")));
5466 (
errmsg(
"database system was interrupted; last known up at %s",
5473 errmsg(
"control file contains invalid database cluster state")));
5477 #ifdef XLOG_REPLAY_DELAY
5527 &haveBackupLabel, &haveTblspcMap);
5680 if (haveBackupLabel)
5786 running.
xcnt = nxids;
5795 running.
xids = xids;
5807 performedWalRecovery =
true;
5810 performedWalRecovery =
false;
5816 EndOfLog = endOfRecoveryInfo->
endOfLog;
5859 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5860 errmsg(
"WAL ends before end of online backup"),
5861 errhint(
"All WAL generated while online backup was taken must be available at recovery.")));
5864 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5865 errmsg(
"WAL ends before consistent recovery point")));
5911 (
errmsg(
"selected new timeline ID: %u", newTLI)));
5944 (
errmsg(
"archive recovery complete")));
5985 if (EndOfLog % XLOG_BLCKSZ != 0)
5998 memset(page +
len, 0, XLOG_BLCKSZ -
len);
6088 if (performedWalRecovery)
6242 bool promoted =
false;
6384 return oldXLogAllowed;
6511 if (
res < last_important)
6512 res = last_important;
6552 (
errmsg(
"shutting down")));
6591 (
errmsg(
"restartpoint starting:%s%s%s%s%s%s%s%s",
6603 (
errmsg(
"checkpoint starting:%s%s%s%s%s%s%s%s",
6625 uint64 average_sync_time;
6655 average_sync_time = 0;
6659 average_msecs = (long) ((average_sync_time + 999) / 1000);
6668 (
errmsg(
"restartpoint complete: wrote %d buffers (%.1f%%); "
6669 "%d WAL file(s) added, %d removed, %d recycled; "
6670 "write=%ld.%03d s, sync=%ld.%03d s, total=%ld.%03d s; "
6671 "sync files=%d, longest=%ld.%03d s, average=%ld.%03d s; "
6672 "distance=%d kB, estimate=%d kB; "
6673 "lsn=%X/%X, redo lsn=%X/%X",
6679 write_msecs / 1000, (
int) (write_msecs % 1000),
6680 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6681 total_msecs / 1000, (
int) (total_msecs % 1000),
6683 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6684 average_msecs / 1000, (
int) (average_msecs % 1000),
6691 (
errmsg(
"checkpoint complete: wrote %d buffers (%.1f%%); "
6692 "%d WAL file(s) added, %d removed, %d recycled; "
6693 "write=%ld.%03d s, sync=%ld.%03d s, total=%ld.%03d s; "
6694 "sync files=%d, longest=%ld.%03d s, average=%ld.%03d s; "
6695 "distance=%d kB, estimate=%d kB; "
6696 "lsn=%X/%X, redo lsn=%X/%X",
6702 write_msecs / 1000, (
int) (write_msecs % 1000),
6703 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6704 total_msecs / 1000, (
int) (total_msecs % 1000),
6706 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6707 average_msecs / 1000, (
int) (average_msecs % 1000),
6775 char activitymsg[128];
6777 snprintf(activitymsg,
sizeof(activitymsg),
"performing %s%s%s",
6780 restartpoint ?
"restartpoint" :
"checkpoint");
6833 int oldXLogAllowed = 0;
6846 elog(
ERROR,
"can't create a checkpoint during recovery");
6880 MemSet(&checkPoint, 0,
sizeof(checkPoint));
6955 checkPoint.
redo = curInsert;
7020 TRACE_POSTGRESQL_CHECKPOINT_START(flags);
7165 (
errmsg(
"concurrent write-ahead log activity while database system is shutting down")));
7304 elog(
ERROR,
"can only be used to end recovery");
7371 elog(
ERROR,
"can only be used at end of recovery");
7372 if (pagePtr % XLOG_BLCKSZ != 0)
7373 elog(
ERROR,
"invalid position for missing continuation record %X/%X",
7383 if (recptr != startPos)
7384 elog(
ERROR,
"invalid WAL insert position %X/%X for OVERWRITE_CONTRECORD",
7414 elog(
ERROR,
"OVERWRITE_CONTRECORD was inserted to unexpected position %X/%X",
7440 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_START(flags);
7450 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_SYNC_START();
7454 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_DONE();
7483 "could not record restart point at %X/%X because there "
7484 "are unresolved references to invalid pages",
7542 (
errmsg_internal(
"skipping restartpoint, recovery has already ended")));
7693 endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
7749 (
errmsg(
"recovery restart point at %X/%X",
7751 xtime ?
errdetail(
"Last completed transaction was at log time %s.",
7759 "archive_cleanup_command",
7761 WAIT_EVENT_ARCHIVE_CLEANUP_COMMAND);
7826 if (currSeg > keepSegs)
7827 oldestSegMaxWalSize = currSeg - keepSegs;
7829 oldestSegMaxWalSize = 1;
7838 if (targetSeg >= oldestSlotSeg)
7841 if (targetSeg >= oldestSegMaxWalSize)
7849 if (targetSeg >= oldestSeg)
7895 uint64 slot_keep_segs;
7900 if (currSegNo - segno > slot_keep_segs)
7901 segno = currSegNo - slot_keep_segs;
7915 if (unsummarized_segno < segno)
7916 segno = unsummarized_segno;
7925 if (currSegNo - segno < keep_segs)
7928 if (currSegNo <= keep_segs)
7931 segno = currSegNo - keep_segs;
7936 if (segno < *logSegNo)
7988 if (mark_unimportant)
8013 (
errmsg(
"restore point \"%s\" created at %X/%X",
8090 bool recoveryInProgress;
8121 Insert->fullPageWrites =
true;
8140 Insert->fullPageWrites =
false;
8220 (
errmsg(
"online backup was canceled, recovery cannot continue")));
8244 running.
xcnt = nxids;
8253 running.
xids = xids;
8277 (
errmsg(
"unexpected timeline ID %u (should be %u) in shutdown checkpoint record",
8335 (
errmsg(
"unexpected timeline ID %u (should be %u) in online checkpoint record",
8364 (
errmsg(
"unexpected timeline ID %u (should be %u) in end-of-recovery record",
8404 elog(
ERROR,
"XLOG_FPI record did not contain a full-page image");
8409 elog(
ERROR,
"unexpected XLogReadBufferForRedo result when restoring backup block");
8515 int o_direct_flag = 0;
8528 return o_direct_flag;
8541 return o_direct_flag;
8544 return O_SYNC | o_direct_flag;
8548 return O_DSYNC | o_direct_flag;
8552 elog(
ERROR,
"unrecognized wal_sync_method: %d", method);
8585 errmsg(
"could not fsync file \"%s\": %m", xlogfname)));
8630 msg =
_(
"could not fsync file \"%s\": %m");
8632 #ifdef HAVE_FSYNC_WRITETHROUGH
8635 msg =
_(
"could not fsync write-through file \"%s\": %m");
8640 msg =
_(
"could not fdatasync file \"%s\": %m");
8649 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8658 int save_errno = errno;
8664 errmsg(msg, xlogfname)));
8726 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8727 errmsg(
"WAL level not sufficient for making an online backup"),
8728 errhint(
"wal_level must be set to \"replica\" or \"logical\" at server start.")));
8732 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8733 errmsg(
"backup label too long (max %d bytes)",
8736 memcpy(
state->name, backupidstr, strlen(backupidstr));
8770 bool gotUniqueStartpoint =
false;
8851 if (!checkpointfpw ||
state->startpoint <= recptr)
8853 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8854 errmsg(
"WAL generated with full_page_writes=off was replayed "
8855 "since last restartpoint"),
8856 errhint(
"This means that the backup being taken on the standby "
8857 "is corrupt and should not be used. "
8858 "Enable full_page_writes and run CHECKPOINT on the primary, "
8859 "and then try an online backup again.")));
8868 gotUniqueStartpoint =
true;
8886 gotUniqueStartpoint =
true;
8889 }
while (!gotUniqueStartpoint);
8894 datadirpathlen = strlen(
DataDir);
8898 while ((de =
ReadDir(tblspcdir,
"pg_tblspc")) != NULL)
8919 tsoid = strtoul(de->
d_name, &badp, 10);
8920 if (*badp !=
'\0' || errno == EINVAL || errno == ERANGE)
8923 snprintf(fullpath,
sizeof(fullpath),
"pg_tblspc/%s", de->
d_name);
8932 rllen =
readlink(fullpath, linkpath,
sizeof(linkpath));
8936 (
errmsg(
"could not read symbolic link \"%s\": %m",
8940 else if (rllen >=
sizeof(linkpath))
8943 (
errmsg(
"symbolic link \"%s\" target is too long",
8947 linkpath[rllen] =
'\0';
8954 if (rllen > datadirpathlen &&
8955 strncmp(linkpath,
DataDir, datadirpathlen) == 0 &&
8964 for (s = linkpath; *s; s++)
8966 if (*s ==
'\n' || *s ==
'\r' || *s ==
'\\')
8984 snprintf(linkpath,
sizeof(linkpath),
"pg_tblspc/%s",
9001 *tablespaces =
lappend(*tablespaces, ti);
9042 bool backup_stopped_in_recovery =
false;
9048 int seconds_before_warning;
9050 bool reported_waiting =
false;
9062 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9063 errmsg(
"WAL level not sufficient for making an online backup"),
9064 errhint(
"wal_level must be set to \"replica\" or \"logical\" at server start.")));
9099 if (
state->started_in_recovery && !backup_stopped_in_recovery)
9101 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9102 errmsg(
"the standby was promoted during online backup"),
9103 errhint(
"This means that the backup being taken is corrupt "
9104 "and should not be used. "
9105 "Try taking another online backup.")));
9135 if (backup_stopped_in_recovery)
9147 if (
state->startpoint <= recptr)
9149 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9150 errmsg(
"WAL generated with full_page_writes=off was replayed "
9151 "during online backup"),
9152 errhint(
"This means that the backup being taken on the standby "
9153 "is corrupt and should not be used. "
9154 "Enable full_page_writes and run CHECKPOINT on the primary, "
9155 "and then try an online backup again.")));
9172 sizeof(
state->startpoint));
9199 errmsg(
"could not create file \"%s\": %m",
9204 fprintf(fp,
"%s", history_file);
9205 pfree(history_file);
9210 errmsg(
"could not write file \"%s\": %m",
9243 if (waitforarchive &&
9255 seconds_before_warning = 60;
9263 if (!reported_waiting && waits > 5)
9266 (
errmsg(
"base backup done, waiting for required WAL segments to be archived")));
9267 reported_waiting =
true;
9273 WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
9276 if (++waits >= seconds_before_warning)
9278 seconds_before_warning *= 2;
9280 (
errmsg(
"still waiting for all required WAL segments to be archived (%d seconds elapsed)",
9282 errhint(
"Check that your archive_command is executing properly. "
9283 "You can safely cancel this backup, "
9284 "but the database backup will not be usable without all the WAL segments.")));
9289 (
errmsg(
"all required WAL segments have been archived")));
9291 else if (waitforarchive)
9293 (
errmsg(
"WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
9330 if (!during_backup_start)
9332 errmsg(
"aborting backup due to backend exiting before pg_backup_stop was called"));
9343 static bool already_done =
false;
9348 already_done =
true;
9358 uint64 current_bytepos;
9361 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_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_monotonic_advance_u64(volatile pg_atomic_uint64 *ptr, uint64 target_)
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
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(void)
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
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)
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)
XLogRecPtr GetOldestUnsummarizedLSN(TimeLineID *tli, bool *lsn_is_exact, bool reset_pending_lsn)
#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 InitControlFile(uint64 sysidentifier)
static void WALInsertLockUpdateInsertingAt(XLogRecPtr insertingAt)
XLogRecPtr GetRedoRecPtr(void)
void assign_wal_consistency_checking(const char *newval, void *extra)
void SetInstallXLogFileSegmentActive(void)
static void AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli, bool opportunistic)
static void WALInsertLockAcquireExclusive(void)
static void UpdateControlFile(void)
bool IsInstallXLogFileSegmentActive(void)
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
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[]
#define BootstrapTimeLineID
CheckpointStatsData CheckpointStats
bool check_wal_buffers(int *newval, void **extra, GucSource source)
XLogRecPtr GetFakeLSNForUnloggedRel(void)
void XLogPutNextOid(Oid nextOid)
uint32 bootstrap_data_checksum_version
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)
void CreateCheckPoint(int flags)
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
void XLogRegisterData(char *data, uint32 len)
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
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)
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