PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
bufpage.c File Reference
#include "postgres.h"
#include "access/htup_details.h"
#include "access/itup.h"
#include "access/xlog.h"
#include "pgstat.h"
#include "storage/checksum.h"
#include "utils/memdebug.h"
#include "utils/memutils.h"
Include dependency graph for bufpage.c:

Go to the source code of this file.

Data Structures

struct  itemIdCompactData
 

Typedefs

typedef struct itemIdCompactData itemIdCompactData
 
typedef itemIdCompactDataitemIdCompact
 

Functions

void PageInit (Page page, Size pageSize, Size specialSize)
 
bool PageIsVerified (PageData *page, BlockNumber blkno, int flags, bool *checksum_failure_p)
 
OffsetNumber PageAddItemExtended (Page page, Item item, Size size, OffsetNumber offsetNumber, int flags)
 
Page PageGetTempPage (const PageData *page)
 
Page PageGetTempPageCopy (const PageData *page)
 
Page PageGetTempPageCopySpecial (const PageData *page)
 
void PageRestoreTempPage (Page tempPage, Page oldPage)
 
static void compactify_tuples (itemIdCompact itemidbase, int nitems, Page page, bool presorted)
 
void PageRepairFragmentation (Page page)
 
void PageTruncateLinePointerArray (Page page)
 
Size PageGetFreeSpace (const PageData *page)
 
Size PageGetFreeSpaceForMultipleTuples (const PageData *page, int ntups)
 
Size PageGetExactFreeSpace (const PageData *page)
 
Size PageGetHeapFreeSpace (const PageData *page)
 
void PageIndexTupleDelete (Page page, OffsetNumber offnum)
 
void PageIndexMultiDelete (Page page, OffsetNumber *itemnos, int nitems)
 
void PageIndexTupleDeleteNoCompact (Page page, OffsetNumber offnum)
 
bool PageIndexTupleOverwrite (Page page, OffsetNumber offnum, Item newtup, Size newsize)
 
char * PageSetChecksumCopy (Page page, BlockNumber blkno)
 
void PageSetChecksumInplace (Page page, BlockNumber blkno)
 

Variables

bool ignore_checksum_failure = false
 

Typedef Documentation

◆ itemIdCompact

Definition at line 442 of file bufpage.c.

◆ itemIdCompactData

Function Documentation

◆ compactify_tuples()

static void compactify_tuples ( itemIdCompact  itemidbase,
int  nitems,
Page  page,
bool  presorted 
)
static

Definition at line 473 of file bufpage.c.

474{
475 PageHeader phdr = (PageHeader) page;
477 Offset copy_tail;
478 Offset copy_head;
479 itemIdCompact itemidptr;
480 int i;
481
482 /* Code within will not work correctly if nitems == 0 */
483 Assert(nitems > 0);
484
485 if (presorted)
486 {
487
488#ifdef USE_ASSERT_CHECKING
489 {
490 /*
491 * Verify we've not gotten any new callers that are incorrectly
492 * passing a true presorted value.
493 */
494 Offset lastoff = phdr->pd_special;
495
496 for (i = 0; i < nitems; i++)
497 {
498 itemidptr = &itemidbase[i];
499
500 Assert(lastoff > itemidptr->itemoff);
501
502 lastoff = itemidptr->itemoff;
503 }
504 }
505#endif /* USE_ASSERT_CHECKING */
506
507 /*
508 * 'itemidbase' is already in the optimal order, i.e, lower item
509 * pointers have a higher offset. This allows us to memmove() the
510 * tuples up to the end of the page without having to worry about
511 * overwriting other tuples that have not been moved yet.
512 *
513 * There's a good chance that there are tuples already right at the
514 * end of the page that we can simply skip over because they're
515 * already in the correct location within the page. We'll do that
516 * first...
517 */
518 upper = phdr->pd_special;
519 i = 0;
520 do
521 {
522 itemidptr = &itemidbase[i];
523 if (upper != itemidptr->itemoff + itemidptr->alignedlen)
524 break;
525 upper -= itemidptr->alignedlen;
526
527 i++;
528 } while (i < nitems);
529
530 /*
531 * Now that we've found the first tuple that needs to be moved, we can
532 * do the tuple compactification. We try and make the least number of
533 * memmove() calls and only call memmove() when there's a gap. When
534 * we see a gap we just move all tuples after the gap up until the
535 * point of the last move operation.
536 */
537 copy_tail = copy_head = itemidptr->itemoff + itemidptr->alignedlen;
538 for (; i < nitems; i++)
539 {
540 ItemId lp;
541
542 itemidptr = &itemidbase[i];
543 lp = PageGetItemId(page, itemidptr->offsetindex + 1);
544
545 if (copy_head != itemidptr->itemoff + itemidptr->alignedlen)
546 {
547 memmove((char *) page + upper,
548 page + copy_head,
549 copy_tail - copy_head);
550
551 /*
552 * We've now moved all tuples already seen, but not the
553 * current tuple, so we set the copy_tail to the end of this
554 * tuple so it can be moved in another iteration of the loop.
555 */
556 copy_tail = itemidptr->itemoff + itemidptr->alignedlen;
557 }
558 /* shift the target offset down by the length of this tuple */
559 upper -= itemidptr->alignedlen;
560 /* point the copy_head to the start of this tuple */
561 copy_head = itemidptr->itemoff;
562
563 /* update the line pointer to reference the new offset */
564 lp->lp_off = upper;
565 }
566
567 /* move the remaining tuples. */
568 memmove((char *) page + upper,
569 page + copy_head,
570 copy_tail - copy_head);
571 }
572 else
573 {
574 PGAlignedBlock scratch;
575 char *scratchptr = scratch.data;
576
577 /*
578 * Non-presorted case: The tuples in the itemidbase array may be in
579 * any order. So, in order to move these to the end of the page we
580 * must make a temp copy of each tuple that needs to be moved before
581 * we copy them back into the page at the new offset.
582 *
583 * If a large percentage of tuples have been pruned (>75%) then we'll
584 * copy these into the temp buffer tuple-by-tuple, otherwise, we'll
585 * just do a single memcpy() for all tuples that need to be moved.
586 * When so many tuples have been removed there's likely to be a lot of
587 * gaps and it's unlikely that many non-movable tuples remain at the
588 * end of the page.
589 */
590 if (nitems < PageGetMaxOffsetNumber(page) / 4)
591 {
592 i = 0;
593 do
594 {
595 itemidptr = &itemidbase[i];
596 memcpy(scratchptr + itemidptr->itemoff, page + itemidptr->itemoff,
597 itemidptr->alignedlen);
598 i++;
599 } while (i < nitems);
600
601 /* Set things up for the compactification code below */
602 i = 0;
603 itemidptr = &itemidbase[0];
604 upper = phdr->pd_special;
605 }
606 else
607 {
608 upper = phdr->pd_special;
609
610 /*
611 * Many tuples are likely to already be in the correct location.
612 * There's no need to copy these into the temp buffer. Instead
613 * we'll just skip forward in the itemidbase array to the position
614 * that we do need to move tuples from so that the code below just
615 * leaves these ones alone.
616 */
617 i = 0;
618 do
619 {
620 itemidptr = &itemidbase[i];
621 if (upper != itemidptr->itemoff + itemidptr->alignedlen)
622 break;
623 upper -= itemidptr->alignedlen;
624
625 i++;
626 } while (i < nitems);
627
628 /* Copy all tuples that need to be moved into the temp buffer */
629 memcpy(scratchptr + phdr->pd_upper,
630 page + phdr->pd_upper,
631 upper - phdr->pd_upper);
632 }
633
634 /*
635 * Do the tuple compactification. itemidptr is already pointing to
636 * the first tuple that we're going to move. Here we collapse the
637 * memcpy calls for adjacent tuples into a single call. This is done
638 * by delaying the memcpy call until we find a gap that needs to be
639 * closed.
640 */
641 copy_tail = copy_head = itemidptr->itemoff + itemidptr->alignedlen;
642 for (; i < nitems; i++)
643 {
644 ItemId lp;
645
646 itemidptr = &itemidbase[i];
647 lp = PageGetItemId(page, itemidptr->offsetindex + 1);
648
649 /* copy pending tuples when we detect a gap */
650 if (copy_head != itemidptr->itemoff + itemidptr->alignedlen)
651 {
652 memcpy((char *) page + upper,
653 scratchptr + copy_head,
654 copy_tail - copy_head);
655
656 /*
657 * We've now copied all tuples already seen, but not the
658 * current tuple, so we set the copy_tail to the end of this
659 * tuple.
660 */
661 copy_tail = itemidptr->itemoff + itemidptr->alignedlen;
662 }
663 /* shift the target offset down by the length of this tuple */
664 upper -= itemidptr->alignedlen;
665 /* point the copy_head to the start of this tuple */
666 copy_head = itemidptr->itemoff;
667
668 /* update the line pointer to reference the new offset */
669 lp->lp_off = upper;
670 }
671
672 /* Copy the remaining chunk */
673 memcpy((char *) page + upper,
674 scratchptr + copy_head,
675 copy_tail - copy_head);
676 }
677
678 phdr->pd_upper = upper;
679}
PageHeaderData * PageHeader
Definition: bufpage.h:174
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:244
static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)
Definition: bufpage.h:372
signed int Offset
Definition: c.h:595
Assert(PointerIsAligned(start, uint64))
#define nitems(x)
Definition: indent.h:31
int i
Definition: isn.c:77
Datum upper(PG_FUNCTION_ARGS)
Definition: oracle_compat.c:80
unsigned lp_off
Definition: itemid.h:27
LocationIndex pd_special
Definition: bufpage.h:168
LocationIndex pd_upper
Definition: bufpage.h:167
uint16 offsetindex
Definition: bufpage.c:438
uint16 alignedlen
Definition: bufpage.c:440
char data[BLCKSZ]
Definition: c.h:1090

