PostgreSQL Source Code git master
resowner.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  ResourceOwnerDesc
 

Macros

#define RELEASE_PRIO_BUFFER_IOS   100
 
#define RELEASE_PRIO_BUFFER_PINS   200
 
#define RELEASE_PRIO_RELCACHE_REFS   300
 
#define RELEASE_PRIO_DSMS   400
 
#define RELEASE_PRIO_JIT_CONTEXTS   500
 
#define RELEASE_PRIO_CRYPTOHASH_CONTEXTS   600
 
#define RELEASE_PRIO_HMAC_CONTEXTS   700
 
#define RELEASE_PRIO_CATCACHE_REFS   100
 
#define RELEASE_PRIO_CATCACHE_LIST_REFS   200
 
#define RELEASE_PRIO_PLANCACHE_REFS   300
 
#define RELEASE_PRIO_TUPDESC_REFS   400
 
#define RELEASE_PRIO_SNAPSHOT_REFS   500
 
#define RELEASE_PRIO_FILES   600
 
#define RELEASE_PRIO_WAITEVENTSETS   700
 
#define RELEASE_PRIO_FIRST   1
 
#define RELEASE_PRIO_LAST   UINT32_MAX
 

Typedefs

typedef struct ResourceOwnerDataResourceOwner
 
typedef uint32 ResourceReleasePriority
 
typedef struct ResourceOwnerDesc ResourceOwnerDesc
 
typedef void(* ResourceReleaseCallback) (ResourceReleasePhase phase, bool isCommit, bool isTopLevel, void *arg)
 

Enumerations

enum  ResourceReleasePhase { RESOURCE_RELEASE_BEFORE_LOCKS = 1 , RESOURCE_RELEASE_LOCKS , RESOURCE_RELEASE_AFTER_LOCKS }
 

Functions

ResourceOwner ResourceOwnerCreate (ResourceOwner parent, const char *name)
 
void ResourceOwnerRelease (ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)
 
void ResourceOwnerDelete (ResourceOwner owner)
 
ResourceOwner ResourceOwnerGetParent (ResourceOwner owner)
 
void ResourceOwnerNewParent (ResourceOwner owner, ResourceOwner newparent)
 
void ResourceOwnerEnlarge (ResourceOwner owner)
 
