111 #define BootstrapTimeLineID 1
140 bool XLOG_DEBUG =
false;
150 #define NUM_XLOGINSERT_LOCKS 8
173 #ifdef HAVE_FSYNC_WRITETHROUGH
582 #define INSERT_FREESPACE(endptr) \
583 (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))
586 #define NextBufIdx(idx) \
587 (((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
593 #define XLogRecPtrToBufIdx(recptr) \
594 (((recptr) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
599 #define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)
605 #define ConvertToXSegs(x, segsize) XLogMBVarToSegs((x), (segsize))
741 bool topxid_included)
768 elog(
ERROR,
"cannot make new WAL entries during recovery");
838 (!prevDoPageWrites ||
902 rdata_crc = rechdr->
xl_crc;
905 rechdr->
xl_crc = rdata_crc;
913 StartPos, EndPos, insertTLI);
955 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
973 TRACE_POSTGRESQL_WAL_SWITCH();
984 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
988 if (offset == EndPos % XLOG_BLCKSZ)
1004 char *errormsg = NULL;
1018 for (; rdata != NULL; rdata = rdata->
next)
1029 .segment_open = NULL,
1030 .segment_close = NULL),
1043 errormsg ? errormsg :
"no error message");
1049 debug_reader->
record = decoded;
1051 debug_reader->
record = NULL;
1102 uint64 startbytepos;
1123 startbytepos =
Insert->CurrBytePos;
1124 endbytepos = startbytepos +
size;
1125 prevbytepos =
Insert->PrevBytePos;
1126 Insert->CurrBytePos = endbytepos;
1127 Insert->PrevBytePos = startbytepos;
1157 uint64 startbytepos;
1172 startbytepos =
Insert->CurrBytePos;
1178 *EndPos = *StartPos = ptr;
1182 endbytepos = startbytepos +
size;
1183 prevbytepos =
Insert->PrevBytePos;
1195 Insert->CurrBytePos = endbytepos;
1196 Insert->PrevBytePos = startbytepos;
1240 while (rdata != NULL)
1242 char *rdata_data = rdata->
data;
1243 int rdata_len = rdata->
len;
1245 while (rdata_len > freespace)
1251 memcpy(currpos, rdata_data, freespace);
1252 rdata_data += freespace;
1253 rdata_len -= freespace;
1254 written += freespace;
1255 CurrPos += freespace;
1286 memcpy(currpos, rdata_data, rdata_len);
1287 currpos += rdata_len;
1288 CurrPos += rdata_len;
1289 freespace -= rdata_len;
1290 written += rdata_len;
1292 rdata = rdata->
next;
1294 Assert(written == write_len);
1310 CurrPos += freespace;
1318 while (CurrPos < EndPos)
1342 CurrPos += XLOG_BLCKSZ;
1351 if (CurrPos != EndPos)
1352 elog(
PANIC,
"space reserved for WAL record does not match what was written");
1374 static int lockToTry = -1;
1376 if (lockToTry == -1)
1501 elog(
PANIC,
"cannot wait without a PGPROC structure");
1505 bytepos =
Insert->CurrBytePos;
1517 if (upto > reservedUpto)
1520 (
errmsg(
"request to flush past end of generated WAL; request %X/%X, current position %X/%X",
1522 upto = reservedUpto;
1534 finishedUpto = reservedUpto;
1566 insertingat, &insertingat))
1577 }
while (insertingat < upto);
1580 finishedUpto = insertingat;
1582 return finishedUpto;
1606 static uint64 cachedPage = 0;
1607 static char *cachedPos = NULL;
1614 if (ptr / XLOG_BLCKSZ == cachedPage)
1618 return cachedPos + ptr % XLOG_BLCKSZ;
1641 expectedEndPtr = ptr;
1642 expectedEndPtr += XLOG_BLCKSZ - ptr % XLOG_BLCKSZ;
1645 if (expectedEndPtr != endptr)
1670 initializedUpto = ptr;
1677 if (expectedEndPtr != endptr)
1678 elog(
PANIC,
"could not find WAL buffer for %X/%X",
1694 cachedPage = ptr / XLOG_BLCKSZ;
1700 return cachedPos + ptr % XLOG_BLCKSZ;
1721 char *pdst = dstbuf;
1723 Size nbytes = count;
1747 uint32 offset = recptr % XLOG_BLCKSZ;
1759 expectedEndPtr = recptr + (XLOG_BLCKSZ - offset);
1766 if (expectedEndPtr != endptr)
1775 psrc = page + offset;
1776 npagebytes =
Min(nbytes, XLOG_BLCKSZ - offset);
1785 memcpy(pdst, psrc, npagebytes);
1798 if (expectedEndPtr != endptr)
1802 recptr += npagebytes;
1803 nbytes -= npagebytes;
1806 Assert(pdst - dstbuf <= count);
1808 return pdst - dstbuf;
1836 seg_offset = XLOG_BLCKSZ;
1879 seg_offset = XLOG_BLCKSZ;
1886 seg_offset += fullpages * XLOG_BLCKSZ + bytesleft;
1910 offset = ptr % XLOG_BLCKSZ;
2014 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
2015 WriteRqst.
Write = OldPageRqstPtr;
2016 WriteRqst.
Flush = 0;
2020 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
2033 NewPageEndPtr = NewPageBeginPtr + XLOG_BLCKSZ;
2051 MemSet((
char *) NewPage, 0, XLOG_BLCKSZ);
2059 NewPage->xlp_tli = tli;
2060 NewPage->xlp_pageaddr = NewPageBeginPtr;
2077 if (
Insert->runningBackups == 0)
2108 if (XLOG_DEBUG && npages > 0)
2110 elog(
DEBUG1,
"initialized %d pages, up to %X/%X",
2168 GUC_check_errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.");
2187 "max_slot_wal_keep_size");
2228 recycleSegNo = (
XLogSegNo) ceil(((
double) lastredoptr + distance) /
2231 if (recycleSegNo < minSegNo)
2232 recycleSegNo = minSegNo;
2233 if (recycleSegNo > maxSegNo)
2234 recycleSegNo = maxSegNo;
2236 return recycleSegNo;
2276 bool last_iteration;
2321 elog(
PANIC,
"xlog write request %X/%X is past end of log %X/%X",
2376 finishing_seg = !ispartialpage &&
2379 if (last_iteration ||
2391 nbytes = npages * (
Size) XLOG_BLCKSZ;
2435 errmsg(
"could not write to log file \"%s\" at offset %u, length %zu: %m",
2436 xlogfname, startoffset, nleft)));
2440 startoffset += written;
2441 }
while (nleft > 0);
2498 if (flexible && npages == 0)
2583 if (asyncXactLSN <= prevAsyncXactLSN)
2698 if (!force && newMinRecoveryPoint < lsn)
2700 "xlog min recovery request %X/%X is past current point %X/%X",
2713 (
errmsg_internal(
"updated min recovery point to %X/%X on timeline %u",
2715 newMinRecoveryPointTLI)));
2753 elog(
LOG,
"xlog flush request %X/%X; write %X/%X; flush %X/%X",
2770 WriteRqstPtr = record;
2782 if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write)
2850 WriteRqst.
Write = insertpos;
2851 WriteRqst.
Flush = insertpos;
2888 "xlog flush request %X/%X is not satisfied --- flushed only to %X/%X",
2921 bool flexible =
true;
2944 WriteRqst.
Write -= WriteRqst.
Write % XLOG_BLCKSZ;
3010 WriteRqst.
Flush = 0;
3015 elog(
LOG,
"xlog bg flush request write %X/%X; flush: %X/%X, current is write %X/%X; flush %X/%X",
3031 XLogWrite(WriteRqst, insertTLI, flexible);
3141 bool *added,
char *path)
3148 int open_flags = O_RDWR | O_CREAT | O_EXCL |
PG_BINARY;
3162 if (errno != ENOENT)
3165 errmsg(
"could not open file \"%s\": %m", path)));
3176 elog(
DEBUG2,
"creating and filling new WAL file");
3190 errmsg(
"could not create file \"%s\": %m", tmppath)));
3222 save_errno = errno ? errno : ENOSPC;
3240 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3251 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3258 errmsg(
"could not close file \"%s\": %m", tmppath)));
3265 installed_segno = logsegno;
3281 elog(
DEBUG2,
"done creating and filling new WAL file");
3328 errmsg(
"could not open file \"%s\": %m", path)));
3367 errmsg(
"could not open file \"%s\": %m", path)));
3381 errmsg(
"could not create file \"%s\": %m", tmppath)));
3390 nread = upto - nbytes;
3396 if (nread <
sizeof(buffer))
3397 memset(buffer.
data, 0,
sizeof(buffer));
3403 if (nread >
sizeof(buffer))
3404 nread =
sizeof(buffer);
3406 r =
read(srcfd, buffer.
data, nread);
3412 errmsg(
"could not read file \"%s\": %m",
3417 errmsg(
"could not read file \"%s\": read %d of %zu",
3418 path, r, (
Size) nread)));
3424 if ((
int)
write(
fd, buffer.
data,
sizeof(buffer)) != (
int)
sizeof(buffer))
3426 int save_errno = errno;
3433 errno = save_errno ? save_errno : ENOSPC;
3437 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3446 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3452 errmsg(
"could not close file \"%s\": %m", tmppath)));
3457 errmsg(
"could not close file \"%s\": %m", path)));
3463 elog(
ERROR,
"InstallXLogFileSegment should not have failed");
3497 struct stat stat_buf;
3518 while (
stat(path, &stat_buf) == 0)
3520 if ((*segno) >= max_segno)
3560 errmsg(
"could not open file \"%s\": %m", path)));
3579 #if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
3581 (void) posix_fadvise(
openLogFile, 0, 0, POSIX_FADV_DONTNEED);
3587 int save_errno = errno;
3593 errmsg(
"could not close file \"%s\": %m", xlogfname)));
3659 int save_errno = errno;
3666 if (segno <= lastRemovedSegNo)
3674 errmsg(
"requested WAL segment %s has already been removed",
3696 return lastRemovedSegNo;
3725 if (tli != file_tli)
3729 if (oldest_segno == 0 || file_segno < oldest_segno)
3730 oldest_segno = file_segno;
3734 return oldest_segno;
3767 elog(
DEBUG2,
"removing all temporary WAL segments");
3774 if (strncmp(xlde->
d_name,
"xlogtemp.", 9) != 0)
3779 elog(
DEBUG2,
"removed temporary WAL segment \"%s\"", path);
3815 elog(
DEBUG2,
"attempting to remove WAL segments older than log file %s",
3838 if (strcmp(xlde->
d_name + 8, lastoff + 8) <= 0)
3885 recycleSegNo = endLogSegNo + 10;
3892 elog(
DEBUG2,
"attempting to remove WAL segments newer than log file %s",
3908 if (strncmp(xlde->
d_name, switchseg, 8) < 0 &&
3909 strcmp(xlde->
d_name + 8, switchseg + 8) > 0)
3947 const char *segname = segment_de->
d_name;
3957 *endlogSegNo <= recycleSegNo &&
3961 true, recycleSegNo, insertTLI))
3992 if (rename(path, newpath) != 0)
3996 errmsg(
"could not rename file \"%s\": %m",
4032 struct stat stat_buf;
4038 (
errmsg(
"required WAL directory \"%s\" does not exist",
4043 if (
stat(path, &stat_buf) == 0)
4048 (
errmsg(
"required WAL directory \"%s\" does not exist",
4054 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4057 (
errmsg(
"could not create missing directory \"%s\": %m",
4063 if (
stat(path, &stat_buf) == 0)
4068 (
errmsg(
"required WAL directory \"%s\" does not exist",
4074 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4077 (
errmsg(
"could not create missing directory \"%s\": %m",
4102 elog(
DEBUG2,
"removing WAL backup history file \"%s\"",
4143 (
errcode(ERRCODE_INTERNAL_ERROR),
4144 errmsg(
"could not generate secret authorization token")));
4215 errmsg(
"could not create file \"%s\": %m",
4227 errmsg(
"could not write to file \"%s\": %m",
4236 errmsg(
"could not fsync file \"%s\": %m",
4243 errmsg(
"could not close file \"%s\": %m",
4252 static char wal_segsz_str[20];
4263 errmsg(
"could not open file \"%s\": %m",
4273 errmsg(
"could not read file \"%s\": %m",
4278 errmsg(
"could not read file \"%s\": read %d of %zu",
4294 (
errmsg(
"database files are incompatible with server"),
4295 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x),"
4296 " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
4299 errhint(
"This could be a problem of mismatched byte ordering. It looks like you need to initdb.")));
4303 (
errmsg(
"database files are incompatible with server"),
4304 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d,"
4305 " but the server was compiled with PG_CONTROL_VERSION %d.",
4307 errhint(
"It looks like you need to initdb.")));
4318 (
errmsg(
"incorrect checksum in control file")));
4327 (
errmsg(
"database files are incompatible with server"),
4328 errdetail(
"The database cluster was initialized with CATALOG_VERSION_NO %d,"
4329 " but the server was compiled with CATALOG_VERSION_NO %d.",
4331 errhint(
"It looks like you need to initdb.")));
4334 (
errmsg(
"database files are incompatible with server"),
4335 errdetail(
"The database cluster was initialized with MAXALIGN %d,"
4336 " but the server was compiled with MAXALIGN %d.",
4338 errhint(
"It looks like you need to initdb.")));
4341 (
errmsg(
"database files are incompatible with server"),
4342 errdetail(
"The database cluster appears to use a different floating-point number format than the server executable."),
4343 errhint(
"It looks like you need to initdb.")));
4346 (
errmsg(
"database files are incompatible with server"),
4347 errdetail(
"The database cluster was initialized with BLCKSZ %d,"
4348 " but the server was compiled with BLCKSZ %d.",
4350 errhint(
"It looks like you need to recompile or initdb.")));
4353 (
errmsg(
"database files are incompatible with server"),
4354 errdetail(
"The database cluster was initialized with RELSEG_SIZE %d,"
4355 " but the server was compiled with RELSEG_SIZE %d.",
4357 errhint(
"It looks like you need to recompile or initdb.")));
4360 (
errmsg(
"database files are incompatible with server"),
4361 errdetail(
"The database cluster was initialized with XLOG_BLCKSZ %d,"
4362 " but the server was compiled with XLOG_BLCKSZ %d.",
4364 errhint(
"It looks like you need to recompile or initdb.")));
4367 (
errmsg(
"database files are incompatible with server"),
4368 errdetail(
"The database cluster was initialized with NAMEDATALEN %d,"
4369 " but the server was compiled with NAMEDATALEN %d.",
4371 errhint(
"It looks like you need to recompile or initdb.")));
4374 (
errmsg(
"database files are incompatible with server"),
4375 errdetail(
"The database cluster was initialized with INDEX_MAX_KEYS %d,"
4376 " but the server was compiled with INDEX_MAX_KEYS %d.",
4378 errhint(
"It looks like you need to recompile or initdb.")));
4381 (
errmsg(
"database files are incompatible with server"),
4382 errdetail(
"The database cluster was initialized with TOAST_MAX_CHUNK_SIZE %d,"
4383 " but the server was compiled with TOAST_MAX_CHUNK_SIZE %d.",
4385 errhint(
"It looks like you need to recompile or initdb.")));
4388 (
errmsg(
"database files are incompatible with server"),
4389 errdetail(
"The database cluster was initialized with LOBLKSIZE %d,"
4390 " but the server was compiled with LOBLKSIZE %d.",
4392 errhint(
"It looks like you need to recompile or initdb.")));
4394 #ifdef USE_FLOAT8_BYVAL
4397 (
errmsg(
"database files are incompatible with server"),
4398 errdetail(
"The database cluster was initialized without USE_FLOAT8_BYVAL"
4399 " but the server was compiled with USE_FLOAT8_BYVAL."),
4400 errhint(
"It looks like you need to recompile or initdb.")));
4404 (
errmsg(
"database files are incompatible with server"),
4405 errdetail(
"The database cluster was initialized with USE_FLOAT8_BYVAL"
4406 " but the server was compiled without USE_FLOAT8_BYVAL."),
4407 errhint(
"It looks like you need to recompile or initdb.")));
4414 errmsg_plural(
"invalid WAL segment size in control file (%d byte)",
4415 "invalid WAL segment size in control file (%d bytes)",
4418 errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.")));
4427 errmsg(
"min_wal_size must be at least twice wal_segment_size")));
4431 errmsg(
"max_wal_size must be at least twice wal_segment_size")));
4585 foreach(l, elemlist)
4587 char *tok = (
char *)
lfirst(l);
4593 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4595 newwalconsistency[rmid] =
true;
4602 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4607 newwalconsistency[rmid] =
true;
4639 memcpy(*extra, newwalconsistency, (
RM_MAX_ID + 1) *
sizeof(
bool));
4705 return "(disabled)";
4823 if (walDebugCxt == NULL)
4840 if (foundCFile || foundXLog)
4843 Assert(foundCFile && foundXLog);
4848 if (localControlFile)
4849 pfree(localControlFile);
4858 if (localControlFile)
4861 pfree(localControlFile);
4897 allocptr = (
char *)
TYPEALIGN(XLOG_BLCKSZ, allocptr);
4928 uint64 sysidentifier;
4948 sysidentifier = ((uint64) tv.tv_sec) << 32;
4949 sysidentifier |= ((uint64) tv.tv_usec) << 12;
4950 sysidentifier |= getpid() & 0xFFF;
4953 buffer = (
char *)
palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
4955 memset(page, 0, XLOG_BLCKSZ);
5012 *(recptr++) =
sizeof(checkPoint);
5013 memcpy(recptr, &checkPoint,
sizeof(checkPoint));
5014 recptr +=
sizeof(checkPoint);
5042 errmsg(
"could not write bootstrap write-ahead log file: %m")));
5050 errmsg(
"could not fsync bootstrap write-ahead log file: %m")));
5056 errmsg(
"could not close bootstrap write-ahead log file: %m")));
5087 static char buf[128];
5090 "%Y-%m-%d %H:%M:%S %Z",
5107 Assert(endTLI != newTLI);
5129 if (endLogSegNo == startLogSegNo)
5153 int save_errno = errno;
5159 errmsg(
"could not close file \"%s\": %m", xlogfname)));
5183 "recovery_end_command",
5185 WAIT_EVENT_RECOVERY_END_COMMAND);
5273 (
errmsg(
"WAL was generated with wal_level=minimal, cannot continue recovering"),
5274 errdetail(
"This happens if you temporarily set wal_level=minimal on the server."),
5275 errhint(
"Use a backup taken after setting wal_level to higher than minimal.")));
5314 bool haveBackupLabel;
5318 bool performedWalRecovery;
5323 bool promoted =
false;
5339 (
errmsg(
"control file contains invalid checkpoint location")));
5350 (
errmsg(
"database system was shut down at %s",
5356 (
errmsg(
"database system was shut down in recovery at %s",
5362 (
errmsg(
"database system shutdown was interrupted; last known up at %s",
5368 (
errmsg(
"database system was interrupted while in recovery at %s",
5370 errhint(
"This probably means that some data is corrupted and"
5371 " you will have to use the last backup for recovery.")));
5376 (
errmsg(
"database system was interrupted while in recovery at log time %s",
5378 errhint(
"If this has occurred more than once some data might be corrupted"
5379 " and you might need to choose an earlier recovery target.")));
5384 (
errmsg(
"database system was interrupted; last known up at %s",
5390 (
errmsg(
"control file contains invalid database cluster state")));
5394 #ifdef XLOG_REPLAY_DELAY
5444 &haveBackupLabel, &haveTblspcMap);
5597 if (haveBackupLabel)
5703 running.
xcnt = nxids;
5712 running.
xids = xids;
5724 performedWalRecovery =
true;
5727 performedWalRecovery =
false;
5733 EndOfLog = endOfRecoveryInfo->
endOfLog;
5776 (
errmsg(
"WAL ends before end of online backup"),
5777 errhint(
"All WAL generated while online backup was taken must be available at recovery.")));
5780 (
errmsg(
"WAL ends before consistent recovery point")));
5826 (
errmsg(
"selected new timeline ID: %u", newTLI)));
5859 (
errmsg(
"archive recovery complete")));
5900 if (EndOfLog % XLOG_BLCKSZ != 0)
5913 memset(page +
len, 0, XLOG_BLCKSZ -
len);
5999 if (performedWalRecovery)
6153 bool promoted =
false;
6295 return oldXLogAllowed;
6424 if (
res < last_important)
6425 res = last_important;
6465 (
errmsg(
"shutting down")));
6504 (
errmsg(
"restartpoint starting:%s%s%s%s%s%s%s%s",
6516 (
errmsg(
"checkpoint starting:%s%s%s%s%s%s%s%s",
6538 uint64 average_sync_time;
6568 average_sync_time = 0;
6572 average_msecs = (long) ((average_sync_time + 999) / 1000);
6581 (
errmsg(
"restartpoint complete: wrote %d buffers (%.1f%%); "
6582 "%d WAL file(s) added, %d removed, %d recycled; "
6583 "write=%ld.%03d s, sync=%ld.%03d s, total=%ld.%03d s; "
6584 "sync files=%d, longest=%ld.%03d s, average=%ld.%03d s; "
6585 "distance=%d kB, estimate=%d kB; "
6586 "lsn=%X/%X, redo lsn=%X/%X",
6592 write_msecs / 1000, (
int) (write_msecs % 1000),
6593 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6594 total_msecs / 1000, (
int) (total_msecs % 1000),
6596 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6597 average_msecs / 1000, (
int) (average_msecs % 1000),
6604 (
errmsg(
"checkpoint complete: wrote %d buffers (%.1f%%); "
6605 "%d WAL file(s) added, %d removed, %d recycled; "
6606 "write=%ld.%03d s, sync=%ld.%03d s, total=%ld.%03d s; "
6607 "sync files=%d, longest=%ld.%03d s, average=%ld.%03d s; "
6608 "distance=%d kB, estimate=%d kB; "
6609 "lsn=%X/%X, redo lsn=%X/%X",
6615 write_msecs / 1000, (
int) (write_msecs % 1000),
6616 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6617 total_msecs / 1000, (
int) (total_msecs % 1000),
6619 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6620 average_msecs / 1000, (
int) (average_msecs % 1000),
6688 char activitymsg[128];
6690 snprintf(activitymsg,
sizeof(activitymsg),
"performing %s%s%s",
6693 restartpoint ?
"restartpoint" :
"checkpoint");
6746 int oldXLogAllowed = 0;
6759 elog(
ERROR,
"can't create a checkpoint during recovery");
6793 MemSet(&checkPoint, 0,
sizeof(checkPoint));
6868 checkPoint.
redo = curInsert;
6933 TRACE_POSTGRESQL_CHECKPOINT_START(flags);
7078 (
errmsg(
"concurrent write-ahead log activity while database system is shutting down")));
7217 elog(
ERROR,
"can only be used to end recovery");
7284 elog(
ERROR,
"can only be used at end of recovery");
7285 if (pagePtr % XLOG_BLCKSZ != 0)
7286 elog(
ERROR,
"invalid position for missing continuation record %X/%X",
7296 if (recptr != startPos)
7297 elog(
ERROR,
"invalid WAL insert position %X/%X for OVERWRITE_CONTRECORD",
7327 elog(
ERROR,
"OVERWRITE_CONTRECORD was inserted to unexpected position %X/%X",
7353 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_START(flags);
7363 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_SYNC_START();
7367 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_DONE();
7396 "could not record restart point at %X/%X because there "
7397 "are unresolved references to invalid pages",
7455 (
errmsg_internal(
"skipping restartpoint, recovery has already ended")));
7606 endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
7662 (
errmsg(
"recovery restart point at %X/%X",
7664 xtime ?
errdetail(
"Last completed transaction was at log time %s.",
7672 "archive_cleanup_command",
7674 WAIT_EVENT_ARCHIVE_CLEANUP_COMMAND);
7739 if (currSeg > keepSegs)
7740 oldestSegMaxWalSize = currSeg - keepSegs;
7742 oldestSegMaxWalSize = 1;
7751 if (targetSeg >= oldestSlotSeg)
7754 if (targetSeg >= oldestSegMaxWalSize)
7762 if (targetSeg >= oldestSeg)
7808 uint64 slot_keep_segs;
7813 if (currSegNo - segno > slot_keep_segs)
7814 segno = currSegNo - slot_keep_segs;
7828 if (unsummarized_segno < segno)
7829 segno = unsummarized_segno;
7838 if (currSegNo - segno < keep_segs)
7841 if (currSegNo <= keep_segs)
7844 segno = currSegNo - keep_segs;
7849 if (segno < *logSegNo)
7901 if (mark_unimportant)
7926 (
errmsg(
"restore point \"%s\" created at %X/%X",
8003 bool recoveryInProgress;
8034 Insert->fullPageWrites =
true;
8053 Insert->fullPageWrites =
false;
8133 (
errmsg(
"online backup was canceled, recovery cannot continue")));
8157 running.
xcnt = nxids;
8166 running.
xids = xids;
8190 (
errmsg(
"unexpected timeline ID %u (should be %u) in shutdown checkpoint record",
8248 (
errmsg(
"unexpected timeline ID %u (should be %u) in online checkpoint record",
8277 (
errmsg(
"unexpected timeline ID %u (should be %u) in end-of-recovery record",
8317 elog(
ERROR,
"XLOG_FPI record did not contain a full-page image");
8322 elog(
ERROR,
"unexpected XLogReadBufferForRedo result when restoring backup block");
8428 int o_direct_flag = 0;
8441 return o_direct_flag;
8454 return o_direct_flag;
8457 return O_SYNC | o_direct_flag;
8461 return O_DSYNC | o_direct_flag;
8465 elog(
ERROR,
"unrecognized wal_sync_method: %d", method);
8498 errmsg(
"could not fsync file \"%s\": %m", xlogfname)));
8543 msg =
_(
"could not fsync file \"%s\": %m");
8545 #ifdef HAVE_FSYNC_WRITETHROUGH
8548 msg =
_(
"could not fsync write-through file \"%s\": %m");
8553 msg =
_(
"could not fdatasync file \"%s\": %m");
8569 int save_errno = errno;
8575 errmsg(msg, xlogfname)));
8637 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8638 errmsg(
"WAL level not sufficient for making an online backup"),
8639 errhint(
"wal_level must be set to \"replica\" or \"logical\" at server start.")));
8643 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8644 errmsg(
"backup label too long (max %d bytes)",
8647 memcpy(
state->name, backupidstr, strlen(backupidstr));
8681 bool gotUniqueStartpoint =
false;
8762 if (!checkpointfpw ||
state->startpoint <= recptr)
8764 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8765 errmsg(
"WAL generated with full_page_writes=off was replayed "
8766 "since last restartpoint"),
8767 errhint(
"This means that the backup being taken on the standby "
8768 "is corrupt and should not be used. "
8769 "Enable full_page_writes and run CHECKPOINT on the primary, "
8770 "and then try an online backup again.")));
8779 gotUniqueStartpoint =
true;
8797 gotUniqueStartpoint =
true;
8800 }
while (!gotUniqueStartpoint);
8805 datadirpathlen = strlen(
DataDir);
8809 while ((de =
ReadDir(tblspcdir,
"pg_tblspc")) != NULL)
8830 tsoid = strtoul(de->
d_name, &badp, 10);
8831 if (*badp !=
'\0' || errno == EINVAL || errno == ERANGE)
8834 snprintf(fullpath,
sizeof(fullpath),
"pg_tblspc/%s", de->
d_name);
8843 rllen =
readlink(fullpath, linkpath,
sizeof(linkpath));
8847 (
errmsg(
"could not read symbolic link \"%s\": %m",
8851 else if (rllen >=
sizeof(linkpath))
8854 (
errmsg(
"symbolic link \"%s\" target is too long",
8858 linkpath[rllen] =
'\0';
8865 if (rllen > datadirpathlen &&
8866 strncmp(linkpath,
DataDir, datadirpathlen) == 0 &&
8875 for (s = linkpath; *s; s++)
8877 if (*s ==
'\n' || *s ==
'\r' || *s ==
'\\')
8895 snprintf(linkpath,
sizeof(linkpath),
"pg_tblspc/%s",
8912 *tablespaces =
lappend(*tablespaces, ti);
8953 bool backup_stopped_in_recovery =
false;
8959 int seconds_before_warning;
8961 bool reported_waiting =
false;
8973 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8974 errmsg(
"WAL level not sufficient for making an online backup"),
8975 errhint(
"wal_level must be set to \"replica\" or \"logical\" at server start.")));
9010 if (
state->started_in_recovery && !backup_stopped_in_recovery)
9012 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9013 errmsg(
"the standby was promoted during online backup"),
9014 errhint(
"This means that the backup being taken is corrupt "
9015 "and should not be used. "
9016 "Try taking another online backup.")));
9046 if (backup_stopped_in_recovery)
9058 if (
state->startpoint <= recptr)
9060 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9061 errmsg(
"WAL generated with full_page_writes=off was replayed "
9062 "during online backup"),
9063 errhint(
"This means that the backup being taken on the standby "
9064 "is corrupt and should not be used. "
9065 "Enable full_page_writes and run CHECKPOINT on the primary, "
9066 "and then try an online backup again.")));
9083 sizeof(
state->startpoint));
9110 errmsg(
"could not create file \"%s\": %m",
9115 fprintf(fp,
"%s", history_file);
9116 pfree(history_file);
9121 errmsg(
"could not write file \"%s\": %m",
9154 if (waitforarchive &&
9166 seconds_before_warning = 60;
9174 if (!reported_waiting && waits > 5)
9177 (
errmsg(
"base backup done, waiting for required WAL segments to be archived")));
9178 reported_waiting =
true;
9184 WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
9187 if (++waits >= seconds_before_warning)
9189 seconds_before_warning *= 2;
9191 (
errmsg(
"still waiting for all required WAL segments to be archived (%d seconds elapsed)",
9193 errhint(
"Check that your archive_command is executing properly. "
9194 "You can safely cancel this backup, "
9195 "but the database backup will not be usable without all the WAL segments.")));
9200 (
errmsg(
"all required WAL segments have been archived")));
9202 else if (waitforarchive)
9204 (
errmsg(
"WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
9241 if (!during_backup_start)
9243 errmsg(
"aborting backup due to backend exiting before pg_backup_stop was called"));
9254 static bool already_done =
false;
9259 already_done =
true;
9269 uint64 current_bytepos;
9272 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_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 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)
Assert(fmt[strlen(fmt) - 1] !='\n')
List * lappend(List *list, void *datum)
void list_free(List *list)
void LWLockUpdateVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
void LWLockReleaseClearVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
bool LWLockWaitForVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval)
void LWLockRelease(LWLock *lock)
void LWLockInitialize(LWLock *lock, int tranche_id)
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
bool LWLockAcquireOrWait(LWLock *lock, LWLockMode mode)
char * pstrdup(const char *in)
void pfree(void *pointer)
MemoryContext TopMemoryContext
void MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
#define AllocSetContextCreate
#define ALLOCSET_DEFAULT_SIZES
#define IsBootstrapProcessingMode()
#define START_CRIT_SECTION()
#define CHECK_FOR_INTERRUPTS()
#define END_CRIT_SECTION()
#define AmWalReceiverProcess()
bool process_shared_preload_libraries_done
BackendType MyBackendType
void MultiXactSetNextMXact(MultiXactId nextMulti, MultiXactOffset nextMultiOffset)
void MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB)
void MultiXactGetCheckptMulti(bool is_shutdown, MultiXactId *nextMulti, MultiXactOffset *nextMultiOffset, MultiXactId *oldestMulti, Oid *oldestMultiDB)
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)
void CheckPointMultiXact(void)
void MultiXactAdvanceNextMXact(MultiXactId minMulti, MultiXactOffset minMultiOffset)
void BootStrapMultiXact(void)
void StartupMultiXact(void)
void StartupReplicationOrigin(void)
void CheckPointReplicationOrigin(void)
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
#define ERRCODE_DATA_CORRUPTED
#define DEFAULT_XLOG_SEG_SIZE
#define PG_CACHE_LINE_SIZE
#define FLOATFORMAT_VALUE
#define XLOG_RESTORE_POINT
#define XLOG_CHECKPOINT_REDO
#define PG_CONTROL_VERSION
#define XLOG_OVERWRITE_CONTRECORD
#define XLOG_FPI_FOR_HINT
#define MOCK_AUTH_NONCE_LEN
@ DB_SHUTDOWNED_IN_RECOVERY
#define XLOG_CHECKPOINT_SHUTDOWN
#define PG_CONTROL_FILE_SIZE
#define XLOG_PARAMETER_CHANGE
#define XLOG_CHECKPOINT_ONLINE
#define XLOG_END_OF_RECOVERY
#define COMP_CRC32C(crc, data, len)
#define EQ_CRC32C(c1, c2)
static rewind_source * source
void pgstat_restore_stats(void)
void pgstat_discard_stats(void)
PgStat_CheckpointerStats PendingCheckpointerStats
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)
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
XLogwrtResult LogwrtResult
XLogRecPtr lastSegSwitchLSN
XLogSegNo lastRemovedSegNo
pg_atomic_uint64 * xlblocks
XLogRecPtr lastCheckPointRecPtr
XLogRecPtr lastFpwDisableRecPtr
bool InstallXLogFileSegmentActive
XLogRecPtr lastCheckPointEndPtr
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)
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