References itemIdCompactData::alignedlen, Assert(), PGAlignedBlock::data, i, itemIdCompactData::itemoff, ItemIdData::lp_off, nitems, itemIdCompactData::offsetindex, PageGetItemId(), PageGetMaxOffsetNumber(), PageHeaderData::pd_special, PageHeaderData::pd_upper, and upper().

Referenced by PageIndexMultiDelete(), and PageRepairFragmentation().

◆ PageAddItemExtended()

OffsetNumber PageAddItemExtended ( Page  page,
Item  item,
Size  size,
OffsetNumber  offsetNumber,
int  flags 
)

Definition at line 193 of file bufpage.c.

198{
199 PageHeader phdr = (PageHeader) page;
200 Size alignedSize;
201 int lower;
202 int upper;
203 ItemId itemId;
204 OffsetNumber limit;
205 bool needshuffle = false;
206
207 /*
208 * Be wary about corrupted page pointers
209 */
210 if (phdr->pd_lower < SizeOfPageHeaderData ||
211 phdr->pd_lower > phdr->pd_upper ||
212 phdr->pd_upper > phdr->pd_special ||
213 phdr->pd_special > BLCKSZ)
216 errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
217 phdr->pd_lower, phdr->pd_upper, phdr->pd_special)));
218
219 /*
220 * Select offsetNumber to place the new item at
221 */
223
224 /* was offsetNumber passed in? */
225 if (OffsetNumberIsValid(offsetNumber))
226 {
227 /* yes, check it */
228 if ((flags & PAI_OVERWRITE) != 0)
229 {
230 if (offsetNumber < limit)
231 {
232 itemId = PageGetItemId(page, offsetNumber);
233 if (ItemIdIsUsed(itemId) || ItemIdHasStorage(itemId))
234 {
235 elog(WARNING, "will not overwrite a used ItemId");
236 return InvalidOffsetNumber;
237 }
238 }
239 }
240 else
241 {
242 if (offsetNumber < limit)
243 needshuffle = true; /* need to move existing linp's */
244 }
245 }
246 else
247 {
248 /* offsetNumber was not passed in, so find a free slot */
249 /* if no free slot, we'll put it at limit (1st open slot) */
250 if (PageHasFreeLinePointers(page))
251 {
252 /*
253 * Scan line pointer array to locate a "recyclable" (unused)
254 * ItemId.
255 *
256 * Always use earlier items first. PageTruncateLinePointerArray
257 * can only truncate unused items when they appear as a contiguous
258 * group at the end of the line pointer array.
259 */
260 for (offsetNumber = FirstOffsetNumber;
261 offsetNumber < limit; /* limit is maxoff+1 */
262 offsetNumber++)
263 {
264 itemId = PageGetItemId(page, offsetNumber);
265
266 /*
267 * We check for no storage as well, just to be paranoid;
268 * unused items should never have storage. Assert() that the
269 * invariant is respected too.
270 */
271 Assert(ItemIdIsUsed(itemId) || !ItemIdHasStorage(itemId));
272
273 if (!ItemIdIsUsed(itemId) && !ItemIdHasStorage(itemId))
274 break;
275 }
276 if (offsetNumber >= limit)
277 {
278 /* the hint is wrong, so reset it */
280 }
281 }
282 else
283 {
284 /* don't bother searching if hint says there's no free slot */
285 offsetNumber = limit;
286 }
287 }
288
289 /* Reject placing items beyond the first unused line pointer */
290 if (offsetNumber > limit)
291 {
292 elog(WARNING, "specified item offset is too large");
293 return InvalidOffsetNumber;
294 }
295
296 /* Reject placing items beyond heap boundary, if heap */
297 if ((flags & PAI_IS_HEAP) != 0 && offsetNumber > MaxHeapTuplesPerPage)
298 {
299 elog(WARNING, "can't put more than MaxHeapTuplesPerPage items in a heap page");
300 return InvalidOffsetNumber;
301 }
302
303 /*
304 * Compute new lower and upper pointers for page, see if it'll fit.
305 *
306 * Note: do arithmetic as signed ints, to avoid mistakes if, say,
307 * alignedSize > pd_upper.
308 */
309 if (offsetNumber == limit || needshuffle)
310 lower = phdr->pd_lower + sizeof(ItemIdData);
311 else
312 lower = phdr->pd_lower;
313
314 alignedSize = MAXALIGN(size);
315
316 upper = (int) phdr->pd_upper - (int) alignedSize;
317
318 if (lower > upper)
319 return InvalidOffsetNumber;
320
321 /*
322 * OK to insert the item. First, shuffle the existing pointers if needed.
323 */
324 itemId = PageGetItemId(page, offsetNumber);
325
326 if (needshuffle)
327 memmove(itemId + 1, itemId,
328 (limit - offsetNumber) * sizeof(ItemIdData));
329
330 /* set the line pointer */
331 ItemIdSetNormal(itemId, upper, size);
332
333 /*
334 * Items normally contain no uninitialized bytes. Core bufpage consumers
335 * conform, but this is not a necessary coding rule; a new index AM could
336 * opt to depart from it. However, data type input functions and other
337 * C-language functions that synthesize datums should initialize all
338 * bytes; datumIsEqual() relies on this. Testing here, along with the
339 * similar check in printtup(), helps to catch such mistakes.
340 *
341 * Values of the "name" type retrieved via index-only scans may contain
342 * uninitialized bytes; see comment in btrescan(). Valgrind will report
343 * this as an error, but it is safe to ignore.
344 */
346
347 /* copy the item's data onto the page */
348 memcpy((char *) page + upper, item, size);
349
350 /* adjust page header */
351 phdr->pd_lower = (LocationIndex) lower;
352 phdr->pd_upper = (LocationIndex) upper;
353
354 return offsetNumber;
355}
#define SizeOfPageHeaderData
Definition: bufpage.h:217
static bool PageHasFreeLinePointers(const PageData *page)
Definition: bufpage.h:397
static void PageClearHasFreeLinePointers(Page page)
Definition: bufpage.h:407
uint16 LocationIndex
Definition: bufpage.h:91
#define PAI_IS_HEAP
Definition: bufpage.h:465
#define PAI_OVERWRITE
Definition: bufpage.h:464
#define MAXALIGN(LEN)
Definition: c.h:782
size_t Size
Definition: c.h:576
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define WARNING
Definition: elog.h:36
#define PANIC
Definition: elog.h:42
#define elog(elevel,...)
Definition: elog.h:226
#define ereport(elevel,...)
Definition: elog.h:149
#define MaxHeapTuplesPerPage
Definition: htup_details.h:624
struct ItemIdData ItemIdData
#define ItemIdSetNormal(itemId, off, len)
Definition: itemid.h:140
#define ItemIdIsUsed(itemId)
Definition: itemid.h:92
#define ItemIdHasStorage(itemId)
Definition: itemid.h:120
#define VALGRIND_CHECK_MEM_IS_DEFINED(addr, size)
Definition: memdebug.h:23
#define InvalidOffsetNumber
Definition: off.h:26
#define OffsetNumberIsValid(offsetNumber)
Definition: off.h:39
#define OffsetNumberNext(offsetNumber)
Definition: off.h:52
uint16 OffsetNumber
Definition: off.h:24
#define FirstOffsetNumber
Definition: off.h:27
Datum lower(PG_FUNCTION_ARGS)
Definition: oracle_compat.c:49
#define ERRCODE_DATA_CORRUPTED
Definition: pg_basebackup.c:41
LocationIndex pd_lower
Definition: bufpage.h:166

