#include "postgres.h"
#include "common/hashfn.h"
#include "common/int.h"
#include "lib/ilist.h"
#include "storage/aio.h"
#include "storage/ipc.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "utils/memutils.h"
#include "utils/resowner.h"

Include dependency graph for resowner.c:

Data Structures
struct	ResourceElem

struct	ResourceOwnerData

struct	ResourceReleaseCallbackItem

Macros
#define	RESOWNER_ARRAY_SIZE 32

#define	RESOWNER_HASH_INIT_SIZE 64

#define	RESOWNER_HASH_MAX_ITEMS(capacity) Min(capacity - RESOWNER_ARRAY_SIZE, (capacity)/4 * 3)

#define	MAX_RESOWNER_LOCKS 15

Typedefs
typedef struct ResourceElem	ResourceElem

typedef struct ResourceReleaseCallbackItem	ResourceReleaseCallbackItem

Functions
	StaticAssertDecl (RESOWNER_HASH_MAX_ITEMS(RESOWNER_HASH_INIT_SIZE) >=RESOWNER_ARRAY_SIZE, "initial hash size too small compared to array size")

static uint32	hash_resource_elem (Datum value, const ResourceOwnerDesc *kind)

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

static int	resource_priority_cmp (const void a, const void b)

static void	ResourceOwnerSort (ResourceOwner owner)

static void	ResourceOwnerReleaseAll (ResourceOwner owner, ResourceReleasePhase phase, bool printLeakWarnings)

static void	ResourceOwnerReleaseInternal (ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)

static void	ReleaseAuxProcessResourcesCallback (int code, Datum arg)

ResourceOwner	ResourceOwnerCreate (ResourceOwner parent, const char *name)

void	ResourceOwnerEnlarge (ResourceOwner owner)

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

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

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

void	ResourceOwnerReleaseAllOfKind (ResourceOwner owner, const ResourceOwnerDesc *kind)

void	ResourceOwnerDelete (ResourceOwner owner)

ResourceOwner	ResourceOwnerGetParent (ResourceOwner owner)

void	ResourceOwnerNewParent (ResourceOwner owner, ResourceOwner newparent)

void	RegisterResourceReleaseCallback (ResourceReleaseCallback callback, void *arg)

void	UnregisterResourceReleaseCallback (ResourceReleaseCallback callback, void *arg)

void	CreateAuxProcessResourceOwner (void)

void	ReleaseAuxProcessResources (bool isCommit)

void	ResourceOwnerRememberLock (ResourceOwner owner, LOCALLOCK *locallock)

void	ResourceOwnerForgetLock (ResourceOwner owner, LOCALLOCK *locallock)

void	ResourceOwnerRememberAioHandle (ResourceOwner owner, struct dlist_node *ioh_node)

void	ResourceOwnerForgetAioHandle (ResourceOwner owner, struct dlist_node *ioh_node)

Variables
ResourceOwner	CurrentResourceOwner = NULL

ResourceOwner	CurTransactionResourceOwner = NULL

ResourceOwner	TopTransactionResourceOwner = NULL

ResourceOwner	AuxProcessResourceOwner = NULL

static ResourceReleaseCallbackItem *	ResourceRelease_callbacks = NULL

Macro Definition Documentation

◆ MAX_RESOWNER_LOCKS

#define MAX_RESOWNER_LOCKS 15

Definition at line 107 of file resowner.c.

◆ RESOWNER_ARRAY_SIZE

#define RESOWNER_ARRAY_SIZE 32

Definition at line 73 of file resowner.c.

◆ RESOWNER_HASH_INIT_SIZE

#define RESOWNER_HASH_INIT_SIZE 64

Definition at line 79 of file resowner.c.

◆ RESOWNER_HASH_MAX_ITEMS

#define RESOWNER_HASH_MAX_ITEMS ( capacity ) Min(capacity - RESOWNER_ARRAY_SIZE, (capacity)/4 * 3)

Definition at line 91 of file resowner.c.

