xlogreader.h File Reference (original) (raw)

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}

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

Assert(PointerIsAligned(start, uint64))

#define InvalidRepOriginId

struct DecodedXLogRecord * next

TransactionId toplevel_xid

RepOriginId record_origin

DecodedBkpBlock blocks[FLEXIBLE_ARRAY_MEMBER]

#define InvalidTransactionId

#define LSN_FORMAT_ARGS(lsn)

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

#define COPY_HEADER_FIELD(_dst, _size)

size_t DecodeXLogRecordRequiredSpace(size_t xl_tot_len)

#define BKPBLOCK_FORK_MASK

#define BKPBLOCK_HAS_DATA

#define BKPIMAGE_HAS_HOLE

#define XLR_BLOCK_ID_DATA_LONG

#define BKPIMAGE_COMPRESSED(info)

#define XLR_BLOCK_ID_TOPLEVEL_XID

#define XLR_BLOCK_ID_DATA_SHORT

#define BKPBLOCK_SAME_REL

#define XLR_BLOCK_ID_ORIGIN

#define BKPBLOCK_HAS_IMAGE