References Assert(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), FirstOffsetNumber, InvalidOffsetNumber, ItemIdHasStorage, ItemIdIsUsed, ItemIdSetNormal, lower(), MAXALIGN, MaxHeapTuplesPerPage, OffsetNumberIsValid, OffsetNumberNext, PageClearHasFreeLinePointers(), PageGetItemId(), PageGetMaxOffsetNumber(), PageHasFreeLinePointers(), PAI_IS_HEAP, PAI_OVERWRITE, PANIC, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, SizeOfPageHeaderData, upper(), VALGRIND_CHECK_MEM_IS_DEFINED, and WARNING.

◆ PageGetExactFreeSpace()

Size PageGetExactFreeSpace ( const PageData page)

Definition at line 957 of file bufpage.c.

958{
959 const PageHeaderData *phdr = (const PageHeaderData *) page;
960 int space;
961
962 /*
963 * Use signed arithmetic here so that we behave sensibly if pd_lower >
964 * pd_upper.
965 */
966 space = (int) phdr->pd_upper - (int) phdr->pd_lower;
967
968 if (space < 0)
969 return 0;
970
971 return (Size) space;
972}

References PageHeaderData::pd_lower, and PageHeaderData::pd_upper.

Referenced by _bt_bottomupdel_pass(), _bt_dedup_pass(), _bt_findsplitloc(), allocNewBuffer(), brin_can_do_samepage_update(), doPickSplit(), GetHashPageStats(), ginHeapTupleFastInsert(), pgstat_heap(), pgstat_index_page(), pgstatindex_impl(), spgAddNodeAction(), SpGistGetBuffer(), SpGistPageAddNewItem(), SpGistSetLastUsedPage(), statapprox_heap(), and writeListPage().

◆ PageGetFreeSpace()

Size PageGetFreeSpace ( const PageData page)

Definition at line 906 of file bufpage.c.

907{
908 const PageHeaderData *phdr = (const PageHeaderData *) page;
909 int space;
910
911 /*
912 * Use signed arithmetic here so that we behave sensibly if pd_lower >
913 * pd_upper.
914 */
915 space = (int) phdr->pd_upper - (int) phdr->pd_lower;
916
917 if (space < (int) sizeof(ItemIdData))
918 return 0;
919 space -= sizeof(ItemIdData);
920
921 return (Size) space;
922}

References PageHeaderData::pd_lower, and PageHeaderData::pd_upper.

Referenced by _bt_buildadd(), _bt_delete_or_dedup_one_page(), _bt_findinsertloc(), _bt_insertonpg(), _bt_search_insert(), _hash_doinsert(), br_page_get_freespace(), entryIsEnoughSpace(), GetBTPageStatistics(), GetHashPageStatistics(), gist_indexsortbuild_levelstate_add(), gistnospace(), heap_xlog_visible(), PageGetHeapFreeSpace(), and terminate_brin_buildstate().

◆ PageGetFreeSpaceForMultipleTuples()

Size PageGetFreeSpaceForMultipleTuples ( const PageData page,
int  ntups 
)

Definition at line 933 of file bufpage.c.

934{
935 const PageHeaderData *phdr = (const PageHeaderData *) page;
936 int space;
937
938 /*
939 * Use signed arithmetic here so that we behave sensibly if pd_lower >
940 * pd_upper.
941 */
942 space = (int) phdr->pd_upper - (int) phdr->pd_lower;
943
944 if (space < (int) (ntups * sizeof(ItemIdData)))
945 return 0;
946 space -= ntups * sizeof(ItemIdData);
947
948 return (Size) space;
949}

References PageHeaderData::pd_lower, and PageHeaderData::pd_upper.

Referenced by _hash_splitbucket(), and _hash_squeezebucket().

◆ PageGetHeapFreeSpace()

Size PageGetHeapFreeSpace ( const PageData page)

Definition at line 990 of file bufpage.c.

