On Thu, Mar 19, 2020 at 03:29:31PM -0500, Justin Pryzby wrote:
> I was going to suggest that we could do that by passing in a pointer to a
> local
> variable "LVRelStats olderrcbarg", like:
> | update_vacuum_error_cbarg(vacrelstats, VACUUM_ERRCB_PHASE_SCAN_HEAP,
> | blkno, NULL, &olderrcbarg);
>
> and then later call:
> |update_vacuum_error_cbarg(vacrelstats, olderrcbarg.phase,
> | olderrcbarg.blkno,
> | olderrcbarg.indname,
> | NULL);
>
> I implemented it in a separate patch, but it may be a bad idea, due to freeing
> indname. To exercise it, I tried to cause a crash by changing "else if
> (errcbarg->indname)" to "if" without else, but wasn't able to cause a crash,
> probably just due to having a narrow timing window.
I realized it was better for the caller to just assign the struct on its own.
Which gives me an excuse for resending patch, which is needed since I spent too
much time testing this that I failed to update the tip commit for the new
argument.
> It's probably a good idea to pass the indname rather than the relation in any
> case.
I included that with 0001.
I also fixed the argument name in the prototype (Relation rel vs indrel).
And removed these, which were the whole motivation behind saving the values.
|Set the error context while continuing heap scan
--
Justin
>From a77a85638404f061d43f06bf3a566f5aa1c5d5f4 Mon Sep 17 00:00:00 2001
From: Justin Pryzby <pryz...@telsasoft.com>
Date: Thu, 12 Dec 2019 20:54:37 -0600
Subject: [PATCH v28 1/5] vacuum errcontext to show block being processed
Discussion:
https://www.postgresql.org/message-id/20191120210600.gc30...@telsasoft.com
---
src/backend/access/heap/vacuumlazy.c | 209 +++++++++++++++++++++++----
src/tools/pgindent/typedefs.list | 1 +
2 files changed, 185 insertions(+), 25 deletions(-)
diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index 03c43efc32..768a69120b 100644
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -268,8 +268,19 @@ typedef struct LVParallelState
int nindexes_parallel_condcleanup;
} LVParallelState;
+typedef enum
+{
+ VACUUM_ERRCB_PHASE_UNKNOWN,
+ VACUUM_ERRCB_PHASE_SCAN_HEAP,
+ VACUUM_ERRCB_PHASE_VACUUM_INDEX,
+ VACUUM_ERRCB_PHASE_VACUUM_HEAP,
+ VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
+} errcb_phase;
+
typedef struct LVRelStats
{
+ char *relnamespace;
+ char *relname;
/* useindex = true means two-pass strategy; false means one-pass */
bool useindex;
/* Overall statistics about rel */
@@ -290,8 +301,12 @@ typedef struct LVRelStats
int num_index_scans;
TransactionId latestRemovedXid;
bool lock_waiter_detected;
-} LVRelStats;
+ /* Used for error callback: */
+ char *indname;
+ BlockNumber blkno; /* used only for heap operations */
+ errcb_phase phase;
+} LVRelStats;
/* A few variables that don't seem worth passing around as parameters */
static int elevel = -1;
@@ -314,10 +329,10 @@ static void lazy_vacuum_all_indexes(Relation onerel, Relation *Irel,
LVRelStats *vacrelstats, LVParallelState *lps,
int nindexes);
static void lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
- LVDeadTuples *dead_tuples, double reltuples);
+ LVDeadTuples *dead_tuples, double reltuples, LVRelStats *vacrelstats);
static void lazy_cleanup_index(Relation indrel,
IndexBulkDeleteResult **stats,
- double reltuples, bool estimated_count);
+ double reltuples, bool estimated_count, LVRelStats *vacrelstats);
static int lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
int tupindex, LVRelStats *vacrelstats, Buffer *vmbuffer);
static bool should_attempt_truncation(VacuumParams *params,
@@ -337,13 +352,13 @@ static void lazy_parallel_vacuum_indexes(Relation *Irel, IndexBulkDeleteResult *
int nindexes);
static void parallel_vacuum_index(Relation *Irel, IndexBulkDeleteResult **stats,
LVShared *lvshared, LVDeadTuples *dead_tuples,
- int nindexes);
+ int nindexes, LVRelStats *vacrelstats);
static void vacuum_indexes_leader(Relation *Irel, IndexBulkDeleteResult **stats,
LVRelStats *vacrelstats, LVParallelState *lps,
int nindexes);
static void vacuum_one_index(Relation indrel, IndexBulkDeleteResult **stats,
LVShared *lvshared, LVSharedIndStats *shared_indstats,
- LVDeadTuples *dead_tuples);
+ LVDeadTuples *dead_tuples, LVRelStats *vacrelstats);
static void lazy_cleanup_all_indexes(Relation *Irel, IndexBulkDeleteResult **stats,
LVRelStats *vacrelstats, LVParallelState *lps,
int nindexes);
@@ -361,6 +376,9 @@ static void end_parallel_vacuum(Relation *Irel, IndexBulkDeleteResult **stats,
LVParallelState *lps, int nindexes);
static LVSharedIndStats *get_indstats(LVShared *lvshared, int n);
static bool skip_parallel_vacuum_index(Relation indrel, LVShared *lvshared);
+static void vacuum_error_callback(void *arg);
+static void update_vacuum_error_cbarg(LVRelStats *errcbarg, int phase,
+ BlockNumber blkno, char *indname);
/*
@@ -460,6 +478,9 @@ heap_vacuum_rel(Relation onerel, VacuumParams *params,
vacrelstats = (LVRelStats *) palloc0(sizeof(LVRelStats));
+ vacrelstats->relnamespace = get_namespace_name(RelationGetNamespace(onerel));
+ vacrelstats->relname = pstrdup(RelationGetRelationName(onerel));
+ vacrelstats->indname = NULL;
vacrelstats->old_rel_pages = onerel->rd_rel->relpages;
vacrelstats->old_live_tuples = onerel->rd_rel->reltuples;
vacrelstats->num_index_scans = 0;
@@ -699,7 +720,6 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
BlockNumber nblocks,
blkno;
HeapTupleData tuple;
- char *relname;
TransactionId relfrozenxid = onerel->rd_rel->relfrozenxid;
TransactionId relminmxid = onerel->rd_rel->relminmxid;
BlockNumber empty_pages,
@@ -724,20 +744,20 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
PROGRESS_VACUUM_MAX_DEAD_TUPLES
};
int64 initprog_val[3];
+ ErrorContextCallback errcallback;
pg_rusage_init(&ru0);
- relname = RelationGetRelationName(onerel);
if (aggressive)
ereport(elevel,
(errmsg("aggressively vacuuming \"%s.%s\"",
- get_namespace_name(RelationGetNamespace(onerel)),
- relname)));
+ vacrelstats->relnamespace,
+ vacrelstats->relname)));
else
ereport(elevel,
(errmsg("vacuuming \"%s.%s\"",
- get_namespace_name(RelationGetNamespace(onerel)),
- relname)));
+ vacrelstats->relnamespace,
+ vacrelstats->relname)));
empty_pages = vacuumed_pages = 0;
next_fsm_block_to_vacuum = (BlockNumber) 0;
@@ -870,6 +890,14 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
else
skipping_blocks = false;
+ /* Setup error traceback support for ereport() */
+ update_vacuum_error_cbarg(vacrelstats, VACUUM_ERRCB_PHASE_SCAN_HEAP,
+ InvalidBlockNumber, NULL);
+ errcallback.callback = vacuum_error_callback;
+ errcallback.arg = vacrelstats;
+ errcallback.previous = error_context_stack;
+ error_context_stack = &errcallback;
+
for (blkno = 0; blkno < nblocks; blkno++)
{
Buffer buf;
@@ -891,8 +919,13 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
#define FORCE_CHECK_PAGE() \
(blkno == nblocks - 1 && should_attempt_truncation(params, vacrelstats))
+ vacrelstats->blkno = blkno;
+
pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_SCANNED, blkno);
+ update_vacuum_error_cbarg(vacrelstats, VACUUM_ERRCB_PHASE_SCAN_HEAP,
+ blkno, NULL);
+
if (blkno == next_unskippable_block)
{
/* Time to advance next_unskippable_block */
@@ -1011,6 +1044,10 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
/* Report that we are once again scanning the heap */
pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
PROGRESS_VACUUM_PHASE_SCAN_HEAP);
+
+ /* Set the error context while continuing heap scan */
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_SCAN_HEAP, blkno, NULL);
}
/*
@@ -1457,6 +1494,10 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
lazy_vacuum_page(onerel, blkno, buf, 0, vacrelstats, &vmbuffer);
vacuumed_pages++;
has_dead_tuples = false;
+
+ /* Set the error context while continuing heap scan */
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_SCAN_HEAP, blkno, NULL);
}
else
{
@@ -1534,7 +1575,7 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
&& VM_ALL_VISIBLE(onerel, blkno, &vmbuffer))
{
elog(WARNING, "page is not marked all-visible but visibility map bit is set in relation \"%s\" page %u",
- relname, blkno);
+ vacrelstats->relname, blkno);
visibilitymap_clear(onerel, blkno, vmbuffer,
VISIBILITYMAP_VALID_BITS);
}
@@ -1555,7 +1596,7 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
else if (PageIsAllVisible(page) && has_dead_tuples)
{
elog(WARNING, "page containing dead tuples is marked as all-visible in relation \"%s\" page %u",
- relname, blkno);
+ vacrelstats->relname, blkno);
PageClearAllVisible(page);
MarkBufferDirty(buf);
visibilitymap_clear(onerel, blkno, vmbuffer,
@@ -1651,6 +1692,9 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
if (vacrelstats->useindex)
lazy_cleanup_all_indexes(Irel, indstats, vacrelstats, lps, nindexes);
+ /* Pop the error context stack */
+ error_context_stack = errcallback.previous;
+
/*
* End parallel mode before updating index statistics as we cannot write
* during parallel mode.
@@ -1744,7 +1788,7 @@ lazy_vacuum_all_indexes(Relation onerel, Relation *Irel,
for (idx = 0; idx < nindexes; idx++)
lazy_vacuum_index(Irel[idx], &stats[idx], vacrelstats->dead_tuples,
- vacrelstats->old_live_tuples);
+ vacrelstats->old_live_tuples, vacrelstats);
}
/* Increase and report the number of index scans */
@@ -1777,6 +1821,10 @@ lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats)
pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
PROGRESS_VACUUM_PHASE_VACUUM_HEAP);
+ /* Setup error traceback support for ereport() */
+ update_vacuum_error_cbarg(vacrelstats, VACUUM_ERRCB_PHASE_VACUUM_HEAP,
+ InvalidBlockNumber, NULL);
+
pg_rusage_init(&ru0);
npages = 0;
@@ -1791,6 +1839,7 @@ lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats)
vacuum_delay_point();
tblk = ItemPointerGetBlockNumber(&vacrelstats->dead_tuples->itemptrs[tupindex]);
+ vacrelstats->blkno = tblk;
buf = ReadBufferExtended(onerel, MAIN_FORKNUM, tblk, RBM_NORMAL,
vac_strategy);
if (!ConditionalLockBufferForCleanup(buf))
@@ -1822,6 +1871,11 @@ lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats)
RelationGetRelationName(onerel),
tupindex, npages),
errdetail_internal("%s", pg_rusage_show(&ru0))));
+
+ /* Clear the error traceback phase */
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_UNKNOWN, InvalidBlockNumber,
+ NULL);
}
/*
@@ -1847,6 +1901,10 @@ lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, blkno);
+ /* Setup error traceback support for ereport() */
+ update_vacuum_error_cbarg(vacrelstats, VACUUM_ERRCB_PHASE_VACUUM_HEAP,
+ blkno, NULL);
+
START_CRIT_SECTION();
for (; tupindex < dead_tuples->num_tuples; tupindex++)
@@ -1923,6 +1981,11 @@ lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
*vmbuffer, visibility_cutoff_xid, flags);
}
+ /* Clear the error traceback phase */
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_UNKNOWN, InvalidBlockNumber,
+ NULL);
+
return tupindex;
}
@@ -2083,7 +2146,7 @@ lazy_parallel_vacuum_indexes(Relation *Irel, IndexBulkDeleteResult **stats,
* indexes in the case where no workers are launched.
*/
parallel_vacuum_index(Irel, stats, lps->lvshared,
- vacrelstats->dead_tuples, nindexes);
+ vacrelstats->dead_tuples, nindexes, vacrelstats);
/* Wait for all vacuum workers to finish */
WaitForParallelWorkersToFinish(lps->pcxt);
@@ -2106,7 +2169,7 @@ lazy_parallel_vacuum_indexes(Relation *Irel, IndexBulkDeleteResult **stats,
static void
parallel_vacuum_index(Relation *Irel, IndexBulkDeleteResult **stats,
LVShared *lvshared, LVDeadTuples *dead_tuples,
- int nindexes)
+ int nindexes, LVRelStats *vacrelstats)
{
/*
* Increment the active worker count if we are able to launch any worker.
@@ -2140,7 +2203,7 @@ parallel_vacuum_index(Relation *Irel, IndexBulkDeleteResult **stats,
/* Do vacuum or cleanup of the index */
vacuum_one_index(Irel[idx], &(stats[idx]), lvshared, shared_indstats,
- dead_tuples);
+ dead_tuples, vacrelstats);
}
/*
@@ -2180,7 +2243,8 @@ vacuum_indexes_leader(Relation *Irel, IndexBulkDeleteResult **stats,
if (shared_indstats == NULL ||
skip_parallel_vacuum_index(Irel[i], lps->lvshared))
vacuum_one_index(Irel[i], &(stats[i]), lps->lvshared,
- shared_indstats, vacrelstats->dead_tuples);
+ shared_indstats, vacrelstats->dead_tuples,
+ vacrelstats);
}
/*
@@ -2200,7 +2264,7 @@ vacuum_indexes_leader(Relation *Irel, IndexBulkDeleteResult **stats,
static void
vacuum_one_index(Relation indrel, IndexBulkDeleteResult **stats,
LVShared *lvshared, LVSharedIndStats *shared_indstats,
- LVDeadTuples *dead_tuples)
+ LVDeadTuples *dead_tuples, LVRelStats *vacrelstats)
{
IndexBulkDeleteResult *bulkdelete_res = NULL;
@@ -2220,10 +2284,10 @@ vacuum_one_index(Relation indrel, IndexBulkDeleteResult **stats,
/* Do vacuum or cleanup of the index */
if (lvshared->for_cleanup)
lazy_cleanup_index(indrel, stats, lvshared->reltuples,
- lvshared->estimated_count);
+ lvshared->estimated_count, vacrelstats);
else
lazy_vacuum_index(indrel, stats, dead_tuples,
- lvshared->reltuples);
+ lvshared->reltuples, vacrelstats);
/*
* Copy the index bulk-deletion result returned from ambulkdelete and
@@ -2298,7 +2362,8 @@ lazy_cleanup_all_indexes(Relation *Irel, IndexBulkDeleteResult **stats,
for (idx = 0; idx < nindexes; idx++)
lazy_cleanup_index(Irel[idx], &stats[idx],
vacrelstats->new_rel_tuples,
- vacrelstats->tupcount_pages < vacrelstats->rel_pages);
+ vacrelstats->tupcount_pages < vacrelstats->rel_pages,
+ vacrelstats);
}
}
@@ -2313,7 +2378,7 @@ lazy_cleanup_all_indexes(Relation *Irel, IndexBulkDeleteResult **stats,
*/
static void
lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
- LVDeadTuples *dead_tuples, double reltuples)
+ LVDeadTuples *dead_tuples, double reltuples, LVRelStats *vacrelstats)
{
IndexVacuumInfo ivinfo;
const char *msg;
@@ -2329,6 +2394,11 @@ lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
ivinfo.num_heap_tuples = reltuples;
ivinfo.strategy = vac_strategy;
+ /* Setup error traceback support for ereport() */
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_VACUUM_INDEX, InvalidBlockNumber,
+ RelationGetRelationName(indrel));
+
/* Do bulk deletion */
*stats = index_bulk_delete(&ivinfo, *stats,
lazy_tid_reaped, (void *) dead_tuples);
@@ -2343,6 +2413,11 @@ lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
RelationGetRelationName(indrel),
dead_tuples->num_tuples),
errdetail_internal("%s", pg_rusage_show(&ru0))));
+
+ /* Clear the error traceback phase */
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_UNKNOWN, InvalidBlockNumber,
+ NULL);
}
/*
@@ -2354,7 +2429,7 @@ lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
static void
lazy_cleanup_index(Relation indrel,
IndexBulkDeleteResult **stats,
- double reltuples, bool estimated_count)
+ double reltuples, bool estimated_count, LVRelStats *vacrelstats)
{
IndexVacuumInfo ivinfo;
const char *msg;
@@ -2371,6 +2446,12 @@ lazy_cleanup_index(Relation indrel,
ivinfo.num_heap_tuples = reltuples;
ivinfo.strategy = vac_strategy;
+ /* Setup error traceback support for ereport() */
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
+ InvalidBlockNumber,
+ RelationGetRelationName(indrel));
+
*stats = index_vacuum_cleanup(&ivinfo, *stats);
if (!(*stats))
@@ -2392,6 +2473,11 @@ lazy_cleanup_index(Relation indrel,
(*stats)->tuples_removed,
(*stats)->pages_deleted, (*stats)->pages_free,
pg_rusage_show(&ru0))));
+
+ /* Clear the error traceback phase */
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_UNKNOWN, InvalidBlockNumber,
+ NULL);
}
/*
@@ -3320,6 +3406,8 @@ parallel_vacuum_main(dsm_segment *seg, shm_toc *toc)
int nindexes;
char *sharedquery;
IndexBulkDeleteResult **stats;
+ LVRelStats vacrelstats;
+ ErrorContextCallback errcallback;
lvshared = (LVShared *) shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_SHARED,
false);
@@ -3369,10 +3457,81 @@ parallel_vacuum_main(dsm_segment *seg, shm_toc *toc)
if (lvshared->maintenance_work_mem_worker > 0)
maintenance_work_mem = lvshared->maintenance_work_mem_worker;
+ /* Init vacrelstats for use as error callback arg by parallel worker */
+ vacrelstats.relnamespace = get_namespace_name(RelationGetNamespace(onerel));
+ vacrelstats.relname = pstrdup(RelationGetRelationName(onerel));
+ vacrelstats.indname = NULL;
+ vacrelstats.phase = VACUUM_ERRCB_PHASE_UNKNOWN; /* Not yet processing */
+
+ /* Setup error traceback support for ereport() */
+ errcallback.callback = vacuum_error_callback;
+ errcallback.arg = &vacrelstats;
+ errcallback.previous = error_context_stack;
+ error_context_stack = &errcallback;
+
/* Process indexes to perform vacuum/cleanup */
- parallel_vacuum_index(indrels, stats, lvshared, dead_tuples, nindexes);
+ parallel_vacuum_index(indrels, stats, lvshared, dead_tuples, nindexes,
+ &vacrelstats);
+
+ /* Pop the error context stack */
+ error_context_stack = errcallback.previous;
vac_close_indexes(nindexes, indrels, RowExclusiveLock);
table_close(onerel, ShareUpdateExclusiveLock);
pfree(stats);
}
+
+/*
+ * Error context callback for errors occurring during vacuum.
+ */
+static void
+vacuum_error_callback(void *arg)
+{
+ LVRelStats *cbarg = arg;
+
+ switch (cbarg->phase)
+ {
+ case VACUUM_ERRCB_PHASE_SCAN_HEAP:
+ if (BlockNumberIsValid(cbarg->blkno))
+ errcontext("while scanning block %u of relation \"%s.%s\"",
+ cbarg->blkno, cbarg->relnamespace, cbarg->relname);
+ break;
+
+ case VACUUM_ERRCB_PHASE_VACUUM_HEAP:
+ if (BlockNumberIsValid(cbarg->blkno))
+ errcontext("while vacuuming block %u of relation \"%s.%s\"",
+ cbarg->blkno, cbarg->relnamespace, cbarg->relname);
+ break;
+
+ case VACUUM_ERRCB_PHASE_VACUUM_INDEX:
+ errcontext("while vacuuming index \"%s\" of relation \"%s.%s\"",
+ cbarg->indname, cbarg->relnamespace, cbarg->relname);
+ break;
+
+ case VACUUM_ERRCB_PHASE_INDEX_CLEANUP:
+ errcontext("while cleaning up index \"%s\" of relation \"%s.%s\"",
+ cbarg->indname, cbarg->relnamespace, cbarg->relname);
+ break;
+
+ case VACUUM_ERRCB_PHASE_UNKNOWN:
+ default:
+ return; /* do nothing; the cbarg may not be
+ * initialized */
+ }
+}
+
+/* Update vacuum error callback for current phase, block and index */
+static void
+update_vacuum_error_cbarg(LVRelStats *errcbarg, int phase, BlockNumber blkno,
+ char *indname)
+{
+ errcbarg->blkno = blkno;
+ errcbarg->phase = phase;
+
+ /* Free index name from any previous phase */
+ if (errcbarg->indname)
+ pfree(errcbarg->indname);
+
+ /* For index phases, save the name of the current index for the callback */
+ errcbarg->indname = indname ? pstrdup(indname) : NULL;
+}
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index fcfcf56f4f..1dee4e1ff2 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -582,6 +582,7 @@ EphemeralNamedRelationMetadata
EphemeralNamedRelationMetadataData
EquivalenceClass
EquivalenceMember
+errcb_phase
ErrorContextCallback
ErrorData
EstimateDSMForeignScan_function
--
2.17.0
>From c6ae656dbac15a06220c22061d32f070a52d4db3 Mon Sep 17 00:00:00 2001
From: Justin Pryzby <pryz...@telsasoft.com>
Date: Thu, 19 Mar 2020 15:21:22 -0500
Subject: [PATCH v28 2/5] Save the values of the callback..
..allowing them to be restored later, rather than setting phase=UNKNOWN.
---
src/backend/access/heap/vacuumlazy.c | 74 +++++++++++++++++-----------
1 file changed, 46 insertions(+), 28 deletions(-)
diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index 768a69120b..141a50e968 100644
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -378,7 +378,8 @@ static LVSharedIndStats *get_indstats(LVShared *lvshared, int n);
static bool skip_parallel_vacuum_index(Relation indrel, LVShared *lvshared);
static void vacuum_error_callback(void *arg);
static void update_vacuum_error_cbarg(LVRelStats *errcbarg, int phase,
- BlockNumber blkno, char *indname);
+ BlockNumber blkno, char *indname,
+ bool free_oldindname);
/*
@@ -892,7 +893,7 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
/* Setup error traceback support for ereport() */
update_vacuum_error_cbarg(vacrelstats, VACUUM_ERRCB_PHASE_SCAN_HEAP,
- InvalidBlockNumber, NULL);
+ InvalidBlockNumber, NULL, false);
errcallback.callback = vacuum_error_callback;
errcallback.arg = vacrelstats;
errcallback.previous = error_context_stack;
@@ -924,7 +925,7 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_SCANNED, blkno);
update_vacuum_error_cbarg(vacrelstats, VACUUM_ERRCB_PHASE_SCAN_HEAP,
- blkno, NULL);
+ blkno, NULL, false);
if (blkno == next_unskippable_block)
{
@@ -1044,10 +1045,6 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
/* Report that we are once again scanning the heap */
pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
PROGRESS_VACUUM_PHASE_SCAN_HEAP);
-
- /* Set the error context while continuing heap scan */
- update_vacuum_error_cbarg(vacrelstats,
- VACUUM_ERRCB_PHASE_SCAN_HEAP, blkno, NULL);
}
/*
@@ -1494,10 +1491,6 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
lazy_vacuum_page(onerel, blkno, buf, 0, vacrelstats, &vmbuffer);
vacuumed_pages++;
has_dead_tuples = false;
-
- /* Set the error context while continuing heap scan */
- update_vacuum_error_cbarg(vacrelstats,
- VACUUM_ERRCB_PHASE_SCAN_HEAP, blkno, NULL);
}
else
{
@@ -1816,14 +1809,16 @@ lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats)
int npages;
PGRUsage ru0;
Buffer vmbuffer = InvalidBuffer;
+ LVRelStats olderrcbarg;
/* Report that we are now vacuuming the heap */
pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
PROGRESS_VACUUM_PHASE_VACUUM_HEAP);
/* Setup error traceback support for ereport() */
+ olderrcbarg = *vacrelstats;
update_vacuum_error_cbarg(vacrelstats, VACUUM_ERRCB_PHASE_VACUUM_HEAP,
- InvalidBlockNumber, NULL);
+ InvalidBlockNumber, NULL, false);
pg_rusage_init(&ru0);
npages = 0;
@@ -1874,8 +1869,10 @@ lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats)
/* Clear the error traceback phase */
update_vacuum_error_cbarg(vacrelstats,
- VACUUM_ERRCB_PHASE_UNKNOWN, InvalidBlockNumber,
- NULL);
+ olderrcbarg.phase,
+ olderrcbarg.blkno,
+ olderrcbarg.indname,
+ true);
}
/*
@@ -1898,12 +1895,14 @@ lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
int uncnt = 0;
TransactionId visibility_cutoff_xid;
bool all_frozen;
+ LVRelStats olderrcbarg;
pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, blkno);
/* Setup error traceback support for ereport() */
+ olderrcbarg = *vacrelstats;
update_vacuum_error_cbarg(vacrelstats, VACUUM_ERRCB_PHASE_VACUUM_HEAP,
- blkno, NULL);
+ blkno, NULL, false);
START_CRIT_SECTION();
@@ -1983,9 +1982,10 @@ lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
/* Clear the error traceback phase */
update_vacuum_error_cbarg(vacrelstats,
- VACUUM_ERRCB_PHASE_UNKNOWN, InvalidBlockNumber,
- NULL);
-
+ olderrcbarg.phase,
+ olderrcbarg.blkno,
+ olderrcbarg.indname,
+ true);
return tupindex;
}
@@ -2383,6 +2383,7 @@ lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
IndexVacuumInfo ivinfo;
const char *msg;
PGRUsage ru0;
+ LVRelStats olderrcbarg;
pg_rusage_init(&ru0);
@@ -2395,9 +2396,12 @@ lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
ivinfo.strategy = vac_strategy;
/* Setup error traceback support for ereport() */
+ olderrcbarg = *vacrelstats;
update_vacuum_error_cbarg(vacrelstats,
- VACUUM_ERRCB_PHASE_VACUUM_INDEX, InvalidBlockNumber,
- RelationGetRelationName(indrel));
+ VACUUM_ERRCB_PHASE_VACUUM_INDEX,
+ InvalidBlockNumber,
+ RelationGetRelationName(indrel),
+ false);
/* Do bulk deletion */
*stats = index_bulk_delete(&ivinfo, *stats,
@@ -2416,8 +2420,10 @@ lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
/* Clear the error traceback phase */
update_vacuum_error_cbarg(vacrelstats,
- VACUUM_ERRCB_PHASE_UNKNOWN, InvalidBlockNumber,
- NULL);
+ olderrcbarg.phase,
+ olderrcbarg.blkno,
+ olderrcbarg.indname,
+ true);
}
/*
@@ -2434,6 +2440,7 @@ lazy_cleanup_index(Relation indrel,
IndexVacuumInfo ivinfo;
const char *msg;
PGRUsage ru0;
+ LVRelStats olderrcbarg;
pg_rusage_init(&ru0);
@@ -2447,10 +2454,12 @@ lazy_cleanup_index(Relation indrel,
ivinfo.strategy = vac_strategy;
/* Setup error traceback support for ereport() */
+ olderrcbarg = *vacrelstats;
update_vacuum_error_cbarg(vacrelstats,
VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
InvalidBlockNumber,
- RelationGetRelationName(indrel));
+ RelationGetRelationName(indrel),
+ false);
*stats = index_vacuum_cleanup(&ivinfo, *stats);
@@ -2476,8 +2485,10 @@ lazy_cleanup_index(Relation indrel,
/* Clear the error traceback phase */
update_vacuum_error_cbarg(vacrelstats,
- VACUUM_ERRCB_PHASE_UNKNOWN, InvalidBlockNumber,
- NULL);
+ olderrcbarg.phase,
+ olderrcbarg.blkno,
+ olderrcbarg.indname,
+ true);
}
/*
@@ -3520,16 +3531,23 @@ vacuum_error_callback(void *arg)
}
}
-/* Update vacuum error callback for current phase, block and index */
+/*
+ * Update vacuum error callback for current phase, block and index
+ *
+ * free_oldindex is true if the previous "indname" should be freed. It must be
+ * false if the caller has copied the old LVRelSTats, to avoid keeping a
+ * pointer to a freed allocation. In which case, the caller should call again
+ * with free_oldindname=true to avoid a leak.
+ */
static void
update_vacuum_error_cbarg(LVRelStats *errcbarg, int phase, BlockNumber blkno,
- char *indname)
+ char *indname, bool free_oldindname)
{
errcbarg->blkno = blkno;
errcbarg->phase = phase;
/* Free index name from any previous phase */
- if (errcbarg->indname)
+ if (free_oldindname && errcbarg->indname)
pfree(errcbarg->indname);
/* For index phases, save the name of the current index for the callback */
--
2.17.0
>From e6573112ee2babdd763905f4e38e581b3d8371a7 Mon Sep 17 00:00:00 2001
From: Justin Pryzby <pryz...@telsasoft.com>
Date: Wed, 4 Mar 2020 12:28:50 -0600
Subject: [PATCH v28 3/5] Drop reltuples
---
src/backend/access/heap/vacuumlazy.c | 24 +++++++++++-------------
1 file changed, 11 insertions(+), 13 deletions(-)
diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index 141a50e968..feee066722 100644
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -329,10 +329,10 @@ static void lazy_vacuum_all_indexes(Relation onerel, Relation *Irel,
LVRelStats *vacrelstats, LVParallelState *lps,
int nindexes);
static void lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
- LVDeadTuples *dead_tuples, double reltuples, LVRelStats *vacrelstats);
+ LVDeadTuples *dead_tuples, LVRelStats *vacrelstats);
static void lazy_cleanup_index(Relation indrel,
IndexBulkDeleteResult **stats,
- double reltuples, bool estimated_count, LVRelStats *vacrelstats);
+ LVRelStats *vacrelstats);
static int lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
int tupindex, LVRelStats *vacrelstats, Buffer *vmbuffer);
static bool should_attempt_truncation(VacuumParams *params,
@@ -1781,7 +1781,7 @@ lazy_vacuum_all_indexes(Relation onerel, Relation *Irel,
for (idx = 0; idx < nindexes; idx++)
lazy_vacuum_index(Irel[idx], &stats[idx], vacrelstats->dead_tuples,
- vacrelstats->old_live_tuples, vacrelstats);
+ vacrelstats);
}
/* Increase and report the number of index scans */
@@ -2283,11 +2283,10 @@ vacuum_one_index(Relation indrel, IndexBulkDeleteResult **stats,
/* Do vacuum or cleanup of the index */
if (lvshared->for_cleanup)
- lazy_cleanup_index(indrel, stats, lvshared->reltuples,
- lvshared->estimated_count, vacrelstats);
+ lazy_cleanup_index(indrel, stats, vacrelstats);
else
lazy_vacuum_index(indrel, stats, dead_tuples,
- lvshared->reltuples, vacrelstats);
+ vacrelstats);
/*
* Copy the index bulk-deletion result returned from ambulkdelete and
@@ -2361,8 +2360,6 @@ lazy_cleanup_all_indexes(Relation *Irel, IndexBulkDeleteResult **stats,
{
for (idx = 0; idx < nindexes; idx++)
lazy_cleanup_index(Irel[idx], &stats[idx],
- vacrelstats->new_rel_tuples,
- vacrelstats->tupcount_pages < vacrelstats->rel_pages,
vacrelstats);
}
}
@@ -2378,7 +2375,7 @@ lazy_cleanup_all_indexes(Relation *Irel, IndexBulkDeleteResult **stats,
*/
static void
lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
- LVDeadTuples *dead_tuples, double reltuples, LVRelStats *vacrelstats)
+ LVDeadTuples *dead_tuples, LVRelStats *vacrelstats)
{
IndexVacuumInfo ivinfo;
const char *msg;
@@ -2392,7 +2389,7 @@ lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
ivinfo.report_progress = false;
ivinfo.estimated_count = true;
ivinfo.message_level = elevel;
- ivinfo.num_heap_tuples = reltuples;
+ ivinfo.num_heap_tuples = vacrelstats->old_live_tuples;
ivinfo.strategy = vac_strategy;
/* Setup error traceback support for ereport() */
@@ -2435,7 +2432,7 @@ lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
static void
lazy_cleanup_index(Relation indrel,
IndexBulkDeleteResult **stats,
- double reltuples, bool estimated_count, LVRelStats *vacrelstats)
+ LVRelStats *vacrelstats)
{
IndexVacuumInfo ivinfo;
const char *msg;
@@ -2447,10 +2444,11 @@ lazy_cleanup_index(Relation indrel,
ivinfo.index = indrel;
ivinfo.analyze_only = false;
ivinfo.report_progress = false;
- ivinfo.estimated_count = estimated_count;
+ ivinfo.estimated_count = (bool)(vacrelstats->tupcount_pages <
+ vacrelstats->rel_pages);
ivinfo.message_level = elevel;
- ivinfo.num_heap_tuples = reltuples;
+ ivinfo.num_heap_tuples = vacrelstats->new_rel_tuples;
ivinfo.strategy = vac_strategy;
/* Setup error traceback support for ereport() */
--
2.17.0
>From 081d8dd086a66c65784b1b30d9713f906346439e Mon Sep 17 00:00:00 2001
From: Justin Pryzby <pryz...@telsasoft.com>
Date: Sun, 16 Feb 2020 20:25:13 -0600
Subject: [PATCH v28 4/5] add callback for truncation
---
src/backend/access/heap/vacuumlazy.c | 56 ++++++++++++++++++++++++++++
1 file changed, 56 insertions(+)
diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index feee066722..b8ac28d609 100644
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -275,6 +275,8 @@ typedef enum
VACUUM_ERRCB_PHASE_VACUUM_INDEX,
VACUUM_ERRCB_PHASE_VACUUM_HEAP,
VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
+ VACUUM_ERRCB_PHASE_TRUNCATE,
+ VACUUM_ERRCB_PHASE_TRUNCATE_PREFETCH,
} errcb_phase;
typedef struct LVRelStats
@@ -2535,6 +2537,7 @@ lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
BlockNumber old_rel_pages = vacrelstats->rel_pages;
BlockNumber new_rel_pages;
int lock_retry;
+ LVRelStats olderrcbarg;
/* Report that we are now truncating */
pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
@@ -2620,11 +2623,24 @@ lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
return;
}
+ /* Setup error traceback support for ereport() */
+ olderrcbarg = *vacrelstats;
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_TRUNCATE, new_rel_pages, NULL,
+ false);
+
/*
* Okay to truncate.
*/
RelationTruncate(onerel, new_rel_pages);
+ /* Clear the error traceback phase */
+ update_vacuum_error_cbarg(vacrelstats,
+ olderrcbarg.phase,
+ olderrcbarg.blkno,
+ olderrcbarg.indname,
+ true);
+
/*
* We can release the exclusive lock as soon as we have truncated.
* Other backends can't safely access the relation until they have
@@ -2664,6 +2680,7 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
BlockNumber blkno;
BlockNumber prefetchedUntil;
instr_time starttime;
+ LVRelStats olderrcbarg;
/* Initialize the starttime if we check for conflicting lock requests */
INSTR_TIME_SET_CURRENT(starttime);
@@ -2678,6 +2695,13 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
StaticAssertStmt((PREFETCH_SIZE & (PREFETCH_SIZE - 1)) == 0,
"prefetch size must be power of 2");
prefetchedUntil = InvalidBlockNumber;
+
+ /* Setup error traceback support for ereport() */
+ olderrcbarg = *vacrelstats;
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_TRUNCATE_PREFETCH, blkno, NULL,
+ false);
+
while (blkno > vacrelstats->nonempty_pages)
{
Buffer buf;
@@ -2736,6 +2760,11 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
prefetchStart = blkno & ~(PREFETCH_SIZE - 1);
for (pblkno = prefetchStart; pblkno <= blkno; pblkno++)
{
+ /* Setup error traceback support for ereport() */
+ update_vacuum_error_cbarg(vacrelstats,
+ VACUUM_ERRCB_PHASE_TRUNCATE_PREFETCH, blkno, NULL,
+ NULL);
+
PrefetchBuffer(onerel, MAIN_FORKNUM, pblkno);
CHECK_FOR_INTERRUPTS();
}
@@ -2783,9 +2812,24 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
/* Done scanning if we found a tuple here */
if (hastup)
+ {
+ /* Clear the error traceback phase */
+ update_vacuum_error_cbarg(vacrelstats,
+ olderrcbarg.phase,
+ olderrcbarg.blkno,
+ olderrcbarg.indname,
+ true);
return blkno + 1;
+ }
}
+ /* Clear the error traceback phase */
+ update_vacuum_error_cbarg(vacrelstats,
+ olderrcbarg.phase,
+ olderrcbarg.blkno,
+ olderrcbarg.indname,
+ true);
+
/*
* If we fall out of the loop, all the previously-thought-to-be-empty
* pages still are; we need not bother to look at the last known-nonempty
@@ -3522,6 +3566,18 @@ vacuum_error_callback(void *arg)
cbarg->indname, cbarg->relnamespace, cbarg->relname);
break;
+ case VACUUM_ERRCB_PHASE_TRUNCATE:
+ if (BlockNumberIsValid(cbarg->blkno))
+ errcontext("while truncating relation \"%s.%s\" to %u blocks",
+ cbarg->relnamespace, cbarg->relname, cbarg->blkno);
+ break;
+
+ case VACUUM_ERRCB_PHASE_TRUNCATE_PREFETCH:
+ if (BlockNumberIsValid(cbarg->blkno))
+ errcontext("while prefetching block %u to truncate relation \"%s.%s\"",
+ cbarg->blkno, cbarg->relnamespace, cbarg->relname);
+ break;
+
case VACUUM_ERRCB_PHASE_UNKNOWN:
default:
return; /* do nothing; the cbarg may not be
--
2.17.0
>From e0438d4057078c87b8992d31def3e63e4ae7e35d Mon Sep 17 00:00:00 2001
From: Justin Pryzby <pryz...@telsasoft.com>
Date: Wed, 26 Feb 2020 19:22:55 -0600
Subject: [PATCH v28 5/5] Avoid some calls to RelationGetRelationName
---
src/backend/access/heap/vacuumlazy.c | 20 ++++++++++----------
1 file changed, 10 insertions(+), 10 deletions(-)
diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index b8ac28d609..70d81f9566 100644
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -623,8 +623,8 @@ heap_vacuum_rel(Relation onerel, VacuumParams *params,
}
appendStringInfo(&buf, msgfmt,
get_database_name(MyDatabaseId),
- get_namespace_name(RelationGetNamespace(onerel)),
- RelationGetRelationName(onerel),
+ vacrelstats->relnamespace,
+ vacrelstats->relname,
vacrelstats->num_index_scans);
appendStringInfo(&buf, _("pages: %u removed, %u remain, %u skipped due to pins, %u skipped frozen\n"),
vacrelstats->pages_removed,
@@ -796,7 +796,7 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
if (params->nworkers > 0)
ereport(WARNING,
(errmsg("disabling parallel option of vacuum on \"%s\" --- cannot vacuum temporary tables in parallel",
- RelationGetRelationName(onerel))));
+ vacrelstats->relname)));
}
else
lps = begin_parallel_vacuum(RelationGetRelid(onerel), Irel,
@@ -1704,7 +1704,7 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
if (vacuumed_pages)
ereport(elevel,
(errmsg("\"%s\": removed %.0f row versions in %u pages",
- RelationGetRelationName(onerel),
+ vacrelstats->relname,
tups_vacuumed, vacuumed_pages)));
/*
@@ -1733,7 +1733,7 @@ lazy_scan_heap(Relation onerel, VacuumParams *params, LVRelStats *vacrelstats,
ereport(elevel,
(errmsg("\"%s\": found %.0f removable, %.0f nonremovable row versions in %u out of %u pages",
- RelationGetRelationName(onerel),
+ vacrelstats->relname,
tups_vacuumed, num_tuples,
vacrelstats->scanned_pages, nblocks),
errdetail_internal("%s", buf.data)));
@@ -1865,7 +1865,7 @@ lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats)
ereport(elevel,
(errmsg("\"%s\": removed %d row versions in %d pages",
- RelationGetRelationName(onerel),
+ vacrelstats->relname,
tupindex, npages),
errdetail_internal("%s", pg_rusage_show(&ru0))));
@@ -2413,7 +2413,7 @@ lazy_vacuum_index(Relation indrel, IndexBulkDeleteResult **stats,
ereport(elevel,
(errmsg(msg,
- RelationGetRelationName(indrel),
+ vacrelstats->relname,
dead_tuples->num_tuples),
errdetail_internal("%s", pg_rusage_show(&ru0))));
@@ -2582,7 +2582,7 @@ lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
vacrelstats->lock_waiter_detected = true;
ereport(elevel,
(errmsg("\"%s\": stopping truncate due to conflicting lock request",
- RelationGetRelationName(onerel))));
+ vacrelstats->relname)));
return;
}
@@ -2660,7 +2660,7 @@ lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
ereport(elevel,
(errmsg("\"%s\": truncated %u to %u pages",
- RelationGetRelationName(onerel),
+ vacrelstats->relname,
old_rel_pages, new_rel_pages),
errdetail_internal("%s",
pg_rusage_show(&ru0))));
@@ -2733,7 +2733,7 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
{
ereport(elevel,
(errmsg("\"%s\": suspending truncate due to conflicting lock request",
- RelationGetRelationName(onerel))));
+ vacrelstats->relname)));
vacrelstats->lock_waiter_detected = true;
return blkno;
--
2.17.0
