From 11f3815d6af840dc9d557cc680ec477931a6825b Mon Sep 17 00:00:00 2001 From: Noah Misch Date: Thu, 27 Jun 2024 19:21:06 -0700 Subject: Cope with inplace update making catcache stale during TOAST fetch. This extends ad98fb14226ae6456fbaed7990ee7591cbe5efd2 to invals of inplace updates. Trouble requires an inplace update of a catalog having a TOAST table, so only pg_database was at risk. (The other catalog on which core code performs inplace updates, pg_class, has no TOAST table.) Trouble would require something like the inplace-inval.spec test. Consider GRANT ... ON DATABASE fetching a stale row from cache and discarding a datfrozenxid update that vac_truncate_clog() has already relied upon. Back-patch to v12 (all supported versions). Reviewed (in an earlier version) by Robert Haas. Discussion: https://postgr.es/m/20240114201411.d0@rfd.leadboat.com Discussion: https://postgr.es/m/20240512232923.aa.nmisch@google.com --- src/backend/utils/cache/catcache.c | 44 +++++++++++++++++++++++++++++++++++--- 1 file changed, 41 insertions(+), 3 deletions(-) (limited to 'src/backend/utils/cache/catcache.c') diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c index 7c8713b28e1..d97a0750799 100644 --- a/src/backend/utils/cache/catcache.c +++ b/src/backend/utils/cache/catcache.c @@ -21,6 +21,7 @@ #include "access/tuptoaster.h" #include "access/valid.h" #include "access/xact.h" +#include "catalog/catalog.h" #include "catalog/pg_collation.h" #include "catalog/pg_operator.h" #include "catalog/pg_type.h" @@ -1846,6 +1847,23 @@ ReleaseCatCacheList(CatCList *list) } +/* + * equalTuple + * Are these tuples memcmp()-equal? + */ +static bool +equalTuple(HeapTuple a, HeapTuple b) +{ + uint32 alen; + uint32 blen; + + alen = a->t_len; + blen = b->t_len; + return (alen == blen && + memcmp((char *) a->t_data, + (char *) b->t_data, blen) == 0); +} + /* * CatalogCacheCreateEntry * Create a new CatCTup entry, copying the given HeapTuple and other @@ -1896,14 +1914,34 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, SysScanDesc scandesc, */ if (HeapTupleHasExternal(ntp)) { + bool need_cmp = IsInplaceUpdateOid(cache->cc_reloid); + HeapTuple before = NULL; + bool matches = true; + + if (need_cmp) + before = heap_copytuple(ntp); dtp = toast_flatten_tuple(ntp, cache->cc_tupdesc); /* * The tuple could become stale while we are doing toast table - * access (since AcceptInvalidationMessages can run then), so we - * must recheck its visibility afterwards. + * access (since AcceptInvalidationMessages can run then). + * equalTuple() detects staleness from inplace updates, while + * systable_recheck_tuple() detects staleness from normal updates. + * + * While this equalTuple() follows the usual rule of reading with + * a pin and no buffer lock, it warrants suspicion since an + * inplace update could appear at any moment. It's safe because + * the inplace update sends an invalidation that can't reorder + * before the inplace heap change. If the heap change reaches + * this process just after equalTuple() looks, we've not missed + * its inval. */ - if (!systable_recheck_tuple(scandesc, ntp)) + if (need_cmp) + { + matches = equalTuple(before, ntp); + heap_freetuple(before); + } + if (!matches || !systable_recheck_tuple(scandesc, ntp)) { heap_freetuple(dtp); return NULL; -- cgit v1.2.3