991{
992 Size space;
993
994 space = PageGetFreeSpace(page);
995 if (space > 0)
996 {
997 OffsetNumber offnum,
998 nline;
999
1000 /*
1001 * Are there already MaxHeapTuplesPerPage line pointers in the page?
1002 */
1003 nline = PageGetMaxOffsetNumber(page);
1004 if (nline >= MaxHeapTuplesPerPage)
1005 {
1006 if (PageHasFreeLinePointers(page))
1007 {
1008 /*
1009 * Since this is just a hint, we must confirm that there is
1010 * indeed a free line pointer
1011 */
1012 for (offnum = FirstOffsetNumber; offnum <= nline; offnum = OffsetNumberNext(offnum))
1013 {
1014 ItemId lp = PageGetItemId(unconstify(PageData *, page), offnum);
1015
1016 if (!ItemIdIsUsed(lp))
1017 break;
1018 }
1019
1020 if (offnum > nline)
1021 {
1022 /*
1023 * The hint is wrong, but we can't clear it here since we
1024 * don't have the ability to mark the page dirty.
1025 */
1026 space = 0;
1027 }
1028 }
1029 else
1030 {
1031 /*
1032 * Although the hint might be wrong, PageAddItem will believe
1033 * it anyway, so we must believe it too.
1034 */
1035 space = 0;
1036 }
1037 }
1038 }
1039 return space;
1040}
Size PageGetFreeSpace(const PageData *page)
Definition: bufpage.c:906
char PageData
Definition: bufpage.h:81
#define unconstify(underlying_type, expr)
Definition: c.h:1216

References FirstOffsetNumber, ItemIdIsUsed, MaxHeapTuplesPerPage, OffsetNumberNext, PageGetFreeSpace(), PageGetItemId(), PageGetMaxOffsetNumber(), PageHasFreeLinePointers(), and unconstify.

Referenced by heap_multi_insert(), heap_page_prune_opt(), heap_update(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_prune_freeze(), heap_xlog_update(), lazy_scan_heap(), lazy_scan_new_or_empty(), lazy_vacuum_heap_rel(), raw_heap_insert(), and RelationGetBufferForTuple().

◆ PageGetTempPage()

Page PageGetTempPage ( const PageData page)

Definition at line 364 of file bufpage.c.

365{
366 Size pageSize;
367 Page temp;
368
369 pageSize = PageGetPageSize(page);
370 temp = (Page) palloc(pageSize);
371
372 return temp;
373}
static Size PageGetPageSize(const PageData *page)
Definition: bufpage.h:277
PageData * Page
Definition: bufpage.h:82
void * palloc(Size size)
Definition: mcxt.c:1940

References PageGetPageSize(), and palloc().

Referenced by _bt_split(), dataSplitPageInternal(), and ginPlaceToPage().

◆ PageGetTempPageCopy()

Page PageGetTempPageCopy ( const PageData page)

Definition at line 381 of file bufpage.c.

382{
383 Size pageSize;
384 Page temp;
385
386 pageSize = PageGetPageSize(page);
387 temp = (Page) palloc(pageSize);
388
389 memcpy(temp, page, pageSize);
390
391 return temp;
392}

References PageGetPageSize(), and palloc().

Referenced by entrySplitPage(), and ginVacuumEntryPage().

◆ PageGetTempPageCopySpecial()

Page PageGetTempPageCopySpecial ( const PageData page)

Definition at line 401 of file bufpage.c.

402{
403 Size pageSize;
404 Page temp;
405
406 pageSize = PageGetPageSize(page);
407 temp = (Page) palloc(pageSize);
408
409 PageInit(temp, pageSize, PageGetSpecialSize(page));
410 memcpy(PageGetSpecialPointer(temp),
412 PageGetSpecialSize(page));
413
414 return temp;
415}
void PageInit(Page page, Size pageSize, Size specialSize)
Definition: bufpage.c:42
static uint16 PageGetSpecialSize(const PageData *page)
Definition: bufpage.h:317
#define PageGetSpecialPointer(page)
Definition: bufpage.h:339

References PageGetPageSize(), PageGetSpecialPointer, PageGetSpecialSize(), PageInit(), and palloc().

Referenced by _bt_dedup_pass(), btree_xlog_dedup(), btree_xlog_split(), and gistplacetopage().

◆ PageIndexMultiDelete()

void PageIndexMultiDelete ( Page  page,
OffsetNumber itemnos,
int  nitems 
)

Definition at line 1160 of file bufpage.c.

1161{
1162 PageHeader phdr = (PageHeader) page;
1163 Offset pd_lower = phdr->pd_lower;
1164 Offset pd_upper = phdr->pd_upper;
1165 Offset pd_special = phdr->pd_special;
1166 Offset last_offset;
1169 itemIdCompact itemidptr;
1170 ItemId lp;
1171 int nline,
1172 nused;
1173 Size totallen;
1174 Size size;
1175 unsigned offset;
1176 int nextitm;
1177 OffsetNumber offnum;
1178 bool presorted = true; /* For now */
1179
1181
1182 /*
1183 * If there aren't very many items to delete, then retail
1184 * PageIndexTupleDelete is the best way. Delete the items in reverse
1185 * order so we don't have to think about adjusting item numbers for
1186 * previous deletions.
1187 *
1188 * TODO: tune the magic number here
1189 */
1190 if (nitems <= 2)
1191 {
1192 while (--nitems >= 0)
1193 PageIndexTupleDelete(page, itemnos[nitems]);
1194 return;
1195 }
1196
1197 /*
1198 * As with PageRepairFragmentation, paranoia seems justified.
1199 */
1200 if (pd_lower < SizeOfPageHeaderData ||
1201 pd_lower > pd_upper ||
1202 pd_upper > pd_special ||
1203 pd_special > BLCKSZ ||
1204 pd_special != MAXALIGN(pd_special))
1205 ereport(ERROR,
1207 errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
1208 pd_lower, pd_upper, pd_special)));
1209
1210 /*
1211 * Scan the line pointer array and build a list of just the ones we are
1212 * going to keep. Notice we do not modify the page yet, since we are
1213 * still validity-checking.
1214 */
1215 nline = PageGetMaxOffsetNumber(page);
1216 itemidptr = itemidbase;
1217 totallen = 0;
1218 nused = 0;
1219 nextitm = 0;
1220 last_offset = pd_special;
1221 for (offnum = FirstOffsetNumber; offnum <= nline; offnum = OffsetNumberNext(offnum))
1222 {
1223 lp = PageGetItemId(page, offnum);
1225 size = ItemIdGetLength(lp);
1226 offset = ItemIdGetOffset(lp);
1227 if (offset < pd_upper ||
1228 (offset + size) > pd_special ||
1229 offset != MAXALIGN(offset))
1230 ereport(ERROR,
1232 errmsg("corrupted line pointer: offset = %u, size = %u",
1233 offset, (unsigned int) size)));
1234
1235 if (nextitm < nitems && offnum == itemnos[nextitm])
1236 {
1237 /* skip item to be deleted */
1238 nextitm++;
1239 }
1240 else
1241 {
1242 itemidptr->offsetindex = nused; /* where it will go */
1243 itemidptr->itemoff = offset;
1244
1245 if (last_offset > itemidptr->itemoff)
1246 last_offset = itemidptr->itemoff;
1247 else
1248 presorted = false;
1249
1250 itemidptr->alignedlen = MAXALIGN(size);
1251 totallen += itemidptr->alignedlen;
1252 newitemids[nused] = *lp;
1253 itemidptr++;
1254 nused++;
1255 }
1256 }
1257
1258 /* this will catch invalid or out-of-order itemnos[] */
1259 if (nextitm != nitems)
1260 elog(ERROR, "incorrect index offsets supplied");
1261
1262 if (totallen > (Size) (pd_special - pd_lower))
1263 ereport(ERROR,
1265 errmsg("corrupted item lengths: total %u, available space %u",
1266 (unsigned int) totallen, pd_special - pd_lower)));
1267
1268 /*
1269 * Looks good. Overwrite the line pointers with the copy, from which we've
1270 * removed all the unused items.
1271 */
1272 memcpy(phdr->pd_linp, newitemids, nused * sizeof(ItemIdData));
1273 phdr->pd_lower = SizeOfPageHeaderData + nused * sizeof(ItemIdData);
1274
1275 /* and compactify the tuple data */
1276 if (nused > 0)
1277 compactify_tuples(itemidbase, nused, page, presorted);
1278 else
1279 phdr->pd_upper = pd_special;
1280}
static void compactify_tuples(itemIdCompact itemidbase, int nitems, Page page, bool presorted)
Definition: bufpage.c:473
void PageIndexTupleDelete(Page page, OffsetNumber offnum)
Definition: bufpage.c:1051
#define ERROR
Definition: elog.h:39
#define ItemIdGetLength(itemId)
Definition: itemid.h:59
#define ItemIdGetOffset(itemId)
Definition: itemid.h:65
#define MaxIndexTuplesPerPage
Definition: itup.h:181
ItemIdData pd_linp[FLEXIBLE_ARRAY_MEMBER]
Definition: bufpage.h:171

