PostgreSQL Source Code  git master
resowner.c File Reference
#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:

Go to the source code of this file.

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 ResourceReleaseCallbackItemResourceRelease_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

◆ ResourceReleaseCallbackItem

Function Documentation

◆ CreateAuxProcessResourceOwner()

void CreateAuxProcessResourceOwner ( void  )

Definition at line 914 of file resowner.c.

915 {
917  Assert(CurrentResourceOwner == NULL);
918  AuxProcessResourceOwner = ResourceOwnerCreate(NULL, "AuxiliaryProcess");
920 
921  /*
922  * Register a shmem-exit callback for cleanup of aux-process resource
923  * owner. (This needs to run after, e.g., ShutdownXLOG.)
924  */
926 }
void on_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:361
Assert(fmt[strlen(fmt) - 1] !='\n')
static void ReleaseAuxProcessResourcesCallback(int code, Datum arg)
Definition: resowner.c:956
ResourceOwner ResourceOwnerCreate(ResourceOwner parent, const char *name)
Definition: resowner.c:429
ResourceOwner CurrentResourceOwner
Definition: resowner.c:147
ResourceOwner AuxProcessResourceOwner
Definition: resowner.c:150

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.

1507 {
1508  elog(WARNING, "cryptohash context reference leak: context %p still referenced",
1509  DatumGetPointer(handle));
1510 }
#define WARNING
Definition: elog.h:36
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312

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

Referenced by ResourceOwnerReleaseInternal().

◆ PrintDSMLeakWarning()

static void PrintDSMLeakWarning ( dsm_segment seg)
static

Definition at line 1426 of file resowner.c.

1427 {
1428  elog(WARNING, "dynamic shared memory leak: segment %u still referenced",
1429  dsm_segment_handle(seg));
1430 }
dsm_handle dsm_segment_handle(dsm_segment *seg)
Definition: dsm.c:1094

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.

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

References elog(), and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintHMACLeakWarning()

static void PrintHMACLeakWarning ( Datum  handle)
static

Definition at line 1551 of file resowner.c.

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

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

Referenced by ResourceOwnerReleaseInternal().

◆ PrintPlanCacheLeakWarning()

static void PrintPlanCacheLeakWarning ( CachedPlan plan)
static

Definition at line 1245 of file resowner.c.

1246 {
1247  elog(WARNING, "plancache reference leak: plan %p not closed", plan);
1248 }
#define plan(x)
Definition: pg_regress.c:154

References elog(), plan, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintRelCacheLeakWarning()

static void PrintRelCacheLeakWarning ( Relation  rel)
static

Definition at line 1200 of file resowner.c.

1201 {
1202  elog(WARNING, "relcache reference leak: relation \"%s\" not closed",
1204 }
#define RelationGetRelationName(relation)
Definition: rel.h:538

References elog(), RelationGetRelationName, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintSnapshotLeakWarning()

static void PrintSnapshotLeakWarning ( Snapshot  snapshot)
static

Definition at line 1335 of file resowner.c.

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

References elog(), and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ PrintTupleDescLeakWarning()

static void PrintTupleDescLeakWarning ( TupleDesc  tupdesc)
static

Definition at line 1289 of file resowner.c.

1290 {
1291  elog(WARNING,
1292  "TupleDesc reference leak: TupleDesc %p (%u,%d) still referenced",
1293  tupdesc, tupdesc->tdtypeid, tupdesc->tdtypmod);
1294 }
int32 tdtypmod
Definition: tupdesc.h:83
Oid tdtypeid
Definition: tupdesc.h:82

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.

877 {
879 
880  item = (ResourceReleaseCallbackItem *)
883  item->callback = callback;
884  item->arg = arg;
887 }
MemoryContext TopMemoryContext
Definition: mcxt.c:141
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1021
void * arg
static ResourceReleaseCallbackItem * ResourceRelease_callbacks
Definition: resowner.c:162
struct ResourceReleaseCallbackItem * next
Definition: resowner.c:157
ResourceReleaseCallback callback
Definition: resowner.c:158
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46

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.

935 {
936  /*
937  * At this writing, the only thing that could actually get released is
938  * buffer pins; but we may as well do the full release protocol.
939  */
942  isCommit, true);
945  isCommit, true);
948  isCommit, true);
949 }
void ResourceOwnerRelease(ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)
Definition: resowner.c:488
@ RESOURCE_RELEASE_LOCKS
Definition: resowner.h:49
@ RESOURCE_RELEASE_BEFORE_LOCKS
Definition: resowner.h:48
@ RESOURCE_RELEASE_AFTER_LOCKS
Definition: resowner.h:50

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.

957 {
958  bool isCommit = (code == 0);
959 
960  ReleaseAuxProcessResources(isCommit);
961 }
void ReleaseAuxProcessResources(bool isCommit)
Definition: resowner.c:934

References ReleaseAuxProcessResources().

Referenced by CreateAuxProcessResourceOwner().

◆ ResourceArrayAdd()

static void ResourceArrayAdd ( ResourceArray resarr,
Datum  value 
)
static

Definition at line 270 of file resowner.c.

