xlogreader.c Source File (original) (raw)

21#ifdef USE_LZ4

22#include <lz4.h>

23#endif

24#ifdef USE_ZSTD

25#include <zstd.h>

26#endif

36#ifndef FRONTEND

39#else

41#endif

47 int reqLen);

56 int segsize, const char *waldir);

59#define MAX_ERRORMSG_LEN 1000

65#define DEFAULT_DECODE_BUFFER_SIZE (64 * 1024)

71static void

73{

76 fmt = _(fmt);

78 va_start(args, fmt);

82 state->errormsg_deferred = true;

83}

90void

92{

95 state->decode_buffer = buffer;

96 state->decode_buffer_size = size;

97 state->decode_buffer_tail = buffer;

98 state->decode_buffer_head = buffer;

99}

100

101

102

103

104

105

109{

111

116 return NULL;

117

118

119 state->routine = *routine;

120

121

122

123

124

125

126

127

130 if ( state ->readBuf)

131 {

133 return NULL;

134 }

135

136

138 waldir);

139

140

141 state->private_data = private_data;

142

145 if ( state ->errormsg_buf)

146 {

149 return NULL;

150 }

151 state->errormsg_buf[0] = '\0';

152

153

154

155

156

159}

160

161void

163{

164 if (state->seg.ws_file != -1)

166

167 if (state->decode_buffer && state->free_decode_buffer)

169

171 if (state->readRecordBuf)

175}

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190static void

192{

193 uint32 newSize = reclength;

194

195 newSize += XLOG_BLCKSZ - (newSize % XLOG_BLCKSZ);

196 newSize = Max(newSize, 5 * Max(BLCKSZ, XLOG_BLCKSZ));

197

198 if (state->readRecordBuf)

200 state->readRecordBuf = (char *) palloc(newSize);

201 state->readRecordBufSize = newSize;

202}

203

204

205

206

207static void

209 int segsize, const char *waldir)

210{

214

216 if (waldir)

218}

219

220

221

222

223

224

225

226

227

228

229

230

231void

233{

235

237

238

239 state->EndRecPtr = RecPtr;

240 state->NextRecPtr = RecPtr;

243}

244

245

246

247

248

251{

254

255 if ( state ->record)

257

258

259

260

261

262 record = state->record;

264 Assert(record == state->decode_queue_head);

265 state->record = NULL;

266 state->decode_queue_head = record->next;

267

268

269 if (state->decode_queue_tail == record)

270 state->decode_queue_tail = NULL;

271

272

274 {

275

277 }

278 else

279 {

280

281 Assert(state->decode_buffer_head == (char *) record);

282

283

284

285

286

287

288 record = record->next;

289 while (unlikely(record && record->oversized))

290 record = record->next;

291

292 if (record)

293 {

294

295 state->decode_buffer_head = (char *) record;

296 }

297 else

298 {

299

300

301

302

303

304

305 state->decode_buffer_head = state->decode_buffer;

306 state->decode_buffer_tail = state->decode_buffer;

307 }

308 }

309

310 return next_lsn;

311}

312

313

314

315

316

317

318

319

320

321

322

323

324

327{

328

330

331 if (state->decode_queue_head == NULL)

332 {

333 *errormsg = NULL;

334 if (state->errormsg_deferred)

335 {

336 if (state->errormsg_buf[0] != '\0')

337 *errormsg = state->errormsg_buf;

338 state->errormsg_deferred = false;

339 }

340

341

342

343

344

345

347

348 return NULL;

349 }

350

351

352

353

354

355

356

357 state->record = state->decode_queue_head;

358

359

360

361

362

363

364

365 state->ReadRecPtr = state->record->lsn;

366 state->EndRecPtr = state->record->next_lsn;

367

368 *errormsg = NULL;

369

370 return state->record;

371}

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

391{

393

394

395

396

397

399

400

401

402

403

406

407

409 if (decoded)

410 {

411

412

413

414

415

416

418 return &decoded->header;

419 }

420

421 return NULL;

422}

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