References itemIdCompactData::alignedlen, Assert(), compactify_tuples(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, FirstOffsetNumber, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, itemIdCompactData::itemoff, MAXALIGN, MaxIndexTuplesPerPage, nitems, itemIdCompactData::offsetindex, OffsetNumberNext, PageGetItemId(), PageGetMaxOffsetNumber(), PageIndexTupleDelete(), PageHeaderData::pd_linp, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

Referenced by _bt_delitems_delete(), _bt_delitems_vacuum(), _hash_squeezebucket(), _hash_vacuum_one_page(), btree_xlog_delete(), btree_xlog_vacuum(), gistprunepage(), gistRedoDeleteRecord(), gistRedoPageUpdateRecord(), gistvacuumpage(), hash_xlog_delete(), hash_xlog_move_page_contents(), hash_xlog_vacuum_one_page(), hashbucketcleanup(), spgPageIndexMultiDelete(), spgRedoVacuumRedirect(), spgRedoVacuumRoot(), vacuumLeafRoot(), and vacuumRedirectAndPlaceholder().

◆ PageIndexTupleDelete()

void PageIndexTupleDelete ( Page  page,
OffsetNumber  offnum 
)

Definition at line 1051 of file bufpage.c.

1052{
1053 PageHeader phdr = (PageHeader) page;
1054 char *addr;
1055 ItemId tup;
1056 Size size;
1057 unsigned offset;
1058 int nbytes;
1059 int offidx;
1060 int nline;
1061
1062 /*
1063 * As with PageRepairFragmentation, paranoia seems justified.
1064 */
1065 if (phdr->pd_lower < SizeOfPageHeaderData ||
1066 phdr->pd_lower > phdr->pd_upper ||
1067 phdr->pd_upper > phdr->pd_special ||
1068 phdr->pd_special > BLCKSZ ||
1069 phdr->pd_special != MAXALIGN(phdr->pd_special))
1070 ereport(ERROR,
1072 errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
1073 phdr->pd_lower, phdr->pd_upper, phdr->pd_special)));
1074
1075 nline = PageGetMaxOffsetNumber(page);
1076 if ((int) offnum <= 0 || (int) offnum > nline)
1077 elog(ERROR, "invalid index offnum: %u", offnum);
1078
1079 /* change offset number to offset index */
1080 offidx = offnum - 1;
1081
1082 tup = PageGetItemId(page, offnum);
1084 size = ItemIdGetLength(tup);
1085 offset = ItemIdGetOffset(tup);
1086
1087 if (offset < phdr->pd_upper || (offset + size) > phdr->pd_special ||
1088 offset != MAXALIGN(offset))
1089 ereport(ERROR,
1091 errmsg("corrupted line pointer: offset = %u, size = %u",
1092 offset, (unsigned int) size)));
1093
1094 /* Amount of space to actually be deleted */
1095 size = MAXALIGN(size);
1096
1097 /*
1098 * First, we want to get rid of the pd_linp entry for the index tuple. We
1099 * copy all subsequent linp's back one slot in the array. We don't use
1100 * PageGetItemId, because we are manipulating the _array_, not individual
1101 * linp's.
1102 */
1103 nbytes = phdr->pd_lower -
1104 ((char *) &phdr->pd_linp[offidx + 1] - (char *) phdr);
1105
1106 if (nbytes > 0)
1107 memmove(&(phdr->pd_linp[offidx]),
1108 &(phdr->pd_linp[offidx + 1]),
1109 nbytes);
1110
1111 /*
1112 * Now move everything between the old upper bound (beginning of tuple
1113 * space) and the beginning of the deleted tuple forward, so that space in
1114 * the middle of the page is left free. If we've just deleted the tuple
1115 * at the beginning of tuple space, then there's no need to do the copy.
1116 */
1117
1118 /* beginning of tuple space */
1119 addr = (char *) page + phdr->pd_upper;
1120
1121 if (offset > phdr->pd_upper)
1122 memmove(addr + size, addr, offset - phdr->pd_upper);
1123
1124 /* adjust free space boundary pointers */
1125 phdr->pd_upper += size;
1126 phdr->pd_lower -= sizeof(ItemIdData);
1127
1128 /*
1129 * Finally, we need to adjust the linp entries that remain.
1130 *
1131 * Anything that used to be before the deleted tuple's data was moved
1132 * forward by the size of the deleted tuple.
1133 */
1134 if (!PageIsEmpty(page))
1135 {
1136 int i;
1137
1138 nline--; /* there's one less than when we started */
1139 for (i = 1; i <= nline; i++)
1140 {
1141 ItemId ii = PageGetItemId(page, i);
1142
1144 if (ItemIdGetOffset(ii) <= offset)
1145 ii->lp_off += size;
1146 }
1147 }
1148}
static bool PageIsEmpty(const PageData *page)
Definition: bufpage.h:224
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81

