#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"

Include dependency graph for resowner.c:

Data Structures
struct	ResourceArray

struct	ResourceOwnerData

struct	ResourceReleaseCallbackItem

Macros
#define	FileGetDatum(file) Int32GetDatum(file)

#define	DatumGetFile(datum) ((File) DatumGetInt32(datum))

#define	BufferGetDatum(buffer) Int32GetDatum(buffer)

#define	DatumGetBuffer(datum) ((Buffer) DatumGetInt32(datum))

#define	RESARRAY_INIT_SIZE 16

#define	RESARRAY_MAX_ARRAY 64

#define	RESARRAY_IS_ARRAY(resarr) ((resarr)->capacity <= RESARRAY_MAX_ARRAY)

#define	RESARRAY_MAX_ITEMS(capacity) ((capacity) <= RESARRAY_MAX_ARRAY ? (capacity) : (capacity)/4 * 3)

#define	MAX_RESOWNER_LOCKS 15

Typedefs
typedef struct ResourceArray	ResourceArray

typedef struct ResourceOwnerData	ResourceOwnerData

typedef struct ResourceReleaseCallbackItem	ResourceReleaseCallbackItem

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

ResourceOwner	ResourceOwnerCreate (ResourceOwner parent, const char *name)

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

void	ResourceOwnerReleaseAllPlanCacheRefs (ResourceOwner owner)

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	ResourceOwnerEnlargeBuffers (ResourceOwner owner)

void	ResourceOwnerRememberBuffer (ResourceOwner owner, Buffer buffer)

void	ResourceOwnerForgetBuffer (ResourceOwner owner, Buffer buffer)

void	ResourceOwnerEnlargeBufferIOs (ResourceOwner owner)

void	ResourceOwnerRememberBufferIO (ResourceOwner owner, Buffer buffer)

void	ResourceOwnerForgetBufferIO (ResourceOwner owner, Buffer buffer)

void	ResourceOwnerRememberLock (ResourceOwner owner, LOCALLOCK *locallock)

void	ResourceOwnerForgetLock (ResourceOwner owner, LOCALLOCK *locallock)

void	ResourceOwnerEnlargeCatCacheRefs (ResourceOwner owner)

void	ResourceOwnerRememberCatCacheRef (ResourceOwner owner, HeapTuple tuple)

void	ResourceOwnerForgetCatCacheRef (ResourceOwner owner, HeapTuple tuple)

void	ResourceOwnerEnlargeCatCacheListRefs (ResourceOwner owner)

void	ResourceOwnerRememberCatCacheListRef (ResourceOwner owner, CatCList *list)

void	ResourceOwnerForgetCatCacheListRef (ResourceOwner owner, CatCList *list)

void	ResourceOwnerEnlargeRelationRefs (ResourceOwner owner)

void	ResourceOwnerRememberRelationRef (ResourceOwner owner, Relation rel)

void	ResourceOwnerForgetRelationRef (ResourceOwner owner, Relation rel)

void	ResourceOwnerEnlargePlanCacheRefs (ResourceOwner owner)

void	ResourceOwnerRememberPlanCacheRef (ResourceOwner owner, CachedPlan *plan)

void	ResourceOwnerForgetPlanCacheRef (ResourceOwner owner, CachedPlan *plan)

void	ResourceOwnerEnlargeTupleDescs (ResourceOwner owner)

void	ResourceOwnerRememberTupleDesc (ResourceOwner owner, TupleDesc tupdesc)

void	ResourceOwnerForgetTupleDesc (ResourceOwner owner, TupleDesc tupdesc)

void	ResourceOwnerEnlargeSnapshots (ResourceOwner owner)

void	ResourceOwnerRememberSnapshot (ResourceOwner owner, Snapshot snapshot)

void	ResourceOwnerForgetSnapshot (ResourceOwner owner, Snapshot snapshot)

void	ResourceOwnerEnlargeFiles (ResourceOwner owner)

void	ResourceOwnerRememberFile (ResourceOwner owner, File file)

void	ResourceOwnerForgetFile (ResourceOwner owner, File file)

void	ResourceOwnerEnlargeDSMs (ResourceOwner owner)

void	ResourceOwnerRememberDSM (ResourceOwner owner, dsm_segment *seg)

void	ResourceOwnerForgetDSM (ResourceOwner owner, dsm_segment *seg)

void	ResourceOwnerEnlargeJIT (ResourceOwner owner)

void	ResourceOwnerRememberJIT (ResourceOwner owner, Datum handle)

void	ResourceOwnerForgetJIT (ResourceOwner owner, Datum handle)

void	ResourceOwnerEnlargeCryptoHash (ResourceOwner owner)

void	ResourceOwnerRememberCryptoHash (ResourceOwner owner, Datum handle)

void	ResourceOwnerForgetCryptoHash (ResourceOwner owner, Datum handle)

void	ResourceOwnerEnlargeHMAC (ResourceOwner owner)

void	ResourceOwnerRememberHMAC (ResourceOwner owner, Datum handle)

void	ResourceOwnerForgetHMAC (ResourceOwner owner, Datum handle)

Variables
ResourceOwner	CurrentResourceOwner = NULL

ResourceOwner	CurTransactionResourceOwner = NULL

ResourceOwner	TopTransactionResourceOwner = NULL

ResourceOwner	AuxProcessResourceOwner = NULL

static ResourceReleaseCallbackItem *	ResourceRelease_callbacks = NULL

Macro Definition Documentation

◆ BufferGetDatum

#define BufferGetDatum ( buffer ) Int32GetDatum(buffer)