void ResourceOwnerRemember (ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
 
void ResourceOwnerForget (ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
 
void ResourceOwnerReleaseAllOfKind (ResourceOwner owner, const ResourceOwnerDesc *kind)
 
void RegisterResourceReleaseCallback (ResourceReleaseCallback callback, void *arg)
 
void UnregisterResourceReleaseCallback (ResourceReleaseCallback callback, void *arg)
 
void CreateAuxProcessResourceOwner (void)
 
void ReleaseAuxProcessResources (bool isCommit)
 
void ResourceOwnerRememberLock (ResourceOwner owner, struct LOCALLOCK *locallock)
 
void ResourceOwnerForgetLock (ResourceOwner owner, struct LOCALLOCK *locallock)
 
void ResourceOwnerRememberAioHandle (ResourceOwner owner, struct dlist_node *ioh_node)
 
void ResourceOwnerForgetAioHandle (ResourceOwner owner, struct dlist_node *ioh_node)
 

Variables

PGDLLIMPORT ResourceOwner CurrentResourceOwner
 
PGDLLIMPORT ResourceOwner CurTransactionResourceOwner
 
PGDLLIMPORT ResourceOwner TopTransactionResourceOwner
 
PGDLLIMPORT ResourceOwner AuxProcessResourceOwner
 

Macro Definition Documentation

◆ RELEASE_PRIO_BUFFER_IOS

#define RELEASE_PRIO_BUFFER_IOS   100

Definition at line 62 of file resowner.h.

◆ RELEASE_PRIO_BUFFER_PINS

#define RELEASE_PRIO_BUFFER_PINS   200

Definition at line 63 of file resowner.h.

◆ RELEASE_PRIO_CATCACHE_LIST_REFS

#define RELEASE_PRIO_CATCACHE_LIST_REFS   200

Definition at line 72 of file resowner.h.

◆ RELEASE_PRIO_CATCACHE_REFS

#define RELEASE_PRIO_CATCACHE_REFS   100

Definition at line 71 of file resowner.h.

◆ RELEASE_PRIO_CRYPTOHASH_CONTEXTS

#define RELEASE_PRIO_CRYPTOHASH_CONTEXTS   600

Definition at line 67 of file resowner.h.

◆ RELEASE_PRIO_DSMS

#define RELEASE_PRIO_DSMS   400

Definition at line 65 of file resowner.h.

◆ RELEASE_PRIO_FILES

#define RELEASE_PRIO_FILES   600

Definition at line 76 of file resowner.h.

◆ RELEASE_PRIO_FIRST

#define RELEASE_PRIO_FIRST   1

Definition at line 80 of file resowner.h.

◆ RELEASE_PRIO_HMAC_CONTEXTS

#define RELEASE_PRIO_HMAC_CONTEXTS   700

Definition at line 68 of file resowner.h.

◆ RELEASE_PRIO_JIT_CONTEXTS

#define RELEASE_PRIO_JIT_CONTEXTS   500

Definition at line 66 of file resowner.h.

◆ RELEASE_PRIO_LAST

#define RELEASE_PRIO_LAST   UINT32_MAX

Definition at line 81 of file resowner.h.

◆ RELEASE_PRIO_PLANCACHE_REFS

#define RELEASE_PRIO_PLANCACHE_REFS   300

Definition at line 73 of file resowner.h.

◆ RELEASE_PRIO_RELCACHE_REFS

#define RELEASE_PRIO_RELCACHE_REFS   300

Definition at line 64 of file resowner.h.

◆ RELEASE_PRIO_SNAPSHOT_REFS

#define RELEASE_PRIO_SNAPSHOT_REFS   500

Definition at line 75 of file resowner.h.

◆ RELEASE_PRIO_TUPDESC_REFS

#define RELEASE_PRIO_TUPDESC_REFS   400

Definition at line 74 of file resowner.h.

◆ RELEASE_PRIO_WAITEVENTSETS

#define RELEASE_PRIO_WAITEVENTSETS   700

Definition at line 77 of file resowner.h.

Typedef Documentation

◆ ResourceOwner

Definition at line 27 of file resowner.h.

◆ ResourceOwnerDesc

◆ ResourceReleaseCallback

typedef void(* ResourceReleaseCallback) (ResourceReleasePhase phase, bool isCommit, bool isTopLevel, void *arg)

Definition at line 126 of file resowner.h.

◆ ResourceReleasePriority

Definition at line 59 of file resowner.h.

Enumeration Type Documentation

◆ ResourceReleasePhase

Enumerator
RESOURCE_RELEASE_BEFORE_LOCKS 
RESOURCE_RELEASE_LOCKS 
RESOURCE_RELEASE_AFTER_LOCKS 

Definition at line 52 of file resowner.h.

53{
ResourceReleasePhase
Definition: resowner.h:53
@ RESOURCE_RELEASE_LOCKS
Definition: resowner.h:55
@ RESOURCE_RELEASE_BEFORE_LOCKS
Definition: resowner.h:54
@ RESOURCE_RELEASE_AFTER_LOCKS
Definition: resowner.h:56

Function Documentation

◆ CreateAuxProcessResourceOwner()

void CreateAuxProcessResourceOwner ( void  )

Definition at line 999 of file resowner.c.

1000{
1003 AuxProcessResourceOwner = ResourceOwnerCreate(NULL, "AuxiliaryProcess");
1005
1006 /*
1007 * Register a shmem-exit callback for cleanup of aux-process resource
1008 * owner. (This needs to run after, e.g., ShutdownXLOG.)
1009 */
1011}
Assert(PointerIsAligned(start, uint64))
void on_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:365
static void ReleaseAuxProcessResourcesCallback(int code, Datum arg)
Definition: resowner.c:1044
ResourceOwner ResourceOwnerCreate(ResourceOwner parent, const char *name)
Definition: resowner.c:421
ResourceOwner CurrentResourceOwner
Definition: resowner.c:173
ResourceOwner AuxProcessResourceOwner
Definition: resowner.c:176

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

Referenced by AuxiliaryProcessMainCommon(), InitPostgres(), and InitWalSender().

◆ RegisterResourceReleaseCallback()

void RegisterResourceReleaseCallback ( ResourceReleaseCallback  callback,
void *  arg 
)

Definition at line 961 of file resowner.c.

962{
964
968 item->callback = callback;
969 item->arg = arg;
972}
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
MemoryContext TopMemoryContext
Definition: mcxt.c:149
void * arg
static ResourceReleaseCallbackItem * ResourceRelease_callbacks
Definition: resowner.c:195
struct ResourceReleaseCallbackItem * next
Definition: resowner.c:190
ResourceReleaseCallback callback
Definition: resowner.c:191
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.

◆ ReleaseAuxProcessResources()

void ReleaseAuxProcessResources ( bool  isCommit)

Definition at line 1019 of file resowner.c.

1020{
1021 /*
1022 * At this writing, the only thing that could actually get released is
1023 * buffer pins; but we may as well do the full release protocol.
1024 */
1027 isCommit, true);
1030 isCommit, true);
1033 isCommit, true);
1034 /* allow it to be reused */
1037}
void ResourceOwnerRelease(ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)
Definition: resowner.c:658

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

