PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
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 ResourceOwnerData *  ResourceOwner
 
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

typedef struct ResourceOwnerData* ResourceOwner

Definition at line 27 of file resowner.h.

◆ ResourceOwnerDesc

typedef struct ResourceOwnerDesc ResourceOwnerDesc

◆ ResourceReleaseCallback

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

Definition at line 126 of file resowner.h.

◆ ResourceReleasePriority

typedef uint32 ResourceReleasePriority

Definition at line 59 of file resowner.h.

Enumeration Type Documentation

◆ ResourceReleasePhase

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

997{
1000 AuxProcessResourceOwner = ResourceOwnerCreate(NULL, "AuxiliaryProcess");
1002
1003 /*
1004 * Register a shmem-exit callback for cleanup of aux-process resource
1005 * owner. (This needs to run after, e.g., ShutdownXLOG.)
1006 */
1008}
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:1041
ResourceOwner ResourceOwnerCreate(ResourceOwner parent, const char *name)
Definition: resowner.c:418
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 958 of file resowner.c.

959{
961
965 item->callback = callback;
966 item->arg = arg;
969}
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1229
MemoryContext TopMemoryContext
Definition: mcxt.c:166
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 1016 of file resowner.c.

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

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

419{
420 ResourceOwner owner;
421
423 sizeof(struct ResourceOwnerData));
424 owner->name = name;
425
426 if (parent)
427 {
428 owner->parent = parent;
429 owner->nextchild = parent->firstchild;
430 parent->firstchild = owner;
431 }
432
433 dlist_init(&owner->aio_handles);
434
435 return owner;
436}
static void dlist_init(dlist_head *head)
Definition: ilist.h:314
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1263
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 868 of file resowner.c.

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

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

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

1108{
1109 dlist_delete_from(&owner->aio_handles, ioh_node);
1110}
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 1079 of file resowner.c.

1080{
1081 int i;
1082
1083 if (owner->nlocks > MAX_RESOWNER_LOCKS)
1084 return; /* we have overflowed */
1085
1086 Assert(owner->nlocks > 0);
1087 for (i = owner->nlocks - 1; i >= 0; i--)
1088 {
1089 if (locallock == owner->locks[i])
1090 {
1091 owner->locks[i] = owner->locks[owner->nlocks - 1];
1092 owner->nlocks--;
1093 return;
1094 }
1095 }
1096 elog(ERROR, "lock reference %p is not owned by resource owner %s",
1097 locallock, owner->name);
1098}
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 902 of file resowner.c.

903{
904 return owner->parent;
905}

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

◆ ResourceOwnerNewParent()

void ResourceOwnerNewParent ( ResourceOwner  owner,
ResourceOwner  newparent 
)

Definition at line 911 of file resowner.c.

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

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

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

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

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

522{
523 uint32 idx;
524
525 /* sanity check the ResourceOwnerDesc */
526 Assert(kind->release_phase != 0);
527 Assert(kind->release_priority != 0);
528
529 /*
530 * Mustn't try to remember more resources after we have already started
531 * releasing. We already checked this in ResourceOwnerEnlarge.
532 */
533 Assert(!owner->releasing);
534 Assert(!owner->sorted);
535
536 if (owner->narr >= RESOWNER_ARRAY_SIZE)
537 {
538 /* forgot to call ResourceOwnerEnlarge? */
539 elog(ERROR, "ResourceOwnerRemember called but array was full");
540 }
541
542 /* Append to the array. */
543 idx = owner->narr;
544 owner->arr[idx].item = value;
545 owner->arr[idx].kind = kind;
546 owner->narr++;
547}
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 1101 of file resowner.c.

1102{
1103 dlist_push_tail(&owner->aio_handles, ioh_node);
1104}
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 1059 of file resowner.c.

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

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

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

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

Variable Documentation

◆ AuxProcessResourceOwner

PGDLLIMPORT ResourceOwner AuxProcessResourceOwner
extern

◆ CurrentResourceOwner

PGDLLIMPORT ResourceOwner CurrentResourceOwner
extern

Definition at line 173 of file resowner.c.

Referenced by _SPI_execute_plan(), apply_spooled_messages(), AssignTransactionId(), AsyncReadBuffers(), AtAbort_ResourceOwner(), AtStart_ResourceOwner(), AtSubAbort_ResourceOwner(), AtSubStart_ResourceOwner(), attach_internal(), buffer_call_start_io(), buffer_stage_common(), BufferAlloc(), CleanupSubTransaction(), CleanupTransaction(), close_lo_relation(), CommitSubTransaction(), CommitTransaction(), create_internal(), CreateAuxProcessResourceOwner(), DecrTupleDescRefCount(), dsm_create_descriptor(), dsm_unpin_mapping(), EvictAllUnpinnedBuffers(), EvictRelUnpinnedBuffers(), 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(), handle_get(), handle_get_and_error(), handle_get_release(), handle_get_twice(), IncrBufferRefCount(), IncrTupleDescRefCount(), init_execution_state(), 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(), read_rel_block_ll(), ReadRecentBuffer(), RegisterSnapshot(), RegisterTemporaryFile(), RelationDecrementReferenceCount(), RelationIncrementReferenceCount(), ReleaseCatCache(), ReleaseCatCacheList(), ReleaseCatCacheListWithOwner(), ReleaseCatCacheWithOwner(), ReleaseLockIfHeld(), ReorderBufferImmediateInvalidation(), ReorderBufferProcessTXN(), 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

AltStyle によって変換されたページ (->オリジナル) /