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.

{
    RESOURCE_RELEASE_BEFORE_LOCKS = 1,
    RESOURCE_RELEASE_LOCKS,
    RESOURCE_RELEASE_AFTER_LOCKS,
} ResourceReleasePhase;

Function Documentation

CreateAuxProcessResourceOwner()

void CreateAuxProcessResourceOwner

(

void

)

Definition at line 999 of file resowner.c.

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

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

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

RegisterResourceReleaseCallback()

void RegisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 961 of file resowner.c.

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

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

ReleaseAuxProcessResources()

void ReleaseAuxProcessResources

(

bool

isCommit

)

Definition at line 1019 of file resowner.c.

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

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

Referenced by 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.

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

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.

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

References Assert(), CurrentResourceOwner, ResourceOwnerData::firstchild, ResourceOwnerData::hash, MAX_RESOWNER_LOCKS, ResourceOwnerData::narr, ResourceOwnerData::nhash, ResourceOwnerData::nlocks, pfree(), 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.

{
    /*
     * Mustn't try to remember more resources after we have already started
     * releasing
     */
    if (owner->releasing)
        elog(ERROR, "ResourceOwnerEnlarge called after release started");
 
    if (owner->narr < RESOWNER_ARRAY_SIZE)
        return;                 /* no work needed */
 
    /*
     * Is there space in the hash? If not, enlarge it.
     */
    if (owner->narr + owner->nhash >= owner->grow_at)
    {
        uint32      i,
                    oldcap,
                    newcap;
        ResourceElem *oldhash;
        ResourceElem *newhash;
 
        oldhash = owner->hash;
        oldcap = owner->capacity;
 
        /* Double the capacity (it must stay a power of 2!) */
        newcap = (oldcap > 0) ? oldcap * 2 : RESOWNER_HASH_INIT_SIZE;
        newhash = (ResourceElem *) MemoryContextAllocZero(TopMemoryContext,
                                                          newcap * sizeof(ResourceElem));
 
        /*
         * We assume we can't fail below this point, so OK to scribble on the
         * owner
         */
        owner->hash = newhash;
        owner->capacity = newcap;
        owner->grow_at = RESOWNER_HASH_MAX_ITEMS(newcap);
        owner->nhash = 0;
 
        if (oldhash != NULL)
        {
            /*
             * Transfer any pre-existing entries into the new hash table; they
             * don't necessarily go where they were before, so this simple
             * logic is the best way.
             */
            for (i = 0; i < oldcap; i++)
            {
                if (oldhash[i].kind != NULL)
                    ResourceOwnerAddToHash(owner, oldhash[i].item, oldhash[i].kind);
            }
 
            /* And release old hash table. */
            pfree(oldhash);
        }
    }
 
    /* Move items from the array to the hash */
    for (int i = 0; i < owner->narr; i++)
        ResourceOwnerAddToHash(owner, owner->arr[i].item, owner->arr[i].kind);
    owner->narr = 0;
 
    Assert(owner->nhash <= owner->grow_at);
}

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

Referenced by BufferAlloc(), CachedPlanAllowsSimpleValidityCheck(), CachedPlanIsSimplyValid(), CreateWaitEventSet(), dsm_create_descriptor(), dsm_unpin_mapping(), 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 564 of file resowner.c.

{
    /*
     * Mustn't call this after we have already started releasing resources.
     * (Release callback functions are not allowed to release additional
     * resources.)
     */
    if (owner->releasing)
        elog(ERROR, "ResourceOwnerForget called for %s after release started", kind->name);
    Assert(!owner->sorted);
 
    /* Search through all items in the array first. */
    for (int i = owner->narr - 1; i >= 0; i--)
    {
        if (owner->arr[i].item == value &&
            owner->arr[i].kind == kind)
        {
            owner->arr[i] = owner->arr[owner->narr - 1];
            owner->narr--;
 
#ifdef RESOWNER_STATS
            narray_lookups++;
#endif
            return;
        }
    }
 
    /* Search hash */
    if (owner->nhash > 0)
    {
        uint32      mask = owner->capacity - 1;
        uint32      idx;
 
        idx = hash_resource_elem(value, kind) & mask;
        for (uint32 i = 0; i < owner->capacity; i++)
        {
            if (owner->hash[idx].item == value &&
                owner->hash[idx].kind == kind)
            {
                owner->hash[idx].item = (Datum) 0;
                owner->hash[idx].kind = NULL;
                owner->nhash--;
 
#ifdef RESOWNER_STATS
                nhash_lookups++;
#endif
                return;
            }
            idx = (idx + 1) & mask;
        }
    }
 
    /*
     * Use %p to print the reference, since most objects tracked by a resource
     * owner are pointers.  It's a bit misleading if it's not a pointer, but
     * this is a programmer error, anyway.
     */
    elog(ERROR, "%s %p is not owned by resource owner %s",
         kind->name, DatumGetPointer(value), owner->name);
}

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

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.