Referenced by AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), InitPostgres(), perform_base_backup(), pgarch_archiveXlog(), ReleaseAuxProcessResourcesCallback(), UploadManifest(), WalSndErrorCleanup(), WalSummarizerMain(), and WalWriterMain().

◆ ResourceOwnerCreate()

ResourceOwner ResourceOwnerCreate ( ResourceOwner  parent,
const char *  name 
)

Definition at line 421 of file resowner.c.

422{
423 ResourceOwner owner;
424
426 sizeof(struct ResourceOwnerData));
427 owner->name = name;
428
429 if (parent)
430 {
431 owner->parent = parent;
432 owner->nextchild = parent->firstchild;
433 parent->firstchild = owner;
434 }
435
436 dlist_init(&owner->aio_handles);
437
438 return owner;
439}
static void dlist_init(dlist_head *head)
Definition: ilist.h:314
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1215
struct ResourceOwnerData * ResourceOwner
Definition: resowner.h:27
ResourceOwner parent
Definition: resowner.c:114
dlist_head aio_handles
Definition: resowner.c:165
const char * name
Definition: resowner.c:117
ResourceOwner nextchild
Definition: resowner.c:116
ResourceOwner firstchild
Definition: resowner.c:115
const char * name

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

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

◆ ResourceOwnerDelete()

void ResourceOwnerDelete ( ResourceOwner  owner)

Definition at line 871 of file resowner.c.

872{
873 /* We had better not be deleting CurrentResourceOwner ... */
875
876 /* And it better not own any resources, either */
877 Assert(owner->narr == 0);
878 Assert(owner->nhash == 0);
879 Assert(owner->nlocks == 0 || owner->nlocks == MAX_RESOWNER_LOCKS + 1);
880
881 /*
882 * Delete children. The recursive call will delink the child from me, so
883 * just iterate as long as there is a child.
884 */
885 while (owner->firstchild != NULL)
887
888 /*
889 * We delink the owner from its parent before deleting it, so that if
890 * there's an error we won't have deleted/busted owners still attached to
891 * the owner tree. Better a leak than a crash.
892 */
893 ResourceOwnerNewParent(owner, NULL);
894
895 /* And free the object. */
896 if (owner->hash)
897 pfree(owner->hash);
898 pfree(owner);
899}
void pfree(void *pointer)
Definition: mcxt.c:1524
void ResourceOwnerNewParent(ResourceOwner owner, ResourceOwner newparent)
Definition: resowner.c:914
#define MAX_RESOWNER_LOCKS
Definition: resowner.c:107
void ResourceOwnerDelete(ResourceOwner owner)
Definition: resowner.c:871
ResourceElem * hash
Definition: resowner.c:154

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

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

◆ ResourceOwnerEnlarge()

void ResourceOwnerEnlarge ( ResourceOwner  owner)

Definition at line 452 of file resowner.c.

