#include "postgres.h"
#include "common/hashfn.h"
#include "common/int.h"
#include "storage/ipc.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "utils/memutils.h"
#include "utils/resowner.h"

Include dependency graph for resowner.c:

Data Structures
struct	ResourceElem

struct	ResourceOwnerData

struct	ResourceReleaseCallbackItem

Macros
#define	RESOWNER_ARRAY_SIZE 32

#define	RESOWNER_HASH_INIT_SIZE 64

#define	RESOWNER_HASH_MAX_ITEMS(capacity) Min(capacity - RESOWNER_ARRAY_SIZE, (capacity)/4 * 3)

#define	MAX_RESOWNER_LOCKS 15

Typedefs
typedef struct ResourceElem	ResourceElem

typedef struct ResourceOwnerData	ResourceOwnerData

typedef struct ResourceReleaseCallbackItem	ResourceReleaseCallbackItem

Functions
	StaticAssertDecl (RESOWNER_HASH_MAX_ITEMS(RESOWNER_HASH_INIT_SIZE) >=RESOWNER_ARRAY_SIZE, "initial hash size too small compared to array size")

static 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)

ResourceOwner	ResourceOwnerCreate (ResourceOwner parent, const char *name)

void	ResourceOwnerEnlarge (ResourceOwner owner)

void	ResourceOwnerRemember (ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)

void	ResourceOwnerForget (ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)

void	ResourceOwnerRelease (ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)

void	ResourceOwnerReleaseAllOfKind (ResourceOwner owner, const ResourceOwnerDesc *kind)

void	ResourceOwnerDelete (ResourceOwner owner)

ResourceOwner	ResourceOwnerGetParent (ResourceOwner owner)

void	ResourceOwnerNewParent (ResourceOwner owner, ResourceOwner newparent)

void	RegisterResourceReleaseCallback (ResourceReleaseCallback callback, void *arg)

void	UnregisterResourceReleaseCallback (ResourceReleaseCallback callback, void *arg)

void	CreateAuxProcessResourceOwner (void)

void	ReleaseAuxProcessResources (bool isCommit)

void	ResourceOwnerRememberLock (ResourceOwner owner, LOCALLOCK *locallock)

void	ResourceOwnerForgetLock (ResourceOwner owner, LOCALLOCK *locallock)

Variables
ResourceOwner	CurrentResourceOwner = NULL

ResourceOwner	CurTransactionResourceOwner = NULL

ResourceOwner	TopTransactionResourceOwner = NULL

ResourceOwner	AuxProcessResourceOwner = NULL

static ResourceReleaseCallbackItem *	ResourceRelease_callbacks = NULL

Macro Definition Documentation

◆ MAX_RESOWNER_LOCKS

#define MAX_RESOWNER_LOCKS 15

Definition at line 105 of file resowner.c.

◆ RESOWNER_ARRAY_SIZE

#define RESOWNER_ARRAY_SIZE 32

Definition at line 71 of file resowner.c.

◆ RESOWNER_HASH_INIT_SIZE

#define RESOWNER_HASH_INIT_SIZE 64

Definition at line 77 of file resowner.c.

◆ RESOWNER_HASH_MAX_ITEMS

#define RESOWNER_HASH_MAX_ITEMS ( capacity ) Min(capacity - RESOWNER_ARRAY_SIZE, (capacity)/4 * 3)

Definition at line 89 of file resowner.c.

Typedef Documentation

◆ ResourceElem

typedef struct ResourceElem ResourceElem

◆ ResourceOwnerData

typedef struct ResourceOwnerData ResourceOwnerData

◆ ResourceReleaseCallbackItem

typedef struct ResourceReleaseCallbackItem ResourceReleaseCallbackItem

Function Documentation

◆ CreateAuxProcessResourceOwner()

void CreateAuxProcessResourceOwner ( void )

Definition at line 982 of file resowner.c.

 {
     Assert(AuxProcessResourceOwner == NULL);
     Assert(CurrentResourceOwner == NULL);
     AuxProcessResourceOwner = ResourceOwnerCreate(NULL, "AuxiliaryProcess");
     CurrentResourceOwner = AuxProcessResourceOwner;
  
     /*
      * Register a shmem-exit callback for cleanup of aux-process resource
      * owner.  (This needs to run after, e.g., ShutdownXLOG.)
      */
     on_shmem_exit(ReleaseAuxProcessResourcesCallback, 0);
 }