References Assert(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, i, if(), ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdData::lp_off, MAXALIGN, PageGetItemId(), PageGetMaxOffsetNumber(), PageIsEmpty(), PageHeaderData::pd_linp, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

Referenced by _bt_mark_page_halfdead(), addLeafTuple(), addOrReplaceTuple(), btree_xlog_mark_page_halfdead(), entryPreparePage(), ginRedoInsertEntry(), ginVacuumEntryPage(), gistdeletepage(), gistplacetopage(), gistRedoPageDelete(), PageIndexMultiDelete(), spgAddNodeAction(), SpGistPageAddNewItem(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoSplitTuple(), and spgSplitNodeAction().

◆ PageIndexTupleDeleteNoCompact()

void PageIndexTupleDeleteNoCompact ( Page  page,
OffsetNumber  offnum 
)

Definition at line 1294 of file bufpage.c.

1295{
1296 PageHeader phdr = (PageHeader) page;
1297 char *addr;
1298 ItemId tup;
1299 Size size;
1300 unsigned offset;
1301 int nline;
1302
1303 /*
1304 * As with PageRepairFragmentation, paranoia seems justified.
1305 */
1306 if (phdr->pd_lower < SizeOfPageHeaderData ||
1307 phdr->pd_lower > phdr->pd_upper ||
1308 phdr->pd_upper > phdr->pd_special ||
1309 phdr->pd_special > BLCKSZ ||
1310 phdr->pd_special != MAXALIGN(phdr->pd_special))
1311 ereport(ERROR,
1313 errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
1314 phdr->pd_lower, phdr->pd_upper, phdr->pd_special)));
1315
1316 nline = PageGetMaxOffsetNumber(page);
1317 if ((int) offnum <= 0 || (int) offnum > nline)
1318 elog(ERROR, "invalid index offnum: %u", offnum);
1319
1320 tup = PageGetItemId(page, offnum);
1322 size = ItemIdGetLength(tup);
1323 offset = ItemIdGetOffset(tup);
1324
1325 if (offset < phdr->pd_upper || (offset + size) > phdr->pd_special ||
1326 offset != MAXALIGN(offset))
1327 ereport(ERROR,
1329 errmsg("corrupted line pointer: offset = %u, size = %u",
1330 offset, (unsigned int) size)));
1331
1332 /* Amount of space to actually be deleted */
1333 size = MAXALIGN(size);
1334
1335 /*
1336 * Either set the line pointer to "unused", or zap it if it's the last
1337 * one. (Note: it's possible that the next-to-last one(s) are already
1338 * unused, but we do not trouble to try to compact them out if so.)
1339 */
1340 if ((int) offnum < nline)
1341 ItemIdSetUnused(tup);
1342 else
1343 {
1344 phdr->pd_lower -= sizeof(ItemIdData);
1345 nline--; /* there's one less than when we started */
1346 }
1347
1348 /*
1349 * Now move everything between the old upper bound (beginning of tuple
1350 * space) and the beginning of the deleted tuple forward, so that space in
1351 * the middle of the page is left free. If we've just deleted the tuple
1352 * at the beginning of tuple space, then there's no need to do the copy.
1353 */
1354
1355 /* beginning of tuple space */
1356 addr = (char *) page + phdr->pd_upper;
1357
1358 if (offset > phdr->pd_upper)
1359 memmove(addr + size, addr, offset - phdr->pd_upper);
1360
1361 /* adjust free space boundary pointer */
1362 phdr->pd_upper += size;
1363
1364 /*
1365 * Finally, we need to adjust the linp entries that remain.
1366 *
1367 * Anything that used to be before the deleted tuple's data was moved
1368 * forward by the size of the deleted tuple.
1369 */
1370 if (!PageIsEmpty(page))
1371 {
1372 int i;
1373
1374 for (i = 1; i <= nline; i++)
1375 {
1376 ItemId ii = PageGetItemId(page, i);
1377
1378 if (ItemIdHasStorage(ii) && ItemIdGetOffset(ii) <= offset)
1379 ii->lp_off += size;
1380 }
1381 }
1382}
#define ItemIdSetUnused(itemId)
Definition: itemid.h:128

References Assert(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, i, if(), ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdSetUnused, ItemIdData::lp_off, MAXALIGN, PageGetItemId(), PageGetMaxOffsetNumber(), PageIsEmpty(), PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

Referenced by brin_doupdate(), brin_xlog_desummarize_page(), brin_xlog_update(), and brinRevmapDesummarizeRange().

◆ PageIndexTupleOverwrite()

bool PageIndexTupleOverwrite ( Page  page,
OffsetNumber  offnum,
Item  newtup,
Size  newsize 
)

Definition at line 1404 of file bufpage.c.

1406{
1407 PageHeader phdr = (PageHeader) page;
1408 ItemId tupid;
1409 int oldsize;
1410 unsigned offset;
1411 Size alignednewsize;
1412 int size_diff;
1413 int itemcount;
1414
1415 /*
1416 * As with PageRepairFragmentation, paranoia seems justified.
1417 */
1418 if (phdr->pd_lower < SizeOfPageHeaderData ||
1419 phdr->pd_lower > phdr->pd_upper ||
1420 phdr->pd_upper > phdr->pd_special ||
1421 phdr->pd_special > BLCKSZ ||
1422 phdr->pd_special != MAXALIGN(phdr->pd_special))
1423 ereport(ERROR,
1425 errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
1426 phdr->pd_lower, phdr->pd_upper, phdr->pd_special)));
1427
1428 itemcount = PageGetMaxOffsetNumber(page);
1429 if ((int) offnum <= 0 || (int) offnum > itemcount)
1430 elog(ERROR, "invalid index offnum: %u", offnum);
1431
1432 tupid = PageGetItemId(page, offnum);
1433 Assert(ItemIdHasStorage(tupid));
1434 oldsize = ItemIdGetLength(tupid);
1435 offset = ItemIdGetOffset(tupid);
1436
1437 if (offset < phdr->pd_upper || (offset + oldsize) > phdr->pd_special ||
1438 offset != MAXALIGN(offset))
1439 ereport(ERROR,
1441 errmsg("corrupted line pointer: offset = %u, size = %u",
1442 offset, (unsigned int) oldsize)));
1443
1444 /*
1445 * Determine actual change in space requirement, check for page overflow.
1446 */
1447 oldsize = MAXALIGN(oldsize);
1448 alignednewsize = MAXALIGN(newsize);
1449 if (alignednewsize > oldsize + (phdr->pd_upper - phdr->pd_lower))
1450 return false;
1451
1452 /*
1453 * Relocate existing data and update line pointers, unless the new tuple
1454 * is the same size as the old (after alignment), in which case there's
1455 * nothing to do. Notice that what we have to relocate is data before the
1456 * target tuple, not data after, so it's convenient to express size_diff
1457 * as the amount by which the tuple's size is decreasing, making it the
1458 * delta to add to pd_upper and affected line pointers.
1459 */
1460 size_diff = oldsize - (int) alignednewsize;
1461 if (size_diff != 0)
1462 {
1463 char *addr = (char *) page + phdr->pd_upper;
1464 int i;
1465
1466 /* relocate all tuple data before the target tuple */
1467 memmove(addr + size_diff, addr, offset - phdr->pd_upper);
1468
1469 /* adjust free space boundary pointer */
1470 phdr->pd_upper += size_diff;
1471
1472 /* adjust affected line pointers too */
1473 for (i = FirstOffsetNumber; i <= itemcount; i++)
1474 {
1475 ItemId ii = PageGetItemId(page, i);
1476
1477 /* Allow items without storage; currently only BRIN needs that */
1478 if (ItemIdHasStorage(ii) && ItemIdGetOffset(ii) <= offset)
1479 ii->lp_off += size_diff;
1480 }
1481 }
1482
1483 /* Update the item's tuple length without changing its lp_flags field */
1484 tupid->lp_off = offset + size_diff;
1485 tupid->lp_len = newsize;
1486
1487 /* Copy new tuple data onto page */
1488 memcpy(PageGetItem(page, tupid), newtup, newsize);
1489
1490 return true;
1491}
static Item PageGetItem(const PageData *page, const ItemIdData *itemId)
Definition: bufpage.h:354
unsigned lp_len
Definition: itemid.h:29