453{
454 /*
455 * Mustn't try to remember more resources after we have already started
456 * releasing
457 */
458 if (owner->releasing)
459 elog(ERROR, "ResourceOwnerEnlarge called after release started");
460
461 if (owner->narr < RESOWNER_ARRAY_SIZE)
462 return; /* no work needed */
463
464 /*
465 * Is there space in the hash? If not, enlarge it.
466 */
467 if (owner->narr + owner->nhash >= owner->grow_at)
468 {
469 uint32 i,
470 oldcap,
471 newcap;
472 ResourceElem *oldhash;
473 ResourceElem *newhash;
474
475 oldhash = owner->hash;
476 oldcap = owner->capacity;
477
478 /* Double the capacity (it must stay a power of 2!) */
479 newcap = (oldcap > 0) ? oldcap * 2 : RESOWNER_HASH_INIT_SIZE;
481 newcap * sizeof(ResourceElem));
482
483 /*
484 * We assume we can't fail below this point, so OK to scribble on the
485 * owner
486 */
487 owner->hash = newhash;
488 owner->capacity = newcap;
489 owner->grow_at = RESOWNER_HASH_MAX_ITEMS(newcap);
490 owner->nhash = 0;
491
492 if (oldhash != NULL)
493 {
494 /*
495 * Transfer any pre-existing entries into the new hash table; they
496 * don't necessarily go where they were before, so this simple
497 * logic is the best way.
498 */
499 for (i = 0; i < oldcap; i++)
500 {
501 if (oldhash[i].kind != NULL)
502 ResourceOwnerAddToHash(owner, oldhash[i].item, oldhash[i].kind);
503 }
504
505 /* And release old hash table. */
506 pfree(oldhash);
507 }
508 }
509
510 /* Move items from the array to the hash */
511 for (int i = 0; i < owner->narr; i++)
512 ResourceOwnerAddToHash(owner, owner->arr[i].item, owner->arr[i].kind);
513 owner->narr = 0;
514
515 Assert(owner->nhash <= owner->grow_at);
516}
uint32_t uint32
Definition: c.h:502
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
int i
Definition: isn.c:74
#define RESOWNER_HASH_INIT_SIZE
Definition: resowner.c:79
#define RESOWNER_HASH_MAX_ITEMS(capacity)
Definition: resowner.c:91
static void ResourceOwnerAddToHash(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
Definition: resowner.c:245
#define RESOWNER_ARRAY_SIZE
Definition: resowner.c:73
Datum item
Definition: resowner.c:66
const ResourceOwnerDesc * kind
Definition: resowner.c:67
ResourceElem arr[RESOWNER_ARRAY_SIZE]
Definition: resowner.c:142

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

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

◆ ResourceOwnerForget()

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

Definition at line 564 of file resowner.c.

565{
566 /*
567 * Mustn't call this after we have already started releasing resources.
568 * (Release callback functions are not allowed to release additional
569 * resources.)
570 */
571 if (owner->releasing)
572 elog(ERROR, "ResourceOwnerForget called for %s after release started", kind->name);
573 Assert(!owner->sorted);
574
575 /* Search through all items in the array first. */
576 for (int i = owner->narr - 1; i >= 0; i--)
577 {
578 if (owner->arr[i].item == value &&
579 owner->arr[i].kind == kind)
580 {
581 owner->arr[i] = owner->arr[owner->narr - 1];
582 owner->narr--;
583
584#ifdef RESOWNER_STATS
585 narray_lookups++;
586#endif
587 return;
588 }
589 }
590
591 /* Search hash */
592 if (owner->nhash > 0)
593 {
594 uint32 mask = owner->capacity - 1;
595 uint32 idx;
596
597 idx = hash_resource_elem(value, kind) & mask;
598 for (uint32 i = 0; i < owner->capacity; i++)
599 {
600 if (owner->hash[idx].item == value &&
601 owner->hash[idx].kind == kind)
602 {
603 owner->hash[idx].item = (Datum) 0;
604 owner->hash[idx].kind = NULL;
605 owner->nhash--;
606
607#ifdef RESOWNER_STATS
608 nhash_lookups++;
609#endif
610 return;
611 }
612 idx = (idx + 1) & mask;
613 }
614 }
615
616 /*
617 * Use %p to print the reference, since most objects tracked by a resource
618 * owner are pointers. It's a bit misleading if it's not a pointer, but
619 * this is a programmer error, anyway.
620 */
621 elog(ERROR, "%s %p is not owned by resource owner %s",
622 kind->name, DatumGetPointer(value), owner->name);
623}
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:259
static struct @165 value
uintptr_t Datum
Definition: postgres.h:69
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:317
static uint32 hash_resource_elem(Datum value, const ResourceOwnerDesc *kind)
Definition: resowner.c:222
const char * name
Definition: resowner.h:93

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

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

◆ ResourceOwnerForgetAioHandle()

void ResourceOwnerForgetAioHandle ( ResourceOwner  owner,
struct dlist_node ioh_node 
)

Definition at line 1110 of file resowner.c.

1111{
1112 dlist_delete_from(&owner->aio_handles, ioh_node);
1113}
static void dlist_delete_from(dlist_head *head, dlist_node *node)
Definition: ilist.h:429

References ResourceOwnerData::aio_handles, and dlist_delete_from().

Referenced by pgaio_io_reclaim(), and pgaio_io_release_resowner().

◆ ResourceOwnerForgetLock()

void ResourceOwnerForgetLock ( ResourceOwner  owner,
struct LOCALLOCK locallock 
)

Definition at line 1082 of file resowner.c.

1083{
1084 int i;
1085
1086 if (owner->nlocks > MAX_RESOWNER_LOCKS)
1087 return; /* we have overflowed */
1088
1089 Assert(owner->nlocks > 0);
1090 for (i = owner->nlocks - 1; i >= 0; i--)
1091 {
1092 if (locallock == owner->locks[i])
1093 {
1094 owner->locks[i] = owner->locks[owner->nlocks - 1];
1095 owner->nlocks--;
1096 return;
1097 }
1098 }
1099 elog(ERROR, "lock reference %p is not owned by resource owner %s",
1100 locallock, owner->name);
1101}
LOCALLOCK * locks[MAX_RESOWNER_LOCKS]
Definition: resowner.c:159

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

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

◆ ResourceOwnerGetParent()

ResourceOwner ResourceOwnerGetParent ( ResourceOwner  owner)

Definition at line 905 of file resowner.c.

906{
907 return owner->parent;
908}

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

◆ ResourceOwnerNewParent()

void ResourceOwnerNewParent ( ResourceOwner  owner,
ResourceOwner  newparent 
)

Definition at line 914 of file resowner.c.

916{
917 ResourceOwner oldparent = owner->parent;
918
919 if (oldparent)
920 {
921 if (owner == oldparent->firstchild)
922 oldparent->firstchild = owner->nextchild;
923 else
924 {
925 ResourceOwner child;
926
927 for (child = oldparent->firstchild; child; child = child->nextchild)
928 {
929 if (owner == child->nextchild)
930 {
931 child->nextchild = owner->nextchild;
932 break;
933 }
934 }
935 }
936 }
937
938 if (newparent)
939 {
940 Assert(owner != newparent);
941 owner->parent = newparent;
942 owner->nextchild = newparent->firstchild;
943 newparent->firstchild = owner;
944 }
945 else
946 {
947 owner->parent = NULL;
948 owner->nextchild = NULL;
949 }
950}

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 658 of file resowner.c.

662{
663 /* There's not currently any setup needed before recursing */
664 ResourceOwnerReleaseInternal(owner, phase, isCommit, isTopLevel);
665
666#ifdef RESOWNER_STATS
667 if (isTopLevel)
668 {
669 elog(LOG, "RESOWNER STATS: lookups: array %d, hash %d",
670 narray_lookups, nhash_lookups);
671 narray_lookups = 0;
672 nhash_lookups = 0;
673 }
674#endif
675}
#define LOG
Definition: elog.h:31
static void ResourceOwnerReleaseInternal(ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)
Definition: resowner.c:678

References elog, LOG, and ResourceOwnerReleaseInternal().

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

◆ ResourceOwnerReleaseAllOfKind()

void ResourceOwnerReleaseAllOfKind ( ResourceOwner  owner,
const ResourceOwnerDesc kind 
)

Definition at line 818 of file resowner.c.

819{
820 /* Mustn't call this after we have already started releasing resources. */
821 if (owner->releasing)
822 elog(ERROR, "ResourceOwnerForget called for %s after release started", kind->name);
823 Assert(!owner->sorted);
824
825 /*
826 * Temporarily set 'releasing', to prevent calls to ResourceOwnerRemember
827 * while we're scanning the owner. Enlarging the hash would cause us to
828 * lose track of the point we're scanning.
829 */
830 owner->releasing = true;
831
832 /* Array first */
833 for (int i = 0; i < owner->narr; i++)
834 {
835 if (owner->arr[i].kind == kind)
836 {
837 Datum value = owner->arr[i].item;
838
839 owner->arr[i] = owner->arr[owner->narr - 1];
840 owner->narr--;
841 i--;
842
843 kind->ReleaseResource(value);
844 }
845 }
846
847 /* Then hash */
848 for (int i = 0; i < owner->capacity; i++)
849 {
850 if (owner->hash[i].kind == kind)
851 {
852 Datum value = owner->hash[i].item;
853
854 owner->hash[i].item = (Datum) 0;
855 owner->hash[i].kind = NULL;
856 owner->nhash--;
857
858 kind->ReleaseResource(value);
859 }
860 }
861 owner->releasing = false;
862}
void(* ReleaseResource)(Datum res)
Definition: resowner.h:108

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

Referenced by ReleaseAllPlanCacheRefsInOwner().

◆ ResourceOwnerRemember()

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

Definition at line 524 of file resowner.c.

525{
526 uint32 idx;
527
528 /* sanity check the ResourceOwnerDesc */
529 Assert(kind->release_phase != 0);
530 Assert(kind->release_priority != 0);
531
532 /*
533 * Mustn't try to remember more resources after we have already started
534 * releasing. We already checked this in ResourceOwnerEnlarge.
535 */
536 Assert(!owner->releasing);
537 Assert(!owner->sorted);
538
539 if (owner->narr >= RESOWNER_ARRAY_SIZE)
540 {
541 /* forgot to call ResourceOwnerEnlarge? */
542 elog(ERROR, "ResourceOwnerRemember called but array was full");
543 }
544
545 /* Append to the array. */
546 idx = owner->narr;
547 owner->arr[idx].item = value;
548 owner->arr[idx].kind = kind;
549 owner->narr++;
550}
ResourceReleasePhase release_phase
Definition: resowner.h:96
ResourceReleasePriority release_priority
Definition: resowner.h:97

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

Referenced by RememberManyTestResources(), ResourceOwnerRememberBuffer(), ResourceOwnerRememberBufferIO(), ResourceOwnerRememberCatCacheListRef(), ResourceOwnerRememberCatCacheRef(), ResourceOwnerRememberCryptoHash(), ResourceOwnerRememberDSM(), ResourceOwnerRememberFile(), ResourceOwnerRememberHMAC(), ResourceOwnerRememberJIT(), ResourceOwnerRememberOSSLCipher(), ResourceOwnerRememberOSSLDigest(), ResourceOwnerRememberPlanCacheRef(), ResourceOwnerRememberRelationRef(), ResourceOwnerRememberSnapshot(), ResourceOwnerRememberTupleDesc(), ResourceOwnerRememberWaitEventSet(), test_resowner_forget_between_phases(), test_resowner_leak(), test_resowner_priorities(), and test_resowner_remember_between_phases().

◆ ResourceOwnerRememberAioHandle()

void ResourceOwnerRememberAioHandle ( ResourceOwner  owner,
struct dlist_node ioh_node 
)

Definition at line 1104 of file resowner.c.

1105{
1106 dlist_push_tail(&owner->aio_handles, ioh_node);
1107}
static void dlist_push_tail(dlist_head *head, dlist_node *node)
Definition: ilist.h:364

References ResourceOwnerData::aio_handles, and dlist_push_tail().

Referenced by pgaio_io_resowner_register().

◆ ResourceOwnerRememberLock()

void ResourceOwnerRememberLock ( ResourceOwner  owner,
struct LOCALLOCK locallock 
)

Definition at line 1062 of file resowner.c.

1063{
1064 Assert(locallock != NULL);
1065
1066 if (owner->nlocks > MAX_RESOWNER_LOCKS)
1067 return; /* we have already overflowed */
1068
1069 if (owner->nlocks < MAX_RESOWNER_LOCKS)
1070 owner->locks[owner->nlocks] = locallock;
1071 else
1072 {
1073 /* overflowed */
1074 }
1075 owner->nlocks++;
1076}

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

Referenced by GrantLockLocal(), and LockReassignOwner().

◆ UnregisterResourceReleaseCallback()

void UnregisterResourceReleaseCallback ( ResourceReleaseCallback  callback,
void *  arg 
)

Definition at line 975 of file resowner.c.

976{
979
980 prev = NULL;
981 for (item = ResourceRelease_callbacks; item; prev = item, item = item->next)
982 {
983 if (item->callback == callback && item->arg == arg)
984 {
985 if (prev)
986 prev->next = item->next;
987 else
989 pfree(item);
990 break;
991 }
992 }
993}

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

Variable Documentation

◆ AuxProcessResourceOwner

◆ CurrentResourceOwner

PGDLLIMPORT ResourceOwner CurrentResourceOwner
extern

Definition at line 173 of file resowner.c.

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

◆ CurTransactionResourceOwner

◆ TopTransactionResourceOwner