Definition at line 46 of file resowner.c.

◆ DatumGetBuffer

#define DatumGetBuffer ( datum ) ((Buffer) DatumGetInt32(datum))

Definition at line 47 of file resowner.c.

◆ DatumGetFile

#define DatumGetFile ( datum ) ((File) DatumGetInt32(datum))

Definition at line 45 of file resowner.c.

◆ FileGetDatum

#define FileGetDatum ( file ) Int32GetDatum(file)

Definition at line 44 of file resowner.c.

◆ MAX_RESOWNER_LOCKS

#define MAX_RESOWNER_LOCKS 15

Definition at line 110 of file resowner.c.

◆ RESARRAY_INIT_SIZE

#define RESARRAY_INIT_SIZE 16

Definition at line 79 of file resowner.c.

◆ RESARRAY_IS_ARRAY

#define RESARRAY_IS_ARRAY ( resarr ) ((resarr)->capacity <= RESARRAY_MAX_ARRAY)

Definition at line 85 of file resowner.c.

◆ RESARRAY_MAX_ARRAY

#define RESARRAY_MAX_ARRAY 64

Definition at line 84 of file resowner.c.

◆ RESARRAY_MAX_ITEMS

#define RESARRAY_MAX_ITEMS ( capacity ) ((capacity) <= RESARRAY_MAX_ARRAY ? (capacity) : (capacity)/4 * 3)

Definition at line 91 of file resowner.c.

Typedef Documentation

◆ ResourceArray

typedef struct ResourceArray ResourceArray

◆ ResourceOwnerData

typedef struct ResourceOwnerData ResourceOwnerData

◆ ResourceReleaseCallbackItem

typedef struct ResourceReleaseCallbackItem ResourceReleaseCallbackItem

Function Documentation

◆ CreateAuxProcessResourceOwner()

void CreateAuxProcessResourceOwner ( void )

Definition at line 914 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 AuxiliaryProcessMain(), and InitPostgres().

◆ PrintCryptoHashLeakWarning()

static void PrintCryptoHashLeakWarning ( Datum handle )

static

Definition at line 1506 of file resowner.c.

 {
     elog(WARNING, "cryptohash context reference leak: context %p still referenced",
          DatumGetPointer(handle));
 }

References DatumGetPointer(), elog(), and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintDSMLeakWarning()

static void PrintDSMLeakWarning ( dsm_segment * seg )

static

Definition at line 1426 of file resowner.c.

 {
     elog(WARNING, "dynamic shared memory leak: segment %u still referenced",
          dsm_segment_handle(seg));
 }

References dsm_segment_handle(), elog(), and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintFileLeakWarning()

static void PrintFileLeakWarning ( File file )

static

Definition at line 1381 of file resowner.c.

 {
     elog(WARNING, "temporary file leak: File %d still referenced",
          file);
 }

References elog(), and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintHMACLeakWarning()

static void PrintHMACLeakWarning ( Datum handle )

static

Definition at line 1551 of file resowner.c.

 {
     elog(WARNING, "HMAC context reference leak: context %p still referenced",
          DatumGetPointer(handle));
 }

References DatumGetPointer(), elog(), and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintPlanCacheLeakWarning()

static void PrintPlanCacheLeakWarning ( CachedPlan * plan )

static

Definition at line 1245 of file resowner.c.

 {
     elog(WARNING, "plancache reference leak: plan %p not closed", plan);
 }

References elog(), plan, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintRelCacheLeakWarning()

static void PrintRelCacheLeakWarning ( Relation rel )

static

Definition at line 1200 of file resowner.c.

 {
     elog(WARNING, "relcache reference leak: relation \"%s\" not closed",
          RelationGetRelationName(rel));
 }

References elog(), RelationGetRelationName, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintSnapshotLeakWarning()

static void PrintSnapshotLeakWarning ( Snapshot snapshot )

static

Definition at line 1335 of file resowner.c.

 {
     elog(WARNING, "Snapshot reference leak: Snapshot %p still referenced",
          snapshot);
 }

References elog(), and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintTupleDescLeakWarning()

static void PrintTupleDescLeakWarning ( TupleDesc tupdesc )

static

Definition at line 1289 of file resowner.c.

 {
     elog(WARNING,
          "TupleDesc reference leak: TupleDesc %p (%u,%d) still referenced",
          tupdesc, tupdesc->tdtypeid, tupdesc->tdtypmod);
 }

References elog(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ RegisterResourceReleaseCallback()

void RegisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 876 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.

Referenced by px_find_cipher(), and px_find_digest().

◆ ReleaseAuxProcessResources()

void ReleaseAuxProcessResources ( bool isCommit )

Definition at line 934 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);
 }

References AuxProcessResourceOwner, RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, and ResourceOwnerRelease().

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

◆ ReleaseAuxProcessResourcesCallback()

static void ReleaseAuxProcessResourcesCallback	(	int	code,
		Datum	arg
	)

static

Definition at line 956 of file resowner.c.

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

References ReleaseAuxProcessResources().

Referenced by CreateAuxProcessResourceOwner().

◆ ResourceArrayAdd()

static void ResourceArrayAdd	(	ResourceArray *	resarr,
		Datum	value
	)

static

Definition at line 270 of file resowner.c.

 {
     uint32      idx;
  
     Assert(value != resarr->invalidval);
     Assert(resarr->nitems < resarr->maxitems);
  
     if (RESARRAY_IS_ARRAY(resarr))
     {
         /* Append to linear array. */
         idx = resarr->nitems;
     }
     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++;
 }

