109 #define BootstrapTimeLineID 1
138 bool XLOG_DEBUG =
false;
148 #define NUM_XLOGINSERT_LOCKS 8
171 #ifdef HAVE_FSYNC_WRITETHROUGH
578 #define INSERT_FREESPACE(endptr) \
579 (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))
582 #define NextBufIdx(idx) \
583 (((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
589 #define XLogRecPtrToBufIdx(recptr) \
590 (((recptr) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
595 #define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)
601 #define ConvertToXSegs(x, segsize) XLogMBVarToSegs((x), (segsize))
618 #define RefreshXLogWriteResult(_target) \
620 _target.Flush = pg_atomic_read_u64(&XLogCtl->logFlushResult); \
622 _target.Write = pg_atomic_read_u64(&XLogCtl->logWriteResult); \
750 bool topxid_included)
777 elog(
ERROR,
"cannot make new WAL entries during recovery");
847 (!prevDoPageWrites ||
911 rdata_crc = rechdr->
xl_crc;
914 rechdr->
xl_crc = rdata_crc;
922 StartPos, EndPos, insertTLI);
964 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
981 TRACE_POSTGRESQL_WAL_SWITCH();
992 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
996 if (offset == EndPos % XLOG_BLCKSZ)
1012 char *errormsg = NULL;
1026 for (; rdata != NULL; rdata = rdata->
next)
1037 .segment_open = NULL,
1038 .segment_close = NULL),
1051 errormsg ? errormsg :
"no error message");
1057 debug_reader->
record = decoded;
1059 debug_reader->
record = NULL;
1110 uint64 startbytepos;
1131 startbytepos =
Insert->CurrBytePos;
1132 endbytepos = startbytepos +
size;
1133 prevbytepos =
Insert->PrevBytePos;
1134 Insert->CurrBytePos = endbytepos;
1135 Insert->PrevBytePos = startbytepos;
1165 uint64 startbytepos;
1180 startbytepos =
Insert->CurrBytePos;
1186 *EndPos = *StartPos = ptr;
1190 endbytepos = startbytepos +
size;
1191 prevbytepos =
Insert->PrevBytePos;
1203 Insert->CurrBytePos = endbytepos;
1204 Insert->PrevBytePos = startbytepos;
1248 while (rdata != NULL)
1250 char *rdata_data = rdata->
data;
1251 int rdata_len = rdata->
len;
1253 while (rdata_len > freespace)
1259 memcpy(currpos, rdata_data, freespace);
1260 rdata_data += freespace;
1261 rdata_len -= freespace;
1262 written += freespace;
1263 CurrPos += freespace;
1294 memcpy(currpos, rdata_data, rdata_len);
1295 currpos += rdata_len;
1296 CurrPos += rdata_len;
1297 freespace -= rdata_len;
1298 written += rdata_len;
1300 rdata = rdata->
next;
1302 Assert(written == write_len);
1318 CurrPos += freespace;
1326 while (CurrPos < EndPos)
1350 CurrPos += XLOG_BLCKSZ;
1359 if (CurrPos != EndPos)
1362 errmsg_internal(
"space reserved for WAL record does not match what was written"));
1384 static int lockToTry = -1;
1386 if (lockToTry == -1)
1512 elog(
PANIC,
"cannot wait without a PGPROC structure");
1519 if (upto <= inserted)
1524 bytepos =
Insert->CurrBytePos;
1536 if (upto > reservedUpto)
1539 (
errmsg(
"request to flush past end of generated WAL; request %X/%X, current position %X/%X",
1541 upto = reservedUpto;
1553 finishedUpto = reservedUpto;
1585 insertingat, &insertingat))
1596 }
while (insertingat < upto);
1599 finishedUpto = insertingat;
1610 return finishedUpto;
1634 static uint64 cachedPage = 0;
1635 static char *cachedPos = NULL;
1642 if (ptr / XLOG_BLCKSZ == cachedPage)
1646 return cachedPos + ptr % XLOG_BLCKSZ;
1669 expectedEndPtr = ptr;
1670 expectedEndPtr += XLOG_BLCKSZ - ptr % XLOG_BLCKSZ;
1673 if (expectedEndPtr != endptr)
1698 initializedUpto = ptr;
1705 if (expectedEndPtr != endptr)
1706 elog(
PANIC,
"could not find WAL buffer for %X/%X",
1722 cachedPage = ptr / XLOG_BLCKSZ;
1728 return cachedPos + ptr % XLOG_BLCKSZ;
1749 char *pdst = dstbuf;
1752 Size nbytes = count;
1764 if (startptr + count > inserted)
1766 errmsg(
"cannot read past end of generated WAL: requested %X/%X, current position %X/%X",
1786 uint32 offset = recptr % XLOG_BLCKSZ;
1798 expectedEndPtr = recptr + (XLOG_BLCKSZ - offset);
1805 if (expectedEndPtr != endptr)
1814 psrc = page + offset;
1815 npagebytes =
Min(nbytes, XLOG_BLCKSZ - offset);
1824 memcpy(pdst, psrc, npagebytes);
1837 if (expectedEndPtr != endptr)
1841 recptr += npagebytes;
1842 nbytes -= npagebytes;
1845 Assert(pdst - dstbuf <= count);
1847 return pdst - dstbuf;
1875 seg_offset = XLOG_BLCKSZ;
1918 seg_offset = XLOG_BLCKSZ;
1925 seg_offset += fullpages * XLOG_BLCKSZ + bytesleft;
1949 offset = ptr % XLOG_BLCKSZ;
2053 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
2054 WriteRqst.
Write = OldPageRqstPtr;
2055 WriteRqst.
Flush = 0;
2059 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
2072 NewPageEndPtr = NewPageBeginPtr + XLOG_BLCKSZ;
2090 MemSet((
char *) NewPage, 0, XLOG_BLCKSZ);
2098 NewPage->xlp_tli = tli;
2099 NewPage->xlp_pageaddr = NewPageBeginPtr;
2116 if (
Insert->runningBackups == 0)
2147 if (XLOG_DEBUG && npages > 0)
2149 elog(
DEBUG1,
"initialized %d pages, up to %X/%X",
2207 GUC_check_errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.");
2226 "max_slot_wal_keep_size");
2267 recycleSegNo = (
XLogSegNo) ceil(((
double) lastredoptr + distance) /
2270 if (recycleSegNo < minSegNo)
2271 recycleSegNo = minSegNo;
2272 if (recycleSegNo > maxSegNo)
2273 recycleSegNo = maxSegNo;
2275 return recycleSegNo;
2315 bool last_iteration;
2360 elog(
PANIC,
"xlog write request %X/%X is past end of log %X/%X",
2415 finishing_seg = !ispartialpage &&
2418 if (last_iteration ||
2430 nbytes = npages * (
Size) XLOG_BLCKSZ;
2474 errmsg(
"could not write to log file \"%s\" at offset %u, length %zu: %m",
2475 xlogfname, startoffset, nleft)));
2479 startoffset += written;
2480 }
while (nleft > 0);
2537 if (flexible && npages == 0)
2602 #ifdef USE_ASSERT_CHECKING
2647 if (asyncXactLSN <= prevAsyncXactLSN)
2764 if (!force && newMinRecoveryPoint < lsn)
2766 "xlog min recovery request %X/%X is past current point %X/%X",
2779 (
errmsg_internal(
"updated min recovery point to %X/%X on timeline %u",
2781 newMinRecoveryPointTLI)));
2819 elog(
LOG,
"xlog flush request %X/%X; write %X/%X; flush %X/%X",
2836 WriteRqstPtr = record;
2856 if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write)
2914 WriteRqst.
Write = insertpos;
2915 WriteRqst.
Flush = insertpos;
2952 "xlog flush request %X/%X is not satisfied --- flushed only to %X/%X",
2985 bool flexible =
true;
3007 WriteRqst.
Write -= WriteRqst.
Write % XLOG_BLCKSZ;
3074 WriteRqst.
Flush = 0;
3079 elog(
LOG,
"xlog bg flush request write %X/%X; flush: %X/%X, current is write %X/%X; flush %X/%X",
3095 XLogWrite(WriteRqst, insertTLI, flexible);
3203 bool *added,
char *path)
3210 int open_flags = O_RDWR | O_CREAT | O_EXCL |
PG_BINARY;
3224 if (errno != ENOENT)
3227 errmsg(
"could not open file \"%s\": %m", path)));
3238 elog(
DEBUG2,
"creating and filling new WAL file");
3252 errmsg(
"could not create file \"%s\": %m", tmppath)));
3284 save_errno = errno ? errno : ENOSPC;
3302 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3313 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3320 errmsg(
"could not close file \"%s\": %m", tmppath)));
3327 installed_segno = logsegno;
3343 elog(
DEBUG2,
"done creating and filling new WAL file");
3390 errmsg(
"could not open file \"%s\": %m", path)));
3429 errmsg(
"could not open file \"%s\": %m", path)));
3443 errmsg(
"could not create file \"%s\": %m", tmppath)));
3452 nread = upto - nbytes;
3458 if (nread <
sizeof(buffer))
3459 memset(buffer.
data, 0,
sizeof(buffer));
3465 if (nread >
sizeof(buffer))
3466 nread =
sizeof(buffer);
3468 r =
read(srcfd, buffer.
data, nread);
3474 errmsg(
"could not read file \"%s\": %m",
3479 errmsg(
"could not read file \"%s\": read %d of %zu",
3480 path, r, (
Size) nread)));
3486 if ((
int)
write(
fd, buffer.
data,
sizeof(buffer)) != (
int)
sizeof(buffer))
3488 int save_errno = errno;
3495 errno = save_errno ? save_errno : ENOSPC;
3499 errmsg(
"could not write to file \"%s\": %m", tmppath)));
3508 errmsg(
"could not fsync file \"%s\": %m", tmppath)));
3514 errmsg(
"could not close file \"%s\": %m", tmppath)));
3519 errmsg(
"could not close file \"%s\": %m", path)));
3525 elog(
ERROR,
"InstallXLogFileSegment should not have failed");
3559 struct stat stat_buf;
3580 while (
stat(path, &stat_buf) == 0)
3582 if ((*segno) >= max_segno)
3622 errmsg(
"could not open file \"%s\": %m", path)));
3641 #if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
3643 (void) posix_fadvise(
openLogFile, 0, 0, POSIX_FADV_DONTNEED);
3649 int save_errno = errno;
3655 errmsg(
"could not close file \"%s\": %m", xlogfname)));
3721 int save_errno = errno;
3728 if (segno <= lastRemovedSegNo)
3736 errmsg(
"requested WAL segment %s has already been removed",
3758 return lastRemovedSegNo;
3787 if (tli != file_tli)
3791 if (oldest_segno == 0 || file_segno < oldest_segno)
3792 oldest_segno = file_segno;
3796 return oldest_segno;
3829 elog(
DEBUG2,
"removing all temporary WAL segments");
3836 if (strncmp(xlde->
d_name,
"xlogtemp.", 9) != 0)
3841 elog(
DEBUG2,
"removed temporary WAL segment \"%s\"", path);
3877 elog(
DEBUG2,
"attempting to remove WAL segments older than log file %s",
3900 if (strcmp(xlde->
d_name + 8, lastoff + 8) <= 0)
3947 recycleSegNo = endLogSegNo + 10;
3954 elog(
DEBUG2,
"attempting to remove WAL segments newer than log file %s",
3970 if (strncmp(xlde->
d_name, switchseg, 8) < 0 &&
3971 strcmp(xlde->
d_name + 8, switchseg + 8) > 0)
4009 const char *segname = segment_de->
d_name;
4019 *endlogSegNo <= recycleSegNo &&
4023 true, recycleSegNo, insertTLI))
4054 if (rename(path, newpath) != 0)
4058 errmsg(
"could not rename file \"%s\": %m",
4094 struct stat stat_buf;
4101 errmsg(
"required WAL directory \"%s\" does not exist",
4106 if (
stat(path, &stat_buf) == 0)
4112 errmsg(
"required WAL directory \"%s\" does not exist",
4118 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4122 errmsg(
"could not create missing directory \"%s\": %m",
4128 if (
stat(path, &stat_buf) == 0)
4133 (
errmsg(
"required WAL directory \"%s\" does not exist",
4139 (
errmsg(
"creating missing WAL directory \"%s\"", path)));
4142 (
errmsg(
"could not create missing directory \"%s\": %m",
4167 elog(
DEBUG2,
"removing WAL backup history file \"%s\"",
4208 (
errcode(ERRCODE_INTERNAL_ERROR),
4209 errmsg(
"could not generate secret authorization token")));
4280 errmsg(
"could not create file \"%s\": %m",
4292 errmsg(
"could not write to file \"%s\": %m",
4301 errmsg(
"could not fsync file \"%s\": %m",
4308 errmsg(
"could not close file \"%s\": %m",
4317 static char wal_segsz_str[20];
4328 errmsg(
"could not open file \"%s\": %m",
4338 errmsg(
"could not read file \"%s\": %m",
4343 errmsg(
"could not read file \"%s\": read %d of %zu",
4359 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4360 errmsg(
"database files are incompatible with server"),
4361 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x),"
4362 " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
4365 errhint(
"This could be a problem of mismatched byte ordering. It looks like you need to initdb.")));
4369 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4370 errmsg(
"database files are incompatible with server"),
4371 errdetail(
"The database cluster was initialized with PG_CONTROL_VERSION %d,"
4372 " but the server was compiled with PG_CONTROL_VERSION %d.",
4374 errhint(
"It looks like you need to initdb.")));
4385 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4386 errmsg(
"incorrect checksum in control file")));
4395 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4396 errmsg(
"database files are incompatible with server"),
4397 errdetail(
"The database cluster was initialized with CATALOG_VERSION_NO %d,"
4398 " but the server was compiled with CATALOG_VERSION_NO %d.",
4400 errhint(
"It looks like you need to initdb.")));
4403 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4404 errmsg(
"database files are incompatible with server"),
4405 errdetail(
"The database cluster was initialized with MAXALIGN %d,"
4406 " but the server was compiled with MAXALIGN %d.",
4408 errhint(
"It looks like you need to initdb.")));
4411 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4412 errmsg(
"database files are incompatible with server"),
4413 errdetail(
"The database cluster appears to use a different floating-point number format than the server executable."),
4414 errhint(
"It looks like you need to initdb.")));
4417 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4418 errmsg(
"database files are incompatible with server"),
4419 errdetail(
"The database cluster was initialized with BLCKSZ %d,"
4420 " but the server was compiled with BLCKSZ %d.",
4422 errhint(
"It looks like you need to recompile or initdb.")));
4425 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4426 errmsg(
"database files are incompatible with server"),
4427 errdetail(
"The database cluster was initialized with RELSEG_SIZE %d,"
4428 " but the server was compiled with RELSEG_SIZE %d.",
4430 errhint(
"It looks like you need to recompile or initdb.")));
4433 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4434 errmsg(
"database files are incompatible with server"),
4435 errdetail(
"The database cluster was initialized with XLOG_BLCKSZ %d,"
4436 " but the server was compiled with XLOG_BLCKSZ %d.",
4438 errhint(
"It looks like you need to recompile or initdb.")));
4441 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4442 errmsg(
"database files are incompatible with server"),
4443 errdetail(
"The database cluster was initialized with NAMEDATALEN %d,"
4444 " but the server was compiled with NAMEDATALEN %d.",
4446 errhint(
"It looks like you need to recompile or initdb.")));
4449 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4450 errmsg(
"database files are incompatible with server"),
4451 errdetail(
"The database cluster was initialized with INDEX_MAX_KEYS %d,"
4452 " but the server was compiled with INDEX_MAX_KEYS %d.",
4454 errhint(
"It looks like you need to recompile or initdb.")));
4457 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4458 errmsg(
"database files are incompatible with server"),
4459 errdetail(
"The database cluster was initialized with TOAST_MAX_CHUNK_SIZE %d,"
4460 " but the server was compiled with TOAST_MAX_CHUNK_SIZE %d.",
4462 errhint(
"It looks like you need to recompile or initdb.")));
4465 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4466 errmsg(
"database files are incompatible with server"),
4467 errdetail(
"The database cluster was initialized with LOBLKSIZE %d,"
4468 " but the server was compiled with LOBLKSIZE %d.",
4470 errhint(
"It looks like you need to recompile or initdb.")));
4472 #ifdef USE_FLOAT8_BYVAL
4475 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4476 errmsg(
"database files are incompatible with server"),
4477 errdetail(
"The database cluster was initialized without USE_FLOAT8_BYVAL"
4478 " but the server was compiled with USE_FLOAT8_BYVAL."),
4479 errhint(
"It looks like you need to recompile or initdb.")));
4483 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4484 errmsg(
"database files are incompatible with server"),
4485 errdetail(
"The database cluster was initialized with USE_FLOAT8_BYVAL"
4486 " but the server was compiled without USE_FLOAT8_BYVAL."),
4487 errhint(
"It looks like you need to recompile or initdb.")));
4494 errmsg_plural(
"invalid WAL segment size in control file (%d byte)",
4495 "invalid WAL segment size in control file (%d bytes)",
4498 errdetail(
"The WAL segment size must be a power of two between 1 MB and 1 GB.")));
4507 errmsg(
"\"min_wal_size\" must be at least twice \"wal_segment_size\"")));
4511 errmsg(
"\"max_wal_size\" must be at least twice \"wal_segment_size\"")));
4665 foreach(l, elemlist)
4667 char *tok = (
char *)
lfirst(l);
4673 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4675 newwalconsistency[rmid] =
true;
4682 for (rmid = 0; rmid <=
RM_MAX_ID; rmid++)
4687 newwalconsistency[rmid] =
true;
4719 memcpy(*extra, newwalconsistency, (
RM_MAX_ID + 1) *
sizeof(
bool));
4785 return "(disabled)";
4903 if (walDebugCxt == NULL)
4920 if (foundCFile || foundXLog)
4923 Assert(foundCFile && foundXLog);
4928 if (localControlFile)
4929 pfree(localControlFile);
4938 if (localControlFile)
4941 pfree(localControlFile);
4977 allocptr = (
char *)
TYPEALIGN(XLOG_BLCKSZ, allocptr);
5011 uint64 sysidentifier;
5031 sysidentifier = ((uint64) tv.tv_sec) << 32;
5032 sysidentifier |= ((uint64) tv.tv_usec) << 12;
5033 sysidentifier |= getpid() & 0xFFF;
5036 buffer = (
char *)
palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
5038 memset(page, 0, XLOG_BLCKSZ);
5096 *(recptr++) =
sizeof(checkPoint);
5097 memcpy(recptr, &checkPoint,
sizeof(checkPoint));
5098 recptr +=
sizeof(checkPoint);
5126 errmsg(
"could not write bootstrap write-ahead log file: %m")));
5134 errmsg(
"could not fsync bootstrap write-ahead log file: %m")));
5140 errmsg(
"could not close bootstrap write-ahead log file: %m")));
5171 static char buf[128];
5174 "%Y-%m-%d %H:%M:%S %Z",
5191 Assert(endTLI != newTLI);
5213 if (endLogSegNo == startLogSegNo)
5237 int save_errno = errno;
5243 errmsg(
"could not close file \"%s\": %m", xlogfname)));
5267 "recovery_end_command",
5269 WAIT_EVENT_RECOVERY_END_COMMAND);
5364 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5365 errmsg(
"WAL was generated with \"wal_level=minimal\", cannot continue recovering"),
5366 errdetail(
"This happens if you temporarily set \"wal_level=minimal\" on the server."),
5367 errhint(
"Use a backup taken after setting \"wal_level\" to higher than \"minimal\".")));
5406 bool haveBackupLabel;
5410 bool performedWalRecovery;
5415 bool promoted =
false;
5432 errmsg(
"control file contains invalid checkpoint location")));
5443 (
errmsg(
"database system was shut down at %s",
5449 (
errmsg(
"database system was shut down in recovery at %s",
5455 (
errmsg(
"database system shutdown was interrupted; last known up at %s",
5461 (
errmsg(
"database system was interrupted while in recovery at %s",
5463 errhint(
"This probably means that some data is corrupted and"
5464 " you will have to use the last backup for recovery.")));
5469 (
errmsg(
"database system was interrupted while in recovery at log time %s",
5471 errhint(
"If this has occurred more than once some data might be corrupted"
5472 " and you might need to choose an earlier recovery target.")));
5477 (
errmsg(
"database system was interrupted; last known up at %s",
5484 errmsg(
"control file contains invalid database cluster state")));
5488 #ifdef XLOG_REPLAY_DELAY
5538 &haveBackupLabel, &haveTblspcMap);
5691 if (haveBackupLabel)
5800 running.
xcnt = nxids;
5809 running.
xids = xids;
5819 performedWalRecovery =
true;
5822 performedWalRecovery =
false;
5828 EndOfLog = endOfRecoveryInfo->
endOfLog;
5871 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5872 errmsg(
"WAL ends before end of online backup"),
5873 errhint(
"All WAL generated while online backup was taken must be available at recovery.")));
5876 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5877 errmsg(
"WAL ends before consistent recovery point")));
5923 (
errmsg(
"selected new timeline ID: %u", newTLI)));
5956 (
errmsg(
"archive recovery complete")));
5999 if (EndOfLog % XLOG_BLCKSZ != 0)
6012 memset(page +
len, 0, XLOG_BLCKSZ -
len);
6102 if (performedWalRecovery)
6256 bool promoted =
false;
6398 return oldXLogAllowed;
6544 if (
res < last_important)
6545 res = last_important;
6585 (
errmsg(
"shutting down")));
6624 (
errmsg(
"restartpoint starting:%s%s%s%s%s%s%s%s",
6636 (
errmsg(
"checkpoint starting:%s%s%s%s%s%s%s%s",
6658 uint64 average_sync_time;
6688 average_sync_time = 0;
6692 average_msecs = (long) ((average_sync_time + 999) / 1000);
6701 (
errmsg(
"restartpoint complete: wrote %d buffers (%.1f%%); "
6702 "%d WAL file(s) added, %d removed, %d recycled; "
6703 "write=%ld.%03d s, sync=%ld.%03d s, total=%ld.%03d s; "
6704 "sync files=%d, longest=%ld.%03d s, average=%ld.%03d s; "
6705 "distance=%d kB, estimate=%d kB; "
6706 "lsn=%X/%X, redo lsn=%X/%X",
6712 write_msecs / 1000, (
int) (write_msecs % 1000),
6713 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6714 total_msecs / 1000, (
int) (total_msecs % 1000),
6716 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6717 average_msecs / 1000, (
int) (average_msecs % 1000),
6724 (
errmsg(
"checkpoint complete: wrote %d buffers (%.1f%%); "
6725 "%d WAL file(s) added, %d removed, %d recycled; "
6726 "write=%ld.%03d s, sync=%ld.%03d s, total=%ld.%03d s; "
6727 "sync files=%d, longest=%ld.%03d s, average=%ld.%03d s; "
6728 "distance=%d kB, estimate=%d kB; "
6729 "lsn=%X/%X, redo lsn=%X/%X",
6735 write_msecs / 1000, (
int) (write_msecs % 1000),
6736 sync_msecs / 1000, (
int) (sync_msecs % 1000),
6737 total_msecs / 1000, (
int) (total_msecs % 1000),
6739 longest_msecs / 1000, (
int) (longest_msecs % 1000),
6740 average_msecs / 1000, (
int) (average_msecs % 1000),
6808 char activitymsg[128];
6810 snprintf(activitymsg,
sizeof(activitymsg),
"performing %s%s%s",
6813 restartpoint ?
"restartpoint" :
"checkpoint");
6866 int oldXLogAllowed = 0;
6879 elog(
ERROR,
"can't create a checkpoint during recovery");
6913 MemSet(&checkPoint, 0,
sizeof(checkPoint));
6989 checkPoint.
redo = curInsert;
7052 TRACE_POSTGRESQL_CHECKPOINT_START(flags);
7206 (
errmsg(
"concurrent write-ahead log activity while database system is shutting down")));
7345 elog(
ERROR,
"can only be used to end recovery");
7413 elog(
ERROR,
"can only be used at end of recovery");
7414 if (pagePtr % XLOG_BLCKSZ != 0)
7415 elog(
ERROR,
"invalid position for missing continuation record %X/%X",
7425 if (recptr != startPos)
7426 elog(
ERROR,
"invalid WAL insert position %X/%X for OVERWRITE_CONTRECORD",
7456 elog(
ERROR,
"OVERWRITE_CONTRECORD was inserted to unexpected position %X/%X",
7482 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_START(flags);
7492 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_SYNC_START();
7496 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_DONE();
7525 "could not record restart point at %X/%X because there "
7526 "are unresolved references to invalid pages",
7584 (
errmsg_internal(
"skipping restartpoint, recovery has already ended")));
7735 endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
7791 (
errmsg(
"recovery restart point at %X/%X",
7793 xtime ?
errdetail(
"Last completed transaction was at log time %s.",
7801 "archive_cleanup_command",
7803 WAIT_EVENT_ARCHIVE_CLEANUP_COMMAND);
7868 if (currSeg > keepSegs)
7869 oldestSegMaxWalSize = currSeg - keepSegs;
7871 oldestSegMaxWalSize = 1;
7880 if (targetSeg >= oldestSlotSeg)
7883 if (targetSeg >= oldestSegMaxWalSize)
7891 if (targetSeg >= oldestSeg)
7937 uint64 slot_keep_segs;
7942 if (currSegNo - segno > slot_keep_segs)
7943 segno = currSegNo - slot_keep_segs;
7957 if (unsummarized_segno < segno)
7958 segno = unsummarized_segno;
7967 if (currSegNo - segno < keep_segs)
7970 if (currSegNo <= keep_segs)
7973 segno = currSegNo - keep_segs;
7978 if (segno < *logSegNo)
8030 if (mark_unimportant)
8055 (
errmsg(
"restore point \"%s\" created at %X/%X",
8132 bool recoveryInProgress;
8163 Insert->fullPageWrites =
true;
8182 Insert->fullPageWrites =
false;
8262 (
errmsg(
"online backup was canceled, recovery cannot continue")));
8289 running.
xcnt = nxids;
8298 running.
xids = xids;
8320 (
errmsg(
"unexpected timeline ID %u (should be %u) in shutdown checkpoint record",
8378 (
errmsg(
"unexpected timeline ID %u (should be %u) in online checkpoint record",
8407 (
errmsg(
"unexpected timeline ID %u (should be %u) in end-of-recovery record",
8447 elog(
ERROR,
"XLOG_FPI record did not contain a full-page image");
8452 elog(
ERROR,
"unexpected XLogReadBufferForRedo result when restoring backup block");
8558 int o_direct_flag = 0;
8571 return o_direct_flag;
8584 return o_direct_flag;
8587 return O_SYNC | o_direct_flag;
8591 return O_DSYNC | o_direct_flag;
8595 elog(
ERROR,
"unrecognized \"wal_sync_method\": %d", method);
8628 errmsg(
"could not fsync file \"%s\": %m", xlogfname)));
8673 msg =
_(
"could not fsync file \"%s\": %m");
8675 #ifdef HAVE_FSYNC_WRITETHROUGH
8678 msg =
_(
"could not fsync write-through file \"%s\": %m");
8683 msg =
_(
"could not fdatasync file \"%s\": %m");
8692 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8701 int save_errno = errno;
8707 errmsg(msg, xlogfname)));
8769 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8770 errmsg(
"WAL level not sufficient for making an online backup"),
8771 errhint(
"\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
8775 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8776 errmsg(
"backup label too long (max %d bytes)",
8813 bool gotUniqueStartpoint =
false;
8894 if (!checkpointfpw ||
state->startpoint <= recptr)
8896 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8897 errmsg(
"WAL generated with \"full_page_writes=off\" was replayed "
8898 "since last restartpoint"),
8899 errhint(
"This means that the backup being taken on the standby "
8900 "is corrupt and should not be used. "
8901 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
8902 "and then try an online backup again.")));
8911 gotUniqueStartpoint =
true;
8929 gotUniqueStartpoint =
true;
8932 }
while (!gotUniqueStartpoint);
8937 datadirpathlen = strlen(
DataDir);
8941 while ((de =
ReadDir(tblspcdir,
"pg_tblspc")) != NULL)
8962 tsoid = strtoul(de->
d_name, &badp, 10);
8963 if (*badp !=
'\0' || errno == EINVAL || errno == ERANGE)
8966 snprintf(fullpath,
sizeof(fullpath),
"pg_tblspc/%s", de->
d_name);
8975 rllen =
readlink(fullpath, linkpath,
sizeof(linkpath));
8979 (
errmsg(
"could not read symbolic link \"%s\": %m",
8983 else if (rllen >=
sizeof(linkpath))
8986 (
errmsg(
"symbolic link \"%s\" target is too long",
8990 linkpath[rllen] =
'\0';
8997 if (rllen > datadirpathlen &&
8998 strncmp(linkpath,
DataDir, datadirpathlen) == 0 &&
9007 for (s = linkpath; *s; s++)
9009 if (*s ==
'\n' || *s ==
'\r' || *s ==
'\\')
9027 snprintf(linkpath,
sizeof(linkpath),
"pg_tblspc/%s",
9044 *tablespaces =
lappend(*tablespaces, ti);
9085 bool backup_stopped_in_recovery =
false;
9091 int seconds_before_warning;
9093 bool reported_waiting =
false;
9105 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9106 errmsg(
"WAL level not sufficient for making an online backup"),
9107 errhint(
"wal_level must be set to \"replica\" or \"logical\" at server start.")));
9142 if (
state->started_in_recovery && !backup_stopped_in_recovery)
9144 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9145 errmsg(
"the standby was promoted during online backup"),
9146 errhint(
"This means that the backup being taken is corrupt "
9147 "and should not be used. "
9148 "Try taking another online backup.")));
9178 if (backup_stopped_in_recovery)
9190 if (
state->startpoint <= recptr)
9192 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9193 errmsg(
"WAL generated with \"full_page_writes=off\" was replayed "
9194 "during online backup"),
9195 errhint(
"This means that the backup being taken on the standby "
9196 "is corrupt and should not be used. "
9197 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
9198 "and then try an online backup again.")));
9215 sizeof(
state->startpoint));
9242 errmsg(
"could not create file \"%s\": %m",
9247 fprintf(fp,
"%s", history_file);
9248 pfree(history_file);
9253 errmsg(
"could not write file \"%s\": %m",
9286 if (waitforarchive &&
9298 seconds_before_warning = 60;
9306 if (!reported_waiting && waits > 5)
9309 (
errmsg(
"base backup done, waiting for required WAL segments to be archived")));
9310 reported_waiting =
true;
9316 WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
9319 if (++waits >= seconds_before_warning)
9321 seconds_before_warning *= 2;
9323 (
errmsg(
"still waiting for all required WAL segments to be archived (%d seconds elapsed)",
9325 errhint(
"Check that your \"archive_command\" is executing properly. "
9326 "You can safely cancel this backup, "
9327 "but the database backup will not be usable without all the WAL segments.")));
9332 (
errmsg(
"all required WAL segments have been archived")));
9334 else if (waitforarchive)
9336 (
errmsg(
"WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
9373 if (!during_backup_start)
9375 errmsg(
"aborting backup due to backend exiting before pg_backup_stop was called"));
9386 static bool already_done =
false;
9391 already_done =
true;
9401 uint64 current_bytepos;
9404 current_bytepos =
Insert->CurrBytePos;
Datum idx(PG_FUNCTION_ARGS)
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
#define pg_memory_barrier()
#define pg_read_barrier()
static uint64 pg_atomic_read_membarrier_u64(volatile pg_atomic_uint64 *ptr)
#define pg_write_barrier()
static uint64 pg_atomic_monotonic_advance_u64(volatile pg_atomic_uint64 *ptr, uint64 target)
static uint64 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
static void pg_atomic_write_membarrier_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
TimeLineID findNewestTimeLine(TimeLineID startTLI)
void restoreTimeLineHistoryFiles(TimeLineID begin, TimeLineID end)
void writeTimeLineHistory(TimeLineID newTLI, TimeLineID parentTLI, XLogRecPtr switchpoint, char *reason)
void startup_progress_timeout_handler(void)
long TimestampDifferenceMilliseconds(TimestampTz start_time, TimestampTz stop_time)
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
TimestampTz GetCurrentTimestamp(void)
Datum now(PG_FUNCTION_ARGS)
const char * timestamptz_to_str(TimestampTz t)
static bool backup_started_in_recovery
void CheckPointBuffers(int flags)
void UnlockReleaseBuffer(Buffer buffer)
#define pg_attribute_unused()
#define TYPEALIGN(ALIGNVAL, LEN)
#define Assert(condition)
#define pg_attribute_always_inline
#define MemSet(start, val, len)
#define CATALOG_VERSION_NO
void AbsorbSyncRequests(void)
double CheckPointCompletionTarget
void RequestCheckpoint(int flags)
void CheckPointCLOG(void)
void StartupCommitTs(void)
void CommitTsParameterChange(bool newvalue, bool oldvalue)
bool track_commit_timestamp
void CompleteCommitTsInitialization(void)
void BootStrapCommitTs(void)
void SetCommitTsLimit(TransactionId oldestXact, TransactionId newestXact)
void CheckPointCommitTs(void)
void update_controlfile(const char *DataDir, ControlFileData *ControlFile, bool do_sync)
static void PGresult * res
int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
int errmsg_internal(const char *fmt,...)
int errcode_for_file_access(void)
int errdetail(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
struct pg_atomic_uint64 pg_atomic_uint64
struct dirent * ReadDir(DIR *dir, const char *dirname)
int MakePGDirectory(const char *directoryName)
int pg_fsync_no_writethrough(int fd)
FILE * AllocateFile(const char *name, const char *mode)
int durable_rename(const char *oldfile, const char *newfile, int elevel)
int CloseTransientFile(int fd)
int BasicOpenFile(const char *fileName, int fileFlags)
int pg_fsync_writethrough(int fd)
void ReleaseExternalFD(void)
int data_sync_elevel(int elevel)
static void Insert(File file)
int durable_unlink(const char *fname, int elevel)
void ReserveExternalFD(void)
int OpenTransientFile(const char *fileName, int fileFlags)
void SyncDataDirectory(void)
DIR * AllocateDir(const char *dirname)
#define IO_DIRECT_WAL_INIT
ssize_t pg_pwrite_zeros(int fd, size_t size, off_t offset)
PGFileType get_dirent_type(const char *path, const struct dirent *de, bool look_through_symlinks, int elevel)
volatile uint32 CritSectionCount
bool IsPostmasterEnvironment
void * guc_malloc(int elevel, size_t size)
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
int set_config_option_ext(const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
#define GUC_check_errdetail
#define TOAST_MAX_CHUNK_SIZE
#define INJECTION_POINT(name)
#define INSTR_TIME_SET_CURRENT(t)
#define INSTR_TIME_SET_ZERO(t)
#define INSTR_TIME_ACCUM_DIFF(x, y, z)
void before_shmem_exit(pg_on_exit_callback function, Datum arg)
#define PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg)
#define PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg)
if(TABLE==NULL||TABLE_index==NULL)
void SetLatch(Latch *latch)
void ResetLatch(Latch *latch)
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
#define WL_EXIT_ON_PM_DEATH
static void const char fflush(stdout)
List * lappend(List *list, void *datum)
void list_free(List *list)
void LWLockUpdateVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
void LWLockReleaseClearVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
bool LWLockWaitForVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval)
void LWLockRelease(LWLock *lock)
void LWLockInitialize(LWLock *lock, int tranche_id)
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
bool LWLockAcquireOrWait(LWLock *lock, LWLockMode mode)
char * pstrdup(const char *in)
void pfree(void *pointer)
MemoryContext TopMemoryContext
void MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
#define AllocSetContextCreate
#define ALLOCSET_DEFAULT_SIZES
#define IsBootstrapProcessingMode()
#define START_CRIT_SECTION()
#define CHECK_FOR_INTERRUPTS()
#define END_CRIT_SECTION()
#define AmWalReceiverProcess()
bool process_shared_preload_libraries_done
BackendType MyBackendType
void MultiXactSetNextMXact(MultiXactId nextMulti, MultiXactOffset nextMultiOffset)
void MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB)
void MultiXactGetCheckptMulti(bool is_shutdown, MultiXactId *nextMulti, MultiXactOffset *nextMultiOffset, MultiXactId *oldestMulti, Oid *oldestMultiDB)
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)
void CheckPointMultiXact(void)
void MultiXactAdvanceNextMXact(MultiXactId minMulti, MultiXactOffset minMultiOffset)
void BootStrapMultiXact(void)
void StartupMultiXact(void)
void StartupReplicationOrigin(void)
void CheckPointReplicationOrigin(void)
#define ERRCODE_DATA_CORRUPTED
#define DEFAULT_XLOG_SEG_SIZE
#define PG_CACHE_LINE_SIZE
#define FLOATFORMAT_VALUE
#define XLOG_RESTORE_POINT
#define XLOG_CHECKPOINT_REDO
#define PG_CONTROL_VERSION
#define XLOG_OVERWRITE_CONTRECORD
#define XLOG_FPI_FOR_HINT
#define MOCK_AUTH_NONCE_LEN
@ DB_SHUTDOWNED_IN_RECOVERY
#define XLOG_CHECKPOINT_SHUTDOWN
#define PG_CONTROL_FILE_SIZE
#define XLOG_PARAMETER_CHANGE
#define XLOG_CHECKPOINT_ONLINE
#define XLOG_END_OF_RECOVERY
#define COMP_CRC32C(crc, data, len)
#define EQ_CRC32C(c1, c2)
static rewind_source * source
void pgstat_restore_stats(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
subxids_array_status subxid_status
TransactionId oldestCommitTsXid
TransactionId newestCommitTsXid
FullTransactionId latestCompletedXid
FullTransactionId nextXid
pg_atomic_uint64 insertingAt
XLogRecPtr lastImportantAt
CheckPoint lastCheckPoint
XLogRecPtr InitializedUpTo
FullTransactionId ckptFullXid
pg_time_t lastSegSwitchTime
XLogRecPtr replicationSlotMinLSN
RecoveryState SharedRecoveryState
TimeLineID InsertTimeLineID
XLogRecPtr lastSegSwitchLSN
XLogSegNo lastRemovedSegNo
pg_atomic_uint64 * xlblocks
pg_atomic_uint64 logWriteResult
XLogRecPtr lastCheckPointRecPtr
XLogRecPtr lastFpwDisableRecPtr
bool InstallXLogFileSegmentActive
XLogRecPtr lastCheckPointEndPtr
pg_atomic_uint64 logFlushResult
pg_atomic_uint64 logInsertResult
TimeLineID PrevTimeLineID
pg_atomic_uint64 unloggedLSN
WALInsertLockPadded * WALInsertLocks
char pad[PG_CACHE_LINE_SIZE]
XLogRecPtr lastBackupStart
DecodedXLogRecord * record
struct XLogRecData * next
TimeLineID PrevTimeLineID
TimeLineID ThisTimeLineID
TimestampTz overwrite_time
XLogRecPtr overwritten_lsn
bool track_commit_timestamp
char rp_name[MAXFNAMELEN]
void StartupSUBTRANS(TransactionId oldestActiveXID)
void CheckPointSUBTRANS(void)
void BootStrapSUBTRANS(void)
void TruncateSUBTRANS(TransactionId oldestXact)
void ProcessSyncRequests(void)
void SyncPreCheckpoint(void)
void SyncPostCheckpoint(void)
TimeoutId RegisterTimeout(TimeoutId id, timeout_handler_proc handler)
@ STARTUP_PROGRESS_TIMEOUT
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
#define TransactionIdRetreat(dest)
#define InvalidTransactionId
static void FullTransactionIdRetreat(FullTransactionId *dest)
#define XidFromFullTransactionId(x)
#define FirstGenbkiObjectId
#define FirstNormalTransactionId
#define TransactionIdIsValid(xid)
static FullTransactionId FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)
#define TransactionIdIsNormal(xid)
#define FullTransactionIdPrecedes(a, b)
void RecoverPreparedTransactions(void)
void restoreTwoPhaseData(void)
TransactionId PrescanPreparedTransactions(TransactionId **xids_p, int *nxids_p)
void StandbyRecoverPreparedTransactions(void)
void CheckPointTwoPhase(XLogRecPtr redo_horizon)
char pad[PG_CACHE_LINE_SIZE]
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
void SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
TransamVariablesData * TransamVariables
static void pgstat_report_wait_start(uint32 wait_event_info)
static void pgstat_report_wait_end(void)
static TimestampTz wakeup[NUM_WALRCV_WAKEUPS]
XLogRecPtr GetWalRcvFlushRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI)
void ShutdownWalRcv(void)
void WalSndWakeup(bool physical, bool logical)
void WalSndInitStopping(void)
void WalSndWaitStopping(void)
static void WalSndWakeupProcessRequests(bool physical, bool logical)
#define WalSndWakeupRequest()
void SetWalSummarizerLatch(void)
void WaitForWalSummarization(XLogRecPtr lsn)
XLogRecPtr GetOldestUnsummarizedLSN(TimeLineID *tli, bool *lsn_is_exact)
#define readlink(path, buf, size)
int gettimeofday(struct timeval *tp, void *tzp)
void MarkSubxactTopXidLogged(void)
void MarkCurrentTransactionIdLoggedIfAny(void)
int XLogFileInit(XLogSegNo logsegno, TimeLineID logtli)
void assign_wal_sync_method(int new_wal_sync_method, void *extra)
static void CreateEndOfRecoveryRecord(void)
uint64 GetSystemIdentifier(void)
int wal_decode_buffer_size
XLogRecPtr ProcLastRecPtr
static XLogCtlData * XLogCtl
void UpdateFullPageWrites(void)
bool RecoveryInProgress(void)
static void CleanupBackupHistory(void)
void GetFullPageWriteInfo(XLogRecPtr *RedoRecPtr_p, bool *doPageWrites_p)
TimeLineID GetWALInsertionTimeLine(void)
bool check_max_slot_wal_keep_size(int *newval, void **extra, GucSource source)
const char * show_in_hot_standby(void)
XLogRecPtr RequestXLogSwitch(bool mark_unimportant)
void do_pg_abort_backup(int code, Datum arg)
XLogSegNo XLogGetLastRemovedSegno(void)
static char * str_time(pg_time_t tnow)
char * XLogArchiveCommand
struct XLogCtlInsert XLogCtlInsert
Size WALReadFromBuffers(char *dstbuf, XLogRecPtr startptr, Size count, TimeLineID tli)
static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto)
static void WALInsertLockRelease(void)
static XLogRecPtr XLogBytePosToRecPtr(uint64 bytepos)
static void WALInsertLockUpdateInsertingAt(XLogRecPtr insertingAt)
XLogRecPtr GetRedoRecPtr(void)
void assign_wal_consistency_checking(const char *newval, void *extra)
static void InitControlFile(uint64 sysidentifier, uint32 data_checksum_version)
void SetInstallXLogFileSegmentActive(void)
static void AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli, bool opportunistic)
static void WALInsertLockAcquireExclusive(void)
static void UpdateControlFile(void)
bool IsInstallXLogFileSegmentActive(void)
void BootStrapXLOG(uint32 data_checksum_version)
XLogRecPtr XactLastRecEnd
bool CreateRestartPoint(int flags)
static void ValidateXLOGDirectoryStructure(void)
static void RemoveOldXlogFiles(XLogSegNo segno, XLogRecPtr lastredoptr, XLogRecPtr endptr, TimeLineID insertTLI)
static XLogRecPtr CreateOverwriteContrecordRecord(XLogRecPtr aborted_lsn, XLogRecPtr pagePtr, TimeLineID newTLI)
XLogRecPtr GetInsertRecPtr(void)
static void CalculateCheckpointSegments(void)
SessionBackupState get_backup_status(void)
static void XLogReportParameters(void)
#define RefreshXLogWriteResult(_target)
void CheckXLogRemoved(XLogSegNo segno, TimeLineID tli)
static void LogCheckpointStart(int flags, bool restartpoint)
static XLogRecPtr RedoRecPtr
void assign_checkpoint_completion_target(double newval, void *extra)
static XLogRecPtr XLogGetReplicationSlotMinimumLSN(void)
XLogRecPtr XLogInsertRecord(XLogRecData *rdata, XLogRecPtr fpw_lsn, uint8 flags, int num_fpi, bool topxid_included)
static bool InstallXLogFileSegment(XLogSegNo *segno, char *tmppath, bool find_free, XLogSegNo max_segno, TimeLineID tli)
static void WriteControlFile(void)
struct XLogwrtResult XLogwrtResult
WALAvailability GetWALAvailability(XLogRecPtr targetLSN)
#define UsableBytesInPage
void ShutdownXLOG(int code, Datum arg)
bool DataChecksumsEnabled(void)
static bool PerformRecoveryXLogAction(void)
RecoveryState GetRecoveryState(void)
static void CleanupAfterArchiveRecovery(TimeLineID EndOfLogTLI, XLogRecPtr EndOfLog, TimeLineID newTLI)
#define ConvertToXSegs(x, segsize)
static void RemoveXlogFile(const struct dirent *segment_de, XLogSegNo recycleSegNo, XLogSegNo *endlogSegNo, TimeLineID insertTLI)
pg_time_t GetLastSegSwitchData(XLogRecPtr *lastSwitchLSN)
char * GetMockAuthenticationNonce(void)
static int XLOGChooseNumBuffers(void)
static XLogRecPtr XLogBytePosToEndRecPtr(uint64 bytepos)
static int get_sync_bit(int method)
static XLogwrtResult LogwrtResult
void XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn)
static void LogCheckpointEnd(bool restartpoint)
union WALInsertLockPadded WALInsertLockPadded
void SwitchIntoArchiveRecovery(XLogRecPtr EndRecPtr, TimeLineID replayTLI)
static bool lastFullPageWrites
char * wal_consistency_checking_string
static void WALInsertLockAcquire(void)
static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch, XLogRecData *rdata, XLogRecPtr StartPos, XLogRecPtr EndPos, TimeLineID tli)
static double CheckPointDistanceEstimate
static uint64 XLogRecPtrToBytePos(XLogRecPtr ptr)
XLogRecPtr GetXLogInsertRecPtr(void)
void SetWalWriterSleeping(bool sleeping)
static void XLogInitNewTimeline(TimeLineID endTLI, XLogRecPtr endOfLog, TimeLineID newTLI)
static void CheckRequiredParameterValues(void)
#define XLogRecPtrToBufIdx(recptr)
int XLogFileOpen(XLogSegNo segno, TimeLineID tli)
int max_slot_wal_keep_size_mb
XLogRecPtr GetFlushRecPtr(TimeLineID *insertTLI)
static void PreallocXlogFiles(XLogRecPtr endptr, TimeLineID tli)
static bool holdingAllLocks
static TimeLineID openLogTLI
XLogRecPtr XactLastCommitEnd
WalLevel GetActiveWalLevelOnStandby(void)
static void KeepLogSeg(XLogRecPtr recptr, XLogSegNo *logSegNo)
static void XLogWrite(XLogwrtRqst WriteRqst, TimeLineID tli, bool flexible)
void InitializeWalConsistencyChecking(void)
static void UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force)
static int LocalSetXLogInsertAllowed(void)
void assign_max_wal_size(int newval, void *extra)
void RemoveNonParentXlogFiles(XLogRecPtr switchpoint, TimeLineID newTLI)
XLogRecPtr GetLastImportantRecPtr(void)
void xlog_redo(XLogReaderState *record)
static void RecoveryRestartPoint(const CheckPoint *checkPoint, XLogReaderState *record)
bool XLogNeedsFlush(XLogRecPtr record)
void register_persistent_abort_backup_handler(void)
static double PrevCheckPointDistance
void ReachedEndOfBackup(XLogRecPtr EndRecPtr, TimeLineID tli)
void LocalProcessControlFile(bool reset)
static void XLogFileClose(void)
static void UpdateCheckPointDistanceEstimate(uint64 nbytes)
static bool LocalRecoveryInProgress
XLogSegNo XLogGetOldestSegno(TimeLineID tli)
XLogRecPtr GetXLogWriteRecPtr(void)
static WALInsertLockPadded * WALInsertLocks
static XLogSegNo openLogSegNo
#define INSERT_FREESPACE(endptr)
int wal_retrieve_retry_interval
bool XLogBackgroundFlush(void)
const struct config_enum_entry archive_mode_options[]
void GetOldestRestartPoint(XLogRecPtr *oldrecptr, TimeLineID *oldtli)
static XLogSegNo XLOGfileslop(XLogRecPtr lastredoptr)
static int UsableBytesInSegment
static char * GetXLogBuffer(XLogRecPtr ptr, TimeLineID tli)
const char * show_archive_command(void)
@ WALINSERT_SPECIAL_SWITCH
@ WALINSERT_SPECIAL_CHECKPOINT
bool XLogInsertAllowed(void)
void do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces, BackupState *state, StringInfo tblspcmapfile)
static ControlFileData * ControlFile
bool check_wal_segment_size(int *newval, void **extra, GucSource source)
static void XLogFileCopy(TimeLineID destTLI, XLogSegNo destsegno, TimeLineID srcTLI, XLogSegNo srcsegno, int upto)
static int LocalXLogInsertAllowed
static void RemoveTempXlogFiles(void)
XLogRecPtr XLogRestorePoint(const char *rpName)
static XLogRecPtr LocalMinRecoveryPoint
#define NUM_XLOGINSERT_LOCKS
struct XLogwrtRqst XLogwrtRqst
TimeLineID GetWALInsertionTimeLineIfSet(void)
void do_pg_backup_stop(BackupState *state, bool waitforarchive)
bool check_wal_consistency_checking(char **newval, void **extra, GucSource source)
const struct config_enum_entry wal_sync_method_options[]
#define BootstrapTimeLineID
CheckpointStatsData CheckpointStats
bool check_wal_buffers(int *newval, void **extra, GucSource source)
XLogRecPtr GetFakeLSNForUnloggedRel(void)
void XLogPutNextOid(Oid nextOid)
void XLogFlush(XLogRecPtr record)
static void ReadControlFile(void)
static SessionBackupState sessionBackupState
static void CheckPointGuts(XLogRecPtr checkPointRedo, int flags)
static bool updateMinRecoveryPoint
static bool check_wal_consistency_checking_deferred
static void ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr)
void XLogShutdownWalRcv(void)
static void UpdateLastRemovedPtr(char *filename)
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