References Assert(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, FirstOffsetNumber, i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdData::lp_len, ItemIdData::lp_off, MAXALIGN, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

Referenced by _bt_buildadd(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_mark_page_halfdead(), brin_doupdate(), brin_xlog_samepage_update(), btree_xlog_updates(), gistplacetopage(), and gistRedoPageUpdateRecord().

◆ PageInit()

void PageInit ( Page  page,
Size  pageSize,
Size  specialSize 
)

Definition at line 42 of file bufpage.c.

43{
44 PageHeader p = (PageHeader) page;
45
46 specialSize = MAXALIGN(specialSize);
47
48 Assert(pageSize == BLCKSZ);
49 Assert(pageSize > specialSize + SizeOfPageHeaderData);
50
51 /* Make sure all fields of page are zero, as well as unused space */
52 MemSet(p, 0, pageSize);
53
54 p->pd_flags = 0;
56 p->pd_upper = pageSize - specialSize;
57 p->pd_special = pageSize - specialSize;
59 /* p->pd_prune_xid = InvalidTransactionId; done by above MemSet */
60}
#define PG_PAGE_LAYOUT_VERSION
Definition: bufpage.h:206
static void PageSetPageSizeAndVersion(Page page, Size size, uint8 version)
Definition: bufpage.h:300
#define MemSet(start, val, len)
Definition: c.h:991
uint16 pd_flags
Definition: bufpage.h:165

References Assert(), MAXALIGN, MemSet, PageSetPageSizeAndVersion(), PageHeaderData::pd_flags, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, PG_PAGE_LAYOUT_VERSION, and SizeOfPageHeaderData.

Referenced by _bt_pageinit(), _hash_pageinit(), BloomInitPage(), brin_page_init(), fill_seq_fork_with_data(), fsm_readbuf(), GinInitPage(), gistinitpage(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), heap_xlog_visible(), modify_rel_block(), PageGetTempPageCopySpecial(), raw_heap_insert(), RelationAddBlocks(), RelationGetBufferForTuple(), seq_redo(), SpGistInitPage(), vm_readbuf(), and XLogRecordPageWithFreeSpace().

◆ PageIsVerified()

bool PageIsVerified ( PageData page,
BlockNumber  blkno,
int  flags,
bool *  checksum_failure_p 
)

Definition at line 94 of file bufpage.c.

95{
96 const PageHeaderData *p = (const PageHeaderData *) page;
97 size_t *pagebytes;
98 bool checksum_failure = false;
99 bool header_sane = false;
100 uint16 checksum = 0;
101
102 if (checksum_failure_p)
103 *checksum_failure_p = false;
104
105 /*
106 * Don't verify page data unless the page passes basic non-zero test
107 */
108 if (!PageIsNew(page))
109 {
111 {
112 checksum = pg_checksum_page(page, blkno);
113
114 if (checksum != p->pd_checksum)
115 {
116 checksum_failure = true;
117 if (checksum_failure_p)
118 *checksum_failure_p = true;
119 }
120 }
121
122 /*
123 * The following checks don't prove the header is correct, only that
124 * it looks sane enough to allow into the buffer pool. Later usage of
125 * the block can still reveal problems, which is why we offer the
126 * checksum option.
127 */
128 if ((p->pd_flags & ~PD_VALID_FLAG_BITS) == 0 &&
129 p->pd_lower <= p->pd_upper &&
130 p->pd_upper <= p->pd_special &&
131 p->pd_special <= BLCKSZ &&
133 header_sane = true;
134
135 if (header_sane && !checksum_failure)
136 return true;
137 }
138
139 /* Check all-zeroes case */
140 pagebytes = (size_t *) page;
141
142 if (pg_memory_is_all_zeros(pagebytes, BLCKSZ))
143 return true;
144
145 /*
146 * Throw a WARNING/LOG, as instructed by PIV_LOG_*, if the checksum fails,
147 * but only after we've checked for the all-zeroes case.
148 */
150 {
151 if ((flags & (PIV_LOG_WARNING | PIV_LOG_LOG)) != 0)
154 errmsg("page verification failed, calculated checksum %u but expected %u",
155 checksum, p->pd_checksum)));
156
157 if (header_sane && (flags & PIV_IGNORE_CHECKSUM_FAILURE))
158 return true;
159 }
160
161 return false;
162}
#define PD_VALID_FLAG_BITS
Definition: bufpage.h:192
#define PIV_LOG_LOG
Definition: bufpage.h:469
#define PIV_LOG_WARNING
Definition: bufpage.h:468
static bool PageIsNew(const PageData *page)
Definition: bufpage.h:234
#define PIV_IGNORE_CHECKSUM_FAILURE
Definition: bufpage.h:470
uint16_t uint16
Definition: c.h:501
uint16 pg_checksum_page(char *page, BlockNumber blkno)
#define LOG
Definition: elog.h:31
static bool pg_memory_is_all_zeros(const void *ptr, size_t len)
Definition: memutils.h:239
static bool checksum_failure
uint16 pd_checksum
Definition: bufpage.h:164
bool DataChecksumsEnabled(void)
Definition: xlog.c:4754

References checksum_failure, DataChecksumsEnabled(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), LOG, MAXALIGN, PageIsNew(), PageHeaderData::pd_checksum, PageHeaderData::pd_flags, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, PD_VALID_FLAG_BITS, pg_checksum_page(), pg_memory_is_all_zeros(), PIV_IGNORE_CHECKSUM_FAILURE, PIV_LOG_LOG, PIV_LOG_WARNING, and WARNING.

Referenced by buffer_readv_complete_one(), and RelationCopyStorage().

◆ PageRepairFragmentation()

void PageRepairFragmentation ( Page  page)

Definition at line 698 of file bufpage.c.

699{
700 Offset pd_lower = ((PageHeader) page)->pd_lower;
701 Offset pd_upper = ((PageHeader) page)->pd_upper;
702 Offset pd_special = ((PageHeader) page)->pd_special;
703 Offset last_offset;
705 itemIdCompact itemidptr;
706 ItemId lp;
707 int nline,
708 nstorage,
709 nunused;
710 OffsetNumber finalusedlp = InvalidOffsetNumber;
711 int i;
712 Size totallen;
713 bool presorted = true; /* For now */
714
715 /*
716 * It's worth the trouble to be more paranoid here than in most places,
717 * because we are about to reshuffle data in (what is usually) a shared
718 * disk buffer. If we aren't careful then corrupted pointers, lengths,
719 * etc could cause us to clobber adjacent disk buffers, spreading the data
720 * loss further. So, check everything.
721 */
722 if (pd_lower < SizeOfPageHeaderData ||
723 pd_lower > pd_upper ||
724 pd_upper > pd_special ||
725 pd_special > BLCKSZ ||
726 pd_special != MAXALIGN(pd_special))
729 errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
730 pd_lower, pd_upper, pd_special)));
731
732 /*
733 * Run through the line pointer array and collect data about live items.
734 */
735 nline = PageGetMaxOffsetNumber(page);
736 itemidptr = itemidbase;
737 nunused = totallen = 0;
738 last_offset = pd_special;
739 for (i = FirstOffsetNumber; i <= nline; i++)
740 {
741 lp = PageGetItemId(page, i);
742 if (ItemIdIsUsed(lp))
743 {
744 if (ItemIdHasStorage(lp))
745 {
746 itemidptr->offsetindex = i - 1;
747 itemidptr->itemoff = ItemIdGetOffset(lp);
748
749 if (last_offset > itemidptr->itemoff)
750 last_offset = itemidptr->itemoff;
751 else
752 presorted = false;
753
754 if (unlikely(itemidptr->itemoff < (int) pd_upper ||
755 itemidptr->itemoff >= (int) pd_special))
758 errmsg("corrupted line pointer: %u",
759 itemidptr->itemoff)));
760 itemidptr->alignedlen = MAXALIGN(ItemIdGetLength(lp));
761 totallen += itemidptr->alignedlen;
762 itemidptr++;
763 }
764
765 finalusedlp = i; /* Could be the final non-LP_UNUSED item */
766 }
767 else
768 {
769 /* Unused entries should have lp_len = 0, but make sure */
771 ItemIdSetUnused(lp);
772 nunused++;
773 }
774 }
775
776 nstorage = itemidptr - itemidbase;
777 if (nstorage == 0)
778 {
779 /* Page is completely empty, so just reset it quickly */
780 ((PageHeader) page)->pd_upper = pd_special;
781 }
782 else
783 {
784 /* Need to compact the page the hard way */
785 if (totallen > (Size) (pd_special - pd_lower))
788 errmsg("corrupted item lengths: total %u, available space %u",
789 (unsigned int) totallen, pd_special - pd_lower)));
790
791 compactify_tuples(itemidbase, nstorage, page, presorted);
792 }
793
794 if (finalusedlp != nline)
795 {
796 /* The last line pointer is not the last used line pointer */
797 int nunusedend = nline - finalusedlp;
798
799 Assert(nunused >= nunusedend && nunusedend > 0);
800
801 /* remove trailing unused line pointers from the count */
802 nunused -= nunusedend;
803 /* truncate the line pointer array */
804 ((PageHeader) page)->pd_lower -= (sizeof(ItemIdData) * nunusedend);
805 }
806
807 /* Set hint bit for PageAddItemExtended */
808 if (nunused > 0)
810 else
812}
static void PageSetHasFreeLinePointers(Page page)
Definition: bufpage.h:402
#define unlikely(x)
Definition: c.h:347