271 {
272  uint32 idx;
273 
274  Assert(value != resarr->invalidval);
275  Assert(resarr->nitems < resarr->maxitems);
276 
277  if (RESARRAY_IS_ARRAY(resarr))
278  {
279  /* Append to linear array. */
280  idx = resarr->nitems;
281  }
282  else
283  {
284  /* Insert into first free slot at or after hash location. */
285  uint32 mask = resarr->capacity - 1;
286 
287  idx = DatumGetUInt32(hash_any((void *) &value, sizeof(value))) & mask;
288  for (;;)
289  {
290  if (resarr->itemsarr[idx] == resarr->invalidval)
291  break;
292  idx = (idx + 1) & mask;
293  }
294  }
295  resarr->lastidx = idx;
296  resarr->itemsarr[idx] = value;
297  resarr->nitems++;
298 }
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:259
unsigned int uint32
Definition: c.h:495
static Datum hash_any(const unsigned char *k, int keylen)
Definition: hashfn.h:31
static struct @148 value
static uint32 DatumGetUInt32(Datum X)
Definition: postgres.h:222
#define RESARRAY_IS_ARRAY(resarr)
Definition: resowner.c:85
Datum invalidval
Definition: resowner.c:68
uint32 maxitems
Definition: resowner.c:71
uint32 nitems
Definition: resowner.c:70
Datum * itemsarr
Definition: resowner.c:67
uint32 capacity
Definition: resowner.c:69
uint32 lastidx
Definition: resowner.c:72

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.

216 {
217  uint32 i,
218  oldcap,
219  newcap;
220  Datum *olditemsarr;
221  Datum *newitemsarr;
222 
223  if (resarr->nitems < resarr->maxitems)
224  return; /* no work needed */
225 
226  olditemsarr = resarr->itemsarr;
227  oldcap = resarr->capacity;
228 
229  /* Double the capacity of the array (capacity must stay a power of 2!) */
230  newcap = (oldcap > 0) ? oldcap * 2 : RESARRAY_INIT_SIZE;
231  newitemsarr = (Datum *) MemoryContextAlloc(TopMemoryContext,
232  newcap * sizeof(Datum));
233  for (i = 0; i < newcap; i++)
234  newitemsarr[i] = resarr->invalidval;
235 
236  /* We assume we can't fail below this point, so OK to scribble on resarr */
237  resarr->itemsarr = newitemsarr;
238  resarr->capacity = newcap;
239  resarr->maxitems = RESARRAY_MAX_ITEMS(newcap);
240  resarr->nitems = 0;
241 
242  if (olditemsarr != NULL)
243  {
244  /*
245  * Transfer any pre-existing entries into the new array; they don't
246  * necessarily go where they were before, so this simple logic is the
247  * best way. Note that if we were managing the set as a simple array,
248  * the entries after nitems are garbage, but that shouldn't matter
249  * because we won't get here unless nitems was equal to oldcap.
250  */
251  for (i = 0; i < oldcap; i++)
252  {
253  if (olditemsarr[i] != resarr->invalidval)
254  ResourceArrayAdd(resarr, olditemsarr[i]);
255  }
256 
257  /* And release old array. */
258  pfree(olditemsarr);
259  }
260 
261  Assert(resarr->nitems < resarr->maxitems);
262 }
int i
Definition: isn.c:73
void pfree(void *pointer)
Definition: mcxt.c:1456
uintptr_t Datum
Definition: postgres.h:64
#define RESARRAY_MAX_ITEMS(capacity)
Definition: resowner.c:91
static void ResourceArrayAdd(ResourceArray *resarr, Datum value)
Definition: resowner.c:270
#define RESARRAY_INIT_SIZE
Definition: resowner.c:79

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.

410 {
411  if (resarr->itemsarr)
412  pfree(resarr->itemsarr);
413 }

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.

378 {
379  if (resarr->nitems == 0)
380  return false;
381 
382  if (RESARRAY_IS_ARRAY(resarr))
383  {
384  /* Linear array: just return the first element. */
385  resarr->lastidx = 0;
386  }
387  else
388  {
389  /* Hash: search forward from wherever we were last. */
390  uint32 mask = resarr->capacity - 1;
391 
392  for (;;)
393  {
394  resarr->lastidx &= mask;
395  if (resarr->itemsarr[resarr->lastidx] != resarr->invalidval)
396  break;
397  resarr->lastidx++;
398  }
399  }
400 
401  *value = resarr->itemsarr[resarr->lastidx];
402  return true;
403 }

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.

197 {
198  /* Assert it's empty */
199  Assert(resarr->itemsarr == NULL);
200  Assert(resarr->capacity == 0);
201  Assert(resarr->nitems == 0);
202  Assert(resarr->maxitems == 0);
203  /* Remember the appropriate "invalid" value */
204  resarr->invalidval = invalidval;
205  /* We don't allocate any storage until needed */
206 }

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.