References Assert(), ResourceArray::capacity, DatumGetUInt32(), hash_any(), idx(), ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::lastidx, ResourceArray::maxitems, ResourceArray::nitems, RESARRAY_IS_ARRAY, and value.

Referenced by ResourceArrayEnlarge(), ResourceOwnerRememberBuffer(), ResourceOwnerRememberBufferIO(), ResourceOwnerRememberCatCacheListRef(), ResourceOwnerRememberCatCacheRef(), ResourceOwnerRememberCryptoHash(), ResourceOwnerRememberDSM(), ResourceOwnerRememberFile(), ResourceOwnerRememberHMAC(), ResourceOwnerRememberJIT(), ResourceOwnerRememberPlanCacheRef(), ResourceOwnerRememberRelationRef(), ResourceOwnerRememberSnapshot(), and ResourceOwnerRememberTupleDesc().

◆ ResourceArrayEnlarge()

static void ResourceArrayEnlarge ( ResourceArray * resarr )

static

Definition at line 215 of file resowner.c.

 {
     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;
  
     /* 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;
  
     if (olditemsarr != NULL)
     {
         /*
          * 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);
     }
  
     Assert(resarr->nitems < resarr->maxitems);
 }

References Assert(), ResourceArray::capacity, i, ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::maxitems, MemoryContextAlloc(), ResourceArray::nitems, pfree(), RESARRAY_INIT_SIZE, RESARRAY_MAX_ITEMS, ResourceArrayAdd(), and TopMemoryContext.

Referenced by ResourceOwnerEnlargeBufferIOs(), ResourceOwnerEnlargeBuffers(), ResourceOwnerEnlargeCatCacheListRefs(), ResourceOwnerEnlargeCatCacheRefs(), ResourceOwnerEnlargeCryptoHash(), ResourceOwnerEnlargeDSMs(), ResourceOwnerEnlargeFiles(), ResourceOwnerEnlargeHMAC(), ResourceOwnerEnlargeJIT(), ResourceOwnerEnlargePlanCacheRefs(), ResourceOwnerEnlargeRelationRefs(), ResourceOwnerEnlargeSnapshots(), and ResourceOwnerEnlargeTupleDescs().

◆ ResourceArrayFree()

static void ResourceArrayFree ( ResourceArray * resarr )

static

Definition at line 409 of file resowner.c.

 {
     if (resarr->itemsarr)
         pfree(resarr->itemsarr);
 }

References ResourceArray::itemsarr, and pfree().

Referenced by ResourceOwnerDelete().

◆ ResourceArrayGetAny()

static bool ResourceArrayGetAny	(	ResourceArray *	resarr,
		Datum *	value
	)

static

Definition at line 377 of file resowner.c.

 {
     if (resarr->nitems == 0)
         return false;
  
     if (RESARRAY_IS_ARRAY(resarr))
     {
         /* Linear array: just return the first element. */
         resarr->lastidx = 0;
     }
     else
     {
         /* Hash: search forward from wherever we were last. */
         uint32      mask = resarr->capacity - 1;
  
         for (;;)
         {
             resarr->lastidx &= mask;
             if (resarr->itemsarr[resarr->lastidx] != resarr->invalidval)
                 break;
             resarr->lastidx++;
         }
     }
  
     *value = resarr->itemsarr[resarr->lastidx];
     return true;
 }

References ResourceArray::capacity, ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::lastidx, ResourceArray::nitems, RESARRAY_IS_ARRAY, and value.

Referenced by ResourceOwnerReleaseAllPlanCacheRefs(), and ResourceOwnerReleaseInternal().

◆ ResourceArrayInit()

static void ResourceArrayInit	(	ResourceArray *	resarr,
		Datum	invalidval
	)

static

Definition at line 196 of file resowner.c.

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

References Assert(), ResourceArray::capacity, ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::maxitems, and ResourceArray::nitems.

Referenced by ResourceOwnerCreate().

◆ ResourceArrayRemove()

static bool ResourceArrayRemove	(	ResourceArray *	resarr,
		Datum	value
	)

static

Definition at line 308 of file resowner.c.

 {
     uint32      i,
                 idx,
                 lastidx = resarr->lastidx;
  
     Assert(value != resarr->invalidval);
  
     /* Search through all items, but try lastidx first. */
     if (RESARRAY_IS_ARRAY(resarr))
     {
         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;
             }
         }
     }
     else
     {
         uint32      mask = resarr->capacity - 1;
  
         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++)
         {
             if (resarr->itemsarr[idx] == value)
             {
                 resarr->itemsarr[idx] = resarr->invalidval;
                 resarr->nitems--;
                 return true;
             }
             idx = (idx + 1) & mask;
         }
     }
  
     return false;
 }

References Assert(), ResourceArray::capacity, DatumGetUInt32(), hash_any(), i, idx(), ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::lastidx, ResourceArray::nitems, nitems, RESARRAY_IS_ARRAY, and value.

Referenced by ResourceOwnerForgetBuffer(), ResourceOwnerForgetBufferIO(), ResourceOwnerForgetCatCacheListRef(), ResourceOwnerForgetCatCacheRef(), ResourceOwnerForgetCryptoHash(), ResourceOwnerForgetDSM(), ResourceOwnerForgetFile(), ResourceOwnerForgetHMAC(), ResourceOwnerForgetJIT(), ResourceOwnerForgetPlanCacheRef(), ResourceOwnerForgetRelationRef(), ResourceOwnerForgetSnapshot(), and ResourceOwnerForgetTupleDesc().

