diff options
Diffstat (limited to 'src/backend/utils')
-rw-r--r-- | src/backend/utils/cache/catcache.c | 125 | ||||
-rw-r--r-- | src/backend/utils/cache/plancache.c | 50 | ||||
-rw-r--r-- | src/backend/utils/cache/relcache.c | 64 | ||||
-rw-r--r-- | src/backend/utils/resowner/README | 114 | ||||
-rw-r--r-- | src/backend/utils/resowner/resowner.c | 1533 | ||||
-rw-r--r-- | src/backend/utils/time/snapmgr.c | 47 |
6 files changed, 882 insertions, 1051 deletions
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c index 18db7e78e21..2e2e4d9f1f7 100644 --- a/src/backend/utils/cache/catcache.c +++ b/src/backend/utils/cache/catcache.c @@ -31,12 +31,13 @@ #endif #include "storage/lmgr.h" #include "utils/builtins.h" +#include "utils/catcache.h" #include "utils/datum.h" #include "utils/fmgroids.h" #include "utils/inval.h" #include "utils/memutils.h" #include "utils/rel.h" -#include "utils/resowner_private.h" +#include "utils/resowner.h" #include "utils/syscache.h" @@ -94,6 +95,8 @@ static CatCTup *CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, uint32 hashValue, Index hashIndex, bool negative); +static void ReleaseCatCacheWithOwner(HeapTuple tuple, ResourceOwner resowner); +static void ReleaseCatCacheListWithOwner(CatCList *list, ResourceOwner resowner); static void CatCacheFreeKeys(TupleDesc tupdesc, int nkeys, int *attnos, Datum *keys); static void CatCacheCopyKeys(TupleDesc tupdesc, int nkeys, int *attnos, @@ -104,6 +107,56 @@ static void CatCacheCopyKeys(TupleDesc tupdesc, int nkeys, int *attnos, * internal support functions */ +/* ResourceOwner callbacks to hold catcache references */ + +static void ResOwnerReleaseCatCache(Datum res); +static char *ResOwnerPrintCatCache(Datum res); +static void ResOwnerReleaseCatCacheList(Datum res); +static char *ResOwnerPrintCatCacheList(Datum res); + +static const ResourceOwnerDesc catcache_resowner_desc = +{ + /* catcache references */ + .name = "catcache reference", + .release_phase = RESOURCE_RELEASE_AFTER_LOCKS, + .release_priority = RELEASE_PRIO_CATCACHE_REFS, + .ReleaseResource = ResOwnerReleaseCatCache, + .DebugPrint = ResOwnerPrintCatCache +}; + +static const ResourceOwnerDesc catlistref_resowner_desc = +{ + /* catcache-list pins */ + .name = "catcache list reference", + .release_phase = RESOURCE_RELEASE_AFTER_LOCKS, + .release_priority = RELEASE_PRIO_CATCACHE_LIST_REFS, + .ReleaseResource = ResOwnerReleaseCatCacheList, + .DebugPrint = ResOwnerPrintCatCacheList +}; + +/* Convenience wrappers over ResourceOwnerRemember/Forget */ +static inline void +ResourceOwnerRememberCatCacheRef(ResourceOwner owner, HeapTuple tuple) +{ + ResourceOwnerRemember(owner, PointerGetDatum(tuple), &catcache_resowner_desc); +} +static inline void +ResourceOwnerForgetCatCacheRef(ResourceOwner owner, HeapTuple tuple) +{ + ResourceOwnerForget(owner, PointerGetDatum(tuple), &catcache_resowner_desc); +} +static inline void +ResourceOwnerRememberCatCacheListRef(ResourceOwner owner, CatCList *list) +{ + ResourceOwnerRemember(owner, PointerGetDatum(list), &catlistref_resowner_desc); +} +static inline void +ResourceOwnerForgetCatCacheListRef(ResourceOwner owner, CatCList *list) +{ + ResourceOwnerForget(owner, PointerGetDatum(list), &catlistref_resowner_desc); +} + + /* * Hash and equality functions for system types that are used as cache key * fields. In some cases, we just call the regular SQL-callable functions for @@ -1268,7 +1321,7 @@ SearchCatCacheInternal(CatCache *cache, */ if (!ct->negative) { - ResourceOwnerEnlargeCatCacheRefs(CurrentResourceOwner); + ResourceOwnerEnlarge(CurrentResourceOwner); ct->refcount++; ResourceOwnerRememberCatCacheRef(CurrentResourceOwner, &ct->tuple); @@ -1369,7 +1422,7 @@ SearchCatCacheMiss(CatCache *cache, hashValue, hashIndex, false); /* immediately set the refcount to 1 */ - ResourceOwnerEnlargeCatCacheRefs(CurrentResourceOwner); + ResourceOwnerEnlarge(CurrentResourceOwner); ct->refcount++; ResourceOwnerRememberCatCacheRef(CurrentResourceOwner, &ct->tuple); break; /* assume only one match */ @@ -1437,6 +1490,12 @@ SearchCatCacheMiss(CatCache *cache, void ReleaseCatCache(HeapTuple tuple) { + ReleaseCatCacheWithOwner(tuple, CurrentResourceOwner); +} + +static void +ReleaseCatCacheWithOwner(HeapTuple tuple, ResourceOwner resowner) +{ CatCTup *ct = (CatCTup *) (((char *) tuple) - offsetof(CatCTup, tuple)); @@ -1445,7 +1504,8 @@ ReleaseCatCache(HeapTuple tuple) Assert(ct->refcount > 0); ct->refcount--; - ResourceOwnerForgetCatCacheRef(CurrentResourceOwner, &ct->tuple); + if (resowner) + ResourceOwnerForgetCatCacheRef(CurrentResourceOwner, &ct->tuple); if ( #ifndef CATCACHE_FORCE_RELEASE @@ -1581,7 +1641,7 @@ SearchCatCacheList(CatCache *cache, dlist_move_head(&cache->cc_lists, &cl->cache_elem); /* Bump the list's refcount and return it */ - ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner); + ResourceOwnerEnlarge(CurrentResourceOwner); cl->refcount++; ResourceOwnerRememberCatCacheListRef(CurrentResourceOwner, cl); @@ -1693,7 +1753,7 @@ SearchCatCacheList(CatCache *cache, table_close(relation, AccessShareLock); /* Make sure the resource owner has room to remember this entry. */ - ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner); + ResourceOwnerEnlarge(CurrentResourceOwner); /* Now we can build the CatCList entry. */ oldcxt = MemoryContextSwitchTo(CacheMemoryContext); @@ -1779,11 +1839,18 @@ SearchCatCacheList(CatCache *cache, void ReleaseCatCacheList(CatCList *list) { + ReleaseCatCacheListWithOwner(list, CurrentResourceOwner); +} + +static void +ReleaseCatCacheListWithOwner(CatCList *list, ResourceOwner resowner) +{ /* Safety checks to ensure we were handed a cache entry */ Assert(list->cl_magic == CL_MAGIC); Assert(list->refcount > 0); list->refcount--; - ResourceOwnerForgetCatCacheListRef(CurrentResourceOwner, list); + if (resowner) + ResourceOwnerForgetCatCacheListRef(CurrentResourceOwner, list); if ( #ifndef CATCACHE_FORCE_RELEASE @@ -2059,31 +2126,43 @@ PrepareToInvalidateCacheTuple(Relation relation, } } +/* ResourceOwner callbacks */ -/* - * Subroutines for warning about reference leaks. These are exported so - * that resowner.c can call them. - */ -void -PrintCatCacheLeakWarning(HeapTuple tuple) +static void +ResOwnerReleaseCatCache(Datum res) { + ReleaseCatCacheWithOwner((HeapTuple) DatumGetPointer(res), NULL); +} + +static char * +ResOwnerPrintCatCache(Datum res) +{ + HeapTuple tuple = (HeapTuple) DatumGetPointer(res); CatCTup *ct = (CatCTup *) (((char *) tuple) - offsetof(CatCTup, tuple)); /* Safety check to ensure we were handed a cache entry */ Assert(ct->ct_magic == CT_MAGIC); - elog(WARNING, "cache reference leak: cache %s (%d), tuple %u/%u has count %d", - ct->my_cache->cc_relname, ct->my_cache->id, - ItemPointerGetBlockNumber(&(tuple->t_self)), - ItemPointerGetOffsetNumber(&(tuple->t_self)), - ct->refcount); + return psprintf("cache %s (%d), tuple %u/%u has count %d", + ct->my_cache->cc_relname, ct->my_cache->id, + ItemPointerGetBlockNumber(&(tuple->t_self)), + ItemPointerGetOffsetNumber(&(tuple->t_self)), + ct->refcount); } -void -PrintCatCacheListLeakWarning(CatCList *list) +static void +ResOwnerReleaseCatCacheList(Datum res) { - elog(WARNING, "cache reference leak: cache %s (%d), list %p has count %d", - list->my_cache->cc_relname, list->my_cache->id, - list, list->refcount); + ReleaseCatCacheListWithOwner((CatCList *) DatumGetPointer(res), NULL); +} + +static char * +ResOwnerPrintCatCacheList(Datum res) +{ + CatCList *list = (CatCList *) DatumGetPointer(res); + + return psprintf("cache %s (%d), list %p has count %d", + list->my_cache->cc_relname, list->my_cache->id, + list, list->refcount); } diff --git a/src/backend/utils/cache/plancache.c b/src/backend/utils/cache/plancache.c index 7d4168f82f5..8f95520f2fb 100644 --- a/src/backend/utils/cache/plancache.c +++ b/src/backend/utils/cache/plancache.c @@ -69,7 +69,7 @@ #include "tcop/utility.h" #include "utils/inval.h" #include "utils/memutils.h" -#include "utils/resowner_private.h" +#include "utils/resowner.h" #include "utils/rls.h" #include "utils/snapmgr.h" #include "utils/syscache.h" @@ -119,6 +119,31 @@ static void PlanCacheRelCallback(Datum arg, Oid relid); static void PlanCacheObjectCallback(Datum arg, int cacheid, uint32 hashvalue); static void PlanCacheSysCallback(Datum arg, int cacheid, uint32 hashvalue); +/* ResourceOwner callbacks to track plancache references */ +static void ResOwnerReleaseCachedPlan(Datum res); + +static const ResourceOwnerDesc planref_resowner_desc = +{ + .name = "plancache reference", + .release_phase = RESOURCE_RELEASE_AFTER_LOCKS, + .release_priority = RELEASE_PRIO_PLANCACHE_REFS, + .ReleaseResource = ResOwnerReleaseCachedPlan, + .DebugPrint = NULL /* the default message is fine */ +}; + +/* Convenience wrappers over ResourceOwnerRemember/Forget */ +static inline void +ResourceOwnerRememberPlanCacheRef(ResourceOwner owner, CachedPlan *plan) +{ + ResourceOwnerRemember(owner, PointerGetDatum(plan), &planref_resowner_desc); +} +static inline void +ResourceOwnerForgetPlanCacheRef(ResourceOwner owner, CachedPlan *plan) +{ + ResourceOwnerForget(owner, PointerGetDatum(plan), &planref_resowner_desc); +} + + /* GUC parameter */ int plan_cache_mode = PLAN_CACHE_MODE_AUTO; @@ -1233,7 +1258,7 @@ GetCachedPlan(CachedPlanSource *plansource, ParamListInfo boundParams, /* Flag the plan as in use by caller */ if (owner) - ResourceOwnerEnlargePlanCacheRefs(owner); + ResourceOwnerEnlarge(owner); plan->refcount++; if (owner) ResourceOwnerRememberPlanCacheRef(owner, plan); @@ -1396,7 +1421,7 @@ CachedPlanAllowsSimpleValidityCheck(CachedPlanSource *plansource, /* Bump refcount if requested. */ if (owner) { - ResourceOwnerEnlargePlanCacheRefs(owner); + ResourceOwnerEnlarge(owner); plan->refcount++; ResourceOwnerRememberPlanCacheRef(owner, plan); } @@ -1457,7 +1482,7 @@ CachedPlanIsSimplyValid(CachedPlanSource *plansource, CachedPlan *plan, /* It's still good. Bump refcount if requested. */ if (owner) { - ResourceOwnerEnlargePlanCacheRefs(owner); + ResourceOwnerEnlarge(owner); plan->refcount++; ResourceOwnerRememberPlanCacheRef(owner, plan); } @@ -2203,3 +2228,20 @@ ResetPlanCache(void) cexpr->is_valid = false; } } + +/* + * Release all CachedPlans remembered by 'owner' + */ +void +ReleaseAllPlanCacheRefsInOwner(ResourceOwner owner) +{ + ResourceOwnerReleaseAllOfKind(owner, &planref_resowner_desc); +} + +/* ResourceOwner callbacks */ + +static void +ResOwnerReleaseCachedPlan(Datum res) +{ + ReleaseCachedPlan((CachedPlan *) DatumGetPointer(res), NULL); +} diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index a49ab465b36..b3faccbefe5 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -80,13 +80,14 @@ #include "storage/smgr.h" #include "utils/array.h" #include "utils/builtins.h" +#include "utils/catcache.h" #include "utils/datum.h" #include "utils/fmgroids.h" #include "utils/inval.h" #include "utils/lsyscache.h" #include "utils/memutils.h" #include "utils/relmapper.h" -#include "utils/resowner_private.h" +#include "utils/resowner.h" #include "utils/snapmgr.h" #include "utils/syscache.h" @@ -273,6 +274,7 @@ static HTAB *OpClassCache = NULL; /* non-export function prototypes */ +static void RelationCloseCleanup(Relation relation); static void RelationDestroyRelation(Relation relation, bool remember_tupdesc); static void RelationClearRelation(Relation relation, bool rebuild); @@ -2115,6 +2117,31 @@ RelationIdGetRelation(Oid relationId) * ---------------------------------------------------------------- */ +/* ResourceOwner callbacks to track relcache references */ +static void ResOwnerReleaseRelation(Datum res); +static char *ResOwnerPrintRelCache(Datum res); + +static const ResourceOwnerDesc relref_resowner_desc = +{ + .name = "relcache reference", + .release_phase = RESOURCE_RELEASE_BEFORE_LOCKS, + .release_priority = RELEASE_PRIO_RELCACHE_REFS, + .ReleaseResource = ResOwnerReleaseRelation, + .DebugPrint = ResOwnerPrintRelCache +}; + +/* Convenience wrappers over ResourceOwnerRemember/Forget */ +static inline void +ResourceOwnerRememberRelationRef(ResourceOwner owner, Relation rel) +{ + ResourceOwnerRemember(owner, PointerGetDatum(rel), &relref_resowner_desc); +} +static inline void +ResourceOwnerForgetRelationRef(ResourceOwner owner, Relation rel) +{ + ResourceOwnerForget(owner, PointerGetDatum(rel), &relref_resowner_desc); +} + /* * RelationIncrementReferenceCount * Increments relation reference count. @@ -2126,7 +2153,7 @@ RelationIdGetRelation(Oid relationId) void RelationIncrementReferenceCount(Relation rel) { - ResourceOwnerEnlargeRelationRefs(CurrentResourceOwner); + ResourceOwnerEnlarge(CurrentResourceOwner); rel->rd_refcnt += 1; if (!IsBootstrapProcessingMode()) ResourceOwnerRememberRelationRef(CurrentResourceOwner, rel); @@ -2162,6 +2189,12 @@ RelationClose(Relation relation) /* Note: no locking manipulations needed */ RelationDecrementReferenceCount(relation); + RelationCloseCleanup(relation); +} + +static void +RelationCloseCleanup(Relation relation) +{ /* * If the relation is no longer open in this session, we can clean up any * stale partition descriptors it has. This is unlikely, so check to see @@ -6813,3 +6846,30 @@ unlink_initfile(const char *initfilename, int elevel) initfilename))); } } + +/* + * ResourceOwner callbacks + */ +static char * +ResOwnerPrintRelCache(Datum res) +{ + Relation rel = (Relation) DatumGetPointer(res); + + return psprintf("relation \"%s\"", RelationGetRelationName(rel)); +} + +static void +ResOwnerReleaseRelation(Datum res) +{ + Relation rel = (Relation) DatumGetPointer(res); + + /* + * This reference has already been removed from the resource owner, so + * just decrement reference count without calling + * ResourceOwnerForgetRelationRef. + */ + Assert(rel->rd_refcnt > 0); + rel->rd_refcnt -= 1; + + RelationCloseCleanup((Relation) res); +} diff --git a/src/backend/utils/resowner/README b/src/backend/utils/resowner/README index f94c9700df4..d67df3faedb 100644 --- a/src/backend/utils/resowner/README +++ b/src/backend/utils/resowner/README @@ -39,8 +39,8 @@ because transactions may initiate operations that require resources (such as query parsing) when no associated Portal exists yet. -API Overview ------------- +Usage +----- The basic operations on a ResourceOwner are: @@ -54,13 +54,6 @@ The basic operations on a ResourceOwner are: * delete a ResourceOwner (including child owner objects); all resources must have been released beforehand -This API directly supports the resource types listed in the definition of -ResourceOwnerData struct in src/backend/utils/resowner/resowner.c. -Other objects can be associated with a ResourceOwner by recording the address -of the owning ResourceOwner in such an object. There is an API for other -modules to get control during ResourceOwner release, so that they can scan -their own data structures to find the objects that need to be deleted. - Locks are handled specially because in non-error situations a lock should be held until end of transaction, even if it was originally taken by a subtransaction or portal. Therefore, the "release" operation on a child @@ -79,3 +72,106 @@ CurrentResourceOwner must point to the same resource owner that was current when the buffer, lock, or cache reference was acquired. It would be possible to relax this restriction given additional bookkeeping effort, but at present there seems no need. + +Adding a new resource type +-------------------------- + +ResourceOwner can track ownership of many different kinds of resources. In +core PostgreSQL it is used for buffer pins, lmgr locks, and catalog cache +references, to name a few examples. + +To add a new kind of resource, define a ResourceOwnerDesc to describe it. +For example: + +static const ResourceOwnerDesc myresource_desc = { + .name = "My fancy resource", + .release_phase = RESOURCE_RELEASE_AFTER_LOCKS, + .release_priority = RELEASE_PRIO_FIRST, + .ReleaseResource = ReleaseMyResource, + .DebugPrint = PrintMyResource +}; + +ResourceOwnerRemember() and ResourceOwnerForget() functions take a pointer +to that struct, along with a Datum to represent the resource. The meaning +of the Datum depends on the resource type. Most resource types use it to +store a pointer to some struct, but it can also be a file descriptor or +library handle, for example. + +The ReleaseResource callback is called when a resource owner is released or +deleted. It should release any resources (e.g. close files, free memory) +associated with the resource. Because the callback is called during +transaction abort, it must perform only low-level cleanup with no user +visible effects. The callback should not perform operations that could +fail, like allocate memory. + +The optional DebugPrint callback is used in the warning at transaction +commit, if any resources are leaked. If not specified, a generic +implementation that prints the resource name and the resource as a pointer +is used. + +There is another API for other modules to get control during ResourceOwner +release, so that they can scan their own data structures to find the objects +that need to be deleted. See RegisterResourceReleaseCallback function. +This used to be the only way for extensions to use the resource owner +mechanism with new kinds of objects; nowadays it easier to define a custom +ResourceOwnerDesc struct. + + +Releasing +--------- + +Releasing the resources of a ResourceOwner happens in three phases: + +1. "Before-locks" resources + +2. Locks + +3. "After-locks" resources + +Each resource type specifies whether it needs to be released before or after +locks. Each resource type also has a priority, which determines the order +that the resources are released in. Note that the phases are performed fully +for the whole tree of resource owners, before moving to the next phase, but +the priority within each phase only determines the order within that +ResourceOwner. Child resource owners are always handled before the parent, +within each phase. + +For example, imagine that you have two ResourceOwners, parent and child, +as follows: + +Parent + parent resource BEFORE_LOCKS priority 1 + parent resource BEFORE_LOCKS priority 2 + parent resource AFTER_LOCKS priority 10001 + parent resource AFTER_LOCKS priority 10002 + Child + child resource BEFORE_LOCKS priority 1 + child resource BEFORE_LOCKS priority 2 + child resource AFTER_LOCKS priority 10001 + child resource AFTER_LOCKS priority 10002 + +These resources would be released in the following order: + +child resource BEFORE_LOCKS priority 1 +child resource BEFORE_LOCKS priority 2 +parent resource BEFORE_LOCKS priority 1 +parent resource BEFORE_LOCKS priority 2 +(locks) +child resource AFTER_LOCKS priority 10001 +child resource AFTER_LOCKS priority 10002 +parent resource AFTER_LOCKS priority 10001 +parent resource AFTER_LOCKS priority 10002 + +To release all the resources, you need to call ResourceOwnerRelease() three +times, once for each phase. You may perform additional tasks between the +phases, but after the first call to ResourceOwnerRelease(), you cannot use +the ResourceOwner to remember any more resources. You also cannot call +ResourceOwnerForget on the resource owner to release any previously +remembered resources "in retail", after you have started the release process. + +Normally, you are expected to call ResourceOwnerForget on every resource so +that at commit, the ResourceOwner is empty (locks are an exception). If there +are any resources still held at commit, ResourceOwnerRelease will print a +WARNING on each such resource. At abort, however, we truly rely on the +ResourceOwner mechanism and it is normal that there are resources to be +released. diff --git a/src/backend/utils/resowner/resowner.c b/src/backend/utils/resowner/resowner.c index f926f1faad3..6e4020f241f 100644 --- a/src/backend/utils/resowner/resowner.c +++ b/src/backend/utils/resowner/resowner.c @@ -6,7 +6,32 @@ * Query-lifespan resources are tracked by associating them with * ResourceOwner objects. This provides a simple mechanism for ensuring * that such resources are freed at the right time. - * See utils/resowner/README for more info. + * See utils/resowner/README for more info on how to use it. + * + * The implementation consists of a small fixed-size array and a hash table. + * New entries are inserted to the fixed-size array, and when the array + * fills up, all the entries are moved to the hash table. This way, the + * array always contains a few most recently remembered references. To find + * a particular reference, you need to search both the array and the hash + * table. + * + * The most frequent usage is that a resource is remembered, and forgotten + * shortly thereafter. For example, pin a buffer, read one tuple from it, + * release the pin. Linearly scanning the small array handles that case + * efficiently. However, some resources are held for a longer time, and + * sometimes a lot of resources need to be held simultaneously. The hash + * table handles those cases. + * + * When it's time to release the resources, we sort them according to the + * release-priority of each resource, and release them in that order. + * + * Local lock references are special, they are not stored in the array or + * the hash table. Instead, each resource owner has a separate small cache + * of locks it owns. The lock manager has the same information in its local + * lock hash table, and we fall back on that if the cache overflows, but + * traversing the hash table is slower when there are a lot of locks + * belonging to other resource owners. This is to speed up bulk releasing + * or reassigning locks from a resource owner to its parent. * * * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group @@ -20,85 +45,54 @@ */ #include "postgres.h" -#include "common/cryptohash.h" #include "common/hashfn.h" -#include "common/hmac.h" -#include "jit/jit.h" -#include "storage/bufmgr.h" #include "storage/ipc.h" #include "storage/predicate.h" #include "storage/proc.h" #include "utils/memutils.h" -#include "utils/rel.h" -#include "utils/resowner_private.h" -#include "utils/snapmgr.h" - - -/* - * All resource IDs managed by this code are required to fit into a Datum, - * which is fine since they are generally pointers or integers. - * - * Provide Datum conversion macros for a couple of things that are really - * just "int". - */ -#define FileGetDatum(file) Int32GetDatum(file) -#define DatumGetFile(datum) ((File) DatumGetInt32(datum)) -#define BufferGetDatum(buffer) Int32GetDatum(buffer) -#define DatumGetBuffer(datum) ((Buffer) DatumGetInt32(datum)) +#include "utils/resowner.h" /* - * ResourceArray is a common structure for storing all types of resource IDs. + * ResourceElem represents a reference associated with a resource owner. * - * We manage small sets of resource IDs by keeping them in a simple array: - * itemsarr[k] holds an ID, for 0 <= k < nitems <= maxitems = capacity. - * - * If a set grows large, we switch over to using open-addressing hashing. - * Then, itemsarr[] is a hash table of "capacity" slots, with each - * slot holding either an ID or "invalidval". nitems is the number of valid - * items present; if it would exceed maxitems, we enlarge the array and - * re-hash. In this mode, maxitems should be rather less than capacity so - * that we don't waste too much time searching for empty slots. - * - * In either mode, lastidx remembers the location of the last item inserted - * or returned by GetAny; this speeds up searches in ResourceArrayRemove. + * All objects managed by this code are required to fit into a Datum, + * which is fine since they are generally pointers or integers. */ -typedef struct ResourceArray +typedef struct ResourceElem { - Datum *itemsarr; /* buffer for storing values */ - Datum invalidval; /* value that is considered invalid */ - uint32 capacity; /* allocated length of itemsarr[] */ - uint32 nitems; /* how many items are stored in items array */ - uint32 maxitems; /* current limit on nitems before enlarging */ - uint32 lastidx; /* index of last item returned by GetAny */ -} ResourceArray; + Datum item; + const ResourceOwnerDesc *kind; /* NULL indicates a free hash table slot */ +} ResourceElem; /* - * Initially allocated size of a ResourceArray. Must be power of two since - * we'll use (arraysize - 1) as mask for hashing. + * Size of the fixed-size array to hold most-recently remembered resources. */ -#define RESARRAY_INIT_SIZE 16 +#define RESOWNER_ARRAY_SIZE 32 /* - * When to switch to hashing vs. simple array logic in a ResourceArray. + * Initially allocated size of a ResourceOwner's hash table. Must be power of + * two because we use (capacity - 1) as mask for hashing. */ -#define RESARRAY_MAX_ARRAY 64 -#define RESARRAY_IS_ARRAY(resarr) ((resarr)->capacity <= RESARRAY_MAX_ARRAY) +#define RESOWNER_HASH_INIT_SIZE 64 /* - * How many items may be stored in a resource array of given capacity. - * When this number is reached, we must resize. + * How many items may be stored in a hash table of given capacity. When this + * number is reached, we must resize. + * + * The hash table must always have enough free space that we can copy the + * entries from the array to it, in ResourceOwnerSort. We also insist that + * the initial size is large enough that we don't hit the max size immediately + * when it's created. Aside from those limitations, 0.75 is a reasonable fill + * factor. */ -#define RESARRAY_MAX_ITEMS(capacity) \ - ((capacity) <= RESARRAY_MAX_ARRAY ? (capacity) : (capacity)/4 * 3) +#define RESOWNER_HASH_MAX_ITEMS(capacity) \ + Min(capacity - RESOWNER_ARRAY_SIZE, (capacity)/4 * 3) + +StaticAssertDecl(RESOWNER_HASH_MAX_ITEMS(RESOWNER_HASH_INIT_SIZE) >= RESOWNER_ARRAY_SIZE, + "initial hash size too small compared to array size"); /* - * To speed up bulk releasing or reassigning locks from a resource owner to - * its parent, each resource owner has a small cache of locks it owns. The - * lock manager has the same information in its local lock hash table, and - * we fall back on that if cache overflows, but traversing the hash table - * is slower when there are a lot of locks belonging to other resource owners. - * - * MAX_RESOWNER_LOCKS is the size of the per-resource owner cache. It's + * MAX_RESOWNER_LOCKS is the size of the per-resource owner locks cache. It's * chosen based on some testing with pg_dump with a large schema. When the * tests were done (on 9.2), resource owners in a pg_dump run contained up * to 9 locks, regardless of the schema size, except for the top resource @@ -119,25 +113,48 @@ typedef struct ResourceOwnerData ResourceOwner nextchild; /* next child of same parent */ const char *name; /* name (just for debugging) */ - /* We have built-in support for remembering: */ - ResourceArray bufferarr; /* owned buffers */ - ResourceArray bufferioarr; /* in-progress buffer IO */ - ResourceArray catrefarr; /* catcache references */ - ResourceArray catlistrefarr; /* catcache-list pins */ - ResourceArray relrefarr; /* relcache references */ - ResourceArray planrefarr; /* plancache references */ - ResourceArray tupdescarr; /* tupdesc references */ - ResourceArray snapshotarr; /* snapshot references */ - ResourceArray filearr; /* open temporary files */ - ResourceArray dsmarr; /* dynamic shmem segments */ - ResourceArray jitarr; /* JIT contexts */ - ResourceArray cryptohasharr; /* cryptohash contexts */ - ResourceArray hmacarr; /* HMAC contexts */ - - /* We can remember up to MAX_RESOWNER_LOCKS references to local locks. */ - int nlocks; /* number of owned locks */ + /* + * When ResourceOwnerRelease is called, we sort the 'hash' and 'arr' by + * the release priority. After that, no new resources can be remembered + * or forgotten in retail. We have separate flags because + * ResourceOwnerReleaseAllOfKind() temporarily sets 'releasing' without + * sorting the arrays. + */ + bool releasing; + bool sorted; /* are 'hash' and 'arr' sorted by priority? */ + + /* + * Number of items in the locks cache, array, and hash table respectively. + * (These are packed together to avoid padding in the struct.) + */ + uint8 nlocks; /* number of owned locks */ + uint8 narr; /* how many items are stored in the array */ + uint32 nhash; /* how many items are stored in the hash */ + + /* + * The fixed-size array for recent resources. + * + * If 'sorted' is set, the contents are sorted by release priority. + */ + ResourceElem arr[RESOWNER_ARRAY_SIZE]; + + /* + * The hash table. Uses open-addressing. 'nhash' is the number of items + * present; if it would exceed 'grow_at', we enlarge it and re-hash. + * 'grow_at' should be rather less than 'capacity' so that we don't waste + * too much time searching for empty slots. + * + * If 'sorted' is set, the contents are no longer hashed, but sorted by + * release priority. The first 'nhash' elements are occupied, the rest + * are empty. + */ + ResourceElem *hash; + uint32 capacity; /* allocated length of hash[] */ + uint32 grow_at; /* grow hash when reach this */ + + /* The local locks cache. */ LOCALLOCK *locks[MAX_RESOWNER_LOCKS]; /* list of owned locks */ -} ResourceOwnerData; +} ResourceOwnerData; /***************************************************************************** @@ -149,6 +166,13 @@ ResourceOwner CurTransactionResourceOwner = NULL; ResourceOwner TopTransactionResourceOwner = NULL; ResourceOwner AuxProcessResourceOwner = NULL; +/* #define RESOWNER_STATS */ + +#ifdef RESOWNER_STATS +static int narray_lookups = 0; +static int nhash_lookups = 0; +#endif + /* * List of add-on callbacks for resource releasing */ @@ -163,253 +187,204 @@ static ResourceReleaseCallbackItem *ResourceRelease_callbacks = NULL; /* Internal routines */ -static void ResourceArrayInit(ResourceArray *resarr, Datum invalidval); -static void ResourceArrayEnlarge(ResourceArray *resarr); -static void ResourceArrayAdd(ResourceArray *resarr, Datum value); -static bool ResourceArrayRemove(ResourceArray *resarr, Datum value); -static bool ResourceArrayGetAny(ResourceArray *resarr, Datum *value); -static void ResourceArrayFree(ResourceArray *resarr); +static inline uint32 hash_resource_elem(Datum value, const ResourceOwnerDesc *kind); +static void ResourceOwnerAddToHash(ResourceOwner owner, Datum value, + const ResourceOwnerDesc *kind); +static int resource_priority_cmp(const void *a, const void *b); +static void ResourceOwnerSort(ResourceOwner owner); +static void ResourceOwnerReleaseAll(ResourceOwner owner, + ResourceReleasePhase phase, + bool printLeakWarnings); static void ResourceOwnerReleaseInternal(ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel); static void ReleaseAuxProcessResourcesCallback(int code, Datum arg); -static void PrintRelCacheLeakWarning(Relation rel); -static void PrintPlanCacheLeakWarning(CachedPlan *plan); -static void PrintTupleDescLeakWarning(TupleDesc tupdesc); -static void PrintSnapshotLeakWarning(Snapshot snapshot); -static void PrintFileLeakWarning(File file); -static void PrintDSMLeakWarning(dsm_segment *seg); -static void PrintCryptoHashLeakWarning(Datum handle); -static void PrintHMACLeakWarning(Datum handle); /***************************************************************************** * INTERNAL ROUTINES * *****************************************************************************/ - -/* - * Initialize a ResourceArray - */ -static void -ResourceArrayInit(ResourceArray *resarr, Datum invalidval) +static inline uint32 +hash_resource_elem(Datum value, const ResourceOwnerDesc *kind) { - /* Assert it's empty */ - Assert(resarr->itemsarr == NULL); - Assert(resarr->capacity == 0); - Assert(resarr->nitems == 0); - Assert(resarr->maxitems == 0); - /* Remember the appropriate "invalid" value */ - resarr->invalidval = invalidval; - /* We don't allocate any storage until needed */ + Datum data[2]; + + data[0] = value; + data[1] = PointerGetDatum(kind); + + return hash_bytes((unsigned char *) &data, 2 * SIZEOF_DATUM); } /* - * Make sure there is room for at least one more resource in an array. - * - * This is separate from actually inserting a resource because if we run out - * of memory, it's critical to do so *before* acquiring the resource. + * Adds 'value' of given 'kind' to the ResourceOwner's hash table */ static void -ResourceArrayEnlarge(ResourceArray *resarr) +ResourceOwnerAddToHash(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind) { - uint32 i, - oldcap, - newcap; - Datum *olditemsarr; - Datum *newitemsarr; - - if (resarr->nitems < resarr->maxitems) - return; /* no work needed */ - - olditemsarr = resarr->itemsarr; - oldcap = resarr->capacity; - - /* Double the capacity of the array (capacity must stay a power of 2!) */ - newcap = (oldcap > 0) ? oldcap * 2 : RESARRAY_INIT_SIZE; - newitemsarr = (Datum *) MemoryContextAlloc(TopMemoryContext, - newcap * sizeof(Datum)); - for (i = 0; i < newcap; i++) - newitemsarr[i] = resarr->invalidval; + uint32 mask = owner->capacity - 1; + uint32 idx; - /* We assume we can't fail below this point, so OK to scribble on resarr */ - resarr->itemsarr = newitemsarr; - resarr->capacity = newcap; - resarr->maxitems = RESARRAY_MAX_ITEMS(newcap); - resarr->nitems = 0; + Assert(kind != NULL); - if (olditemsarr != NULL) + /* Insert into first free slot at or after hash location. */ + idx = hash_resource_elem(value, kind) & mask; + for (;;) { - /* - * Transfer any pre-existing entries into the new array; they don't - * necessarily go where they were before, so this simple logic is the - * best way. Note that if we were managing the set as a simple array, - * the entries after nitems are garbage, but that shouldn't matter - * because we won't get here unless nitems was equal to oldcap. - */ - for (i = 0; i < oldcap; i++) - { - if (olditemsarr[i] != resarr->invalidval) - ResourceArrayAdd(resarr, olditemsarr[i]); - } - - /* And release old array. */ - pfree(olditemsarr); + if (owner->hash[idx].kind == NULL) + break; /* found a free slot */ + idx = (idx + 1) & mask; } - - Assert(resarr->nitems < resarr->maxitems); + owner->hash[idx].item = value; + owner->hash[idx].kind = kind; + owner->nhash++; } /* - * Add a resource to ResourceArray - * - * Caller must have previously done ResourceArrayEnlarge() + * Comparison function to sort by release phase and priority */ -static void -ResourceArrayAdd(ResourceArray *resarr, Datum value) +static int +resource_priority_cmp(const void *a, const void *b) { - uint32 idx; - - Assert(value != resarr->invalidval); - Assert(resarr->nitems < resarr->maxitems); + const ResourceElem *ra = (const ResourceElem *) a; + const ResourceElem *rb = (const ResourceElem *) b; - if (RESARRAY_IS_ARRAY(resarr)) + /* Note: reverse order */ + if (ra->kind->release_phase == rb->kind->release_phase) { - /* Append to linear array. */ - idx = resarr->nitems; + if (ra->kind->release_priority == rb->kind->release_priority) + return 0; + else if (ra->kind->release_priority > rb->kind->release_priority) + return -1; + else + return 1; } + else if (ra->kind->release_phase > rb->kind->release_phase) + return -1; else - { - /* Insert into first free slot at or after hash location. */ - uint32 mask = resarr->capacity - 1; - - idx = DatumGetUInt32(hash_any((void *) &value, sizeof(value))) & mask; - for (;;) - { - if (resarr->itemsarr[idx] == resarr->invalidval) - break; - idx = (idx + 1) & mask; - } - } - resarr->lastidx = idx; - resarr->itemsarr[idx] = value; - resarr->nitems++; + return 1; } /* - * Remove a resource from ResourceArray + * Sort resources in reverse release priority. * - * Returns true on success, false if resource was not found. - * - * Note: if same resource ID appears more than once, one instance is removed. + * If the hash table is in use, all the elements from the fixed-size array are + * moved to the hash table, and then the hash table is sorted. If there is no + * hash table, then the fixed-size array is sorted directly. In either case, + * the result is one sorted array that contains all the resources. */ -static bool -ResourceArrayRemove(ResourceArray *resarr, Datum value) +static void +ResourceOwnerSort(ResourceOwner owner) { - uint32 i, - idx, - lastidx = resarr->lastidx; - - Assert(value != resarr->invalidval); + ResourceElem *items; + uint32 nitems; - /* Search through all items, but try lastidx first. */ - if (RESARRAY_IS_ARRAY(resarr)) + if (owner->nhash == 0) { - if (lastidx < resarr->nitems && - resarr->itemsarr[lastidx] == value) - { - resarr->itemsarr[lastidx] = resarr->itemsarr[resarr->nitems - 1]; - resarr->nitems--; - /* Update lastidx to make reverse-order removals fast. */ - resarr->lastidx = resarr->nitems - 1; - return true; - } - for (i = 0; i < resarr->nitems; i++) - { - if (resarr->itemsarr[i] == value) - { - resarr->itemsarr[i] = resarr->itemsarr[resarr->nitems - 1]; - resarr->nitems--; - /* Update lastidx to make reverse-order removals fast. */ - resarr->lastidx = resarr->nitems - 1; - return true; - } - } + items = owner->arr; + nitems = owner->narr; } else { - uint32 mask = resarr->capacity - 1; + /* + * Compact the hash table, so that all the elements are in the + * beginning of the 'hash' array, with no empty elements. + */ + uint32 dst = 0; - if (lastidx < resarr->capacity && - resarr->itemsarr[lastidx] == value) - { - resarr->itemsarr[lastidx] = resarr->invalidval; - resarr->nitems--; - return true; - } - idx = DatumGetUInt32(hash_any((void *) &value, sizeof(value))) & mask; - for (i = 0; i < resarr->capacity; i++) + for (int idx = 0; idx < owner->capacity; idx++) { - if (resarr->itemsarr[idx] == value) + if (owner->hash[idx].kind != NULL) { - resarr->itemsarr[idx] = resarr->invalidval; - resarr->nitems--; - return true; + if (dst != idx) + owner->hash[dst] = owner->hash[idx]; + dst++; } - idx = (idx + 1) & mask; } + + /* + * Move all entries from the fixed-size array to 'hash'. + * + * RESOWNER_HASH_MAX_ITEMS is defined so that there is always enough + * free space to move all the elements from the fixed-size array to + * the hash. + */ + Assert(dst + owner->narr <= owner->capacity); + for (int idx = 0; idx < owner->narr; idx++) + { + owner->hash[dst] = owner->arr[idx]; + dst++; + } + Assert(dst == owner->nhash + owner->narr); + owner->narr = 0; + owner->nhash = dst; + + items = owner->hash; + nitems = owner->nhash; } - return false; + qsort(items, nitems, sizeof(ResourceElem), resource_priority_cmp); } /* - * Get any convenient entry in a ResourceArray. - * - * "Convenient" is defined as "easy for ResourceArrayRemove to remove"; - * we help that along by setting lastidx to match. This avoids O(N^2) cost - * when removing all ResourceArray items during ResourceOwner destruction. - * - * Returns true if we found an element, or false if the array is empty. + * Call the ReleaseResource callback on entries with given 'phase'. */ -static bool -ResourceArrayGetAny(ResourceArray *resarr, Datum *value) +static void +ResourceOwnerReleaseAll(ResourceOwner owner, ResourceReleasePhase phase, + bool printLeakWarnings) { - if (resarr->nitems == 0) - return false; + ResourceElem *items; + uint32 nitems; - if (RESARRAY_IS_ARRAY(resarr)) + /* ResourceOwnerSort must've been called already */ + Assert(owner->releasing); + Assert(owner->sorted); + if (!owner->hash) { - /* Linear array: just return the first element. */ - resarr->lastidx = 0; + items = owner->arr; + nitems = owner->narr; } else { - /* Hash: search forward from wherever we were last. */ - uint32 mask = resarr->capacity - 1; + Assert(owner->narr == 0); + items = owner->hash; + nitems = owner->nhash; + } + + /* + * The resources are sorted in reverse priority order. Release them + * starting from the end, until we hit the end of the phase that we are + * releasing now. We will continue from there when called again for the + * next phase. + */ + while (nitems > 0) + { + uint32 idx = nitems - 1; + Datum value = items[idx].item; + const ResourceOwnerDesc *kind = items[idx].kind; - for (;;) + if (kind->release_phase > phase) + break; + Assert(kind->release_phase == phase); + + if (printLeakWarnings) { - resarr->lastidx &= mask; - if (resarr->itemsarr[resarr->lastidx] != resarr->invalidval) - break; - resarr->lastidx++; + char *res_str; + + res_str = kind->DebugPrint ? + kind->DebugPrint(value) + : psprintf("%s %p", kind->name, DatumGetPointer(value)); + elog(WARNING, "resource was not closed: %s", res_str); + pfree(res_str); } + kind->ReleaseResource(value); + nitems--; } - - *value = resarr->itemsarr[resarr->lastidx]; - return true; -} - -/* - * Trash a ResourceArray (we don't care about its state after this) - */ -static void -ResourceArrayFree(ResourceArray *resarr) -{ - if (resarr->itemsarr) - pfree(resarr->itemsarr); + if (!owner->hash) + owner->narr = nitems; + else + owner->nhash = nitems; } @@ -441,24 +416,189 @@ ResourceOwnerCreate(ResourceOwner parent, const char *name) parent->firstchild = owner; } - ResourceArrayInit(&(owner->bufferarr), BufferGetDatum(InvalidBuffer)); - ResourceArrayInit(&(owner->bufferioarr), BufferGetDatum(InvalidBuffer)); - ResourceArrayInit(&(owner->catrefarr), PointerGetDatum(NULL)); - ResourceArrayInit(&(owner->catlistrefarr), PointerGetDatum(NULL)); - ResourceArrayInit(&(owner->relrefarr), PointerGetDatum(NULL)); - ResourceArrayInit(&(owner->planrefarr), PointerGetDatum(NULL)); - ResourceArrayInit(&(owner->tupdescarr), PointerGetDatum(NULL)); - ResourceArrayInit(&(owner->snapshotarr), PointerGetDatum(NULL)); - ResourceArrayInit(&(owner->filearr), FileGetDatum(-1)); - ResourceArrayInit(&(owner->dsmarr), PointerGetDatum(NULL)); - ResourceArrayInit(&(owner->jitarr), PointerGetDatum(NULL)); - ResourceArrayInit(&(owner->cryptohasharr), PointerGetDatum(NULL)); - ResourceArrayInit(&(owner->hmacarr), PointerGetDatum(NULL)); - return owner; } /* + * Make sure there is room for at least one more resource in an array. + * + * This is separate from actually inserting a resource because if we run out + * of memory, it's critical to do so *before* acquiring the resource. + * + * NB: Make sure there are no unrelated ResourceOwnerRemember() calls between + * your ResourceOwnerEnlarge() call and the ResourceOwnerRemember() call that + * you reserved the space for! + */ +void +ResourceOwnerEnlarge(ResourceOwner owner) +{ + /* + * Mustn't try to remember more resources after we have already started + * releasing + */ + if (owner->releasing) + elog(ERROR, "ResourceOwnerEnlarge called after release started"); + + if (owner->narr < RESOWNER_ARRAY_SIZE) + return; /* no work needed */ + + /* + * Is there space in the hash? If not, enlarge it. + */ + if (owner->narr + owner->nhash >= owner->grow_at) + { + uint32 i, + oldcap, + newcap; + ResourceElem *oldhash; + ResourceElem *newhash; + + oldhash = owner->hash; + oldcap = owner->capacity; + + /* Double the capacity (it must stay a power of 2!) */ + newcap = (oldcap > 0) ? oldcap * 2 : RESOWNER_HASH_INIT_SIZE; + newhash = (ResourceElem *) MemoryContextAllocZero(TopMemoryContext, + newcap * sizeof(ResourceElem)); + + /* + * We assume we can't fail below this point, so OK to scribble on the + * owner + */ + owner->hash = newhash; + owner->capacity = newcap; + owner->grow_at = RESOWNER_HASH_MAX_ITEMS(newcap); + owner->nhash = 0; + + if (oldhash != NULL) + { + /* + * Transfer any pre-existing entries into the new hash table; they + * don't necessarily go where they were before, so this simple + * logic is the best way. + */ + for (i = 0; i < oldcap; i++) + { + if (oldhash[i].kind != NULL) + ResourceOwnerAddToHash(owner, oldhash[i].item, oldhash[i].kind); + } + + /* And release old hash table. */ + pfree(oldhash); + } + } + + /* Move items from the array to the hash */ + for (int i = 0; i < owner->narr; i++) + ResourceOwnerAddToHash(owner, owner->arr[i].item, owner->arr[i].kind); + owner->narr = 0; + + Assert(owner->nhash <= owner->grow_at); +} + +/* + * Remember that an object is owned by a ResourceOwner + * + * Caller must have previously done ResourceOwnerEnlarge() + */ +void +ResourceOwnerRemember(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind) +{ + uint32 idx; + + /* sanity check the ResourceOwnerDesc */ + Assert(kind->release_phase != 0); + Assert(kind->release_priority != 0); + + /* + * Mustn't try to remember more resources after we have already started + * releasing. We already checked this in ResourceOwnerEnlarge. + */ + Assert(!owner->releasing); + Assert(!owner->sorted); + + if (owner->narr >= RESOWNER_ARRAY_SIZE) + { + /* forgot to call ResourceOwnerEnlarge? */ + elog(ERROR, "ResourceOwnerRemember called but array was full"); + } + + /* Append to the array. */ + idx = owner->narr; + owner->arr[idx].item = value; + owner->arr[idx].kind = kind; + owner->narr++; +} + +/* + * Forget that an object is owned by a ResourceOwner + * + * Note: if same resource ID is associated with the ResourceOwner more than + * once, one instance is removed. + */ +void +ResourceOwnerForget(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind) +{ + /* + * Mustn't call this after we have already started releasing resources. + * (Release callback functions are not allowed to release additional + * resources.) + */ + if (owner->releasing) + elog(ERROR, "ResourceOwnerForget called for %s after release started", kind->name); + Assert(!owner->sorted); + + /* Search through all items in the array first. */ + for (int i = owner->narr - 1; i >= 0; i--) + { + if (owner->arr[i].item == value && + owner->arr[i].kind == kind) + { + owner->arr[i] = owner->arr[owner->narr - 1]; + owner->narr--; + +#ifdef RESOWNER_STATS + narray_lookups++; +#endif + return; + } + } + + /* Search hash */ + if (owner->nhash > 0) + { + uint32 mask = owner->capacity - 1; + uint32 idx; + + idx = hash_resource_elem(value, kind) & mask; + for (uint32 i = 0; i < owner->capacity; i++) + { + if (owner->hash[idx].item == value && + owner->hash[idx].kind == kind) + { + owner->hash[idx].item = (Datum) 0; + owner->hash[idx].kind = NULL; + owner->nhash--; + +#ifdef RESOWNER_STATS + nhash_lookups++; +#endif + return; + } + idx = (idx + 1) & mask; + } + } + + /* + * Use %p to print the reference, since most objects tracked by a resource + * owner are pointers. It's a bit misleading if it's not a pointer, but + * this is a programmer error, anyway. + */ + elog(ERROR, "%s %p is not owned by resource owner %s", + kind->name, DatumGetPointer(value), owner->name); +} + +/* * ResourceOwnerRelease * Release all resources owned by a ResourceOwner and its descendants, * but don't delete the owner objects themselves. @@ -483,6 +623,12 @@ ResourceOwnerCreate(ResourceOwner parent, const char *name) * isTopLevel is passed when we are releasing TopTransactionResourceOwner * at completion of a main transaction. This generally means that *all* * resources will be released, and so we can optimize things a bit. + * + * NOTE: After starting the release process, by calling this function, no new + * resources can be remembered in the resource owner. You also cannot call + * ResourceOwnerForget on any previously remembered resources to release + * resources "in retail" after that, you must let the bulk release take care + * of them. */ void ResourceOwnerRelease(ResourceOwner owner, @@ -492,6 +638,16 @@ ResourceOwnerRelease(ResourceOwner owner, { /* There's not currently any setup needed before recursing */ ResourceOwnerReleaseInternal(owner, phase, isCommit, isTopLevel); + +#ifdef RESOWNER_STATS + if (isTopLevel) + { + elog(LOG, "RESOWNER STATS: lookups: array %d, hash %d", + narray_lookups, nhash_lookups); + narray_lookups = 0; + nhash_lookups = 0; + } +#endif } static void @@ -504,105 +660,57 @@ ResourceOwnerReleaseInternal(ResourceOwner owner, ResourceOwner save; ResourceReleaseCallbackItem *item; ResourceReleaseCallbackItem *next; - Datum foundres; /* Recurse to handle descendants */ for (child = owner->firstchild; child != NULL; child = child->nextchild) ResourceOwnerReleaseInternal(child, phase, isCommit, isTopLevel); /* - * Make CurrentResourceOwner point to me, so that ReleaseBuffer etc don't - * get confused. + * To release the resources in the right order, sort them by phase and + * priority. + * + * The ReleaseResource callback functions are not allowed to remember or + * forget any other resources after this. Otherwise we lose track of where + * we are in processing the hash/array. */ - save = CurrentResourceOwner; - CurrentResourceOwner = owner; - - if (phase == RESOURCE_RELEASE_BEFORE_LOCKS) + if (!owner->releasing) + { + Assert(phase == RESOURCE_RELEASE_BEFORE_LOCKS); + Assert(!owner->sorted); + owner->releasing = true; + } + else { /* - * Abort failed buffer IO. AbortBufferIO()->TerminateBufferIO() calls - * ResourceOwnerForgetBufferIO(), so we just have to iterate till - * there are none. - * - * Needs to be before we release buffer pins. - * - * During a commit, there shouldn't be any in-progress IO. + * Phase is normally > RESOURCE_RELEASE_BEFORE_LOCKS, if this is not + * the first call to ResourceOwnerRelease. But if an error happens + * between the release phases, we might get called again for the same + * ResourceOwner from AbortTransaction. */ - while (ResourceArrayGetAny(&(owner->bufferioarr), &foundres)) - { - Buffer res = DatumGetBuffer(foundres); + } + if (!owner->sorted) + { + ResourceOwnerSort(owner); + owner->sorted = true; + } - if (isCommit) - elog(PANIC, "lost track of buffer IO on buffer %d", res); - AbortBufferIO(res); - } + /* + * Make CurrentResourceOwner point to me, so that the release callback + * functions know which resource owner is been released. + */ + save = CurrentResourceOwner; + CurrentResourceOwner = owner; + if (phase == RESOURCE_RELEASE_BEFORE_LOCKS) + { /* - * Release buffer pins. Note that ReleaseBuffer will remove the - * buffer entry from our array, so we just have to iterate till there - * are none. + * Release all resources that need to be released before the locks. * - * During a commit, there shouldn't be any remaining pins --- that - * would indicate failure to clean up the executor correctly --- so - * issue warnings. In the abort case, just clean up quietly. + * During a commit, there shouldn't be any remaining resources --- + * that would indicate failure to clean up the executor correctly --- + * so issue warnings. In the abort case, just clean up quietly. */ - while (ResourceArrayGetAny(&(owner->bufferarr), &foundres)) - { - Buffer res = DatumGetBuffer(foundres); - - if (isCommit) - PrintBufferLeakWarning(res); - ReleaseBuffer(res); - } - - /* Ditto for relcache references */ - while (ResourceArrayGetAny(&(owner->relrefarr), &foundres)) - { - Relation res = (Relation) DatumGetPointer(foundres); - - if (isCommit) - PrintRelCacheLeakWarning(res); - RelationClose(res); - } - - /* Ditto for dynamic shared memory segments */ - while (ResourceArrayGetAny(&(owner->dsmarr), &foundres)) - { - dsm_segment *res = (dsm_segment *) DatumGetPointer(foundres); - - if (isCommit) - PrintDSMLeakWarning(res); - dsm_detach(res); - } - - /* Ditto for JIT contexts */ - while (ResourceArrayGetAny(&(owner->jitarr), &foundres)) - { - JitContext *context = (JitContext *) DatumGetPointer(foundres); - - jit_release_context(context); - } - - /* Ditto for cryptohash contexts */ - while (ResourceArrayGetAny(&(owner->cryptohasharr), &foundres)) - { - pg_cryptohash_ctx *context = - (pg_cryptohash_ctx *) DatumGetPointer(foundres); - - if (isCommit) - PrintCryptoHashLeakWarning(foundres); - pg_cryptohash_free(context); - } - - /* Ditto for HMAC contexts */ - while (ResourceArrayGetAny(&(owner->hmacarr), &foundres)) - { - pg_hmac_ctx *context = (pg_hmac_ctx *) DatumGetPointer(foundres); - - if (isCommit) - PrintHMACLeakWarning(foundres); - pg_hmac_free(context); - } + ResourceOwnerReleaseAll(owner, phase, isCommit); } else if (phase == RESOURCE_RELEASE_LOCKS) { @@ -655,70 +763,9 @@ ResourceOwnerReleaseInternal(ResourceOwner owner, else if (phase == RESOURCE_RELEASE_AFTER_LOCKS) { /* - * Release catcache references. Note that ReleaseCatCache will remove - * the catref entry from our array, so we just have to iterate till - * there are none. - * - * As with buffer pins, warn if any are left at commit time. + * Release all resources that need to be released after the locks. */ - while (ResourceArrayGetAny(&(owner->catrefarr), &foundres)) - { - HeapTuple res = (HeapTuple) DatumGetPointer(foundres); - - if (isCommit) - PrintCatCacheLeakWarning(res); - ReleaseCatCache(res); - } - - /* Ditto for catcache lists */ - while (ResourceArrayGetAny(&(owner->catlistrefarr), &foundres)) - { - CatCList *res = (CatCList *) DatumGetPointer(foundres); - - if (isCommit) - PrintCatCacheListLeakWarning(res); - ReleaseCatCacheList(res); - } - - /* Ditto for plancache references */ - while (ResourceArrayGetAny(&(owner->planrefarr), &foundres)) - { - CachedPlan *res = (CachedPlan *) DatumGetPointer(foundres); - - if (isCommit) - PrintPlanCacheLeakWarning(res); - ReleaseCachedPlan(res, owner); - } - - /* Ditto for tupdesc references */ - while (ResourceArrayGetAny(&(owner->tupdescarr), &foundres)) - { - TupleDesc res = (TupleDesc) DatumGetPointer(foundres); - - if (isCommit) - PrintTupleDescLeakWarning(res); - DecrTupleDescRefCount(res); - } - - /* Ditto for snapshot references */ - while (ResourceArrayGetAny(&(owner->snapshotarr), &foundres)) - { - Snapshot res = (Snapshot) DatumGetPointer(foundres); - - if (isCommit) - PrintSnapshotLeakWarning(res); - UnregisterSnapshot(res); - } - - /* Ditto for temporary files */ - while (ResourceArrayGetAny(&(owner->filearr), &foundres)) - { - File res = DatumGetFile(foundres); - - if (isCommit) - PrintFileLeakWarning(res); - FileClose(res); - } + ResourceOwnerReleaseAll(owner, phase, isCommit); } /* Let add-on modules get a chance too */ @@ -733,23 +780,54 @@ ResourceOwnerReleaseInternal(ResourceOwner owner, } /* - * ResourceOwnerReleaseAllPlanCacheRefs - * Release the plancache references (only) held by this owner. - * - * We might eventually add similar functions for other resource types, - * but for now, only this is needed. + * ResourceOwnerReleaseAllOfKind + * Release all resources of a certain type held by this owner. */ void -ResourceOwnerReleaseAllPlanCacheRefs(ResourceOwner owner) +ResourceOwnerReleaseAllOfKind(ResourceOwner owner, const ResourceOwnerDesc *kind) { - Datum foundres; + /* Mustn't call this after we have already started releasing resources. */ + if (owner->releasing) + elog(ERROR, "ResourceOwnerForget called for %s after release started", kind->name); + Assert(!owner->sorted); + + /* + * Temporarily set 'releasing', to prevent calls to ResourceOwnerRemember + * while we're scanning the owner. Enlarging the hash would cause us to + * lose track of the point we're scanning. + */ + owner->releasing = true; - while (ResourceArrayGetAny(&(owner->planrefarr), &foundres)) + /* Array first */ + for (int i = 0; i < owner->narr; i++) { - CachedPlan *res = (CachedPlan *) DatumGetPointer(foundres); + if (owner->arr[i].kind == kind) + { + Datum value = owner->arr[i].item; + + owner->arr[i] = owner->arr[owner->narr - 1]; + owner->narr--; + i--; - ReleaseCachedPlan(res, owner); + kind->ReleaseResource(value); + } } + + /* Then hash */ + for (int i = 0; i < owner->capacity; i++) + { + if (owner->hash[i].kind == kind) + { + Datum value = owner->hash[i].item; + + owner->hash[i].item = (Datum) 0; + owner->hash[i].kind = NULL; + owner->nhash--; + + kind->ReleaseResource(value); + } + } + owner->releasing = false; } /* @@ -765,19 +843,8 @@ ResourceOwnerDelete(ResourceOwner owner) Assert(owner != CurrentResourceOwner); /* And it better not own any resources, either */ - Assert(owner->bufferarr.nitems == 0); - Assert(owner->bufferioarr.nitems == 0); - Assert(owner->catrefarr.nitems == 0); - Assert(owner->catlistrefarr.nitems == 0); - Assert(owner->relrefarr.nitems == 0); - Assert(owner->planrefarr.nitems == 0); - Assert(owner->tupdescarr.nitems == 0); - Assert(owner->snapshotarr.nitems == 0); - Assert(owner->filearr.nitems == 0); - Assert(owner->dsmarr.nitems == 0); - Assert(owner->jitarr.nitems == 0); - Assert(owner->cryptohasharr.nitems == 0); - Assert(owner->hmacarr.nitems == 0); + Assert(owner->narr == 0); + Assert(owner->nhash == 0); Assert(owner->nlocks == 0 || owner->nlocks == MAX_RESOWNER_LOCKS + 1); /* @@ -795,20 +862,8 @@ ResourceOwnerDelete(ResourceOwner owner) ResourceOwnerNewParent(owner, NULL); /* And free the object. */ - ResourceArrayFree(&(owner->bufferarr)); - ResourceArrayFree(&(owner->bufferioarr)); - ResourceArrayFree(&(owner->catrefarr)); - ResourceArrayFree(&(owner->catlistrefarr)); - ResourceArrayFree(&(owner->relrefarr)); - ResourceArrayFree(&(owner->planrefarr)); - ResourceArrayFree(&(owner->tupdescarr)); - ResourceArrayFree(&(owner->snapshotarr)); - ResourceArrayFree(&(owner->filearr)); - ResourceArrayFree(&(owner->dsmarr)); - ResourceArrayFree(&(owner->jitarr)); - ResourceArrayFree(&(owner->cryptohasharr)); - ResourceArrayFree(&(owner->hmacarr)); - + if (owner->hash) + pfree(owner->hash); pfree(owner); } @@ -866,11 +921,10 @@ ResourceOwnerNewParent(ResourceOwner owner, /* * Register or deregister callback functions for resource cleanup * - * These functions are intended for use by dynamically loaded modules. - * For built-in modules we generally just hardwire the appropriate calls. - * - * Note that the callback occurs post-commit or post-abort, so the callback - * functions can only do noncritical cleanup. + * These functions can be used by dynamically loaded modules. These used + * to be the only way for an extension to register custom resource types + * with a resource owner, but nowadays it is easier to define a new + * ResourceOwnerDesc with custom callbacks. */ void RegisterResourceReleaseCallback(ResourceReleaseCallback callback, void *arg) @@ -946,6 +1000,9 @@ ReleaseAuxProcessResources(bool isCommit) ResourceOwnerRelease(AuxProcessResourceOwner, RESOURCE_RELEASE_AFTER_LOCKS, isCommit, true); + /* allow it to be reused */ + AuxProcessResourceOwner->releasing = false; + AuxProcessResourceOwner->sorted = false; } /* @@ -960,88 +1017,12 @@ ReleaseAuxProcessResourcesCallback(int code, Datum arg) ReleaseAuxProcessResources(isCommit); } - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * buffer array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeBuffers(ResourceOwner owner) -{ - /* We used to allow pinning buffers without a resowner, but no more */ - Assert(owner != NULL); - ResourceArrayEnlarge(&(owner->bufferarr)); -} - -/* - * Remember that a buffer pin is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeBuffers() - */ -void -ResourceOwnerRememberBuffer(ResourceOwner owner, Buffer buffer) -{ - ResourceArrayAdd(&(owner->bufferarr), BufferGetDatum(buffer)); -} - -/* - * Forget that a buffer pin is owned by a ResourceOwner - */ -void -ResourceOwnerForgetBuffer(ResourceOwner owner, Buffer buffer) -{ - if (!ResourceArrayRemove(&(owner->bufferarr), BufferGetDatum(buffer))) - elog(ERROR, "buffer %d is not owned by resource owner %s", - buffer, owner->name); -} - - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * buffer array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeBufferIOs(ResourceOwner owner) -{ - /* We used to allow pinning buffers without a resowner, but no more */ - Assert(owner != NULL); - ResourceArrayEnlarge(&(owner->bufferioarr)); -} - -/* - * Remember that a buffer IO is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeBufferIOs() - */ -void -ResourceOwnerRememberBufferIO(ResourceOwner owner, Buffer buffer) -{ - ResourceArrayAdd(&(owner->bufferioarr), BufferGetDatum(buffer)); -} - -/* - * Forget that a buffer IO is owned by a ResourceOwner - */ -void -ResourceOwnerForgetBufferIO(ResourceOwner owner, Buffer buffer) -{ - if (!ResourceArrayRemove(&(owner->bufferioarr), BufferGetDatum(buffer))) - elog(PANIC, "buffer IO %d is not owned by resource owner %s", - buffer, owner->name); -} - /* * Remember that a Local Lock is owned by a ResourceOwner * - * This is different from the other Remember functions in that the list of - * locks is only a lossy cache. It can hold up to MAX_RESOWNER_LOCKS entries, - * and when it overflows, we stop tracking locks. The point of only remembering + * This is different from the generic ResourceOwnerRemember in that the list of + * locks is only a lossy cache. It can hold up to MAX_RESOWNER_LOCKS entries, + * and when it overflows, we stop tracking locks. The point of only remembering * only up to MAX_RESOWNER_LOCKS entries is that if a lot of locks are held, * ResourceOwnerForgetLock doesn't need to scan through a large array to find * the entry. @@ -1087,469 +1068,3 @@ ResourceOwnerForgetLock(ResourceOwner owner, LOCALLOCK *locallock) elog(ERROR, "lock reference %p is not owned by resource owner %s", locallock, owner->name); } - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * catcache reference array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeCatCacheRefs(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->catrefarr)); -} - -/* - * Remember that a catcache reference is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeCatCacheRefs() - */ -void -ResourceOwnerRememberCatCacheRef(ResourceOwner owner, HeapTuple tuple) -{ - ResourceArrayAdd(&(owner->catrefarr), PointerGetDatum(tuple)); -} - -/* - * Forget that a catcache reference is owned by a ResourceOwner - */ -void -ResourceOwnerForgetCatCacheRef(ResourceOwner owner, HeapTuple tuple) -{ - if (!ResourceArrayRemove(&(owner->catrefarr), PointerGetDatum(tuple))) - elog(ERROR, "catcache reference %p is not owned by resource owner %s", - tuple, owner->name); -} - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * catcache-list reference array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeCatCacheListRefs(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->catlistrefarr)); -} - -/* - * Remember that a catcache-list reference is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeCatCacheListRefs() - */ -void -ResourceOwnerRememberCatCacheListRef(ResourceOwner owner, CatCList *list) -{ - ResourceArrayAdd(&(owner->catlistrefarr), PointerGetDatum(list)); -} - -/* - * Forget that a catcache-list reference is owned by a ResourceOwner - */ -void -ResourceOwnerForgetCatCacheListRef(ResourceOwner owner, CatCList *list) -{ - if (!ResourceArrayRemove(&(owner->catlistrefarr), PointerGetDatum(list))) - elog(ERROR, "catcache list reference %p is not owned by resource owner %s", - list, owner->name); -} - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * relcache reference array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeRelationRefs(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->relrefarr)); -} - -/* - * Remember that a relcache reference is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeRelationRefs() - */ -void -ResourceOwnerRememberRelationRef(ResourceOwner owner, Relation rel) -{ - ResourceArrayAdd(&(owner->relrefarr), PointerGetDatum(rel)); -} - -/* - * Forget that a relcache reference is owned by a ResourceOwner - */ -void -ResourceOwnerForgetRelationRef(ResourceOwner owner, Relation rel) -{ - if (!ResourceArrayRemove(&(owner->relrefarr), PointerGetDatum(rel))) - elog(ERROR, "relcache reference %s is not owned by resource owner %s", - RelationGetRelationName(rel), owner->name); -} - -/* - * Debugging subroutine - */ -static void -PrintRelCacheLeakWarning(Relation rel) -{ - elog(WARNING, "relcache reference leak: relation \"%s\" not closed", - RelationGetRelationName(rel)); -} - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * plancache reference array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargePlanCacheRefs(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->planrefarr)); -} - -/* - * Remember that a plancache reference is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargePlanCacheRefs() - */ -void -ResourceOwnerRememberPlanCacheRef(ResourceOwner owner, CachedPlan *plan) -{ - ResourceArrayAdd(&(owner->planrefarr), PointerGetDatum(plan)); -} - -/* - * Forget that a plancache reference is owned by a ResourceOwner - */ -void -ResourceOwnerForgetPlanCacheRef(ResourceOwner owner, CachedPlan *plan) -{ - if (!ResourceArrayRemove(&(owner->planrefarr), PointerGetDatum(plan))) - elog(ERROR, "plancache reference %p is not owned by resource owner %s", - plan, owner->name); -} - -/* - * Debugging subroutine - */ -static void -PrintPlanCacheLeakWarning(CachedPlan *plan) -{ - elog(WARNING, "plancache reference leak: plan %p not closed", plan); -} - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * tupdesc reference array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeTupleDescs(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->tupdescarr)); -} - -/* - * Remember that a tupdesc reference is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeTupleDescs() - */ -void -ResourceOwnerRememberTupleDesc(ResourceOwner owner, TupleDesc tupdesc) -{ - ResourceArrayAdd(&(owner->tupdescarr), PointerGetDatum(tupdesc)); -} - -/* - * Forget that a tupdesc reference is owned by a ResourceOwner - */ -void -ResourceOwnerForgetTupleDesc(ResourceOwner owner, TupleDesc tupdesc) -{ - if (!ResourceArrayRemove(&(owner->tupdescarr), PointerGetDatum(tupdesc))) - elog(ERROR, "tupdesc reference %p is not owned by resource owner %s", - tupdesc, owner->name); -} - -/* - * Debugging subroutine - */ -static void -PrintTupleDescLeakWarning(TupleDesc tupdesc) -{ - elog(WARNING, - "TupleDesc reference leak: TupleDesc %p (%u,%d) still referenced", - tupdesc, tupdesc->tdtypeid, tupdesc->tdtypmod); -} - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * snapshot reference array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeSnapshots(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->snapshotarr)); -} - -/* - * Remember that a snapshot reference is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeSnapshots() - */ -void -ResourceOwnerRememberSnapshot(ResourceOwner owner, Snapshot snapshot) -{ - ResourceArrayAdd(&(owner->snapshotarr), PointerGetDatum(snapshot)); -} - -/* - * Forget that a snapshot reference is owned by a ResourceOwner - */ -void -ResourceOwnerForgetSnapshot(ResourceOwner owner, Snapshot snapshot) -{ - if (!ResourceArrayRemove(&(owner->snapshotarr), PointerGetDatum(snapshot))) - elog(ERROR, "snapshot reference %p is not owned by resource owner %s", - snapshot, owner->name); -} - -/* - * Debugging subroutine - */ -static void -PrintSnapshotLeakWarning(Snapshot snapshot) -{ - elog(WARNING, "Snapshot reference leak: Snapshot %p still referenced", - snapshot); -} - - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * files reference array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeFiles(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->filearr)); -} - -/* - * Remember that a temporary file is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeFiles() - */ -void -ResourceOwnerRememberFile(ResourceOwner owner, File file) -{ - ResourceArrayAdd(&(owner->filearr), FileGetDatum(file)); -} - -/* - * Forget that a temporary file is owned by a ResourceOwner - */ -void -ResourceOwnerForgetFile(ResourceOwner owner, File file) -{ - if (!ResourceArrayRemove(&(owner->filearr), FileGetDatum(file))) - elog(ERROR, "temporary file %d is not owned by resource owner %s", - file, owner->name); -} - -/* - * Debugging subroutine - */ -static void -PrintFileLeakWarning(File file) -{ - elog(WARNING, "temporary file leak: File %d still referenced", - file); -} - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * dynamic shmem segment reference array. - * - * This is separate from actually inserting an entry because if we run out - * of memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeDSMs(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->dsmarr)); -} - -/* - * Remember that a dynamic shmem segment is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeDSMs() - */ -void -ResourceOwnerRememberDSM(ResourceOwner owner, dsm_segment *seg) -{ - ResourceArrayAdd(&(owner->dsmarr), PointerGetDatum(seg)); -} - -/* - * Forget that a dynamic shmem segment is owned by a ResourceOwner - */ -void -ResourceOwnerForgetDSM(ResourceOwner owner, dsm_segment *seg) -{ - if (!ResourceArrayRemove(&(owner->dsmarr), PointerGetDatum(seg))) - elog(ERROR, "dynamic shared memory segment %u is not owned by resource owner %s", - dsm_segment_handle(seg), owner->name); -} - -/* - * Debugging subroutine - */ -static void -PrintDSMLeakWarning(dsm_segment *seg) -{ - elog(WARNING, "dynamic shared memory leak: segment %u still referenced", - dsm_segment_handle(seg)); -} - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * JIT context reference array. - * - * This is separate from actually inserting an entry because if we run out of - * memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeJIT(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->jitarr)); -} - -/* - * Remember that a JIT context is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeJIT() - */ -void -ResourceOwnerRememberJIT(ResourceOwner owner, Datum handle) -{ - ResourceArrayAdd(&(owner->jitarr), handle); -} - -/* - * Forget that a JIT context is owned by a ResourceOwner - */ -void -ResourceOwnerForgetJIT(ResourceOwner owner, Datum handle) -{ - if (!ResourceArrayRemove(&(owner->jitarr), handle)) - elog(ERROR, "JIT context %p is not owned by resource owner %s", - DatumGetPointer(handle), owner->name); -} - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * cryptohash context reference array. - * - * This is separate from actually inserting an entry because if we run out of - * memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeCryptoHash(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->cryptohasharr)); -} - -/* - * Remember that a cryptohash context is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeCryptoHash() - */ -void -ResourceOwnerRememberCryptoHash(ResourceOwner owner, Datum handle) -{ - ResourceArrayAdd(&(owner->cryptohasharr), handle); -} - -/* - * Forget that a cryptohash context is owned by a ResourceOwner - */ -void -ResourceOwnerForgetCryptoHash(ResourceOwner owner, Datum handle) -{ - if (!ResourceArrayRemove(&(owner->cryptohasharr), handle)) - elog(ERROR, "cryptohash context %p is not owned by resource owner %s", - DatumGetPointer(handle), owner->name); -} - -/* - * Debugging subroutine - */ -static void -PrintCryptoHashLeakWarning(Datum handle) -{ - elog(WARNING, "cryptohash context reference leak: context %p still referenced", - DatumGetPointer(handle)); -} - -/* - * Make sure there is room for at least one more entry in a ResourceOwner's - * hmac context reference array. - * - * This is separate from actually inserting an entry because if we run out of - * memory, it's critical to do so *before* acquiring the resource. - */ -void -ResourceOwnerEnlargeHMAC(ResourceOwner owner) -{ - ResourceArrayEnlarge(&(owner->hmacarr)); -} - -/* - * Remember that a HMAC context is owned by a ResourceOwner - * - * Caller must have previously done ResourceOwnerEnlargeHMAC() - */ -void -ResourceOwnerRememberHMAC(ResourceOwner owner, Datum handle) -{ - ResourceArrayAdd(&(owner->hmacarr), handle); -} - -/* - * Forget that a HMAC context is owned by a ResourceOwner - */ -void -ResourceOwnerForgetHMAC(ResourceOwner owner, Datum handle) -{ - if (!ResourceArrayRemove(&(owner->hmacarr), handle)) - elog(ERROR, "HMAC context %p is not owned by resource owner %s", - DatumGetPointer(handle), owner->name); -} - -/* - * Debugging subroutine - */ -static void -PrintHMACLeakWarning(Datum handle) -{ - elog(WARNING, "HMAC context reference leak: context %p still referenced", - DatumGetPointer(handle)); -} diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c index 4a3613d15fc..9198850ad25 100644 --- a/src/backend/utils/time/snapmgr.c +++ b/src/backend/utils/time/snapmgr.c @@ -57,6 +57,7 @@ #include "lib/pairingheap.h" #include "miscadmin.h" #include "port/pg_lfind.h" +#include "storage/fd.h" #include "storage/predicate.h" #include "storage/proc.h" #include "storage/procarray.h" @@ -66,7 +67,7 @@ #include "utils/builtins.h" #include "utils/memutils.h" #include "utils/rel.h" -#include "utils/resowner_private.h" +#include "utils/resowner.h" #include "utils/snapmgr.h" #include "utils/syscache.h" #include "utils/timestamp.h" @@ -162,9 +163,34 @@ static List *exportedSnapshots = NIL; /* Prototypes for local functions */ static Snapshot CopySnapshot(Snapshot snapshot); +static void UnregisterSnapshotNoOwner(Snapshot snapshot); static void FreeSnapshot(Snapshot snapshot); static void SnapshotResetXmin(void); +/* ResourceOwner callbacks to track snapshot references */ +static void ResOwnerReleaseSnapshot(Datum res); + +static const ResourceOwnerDesc snapshot_resowner_desc = +{ + .name = "snapshot reference", + .release_phase = RESOURCE_RELEASE_AFTER_LOCKS, + .release_priority = RELEASE_PRIO_SNAPSHOT_REFS, + .ReleaseResource = ResOwnerReleaseSnapshot, + .DebugPrint = NULL /* the default message is fine */ +}; + +/* Convenience wrappers over ResourceOwnerRemember/Forget */ +static inline void +ResourceOwnerRememberSnapshot(ResourceOwner owner, Snapshot snap) +{ + ResourceOwnerRemember(owner, PointerGetDatum(snap), &snapshot_resowner_desc); +} +static inline void +ResourceOwnerForgetSnapshot(ResourceOwner owner, Snapshot snap) +{ + ResourceOwnerForget(owner, PointerGetDatum(snap), &snapshot_resowner_desc); +} + /* * Snapshot fields to be serialized. * @@ -796,7 +822,7 @@ RegisterSnapshotOnOwner(Snapshot snapshot, ResourceOwner owner) snap = snapshot->copied ? snapshot : CopySnapshot(snapshot); /* and tell resowner.c about it */ - ResourceOwnerEnlargeSnapshots(owner); + ResourceOwnerEnlarge(owner); snap->regd_count++; ResourceOwnerRememberSnapshot(owner, snap); @@ -832,11 +858,16 @@ UnregisterSnapshotFromOwner(Snapshot snapshot, ResourceOwner owner) if (snapshot == NULL) return; + ResourceOwnerForgetSnapshot(owner, snapshot); + UnregisterSnapshotNoOwner(snapshot); +} + +static void +UnregisterSnapshotNoOwner(Snapshot snapshot) +{ Assert(snapshot->regd_count > 0); Assert(!pairingheap_is_empty(&RegisteredSnapshots)); - ResourceOwnerForgetSnapshot(owner, snapshot); - snapshot->regd_count--; if (snapshot->regd_count == 0) pairingheap_remove(&RegisteredSnapshots, &snapshot->ph_node); @@ -1923,3 +1954,11 @@ XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot) return false; } + +/* ResourceOwner callbacks */ + +static void +ResOwnerReleaseSnapshot(Datum res) +{ + UnregisterSnapshotNoOwner((Snapshot) DatumGetPointer(res)); +} |