{
    dlist_delete_from(&owner->aio_handles, ioh_node);
}

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.

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

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

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

ResourceOwnerGetParent()

ResourceOwner ResourceOwnerGetParent

(

ResourceOwner

owner

)

Definition at line 905 of file resowner.c.

{
    return owner->parent;
}

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

ResourceOwnerNewParent()

void ResourceOwnerNewParent	(	ResourceOwner	owner,
		ResourceOwner	newparent
	)

Definition at line 914 of file resowner.c.

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

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

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

ResourceOwnerRelease()

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

Definition at line 658 of file resowner.c.

{
    /* There's not currently any setup needed before recursing */
    ResourceOwnerReleaseInternal(owner, phase, isCommit, isTopLevel);
 
#ifdef RESOWNER_STATS
    if (isTopLevel)
    {
        elog(LOG, "RESOWNER STATS: lookups: array %d, hash %d",
             narray_lookups, nhash_lookups);
        narray_lookups = 0;
        nhash_lookups = 0;
    }
#endif
}

References elog, LOG, and ResourceOwnerReleaseInternal().

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

ResourceOwnerReleaseAllOfKind()

void ResourceOwnerReleaseAllOfKind	(	ResourceOwner	owner,
		const ResourceOwnerDesc *	kind
	)

Definition at line 818 of file resowner.c.

{
    /* Mustn't call this after we have already started releasing resources. */
    if (owner->releasing)
        elog(ERROR, "ResourceOwnerForget called for %s after release started", kind->name);
    Assert(!owner->sorted);
 
    /*
     * Temporarily set 'releasing', to prevent calls to ResourceOwnerRemember
     * while we're scanning the owner.  Enlarging the hash would cause us to
     * lose track of the point we're scanning.
     */
    owner->releasing = true;
 
    /* Array first */
    for (int i = 0; i < owner->narr; i++)
    {
        if (owner->arr[i].kind == kind)
        {
            Datum       value = owner->arr[i].item;
 
            owner->arr[i] = owner->arr[owner->narr - 1];
            owner->narr--;
            i--;
 
            kind->ReleaseResource(value);
        }
    }
 
    /* Then hash */
    for (int i = 0; i < owner->capacity; i++)
    {
        if (owner->hash[i].kind == kind)
        {
            Datum       value = owner->hash[i].item;
 
            owner->hash[i].item = (Datum) 0;
            owner->hash[i].kind = NULL;
            owner->nhash--;
 
            kind->ReleaseResource(value);
        }
    }
    owner->releasing = false;
}

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

Referenced by ReleaseAllPlanCacheRefsInOwner().

ResourceOwnerRemember()

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

Definition at line 524 of file resowner.c.

{
    uint32      idx;
 
    /* sanity check the ResourceOwnerDesc */
    Assert(kind->release_phase != 0);
    Assert(kind->release_priority != 0);
 
    /*
     * Mustn't try to remember more resources after we have already started
     * releasing.  We already checked this in ResourceOwnerEnlarge.
     */
    Assert(!owner->releasing);
    Assert(!owner->sorted);
 
    if (owner->narr >= RESOWNER_ARRAY_SIZE)
    {
        /* forgot to call ResourceOwnerEnlarge? */
        elog(ERROR, "ResourceOwnerRemember called but array was full");
    }
 
    /* Append to the array. */
    idx = owner->narr;
    owner->arr[idx].item = value;
    owner->arr[idx].kind = kind;
    owner->narr++;
}

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

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.

{
    dlist_push_tail(&owner->aio_handles, ioh_node);
}

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.

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

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

Referenced by GrantLockLocal(), and LockReassignOwner().

UnregisterResourceReleaseCallback()

void UnregisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 975 of file resowner.c.

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

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

Variable Documentation

AuxProcessResourceOwner

PGDLLIMPORT ResourceOwner AuxProcessResourceOwner

extern

Definition at line 176 of file resowner.c.

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

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(), 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

PGDLLIMPORT ResourceOwner CurTransactionResourceOwner

extern

Definition at line 174 of file resowner.c.

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

TopTransactionResourceOwner

PGDLLIMPORT ResourceOwner TopTransactionResourceOwner

extern

Definition at line 175 of file resowner.c.

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