◆ ResourceOwnerCreate()

ResourceOwner ResourceOwnerCreate	(	ResourceOwner	parent,
		const char *	name
	)

Definition at line 429 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;
     }
  
     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;
 }

Referenced by AtStart_ResourceOwner(), AtSubStart_ResourceOwner(), CreateAuxProcessResourceOwner(), CreatePortal(), perform_base_backup(), plpgsql_call_handler(), plpgsql_create_econtext(), and plpgsql_inline_handler().

◆ ResourceOwnerDelete()

void ResourceOwnerDelete ( ResourceOwner owner )

Definition at line 762 of file resowner.c.

 {
     /* We had better not be deleting CurrentResourceOwner ... */
     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->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. */
     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));
  
     pfree(owner);
 }

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

◆ ResourceOwnerEnlargeBufferIOs()

void ResourceOwnerEnlargeBufferIOs ( ResourceOwner owner )

Definition at line 1010 of file resowner.c.

 {
     /* We used to allow pinning buffers without a resowner, but no more */
     Assert(owner != NULL);
     ResourceArrayEnlarge(&(owner->bufferioarr));
 }

References Assert(), ResourceOwnerData::bufferioarr, and ResourceArrayEnlarge().

Referenced by StartBufferIO().

◆ ResourceOwnerEnlargeBuffers()

void ResourceOwnerEnlargeBuffers ( ResourceOwner owner )

Definition at line 972 of file resowner.c.

 {
     /* We used to allow pinning buffers without a resowner, but no more */
     Assert(owner != NULL);
     ResourceArrayEnlarge(&(owner->bufferarr));
 }

References Assert(), ResourceOwnerData::bufferarr, and ResourceArrayEnlarge().

Referenced by BgBufferSync(), BufferSync(), ExtendBufferedRelShared(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetLocalVictimBuffer(), GetVictimBuffer(), IncrBufferRefCount(), ReadBuffer_common(), and ReadRecentBuffer().

◆ ResourceOwnerEnlargeCatCacheListRefs()

void ResourceOwnerEnlargeCatCacheListRefs ( ResourceOwner owner )

Definition at line 1134 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->catlistrefarr));
 }

References ResourceOwnerData::catlistrefarr, and ResourceArrayEnlarge().

Referenced by SearchCatCacheList().

◆ ResourceOwnerEnlargeCatCacheRefs()

void ResourceOwnerEnlargeCatCacheRefs ( ResourceOwner owner )

Definition at line 1099 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->catrefarr));
 }

References ResourceOwnerData::catrefarr, and ResourceArrayEnlarge().

Referenced by SearchCatCacheInternal(), and SearchCatCacheMiss().

◆ ResourceOwnerEnlargeCryptoHash()

void ResourceOwnerEnlargeCryptoHash ( ResourceOwner owner )

Definition at line 1475 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->cryptohasharr));
 }

References ResourceOwnerData::cryptohasharr, and ResourceArrayEnlarge().

Referenced by pg_cryptohash_create().

◆ ResourceOwnerEnlargeDSMs()

void ResourceOwnerEnlargeDSMs ( ResourceOwner owner )

Definition at line 1395 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->dsmarr));
 }

References ResourceOwnerData::dsmarr, and ResourceArrayEnlarge().

Referenced by dsm_create_descriptor(), and dsm_unpin_mapping().

◆ ResourceOwnerEnlargeFiles()

void ResourceOwnerEnlargeFiles ( ResourceOwner owner )

Definition at line 1350 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->filearr));
 }

References ResourceOwnerData::filearr, and ResourceArrayEnlarge().

Referenced by OpenTemporaryFile(), PathNameCreateTemporaryFile(), and PathNameOpenTemporaryFile().

◆ ResourceOwnerEnlargeHMAC()

void ResourceOwnerEnlargeHMAC ( ResourceOwner owner )

Definition at line 1520 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->hmacarr));
 }

References ResourceOwnerData::hmacarr, and ResourceArrayEnlarge().

Referenced by pg_hmac_create().

◆ ResourceOwnerEnlargeJIT()

void ResourceOwnerEnlargeJIT ( ResourceOwner owner )

Definition at line 1440 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->jitarr));
 }

References ResourceOwnerData::jitarr, and ResourceArrayEnlarge().

Referenced by llvm_create_context().

◆ ResourceOwnerEnlargePlanCacheRefs()

void ResourceOwnerEnlargePlanCacheRefs ( ResourceOwner owner )

Definition at line 1214 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->planrefarr));
 }

References ResourceOwnerData::planrefarr, and ResourceArrayEnlarge().

Referenced by CachedPlanAllowsSimpleValidityCheck(), CachedPlanIsSimplyValid(), and GetCachedPlan().

◆ ResourceOwnerEnlargeRelationRefs()

void ResourceOwnerEnlargeRelationRefs ( ResourceOwner owner )

Definition at line 1169 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->relrefarr));
 }

References ResourceOwnerData::relrefarr, and ResourceArrayEnlarge().

Referenced by RelationIncrementReferenceCount().

◆ ResourceOwnerEnlargeSnapshots()

void ResourceOwnerEnlargeSnapshots ( ResourceOwner owner )

Definition at line 1304 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->snapshotarr));
 }

References ResourceArrayEnlarge(), and ResourceOwnerData::snapshotarr.

Referenced by RegisterSnapshotOnOwner().

◆ ResourceOwnerEnlargeTupleDescs()

void ResourceOwnerEnlargeTupleDescs ( ResourceOwner owner )