References Assert, AuxProcessResourceOwner, CurrentResourceOwner, on_shmem_exit(), ReleaseAuxProcessResourcesCallback(), and ResourceOwnerCreate().

Referenced by AuxiliaryProcessMainCommon(), and InitPostgres().

◆ hash_resource_elem()

static uint32 hash_resource_elem	(	Datum	value,
		const ResourceOwnerDesc *	kind
	)

inlinestatic

Definition at line 214 of file resowner.c.

 {
     /*
      * Most resource kinds store a pointer in 'value', and pointers are unique
      * all on their own.  But some resources store plain integers (Files and
      * Buffers as of this writing), so we want to incorporate the 'kind' in
      * the hash too, otherwise those resources will collide a lot.  But
      * because there are only a few resource kinds like that - and only a few
      * resource kinds to begin with - we don't need to work too hard to mix
      * 'kind' into the hash.  Just add it with hash_combine(), it perturbs the
      * result enough for our purposes.
      */
 #if SIZEOF_DATUM == 8
     return hash_combine64(murmurhash64((uint64) value), (uint64) kind);
 #else
     return hash_combine(murmurhash32((uint32) value), (uint32) kind);
 #endif
 }

References hash_combine(), hash_combine64(), murmurhash32(), murmurhash64(), and value.

Referenced by ResourceOwnerAddToHash(), and ResourceOwnerForget().

◆ RegisterResourceReleaseCallback()

void RegisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 944 of file resowner.c.

 {
     ResourceReleaseCallbackItem *item;
  
     item = (ResourceReleaseCallbackItem *)
         MemoryContextAlloc(TopMemoryContext,
                            sizeof(ResourceReleaseCallbackItem));
     item->callback = callback;
     item->arg = arg;
     item->next = ResourceRelease_callbacks;
     ResourceRelease_callbacks = item;
 }

References ResourceReleaseCallbackItem::arg, arg, ResourceReleaseCallbackItem::callback, callback(), MemoryContextAlloc(), ResourceReleaseCallbackItem::next, ResourceRelease_callbacks, and TopMemoryContext.

◆ ReleaseAuxProcessResources()

void ReleaseAuxProcessResources ( bool isCommit )

Definition at line 1002 of file resowner.c.

 {
     /*
      * At this writing, the only thing that could actually get released is
      * buffer pins; but we may as well do the full release protocol.
      */
     ResourceOwnerRelease(AuxProcessResourceOwner,
                          RESOURCE_RELEASE_BEFORE_LOCKS,
                          isCommit, true);
     ResourceOwnerRelease(AuxProcessResourceOwner,
                          RESOURCE_RELEASE_LOCKS,
                          isCommit, true);
     ResourceOwnerRelease(AuxProcessResourceOwner,
                          RESOURCE_RELEASE_AFTER_LOCKS,
                          isCommit, true);
     /* allow it to be reused */
     AuxProcessResourceOwner->releasing = false;
     AuxProcessResourceOwner->sorted = false;
 }

References AuxProcessResourceOwner, ResourceOwnerData::releasing, RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerRelease(), and ResourceOwnerData::sorted.

Referenced by BackgroundWriterMain(), CheckpointerMain(), InitPostgres(), pgarch_archiveXlog(), ReleaseAuxProcessResourcesCallback(), WalSummarizerMain(), and WalWriterMain().

◆ ReleaseAuxProcessResourcesCallback()

static void ReleaseAuxProcessResourcesCallback	(	int	code,
		Datum	arg
	)

static

Definition at line 1027 of file resowner.c.

 {
     bool        isCommit = (code == 0);
  
     ReleaseAuxProcessResources(isCommit);
 }

References ReleaseAuxProcessResources().

Referenced by CreateAuxProcessResourceOwner().

◆ resource_priority_cmp()

static int resource_priority_cmp	(	const void *	a,
		const void *	b
	)

static

Definition at line 261 of file resowner.c.

 {
     const ResourceElem *ra = (const ResourceElem *) a;
     const ResourceElem *rb = (const ResourceElem *) b;
  
     /* Note: reverse order */
     if (ra->kind->release_phase == rb->kind->release_phase)
         return pg_cmp_u32(rb->kind->release_priority, ra->kind->release_priority);
     else if (ra->kind->release_phase > rb->kind->release_phase)
         return -1;
     else
         return 1;
 }

References a, b, ResourceElem::kind, pg_cmp_u32(), ResourceOwnerDesc::release_phase, and ResourceOwnerDesc::release_priority.

Referenced by ResourceOwnerSort().

◆ ResourceOwnerAddToHash()