440{

443

444

446 {

447 if (state->decode_buffer_size == 0)

450 state->decode_buffer_head = state->decode_buffer;

451 state->decode_buffer_tail = state->decode_buffer;

452 state->free_decode_buffer = true;

453 }

454

455

456 if (state->decode_buffer_tail >= state->decode_buffer_head)

457 {

458

459 if (required_space <=

460 state->decode_buffer_size -

461 (state->decode_buffer_tail - state->decode_buffer))

462 {

463

464

465

466

467

468

469

470

471

472

475 return decoded;

476 }

477 else if (required_space <

478 state->decode_buffer_head - state->decode_buffer)

479 {

480

481

482

483

484

485

486

487

488

489

492 return decoded;

493 }

494 }

495 else

496 {

497

498 if (required_space <

499 state->decode_buffer_head - state->decode_buffer_tail)

500 {

501

502

503

504

505

506

507

508

509

510

513 return decoded;

514 }

515 }

516

517

518 if (allow_oversized)

519 {

520 decoded = palloc(required_space);

522 return decoded;

523 }

524

525 return NULL;

526}

527

530{

534 bool randAccess;

536 total_len;

538 uint32 pageHeaderSize;

539 bool assembled;

540 bool gotheader;

543 char *errormsg;

544

545

546

547

548

549

550 randAccess = false;

551

552

553 state->errormsg_buf[0] = '\0';

554 decoded = NULL;

555

558

559 RecPtr = state->NextRecPtr;

560

562 {

563

564

565

566

567

568

569

570

571 }

572 else

573 {

574

575

576

577

578

579

580

582 randAccess = true;

583 }

584

585restart:

586 state->nonblocking = nonblocking;

587 state->currRecPtr = RecPtr;

588 assembled = false;

589

590 targetPagePtr = RecPtr - (RecPtr % XLOG_BLCKSZ);

591 targetRecOff = RecPtr % XLOG_BLCKSZ;

592

593

594

595

596

597

603 goto err;

604

605

606

607

608

610 if (targetRecOff == 0)

611 {

612

613

614

615 RecPtr += pageHeaderSize;

616 targetRecOff = pageHeaderSize;

617 }

618 else if (targetRecOff < pageHeaderSize)

619 {

622 pageHeaderSize, targetRecOff);

623 goto err;

624 }

625

627 targetRecOff == pageHeaderSize)

628 {

631 goto err;

632 }

633

634

636

637

638

639

640

641

642

643

644

645

646 record = (XLogRecord *) (state->readBuf + RecPtr % XLOG_BLCKSZ);

648

649

650

651

652

653

654

655

656

658 {

660 randAccess))

661 goto err;

662 gotheader = true;

663 }

664 else

665 {

666

668 {

670 "invalid record length at %X/%X: expected at least %u, got %u",

673 goto err;

674 }

675

676 gotheader = false;

677 }

678

679

680

681

682

683

685 total_len,

686 false );

687 if (decoded == NULL && nonblocking)

688 {

689

690

691

692

693

695 }

696

697 len = XLOG_BLCKSZ - RecPtr % XLOG_BLCKSZ;

698 if (total_len > len)

699 {

700

701 char *contdata;

703 char *buffer;

705

706 assembled = true;

707

708

709

710

711

712 Assert(state->readRecordBufSize >= XLOG_BLCKSZ * 2);

714

715

716 memcpy(state->readRecordBuf,

717 state->readBuf + RecPtr % XLOG_BLCKSZ, len);

718 buffer = state->readRecordBuf + len;

719 gotlen = len;

720

721 do

722 {

723

724 targetPagePtr += XLOG_BLCKSZ;

725

726

729 XLOG_BLCKSZ));

730

734 goto err;

735

737

739

740

741

742

743

744

745

746

747

749 {

750 state->overwrittenRecPtr = RecPtr;

751 RecPtr = targetPagePtr;

752 goto restart;

753 }

754

755

757 {

759 "there is no contrecord flag at %X/%X",

761 goto err;

762 }

763

764

765

766

767

769 total_len != (pageHeader->xlp_rem_len + gotlen))

770 {

772 "invalid contrecord length %u (expected %lld) at %X/%X",

774 ((long long) total_len) - gotlen,

776 goto err;

777 }

778

779

781

782 if (readOff < pageHeaderSize)

784 pageHeaderSize);

785

787

788 contdata = (char *) state->readBuf + pageHeaderSize;

789 len = XLOG_BLCKSZ - pageHeaderSize;

792

