resowner.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * resowner.c
 *    POSTGRES resource owner management code.
 *
 * Query-lifespan resources are tracked by associating them with
 * ResourceOwner objects.  This provides a simple mechanism for ensuring
 * that such resources are freed at the right time.
 * See utils/resowner/README for more info on how to use it.
 *
 * The implementation consists of a small fixed-size array and a hash table.
 * New entries are inserted to the fixed-size array, and when the array
 * fills up, all the entries are moved to the hash table.  This way, the
 * array always contains a few most recently remembered references.  To find
 * a particular reference, you need to search both the array and the hash
 * table.
 *
 * The most frequent usage is that a resource is remembered, and forgotten
 * shortly thereafter.  For example, pin a buffer, read one tuple from it,
 * release the pin.  Linearly scanning the small array handles that case
 * efficiently.  However, some resources are held for a longer time, and
 * sometimes a lot of resources need to be held simultaneously.  The hash
 * table handles those cases.
 *
 * When it's time to release the resources, we sort them according to the
 * release-priority of each resource, and release them in that order.
 *
 * Local lock references are special, they are not stored in the array or
 * the hash table.  Instead, each resource owner has a separate small cache
 * of locks it owns.  The lock manager has the same information in its local
 * lock hash table, and we fall back on that if the cache overflows, but
 * traversing the hash table is slower when there are a lot of locks
 * belonging to other resource owners.  This is to speed up bulk releasing
 * or reassigning locks from a resource owner to its parent.
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/utils/resowner/resowner.c
 *
 *-------------------------------------------------------------------------
 */
#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"
 
/*
 * ResourceElem represents a reference associated with a resource owner.
 *
 * All objects managed by this code are required to fit into a Datum,
 * which is fine since they are generally pointers or integers.
 */
typedef struct ResourceElem
{
    Datum       item;
    const ResourceOwnerDesc *kind;  /* NULL indicates a free hash table slot */
} ResourceElem;
 
/*
 * Size of the fixed-size array to hold most-recently remembered resources.
 */
#define RESOWNER_ARRAY_SIZE 32
 
/*
 * Initially allocated size of a ResourceOwner's hash table.  Must be power of
 * two because we use (capacity - 1) as mask for hashing.
 */
#define RESOWNER_HASH_INIT_SIZE 64
 
/*
 * How many items may be stored in a hash table of given capacity.  When this
 * number is reached, we must resize.
 *
 * The hash table must always have enough free space that we can copy the
 * entries from the array to it, in ResourceOwnerSort.  We also insist that
 * the initial size is large enough that we don't hit the max size immediately
 * when it's created.  Aside from those limitations, 0.75 is a reasonable fill
 * factor.
 */
#define RESOWNER_HASH_MAX_ITEMS(capacity) \
    Min(capacity - RESOWNER_ARRAY_SIZE, (capacity)/4 * 3)
 
StaticAssertDecl(RESOWNER_HASH_MAX_ITEMS(RESOWNER_HASH_INIT_SIZE) >= RESOWNER_ARRAY_SIZE,
                 "initial hash size too small compared to array size");
 
/*
 * MAX_RESOWNER_LOCKS is the size of the per-resource owner locks cache. It's
 * chosen based on some testing with pg_dump with a large schema. When the
 * tests were done (on 9.2), resource owners in a pg_dump run contained up
 * to 9 locks, regardless of the schema size, except for the top resource
 * owner which contained much more (overflowing the cache). 15 seems like a
 * nice round number that's somewhat higher than what pg_dump needs. Note that
 * making this number larger is not free - the bigger the cache, the slower
 * it is to release locks (in retail), when a resource owner holds many locks.
 */
#define MAX_RESOWNER_LOCKS 15
 
/*
 * ResourceOwner objects look like this
 */
struct ResourceOwnerData
{
    ResourceOwner parent;       /* NULL if no parent (toplevel owner) */
    ResourceOwner firstchild;   /* head of linked list of children */
    ResourceOwner nextchild;    /* next child of same parent */
    const char *name;           /* name (just for debugging) */
 
    /*
     * When ResourceOwnerRelease is called, we sort the 'hash' and 'arr' by
     * the release priority.  After that, no new resources can be remembered
     * or forgotten in retail.  We have separate flags because
     * ResourceOwnerReleaseAllOfKind() temporarily sets 'releasing' without
     * sorting the arrays.
     */
    bool        releasing;
    bool        sorted;         /* are 'hash' and 'arr' sorted by priority? */
 
    /*
     * Number of items in the locks cache, array, and hash table respectively.
     * (These are packed together to avoid padding in the struct.)
     */
    uint8       nlocks;         /* number of owned locks */
    uint8       narr;           /* how many items are stored in the array */
    uint32      nhash;          /* how many items are stored in the hash */
 
    /*
     * The fixed-size array for recent resources.
     *
     * If 'sorted' is set, the contents are sorted by release priority.
     */
    ResourceElem arr[RESOWNER_ARRAY_SIZE];
 