Definition at line 1258 of file resowner.c.

 {
     ResourceArrayEnlarge(&(owner->tupdescarr));
 }

References ResourceArrayEnlarge(), and ResourceOwnerData::tupdescarr.

Referenced by IncrTupleDescRefCount().

◆ ResourceOwnerForgetBuffer()

void ResourceOwnerForgetBuffer	(	ResourceOwner	owner,
		Buffer	buffer
	)

Definition at line 994 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->bufferarr), BufferGetDatum(buffer)))
         elog(ERROR, "buffer %d is not owned by resource owner %s",
              buffer, owner->name);
 }

References ResourceOwnerData::bufferarr, BufferGetDatum, elog(), ERROR, ResourceOwnerData::name, and ResourceArrayRemove().

Referenced by UnpinBuffer(), and UnpinLocalBuffer().

◆ ResourceOwnerForgetBufferIO()

void ResourceOwnerForgetBufferIO	(	ResourceOwner	owner,
		Buffer	buffer
	)

Definition at line 1032 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->bufferioarr), BufferGetDatum(buffer)))
         elog(PANIC, "buffer IO %d is not owned by resource owner %s",
              buffer, owner->name);
 }

References BufferGetDatum, ResourceOwnerData::bufferioarr, elog(), ResourceOwnerData::name, PANIC, and ResourceArrayRemove().

Referenced by TerminateBufferIO().

◆ ResourceOwnerForgetCatCacheListRef()

void ResourceOwnerForgetCatCacheListRef	(	ResourceOwner	owner,
		CatCList *	list
	)

Definition at line 1154 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->catlistrefarr), PointerGetDatum(list)))
         elog(ERROR, "catcache list reference %p is not owned by resource owner %s",
              list, owner->name);
 }

References ResourceOwnerData::catlistrefarr, elog(), ERROR, sort-test::list, ResourceOwnerData::name, PointerGetDatum(), and ResourceArrayRemove().

Referenced by ReleaseCatCacheList().

◆ ResourceOwnerForgetCatCacheRef()

void ResourceOwnerForgetCatCacheRef	(	ResourceOwner	owner,
		HeapTuple	tuple
	)

Definition at line 1119 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->catrefarr), PointerGetDatum(tuple)))
         elog(ERROR, "catcache reference %p is not owned by resource owner %s",
              tuple, owner->name);
 }

References ResourceOwnerData::catrefarr, elog(), ERROR, ResourceOwnerData::name, PointerGetDatum(), and ResourceArrayRemove().

Referenced by ReleaseCatCache().

◆ ResourceOwnerForgetCryptoHash()

void ResourceOwnerForgetCryptoHash	(	ResourceOwner	owner,
		Datum	handle
	)

Definition at line 1495 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->cryptohasharr), handle))
         elog(ERROR, "cryptohash context %p is not owned by resource owner %s",
              DatumGetPointer(handle), owner->name);
 }

References ResourceOwnerData::cryptohasharr, DatumGetPointer(), elog(), ERROR, ResourceOwnerData::name, and ResourceArrayRemove().

Referenced by pg_cryptohash_free().

◆ ResourceOwnerForgetDSM()

void ResourceOwnerForgetDSM	(	ResourceOwner	owner,
		dsm_segment *	seg
	)

Definition at line 1415 of file resowner.c.

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

References dsm_segment_handle(), ResourceOwnerData::dsmarr, elog(), ERROR, ResourceOwnerData::name, PointerGetDatum(), and ResourceArrayRemove().

Referenced by dsm_create(), dsm_detach(), and dsm_pin_mapping().

◆ ResourceOwnerForgetFile()

void ResourceOwnerForgetFile	(	ResourceOwner	owner,
		File	file
	)

Definition at line 1370 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->filearr), FileGetDatum(file)))
         elog(ERROR, "temporary file %d is not owned by resource owner %s",
              file, owner->name);
 }

References elog(), ERROR, ResourceOwnerData::filearr, FileGetDatum, ResourceOwnerData::name, and ResourceArrayRemove().

Referenced by FileClose().

◆ ResourceOwnerForgetHMAC()

void ResourceOwnerForgetHMAC	(	ResourceOwner	owner,
		Datum	handle
	)

Definition at line 1540 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->hmacarr), handle))
         elog(ERROR, "HMAC context %p is not owned by resource owner %s",
              DatumGetPointer(handle), owner->name);
 }

References DatumGetPointer(), elog(), ERROR, ResourceOwnerData::hmacarr, ResourceOwnerData::name, and ResourceArrayRemove().

Referenced by pg_hmac_free().

◆ ResourceOwnerForgetJIT()

void ResourceOwnerForgetJIT	(	ResourceOwner	owner,
		Datum	handle
	)

Definition at line 1460 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->jitarr), handle))
         elog(ERROR, "JIT context %p is not owned by resource owner %s",
              DatumGetPointer(handle), owner->name);
 }

References DatumGetPointer(), elog(), ERROR, ResourceOwnerData::jitarr, ResourceOwnerData::name, and ResourceArrayRemove().

Referenced by jit_release_context().

◆ ResourceOwnerForgetLock()

void ResourceOwnerForgetLock	(	ResourceOwner	owner,
		LOCALLOCK *	locallock
	)

Definition at line 1070 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().

◆ ResourceOwnerForgetPlanCacheRef()

void ResourceOwnerForgetPlanCacheRef	(	ResourceOwner	owner,
		CachedPlan *	plan
	)

Definition at line 1234 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->planrefarr), PointerGetDatum(plan)))
         elog(ERROR, "plancache reference %p is not owned by resource owner %s",
              plan, owner->name);
 }