795 pageHeaderSize + len);

796

797 memcpy(buffer, contdata, len);

798 buffer += len;

799 gotlen += len;

800

801

802 if (!gotheader)

803 {

806 record, randAccess))

807 goto err;

808 gotheader = true;

809 }

810

811

812

813

814

815

816

817 if (total_len > state->readRecordBufSize)

818 {

819 char save_copy[XLOG_BLCKSZ * 2];

820

821

822

823

824

826 Assert(gotlen <= state->readRecordBufSize);

827 memcpy(save_copy, state->readRecordBuf, gotlen);

829 memcpy(state->readRecordBuf, save_copy, gotlen);

830 buffer = state->readRecordBuf + gotlen;

831 }

832 } while (gotlen < total_len);

834

837 goto err;

838

840 state->DecodeRecPtr = RecPtr;

841 state->NextRecPtr = targetPagePtr + pageHeaderSize

843 }

844 else

845 {

846

848 Min(targetRecOff + total_len, XLOG_BLCKSZ));

852 goto err;

853

854

856 goto err;

857

858 state->NextRecPtr = RecPtr + MAXALIGN(total_len);

859

860 state->DecodeRecPtr = RecPtr;

861 }

862

863

864

865

866 if (record->xl_rmid == RM_XLOG_ID &&

868 {

869

870 state->NextRecPtr += state->segcxt.ws_segsize - 1;

872 }

873

874

875

876

877

878 if (decoded == NULL)

879 {

880 Assert(!nonblocking);

882 total_len,

883 true );

884

885 Assert(decoded != NULL);

886 }

887

889 {

890

892

893

894

895

896

898 {

899

901 if ((char *) decoded == state->decode_buffer)

902 state->decode_buffer_tail = state->decode_buffer + decoded->size;

903 else

904 state->decode_buffer_tail += decoded->size;

905 }

906

907

908 Assert(state->decode_queue_tail != decoded);

909 if (state->decode_queue_tail)

910 state->decode_queue_tail->next = decoded;

911 state->decode_queue_tail = decoded;

912 if ( state ->decode_queue_head)

913 state->decode_queue_head = decoded;

915 }

916

918 if (assembled)

919 {

920

921

922

923

924

925

926

927

928

929 state->abortedRecPtr = RecPtr;

930 state->missingContrecPtr = targetPagePtr;

931

932

933

934

935

936

937 state->errormsg_deferred = true;

938 }

939

940 if (decoded && decoded->oversized)

942

943

944

945

946

948

949

950

951

952

953

954

956}

957

958

959

960

961

962

963

964

965

968{

970

971 if (state->errormsg_deferred)

972 return NULL;

973

976 {

977 Assert(state->decode_queue_tail != NULL);

978 return state->decode_queue_tail;

979 }

980

981 return NULL;

982}

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000static int

1002{

1004 uint32 targetPageOff;

1007

1008 Assert((pageptr % XLOG_BLCKSZ) == 0);

1009

1010 XLByteToSeg(pageptr, targetSegNo, state->segcxt.ws_segsize);

1012

1013

1014 if (targetSegNo == state->seg.ws_segno &&

1015 targetPageOff == state->segoff && reqLen <= state->readLen)

1016 return state->readLen;

1017

1018

1019

1020

1021

1022

1023 state->readLen = 0;

1024

1025

1026

1027

1028

1029

1030

1031

1032

1033

1034

1035

1036

1037 if (targetSegNo != state->seg.ws_segno && targetPageOff != 0)

1038 {

1039 XLogRecPtr targetSegmentPtr = pageptr - targetPageOff;

1040

1041 readLen = state->routine.page_read(state, targetSegmentPtr, XLOG_BLCKSZ,

1042 state->currRecPtr,

1043 state->readBuf);

1047 goto err;

1048

1049

1051

1053 state->readBuf))

1054 goto err;

1055 }

1056

1057

1058

1059

1060

1062 state->currRecPtr,

1063 state->readBuf);

1067 goto err;

1068

1070

1071

1073 goto err;

1074

1076

1078

1079

1081 {

1083 state->currRecPtr,

1084 state->readBuf);

1088 goto err;

1089 }

1090

1091

1092

1093

1095 goto err;

1096

1097

1098 state->seg.ws_segno = targetSegNo;