309 {
310  uint32 i,
311  idx,
312  lastidx = resarr->lastidx;
313 
314  Assert(value != resarr->invalidval);
315 
316  /* Search through all items, but try lastidx first. */
317  if (RESARRAY_IS_ARRAY(resarr))
318  {
319  if (lastidx < resarr->nitems &&
320  resarr->itemsarr[lastidx] == value)
321  {
322  resarr->itemsarr[lastidx] = resarr->itemsarr[resarr->nitems - 1];
323  resarr->nitems--;
324  /* Update lastidx to make reverse-order removals fast. */
325  resarr->lastidx = resarr->nitems - 1;
326  return true;
327  }
328  for (i = 0; i < resarr->nitems; i++)
329  {
330  if (resarr->itemsarr[i] == value)
331  {
332  resarr->itemsarr[i] = resarr->itemsarr[resarr->nitems - 1];
333  resarr->nitems--;
334  /* Update lastidx to make reverse-order removals fast. */
335  resarr->lastidx = resarr->nitems - 1;
336  return true;
337  }
338  }
339  }
340  else
341  {
342  uint32 mask = resarr->capacity - 1;
343 
344  if (lastidx < resarr->capacity &&
345  resarr->itemsarr[lastidx] == value)
346  {
347  resarr->itemsarr[lastidx] = resarr->invalidval;
348  resarr->nitems--;
349  return true;
350  }
351  idx = DatumGetUInt32(hash_any((void *) &value, sizeof(value))) & mask;
352  for (i = 0; i < resarr->capacity; i++)
353  {
354  if (resarr->itemsarr[idx] == value)
355  {
356  resarr->itemsarr[idx] = resarr->invalidval;
357  resarr->nitems--;
358  return true;
359  }
360  idx = (idx + 1) & mask;
361  }
362  }
363 
364  return false;
365 }
#define nitems(x)
Definition: indent.h:31

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.

430 {
431  ResourceOwner owner;
432 
434  sizeof(ResourceOwnerData));
435  owner->name = name;
436 
437  if (parent)
438  {
439  owner->parent = parent;
440  owner->nextchild = parent->firstchild;
441  parent->firstchild = owner;
442  }
443 
446  ResourceArrayInit(&(owner->catrefarr), PointerGetDatum(NULL));
448  ResourceArrayInit(&(owner->relrefarr), PointerGetDatum(NULL));
449  ResourceArrayInit(&(owner->planrefarr), PointerGetDatum(NULL));
450  ResourceArrayInit(&(owner->tupdescarr), PointerGetDatum(NULL));
452  ResourceArrayInit(&(owner->filearr), FileGetDatum(-1));
453  ResourceArrayInit(&(owner->dsmarr), PointerGetDatum(NULL));
454  ResourceArrayInit(&(owner->jitarr), PointerGetDatum(NULL));
456  ResourceArrayInit(&(owner->hmacarr), PointerGetDatum(NULL));
457 
458  return owner;
459 }
#define InvalidBuffer
Definition: buf.h:25
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1064
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
static void ResourceArrayInit(ResourceArray *resarr, Datum invalidval)
Definition: resowner.c:196
#define BufferGetDatum(buffer)
Definition: resowner.c:46
#define FileGetDatum(file)
Definition: resowner.c:44
struct ResourceOwnerData * ResourceOwner
Definition: resowner.h:27
ResourceOwner parent
Definition: resowner.c:117
ResourceArray dsmarr
Definition: resowner.c:132
const char * name
Definition: resowner.c:120
ResourceArray bufferioarr
Definition: resowner.c:124
ResourceArray catlistrefarr
Definition: resowner.c:126
ResourceArray bufferarr
Definition: resowner.c:123
ResourceArray catrefarr
Definition: resowner.c:125
ResourceArray hmacarr
Definition: resowner.c:135
ResourceArray jitarr
Definition: resowner.c:133
ResourceOwner nextchild
Definition: resowner.c:119
ResourceArray relrefarr
Definition: resowner.c:127
ResourceArray cryptohasharr
Definition: resowner.c:134
ResourceOwner firstchild
Definition: resowner.c:118
ResourceArray planrefarr
Definition: resowner.c:128
ResourceArray tupdescarr
Definition: resowner.c:129
ResourceArray snapshotarr
Definition: resowner.c:130
ResourceArray filearr
Definition: resowner.c:131
const char * name

References ResourceOwnerData::bufferarr, BufferGetDatum, ResourceOwnerData::bufferioarr, ResourceOwnerData::catlistrefarr, ResourceOwnerData::catrefarr, ResourceOwnerData::cryptohasharr, ResourceOwnerData::dsmarr, ResourceOwnerData::filearr, FileGetDatum, ResourceOwnerData::firstchild, ResourceOwnerData::hmacarr, InvalidBuffer, ResourceOwnerData::jitarr, MemoryContextAllocZero(), name, ResourceOwnerData::name, ResourceOwnerData::nextchild, ResourceOwnerData::parent, ResourceOwnerData::planrefarr, PointerGetDatum(), ResourceOwnerData::relrefarr, ResourceArrayInit(), ResourceOwnerData::snapshotarr, TopMemoryContext, and ResourceOwnerData::tupdescarr.

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.