References itemIdCompactData::alignedlen, Assert(), compactify_tuples(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, FirstOffsetNumber, i, InvalidOffsetNumber, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdIsUsed, ItemIdSetUnused, itemIdCompactData::itemoff, MAXALIGN, MaxHeapTuplesPerPage, itemIdCompactData::offsetindex, PageClearHasFreeLinePointers(), PageGetItemId(), PageGetMaxOffsetNumber(), PageSetHasFreeLinePointers(), SizeOfPageHeaderData, and unlikely.

Referenced by heap_page_prune_execute().

◆ PageRestoreTempPage()

void PageRestoreTempPage ( Page  tempPage,
Page  oldPage 
)

Definition at line 423 of file bufpage.c.

424{
425 Size pageSize;
426
427 pageSize = PageGetPageSize(tempPage);
428 memcpy(oldPage, tempPage, pageSize);
429
430 pfree(tempPage);
431}
void pfree(void *pointer)
Definition: mcxt.c:2147

References PageGetPageSize(), and pfree().

Referenced by _bt_dedup_pass(), _bt_split(), btree_xlog_dedup(), btree_xlog_split(), createPostingTree(), ginbulkdelete(), and gistplacetopage().

◆ PageSetChecksumCopy()

char * PageSetChecksumCopy ( Page  page,
BlockNumber  blkno 
)

Definition at line 1509 of file bufpage.c.

1510{
1511 static char *pageCopy = NULL;
1512
1513 /* If we don't need a checksum, just return the passed-in data */
1514 if (PageIsNew(page) || !DataChecksumsEnabled())
1515 return page;
1516
1517 /*
1518 * We allocate the copy space once and use it over on each subsequent
1519 * call. The point of palloc'ing here, rather than having a static char
1520 * array, is first to ensure adequate alignment for the checksumming code
1521 * and second to avoid wasting space in processes that never call this.
1522 */
1523 if (pageCopy == NULL)
1525 BLCKSZ,
1527 0);
1528
1529 memcpy(pageCopy, page, BLCKSZ);
1530 ((PageHeader) pageCopy)->pd_checksum = pg_checksum_page(pageCopy, blkno);
1531 return pageCopy;
1532}
void * MemoryContextAllocAligned(MemoryContext context, Size size, Size alignto, int flags)
Definition: mcxt.c:2035
MemoryContext TopMemoryContext
Definition: mcxt.c:165
#define PG_IO_ALIGN_SIZE

References DataChecksumsEnabled(), MemoryContextAllocAligned(), PageIsNew(), pg_checksum_page(), PG_IO_ALIGN_SIZE, and TopMemoryContext.

Referenced by FlushBuffer().

◆ PageSetChecksumInplace()

void PageSetChecksumInplace ( Page  page,
BlockNumber  blkno 
)

Definition at line 1541 of file bufpage.c.

1542{
1543 /* If we don't need a checksum, just return */
1544 if (PageIsNew(page) || !DataChecksumsEnabled())
1545 return;
1546
1547 ((PageHeader) page)->pd_checksum = pg_checksum_page(page, blkno);
1548}

References DataChecksumsEnabled(), PageIsNew(), and pg_checksum_page().

Referenced by _hash_alloc_buckets(), FlushLocalBuffer(), modify_rel_block(), and smgr_bulk_flush().

◆ PageTruncateLinePointerArray()

void PageTruncateLinePointerArray ( Page  page)

Definition at line 834 of file bufpage.c.

835{
836 PageHeader phdr = (PageHeader) page;
837 bool countdone = false,
838 sethint = false;
839 int nunusedend = 0;
840
841 /* Scan line pointer array back-to-front */
842 for (int i = PageGetMaxOffsetNumber(page); i >= FirstOffsetNumber; i--)
843 {
844 ItemId lp = PageGetItemId(page, i);
845
846 if (!countdone && i > FirstOffsetNumber)
847 {
848 /*
849 * Still determining which line pointers from the end of the array
850 * will be truncated away. Either count another line pointer as
851 * safe to truncate, or notice that it's not safe to truncate
852 * additional line pointers (stop counting line pointers).
853 */
854 if (!ItemIdIsUsed(lp))
855 nunusedend++;
856 else
857 countdone = true;
858 }
859 else
860 {
861 /*
862 * Once we've stopped counting we still need to figure out if
863 * there are any remaining LP_UNUSED line pointers somewhere more
864 * towards the front of the array.
865 */
866 if (!ItemIdIsUsed(lp))
867 {
868 /*
869 * This is an unused line pointer that we won't be truncating
870 * away -- so there is at least one. Set hint on page.
871 */
872 sethint = true;
873 break;
874 }
875 }
876 }
877
878 if (nunusedend > 0)
879 {
880 phdr->pd_lower -= sizeof(ItemIdData) * nunusedend;
881
882#ifdef CLOBBER_FREED_MEMORY
883 memset((char *) page + phdr->pd_lower, 0x7F,
884 sizeof(ItemIdData) * nunusedend);
885#endif
886 }
887 else
888 Assert(sethint);
889
890 /* Set hint bit for PageAddItemExtended */
891 if (sethint)
893 else
895}

References Assert(), FirstOffsetNumber, i, ItemIdIsUsed, PageClearHasFreeLinePointers(), PageGetItemId(), PageGetMaxOffsetNumber(), PageSetHasFreeLinePointers(), and PageHeaderData::pd_lower.

Referenced by heap_page_prune_execute(), and lazy_vacuum_heap_page().

Variable Documentation

◆ ignore_checksum_failure

bool ignore_checksum_failure = false

Definition at line 27 of file bufpage.c.

Referenced by AsyncReadBuffers(), read_rel_block_ll(), and RelationCopyStorage().