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 res, const ResourceOwnerDesc *kind)
void	ResourceOwnerForget (ResourceOwner owner, Datum res, 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)

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 982 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(), and InitPostgres().

RegisterResourceReleaseCallback()

void RegisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 944 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 1002 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 BackgroundWriterMain(), CheckpointerMain(), InitPostgres(), pgarch_archiveXlog(), ReleaseAuxProcessResourcesCallback(), WalSummarizerMain(), and WalWriterMain().

ResourceOwnerCreate()

ResourceOwner ResourceOwnerCreate	(	ResourceOwner	parent,
		const char *	name
	)

Definition at line 413 of file resowner.c.

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

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

Referenced by AtStart_ResourceOwner(), AtSubStart_ResourceOwner(), CreateAuxProcessResourceOwner(), CreatePortal(), perform_base_backup(), 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(), test_resowner_remember_between_phases(), and UploadManifest().

ResourceOwnerDelete()

void ResourceOwnerDelete

(

ResourceOwner

owner

)

Definition at line 854 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(), and ResourceOwnerNewParent().

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

ResourceOwnerEnlarge()

void ResourceOwnerEnlarge

(

ResourceOwner

owner

)

Definition at line 442 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(), 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	res,
		const ResourceOwnerDesc *	kind
	)

Definition at line 554 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(), ResourceOwnerForgetJIT(), ResourceOwnerForgetOSSLCipher(), ResourceOwnerForgetOSSLDigest(), ResourceOwnerForgetPlanCacheRef(), ResourceOwnerForgetRelationRef(), ResourceOwnerForgetSnapshot(), ResourceOwnerForgetTupleDesc(), ResourceOwnerForgetWaitEventSet(), and test_resowner_forget_between_phases().

ResourceOwnerForgetLock()

void ResourceOwnerForgetLock	(	ResourceOwner	owner,
		struct LOCALLOCK *	locallock
	)

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

{
    return owner->parent;
}

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

ResourceOwnerNewParent()

void ResourceOwnerNewParent	(	ResourceOwner	owner,
		ResourceOwner	newparent
	)

Definition at line 897 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 648 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(), test_resowner_remember_between_phases(), and WalSndResourceCleanup().

ResourceOwnerReleaseAllOfKind()

void ResourceOwnerReleaseAllOfKind	(	ResourceOwner	owner,
		const ResourceOwnerDesc *	kind
	)

Definition at line 801 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	res,
		const ResourceOwnerDesc *	kind
	)

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

ResourceOwnerRememberLock()

void ResourceOwnerRememberLock	(	ResourceOwner	owner,
		struct LOCALLOCK *	locallock
	)

Definition at line 1045 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 958 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 168 of file resowner.c.

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

CurrentResourceOwner

PGDLLIMPORT ResourceOwner CurrentResourceOwner

extern

Definition at line 165 of file resowner.c.

Referenced by _SPI_execute_plan(), AbortSubTransaction(), 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_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(), 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(), WaitLatchOrSocket(), and WalSndResourceCleanup().

CurTransactionResourceOwner

PGDLLIMPORT ResourceOwner CurTransactionResourceOwner

extern

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