763 {
764  /* We had better not be deleting CurrentResourceOwner ... */
765  Assert(owner != CurrentResourceOwner);
766 
767  /* And it better not own any resources, either */
768  Assert(owner->bufferarr.nitems == 0);
769  Assert(owner->bufferioarr.nitems == 0);
770  Assert(owner->catrefarr.nitems == 0);
771  Assert(owner->catlistrefarr.nitems == 0);
772  Assert(owner->relrefarr.nitems == 0);
773  Assert(owner->planrefarr.nitems == 0);
774  Assert(owner->tupdescarr.nitems == 0);
775  Assert(owner->snapshotarr.nitems == 0);
776  Assert(owner->filearr.nitems == 0);
777  Assert(owner->dsmarr.nitems == 0);
778  Assert(owner->jitarr.nitems == 0);
779  Assert(owner->cryptohasharr.nitems == 0);
780  Assert(owner->hmacarr.nitems == 0);
781  Assert(owner->nlocks == 0 || owner->nlocks == MAX_RESOWNER_LOCKS + 1);
782 
783  /*
784  * Delete children. The recursive call will delink the child from me, so
785  * just iterate as long as there is a child.
786  */
787  while (owner->firstchild != NULL)
789 
790  /*
791  * We delink the owner from its parent before deleting it, so that if
792  * there's an error we won't have deleted/busted owners still attached to
793  * the owner tree. Better a leak than a crash.
794  */
795  ResourceOwnerNewParent(owner, NULL);
796 
797  /* And free the object. */
798  ResourceArrayFree(&(owner->bufferarr));
799  ResourceArrayFree(&(owner->bufferioarr));
800  ResourceArrayFree(&(owner->catrefarr));
801  ResourceArrayFree(&(owner->catlistrefarr));
802  ResourceArrayFree(&(owner->relrefarr));
803  ResourceArrayFree(&(owner->planrefarr));
804  ResourceArrayFree(&(owner->tupdescarr));
805  ResourceArrayFree(&(owner->snapshotarr));
806  ResourceArrayFree(&(owner->filearr));
807  ResourceArrayFree(&(owner->dsmarr));
808  ResourceArrayFree(&(owner->jitarr));
809  ResourceArrayFree(&(owner->cryptohasharr));
810  ResourceArrayFree(&(owner->hmacarr));
811 
812  pfree(owner);
813 }
void ResourceOwnerNewParent(ResourceOwner owner, ResourceOwner newparent)
Definition: resowner.c:828
#define MAX_RESOWNER_LOCKS
Definition: resowner.c:110
static void ResourceArrayFree(ResourceArray *resarr)
Definition: resowner.c:409
void ResourceOwnerDelete(ResourceOwner owner)
Definition: resowner.c:762

References Assert(), ResourceOwnerData::bufferarr, ResourceOwnerData::bufferioarr, ResourceOwnerData::catlistrefarr, ResourceOwnerData::catrefarr, ResourceOwnerData::cryptohasharr, CurrentResourceOwner, ResourceOwnerData::dsmarr, ResourceOwnerData::filearr, ResourceOwnerData::firstchild, ResourceOwnerData::hmacarr, ResourceOwnerData::jitarr, MAX_RESOWNER_LOCKS, ResourceArray::nitems, ResourceOwnerData::nlocks, pfree(), ResourceOwnerData::planrefarr, ResourceOwnerData::relrefarr, ResourceArrayFree(), ResourceOwnerNewParent(), ResourceOwnerData::snapshotarr, and ResourceOwnerData::tupdescarr.

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.

1011 {
1012  /* We used to allow pinning buffers without a resowner, but no more */
1013  Assert(owner != NULL);
1014  ResourceArrayEnlarge(&(owner->bufferioarr));
1015 }
static void ResourceArrayEnlarge(ResourceArray *resarr)
Definition: resowner.c:215

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

Referenced by StartBufferIO().

◆ ResourceOwnerEnlargeBuffers()

void ResourceOwnerEnlargeBuffers ( ResourceOwner  owner)

Definition at line 972 of file resowner.c.

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

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.

1135 {
1137 }

References ResourceOwnerData::catlistrefarr, and ResourceArrayEnlarge().

Referenced by SearchCatCacheList().

◆ ResourceOwnerEnlargeCatCacheRefs()

void ResourceOwnerEnlargeCatCacheRefs ( ResourceOwner  owner)

Definition at line 1099 of file resowner.c.

1100 {
1101  ResourceArrayEnlarge(&(owner->catrefarr));
1102 }

References ResourceOwnerData::catrefarr, and ResourceArrayEnlarge().

Referenced by SearchCatCacheInternal(), and SearchCatCacheMiss().

◆ ResourceOwnerEnlargeCryptoHash()

void ResourceOwnerEnlargeCryptoHash ( ResourceOwner  owner)

Definition at line 1475 of file resowner.c.

1476 {
1478 }

References ResourceOwnerData::cryptohasharr, and ResourceArrayEnlarge().

Referenced by pg_cryptohash_create().

◆ ResourceOwnerEnlargeDSMs()

void ResourceOwnerEnlargeDSMs ( ResourceOwner  owner)

Definition at line 1395 of file resowner.c.

1396 {
1397  ResourceArrayEnlarge(&(owner->dsmarr));
1398 }

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.

1351 {
1352  ResourceArrayEnlarge(&(owner->filearr));
1353 }

References ResourceOwnerData::filearr, and ResourceArrayEnlarge().

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

◆ ResourceOwnerEnlargeHMAC()

void ResourceOwnerEnlargeHMAC ( ResourceOwner  owner)

Definition at line 1520 of file resowner.c.

1521 {
1522  ResourceArrayEnlarge(&(owner->hmacarr));
1523 }

References ResourceOwnerData::hmacarr, and ResourceArrayEnlarge().

Referenced by pg_hmac_create().