Typedef Documentation

◆ ResourceElem

typedef struct ResourceElem ResourceElem

◆ ResourceReleaseCallbackItem

typedef struct ResourceReleaseCallbackItem ResourceReleaseCallbackItem

Function Documentation

◆ CreateAuxProcessResourceOwner()

void CreateAuxProcessResourceOwner ( void )

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

◆ hash_resource_elem()

static uint32 hash_resource_elem	(	Datum	value,
		const ResourceOwnerDesc *	kind
	)

inlinestatic

Definition at line 222 of file resowner.c.

{
    /*
     * Most resource kinds store a pointer in 'value', and pointers are unique
     * all on their own.  But some resources store plain integers (Files and
     * Buffers as of this writing), so we want to incorporate the 'kind' in
     * the hash too, otherwise those resources will collide a lot.  But
     * because there are only a few resource kinds like that - and only a few
     * resource kinds to begin with - we don't need to work too hard to mix
     * 'kind' into the hash.  Just add it with hash_combine(), it perturbs the
     * result enough for our purposes.
     */
    return hash_combine64(murmurhash64((uint64) value),
                          (uint64) (uintptr_t) kind);
}

References hash_combine64(), murmurhash64(), and value.

Referenced by ResourceOwnerAddToHash(), and ResourceOwnerForget().

◆ RegisterResourceReleaseCallback()

void RegisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 958 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 1016 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().

◆ ReleaseAuxProcessResourcesCallback()

static void ReleaseAuxProcessResourcesCallback	(	int	code,
		Datum	arg
	)

static

Definition at line 1041 of file resowner.c.

{
    bool        isCommit = (code == 0);
 
    ReleaseAuxProcessResources(isCommit);
}

References ReleaseAuxProcessResources().

Referenced by CreateAuxProcessResourceOwner().

◆ resource_priority_cmp()

static int resource_priority_cmp	(	const void *	a,
		const void *	b
	)

static

Definition at line 266 of file resowner.c.

{
    const ResourceElem *ra = (const ResourceElem *) a;
    const ResourceElem *rb = (const ResourceElem *) b;
 
    /* Note: reverse order */
    if (ra->kind->release_phase == rb->kind->release_phase)
        return pg_cmp_u32(rb->kind->release_priority, ra->kind->release_priority);
    else if (ra->kind->release_phase > rb->kind->release_phase)
        return -1;
    else
        return 1;
}

References a, b, ResourceElem::kind, pg_cmp_u32(), ResourceOwnerDesc::release_phase, and ResourceOwnerDesc::release_priority.

Referenced by ResourceOwnerSort().

◆ ResourceOwnerAddToHash()

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

static

Definition at line 242 of file resowner.c.

{
    uint32      mask = owner->capacity - 1;
    uint32      idx;
 
    Assert(kind != NULL);
 
    /* Insert into first free slot at or after hash location. */
    idx = hash_resource_elem(value, kind) & mask;
    for (;;)
    {
        if (owner->hash[idx].kind == NULL)
            break;              /* found a free slot */
        idx = (idx + 1) & mask;
    }
    owner->hash[idx].item = value;
    owner->hash[idx].kind = kind;
    owner->nhash++;
}

References Assert(), ResourceOwnerData::capacity, ResourceOwnerData::hash, hash_resource_elem(), idx(), ResourceElem::item, ResourceElem::kind, ResourceOwnerData::nhash, and value.

Referenced by ResourceOwnerEnlarge().

◆ ResourceOwnerCreate()

ResourceOwner ResourceOwnerCreate	(	ResourceOwner	parent,
		const char *	name
	)

Definition at line 418 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 868 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 449 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 561 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.

◆ ResourceOwnerForgetAioHandle()

void ResourceOwnerForgetAioHandle	(	ResourceOwner	owner,
		struct dlist_node *	ioh_node
	)

Definition at line 1107 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,
		LOCALLOCK *	locallock
	)

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

{
    return owner->parent;
}

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