static void ResourceOwnerAddToHash	(	ResourceOwner	owner,
		Datum	value,
		const ResourceOwnerDesc *	kind
	)

static

Definition at line 237 of file resowner.c.

 {
     uint32      mask = owner->capacity - 1;
     uint32      idx;
  
     Assert(kind != NULL);
  
     /* Insert into first free slot at or after hash location. */
     idx = hash_resource_elem(value, kind) & mask;
     for (;;)
     {
         if (owner->hash[idx].kind == NULL)
             break;              /* found a free slot */
         idx = (idx + 1) & mask;
     }
     owner->hash[idx].item = value;
     owner->hash[idx].kind = kind;
     owner->nhash++;
 }

References Assert, ResourceOwnerData::capacity, ResourceOwnerData::hash, hash_resource_elem(), idx(), ResourceElem::item, ResourceElem::kind, ResourceOwnerData::nhash, and value.

Referenced by ResourceOwnerEnlarge().

◆ ResourceOwnerCreate()

ResourceOwner ResourceOwnerCreate	(	ResourceOwner	parent,
		const char *	name
	)

Definition at line 413 of file resowner.c.

 {
     ResourceOwner owner;
  
     owner = (ResourceOwner) MemoryContextAllocZero(TopMemoryContext,
                                                    sizeof(ResourceOwnerData));
     owner->name = name;
  
     if (parent)
     {
         owner->parent = parent;
         owner->nextchild = parent->firstchild;
         parent->firstchild = owner;
     }
  
     return owner;
 }

References ResourceOwnerData::firstchild, MemoryContextAllocZero(), name, ResourceOwnerData::name, ResourceOwnerData::nextchild, ResourceOwnerData::parent, and TopMemoryContext.

Referenced by AtStart_ResourceOwner(), AtSubStart_ResourceOwner(), CreateAuxProcessResourceOwner(), CreatePortal(), perform_base_backup(), plpgsql_call_handler(), plpgsql_create_econtext(), plpgsql_inline_handler(), test_dsa_resowners(), test_resowner_forget_between_phases(), test_resowner_leak(), test_resowner_many(), test_resowner_priorities(), test_resowner_remember_between_phases(), and UploadManifest().

◆ ResourceOwnerDelete()

void ResourceOwnerDelete ( ResourceOwner owner )

Definition at line 854 of file resowner.c.

 {
     /* We had better not be deleting CurrentResourceOwner ... */
     Assert(owner != CurrentResourceOwner);
  
     /* And it better not own any resources, either */
     Assert(owner->narr == 0);
     Assert(owner->nhash == 0);
     Assert(owner->nlocks == 0 || owner->nlocks == MAX_RESOWNER_LOCKS + 1);
  
     /*
      * Delete children.  The recursive call will delink the child from me, so
      * just iterate as long as there is a child.
      */
     while (owner->firstchild != NULL)
         ResourceOwnerDelete(owner->firstchild);
  
     /*
      * We delink the owner from its parent before deleting it, so that if
      * there's an error we won't have deleted/busted owners still attached to
      * the owner tree.  Better a leak than a crash.
      */
     ResourceOwnerNewParent(owner, NULL);
  
     /* And free the object. */
     if (owner->hash)
         pfree(owner->hash);
     pfree(owner);
 }

References Assert, CurrentResourceOwner, ResourceOwnerData::firstchild, ResourceOwnerData::hash, MAX_RESOWNER_LOCKS, ResourceOwnerData::narr, ResourceOwnerData::nhash, ResourceOwnerData::nlocks, pfree(), and ResourceOwnerNewParent().

Referenced by CleanupSubTransaction(), CleanupTransaction(), CommitSubTransaction(), CommitTransaction(), plpgsql_call_handler(), plpgsql_inline_handler(), PortalDrop(), PrepareTransaction(), test_dsa_resowners(), test_resowner_leak(), test_resowner_many(), test_resowner_priorities(), and WalSndResourceCleanup().

◆ ResourceOwnerEnlarge()

void ResourceOwnerEnlarge ( ResourceOwner owner )