    /*
     * The hash table.  Uses open-addressing.  'nhash' is the number of items
     * present; if it would exceed 'grow_at', we enlarge it and re-hash.
     * 'grow_at' should be rather less than 'capacity' so that we don't waste
     * too much time searching for empty slots.
     *
     * If 'sorted' is set, the contents are no longer hashed, but sorted by
     * release priority.  The first 'nhash' elements are occupied, the rest
     * are empty.
     */
    ResourceElem *hash;
    uint32      capacity;       /* allocated length of hash[] */
    uint32      grow_at;        /* grow hash when reach this */
 
    /* The local locks cache. */
    LOCALLOCK  *locks[MAX_RESOWNER_LOCKS];  /* list of owned locks */
 
    /*
     * AIO handles need be registered in critical sections and therefore
     * cannot use the normal ResourceElem mechanism.
     */
    dlist_head  aio_handles;
};
 
 
/*****************************************************************************
 *    GLOBAL MEMORY                                                          *
 *****************************************************************************/
 
ResourceOwner CurrentResourceOwner = NULL;
ResourceOwner CurTransactionResourceOwner = NULL;
ResourceOwner TopTransactionResourceOwner = NULL;
ResourceOwner AuxProcessResourceOwner = NULL;
 
/* #define RESOWNER_STATS */
 
#ifdef RESOWNER_STATS
static int  narray_lookups = 0;
static int  nhash_lookups = 0;
#endif
 
/*
 * List of add-on callbacks for resource releasing
 */
typedef struct ResourceReleaseCallbackItem
{
    struct ResourceReleaseCallbackItem *next;
    ResourceReleaseCallback callback;
    void       *arg;
} ResourceReleaseCallbackItem;
 
static ResourceReleaseCallbackItem *ResourceRelease_callbacks = NULL;
 
 
/* Internal routines */
static inline 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);
 
 
/*****************************************************************************
 *    INTERNAL ROUTINES                                                      *
 *****************************************************************************/
 
/*
 * Hash function for value+kind combination.
 */
static inline uint32
hash_resource_elem(Datum value, const ResourceOwnerDesc *kind)
{
    /*
     * 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.
     */
#if SIZEOF_DATUM == 8
    return hash_combine64(murmurhash64((uint64) value), (uint64) kind);
#else
    return hash_combine(murmurhash32((uint32) value), (uint32) kind);
#endif
}
 
/*
 * Adds 'value' of given 'kind' to the ResourceOwner's hash table
 */
static void
ResourceOwnerAddToHash(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
{
    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++;
}
 
/*
 * Comparison function to sort by release phase and priority
 */
static int
resource_priority_cmp(const void *a, const void *b)
{
    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;
}
 
/*
 * Sort resources in reverse release priority.
 *
 * If the hash table is in use, all the elements from the fixed-size array are
 * moved to the hash table, and then the hash table is sorted.  If there is no
 * hash table, then the fixed-size array is sorted directly.  In either case,
 * the result is one sorted array that contains all the resources.
 */
static void
ResourceOwnerSort(ResourceOwner owner)
{
    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);
}
 
/*
 * Call the ReleaseResource callback on entries with given 'phase'.
 */
static void
ResourceOwnerReleaseAll(ResourceOwner owner, ResourceReleasePhase phase,
                        bool printLeakWarnings)
{
    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;
}
 
 
/*****************************************************************************
 *    EXPORTED ROUTINES                                                      *
 *****************************************************************************/
 
 
/*
 * ResourceOwnerCreate
 *      Create an empty ResourceOwner.
 *
 * All ResourceOwner objects are kept in TopMemoryContext, since they should
 * only be freed explicitly.
 */
ResourceOwner
ResourceOwnerCreate(ResourceOwner parent, const char *name)
{
    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;
}
 
/*
 * Make sure there is room for at least one more resource in an array.
 *
 * This is separate from actually inserting a resource because if we run out
 * of memory, it's critical to do so *before* acquiring the resource.
 *
 * NB: Make sure there are no unrelated ResourceOwnerRemember() calls between
 * your ResourceOwnerEnlarge() call and the ResourceOwnerRemember() call that
 * you reserved the space for!
 */