References elog(), ERROR, ResourceOwnerData::name, plan, ResourceOwnerData::planrefarr, PointerGetDatum(), and ResourceArrayRemove().

Referenced by ReleaseCachedPlan().

◆ ResourceOwnerForgetRelationRef()

void ResourceOwnerForgetRelationRef	(	ResourceOwner	owner,
		Relation	rel
	)

Definition at line 1189 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->relrefarr), PointerGetDatum(rel)))
         elog(ERROR, "relcache reference %s is not owned by resource owner %s",
              RelationGetRelationName(rel), owner->name);
 }

References elog(), ERROR, ResourceOwnerData::name, PointerGetDatum(), RelationGetRelationName, ResourceOwnerData::relrefarr, and ResourceArrayRemove().

Referenced by RelationDecrementReferenceCount().

◆ ResourceOwnerForgetSnapshot()

void ResourceOwnerForgetSnapshot	(	ResourceOwner	owner,
		Snapshot	snapshot
	)

Definition at line 1324 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->snapshotarr), PointerGetDatum(snapshot)))
         elog(ERROR, "snapshot reference %p is not owned by resource owner %s",
              snapshot, owner->name);
 }

References elog(), ERROR, ResourceOwnerData::name, PointerGetDatum(), ResourceArrayRemove(), and ResourceOwnerData::snapshotarr.

Referenced by UnregisterSnapshotFromOwner().

◆ ResourceOwnerForgetTupleDesc()

void ResourceOwnerForgetTupleDesc	(	ResourceOwner	owner,
		TupleDesc	tupdesc
	)

Definition at line 1278 of file resowner.c.

 {
     if (!ResourceArrayRemove(&(owner->tupdescarr), PointerGetDatum(tupdesc)))
         elog(ERROR, "tupdesc reference %p is not owned by resource owner %s",
              tupdesc, owner->name);
 }

References elog(), ERROR, ResourceOwnerData::name, PointerGetDatum(), ResourceArrayRemove(), and ResourceOwnerData::tupdescarr.

Referenced by DecrTupleDescRefCount().

◆ ResourceOwnerGetParent()

ResourceOwner ResourceOwnerGetParent ( ResourceOwner owner )

Definition at line 819 of file resowner.c.

 {
     return owner->parent;
 }

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

◆ ResourceOwnerNewParent()

void ResourceOwnerNewParent	(	ResourceOwner	owner,
		ResourceOwner	newparent
	)

Definition at line 828 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 488 of file resowner.c.

 {
     /* There's not currently any setup needed before recursing */
     ResourceOwnerReleaseInternal(owner, phase, isCommit, isTopLevel);
 }

References ResourceOwnerReleaseInternal().

Referenced by AbortSubTransaction(), AbortTransaction(), CommitSubTransaction(), CommitTransaction(), PortalDrop(), PrepareTransaction(), ReleaseAuxProcessResources(), and WalSndResourceCleanup().

◆ ResourceOwnerReleaseAllPlanCacheRefs()

void ResourceOwnerReleaseAllPlanCacheRefs ( ResourceOwner owner )

Definition at line 743 of file resowner.c.

 {
     Datum       foundres;
  
     while (ResourceArrayGetAny(&(owner->planrefarr), &foundres))
     {
         CachedPlan *res = (CachedPlan *) DatumGetPointer(foundres);
  
         ReleaseCachedPlan(res, owner);
     }
 }

References DatumGetPointer(), ResourceOwnerData::planrefarr, ReleaseCachedPlan(), res, and ResourceArrayGetAny().

Referenced by plpgsql_call_handler(), plpgsql_inline_handler(), and plpgsql_xact_cb().

◆ ResourceOwnerReleaseInternal()

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

static