1099 state->segoff = targetPageOff;

1101

1103

1106

1108}

1109

1110

1111

1112

1113static void

1115{

1116 state->seg.ws_segno = 0;

1117 state->segoff = 0;

1118 state->readLen = 0;

1119}

1120

1121

1122

1123

1124

1125

1126

1127static bool

1130 bool randAccess)

1131{

1133 {

1135 "invalid record length at %X/%X: expected at least %u, got %u",

1138 return false;

1139 }

1141 {

1143 "invalid resource manager ID %u at %X/%X",

1145 return false;

1146 }

1147 if (randAccess)

1148 {

1149

1150

1151

1152

1153 if (!(record->xl_prev < RecPtr))

1154 {

1156 "record with incorrect prev-link %X/%X at %X/%X",

1159 return false;

1160 }

1161 }

1162 else

1163 {

1164

1165

1166

1167

1168

1169 if (record->xl_prev != PrevRecPtr)

1170 {

1172 "record with incorrect prev-link %X/%X at %X/%X",

1175 return false;

1176 }

1177 }

1178

1179 return true;

1180}

1181

1182

1183

1184

1185

1186

1187

1188

1189

1190

1191

1192

1193static bool

1195{

1197

1199

1200

1203

1206

1208 {

1210 "incorrect resource manager data checksum in record at %X/%X",

1212 return false;

1213 }

1214

1215 return true;

1216}

1217

1218

1219

1220

1221

1222

1223

1224bool

1226 char *phdr)

1227{

1231

1232 Assert((recptr % XLOG_BLCKSZ) == 0);

1233

1236

1238 {

1240

1242

1244 "invalid magic number %04X in WAL segment %s, LSN %X/%X, offset %u",

1246 fname,

1248 offset);

1249 return false;

1250 }

1251

1253 {

1255

1257

1259 "invalid info bits %04X in WAL segment %s, LSN %X/%X, offset %u",

1261 fname,

1263 offset);

1264 return false;

1265 }

1266

1268 {

1270

1271 if (state->system_identifier &&

1273 {

1275 "WAL file is from different database system: WAL file database system identifier is %" PRIu64 ", pg_control database system identifier is %" PRIu64,

1277 state->system_identifier);

1278 return false;

1279 }

1281 {

1283 "WAL file is from different database system: incorrect segment size in page header");

1284 return false;

1285 }

1287 {

1289 "WAL file is from different database system: incorrect XLOG_BLCKSZ in page header");

1290 return false;

1291 }

1292 }

1293 else if (offset == 0)

1294 {

1296

1298

1299

1301 "invalid info bits %04X in WAL segment %s, LSN %X/%X, offset %u",

1303 fname,

1305 offset);

1306 return false;

1307 }

1308

1309

1310

1311

1312

1313

1315 {

1317

1319

1321 "unexpected pageaddr %X/%X in WAL segment %s, LSN %X/%X, offset %u",

1323 fname,

1325 offset);

1326 return false;

1327 }

1328

1329

1330

1331

1332

1333

1334

1335

1336

1337

1338 if (recptr > state->latestPagePtr)

1339 {

1341 {

1343

1345

1347 "out-of-sequence timeline ID %u (after %u) in WAL segment %s, LSN %X/%X, offset %u",

1349 state->latestPageTLI,

1350 fname,

1352 offset);

1353 return false;

1354 }

1355 }

1356 state->latestPagePtr = recptr;

1358

1359 return true;

1360}

1361

1362

1363

1364

1365void

1367{

1368 state->errormsg_buf[0] = '\0';

1369 state->errormsg_deferred = false;

1370}

1371

1372

1373

1374

1375

1376

1377

1378

1379

1380

1381

1382