void
ResourceOwnerEnlarge(ResourceOwner owner)
{
    /*
     * 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);
}
 
/*
 * Remember that an object is owned by a ResourceOwner
 *
 * Caller must have previously done ResourceOwnerEnlarge()
 */
void
ResourceOwnerRemember(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
{
    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++;
}
 
/*
 * Forget that an object is owned by a ResourceOwner
 *
 * Note: If same resource ID is associated with the ResourceOwner more than
 * once, one instance is removed.
 *
 * Note: Forgetting a resource does not guarantee that there is room to
 * remember a new resource.  One exception is when you forget the most
 * recently remembered resource; that does make room for a new remember call.
 * Some code callers rely on that exception.
 */
void
ResourceOwnerForget(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
{
    /*
     * 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);
}
 
/*
 * ResourceOwnerRelease
 *      Release all resources owned by a ResourceOwner and its descendants,
 *      but don't delete the owner objects themselves.
 *
 * Note that this executes just one phase of release, and so typically
 * must be called three times.  We do it this way because (a) we want to
 * do all the recursion separately for each phase, thereby preserving
 * the needed order of operations; and (b) xact.c may have other operations
 * to do between the phases.
 *
 * phase: release phase to execute
 * isCommit: true for successful completion of a query or transaction,
 *          false for unsuccessful
 * isTopLevel: true if completing a main transaction, else false
 *
 * isCommit is passed because some modules may expect that their resources
 * were all released already if the transaction or portal finished normally.
 * If so it is reasonable to give a warning (NOT an error) should any
 * unreleased resources be present.  When isCommit is false, such warnings
 * are generally inappropriate.
 *
 * isTopLevel is passed when we are releasing TopTransactionResourceOwner
 * at completion of a main transaction.  This generally means that *all*
 * resources will be released, and so we can optimize things a bit.
 *
 * NOTE: After starting the release process, by calling this function, no new
 * resources can be remembered in the resource owner.  You also cannot call
 * ResourceOwnerForget on any previously remembered resources to release
 * resources "in retail" after that, you must let the bulk release take care
 * of them.
 */
void
ResourceOwnerRelease(ResourceOwner owner,
                     ResourceReleasePhase phase,
                     bool isCommit,
                     bool isTopLevel)
{
    /* 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
}
 
static void
ResourceOwnerReleaseInternal(ResourceOwner owner,
                             ResourceReleasePhase phase,
                             bool isCommit,
                             bool isTopLevel)
{
    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;
}
 
/*
 * ResourceOwnerReleaseAllOfKind
 *      Release all resources of a certain type held by this owner.
 */
void
ResourceOwnerReleaseAllOfKind(ResourceOwner owner, const ResourceOwnerDesc *kind)
{
    /* 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;
}
 
/*
 * ResourceOwnerDelete
 *      Delete an owner object and its descendants.
 *
 * The caller must have already released all resources in the object tree.
 */
void
ResourceOwnerDelete(ResourceOwner owner)
{
    /* 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);
}
 
/*
 * Fetch parent of a ResourceOwner (returns NULL if top-level owner)
 */
ResourceOwner
ResourceOwnerGetParent(ResourceOwner owner)
{
    return owner->parent;
}
 
/*
 * Reassign a ResourceOwner to have a new parent
 */
void
ResourceOwnerNewParent(ResourceOwner owner,
                       ResourceOwner newparent)
{
    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;
    }
}
 
/*
 * Register or deregister callback functions for resource cleanup
 *
 * These functions can be used by dynamically loaded modules.  These used
 * to be the only way for an extension to register custom resource types
 * with a resource owner, but nowadays it is easier to define a new
 * ResourceOwnerDesc with custom callbacks.
 */
void
RegisterResourceReleaseCallback(ResourceReleaseCallback callback, void *arg)
{
    ResourceReleaseCallbackItem *item;
 
    item = (ResourceReleaseCallbackItem *)
        MemoryContextAlloc(TopMemoryContext,
                           sizeof(ResourceReleaseCallbackItem));
    item->callback = callback;
    item->arg = arg;
    item->next = ResourceRelease_callbacks;
    ResourceRelease_callbacks = item;
}
 
void
UnregisterResourceReleaseCallback(ResourceReleaseCallback callback, void *arg)
{
    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;
        }
    }
}
 
/*
 * Establish an AuxProcessResourceOwner for the current process.
 */
void
CreateAuxProcessResourceOwner(void)
{
    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);
}
 
/*
 * Convenience routine to release all resources tracked in
 * AuxProcessResourceOwner (but that resowner is not destroyed here).
 * Warn about leaked resources if isCommit is true.
 */
void
ReleaseAuxProcessResources(bool isCommit)
{
    /*
     * 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;
}
 
/*
 * Shmem-exit callback for the same.
 * Warn about leaked resources if process exit code is zero (ie normal).
 */
static void
ReleaseAuxProcessResourcesCallback(int code, Datum arg)
{
    bool        isCommit = (code == 0);
 
    ReleaseAuxProcessResources(isCommit);
}
 
/*
 * Remember that a Local Lock is owned by a ResourceOwner
 *
 * This is different from the generic ResourceOwnerRemember in that the list of
 * locks is only a lossy cache.  It can hold up to MAX_RESOWNER_LOCKS entries,
 * and when it overflows, we stop tracking locks.  The point of only remembering
 * only up to MAX_RESOWNER_LOCKS entries is that if a lot of locks are held,
 * ResourceOwnerForgetLock doesn't need to scan through a large array to find
 * the entry.
 */
void
ResourceOwnerRememberLock(ResourceOwner owner, LOCALLOCK *locallock)
{
    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++;
}
 
/*
 * Forget that a Local Lock is owned by a ResourceOwner
 */
void
ResourceOwnerForgetLock(ResourceOwner owner, LOCALLOCK *locallock)
{
    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);
}
 
void
ResourceOwnerRememberAioHandle(ResourceOwner owner, struct dlist_node *ioh_node)
{
    dlist_push_tail(&owner->aio_handles, ioh_node);
}
 
void
ResourceOwnerForgetAioHandle(ResourceOwner owner, struct dlist_node *ioh_node)
{
    dlist_delete_from(&owner->aio_handles, ioh_node);
}