◆ ResourceOwnerEnlargeJIT()

void ResourceOwnerEnlargeJIT ( ResourceOwner  owner)

Definition at line 1440 of file resowner.c.

1441 {
1442  ResourceArrayEnlarge(&(owner->jitarr));
1443 }

References ResourceOwnerData::jitarr, and ResourceArrayEnlarge().

Referenced by llvm_create_context().

◆ ResourceOwnerEnlargePlanCacheRefs()

void ResourceOwnerEnlargePlanCacheRefs ( ResourceOwner  owner)

◆ ResourceOwnerEnlargeRelationRefs()

void ResourceOwnerEnlargeRelationRefs ( ResourceOwner  owner)

Definition at line 1169 of file resowner.c.

1170 {
1171  ResourceArrayEnlarge(&(owner->relrefarr));
1172 }

References ResourceOwnerData::relrefarr, and ResourceArrayEnlarge().

Referenced by RelationIncrementReferenceCount().

◆ ResourceOwnerEnlargeSnapshots()

void ResourceOwnerEnlargeSnapshots ( ResourceOwner  owner)

Definition at line 1304 of file resowner.c.

1305 {
1306  ResourceArrayEnlarge(&(owner->snapshotarr));
1307 }

References ResourceArrayEnlarge(), and ResourceOwnerData::snapshotarr.

Referenced by RegisterSnapshotOnOwner().

◆ ResourceOwnerEnlargeTupleDescs()

void ResourceOwnerEnlargeTupleDescs ( ResourceOwner  owner)

Definition at line 1258 of file resowner.c.

1259 {
1260  ResourceArrayEnlarge(&(owner->tupdescarr));
1261 }

References ResourceArrayEnlarge(), and ResourceOwnerData::tupdescarr.

Referenced by IncrTupleDescRefCount().

◆ ResourceOwnerForgetBuffer()

void ResourceOwnerForgetBuffer ( ResourceOwner  owner,
Buffer  buffer 
)

Definition at line 994 of file resowner.c.

995 {
996  if (!ResourceArrayRemove(&(owner->bufferarr), BufferGetDatum(buffer)))
997  elog(ERROR, "buffer %d is not owned by resource owner %s",
998  buffer, owner->name);
999 }
#define ERROR
Definition: elog.h:39
static bool ResourceArrayRemove(ResourceArray *resarr, Datum value)
Definition: resowner.c:308

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.

1033 {
1034  if (!ResourceArrayRemove(&(owner->bufferioarr), BufferGetDatum(buffer)))
1035  elog(PANIC, "buffer IO %d is not owned by resource owner %s",
1036  buffer, owner->name);
1037 }
#define PANIC
Definition: elog.h:42

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.

1155 {
1157  elog(ERROR, "catcache list reference %p is not owned by resource owner %s",
1158  list, owner->name);
1159 }

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.

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

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.

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

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.

1416 {
1417  if (!ResourceArrayRemove(&(owner->dsmarr), PointerGetDatum(seg)))
1418  elog(ERROR, "dynamic shared memory segment %u is not owned by resource owner %s",
1419  dsm_segment_handle(seg), owner->name);
1420 }

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.

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

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.

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

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.

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

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.

1071 {
1072  int i;
1073 
1074  if (owner->nlocks > MAX_RESOWNER_LOCKS)
1075  return; /* we have overflowed */
1076 
1077  Assert(owner->nlocks > 0);
1078  for (i = owner->nlocks - 1; i >= 0; i--)
1079  {
1080  if (locallock == owner->locks[i])
1081  {
1082  owner->locks[i] = owner->locks[owner->nlocks - 1];
1083  owner->nlocks--;
1084  return;
1085  }
1086  }
1087  elog(ERROR, "lock reference %p is not owned by resource owner %s",
1088  locallock, owner->name);
1089 }
LOCALLOCK * locks[MAX_RESOWNER_LOCKS]
Definition: resowner.c:139

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.

1235 {
1237  elog(ERROR, "plancache reference %p is not owned by resource owner %s",
1238  plan, owner->name);
1239 }

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.

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

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.

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

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.

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

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.

820 {
821  return owner->parent;
822 }

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

◆ ResourceOwnerNewParent()

void ResourceOwnerNewParent ( ResourceOwner  owner,
ResourceOwner  newparent 
)

Definition at line 828 of file resowner.c.

830 {
831  ResourceOwner oldparent = owner->parent;
832 
833  if (oldparent)
834  {
835  if (owner == oldparent->firstchild)
836  oldparent->firstchild = owner->nextchild;
837  else
838  {
839  ResourceOwner child;
840 
841  for (child = oldparent->firstchild; child; child = child->nextchild)
842  {
843  if (owner == child->nextchild)
844  {
845  child->nextchild = owner->nextchild;
846  break;
847  }
848  }
849  }
850  }
851 
852  if (newparent)
853  {
854  Assert(owner != newparent);
855  owner->parent = newparent;
856  owner->nextchild = newparent->firstchild;
857  newparent->firstchild = owner;
858  }
859  else
860  {
861  owner->parent = NULL;
862  owner->nextchild = NULL;
863  }
864 }

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.

492 {
493  /* There's not currently any setup needed before recursing */
494  ResourceOwnerReleaseInternal(owner, phase, isCommit, isTopLevel);
495 }
static void ResourceOwnerReleaseInternal(ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)
Definition: resowner.c:498

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.