◆ ResourceOwnerNewParent()

void ResourceOwnerNewParent	(	ResourceOwner	owner,
		ResourceOwner	newparent
	)

Definition at line 911 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 655 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().

◆ ResourceOwnerReleaseAll()

static void ResourceOwnerReleaseAll	(	ResourceOwner	owner,
		ResourceReleasePhase	phase,
		bool	printLeakWarnings
	)

static

Definition at line 345 of file resowner.c.

{
    ResourceElem *items;
    uint32      nitems;
 
    /*
     * ResourceOwnerSort must've been called already.  All the resources are
     * either in the array or the hash.
     */
    Assert(owner->releasing);
    Assert(owner->sorted);
    if (owner->nhash == 0)
    {
        items = owner->arr;
        nitems = owner->narr;
    }
    else
    {
        Assert(owner->narr == 0);
        items = owner->hash;
        nitems = owner->nhash;
    }
 
    /*
     * The resources are sorted in reverse priority order.  Release them
     * starting from the end, until we hit the end of the phase that we are
     * releasing now.  We will continue from there when called again for the
     * next phase.
     */
    while (nitems > 0)
    {
        uint32      idx = nitems - 1;
        Datum       value = items[idx].item;
        const ResourceOwnerDesc *kind = items[idx].kind;
 
        if (kind->release_phase > phase)
            break;
        Assert(kind->release_phase == phase);
 
        if (printLeakWarnings)
        {
            char       *res_str;
 
            res_str = kind->DebugPrint ?
                kind->DebugPrint(value)
                : psprintf("%s %p", kind->name, DatumGetPointer(value));
            elog(WARNING, "resource was not closed: %s", res_str);
            pfree(res_str);
        }
        kind->ReleaseResource(value);
        nitems--;
    }
    if (owner->nhash == 0)
        owner->narr = nitems;
    else
        owner->nhash = nitems;
}

References ResourceOwnerData::arr, Assert(), DatumGetPointer(), ResourceOwnerDesc::DebugPrint, elog, ResourceOwnerData::hash, idx(), items, ResourceOwnerDesc::name, ResourceOwnerData::narr, ResourceOwnerData::nhash, nitems, pfree(), psprintf(), ResourceOwnerDesc::release_phase, ResourceOwnerDesc::ReleaseResource, ResourceOwnerData::releasing, ResourceOwnerData::sorted, value, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ ResourceOwnerReleaseAllOfKind()

void ResourceOwnerReleaseAllOfKind	(	ResourceOwner	owner,
		const ResourceOwnerDesc *	kind
	)

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

◆ ResourceOwnerReleaseInternal()

static void ResourceOwnerReleaseInternal	(	ResourceOwner	owner,
		ResourceReleasePhase	phase,
		bool	isCommit,
		bool	isTopLevel
	)

static

Definition at line 675 of file resowner.c.