1385{

1389 char *errormsg;

1390

1392

1393

1394 state->nonblocking = false;

1395

1396

1397

1398

1399

1400 tmpRecPtr = RecPtr;

1401 while (true)

1402 {

1404 int targetRecOff;

1405 uint32 pageHeaderSize;

1407

1408

1409

1410

1411

1412

1413

1414

1415

1416

1417 targetRecOff = tmpRecPtr % XLOG_BLCKSZ;

1418

1419

1420 targetPagePtr = tmpRecPtr - targetRecOff;

1421

1422

1425 goto err;

1426

1428

1430

1431

1434 goto err;

1435

1436

1438 {

1439

1440

1441

1442

1443

1444

1445

1446

1447

1449 tmpRecPtr = targetPagePtr + XLOG_BLCKSZ;

1450 else

1451 {

1452

1453

1454

1455

1456 tmpRecPtr = targetPagePtr + pageHeaderSize

1458 break;

1459 }

1460 }

1461 else

1462 {

1463 tmpRecPtr = targetPagePtr + pageHeaderSize;

1464 break;

1465 }

1466 }

1467

1468

1469

1470

1471

1472

1475 {

1476

1477 if (RecPtr <= state->ReadRecPtr)

1478 {

1479

1480 found = state->ReadRecPtr;

1482 return found;

1483 }

1484 }

1485

1488

1490}

1491

1492

1493

1494

1495

1496

1497

1498

1499

1500

1501

1502

1503bool

1507{

1508 char *p;

1510 Size nbytes;

1511#ifndef FRONTEND

1513#endif

1514

1515 p = buf;

1516 recptr = startptr;

1517 nbytes = count;

1518

1519 while (nbytes > 0)

1520 {

1522 int segbytes;

1523 int readbytes;

1524

1526

1527

1528

1529

1530

1531

1532 if (state->seg.ws_file < 0 ||

1534 tli != state->seg.ws_tli)

1535 {

1537

1538 if (state->seg.ws_file >= 0)

1539 state->routine.segment_close(state);

1540

1542 state->routine.segment_open(state, nextSegNo, &tli);

1543

1544

1546

1547

1548 state->seg.ws_tli = tli;

1549 state->seg.ws_segno = nextSegNo;

1550 }

1551

1552

1553 if (nbytes > (state->segcxt.ws_segsize - startoff))

1554 segbytes = state->segcxt.ws_segsize - startoff;

1555 else

1556 segbytes = nbytes;

1557

1558#ifndef FRONTEND

1559

1561

1563#endif

1564

1565

1566 errno = 0;

1567 readbytes = pg_pread(state->seg.ws_file, p, segbytes, (off_t) startoff);

1568

1569#ifndef FRONTEND

1571

1573 io_start, 1, readbytes);

1574#endif

1575

1576 if (readbytes <= 0)

1577 {

1579 errinfo->wre_req = segbytes;

1580 errinfo->wre_read = readbytes;

1581 errinfo->wre_off = startoff;

1583 return false;

1584 }

1585

1586

1587 recptr += readbytes;

1588 nbytes -= readbytes;

1589 p += readbytes;

1590 }

1591

1592 return true;

1593}

1594

1595

1596

1597

1598

1599

1600

1601

1602

1603

1604static void

1606{

1608

1609

1610 while ((r = state->decode_queue_head) != NULL)

1611 {

1612 state->decode_queue_head = r->next;

1615 }

1616 state->decode_queue_tail = NULL;

1617 state->decode_queue_head = NULL;

1618 state->record = NULL;

1619

1620

1621 state->decode_buffer_tail = state->decode_buffer;

1622 state->decode_buffer_head = state->decode_buffer;

1623

1624

1625 state->errormsg_buf[0] = '\0';

1626 state->errormsg_deferred = false;

1627}

1628

1629

1630

1631

1632

1633

1634

1635

1636

1637

1638size_t

1640{

1641 size_t size = 0;

1642

1643

1645

1647

1648 size += xl_tot_len;

1649

1650 size += (MAXIMUM_ALIGNOF - 1);

1651

1653

1654 size += (MAXIMUM_ALIGNOF - 1);

1655

1656 return size;

1657}

1658

1659

1660

1661

1662

1663

1664

1665

1666

1667

1668

1669

1670

1671bool

1676 char **errormsg)