Definition at line 498 of file resowner.c.

 {
     ResourceOwner child;
     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.
      */
     save = CurrentResourceOwner;
     CurrentResourceOwner = owner;
  
     if (phase == RESOURCE_RELEASE_BEFORE_LOCKS)
     {
         /*
          * 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.
          */
         while (ResourceArrayGetAny(&(owner->bufferioarr), &foundres))
         {
             Buffer      res = DatumGetBuffer(foundres);
  
             if (isCommit)
                 elog(PANIC, "lost track of buffer IO on buffer %d", res);
             AbortBufferIO(res);
         }
  
         /*
          * Release buffer pins.  Note that ReleaseBuffer will remove the
          * buffer entry from our array, so we just have to iterate till there
          * are none.
          *
          * 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.
          */
         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);
         }
     }
     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 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.
          */
         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);
         }
     }
  
     /* 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;
 }

Referenced by ResourceOwnerRelease().

◆ ResourceOwnerRememberBuffer()

void ResourceOwnerRememberBuffer	(	ResourceOwner	owner,
		Buffer	buffer
	)

Definition at line 985 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->bufferarr), BufferGetDatum(buffer));
 }

References ResourceOwnerData::bufferarr, BufferGetDatum, and ResourceArrayAdd().

Referenced by IncrBufferRefCount(), PinBuffer(), PinBuffer_Locked(), and PinLocalBuffer().

◆ ResourceOwnerRememberBufferIO()

void ResourceOwnerRememberBufferIO	(	ResourceOwner	owner,
		Buffer	buffer
	)

Definition at line 1023 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->bufferioarr), BufferGetDatum(buffer));
 }

References BufferGetDatum, ResourceOwnerData::bufferioarr, and ResourceArrayAdd().

Referenced by StartBufferIO().

◆ ResourceOwnerRememberCatCacheListRef()

void ResourceOwnerRememberCatCacheListRef	(	ResourceOwner	owner,
		CatCList *	list
	)

Definition at line 1145 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->catlistrefarr), PointerGetDatum(list));
 }

References ResourceOwnerData::catlistrefarr, sort-test::list, PointerGetDatum(), and ResourceArrayAdd().

Referenced by SearchCatCacheList().

◆ ResourceOwnerRememberCatCacheRef()

void ResourceOwnerRememberCatCacheRef	(	ResourceOwner	owner,
		HeapTuple	tuple
	)

Definition at line 1110 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->catrefarr), PointerGetDatum(tuple));
 }

References ResourceOwnerData::catrefarr, PointerGetDatum(), and ResourceArrayAdd().

Referenced by SearchCatCacheInternal(), and SearchCatCacheMiss().

◆ ResourceOwnerRememberCryptoHash()

void ResourceOwnerRememberCryptoHash	(	ResourceOwner	owner,
		Datum	handle
	)

Definition at line 1486 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->cryptohasharr), handle);
 }

References ResourceOwnerData::cryptohasharr, and ResourceArrayAdd().

Referenced by pg_cryptohash_create().

◆ ResourceOwnerRememberDSM()

void ResourceOwnerRememberDSM	(	ResourceOwner	owner,
		dsm_segment *	seg
	)

Definition at line 1406 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->dsmarr), PointerGetDatum(seg));
 }

References ResourceOwnerData::dsmarr, PointerGetDatum(), and ResourceArrayAdd().

Referenced by dsm_create_descriptor(), and dsm_unpin_mapping().

◆ ResourceOwnerRememberFile()

void ResourceOwnerRememberFile	(	ResourceOwner	owner,
		File	file
	)

Definition at line 1361 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->filearr), FileGetDatum(file));
 }

References ResourceOwnerData::filearr, FileGetDatum, and ResourceArrayAdd().

Referenced by RegisterTemporaryFile().

◆ ResourceOwnerRememberHMAC()

void ResourceOwnerRememberHMAC	(	ResourceOwner	owner,
		Datum	handle
	)

Definition at line 1531 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->hmacarr), handle);
 }

References ResourceOwnerData::hmacarr, and ResourceArrayAdd().

Referenced by pg_hmac_create().

◆ ResourceOwnerRememberJIT()

void ResourceOwnerRememberJIT	(	ResourceOwner	owner,
		Datum	handle
	)

Definition at line 1451 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->jitarr), handle);
 }

References ResourceOwnerData::jitarr, and ResourceArrayAdd().

Referenced by llvm_create_context().

◆ ResourceOwnerRememberLock()

void ResourceOwnerRememberLock	(	ResourceOwner	owner,
		LOCALLOCK *	locallock
	)

Definition at line 1050 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().

◆ ResourceOwnerRememberPlanCacheRef()

void ResourceOwnerRememberPlanCacheRef	(	ResourceOwner	owner,
		CachedPlan *	plan
	)

Definition at line 1225 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->planrefarr), PointerGetDatum(plan));
 }

References plan, ResourceOwnerData::planrefarr, PointerGetDatum(), and ResourceArrayAdd().

Referenced by CachedPlanAllowsSimpleValidityCheck(), CachedPlanIsSimplyValid(), and GetCachedPlan().

◆ ResourceOwnerRememberRelationRef()

void ResourceOwnerRememberRelationRef	(	ResourceOwner	owner,
		Relation	rel
	)

Definition at line 1180 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->relrefarr), PointerGetDatum(rel));
 }

References PointerGetDatum(), ResourceOwnerData::relrefarr, and ResourceArrayAdd().

Referenced by RelationIncrementReferenceCount().

◆ ResourceOwnerRememberSnapshot()

void ResourceOwnerRememberSnapshot	(	ResourceOwner	owner,
		Snapshot	snapshot
	)

Definition at line 1315 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->snapshotarr), PointerGetDatum(snapshot));
 }

References PointerGetDatum(), ResourceArrayAdd(), and ResourceOwnerData::snapshotarr.

Referenced by RegisterSnapshotOnOwner().

◆ ResourceOwnerRememberTupleDesc()

void ResourceOwnerRememberTupleDesc	(	ResourceOwner	owner,
		TupleDesc	tupdesc
	)

Definition at line 1269 of file resowner.c.

 {
     ResourceArrayAdd(&(owner->tupdescarr), PointerGetDatum(tupdesc));
 }

References PointerGetDatum(), ResourceArrayAdd(), and ResourceOwnerData::tupdescarr.

Referenced by IncrTupleDescRefCount().

◆ UnregisterResourceReleaseCallback()

void UnregisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 890 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 150 of file resowner.c.

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

◆ CurrentResourceOwner

ResourceOwner CurrentResourceOwner = NULL

Definition at line 147 of file resowner.c.

Referenced by _SPI_execute_plan(), apply_spooled_messages(), AssignTransactionId(), AtAbort_ResourceOwner(), AtStart_ResourceOwner(), AtSubAbort_ResourceOwner(), AtSubStart_ResourceOwner(), BgBufferSync(), BufferSync(), cipher_free_callback(), CleanupSubTransaction(), CleanupTransaction(), close_lo_relation(), CommitSubTransaction(), CommitTransaction(), CreateAuxProcessResourceOwner(), DecrTupleDescRefCount(), digest_free_callback(), dsm_create_descriptor(), dsm_unpin_mapping(), exec_eval_simple_expr(), exec_init_tuple_store(), exec_simple_check_plan(), exec_stmt_block(), ExplainExecuteQuery(), ExtendBufferedRelShared(), extendBufFile(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetCurrentFDWTuplestore(), GetLocalVictimBuffer(), GetVictimBuffer(), IncrBufferRefCount(), IncrTupleDescRefCount(), InitPostgres(), llvm_create_context(), lock_and_open_sequence(), LockAcquireExtended(), LockReassignCurrentOwner(), LockReassignOwner(), LockRelease(), makeBufFileCommon(), MakeTransitionCaptureState(), open_lo_relation(), OpenTemporaryFile(), PathNameCreateTemporaryFile(), PathNameOpenTemporaryFile(), perform_base_backup(), PersistHoldablePortal(), pg_cryptohash_create(), pg_hmac_create(), pg_logical_replication_slot_advance(), 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(), ReadBuffer_common(), ReadRecentBuffer(), RegisterSnapshot(), RegisterTemporaryFile(), RelationDecrementReferenceCount(), RelationIncrementReferenceCount(), ReleaseCatCache(), ReleaseCatCacheList(), ReleaseLockIfHeld(), ResourceOwnerDelete(), ResourceOwnerReleaseInternal(), SearchCatCacheInternal(), SearchCatCacheList(), SearchCatCacheMiss(), ShutdownXLOG(), SnapBuildClearExportedSnapshot(), SnapBuildExportSnapshot(), SPI_plan_get_cached_plan(), StartBufferIO(), StartupXLOG(), TerminateBufferIO(), tuplestore_begin_common(), tuplestore_puttuple_common(), UnpinBuffer(), UnpinLocalBuffer(), UnregisterSnapshot(), and WalSndResourceCleanup().

◆ CurTransactionResourceOwner

ResourceOwner CurTransactionResourceOwner = NULL

Definition at line 148 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 162 of file resowner.c.

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

◆ TopTransactionResourceOwner

ResourceOwner TopTransactionResourceOwner = NULL

Definition at line 149 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

◆ BufferGetDatum

◆ DatumGetBuffer

◆ DatumGetFile

◆ FileGetDatum

◆ MAX_RESOWNER_LOCKS

◆ RESARRAY_INIT_SIZE

◆ RESARRAY_IS_ARRAY

◆ RESARRAY_MAX_ARRAY

◆ RESARRAY_MAX_ITEMS

Typedef Documentation

◆ ResourceArray

◆ ResourceOwnerData

◆ ResourceReleaseCallbackItem

Function Documentation

◆ CreateAuxProcessResourceOwner()

◆ PrintCryptoHashLeakWarning()

◆ PrintDSMLeakWarning()

◆ PrintFileLeakWarning()

◆ PrintHMACLeakWarning()

◆ PrintPlanCacheLeakWarning()

◆ PrintRelCacheLeakWarning()

◆ PrintSnapshotLeakWarning()

◆ PrintTupleDescLeakWarning()

◆ RegisterResourceReleaseCallback()

◆ ReleaseAuxProcessResources()

◆ ReleaseAuxProcessResourcesCallback()

◆ ResourceArrayAdd()

◆ ResourceArrayEnlarge()

◆ ResourceArrayFree()

◆ ResourceArrayGetAny()

◆ ResourceArrayInit()

◆ ResourceArrayRemove()

◆ ResourceOwnerCreate()

◆ ResourceOwnerDelete()

◆ ResourceOwnerEnlargeBufferIOs()

◆ ResourceOwnerEnlargeBuffers()

◆ ResourceOwnerEnlargeCatCacheListRefs()

◆ ResourceOwnerEnlargeCatCacheRefs()

◆ ResourceOwnerEnlargeCryptoHash()

◆ ResourceOwnerEnlargeDSMs()

◆ ResourceOwnerEnlargeFiles()

◆ ResourceOwnerEnlargeHMAC()

◆ ResourceOwnerEnlargeJIT()

◆ ResourceOwnerEnlargePlanCacheRefs()

◆ ResourceOwnerEnlargeRelationRefs()

◆ ResourceOwnerEnlargeSnapshots()

◆ ResourceOwnerEnlargeTupleDescs()

◆ ResourceOwnerForgetBuffer()

◆ ResourceOwnerForgetBufferIO()

◆ ResourceOwnerForgetCatCacheListRef()

◆ ResourceOwnerForgetCatCacheRef()

◆ ResourceOwnerForgetCryptoHash()

◆ ResourceOwnerForgetDSM()

◆ ResourceOwnerForgetFile()

◆ ResourceOwnerForgetHMAC()

◆ ResourceOwnerForgetJIT()

◆ ResourceOwnerForgetLock()

◆ ResourceOwnerForgetPlanCacheRef()

◆ ResourceOwnerForgetRelationRef()

◆ ResourceOwnerForgetSnapshot()

◆ ResourceOwnerForgetTupleDesc()

◆ ResourceOwnerGetParent()

◆ ResourceOwnerNewParent()

◆ ResourceOwnerRelease()

◆ ResourceOwnerReleaseAllPlanCacheRefs()

◆ ResourceOwnerReleaseInternal()

◆ ResourceOwnerRememberBuffer()

◆ ResourceOwnerRememberBufferIO()

◆ ResourceOwnerRememberCatCacheListRef()

◆ ResourceOwnerRememberCatCacheRef()

◆ ResourceOwnerRememberCryptoHash()

◆ ResourceOwnerRememberDSM()

◆ ResourceOwnerRememberFile()

◆ ResourceOwnerRememberHMAC()