Definition at line 442 of file resowner.c.

 {
     /*
      * 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);
 }

References ResourceOwnerData::arr, Assert, ResourceOwnerData::capacity, elog, ERROR, ResourceOwnerData::grow_at, ResourceOwnerData::hash, i, ResourceElem::item, ResourceElem::kind, MemoryContextAllocZero(), ResourceOwnerData::narr, ResourceOwnerData::nhash, pfree(), ResourceOwnerData::releasing, ResourceOwnerAddToHash(), RESOWNER_ARRAY_SIZE, RESOWNER_HASH_INIT_SIZE, RESOWNER_HASH_MAX_ITEMS, and TopMemoryContext.

Referenced by BufferAlloc(), CachedPlanAllowsSimpleValidityCheck(), CachedPlanIsSimplyValid(), CreateWaitEventSet(), dsm_create_descriptor(), dsm_unpin_mapping(), EvictUnpinnedBuffer(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetCachedPlan(), GetLocalVictimBuffer(), GetVictimBuffer(), IncrBufferRefCount(), IncrTupleDescRefCount(), llvm_create_context(), LocalBufferAlloc(), OpenTemporaryFile(), PathNameCreateTemporaryFile(), PathNameOpenTemporaryFile(), pg_cryptohash_create(), pg_hmac_create(), px_find_cipher(), px_find_digest(), ReadRecentBuffer(), RegisterSnapshotOnOwner(), RelationIncrementReferenceCount(), RememberManyTestResources(), SearchCatCacheInternal(), SearchCatCacheList(), SearchCatCacheMiss(), StartBufferIO(), SyncOneBuffer(), test_resowner_forget_between_phases(), test_resowner_leak(), test_resowner_priorities(), and test_resowner_remember_between_phases().

◆ ResourceOwnerForget()

void ResourceOwnerForget	(	ResourceOwner	owner,
		Datum	value,
		const ResourceOwnerDesc *	kind
	)

Definition at line 554 of file resowner.c.

 {
     /*
      * 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);
 }

References ResourceOwnerData::arr, Assert, ResourceOwnerData::capacity, DatumGetPointer(), elog, ERROR, ResourceOwnerData::hash, hash_resource_elem(), i, idx(), ResourceElem::item, ResourceElem::kind, ResourceOwnerData::name, ResourceOwnerDesc::name, ResourceOwnerData::narr, ResourceOwnerData::nhash, ResourceOwnerData::releasing, ResourceOwnerData::sorted, and value.

◆ ResourceOwnerForgetLock()

void ResourceOwnerForgetLock	(	ResourceOwner	owner,
		LOCALLOCK *	locallock
	)

Definition at line 1065 of file resowner.c.

 {
     int         i;
  
     if (owner->nlocks > MAX_RESOWNER_LOCKS)
         return;                 /* we have overflowed */
  
     Assert(owner->nlocks > 0);
     for (i = owner->nlocks - 1; i >= 0; i--)
     {
         if (locallock == owner->locks[i])
         {
             owner->locks[i] = owner->locks[owner->nlocks - 1];
             owner->nlocks--;
             return;
         }
     }
     elog(ERROR, "lock reference %p is not owned by resource owner %s",
          locallock, owner->name);
 }

References Assert, elog, ERROR, i, ResourceOwnerData::locks, MAX_RESOWNER_LOCKS, ResourceOwnerData::name, and ResourceOwnerData::nlocks.

Referenced by LockReassignOwner(), LockRelease(), LockReleaseAll(), ReleaseLockIfHeld(), and RemoveLocalLock().

◆ ResourceOwnerGetParent()

ResourceOwner ResourceOwnerGetParent ( ResourceOwner owner )

Definition at line 888 of file resowner.c.

 {
     return owner->parent;
 }

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

◆ ResourceOwnerNewParent()

void ResourceOwnerNewParent	(	ResourceOwner	owner,
		ResourceOwner	newparent
	)

Definition at line 897 of file resowner.c.

 {
     ResourceOwner oldparent = owner->parent;
  
     if (oldparent)
     {
         if (owner == oldparent->firstchild)
             oldparent->firstchild = owner->nextchild;
         else
         {
             ResourceOwner child;
  
             for (child = oldparent->firstchild; child; child = child->nextchild)
             {
                 if (owner == child->nextchild)
                 {
                     child->nextchild = owner->nextchild;
                     break;
                 }
             }
         }
     }
  
     if (newparent)
     {
         Assert(owner != newparent);
         owner->parent = newparent;
         owner->nextchild = newparent->firstchild;
         newparent->firstchild = owner;
     }
     else
     {
         owner->parent = NULL;
         owner->nextchild = NULL;
     }
 }

References Assert, ResourceOwnerData::firstchild, ResourceOwnerData::nextchild, and ResourceOwnerData::parent.

Referenced by AtSubAbort_Portals(), AtSubCommit_Portals(), and ResourceOwnerDelete().

