PostgreSQL Source Code  git master
heap_surgery.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * heap_surgery.c
4  * Functions to perform surgery on the damaged heap table.
5  *
6  * Copyright (c) 2020-2021, PostgreSQL Global Development Group
7  *
8  * IDENTIFICATION
9  * contrib/pg_surgery/heap_surgery.c
10  *
11  *-------------------------------------------------------------------------
12  */
13 #include "postgres.h"
14 
15 #include "access/heapam.h"
16 #include "access/visibilitymap.h"
17 #include "catalog/pg_am_d.h"
18 #include "catalog/pg_proc_d.h"
19 #include "miscadmin.h"
20 #include "storage/bufmgr.h"
21 #include "utils/acl.h"
22 #include "utils/rel.h"
23 
25 
26 /* Options to forcefully change the state of a heap tuple. */
28 {
32 
35 
36 static int32 tidcmp(const void *a, const void *b);
38  HeapTupleForceOption heap_force_opt);
39 static void sanity_check_tid_array(ArrayType *ta, int *ntids);
40 static BlockNumber find_tids_one_page(ItemPointer tids, int ntids,
41  OffsetNumber *next_start_ptr);
42 
43 /*-------------------------------------------------------------------------
44  * heap_force_kill()
45  *
46  * Force kill the tuple(s) pointed to by the item pointer(s) stored in the
47  * given TID array.
48  *
49  * Usage: SELECT heap_force_kill(regclass, tid[]);
50  *-------------------------------------------------------------------------
51  */
52 Datum
54 {
56 }
57 
58 /*-------------------------------------------------------------------------
59  * heap_force_freeze()
60  *
61  * Force freeze the tuple(s) pointed to by the item pointer(s) stored in the
62  * given TID array.
63  *
64  * Usage: SELECT heap_force_freeze(regclass, tid[]);
65  *-------------------------------------------------------------------------
66  */
67 Datum
69 {
71 }
72 
73 /*-------------------------------------------------------------------------
74  * heap_force_common()
75  *
76  * Common code for heap_force_kill and heap_force_freeze
77  *-------------------------------------------------------------------------
78  */
79 static Datum
81 {
82  Oid relid = PG_GETARG_OID(0);
84  ItemPointer tids;
85  int ntids,
86  nblocks;
87  Relation rel;
88  OffsetNumber curr_start_ptr,
89  next_start_ptr;
90  bool include_this_tid[MaxHeapTuplesPerPage];
91 
92  if (RecoveryInProgress())
93  ereport(ERROR,
94  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
95  errmsg("recovery is in progress"),
96  errhint("heap surgery functions cannot be executed during recovery.")));
97 
98  /* Check inputs. */
99  sanity_check_tid_array(ta, &ntids);
100 
101  rel = relation_open(relid, RowExclusiveLock);
102 
103  /*
104  * Check target relation.
105  */
106  if (rel->rd_rel->relkind != RELKIND_RELATION &&
107  rel->rd_rel->relkind != RELKIND_MATVIEW &&
108  rel->rd_rel->relkind != RELKIND_TOASTVALUE)
109  ereport(ERROR,
110  (errcode(ERRCODE_WRONG_OBJECT_TYPE),
111  errmsg("cannot operate on relation \"%s\"",
113  errdetail_relkind_not_supported(rel->rd_rel->relkind)));
114 
115  if (rel->rd_rel->relam != HEAP_TABLE_AM_OID)
116  ereport(ERROR,
117  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
118  errmsg("only heap AM is supported")));
119 
120  /* Must be owner of the table or superuser. */
123  get_relkind_objtype(rel->rd_rel->relkind),
125 
126  tids = ((ItemPointer) ARR_DATA_PTR(ta));
127 
128  /*
129  * If there is more than one TID in the array, sort them so that we can
130  * easily fetch all the TIDs belonging to one particular page from the
131  * array.
132  */
133  if (ntids > 1)
134  qsort((void *) tids, ntids, sizeof(ItemPointerData), tidcmp);
135 
136  curr_start_ptr = next_start_ptr = 0;
137  nblocks = RelationGetNumberOfBlocks(rel);
138 
139  /*
140  * Loop, performing the necessary actions for each block.
141  */
142  while (next_start_ptr != ntids)
143  {
144  Buffer buf;
145  Buffer vmbuf = InvalidBuffer;
146  Page page;
147  BlockNumber blkno;
148  OffsetNumber curoff;
149  OffsetNumber maxoffset;
150  int i;
151  bool did_modify_page = false;
152  bool did_modify_vm = false;
153 
155 
156  /*
157  * Find all the TIDs belonging to one particular page starting from
158  * next_start_ptr and process them one by one.
159  */
160  blkno = find_tids_one_page(tids, ntids, &next_start_ptr);
161 
162  /* Check whether the block number is valid. */
163  if (blkno >= nblocks)
164  {
165  /* Update the current_start_ptr before moving to the next page. */
166  curr_start_ptr = next_start_ptr;
167 
168  ereport(NOTICE,
169  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
170  errmsg("skipping block %u for relation \"%s\" because the block number is out of range",
171  blkno, RelationGetRelationName(rel))));
172  continue;
173  }
174 
175  buf = ReadBuffer(rel, blkno);
177 
178  page = BufferGetPage(buf);
179 
180  maxoffset = PageGetMaxOffsetNumber(page);
181 
182  /*
183  * Figure out which TIDs we are going to process and which ones we are
184  * going to skip.
185  */
186  memset(include_this_tid, 0, sizeof(include_this_tid));
187  for (i = curr_start_ptr; i < next_start_ptr; i++)
188  {
190  ItemId itemid;
191 
192  /* Check whether the offset number is valid. */
193  if (offno == InvalidOffsetNumber || offno > maxoffset)
194  {
195  ereport(NOTICE,
196  errmsg("skipping tid (%u, %u) for relation \"%s\" because the item number is out of range",
197  blkno, offno, RelationGetRelationName(rel)));
198  continue;
199  }
200 
201  itemid = PageGetItemId(page, offno);
202 
203  /* Only accept an item ID that is used. */
204  if (ItemIdIsRedirected(itemid))
205  {
206  ereport(NOTICE,
207  errmsg("skipping tid (%u, %u) for relation \"%s\" because it redirects to item %u",
208  blkno, offno, RelationGetRelationName(rel),
209  ItemIdGetRedirect(itemid)));
210  continue;
211  }
212  else if (ItemIdIsDead(itemid))
213  {
214  ereport(NOTICE,
215  (errmsg("skipping tid (%u, %u) for relation \"%s\" because it is marked dead",
216  blkno, offno, RelationGetRelationName(rel))));
217  continue;
218  }
219  else if (!ItemIdIsUsed(itemid))
220  {
221  ereport(NOTICE,
222  (errmsg("skipping tid (%u, %u) for relation \"%s\" because it is marked unused",
223  blkno, offno, RelationGetRelationName(rel))));
224  continue;
225  }
226 
227  /* Mark it for processing. */
228  Assert(offno < MaxHeapTuplesPerPage);
229  include_this_tid[offno] = true;
230  }
231 
232  /*
233  * Before entering the critical section, pin the visibility map page
234  * if it appears to be necessary.
235  */
236  if (heap_force_opt == HEAP_FORCE_KILL && PageIsAllVisible(page))
237  visibilitymap_pin(rel, blkno, &vmbuf);
238 
239  /* No ereport(ERROR) from here until all the changes are logged. */
241 
242  for (curoff = FirstOffsetNumber; curoff <= maxoffset;
243  curoff = OffsetNumberNext(curoff))
244  {
245  ItemId itemid;
246 
247  if (!include_this_tid[curoff])
248  continue;
249 
250  itemid = PageGetItemId(page, curoff);
251  Assert(ItemIdIsNormal(itemid));
252 
253  did_modify_page = true;
254 
255  if (heap_force_opt == HEAP_FORCE_KILL)
256  {
257  ItemIdSetDead(itemid);
258 
259  /*
260  * If the page is marked all-visible, we must clear
261  * PD_ALL_VISIBLE flag on the page header and an all-visible
262  * bit on the visibility map corresponding to the page.
263  */
264  if (PageIsAllVisible(page))
265  {
266  PageClearAllVisible(page);
267  visibilitymap_clear(rel, blkno, vmbuf,
269  did_modify_vm = true;
270  }
271  }
272  else
273  {
274  HeapTupleHeader htup;
275 
276  Assert(heap_force_opt == HEAP_FORCE_FREEZE);
277 
278  htup = (HeapTupleHeader) PageGetItem(page, itemid);
279 
280  /*
281  * Reset all visibility-related fields of the tuple. This
282  * logic should mimic heap_execute_freeze_tuple(), but we
283  * choose to reset xmin and ctid just to be sure that no
284  * potentially-garbled data is left behind.
285  */
286  ItemPointerSet(&htup->t_ctid, blkno, curoff);
289  if (htup->t_infomask & HEAP_MOVED)
290  {
291  if (htup->t_infomask & HEAP_MOVED_OFF)
293  else
295  }
296 
297  /*
298  * Clear all the visibility-related bits of this tuple and
299  * mark it as frozen. Also, get rid of HOT_UPDATED and
300  * KEYS_UPDATES bits.
301  */
302  htup->t_infomask &= ~HEAP_XACT_MASK;
304  htup->t_infomask2 &= ~HEAP_HOT_UPDATED;
305  htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
306  }
307  }
308 
309  /*
310  * If the page was modified, only then, we mark the buffer dirty or do
311  * the WAL logging.
312  */
313  if (did_modify_page)
314  {
315  /* Mark buffer dirty before we write WAL. */
316  MarkBufferDirty(buf);
317 
318  /* XLOG stuff */
319  if (RelationNeedsWAL(rel))
320  log_newpage_buffer(buf, true);
321  }
322 
323  /* WAL log the VM page if it was modified. */
324  if (did_modify_vm && RelationNeedsWAL(rel))
325  log_newpage_buffer(vmbuf, false);
326 
328 
329  UnlockReleaseBuffer(buf);
330 
331  if (vmbuf != InvalidBuffer)
332  ReleaseBuffer(vmbuf);
333 
334  /* Update the current_start_ptr before moving to the next page. */
335  curr_start_ptr = next_start_ptr;
336  }
337 
339 
340  pfree(ta);
341 
342  PG_RETURN_VOID();
343 }
344 
345 /*-------------------------------------------------------------------------
346  * tidcmp()
347  *
348  * Compare two item pointers, return -1, 0, or +1.
349  *
350  * See ItemPointerCompare for details.
351  * ------------------------------------------------------------------------
352  */
353 static int32
354 tidcmp(const void *a, const void *b)
355 {
356  ItemPointer iptr1 = ((const ItemPointer) a);
357  ItemPointer iptr2 = ((const ItemPointer) b);
358 
359  return ItemPointerCompare(iptr1, iptr2);
360 }
361 
362 /*-------------------------------------------------------------------------
363  * sanity_check_tid_array()
364  *
365  * Perform sanity checks on the given tid array, and set *ntids to the
366  * number of items in the array.
367  * ------------------------------------------------------------------------
368  */
369 static void
371 {
372  if (ARR_HASNULL(ta) && array_contains_nulls(ta))
373  ereport(ERROR,
374  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
375  errmsg("array must not contain nulls")));
376 
377  if (ARR_NDIM(ta) > 1)
378  ereport(ERROR,
379  (errcode(ERRCODE_DATA_EXCEPTION),
380  errmsg("argument must be empty or one-dimensional array")));
381 
382  *ntids = ArrayGetNItems(ARR_NDIM(ta), ARR_DIMS(ta));
383 }
384 
385 /*-------------------------------------------------------------------------
386  * find_tids_one_page()
387  *
388  * Find all the tids residing in the same page as tids[next_start_ptr], and
389  * update next_start_ptr so that it points to the first tid in the next page.
390  *
391  * NOTE: The input tids[] array must be sorted.
392  * ------------------------------------------------------------------------
393  */
394 static BlockNumber
395 find_tids_one_page(ItemPointer tids, int ntids, OffsetNumber *next_start_ptr)
396 {
397  int i;
398  BlockNumber prev_blkno,
399  blkno;
400 
401  prev_blkno = blkno = InvalidBlockNumber;
402 
403  for (i = *next_start_ptr; i < ntids; i++)
404  {
405  ItemPointerData tid = tids[i];
406 
407  blkno = ItemPointerGetBlockNumberNoCheck(&tid);
408 
409  if (i == *next_start_ptr)
410  prev_blkno = blkno;
411 
412  if (prev_blkno != blkno)
413  break;
414  }
415 
416  *next_start_ptr = i;
417  return prev_blkno;
418 }
int32 ItemPointerCompare(ItemPointer arg1, ItemPointer arg2)
Definition: itemptr.c:52
int errdetail_relkind_not_supported(char relkind)
Definition: pg_class.c:24
#define ItemPointerGetOffsetNumberNoCheck(pointer)
Definition: itemptr.h:108
void LockBufferForCleanup(Buffer buffer)
Definition: bufmgr.c:4064
Datum heap_force_kill(PG_FUNCTION_ARGS)
Definition: heap_surgery.c:53
int errhint(const char *fmt,...)
Definition: elog.c:1156
XLogRecPtr log_newpage_buffer(Buffer buffer, bool page_std)
Definition: xloginsert.c:1142
#define ItemIdIsRedirected(itemId)
Definition: itemid.h:106
#define PageIsAllVisible(page)
Definition: bufpage.h:385
Oid GetUserId(void)
Definition: miscinit.c:495
void visibilitymap_pin(Relation rel, BlockNumber heapBlk, Buffer *buf)
#define PG_GETARG_ARRAYTYPE_P_COPY(n)
Definition: array.h:257
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:1565
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define ItemIdGetRedirect(itemId)
Definition: itemid.h:78
#define END_CRIT_SECTION()
Definition: miscadmin.h:149
#define HEAP_XMIN_FROZEN
Definition: htup_details.h:205
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:76
#define ItemIdIsUsed(itemId)
Definition: itemid.h:92
#define MaxHeapTuplesPerPage
Definition: htup_details.h:573
#define InvalidBuffer
Definition: buf.h:25
#define START_CRIT_SECTION()
Definition: miscadmin.h:147
int errcode(int sqlerrcode)
Definition: elog.c:698
uint32 BlockNumber
Definition: block.h:31
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3768
PG_FUNCTION_INFO_V1(heap_force_kill)
Form_pg_class rd_rel
Definition: rel.h:109
unsigned int Oid
Definition: postgres_ext.h:31
bool RecoveryInProgress(void)
Definition: xlog.c:8220
#define ItemIdIsDead(itemId)
Definition: itemid.h:113
#define HeapTupleHeaderSetXvac(tup, xid)
Definition: htup_details.h:423
#define PageGetMaxOffsetNumber(page)
Definition: bufpage.h:357
Datum heap_force_freeze(PG_FUNCTION_ARGS)
Definition: heap_surgery.c:68
signed int int32
Definition: c.h:429
uint16 OffsetNumber
Definition: off.h:24
ItemPointerData * ItemPointer
Definition: itemptr.h:49
#define VISIBILITYMAP_VALID_BITS
Definition: visibilitymap.h:28
static void sanity_check_tid_array(ArrayType *ta, int *ntids)
Definition: heap_surgery.c:370
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:3308
void pfree(void *pointer)
Definition: mcxt.c:1169
bool visibilitymap_clear(Relation rel, BlockNumber heapBlk, Buffer buf, uint8 flags)
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3791
#define ERROR
Definition: elog.h:46
#define HEAP_XMAX_INVALID
Definition: htup_details.h:207
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:48
#define ARR_DIMS(a)
Definition: array.h:287
ItemPointerData t_ctid
Definition: htup_details.h:160
#define ARR_DATA_PTR(a)
Definition: array.h:315
static char * buf
Definition: pg_test_fsync.c:68
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define FirstOffsetNumber
Definition: off.h:27
#define RowExclusiveLock
Definition: lockdefs.h:38
#define HeapTupleHeaderSetXmax(tup, xid)
Definition: htup_details.h:380
#define InvalidTransactionId
Definition: transam.h:31
#define RelationGetRelationName(relation)
Definition: rel.h:511
#define ARR_HASNULL(a)
Definition: array.h:284
#define BufferGetPage(buffer)
Definition: bufmgr.h:169
PG_MODULE_MAGIC
Definition: heap_surgery.c:24
static int32 tidcmp(const void *a, const void *b)
Definition: heap_surgery.c:354
#define PageGetItemId(page, offsetNumber)
Definition: bufpage.h:235
uintptr_t Datum
Definition: postgres.h:411
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
#define HEAP_KEYS_UPDATED
Definition: htup_details.h:278
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:212
#define InvalidOffsetNumber
Definition: off.h:26
#define HEAP_MOVED
Definition: htup_details.h:216
#define ereport(elevel,...)
Definition: elog.h:157
#define NOTICE
Definition: elog.h:37
#define PG_RETURN_VOID()
Definition: fmgr.h:349
#define PageClearAllVisible(page)
Definition: bufpage.h:389
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:206
#define HEAP_MOVED_OFF
Definition: htup_details.h:210
#define Assert(condition)
Definition: c.h:804
#define FrozenTransactionId
Definition: transam.h:33
bool pg_class_ownercheck(Oid class_oid, Oid roleid)
Definition: aclchk.c:4818
#define ItemIdIsNormal(itemId)
Definition: itemid.h:99
static BlockNumber find_tids_one_page(ItemPointer tids, int ntids, OffsetNumber *next_start_ptr)
Definition: heap_surgery.c:395
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:694
#define OffsetNumberNext(offsetNumber)
Definition: off.h:52
#define InvalidBlockNumber
Definition: block.h:33
#define RelationNeedsWAL(relation)
Definition: rel.h:601
#define ARR_NDIM(a)
Definition: array.h:283
static Datum heap_force_common(FunctionCallInfo fcinfo, HeapTupleForceOption heap_force_opt)
Definition: heap_surgery.c:80
int errmsg(const char *fmt,...)
Definition: elog.c:909
#define ItemPointerGetBlockNumberNoCheck(pointer)
Definition: itemptr.h:89
int i
ObjectType get_relkind_objtype(char relkind)
HeapTupleForceOption
Definition: heap_surgery.c:27
#define HEAP_HOT_UPDATED
Definition: htup_details.h:280
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define HEAP_XACT_MASK
Definition: htup_details.h:218
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:120
#define ItemIdSetDead(itemId)
Definition: itemid.h:164
#define qsort(a, b, c, d)
Definition: port.h:504
bool array_contains_nulls(ArrayType *array)
Definition: arrayfuncs.c:3558
int Buffer
Definition: buf.h:23
#define RelationGetRelid(relation)
Definition: rel.h:477
#define PageGetItem(page, itemId)
Definition: bufpage.h:340
Pointer Page
Definition: bufpage.h:78
#define ItemPointerSet(pointer, blockNumber, offNum)
Definition: itemptr.h:127
#define HeapTupleHeaderSetXmin(tup, xid)
Definition: htup_details.h:319