1677{

1678

1679

1680

1681#define COPY_HEADER_FIELD(_dst, _size) \

1682 do { \

1683 if (remaining < _size) \

1684 goto shortdata_err; \

1685 memcpy(_dst, ptr, _size); \

1686 ptr += _size; \

1687 remaining -= _size; \

1688 } while(0)

1689

1690 char *ptr;

1691 char *out;

1696

1697 decoded->header = *record;

1698 decoded->lsn = lsn;

1699 decoded->next = NULL;

1705 ptr = (char *) record;

1708

1709

1710 datatotal = 0;

1712 {

1714

1716 {

1717

1718 uint8 main_data_len;

1719

1721

1723 datatotal += main_data_len;

1724 break;

1725

1726 }

1728 {

1729

1730 uint32 main_data_len;

1731

1734 datatotal += main_data_len;

1735 break;

1736

1737 }

1739 {

1741 }

1743 {

1745 }

1747 {

1748

1750 uint8 fork_flags;

1751

1752

1753 for (int i = decoded->max_block_id + 1; i < block_id; ++i)

1755

1756 if (block_id <= decoded->max_block_id)

1757 {

1759 "out-of-order block_id %u at %X/%X",

1760 block_id,

1762 goto err;

1763 }

1765

1766 blk = &decoded->blocks[block_id];

1769

1772 blk->flags = fork_flags;

1775

1777

1779

1781 {

1783 "BKPBLOCK_HAS_DATA set, but no data included at %X/%X",

1785 goto err;

1786 }

1788 {

1790 "BKPBLOCK_HAS_DATA not set, but data length is %u at %X/%X",

1791 (unsigned int) blk->data_len,

1793 goto err;

1794 }

1796

1798 {

1802

1804

1806 {

1809 else

1811 }

1812 else

1815

1816

1817

1818

1819

1824 {

1826 "BKPIMAGE_HAS_HOLE set, but hole offset %u length %u block image length %u at %X/%X",

1829 (unsigned int) blk->bimg_len,

1831 goto err;

1832 }

1833

1834

1835

1836

1837

1840 {

1842 "BKPIMAGE_HAS_HOLE not set, but hole offset %u length %u at %X/%X",

1846 goto err;

1847 }

1848

1849

1850

1851

1854 {

1856 "BKPIMAGE_COMPRESSED set, but block image length %u at %X/%X",

1857 (unsigned int) blk->bimg_len,

1859 goto err;

1860 }

1861

1862

1863

1864

1865

1869 {

1871 "neither BKPIMAGE_HAS_HOLE nor BKPIMAGE_COMPRESSED set, but block image length is %u at %X/%X",

1872 (unsigned int) blk->data_len,

1874 goto err;

1875 }

1876 }

1878 {

1881 }

1882 else

1883 {

1884 if (rlocator == NULL)

1885 {

1887 "BKPBLOCK_SAME_REL set but no previous rel at %X/%X",

1889 goto err;

1890 }

1891

1893 }

1895 }

1896 else

1897 {

1899 "invalid block_id %u at %X/%X",

1901 goto err;

1902 }

1903 }

1904

1906 goto shortdata_err;

1907

1908

1909

1910

1911

1912

1913

1914

1915 out = ((char *) decoded) +

1918

1919

1920 for (block_id = 0; block_id <= decoded->max_block_id; block_id++)

1921 {

1923

1925 continue;

1926

1928

1930 {

1931

1933 memcpy(out, ptr, blk->bimg_len);

1936 }

1938 {

1939 out = (char *) MAXALIGN(out);

1940 blk->data = out;

1944 }

1945 }

1946

1947

1949 {

1950 out = (char *) MAXALIGN(out);

1955 }

1956

1957

1958 decoded->size = MAXALIGN(out - (char *) decoded);

1960 decoded->size);

1961

1962 return true;

1963

1964shortdata_err:

1966 "record with invalid length at %X/%X",

1969 *errormsg = state->errormsg_buf;

1970

1971 return false;

1972}

1973

1974

1975

1976

1977

1978

1979

1980void

1984{

1986 blknum, NULL))

1987 {

1988#ifndef FRONTEND

1989 elog(ERROR, "could not locate backup block with ID %d in WAL record",

1990 block_id);

1991#else

1992 pg_fatal("could not locate backup block with ID %d in WAL record",

1993 block_id);

1994#endif

1995 }

1996}

1997

1998

1999

2000

2001

2002

2003

2004

2005

2006bool

2010 Buffer *prefetch_buffer)

2011{

2013

2015 return false;

2016

2018 if (rlocator)

2020 if (forknum)

2021 *forknum = bkpb->forknum;

2022 if (blknum)

2023 *blknum = bkpb->blkno;

2024 if (prefetch_buffer)

2026 return true;

2027}