744 {
745  Datum foundres;
746 
747  while (ResourceArrayGetAny(&(owner->planrefarr), &foundres))
748  {
749  CachedPlan *res = (CachedPlan *) DatumGetPointer(foundres);
750 
751  ReleaseCachedPlan(res, owner);
752  }
753 }
void ReleaseCachedPlan(CachedPlan *plan, ResourceOwner owner)
Definition: plancache.c:1268
static bool ResourceArrayGetAny(ResourceArray *resarr, Datum *value)
Definition: resowner.c:377

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.

502 {
503  ResourceOwner child;
504  ResourceOwner save;
507  Datum foundres;
508 
509  /* Recurse to handle descendants */
510  for (child = owner->firstchild; child != NULL; child = child->nextchild)
511  ResourceOwnerReleaseInternal(child, phase, isCommit, isTopLevel);
512 
513  /*
514  * Make CurrentResourceOwner point to me, so that ReleaseBuffer etc don't
515  * get confused.
516  */
517  save = CurrentResourceOwner;
518  CurrentResourceOwner = owner;
519 
520  if (phase == RESOURCE_RELEASE_BEFORE_LOCKS)
521  {
522  /*
523  * Abort failed buffer IO. AbortBufferIO()->TerminateBufferIO() calls
524  * ResourceOwnerForgetBufferIO(), so we just have to iterate till
525  * there are none.
526  *
527  * Needs to be before we release buffer pins.
528  *
529  * During a commit, there shouldn't be any in-progress IO.
530  */
531  while (ResourceArrayGetAny(&(owner->bufferioarr), &foundres))
532  {
533  Buffer res = DatumGetBuffer(foundres);
534 
535  if (isCommit)
536  elog(PANIC, "lost track of buffer IO on buffer %d", res);
538  }
539 
540  /*
541  * Release buffer pins. Note that ReleaseBuffer will remove the
542  * buffer entry from our array, so we just have to iterate till there
543  * are none.
544  *
545  * During a commit, there shouldn't be any remaining pins --- that
546  * would indicate failure to clean up the executor correctly --- so
547  * issue warnings. In the abort case, just clean up quietly.
548  */
549  while (ResourceArrayGetAny(&(owner->bufferarr), &foundres))
550  {
551  Buffer res = DatumGetBuffer(foundres);
552 
553  if (isCommit)
556  }
557 
558  /* Ditto for relcache references */
559  while (ResourceArrayGetAny(&(owner->relrefarr), &foundres))
560  {
561  Relation res = (Relation) DatumGetPointer(foundres);
562 
563  if (isCommit)
566  }
567 
568  /* Ditto for dynamic shared memory segments */
569  while (ResourceArrayGetAny(&(owner->dsmarr), &foundres))
570  {
571  dsm_segment *res = (dsm_segment *) DatumGetPointer(foundres);
572 
573  if (isCommit)
575  dsm_detach(res);
576  }
577 
578  /* Ditto for JIT contexts */
579  while (ResourceArrayGetAny(&(owner->jitarr), &foundres))
580  {
581  JitContext *context = (JitContext *) DatumGetPointer(foundres);
582 
583  jit_release_context(context);
584  }
585 
586  /* Ditto for cryptohash contexts */
587  while (ResourceArrayGetAny(&(owner->cryptohasharr), &foundres))
588  {
589  pg_cryptohash_ctx *context =
590  (pg_cryptohash_ctx *) DatumGetPointer(foundres);
591 
592  if (isCommit)
593  PrintCryptoHashLeakWarning(foundres);
594  pg_cryptohash_free(context);
595  }
596 
597  /* Ditto for HMAC contexts */
598  while (ResourceArrayGetAny(&(owner->hmacarr), &foundres))
599  {
600  pg_hmac_ctx *context = (pg_hmac_ctx *) DatumGetPointer(foundres);
601 
602  if (isCommit)
603  PrintHMACLeakWarning(foundres);
604  pg_hmac_free(context);
605  }
606  }
607  else if (phase == RESOURCE_RELEASE_LOCKS)
608  {
609  if (isTopLevel)
610  {
611  /*
612  * For a top-level xact we are going to release all locks (or at
613  * least all non-session locks), so just do a single lmgr call at
614  * the top of the recursion.
615  */
616  if (owner == TopTransactionResourceOwner)
617  {
618  ProcReleaseLocks(isCommit);
619  ReleasePredicateLocks(isCommit, false);
620  }
621  }
622  else
623  {
624  /*
625  * Release locks retail. Note that if we are committing a
626  * subtransaction, we do NOT release its locks yet, but transfer
627  * them to the parent.
628  */
629  LOCALLOCK **locks;
630  int nlocks;
631 
632  Assert(owner->parent != NULL);
633 
634  /*
635  * Pass the list of locks owned by this resource owner to the lock
636  * manager, unless it has overflowed.
637  */
638  if (owner->nlocks > MAX_RESOWNER_LOCKS)
639  {
640  locks = NULL;
641  nlocks = 0;
642  }
643  else
644  {
645  locks = owner->locks;
646  nlocks = owner->nlocks;
647  }
648 
649  if (isCommit)
650  LockReassignCurrentOwner(locks, nlocks);
651  else
652  LockReleaseCurrentOwner(locks, nlocks);
653  }
654  }
655  else if (phase == RESOURCE_RELEASE_AFTER_LOCKS)
656  {
657  /*
658  * Release catcache references. Note that ReleaseCatCache will remove
659  * the catref entry from our array, so we just have to iterate till
660  * there are none.
661  *
662  * As with buffer pins, warn if any are left at commit time.
663  */
664  while (ResourceArrayGetAny(&(owner->catrefarr), &foundres))
665  {
666  HeapTuple res = (HeapTuple) DatumGetPointer(foundres);
667 
668  if (isCommit)
671  }
672 
673  /* Ditto for catcache lists */
674  while (ResourceArrayGetAny(&(owner->catlistrefarr), &foundres))
675  {
676  CatCList *res = (CatCList *) DatumGetPointer(foundres);
677 
678  if (isCommit)
681  }
682 
683  /* Ditto for plancache references */
684  while (ResourceArrayGetAny(&(owner->planrefarr), &foundres))
685  {
686  CachedPlan *res = (CachedPlan *) DatumGetPointer(foundres);
687 
688  if (isCommit)
690  ReleaseCachedPlan(res, owner);
691  }
692 
693  /* Ditto for tupdesc references */
694  while (ResourceArrayGetAny(&(owner->tupdescarr), &foundres))
695  {
696  TupleDesc res = (TupleDesc) DatumGetPointer(foundres);
697 
698  if (isCommit)
701  }
702 
703  /* Ditto for snapshot references */
704  while (ResourceArrayGetAny(&(owner->snapshotarr), &foundres))
705  {
706  Snapshot res = (Snapshot) DatumGetPointer(foundres);
707 
708  if (isCommit)
711  }
712 
713  /* Ditto for temporary files */
714  while (ResourceArrayGetAny(&(owner->filearr), &foundres))
715  {
716  File res = DatumGetFile(foundres);
717 
718  if (isCommit)
720  FileClose(res);
721  }
722  }
723 
724  /* Let add-on modules get a chance too */
725  for (item = ResourceRelease_callbacks; item; item = next)
726  {
727  /* allow callbacks to unregister themselves when called */
728  next = item->next;
729  item->callback(phase, isCommit, isTopLevel, item->arg);
730  }
731 
732  CurrentResourceOwner = save;
733 }
static int32 next
Definition: blutils.c:219
int Buffer
Definition: buf.h:23
void AbortBufferIO(Buffer buffer)
Definition: bufmgr.c:5191
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4480
void PrintBufferLeakWarning(Buffer buffer)
Definition: bufmgr.c:3232
void ReleaseCatCacheList(CatCList *list)
Definition: catcache.c:1779
void PrintCatCacheLeakWarning(HeapTuple tuple)
Definition: catcache.c:2067
void PrintCatCacheListLeakWarning(CatCList *list)
Definition: catcache.c:2083
void ReleaseCatCache(HeapTuple tuple)
Definition: catcache.c:1438
void pg_cryptohash_free(pg_cryptohash_ctx *ctx)
Definition: cryptohash.c:238
void dsm_detach(dsm_segment *seg)
Definition: dsm.c:776
void FileClose(File file)
Definition: fd.c:1930
int File
Definition: fd.h:49
void pg_hmac_free(pg_hmac_ctx *ctx)
Definition: hmac.c:289
HeapTupleData * HeapTuple
Definition: htup.h:71
void jit_release_context(JitContext *context)
Definition: jit.c:138
void LockReassignCurrentOwner(LOCALLOCK **locallocks, int nlocks)
Definition: lock.c:2520
void LockReleaseCurrentOwner(LOCALLOCK **locallocks, int nlocks)
Definition: lock.c:2425
void ReleasePredicateLocks(bool isCommit, bool isReadOnlySafe)
Definition: predicate.c:3246
void RelationClose(Relation relation)
Definition: relcache.c:2160
struct RelationData * Relation
Definition: relcache.h:27
#define DatumGetBuffer(datum)
Definition: resowner.c:47
ResourceOwner TopTransactionResourceOwner
Definition: resowner.c:149
static void PrintPlanCacheLeakWarning(CachedPlan *plan)
Definition: resowner.c:1245
static void PrintSnapshotLeakWarning(Snapshot snapshot)
Definition: resowner.c:1335
static void PrintCryptoHashLeakWarning(Datum handle)
Definition: resowner.c:1506
static void PrintTupleDescLeakWarning(TupleDesc tupdesc)
Definition: resowner.c:1289
#define DatumGetFile(datum)
Definition: resowner.c:45
static void PrintRelCacheLeakWarning(Relation rel)
Definition: resowner.c:1200
static void PrintHMACLeakWarning(Datum handle)
Definition: resowner.c:1551
static void PrintDSMLeakWarning(dsm_segment *seg)
Definition: resowner.c:1426
static void PrintFileLeakWarning(File file)
Definition: resowner.c:1381
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:817
struct SnapshotData * Snapshot
Definition: snapshot.h:121
void ProcReleaseLocks(bool isCommit)
Definition: proc.c:774
Definition: jit.h:58
void DecrTupleDescRefCount(TupleDesc tupdesc)
Definition: tupdesc.c:384
struct TupleDescData * TupleDesc
Definition: tupdesc.h:89