◆ ResourceOwnerRelease()

void ResourceOwnerRelease	(	ResourceOwner	owner,
		ResourceReleasePhase	phase,
		bool	isCommit,
		bool	isTopLevel
	)

Definition at line 648 of file resowner.c.

 {
     /* 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
 }

References elog, LOG, and ResourceOwnerReleaseInternal().

Referenced by AbortSubTransaction(), AbortTransaction(), CommitSubTransaction(), CommitTransaction(), PortalDrop(), PrepareTransaction(), ReleaseAuxProcessResources(), test_dsa_resowners(), test_resowner_forget_between_phases(), test_resowner_leak(), test_resowner_many(), test_resowner_priorities(), test_resowner_remember_between_phases(), and WalSndResourceCleanup().

◆ ResourceOwnerReleaseAll()

static void ResourceOwnerReleaseAll	(	ResourceOwner	owner,
		ResourceReleasePhase	phase,
		bool	printLeakWarnings
	)

static

Definition at line 340 of file resowner.c.

 {
     ResourceElem *items;
     uint32      nitems;
  
     /*
      * ResourceOwnerSort must've been called already.  All the resources are
      * either in the array or the hash.
      */
     Assert(owner->releasing);
     Assert(owner->sorted);
     if (owner->nhash == 0)
     {
         items = owner->arr;
         nitems = owner->narr;
     }
     else
     {
         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;
  
         if (kind->release_phase > phase)
             break;
         Assert(kind->release_phase == phase);
  
         if (printLeakWarnings)
         {
             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--;
     }
     if (owner->nhash == 0)
         owner->narr = nitems;
     else
         owner->nhash = nitems;
 }

References ResourceOwnerData::arr, Assert, DatumGetPointer(), ResourceOwnerDesc::DebugPrint, elog, ResourceOwnerData::hash, idx(), items, ResourceOwnerDesc::name, ResourceOwnerData::narr, ResourceOwnerData::nhash, nitems, pfree(), psprintf(), ResourceOwnerDesc::release_phase, ResourceOwnerDesc::ReleaseResource, ResourceOwnerData::releasing, ResourceOwnerData::sorted, value, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ ResourceOwnerReleaseAllOfKind()

void ResourceOwnerReleaseAllOfKind	(	ResourceOwner	owner,
		const ResourceOwnerDesc *	kind
	)

Definition at line 801 of file resowner.c.

 {
     /* 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;
  
     /* Array first */
     for (int i = 0; i < owner->narr; i++)
     {
         if (owner->arr[i].kind == kind)
         {
             Datum       value = owner->arr[i].item;
  
             owner->arr[i] = owner->arr[owner->narr - 1];
             owner->narr--;
             i--;
  
             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;
 }

References ResourceOwnerData::arr, Assert, ResourceOwnerData::capacity, elog, ERROR, ResourceOwnerData::hash, i, ResourceElem::item, ResourceElem::kind, ResourceOwnerDesc::name, ResourceOwnerData::narr, ResourceOwnerData::nhash, ResourceOwnerDesc::ReleaseResource, ResourceOwnerData::releasing, ResourceOwnerData::sorted, and value.

Referenced by ReleaseAllPlanCacheRefsInOwner().

◆ ResourceOwnerReleaseInternal()

static void ResourceOwnerReleaseInternal	(	ResourceOwner	owner,
		ResourceReleasePhase	phase,
		bool	isCommit,
		bool	isTopLevel
	)

static

Definition at line 668 of file resowner.c.

 {
     ResourceOwner child;
     ResourceOwner save;
     ResourceReleaseCallbackItem *item;
     ResourceReleaseCallbackItem *next;
  
     /* Recurse to handle descendants */
     for (child = owner->firstchild; child != NULL; child = child->nextchild)
         ResourceOwnerReleaseInternal(child, phase, isCommit, isTopLevel);
  
     /*
      * 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.
      */
     if (!owner->releasing)
     {
         Assert(phase == RESOURCE_RELEASE_BEFORE_LOCKS);
         Assert(!owner->sorted);
         owner->releasing = true;
     }
     else
     {
         /*
          * 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.
          */
     }
     if (!owner->sorted)
     {
         ResourceOwnerSort(owner);
         owner->sorted = true;
     }
  
     /*
      * 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 all resources that need to be released before the locks.
          *
          * 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.
          */
         ResourceOwnerReleaseAll(owner, phase, isCommit);
     }
     else if (phase == RESOURCE_RELEASE_LOCKS)
     {
         if (isTopLevel)
         {
             /*
              * For a top-level xact we are going to release all locks (or at
              * least all non-session locks), so just do a single lmgr call at
              * the top of the recursion.
              */
             if (owner == TopTransactionResourceOwner)
             {
                 ProcReleaseLocks(isCommit);
                 ReleasePredicateLocks(isCommit, false);
             }
         }
         else
         {
             /*
              * Release locks retail.  Note that if we are committing a
              * subtransaction, we do NOT release its locks yet, but transfer
              * them to the parent.
              */
             LOCALLOCK **locks;
             int         nlocks;
  
             Assert(owner->parent != NULL);
  
             /*
              * Pass the list of locks owned by this resource owner to the lock
              * manager, unless it has overflowed.
              */
             if (owner->nlocks > MAX_RESOWNER_LOCKS)
             {
                 locks = NULL;
                 nlocks = 0;
             }
             else
             {
                 locks = owner->locks;
                 nlocks = owner->nlocks;
             }
  
             if (isCommit)
                 LockReassignCurrentOwner(locks, nlocks);
             else
                 LockReleaseCurrentOwner(locks, nlocks);
         }
     }
     else if (phase == RESOURCE_RELEASE_AFTER_LOCKS)
     {
         /*
          * Release all resources that need to be released after the locks.
          */
         ResourceOwnerReleaseAll(owner, phase, isCommit);
     }
  
     /* Let add-on modules get a chance too */
     for (item = ResourceRelease_callbacks; item; item = next)
     {
         /* allow callbacks to unregister themselves when called */
         next = item->next;
         item->callback(phase, isCommit, isTopLevel, item->arg);
     }
  
     CurrentResourceOwner = save;
 }

References ResourceReleaseCallbackItem::arg, Assert, ResourceReleaseCallbackItem::callback, CurrentResourceOwner, ResourceOwnerData::firstchild, LockReassignCurrentOwner(), LockReleaseCurrentOwner(), ResourceOwnerData::locks, MAX_RESOWNER_LOCKS, next, ResourceReleaseCallbackItem::next, ResourceOwnerData::nextchild, ResourceOwnerData::nlocks, ResourceOwnerData::parent, ProcReleaseLocks(), ReleasePredicateLocks(), ResourceOwnerData::releasing, RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerReleaseAll(), ResourceOwnerSort(), ResourceRelease_callbacks, ResourceOwnerData::sorted, and TopTransactionResourceOwner.

Referenced by ResourceOwnerRelease().

◆ ResourceOwnerRemember()

void ResourceOwnerRemember	(	ResourceOwner	owner,
		Datum	value,
		const ResourceOwnerDesc *	kind
	)

Definition at line 514 of file resowner.c.

 {
     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++;
 }

References ResourceOwnerData::arr, Assert, elog, ERROR, idx(), ResourceElem::item, ResourceElem::kind, ResourceOwnerData::narr, ResourceOwnerDesc::release_phase, ResourceOwnerDesc::release_priority, ResourceOwnerData::releasing, RESOWNER_ARRAY_SIZE, ResourceOwnerData::sorted, and value.

◆ ResourceOwnerRememberLock()

void ResourceOwnerRememberLock	(	ResourceOwner	owner,
		LOCALLOCK *	locallock
	)

Definition at line 1045 of file resowner.c.

 {
     Assert(locallock != NULL);
  
     if (owner->nlocks > MAX_RESOWNER_LOCKS)
         return;                 /* we have already overflowed */
  
     if (owner->nlocks < MAX_RESOWNER_LOCKS)
         owner->locks[owner->nlocks] = locallock;
     else
     {
         /* overflowed */
     }
     owner->nlocks++;
 }

References Assert, ResourceOwnerData::locks, MAX_RESOWNER_LOCKS, and ResourceOwnerData::nlocks.

Referenced by GrantLockLocal(), and LockReassignOwner().

◆ ResourceOwnerSort()

static void ResourceOwnerSort ( ResourceOwner owner )

static

Definition at line 284 of file resowner.c.

 {
     ResourceElem *items;
     uint32      nitems;
  
     if (owner->nhash == 0)
     {
         items = owner->arr;
         nitems = owner->narr;
     }
     else
     {
         /*
          * Compact the hash table, so that all the elements are in the
          * beginning of the 'hash' array, with no empty elements.
          */
         uint32      dst = 0;
  
         for (int idx = 0; idx < owner->capacity; idx++)
         {
             if (owner->hash[idx].kind != NULL)
             {
                 if (dst != idx)
                     owner->hash[dst] = owner->hash[idx];
                 dst++;
             }
         }
  
         /*
          * 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;
     }
  
     qsort(items, nitems, sizeof(ResourceElem), resource_priority_cmp);
 }

References ResourceOwnerData::arr, Assert, ResourceOwnerData::capacity, ResourceOwnerData::hash, idx(), items, ResourceElem::kind, ResourceOwnerData::narr, ResourceOwnerData::nhash, nitems, qsort, and resource_priority_cmp().

Referenced by ResourceOwnerReleaseInternal().

◆ StaticAssertDecl()

StaticAssertDecl	(	RESOWNER_HASH_MAX_ITEMS(RESOWNER_HASH_INIT_SIZE) >=	RESOWNER_ARRAY_SIZE,
		"initial hash size too small compared to array size"
	)

◆ UnregisterResourceReleaseCallback()

void UnregisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 958 of file resowner.c.

 {
     ResourceReleaseCallbackItem *item;
     ResourceReleaseCallbackItem *prev;
  
     prev = NULL;
     for (item = ResourceRelease_callbacks; item; prev = item, item = item->next)
     {
         if (item->callback == callback && item->arg == arg)
         {
             if (prev)
                 prev->next = item->next;
             else
                 ResourceRelease_callbacks = item->next;
             pfree(item);
             break;
         }
     }
 }

References ResourceReleaseCallbackItem::arg, arg, ResourceReleaseCallbackItem::callback, callback(), ResourceReleaseCallbackItem::next, pfree(), and ResourceRelease_callbacks.

Variable Documentation

◆ AuxProcessResourceOwner

ResourceOwner AuxProcessResourceOwner = NULL

Definition at line 168 of file resowner.c.

Referenced by CreateAuxProcessResourceOwner(), ReleaseAuxProcessResources(), ShutdownXLOG(), and StartupXLOG().

◆ CurrentResourceOwner

ResourceOwner CurrentResourceOwner = NULL

Definition at line 165 of file resowner.c.

Referenced by _SPI_execute_plan(), AbortSubTransaction(), apply_spooled_messages(), AssignTransactionId(), AtAbort_ResourceOwner(), AtStart_ResourceOwner(), AtSubAbort_ResourceOwner(), AtSubStart_ResourceOwner(), attach_internal(), BufferAlloc(), CleanupSubTransaction(), CleanupTransaction(), close_lo_relation(), CommitSubTransaction(), CommitTransaction(), create_internal(), CreateAuxProcessResourceOwner(), DecrTupleDescRefCount(), dsm_create_descriptor(), dsm_unpin_mapping(), EvictUnpinnedBuffer(), exec_eval_simple_expr(), exec_init_tuple_store(), exec_simple_check_plan(), exec_stmt_block(), ExecAppendAsyncEventWait(), ExplainExecuteQuery(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), extendBufFile(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), get_segment_by_index(), GetCurrentFDWTuplestore(), GetLocalVictimBuffer(), GetVictimBuffer(), IncrBufferRefCount(), IncrTupleDescRefCount(), InitPostgres(), llvm_create_context(), LocalBufferAlloc(), lock_and_open_sequence(), LockAcquireExtended(), LockReassignCurrentOwner(), LockReassignOwner(), LockRelease(), LogicalSlotAdvanceAndCheckSnapState(), make_new_segment(), makeBufFileCommon(), MakeTransitionCaptureState(), open_lo_relation(), OpenTemporaryFile(), PathNameCreateTemporaryFile(), PathNameOpenTemporaryFile(), perform_base_backup(), PersistHoldablePortal(), pg_cryptohash_create(), pg_hmac_create(), pg_logical_slot_get_changes_guts(), PinBuffer(), PinBuffer_Locked(), PinLocalBuffer(), plperl_spi_exec(), plperl_spi_exec_prepared(), plperl_spi_fetchrow(), plperl_spi_prepare(), plperl_spi_query(), plperl_spi_query_prepared(), plpgsql_estate_setup(), pltcl_func_handler(), pltcl_init_tuple_store(), pltcl_returnnext(), pltcl_SPI_execute(), pltcl_SPI_execute_plan(), pltcl_SPI_prepare(), pltcl_subtrans_abort(), pltcl_subtrans_commit(), pltcl_subtransaction(), PLy_abort_open_subtransactions(), PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_cursor_plan(), PLy_cursor_query(), PLy_spi_execute_plan(), PLy_spi_execute_query(), PLy_spi_prepare(), PLy_spi_subtransaction_abort(), PLy_spi_subtransaction_commit(), PLy_subtransaction_enter(), PLy_subtransaction_exit(), PopTransaction(), PortalCleanup(), PortalRun(), PortalRunFetch(), PortalStart(), PrepareTransaction(), px_find_cipher(), px_find_digest(), ReadRecentBuffer(), RegisterSnapshot(), RegisterTemporaryFile(), RelationDecrementReferenceCount(), RelationIncrementReferenceCount(), ReleaseCatCache(), ReleaseCatCacheList(), ReleaseCatCacheListWithOwner(), ReleaseCatCacheWithOwner(), ReleaseLockIfHeld(), ResourceOwnerDelete(), ResourceOwnerReleaseInternal(), SearchCatCacheInternal(), SearchCatCacheList(), SearchCatCacheMiss(), ShutdownXLOG(), SnapBuildClearExportedSnapshot(), SnapBuildExportSnapshot(), SPI_plan_get_cached_plan(), StartBufferIO(), StartupXLOG(), SyncOneBuffer(), TerminateBufferIO(), test_dsa_resowners(), test_resowner_forget_between_phases(), test_resowner_leak(), test_resowner_many(), test_resowner_priorities(), test_resowner_remember_between_phases(), tuplestore_begin_common(), tuplestore_puttuple_common(), UnpinBuffer(), UnpinLocalBuffer(), UnregisterSnapshot(), UploadManifest(), WaitLatchOrSocket(), and WalSndResourceCleanup().

◆ CurTransactionResourceOwner

ResourceOwner CurTransactionResourceOwner = NULL

Definition at line 166 of file resowner.c.

Referenced by AtStart_ResourceOwner(), AtSubStart_ResourceOwner(), CleanupSubTransaction(), CleanupTransaction(), CommitSubTransaction(), CommitTransaction(), CreatePortal(), GetCurrentFDWTuplestore(), MakeTransitionCaptureState(), PopTransaction(), and PrepareTransaction().

◆ ResourceRelease_callbacks

ResourceReleaseCallbackItem* ResourceRelease_callbacks = NULL

static

Definition at line 187 of file resowner.c.

Referenced by RegisterResourceReleaseCallback(), ResourceOwnerReleaseInternal(), and UnregisterResourceReleaseCallback().

◆ TopTransactionResourceOwner

ResourceOwner TopTransactionResourceOwner = NULL

Definition at line 167 of file resowner.c.

Referenced by AbortTransaction(), apply_spooled_messages(), AtAbort_ResourceOwner(), AtStart_ResourceOwner(), be_lo_open(), CleanupTransaction(), close_lo_relation(), closeLOfd(), CommitTransaction(), lock_and_open_sequence(), open_lo_relation(), plpgsql_create_econtext(), PortalRun(), PrepareTransaction(), and ResourceOwnerReleaseInternal().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ MAX_RESOWNER_LOCKS

◆ RESOWNER_ARRAY_SIZE

◆ RESOWNER_HASH_INIT_SIZE

◆ RESOWNER_HASH_MAX_ITEMS

Typedef Documentation

◆ ResourceElem

◆ ResourceOwnerData

◆ ResourceReleaseCallbackItem

Function Documentation

◆ CreateAuxProcessResourceOwner()

◆ hash_resource_elem()

◆ RegisterResourceReleaseCallback()

◆ ReleaseAuxProcessResources()

◆ ReleaseAuxProcessResourcesCallback()

◆ resource_priority_cmp()

◆ ResourceOwnerAddToHash()

◆ ResourceOwnerCreate()

◆ ResourceOwnerDelete()

◆ ResourceOwnerEnlarge()

◆ ResourceOwnerForget()

◆ ResourceOwnerForgetLock()

◆ ResourceOwnerGetParent()

◆ ResourceOwnerNewParent()

◆ ResourceOwnerRelease()

◆ ResourceOwnerReleaseAll()

◆ ResourceOwnerReleaseAllOfKind()

◆ ResourceOwnerReleaseInternal()

◆ ResourceOwnerRemember()

◆ ResourceOwnerRememberLock()

◆ ResourceOwnerSort()

◆ StaticAssertDecl()

◆ UnregisterResourceReleaseCallback()

Variable Documentation

◆ AuxProcessResourceOwner

◆ CurrentResourceOwner

◆ CurTransactionResourceOwner

◆ ResourceRelease_callbacks

◆ TopTransactionResourceOwner