{
    ResourceOwner child;
    ResourceOwner save;
    ResourceReleaseCallbackItem *item;
    ResourceReleaseCallbackItem *next;
 
    /* Recurse to handle descendants */
    for (child = owner->firstchild; child != NULL; child = child->nextchild)
        ResourceOwnerReleaseInternal(child, phase, isCommit, isTopLevel);
 
    /*
     * To release the resources in the right order, sort them by phase and
     * priority.
     *
     * The ReleaseResource callback functions are not allowed to remember or
     * forget any other resources after this. Otherwise we lose track of where
     * we are in processing the hash/array.
     */
    if (!owner->releasing)
    {
        Assert(phase == RESOURCE_RELEASE_BEFORE_LOCKS);
        Assert(!owner->sorted);
        owner->releasing = true;
    }
    else
    {
        /*
         * Phase is normally > RESOURCE_RELEASE_BEFORE_LOCKS, if this is not
         * the first call to ResourceOwnerRelease. But if an error happens
         * between the release phases, we might get called again for the same
         * ResourceOwner from AbortTransaction.
         */
    }
    if (!owner->sorted)
    {
        ResourceOwnerSort(owner);
        owner->sorted = true;
    }
 
    /*
     * Make CurrentResourceOwner point to me, so that the release callback
     * functions know which resource owner is been released.
     */
    save = CurrentResourceOwner;
    CurrentResourceOwner = owner;
 
    if (phase == RESOURCE_RELEASE_BEFORE_LOCKS)
    {
        /*
         * Release all resources that need to be released before the locks.
         *
         * During a commit, there shouldn't be any remaining resources ---
         * that would indicate failure to clean up the executor correctly ---
         * so issue warnings.  In the abort case, just clean up quietly.
         */
        ResourceOwnerReleaseAll(owner, phase, isCommit);
 
        while (!dlist_is_empty(&owner->aio_handles))
        {
            dlist_node *node = dlist_head_node(&owner->aio_handles);
 
            pgaio_io_release_resowner(node, !isCommit);
        }
    }
    else if (phase == RESOURCE_RELEASE_LOCKS)
    {
        if (isTopLevel)
        {
            /*
             * For a top-level xact we are going to release all locks (or at
             * least all non-session locks), so just do a single lmgr call at
             * the top of the recursion.
             */
            if (owner == TopTransactionResourceOwner)
            {
                ProcReleaseLocks(isCommit);
                ReleasePredicateLocks(isCommit, false);
            }
        }
        else
        {
            /*
             * Release locks retail.  Note that if we are committing a
             * subtransaction, we do NOT release its locks yet, but transfer
             * them to the parent.
             */
            LOCALLOCK **locks;
            int         nlocks;
 
            Assert(owner->parent != NULL);
 
            /*
             * Pass the list of locks owned by this resource owner to the lock
             * manager, unless it has overflowed.
             */
            if (owner->nlocks > MAX_RESOWNER_LOCKS)
            {
                locks = NULL;
                nlocks = 0;
            }
            else
            {
                locks = owner->locks;
                nlocks = owner->nlocks;
            }
 
            if (isCommit)
                LockReassignCurrentOwner(locks, nlocks);
            else
                LockReleaseCurrentOwner(locks, nlocks);
        }
    }
    else if (phase == RESOURCE_RELEASE_AFTER_LOCKS)
    {
        /*
         * Release all resources that need to be released after the locks.
         */
        ResourceOwnerReleaseAll(owner, phase, isCommit);
    }
 
    /* Let add-on modules get a chance too */
    for (item = ResourceRelease_callbacks; item; item = next)
    {
        /* allow callbacks to unregister themselves when called */
        next = item->next;
        item->callback(phase, isCommit, isTopLevel, item->arg);
    }
 
    CurrentResourceOwner = save;
}

Referenced by ResourceOwnerRelease(), and ResourceOwnerReleaseInternal().

◆ ResourceOwnerRemember()

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

Definition at line 521 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.

◆ ResourceOwnerRememberAioHandle()

void ResourceOwnerRememberAioHandle	(	ResourceOwner	owner,
		struct dlist_node *	ioh_node
	)

Definition at line 1101 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,
		LOCALLOCK *	locallock
	)

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

◆ ResourceOwnerSort()

static void ResourceOwnerSort ( ResourceOwner owner )

static

Definition at line 289 of file resowner.c.

{
    ResourceElem *items;
    uint32      nitems;
 
    if (owner->nhash == 0)
    {
        items = owner->arr;
        nitems = owner->narr;
    }
    else
    {
        /*
         * Compact the hash table, so that all the elements are in the
         * beginning of the 'hash' array, with no empty elements.
         */
        uint32      dst = 0;
 
        for (int idx = 0; idx < owner->capacity; idx++)
        {
            if (owner->hash[idx].kind != NULL)
            {
                if (dst != idx)
                    owner->hash[dst] = owner->hash[idx];
                dst++;
            }
        }
 
        /*
         * Move all entries from the fixed-size array to 'hash'.
         *
         * RESOWNER_HASH_MAX_ITEMS is defined so that there is always enough
         * free space to move all the elements from the fixed-size array to
         * the hash.
         */
        Assert(dst + owner->narr <= owner->capacity);
        for (int idx = 0; idx < owner->narr; idx++)
        {
            owner->hash[dst] = owner->arr[idx];
            dst++;
        }
        Assert(dst == owner->nhash + owner->narr);
        owner->narr = 0;
        owner->nhash = dst;
 
        items = owner->hash;
        nitems = owner->nhash;
    }
 
    qsort(items, nitems, sizeof(ResourceElem), resource_priority_cmp);
}