References AbortBufferIO(), ResourceReleaseCallbackItem::arg, Assert(), ResourceOwnerData::bufferarr, ResourceOwnerData::bufferioarr, ResourceReleaseCallbackItem::callback, ResourceOwnerData::catlistrefarr, ResourceOwnerData::catrefarr, ResourceOwnerData::cryptohasharr, CurrentResourceOwner, DatumGetBuffer, DatumGetFile, DatumGetPointer(), DecrTupleDescRefCount(), dsm_detach(), ResourceOwnerData::dsmarr, elog(), ResourceOwnerData::filearr, FileClose(), ResourceOwnerData::firstchild, ResourceOwnerData::hmacarr, jit_release_context(), ResourceOwnerData::jitarr, LockReassignCurrentOwner(), LockReleaseCurrentOwner(), ResourceOwnerData::locks, MAX_RESOWNER_LOCKS, next, ResourceReleaseCallbackItem::next, ResourceOwnerData::nextchild, ResourceOwnerData::nlocks, PANIC, ResourceOwnerData::parent, pg_cryptohash_free(), pg_hmac_free(), ResourceOwnerData::planrefarr, PrintBufferLeakWarning(), PrintCatCacheLeakWarning(), PrintCatCacheListLeakWarning(), PrintCryptoHashLeakWarning(), PrintDSMLeakWarning(), PrintFileLeakWarning(), PrintHMACLeakWarning(), PrintPlanCacheLeakWarning(), PrintRelCacheLeakWarning(), PrintSnapshotLeakWarning(), PrintTupleDescLeakWarning(), ProcReleaseLocks(), RelationClose(), ReleaseBuffer(), ReleaseCachedPlan(), ReleaseCatCache(), ReleaseCatCacheList(), ReleasePredicateLocks(), ResourceOwnerData::relrefarr, res, RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceArrayGetAny(), ResourceRelease_callbacks, ResourceOwnerData::snapshotarr, TopTransactionResourceOwner, ResourceOwnerData::tupdescarr, and UnregisterSnapshot().