2028

2029

2030

2031

2032

2033

2034char *

2036{

2038

2041 return NULL;

2042

2044

2046 {

2047 if (len)

2048 *len = 0;

2049 return NULL;

2050 }

2051 else

2052 {

2053 if (len)

2055 return bkpb->data;

2056 }

2057}

2058

2059

2060

2061

2062

2063

2064

2065bool

2067{

2069 char *ptr;

2071

2074 {

2076 "could not restore image at %X/%X with invalid block %d specified",

2078 block_id);

2079 return false;

2080 }

2082 {

2083 report_invalid_record(record, "could not restore image at %X/%X with invalid state, block %d",

2085 block_id);

2086 return false;

2087 }

2088

2091

2093 {

2094

2095 bool decomp_success = true;

2096

2098 {

2101 decomp_success = false;

2102 }

2104 {

2105#ifdef USE_LZ4

2106 if (LZ4_decompress_safe(ptr, tmp.data,

2108 decomp_success = false;

2109#else

2110 report_invalid_record(record, "could not restore image at %X/%X compressed with %s not supported by build, block %d",

2112 "LZ4",

2113 block_id);

2114 return false;

2115#endif

2116 }

2118 {

2119#ifdef USE_ZSTD

2120 size_t decomp_result = ZSTD_decompress(tmp.data,

2123

2124 if (ZSTD_isError(decomp_result))

2125 decomp_success = false;

2126#else

2127 report_invalid_record(record, "could not restore image at %X/%X compressed with %s not supported by build, block %d",

2129 "zstd",

2130 block_id);

2131 return false;

2132#endif

2133 }

2134 else

2135 {

2136 report_invalid_record(record, "could not restore image at %X/%X compressed with unknown method, block %d",

2138 block_id);

2139 return false;

2140 }

2141

2142 if (!decomp_success)

2143 {

2146 block_id);

2147 return false;

2148 }

2149

2150 ptr = tmp.data;

2151 }

2152

2153

2155 {

2156 memcpy(page, ptr, BLCKSZ);

2157 }

2158 else

2159 {

2161

2166 }

2167

2168 return true;

2169}

2170

2171#ifndef FRONTEND

2172

2173

2174

2175

2178{

2179

2180

2181

2182

2184

2187}

2188

2189#endif

#define pg_attribute_printf(f, a)

#define MemSet(start, val, len)

void err(int eval, const char *fmt,...)

#define MCXT_ALLOC_NO_OOM

Assert(PointerIsAligned(start, uint64))

if(TABLE==NULL||TABLE_index==NULL)

void pfree(void *pointer)

void * palloc_extended(Size size, int flags)

#define AmStartupProcess()

#define InvalidRepOriginId

#define COMP_CRC32C(crc, data, len)

#define EQ_CRC32C(c1, c2)

int32 pglz_decompress(const char *source, int32 slen, char *dest, int32 rawsize, bool check_complete)

instr_time pgstat_prepare_io_time(bool track_io_guc)

void pgstat_count_io_op_time(IOObject io_object, IOContext io_context, IOOp io_op, instr_time start_time, uint32 cnt, uint64 bytes)

#define RmgrIdIsValid(rmid)

struct DecodedXLogRecord * next

TransactionId toplevel_xid

RepOriginId record_origin

DecodedBkpBlock blocks[FLEXIBLE_ARRAY_MEMBER]

FullTransactionId nextXid

DecodedXLogRecord * record

#define InvalidTransactionId

static FullTransactionId FullTransactionIdFromAllowableAt(FullTransactionId nextFullXid, TransactionId xid)

TransamVariablesData * TransamVariables

static void pgstat_report_wait_start(uint32 wait_event_info)

static void pgstat_report_wait_end(void)

#define XLP_FIRST_IS_CONTRECORD

XLogLongPageHeaderData * XLogLongPageHeader

#define XLP_FIRST_IS_OVERWRITE_CONTRECORD

#define XLogSegmentOffset(xlogptr, wal_segsz_bytes)

XLogPageHeaderData * XLogPageHeader

#define XLByteToSeg(xlrp, logSegNo, wal_segsz_bytes)

#define XRecOffIsValid(xlrp)

#define SizeOfXLogShortPHD

static void XLogFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)