References ResourceOwnerData::arr, Assert(), ResourceOwnerData::capacity, ResourceOwnerData::hash, idx(), items, ResourceElem::kind, ResourceOwnerData::narr, ResourceOwnerData::nhash, nitems, qsort, and resource_priority_cmp().

Referenced by ResourceOwnerReleaseInternal().

◆ StaticAssertDecl()

StaticAssertDecl	(	RESOWNER_HASH_MAX_ITEMS(RESOWNER_HASH_INIT_SIZE) >=	RESOWNER_ARRAY_SIZE,
		"initial hash size too small compared to array size"
	)

◆ UnregisterResourceReleaseCallback()

void UnregisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 972 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

ResourceOwner AuxProcessResourceOwner = NULL

Definition at line 176 of file resowner.c.

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

◆ CurrentResourceOwner

ResourceOwner CurrentResourceOwner = NULL

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(), 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(), TrackNewBufferPin(), tuplestore_begin_common(), tuplestore_puttuple_common(), UnpinBuffer(), UnpinLocalBuffer(), UnregisterSnapshot(), UploadManifest(), and WaitLatchOrSocket().

◆ CurTransactionResourceOwner

ResourceOwner CurTransactionResourceOwner = NULL

Definition at line 174 of file resowner.c.

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

◆ ResourceRelease_callbacks

ResourceReleaseCallbackItem* ResourceRelease_callbacks = NULL

static

Definition at line 195 of file resowner.c.

Referenced by RegisterResourceReleaseCallback(), ResourceOwnerReleaseInternal(), and UnregisterResourceReleaseCallback().

◆ TopTransactionResourceOwner

ResourceOwner TopTransactionResourceOwner = NULL

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

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ MAX_RESOWNER_LOCKS

◆ RESOWNER_ARRAY_SIZE

◆ RESOWNER_HASH_INIT_SIZE

◆ RESOWNER_HASH_MAX_ITEMS

Typedef Documentation

◆ ResourceElem

◆ ResourceReleaseCallbackItem

Function Documentation

◆ CreateAuxProcessResourceOwner()

◆ hash_resource_elem()

◆ RegisterResourceReleaseCallback()

◆ ReleaseAuxProcessResources()

◆ ReleaseAuxProcessResourcesCallback()

◆ resource_priority_cmp()

◆ ResourceOwnerAddToHash()

◆ ResourceOwnerCreate()

◆ ResourceOwnerDelete()

◆ ResourceOwnerEnlarge()

◆ ResourceOwnerForget()

◆ ResourceOwnerForgetAioHandle()

◆ ResourceOwnerForgetLock()

◆ ResourceOwnerGetParent()

◆ ResourceOwnerNewParent()

◆ ResourceOwnerRelease()

◆ ResourceOwnerReleaseAll()

◆ ResourceOwnerReleaseAllOfKind()

◆ ResourceOwnerReleaseInternal()

◆ ResourceOwnerRemember()

◆ ResourceOwnerRememberAioHandle()

◆ ResourceOwnerRememberLock()

◆ ResourceOwnerSort()

◆ StaticAssertDecl()

◆ UnregisterResourceReleaseCallback()

Variable Documentation

◆ AuxProcessResourceOwner

◆ CurrentResourceOwner

◆ CurTransactionResourceOwner

◆ ResourceRelease_callbacks

◆ TopTransactionResourceOwner