Referenced by ResourceOwnerRelease().

◆ ResourceOwnerRememberBuffer()

void ResourceOwnerRememberBuffer ( ResourceOwner  owner,
Buffer  buffer 
)

Definition at line 985 of file resowner.c.

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

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.

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

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

Referenced by StartBufferIO().

◆ ResourceOwnerRememberCatCacheListRef()

void ResourceOwnerRememberCatCacheListRef ( ResourceOwner  owner,
CatCList list 
)

Definition at line 1145 of file resowner.c.

1146 {
1148 }

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.

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

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.

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

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.

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

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.

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

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

Referenced by RegisterTemporaryFile().

◆ ResourceOwnerRememberHMAC()

void ResourceOwnerRememberHMAC ( ResourceOwner  owner,
Datum  handle 
)

Definition at line 1531 of file resowner.c.

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

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.

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

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.

1051 {
1052  Assert(locallock != NULL);
1053 
1054  if (owner->nlocks > MAX_RESOWNER_LOCKS)
1055  return; /* we have already overflowed */
1056 
1057  if (owner->nlocks < MAX_RESOWNER_LOCKS)
1058  owner->locks[owner->nlocks] = locallock;
1059  else
1060  {
1061  /* overflowed */
1062  }
1063  owner->nlocks++;
1064 }

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

Referenced by GrantLockLocal(), and LockReassignOwner().

◆ ResourceOwnerRememberPlanCacheRef()

void ResourceOwnerRememberPlanCacheRef ( ResourceOwner  owner,
CachedPlan plan 
)

◆ ResourceOwnerRememberRelationRef()

void ResourceOwnerRememberRelationRef ( ResourceOwner  owner,
Relation  rel 
)

Definition at line 1180 of file resowner.c.

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

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

Referenced by RelationIncrementReferenceCount().

◆ ResourceOwnerRememberSnapshot()

void ResourceOwnerRememberSnapshot ( ResourceOwner  owner,
Snapshot  snapshot 
)

Definition at line 1315 of file resowner.c.

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

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

Referenced by RegisterSnapshotOnOwner().

◆ ResourceOwnerRememberTupleDesc()

void ResourceOwnerRememberTupleDesc ( ResourceOwner  owner,
TupleDesc  tupdesc 
)

Definition at line 1269 of file resowner.c.

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

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

Referenced by IncrTupleDescRefCount().

◆ UnregisterResourceReleaseCallback()

void UnregisterResourceReleaseCallback ( ResourceReleaseCallback  callback,
void *  arg 
)

Definition at line 890 of file resowner.c.

891 {
894 
895  prev = NULL;
896  for (item = ResourceRelease_callbacks; item; prev = item, item = item->next)
897  {
898  if (item->callback == callback && item->arg == arg)
899  {
900  if (prev)
901  prev->next = item->next;
902  else
904  pfree(item);
905  break;
906  }
907  }
908 }

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

Variable Documentation

◆ AuxProcessResourceOwner

ResourceOwner AuxProcessResourceOwner = NULL

◆ 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

◆ ResourceRelease_callbacks

ResourceReleaseCallbackItem* ResourceRelease_callbacks = NULL
static

◆ TopTransactionResourceOwner