#define XLogPageHeaderSize(hdr)

#define XLByteInSeg(xlrp, logSegNo, wal_segsz_bytes)

#define LSN_FORMAT_ARGS(lsn)

#define XLogRecPtrIsInvalid(r)

#define InvalidXLogRecPtr

bool XLogRecGetBlockTagExtended(XLogReaderState *record, uint8 block_id, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum, Buffer *prefetch_buffer)

static XLogPageReadResult XLogDecodeNextRecord(XLogReaderState *state, bool nonblocking)

XLogReaderState * XLogReaderAllocate(int wal_segment_size, const char *waldir, XLogReaderRoutine *routine, void *private_data)

void XLogReaderSetDecodeBuffer(XLogReaderState *state, void *buffer, size_t size)

DecodedXLogRecord * XLogReadAhead(XLogReaderState *state, bool nonblocking)

static void WALOpenSegmentInit(WALOpenSegment *seg, WALSegmentContext *segcxt, int segsize, const char *waldir)

char * XLogRecGetBlockData(XLogReaderState *record, uint8 block_id, Size *len)

static int ReadPageInternal(XLogReaderState *state, XLogRecPtr pageptr, int reqLen)

DecodedXLogRecord * XLogNextRecord(XLogReaderState *state, char **errormsg)

static void report_invalid_record(XLogReaderState *state, const char *fmt,...) pg_attribute_printf(2

static void static void allocate_recordbuf(XLogReaderState *state, uint32 reclength)

bool WALRead(XLogReaderState *state, char *buf, XLogRecPtr startptr, Size count, TimeLineID tli, WALReadError *errinfo)

XLogRecord * XLogReadRecord(XLogReaderState *state, char **errormsg)

void XLogReaderResetError(XLogReaderState *state)

static void XLogReaderInvalReadState(XLogReaderState *state)

#define COPY_HEADER_FIELD(_dst, _size)

bool XLogReaderValidatePageHeader(XLogReaderState *state, XLogRecPtr recptr, char *phdr)

FullTransactionId XLogRecGetFullXid(XLogReaderState *record)

void XLogReaderFree(XLogReaderState *state)

void XLogRecGetBlockTag(XLogReaderState *record, uint8 block_id, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum)

static void ResetDecoder(XLogReaderState *state)

bool DecodeXLogRecord(XLogReaderState *state, DecodedXLogRecord *decoded, XLogRecord *record, XLogRecPtr lsn, char **errormsg)

static bool ValidXLogRecord(XLogReaderState *state, XLogRecord *record, XLogRecPtr recptr)

#define DEFAULT_DECODE_BUFFER_SIZE

size_t DecodeXLogRecordRequiredSpace(size_t xl_tot_len)

static DecodedXLogRecord * XLogReadRecordAlloc(XLogReaderState *state, size_t xl_tot_len, bool allow_oversized)

XLogRecPtr XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr)

void XLogBeginRead(XLogReaderState *state, XLogRecPtr RecPtr)

bool RestoreBlockImage(XLogReaderState *record, uint8 block_id, char *page)

XLogRecPtr XLogReleasePreviousRecord(XLogReaderState *state)

static bool ValidXLogRecordHeader(XLogReaderState *state, XLogRecPtr RecPtr, XLogRecPtr PrevRecPtr, XLogRecord *record, bool randAccess)

static bool XLogReaderHasQueuedRecordOrError(XLogReaderState *state)

#define XLogRecGetXid(decoder)

#define XLogRecHasBlockRef(decoder, block_id)

#define BKPIMAGE_COMPRESS_ZSTD

#define BKPBLOCK_FORK_MASK

#define BKPBLOCK_HAS_DATA

#define BKPIMAGE_HAS_HOLE

#define XLR_BLOCK_ID_DATA_LONG

#define BKPIMAGE_COMPRESS_LZ4

#define BKPIMAGE_COMPRESSED(info)

#define XLR_BLOCK_ID_TOPLEVEL_XID

#define XLR_BLOCK_ID_DATA_SHORT

#define BKPBLOCK_SAME_REL

#define BKPIMAGE_COMPRESS_PGLZ

#define XLR_BLOCK_ID_ORIGIN

#define BKPBLOCK_HAS_IMAGE