resowner.c File Reference

#include "postgres.h"
#include "common/hashfn.h"
#include "jit/jit.h"
#include "storage/bufmgr.h"
#include "storage/ipc.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/resowner_private.h"
#include "utils/snapmgr.h"

Include dependency graph for resowner.c:

Go to the source code of this file.

Data Structures
struct	ResourceArray
struct	ResourceOwnerData
struct	ResourceReleaseCallbackItem

Macros
#define	FileGetDatum(file)   Int32GetDatum(file)
#define	DatumGetFile(datum)   ((File) DatumGetInt32(datum))
#define	BufferGetDatum(buffer)   Int32GetDatum(buffer)
#define	DatumGetBuffer(datum)   ((Buffer) DatumGetInt32(datum))
#define	RESARRAY_INIT_SIZE   16
#define	RESARRAY_MAX_ARRAY   64
#define	RESARRAY_IS_ARRAY(resarr)   ((resarr)->capacity <= RESARRAY_MAX_ARRAY)
#define	RESARRAY_MAX_ITEMS(capacity)   ((capacity) <= RESARRAY_MAX_ARRAY ? (capacity) : (capacity)/4 * 3)
#define	MAX_RESOWNER_LOCKS   15

Typedefs
typedef struct ResourceArray	ResourceArray
typedef struct ResourceOwnerData	ResourceOwnerData
typedef struct ResourceReleaseCallbackItem	ResourceReleaseCallbackItem

Functions
static void	ResourceArrayInit (ResourceArray *resarr, Datum invalidval)
static void	ResourceArrayEnlarge (ResourceArray *resarr)
static void	ResourceArrayAdd (ResourceArray *resarr, Datum value)
static bool	ResourceArrayRemove (ResourceArray *resarr, Datum value)
static bool	ResourceArrayGetAny (ResourceArray *resarr, Datum *value)
static void	ResourceArrayFree (ResourceArray *resarr)
static void	ResourceOwnerReleaseInternal (ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)
static void	ReleaseAuxProcessResourcesCallback (int code, Datum arg)
static void	PrintRelCacheLeakWarning (Relation rel)
static void	PrintPlanCacheLeakWarning (CachedPlan *plan)
static void	PrintTupleDescLeakWarning (TupleDesc tupdesc)
static void	PrintSnapshotLeakWarning (Snapshot snapshot)
static void	PrintFileLeakWarning (File file)
static void	PrintDSMLeakWarning (dsm_segment *seg)
ResourceOwner	ResourceOwnerCreate (ResourceOwner parent, const char *name)
void	ResourceOwnerRelease (ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)
void	ResourceOwnerReleaseAllPlanCacheRefs (ResourceOwner owner)
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	ResourceOwnerEnlargeBuffers (ResourceOwner owner)
void	ResourceOwnerRememberBuffer (ResourceOwner owner, Buffer buffer)
void	ResourceOwnerForgetBuffer (ResourceOwner owner, Buffer buffer)
void	ResourceOwnerRememberLock (ResourceOwner owner, LOCALLOCK *locallock)
void	ResourceOwnerForgetLock (ResourceOwner owner, LOCALLOCK *locallock)
void	ResourceOwnerEnlargeCatCacheRefs (ResourceOwner owner)
void	ResourceOwnerRememberCatCacheRef (ResourceOwner owner, HeapTuple tuple)
void	ResourceOwnerForgetCatCacheRef (ResourceOwner owner, HeapTuple tuple)
void	ResourceOwnerEnlargeCatCacheListRefs (ResourceOwner owner)
void	ResourceOwnerRememberCatCacheListRef (ResourceOwner owner, CatCList *list)
void	ResourceOwnerForgetCatCacheListRef (ResourceOwner owner, CatCList *list)
void	ResourceOwnerEnlargeRelationRefs (ResourceOwner owner)
void	ResourceOwnerRememberRelationRef (ResourceOwner owner, Relation rel)
void	ResourceOwnerForgetRelationRef (ResourceOwner owner, Relation rel)
void	ResourceOwnerEnlargePlanCacheRefs (ResourceOwner owner)
void	ResourceOwnerRememberPlanCacheRef (ResourceOwner owner, CachedPlan *plan)
void	ResourceOwnerForgetPlanCacheRef (ResourceOwner owner, CachedPlan *plan)
void	ResourceOwnerEnlargeTupleDescs (ResourceOwner owner)
void	ResourceOwnerRememberTupleDesc (ResourceOwner owner, TupleDesc tupdesc)
void	ResourceOwnerForgetTupleDesc (ResourceOwner owner, TupleDesc tupdesc)
void	ResourceOwnerEnlargeSnapshots (ResourceOwner owner)
void	ResourceOwnerRememberSnapshot (ResourceOwner owner, Snapshot snapshot)
void	ResourceOwnerForgetSnapshot (ResourceOwner owner, Snapshot snapshot)
void	ResourceOwnerEnlargeFiles (ResourceOwner owner)
void	ResourceOwnerRememberFile (ResourceOwner owner, File file)
void	ResourceOwnerForgetFile (ResourceOwner owner, File file)
void	ResourceOwnerEnlargeDSMs (ResourceOwner owner)
void	ResourceOwnerRememberDSM (ResourceOwner owner, dsm_segment *seg)
void	ResourceOwnerForgetDSM (ResourceOwner owner, dsm_segment *seg)
void	ResourceOwnerEnlargeJIT (ResourceOwner owner)
void	ResourceOwnerRememberJIT (ResourceOwner owner, Datum handle)
void	ResourceOwnerForgetJIT (ResourceOwner owner, Datum handle)

Variables
ResourceOwner	CurrentResourceOwner = NULL
ResourceOwner	CurTransactionResourceOwner = NULL
ResourceOwner	TopTransactionResourceOwner = NULL
ResourceOwner	AuxProcessResourceOwner = NULL
static ResourceReleaseCallbackItem *	ResourceRelease_callbacks = NULL

Macro Definition Documentation

BufferGetDatum

#define BufferGetDatum

(

buffer

)

Int32GetDatum(buffer)

Definition at line 44 of file resowner.c.

Referenced by ResourceOwnerCreate(), ResourceOwnerForgetBuffer(), and ResourceOwnerRememberBuffer().

DatumGetBuffer

#define DatumGetBuffer

(

datum

)

((Buffer) DatumGetInt32(datum))

Definition at line 45 of file resowner.c.

Referenced by ResourceOwnerReleaseInternal().

DatumGetFile

#define DatumGetFile

(

datum

)

((File) DatumGetInt32(datum))

Definition at line 43 of file resowner.c.

Referenced by ResourceOwnerReleaseInternal().

FileGetDatum

#define FileGetDatum

(

file

)

Int32GetDatum(file)

Definition at line 42 of file resowner.c.

Referenced by ResourceOwnerCreate(), ResourceOwnerForgetFile(), and ResourceOwnerRememberFile().

MAX_RESOWNER_LOCKS

#define MAX_RESOWNER_LOCKS   15

Definition at line 108 of file resowner.c.

Referenced by ResourceOwnerDelete(), ResourceOwnerForgetLock(), ResourceOwnerReleaseInternal(), and ResourceOwnerRememberLock().

RESARRAY_INIT_SIZE

#define RESARRAY_INIT_SIZE   16

Definition at line 77 of file resowner.c.

Referenced by ResourceArrayEnlarge().

RESARRAY_IS_ARRAY

#define RESARRAY_IS_ARRAY

(

resarr

)

((resarr)->capacity <= RESARRAY_MAX_ARRAY)

Definition at line 83 of file resowner.c.

Referenced by ResourceArrayAdd(), ResourceArrayGetAny(), and ResourceArrayRemove().

RESARRAY_MAX_ARRAY

#define RESARRAY_MAX_ARRAY   64

Definition at line 82 of file resowner.c.

RESARRAY_MAX_ITEMS

#define RESARRAY_MAX_ITEMS

(

capacity

)

((capacity) <= RESARRAY_MAX_ARRAY ? (capacity) : (capacity)/4 * 3)

Definition at line 89 of file resowner.c.

Referenced by ResourceArrayEnlarge().

Typedef Documentation

ResourceArray

typedef struct ResourceArray ResourceArray

ResourceOwnerData

typedef struct ResourceOwnerData ResourceOwnerData

ResourceReleaseCallbackItem

typedef struct ResourceReleaseCallbackItem ResourceReleaseCallbackItem

Function Documentation

CreateAuxProcessResourceOwner()

void CreateAuxProcessResourceOwner

(

void

)

Definition at line 858 of file resowner.c.

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

Referenced by AuxiliaryProcessMain(), and InitPostgres().

{
    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);

}

PrintDSMLeakWarning()

static void PrintDSMLeakWarning ( dsm_segment *  seg )

static

Definition at line 1333 of file resowner.c.

References dsm_segment_handle(), elog, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

{
    elog(WARNING, "dynamic shared memory leak: segment %u still referenced",
         dsm_segment_handle(seg));
}

PrintFileLeakWarning()

static void PrintFileLeakWarning ( File  file )

static

Definition at line 1288 of file resowner.c.

References elog, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

{
    elog(WARNING, "temporary file leak: File %d still referenced",
         file);
}

PrintPlanCacheLeakWarning()

static void PrintPlanCacheLeakWarning ( CachedPlan *  plan )

static

Definition at line 1152 of file resowner.c.

References elog, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

{
    elog(WARNING, "plancache reference leak: plan %p not closed", plan);
}

PrintRelCacheLeakWarning()

static void PrintRelCacheLeakWarning ( Relation  rel )

static

Definition at line 1107 of file resowner.c.

References elog, RelationGetRelationName, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

{
    elog(WARNING, "relcache reference leak: relation \"%s\" not closed",
         RelationGetRelationName(rel));
}

PrintSnapshotLeakWarning()

static void PrintSnapshotLeakWarning ( Snapshot  snapshot )

static

Definition at line 1242 of file resowner.c.

References elog, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

{
    elog(WARNING, "Snapshot reference leak: Snapshot %p still referenced",
         snapshot);
}

PrintTupleDescLeakWarning()

static void PrintTupleDescLeakWarning ( TupleDesc  tupdesc )

static

Definition at line 1196 of file resowner.c.

References elog, TupleDescData::tdtypeid, TupleDescData::tdtypmod, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

{
    elog(WARNING,
         "TupleDesc reference leak: TupleDesc %p (%u,%d) still referenced",
         tupdesc, tupdesc->tdtypeid, tupdesc->tdtypmod);
}

RegisterResourceReleaseCallback()

void RegisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 820 of file resowner.c.

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

Referenced by px_find_cipher(), and px_find_digest().

{
    ResourceReleaseCallbackItem *item;

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

ReleaseAuxProcessResources()

void ReleaseAuxProcessResources

(

bool

isCommit

)

Definition at line 879 of file resowner.c.

References RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, and ResourceOwnerRelease().

Referenced by AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), InitPostgres(), ReleaseAuxProcessResourcesCallback(), and WalWriterMain().

{
    /*
     * 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);
}

ReleaseAuxProcessResourcesCallback()

static void ReleaseAuxProcessResourcesCallback ( int  code, Datum  arg  )

static

Definition at line 901 of file resowner.c.

References ReleaseAuxProcessResources().

Referenced by CreateAuxProcessResourceOwner().

{
    bool        isCommit = (code == 0);

    ReleaseAuxProcessResources(isCommit);
}

ResourceArrayAdd()

static void ResourceArrayAdd ( ResourceArray *  resarr, Datum  value  )

static

Definition at line 263 of file resowner.c.

References Assert, ResourceArray::capacity, DatumGetUInt32, hash_any(), idx(), ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::lastidx, ResourceArray::maxitems, ResourceArray::nitems, RESARRAY_IS_ARRAY, and value.

Referenced by ResourceArrayEnlarge(), ResourceOwnerRememberBuffer(), ResourceOwnerRememberCatCacheListRef(), ResourceOwnerRememberCatCacheRef(), ResourceOwnerRememberDSM(), ResourceOwnerRememberFile(), ResourceOwnerRememberJIT(), ResourceOwnerRememberPlanCacheRef(), ResourceOwnerRememberRelationRef(), ResourceOwnerRememberSnapshot(), and ResourceOwnerRememberTupleDesc().

{
    uint32      idx;

    Assert(value != resarr->invalidval);
    Assert(resarr->nitems < resarr->maxitems);

    if (RESARRAY_IS_ARRAY(resarr))
    {
        /* Append to linear array. */
        idx = resarr->nitems;
    }
    else
    {
        /* Insert into first free slot at or after hash location. */
        uint32      mask = resarr->capacity - 1;

        idx = DatumGetUInt32(hash_any((void *) &value, sizeof(value))) & mask;
        for (;;)
        {
            if (resarr->itemsarr[idx] == resarr->invalidval)
                break;
            idx = (idx + 1) & mask;
        }
    }
    resarr->lastidx = idx;
    resarr->itemsarr[idx] = value;
    resarr->nitems++;
}

ResourceArrayEnlarge()

static void ResourceArrayEnlarge ( ResourceArray *  resarr )

static

Definition at line 208 of file resowner.c.

References Assert, ResourceArray::capacity, i, ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::maxitems, MemoryContextAlloc(), ResourceArray::nitems, pfree(), RESARRAY_INIT_SIZE, RESARRAY_MAX_ITEMS, ResourceArrayAdd(), and TopMemoryContext.

Referenced by ResourceOwnerEnlargeBuffers(), ResourceOwnerEnlargeCatCacheListRefs(), ResourceOwnerEnlargeCatCacheRefs(), ResourceOwnerEnlargeDSMs(), ResourceOwnerEnlargeFiles(), ResourceOwnerEnlargeJIT(), ResourceOwnerEnlargePlanCacheRefs(), ResourceOwnerEnlargeRelationRefs(), ResourceOwnerEnlargeSnapshots(), and ResourceOwnerEnlargeTupleDescs().

{
    uint32      i,
                oldcap,
                newcap;
    Datum      *olditemsarr;
    Datum      *newitemsarr;

    if (resarr->nitems < resarr->maxitems)
        return;                 /* no work needed */

    olditemsarr = resarr->itemsarr;
    oldcap = resarr->capacity;

    /* Double the capacity of the array (capacity must stay a power of 2!) */
    newcap = (oldcap > 0) ? oldcap * 2 : RESARRAY_INIT_SIZE;
    newitemsarr = (Datum *) MemoryContextAlloc(TopMemoryContext,
                                               newcap * sizeof(Datum));
    for (i = 0; i < newcap; i++)
        newitemsarr[i] = resarr->invalidval;

    /* We assume we can't fail below this point, so OK to scribble on resarr */
    resarr->itemsarr = newitemsarr;
    resarr->capacity = newcap;
    resarr->maxitems = RESARRAY_MAX_ITEMS(newcap);
    resarr->nitems = 0;

    if (olditemsarr != NULL)
    {
        /*
         * Transfer any pre-existing entries into the new array; they don't
         * necessarily go where they were before, so this simple logic is the
         * best way.  Note that if we were managing the set as a simple array,
         * the entries after nitems are garbage, but that shouldn't matter
         * because we won't get here unless nitems was equal to oldcap.
         */
        for (i = 0; i < oldcap; i++)
        {
            if (olditemsarr[i] != resarr->invalidval)
                ResourceArrayAdd(resarr, olditemsarr[i]);
        }

        /* And release old array. */
        pfree(olditemsarr);
    }

    Assert(resarr->nitems < resarr->maxitems);
}

ResourceArrayFree()

static void ResourceArrayFree ( ResourceArray *  resarr )

static

Definition at line 402 of file resowner.c.

References ResourceArray::itemsarr, and pfree().

Referenced by ResourceOwnerDelete().

{
    if (resarr->itemsarr)
        pfree(resarr->itemsarr);
}

ResourceArrayGetAny()

static bool ResourceArrayGetAny ( ResourceArray *  resarr, Datum *  value  )

static

Definition at line 370 of file resowner.c.

References ResourceArray::capacity, ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::lastidx, ResourceArray::nitems, and RESARRAY_IS_ARRAY.

Referenced by ResourceOwnerReleaseAllPlanCacheRefs(), and ResourceOwnerReleaseInternal().

{
    if (resarr->nitems == 0)
        return false;

    if (RESARRAY_IS_ARRAY(resarr))
    {
        /* Linear array: just return the first element. */
        resarr->lastidx = 0;
    }
    else
    {
        /* Hash: search forward from wherever we were last. */
        uint32      mask = resarr->capacity - 1;

        for (;;)
        {
            resarr->lastidx &= mask;
            if (resarr->itemsarr[resarr->lastidx] != resarr->invalidval)
                break;
            resarr->lastidx++;
        }
    }

    *value = resarr->itemsarr[resarr->lastidx];
    return true;
}

ResourceArrayInit()

static void ResourceArrayInit ( ResourceArray *  resarr, Datum  invalidval  )

static

Definition at line 189 of file resowner.c.

References Assert, ResourceArray::capacity, ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::maxitems, and ResourceArray::nitems.

Referenced by ResourceOwnerCreate().

{
    /* Assert it's empty */
    Assert(resarr->itemsarr == NULL);
    Assert(resarr->capacity == 0);
    Assert(resarr->nitems == 0);
    Assert(resarr->maxitems == 0);
    /* Remember the appropriate "invalid" value */
    resarr->invalidval = invalidval;
    /* We don't allocate any storage until needed */
}

ResourceArrayRemove()

static bool ResourceArrayRemove ( ResourceArray *  resarr, Datum  value  )

static

Definition at line 301 of file resowner.c.

References Assert, ResourceArray::capacity, DatumGetUInt32, hash_any(), i, idx(), ResourceArray::invalidval, ResourceArray::itemsarr, ResourceArray::lastidx, ResourceArray::nitems, and RESARRAY_IS_ARRAY.

Referenced by ResourceOwnerForgetBuffer(), ResourceOwnerForgetCatCacheListRef(), ResourceOwnerForgetCatCacheRef(), ResourceOwnerForgetDSM(), ResourceOwnerForgetFile(), ResourceOwnerForgetJIT(), ResourceOwnerForgetPlanCacheRef(), ResourceOwnerForgetRelationRef(), ResourceOwnerForgetSnapshot(), and ResourceOwnerForgetTupleDesc().

{
    uint32      i,
                idx,
                lastidx = resarr->lastidx;

    Assert(value != resarr->invalidval);

    /* Search through all items, but try lastidx first. */
    if (RESARRAY_IS_ARRAY(resarr))
    {
        if (lastidx < resarr->nitems &&
            resarr->itemsarr[lastidx] == value)
        {
            resarr->itemsarr[lastidx] = resarr->itemsarr[resarr->nitems - 1];
            resarr->nitems--;
            /* Update lastidx to make reverse-order removals fast. */
            resarr->lastidx = resarr->nitems - 1;
            return true;
        }
        for (i = 0; i < resarr->nitems; i++)
        {
            if (resarr->itemsarr[i] == value)
            {
                resarr->itemsarr[i] = resarr->itemsarr[resarr->nitems - 1];
                resarr->nitems--;
                /* Update lastidx to make reverse-order removals fast. */
                resarr->lastidx = resarr->nitems - 1;
                return true;
            }
        }
    }
    else
    {
        uint32      mask = resarr->capacity - 1;

        if (lastidx < resarr->capacity &&
            resarr->itemsarr[lastidx] == value)
        {
            resarr->itemsarr[lastidx] = resarr->invalidval;
            resarr->nitems--;
            return true;
        }
        idx = DatumGetUInt32(hash_any((void *) &value, sizeof(value))) & mask;
        for (i = 0; i < resarr->capacity; i++)
        {
            if (resarr->itemsarr[idx] == value)
            {
                resarr->itemsarr[idx] = resarr->invalidval;
                resarr->nitems--;
                return true;
            }
            idx = (idx + 1) & mask;
        }
    }

    return false;
}

ResourceOwnerCreate()

ResourceOwner ResourceOwnerCreate	(	ResourceOwner	parent,
		const char *	name
	)

Definition at line 422 of file resowner.c.

References ResourceOwnerData::bufferarr, BufferGetDatum, ResourceOwnerData::catlistrefarr, ResourceOwnerData::catrefarr, ResourceOwnerData::dsmarr, ResourceOwnerData::filearr, FileGetDatum, ResourceOwnerData::firstchild, InvalidBuffer, ResourceOwnerData::jitarr, MemoryContextAllocZero(), ResourceOwnerData::name, name, ResourceOwnerData::nextchild, ResourceOwnerData::parent, ResourceOwnerData::planrefarr, PointerGetDatum, ResourceOwnerData::relrefarr, ResourceArrayInit(), ResourceOwnerData::snapshotarr, TopMemoryContext, and ResourceOwnerData::tupdescarr.

Referenced by AtStart_ResourceOwner(), AtSubStart_ResourceOwner(), CreateAuxProcessResourceOwner(), CreatePortal(), perform_base_backup(), plpgsql_create_econtext(), and plpgsql_inline_handler().

{
    ResourceOwner owner;

    owner = (ResourceOwner) MemoryContextAllocZero(TopMemoryContext,
                                                   sizeof(ResourceOwnerData));
    owner->name = name;

    if (parent)
    {
        owner->parent = parent;
        owner->nextchild = parent->firstchild;
        parent->firstchild = owner;
    }

    ResourceArrayInit(&(owner->bufferarr), BufferGetDatum(InvalidBuffer));
    ResourceArrayInit(&(owner->catrefarr), PointerGetDatum(NULL));
    ResourceArrayInit(&(owner->catlistrefarr), PointerGetDatum(NULL));
    ResourceArrayInit(&(owner->relrefarr), PointerGetDatum(NULL));
    ResourceArrayInit(&(owner->planrefarr), PointerGetDatum(NULL));
    ResourceArrayInit(&(owner->tupdescarr), PointerGetDatum(NULL));
    ResourceArrayInit(&(owner->snapshotarr), PointerGetDatum(NULL));
    ResourceArrayInit(&(owner->filearr), FileGetDatum(-1));
    ResourceArrayInit(&(owner->dsmarr), PointerGetDatum(NULL));
    ResourceArrayInit(&(owner->jitarr), PointerGetDatum(NULL));

    return owner;
}

ResourceOwnerDelete()

void ResourceOwnerDelete

(

ResourceOwner

owner

)

Definition at line 712 of file resowner.c.

References Assert, ResourceOwnerData::bufferarr, ResourceOwnerData::catlistrefarr, ResourceOwnerData::catrefarr, ResourceOwnerData::dsmarr, ResourceOwnerData::filearr, ResourceOwnerData::firstchild, ResourceOwnerData::jitarr, MAX_RESOWNER_LOCKS, ResourceArray::nitems, ResourceOwnerData::nlocks, pfree(), ResourceOwnerData::planrefarr, ResourceOwnerData::relrefarr, ResourceArrayFree(), ResourceOwnerDelete(), ResourceOwnerNewParent(), ResourceOwnerData::snapshotarr, and ResourceOwnerData::tupdescarr.

Referenced by CleanupSubTransaction(), CleanupTransaction(), CommitSubTransaction(), CommitTransaction(), plpgsql_inline_handler(), PortalDrop(), PrepareTransaction(), ResourceOwnerDelete(), and WalSndResourceCleanup().

{
    /* We had better not be deleting CurrentResourceOwner ... */
    Assert(owner != CurrentResourceOwner);

    /* And it better not own any resources, either */
    Assert(owner->bufferarr.nitems == 0);
    Assert(owner->catrefarr.nitems == 0);
    Assert(owner->catlistrefarr.nitems == 0);
    Assert(owner->relrefarr.nitems == 0);
    Assert(owner->planrefarr.nitems == 0);
    Assert(owner->tupdescarr.nitems == 0);
    Assert(owner->snapshotarr.nitems == 0);
    Assert(owner->filearr.nitems == 0);
    Assert(owner->dsmarr.nitems == 0);
    Assert(owner->jitarr.nitems == 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. */
    ResourceArrayFree(&(owner->bufferarr));
    ResourceArrayFree(&(owner->catrefarr));
    ResourceArrayFree(&(owner->catlistrefarr));
    ResourceArrayFree(&(owner->relrefarr));
    ResourceArrayFree(&(owner->planrefarr));
    ResourceArrayFree(&(owner->tupdescarr));
    ResourceArrayFree(&(owner->snapshotarr));
    ResourceArrayFree(&(owner->filearr));
    ResourceArrayFree(&(owner->dsmarr));
    ResourceArrayFree(&(owner->jitarr));

    pfree(owner);
}

ResourceOwnerEnlargeBuffers()

void ResourceOwnerEnlargeBuffers

(

ResourceOwner

owner

)

Definition at line 917 of file resowner.c.

References Assert, ResourceOwnerData::bufferarr, and ResourceArrayEnlarge().

Referenced by BgBufferSync(), BufferSync(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), IncrBufferRefCount(), and ReadBuffer_common().

{
    /* We used to allow pinning buffers without a resowner, but no more */
    Assert(owner != NULL);
    ResourceArrayEnlarge(&(owner->bufferarr));
}

ResourceOwnerEnlargeCatCacheListRefs()

void ResourceOwnerEnlargeCatCacheListRefs

(

ResourceOwner

owner

)

Definition at line 1041 of file resowner.c.

References ResourceOwnerData::catlistrefarr, and ResourceArrayEnlarge().

Referenced by SearchCatCacheList().

{
    ResourceArrayEnlarge(&(owner->catlistrefarr));
}

ResourceOwnerEnlargeCatCacheRefs()

void ResourceOwnerEnlargeCatCacheRefs

(

ResourceOwner

owner

)

Definition at line 1006 of file resowner.c.

References ResourceOwnerData::catrefarr, and ResourceArrayEnlarge().

Referenced by SearchCatCacheInternal(), and SearchCatCacheMiss().

{
    ResourceArrayEnlarge(&(owner->catrefarr));
}

ResourceOwnerEnlargeDSMs()

void ResourceOwnerEnlargeDSMs

(

ResourceOwner

owner

)

Definition at line 1302 of file resowner.c.

References ResourceOwnerData::dsmarr, and ResourceArrayEnlarge().

Referenced by dsm_create_descriptor(), and dsm_unpin_mapping().

{
    ResourceArrayEnlarge(&(owner->dsmarr));
}

ResourceOwnerEnlargeFiles()

void ResourceOwnerEnlargeFiles

(

ResourceOwner

owner

)

Definition at line 1257 of file resowner.c.

References ResourceOwnerData::filearr, and ResourceArrayEnlarge().

Referenced by OpenTemporaryFile(), PathNameCreateTemporaryFile(), and PathNameOpenTemporaryFile().

{
    ResourceArrayEnlarge(&(owner->filearr));
}

ResourceOwnerEnlargeJIT()

void ResourceOwnerEnlargeJIT

(

ResourceOwner

owner

)

Definition at line 1347 of file resowner.c.

References ResourceOwnerData::jitarr, and ResourceArrayEnlarge().

Referenced by llvm_create_context().

{
    ResourceArrayEnlarge(&(owner->jitarr));
}

ResourceOwnerEnlargePlanCacheRefs()

void ResourceOwnerEnlargePlanCacheRefs

(

ResourceOwner

owner

)

Definition at line 1121 of file resowner.c.

References ResourceOwnerData::planrefarr, and ResourceArrayEnlarge().

Referenced by CachedPlanAllowsSimpleValidityCheck(), CachedPlanIsSimplyValid(), and GetCachedPlan().

{
    ResourceArrayEnlarge(&(owner->planrefarr));
}

ResourceOwnerEnlargeRelationRefs()

void ResourceOwnerEnlargeRelationRefs

(

ResourceOwner

owner

)

Definition at line 1076 of file resowner.c.

References ResourceOwnerData::relrefarr, and ResourceArrayEnlarge().

Referenced by RelationIncrementReferenceCount().

{
    ResourceArrayEnlarge(&(owner->relrefarr));
}

ResourceOwnerEnlargeSnapshots()

void ResourceOwnerEnlargeSnapshots

(

ResourceOwner

owner

)

Definition at line 1211 of file resowner.c.

References ResourceArrayEnlarge(), and ResourceOwnerData::snapshotarr.

Referenced by RegisterSnapshotOnOwner().

{
    ResourceArrayEnlarge(&(owner->snapshotarr));
}

ResourceOwnerEnlargeTupleDescs()

void ResourceOwnerEnlargeTupleDescs

(

ResourceOwner

owner

)

Definition at line 1165 of file resowner.c.

References ResourceArrayEnlarge(), and ResourceOwnerData::tupdescarr.

Referenced by IncrTupleDescRefCount().

{
    ResourceArrayEnlarge(&(owner->tupdescarr));
}

ResourceOwnerForgetBuffer()

void ResourceOwnerForgetBuffer	(	ResourceOwner	owner,
		Buffer	buffer
	)

Definition at line 939 of file resowner.c.

References ResourceOwnerData::bufferarr, BufferGetDatum, elog, ERROR, ResourceOwnerData::name, and ResourceArrayRemove().

Referenced by ReleaseAndReadBuffer(), ReleaseBuffer(), and UnpinBuffer().

{
    if (!ResourceArrayRemove(&(owner->bufferarr), BufferGetDatum(buffer)))
        elog(ERROR, "buffer %d is not owned by resource owner %s",
             buffer, owner->name);
}

ResourceOwnerForgetCatCacheListRef()

void ResourceOwnerForgetCatCacheListRef	(	ResourceOwner	owner,
		CatCList *	list
	)

Definition at line 1061 of file resowner.c.

References ResourceOwnerData::catlistrefarr, elog, ERROR, ResourceOwnerData::name, PointerGetDatum, and ResourceArrayRemove().

Referenced by ReleaseCatCacheList().

{
    if (!ResourceArrayRemove(&(owner->catlistrefarr), PointerGetDatum(list)))
        elog(ERROR, "catcache list reference %p is not owned by resource owner %s",
             list, owner->name);
}

ResourceOwnerForgetCatCacheRef()

void ResourceOwnerForgetCatCacheRef	(	ResourceOwner	owner,
		HeapTuple	tuple
	)

Definition at line 1026 of file resowner.c.

References ResourceOwnerData::catrefarr, elog, ERROR, ResourceOwnerData::name, PointerGetDatum, and ResourceArrayRemove().

Referenced by ReleaseCatCache().

{
    if (!ResourceArrayRemove(&(owner->catrefarr), PointerGetDatum(tuple)))
        elog(ERROR, "catcache reference %p is not owned by resource owner %s",
             tuple, owner->name);
}

ResourceOwnerForgetDSM()

void ResourceOwnerForgetDSM	(	ResourceOwner	owner,
		dsm_segment *	seg
	)

Definition at line 1322 of file resowner.c.

References dsm_segment_handle(), ResourceOwnerData::dsmarr, elog, ERROR, ResourceOwnerData::name, PointerGetDatum, and ResourceArrayRemove().

Referenced by dsm_create(), dsm_detach(), and dsm_pin_mapping().

{
    if (!ResourceArrayRemove(&(owner->dsmarr), PointerGetDatum(seg)))
        elog(ERROR, "dynamic shared memory segment %u is not owned by resource owner %s",
             dsm_segment_handle(seg), owner->name);
}

ResourceOwnerForgetFile()

void ResourceOwnerForgetFile	(	ResourceOwner	owner,
		File	file
	)

Definition at line 1277 of file resowner.c.

References elog, ERROR, ResourceOwnerData::filearr, FileGetDatum, ResourceOwnerData::name, and ResourceArrayRemove().

Referenced by FileClose().

{
    if (!ResourceArrayRemove(&(owner->filearr), FileGetDatum(file)))
        elog(ERROR, "temporary file %d is not owned by resource owner %s",
             file, owner->name);
}

ResourceOwnerForgetJIT()

void ResourceOwnerForgetJIT	(	ResourceOwner	owner,
		Datum	handle
	)

Definition at line 1367 of file resowner.c.

References DatumGetPointer, elog, ERROR, ResourceOwnerData::jitarr, ResourceOwnerData::name, and ResourceArrayRemove().

Referenced by jit_release_context().

{
    if (!ResourceArrayRemove(&(owner->jitarr), handle))
        elog(ERROR, "JIT context %p is not owned by resource owner %s",
             DatumGetPointer(handle), owner->name);
}

ResourceOwnerForgetLock()

void ResourceOwnerForgetLock	(	ResourceOwner	owner,
		LOCALLOCK *	locallock
	)

Definition at line 977 of file resowner.c.

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

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

{
    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);
}

ResourceOwnerForgetPlanCacheRef()

void ResourceOwnerForgetPlanCacheRef	(	ResourceOwner	owner,
		CachedPlan *	plan
	)

Definition at line 1141 of file resowner.c.

References elog, ERROR, ResourceOwnerData::name, ResourceOwnerData::planrefarr, PointerGetDatum, and ResourceArrayRemove().

Referenced by ReleaseCachedPlan().

{
    if (!ResourceArrayRemove(&(owner->planrefarr), PointerGetDatum(plan)))
        elog(ERROR, "plancache reference %p is not owned by resource owner %s",
             plan, owner->name);
}

ResourceOwnerForgetRelationRef()

void ResourceOwnerForgetRelationRef	(	ResourceOwner	owner,
		Relation	rel
	)

Definition at line 1096 of file resowner.c.

References elog, ERROR, ResourceOwnerData::name, PointerGetDatum, RelationGetRelationName, ResourceOwnerData::relrefarr, and ResourceArrayRemove().

Referenced by RelationDecrementReferenceCount().

{
    if (!ResourceArrayRemove(&(owner->relrefarr), PointerGetDatum(rel)))
        elog(ERROR, "relcache reference %s is not owned by resource owner %s",
             RelationGetRelationName(rel), owner->name);
}

ResourceOwnerForgetSnapshot()

void ResourceOwnerForgetSnapshot	(	ResourceOwner	owner,
		Snapshot	snapshot
	)

Definition at line 1231 of file resowner.c.

References elog, ERROR, ResourceOwnerData::name, PointerGetDatum, ResourceArrayRemove(), and ResourceOwnerData::snapshotarr.

Referenced by UnregisterSnapshotFromOwner().

{
    if (!ResourceArrayRemove(&(owner->snapshotarr), PointerGetDatum(snapshot)))
        elog(ERROR, "snapshot reference %p is not owned by resource owner %s",
             snapshot, owner->name);
}

ResourceOwnerForgetTupleDesc()

void ResourceOwnerForgetTupleDesc	(	ResourceOwner	owner,
		TupleDesc	tupdesc
	)

Definition at line 1185 of file resowner.c.

References elog, ERROR, ResourceOwnerData::name, PointerGetDatum, ResourceArrayRemove(), and ResourceOwnerData::tupdescarr.

Referenced by DecrTupleDescRefCount().

{
    if (!ResourceArrayRemove(&(owner->tupdescarr), PointerGetDatum(tupdesc)))
        elog(ERROR, "tupdesc reference %p is not owned by resource owner %s",
             tupdesc, owner->name);
}

ResourceOwnerGetParent()

ResourceOwner ResourceOwnerGetParent

(

ResourceOwner

owner

)

Definition at line 763 of file resowner.c.

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

{
    return owner->parent;
}

ResourceOwnerNewParent()

void ResourceOwnerNewParent	(	ResourceOwner	owner,
		ResourceOwner	newparent
	)

Definition at line 772 of file resowner.c.

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

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

{
    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;
    }
}

ResourceOwnerRelease()

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

Definition at line 478 of file resowner.c.

References ResourceOwnerReleaseInternal().

Referenced by AbortSubTransaction(), AbortTransaction(), CommitSubTransaction(), CommitTransaction(), PortalDrop(), PrepareTransaction(), ReleaseAuxProcessResources(), and WalSndResourceCleanup().

{
    /* There's not currently any setup needed before recursing */
    ResourceOwnerReleaseInternal(owner, phase, isCommit, isTopLevel);
}

ResourceOwnerReleaseAllPlanCacheRefs()

void ResourceOwnerReleaseAllPlanCacheRefs

(

ResourceOwner

owner

)

Definition at line 689 of file resowner.c.

References CurrentResourceOwner, DatumGetPointer, ResourceOwnerData::planrefarr, ReleaseCachedPlan(), and ResourceArrayGetAny().

Referenced by plpgsql_inline_handler(), and plpgsql_xact_cb().

{
    ResourceOwner save;
    Datum       foundres;

    save = CurrentResourceOwner;
    CurrentResourceOwner = owner;
    while (ResourceArrayGetAny(&(owner->planrefarr), &foundres))
    {
        CachedPlan *res = (CachedPlan *) DatumGetPointer(foundres);

        ReleaseCachedPlan(res, true);
    }
    CurrentResourceOwner = save;
}

ResourceOwnerReleaseInternal()

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

static

Definition at line 488 of file resowner.c.

References ResourceReleaseCallbackItem::arg, Assert, ResourceOwnerData::bufferarr, ResourceReleaseCallbackItem::callback, ResourceOwnerData::catlistrefarr, ResourceOwnerData::catrefarr, CurrentResourceOwner, DatumGetBuffer, DatumGetFile, DatumGetPointer, DecrTupleDescRefCount(), dsm_detach(), ResourceOwnerData::dsmarr, ResourceOwnerData::filearr, FileClose(), ResourceOwnerData::firstchild, jit_release_context(), ResourceOwnerData::jitarr, LockReassignCurrentOwner(), LockReleaseCurrentOwner(), ResourceOwnerData::locks, MAX_RESOWNER_LOCKS, ResourceReleaseCallbackItem::next, ResourceOwnerData::nextchild, ResourceOwnerData::nlocks, ResourceOwnerData::parent, ResourceOwnerData::planrefarr, PointerGetDatum, PrintBufferLeakWarning(), PrintCatCacheLeakWarning(), PrintCatCacheListLeakWarning(), PrintDSMLeakWarning(), PrintFileLeakWarning(), PrintPlanCacheLeakWarning(), PrintRelCacheLeakWarning(), PrintSnapshotLeakWarning(), PrintTupleDescLeakWarning(), ProcReleaseLocks(), RelationClose(), ReleaseBuffer(), ReleaseCachedPlan(), ReleaseCatCache(), ReleaseCatCacheList(), ReleasePredicateLocks(), ResourceOwnerData::relrefarr, RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceArrayGetAny(), ResourceOwnerData::snapshotarr, ResourceOwnerData::tupdescarr, and UnregisterSnapshot().

Referenced by ResourceOwnerRelease().

{
    ResourceOwner child;
    ResourceOwner save;
    ResourceReleaseCallbackItem *item;
    Datum       foundres;

    /* Recurse to handle descendants */
    for (child = owner->firstchild; child != NULL; child = child->nextchild)
        ResourceOwnerReleaseInternal(child, phase, isCommit, isTopLevel);

    /*
     * Make CurrentResourceOwner point to me, so that ReleaseBuffer etc don't
     * get confused.
     */
    save = CurrentResourceOwner;
    CurrentResourceOwner = owner;

    if (phase == RESOURCE_RELEASE_BEFORE_LOCKS)
    {
        /*
         * Release buffer pins.  Note that ReleaseBuffer will remove the
         * buffer entry from our array, so we just have to iterate till there
         * are none.
         *
         * During a commit, there shouldn't be any remaining pins --- that
         * would indicate failure to clean up the executor correctly --- so
         * issue warnings.  In the abort case, just clean up quietly.
         */
        while (ResourceArrayGetAny(&(owner->bufferarr), &foundres))
        {
            Buffer      res = DatumGetBuffer(foundres);

            if (isCommit)
                PrintBufferLeakWarning(res);
            ReleaseBuffer(res);
        }

        /* Ditto for relcache references */
        while (ResourceArrayGetAny(&(owner->relrefarr), &foundres))
        {
            Relation    res = (Relation) DatumGetPointer(foundres);

            if (isCommit)
                PrintRelCacheLeakWarning(res);
            RelationClose(res);
        }

        /* Ditto for dynamic shared memory segments */
        while (ResourceArrayGetAny(&(owner->dsmarr), &foundres))
        {
            dsm_segment *res = (dsm_segment *) DatumGetPointer(foundres);

            if (isCommit)
                PrintDSMLeakWarning(res);
            dsm_detach(res);
        }

        /* Ditto for JIT contexts */
        while (ResourceArrayGetAny(&(owner->jitarr), &foundres))
        {
            JitContext *context = (JitContext *) PointerGetDatum(foundres);

            jit_release_context(context);
        }
    }
    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 catcache references.  Note that ReleaseCatCache will remove
         * the catref entry from our array, so we just have to iterate till
         * there are none.
         *
         * As with buffer pins, warn if any are left at commit time.
         */
        while (ResourceArrayGetAny(&(owner->catrefarr), &foundres))
        {
            HeapTuple   res = (HeapTuple) DatumGetPointer(foundres);

            if (isCommit)
                PrintCatCacheLeakWarning(res);
            ReleaseCatCache(res);
        }

        /* Ditto for catcache lists */
        while (ResourceArrayGetAny(&(owner->catlistrefarr), &foundres))
        {
            CatCList   *res = (CatCList *) DatumGetPointer(foundres);

            if (isCommit)
                PrintCatCacheListLeakWarning(res);
            ReleaseCatCacheList(res);
        }

        /* Ditto for plancache references */
        while (ResourceArrayGetAny(&(owner->planrefarr), &foundres))
        {
            CachedPlan *res = (CachedPlan *) DatumGetPointer(foundres);

            if (isCommit)
                PrintPlanCacheLeakWarning(res);
            ReleaseCachedPlan(res, true);
        }

        /* Ditto for tupdesc references */
        while (ResourceArrayGetAny(&(owner->tupdescarr), &foundres))
        {
            TupleDesc   res = (TupleDesc) DatumGetPointer(foundres);

            if (isCommit)
                PrintTupleDescLeakWarning(res);
            DecrTupleDescRefCount(res);
        }

        /* Ditto for snapshot references */
        while (ResourceArrayGetAny(&(owner->snapshotarr), &foundres))
        {
            Snapshot    res = (Snapshot) DatumGetPointer(foundres);

            if (isCommit)
                PrintSnapshotLeakWarning(res);
            UnregisterSnapshot(res);
        }

        /* Ditto for temporary files */
        while (ResourceArrayGetAny(&(owner->filearr), &foundres))
        {
            File        res = DatumGetFile(foundres);

            if (isCommit)
                PrintFileLeakWarning(res);
            FileClose(res);
        }
    }

    /* Let add-on modules get a chance too */
    for (item = ResourceRelease_callbacks; item; item = item->next)
        item->callback(phase, isCommit, isTopLevel, item->arg);

    CurrentResourceOwner = save;
}

ResourceOwnerRememberBuffer()

void ResourceOwnerRememberBuffer	(	ResourceOwner	owner,
		Buffer	buffer
	)

Definition at line 930 of file resowner.c.

References ResourceOwnerData::bufferarr, BufferGetDatum, and ResourceArrayAdd().

Referenced by IncrBufferRefCount(), LocalBufferAlloc(), PinBuffer(), and PinBuffer_Locked().

{
    ResourceArrayAdd(&(owner->bufferarr), BufferGetDatum(buffer));
}

ResourceOwnerRememberCatCacheListRef()

void ResourceOwnerRememberCatCacheListRef	(	ResourceOwner	owner,
		CatCList *	list
	)

Definition at line 1052 of file resowner.c.

References ResourceOwnerData::catlistrefarr, PointerGetDatum, and ResourceArrayAdd().

Referenced by SearchCatCacheList().

{
    ResourceArrayAdd(&(owner->catlistrefarr), PointerGetDatum(list));
}

ResourceOwnerRememberCatCacheRef()

void ResourceOwnerRememberCatCacheRef	(	ResourceOwner	owner,
		HeapTuple	tuple
	)

Definition at line 1017 of file resowner.c.

References ResourceOwnerData::catrefarr, PointerGetDatum, and ResourceArrayAdd().

Referenced by SearchCatCacheInternal(), and SearchCatCacheMiss().

{
    ResourceArrayAdd(&(owner->catrefarr), PointerGetDatum(tuple));
}

ResourceOwnerRememberDSM()

void ResourceOwnerRememberDSM	(	ResourceOwner	owner,
		dsm_segment *	seg
	)

Definition at line 1313 of file resowner.c.

References ResourceOwnerData::dsmarr, PointerGetDatum, and ResourceArrayAdd().

Referenced by dsm_create_descriptor(), and dsm_unpin_mapping().

{
    ResourceArrayAdd(&(owner->dsmarr), PointerGetDatum(seg));
}

ResourceOwnerRememberFile()

void ResourceOwnerRememberFile	(	ResourceOwner	owner,
		File	file
	)

Definition at line 1268 of file resowner.c.

References ResourceOwnerData::filearr, FileGetDatum, and ResourceArrayAdd().

Referenced by RegisterTemporaryFile().

{
    ResourceArrayAdd(&(owner->filearr), FileGetDatum(file));
}

ResourceOwnerRememberJIT()

void ResourceOwnerRememberJIT	(	ResourceOwner	owner,
		Datum	handle
	)

Definition at line 1358 of file resowner.c.

References ResourceOwnerData::jitarr, and ResourceArrayAdd().

Referenced by llvm_create_context().

{
    ResourceArrayAdd(&(owner->jitarr), handle);
}

ResourceOwnerRememberLock()

void ResourceOwnerRememberLock	(	ResourceOwner	owner,
		LOCALLOCK *	locallock
	)

Definition at line 957 of file resowner.c.

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

Referenced by GrantLockLocal(), and LockReassignOwner().

{
    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++;
}

ResourceOwnerRememberPlanCacheRef()

void ResourceOwnerRememberPlanCacheRef	(	ResourceOwner	owner,
		CachedPlan *	plan
	)

Definition at line 1132 of file resowner.c.

References ResourceOwnerData::planrefarr, PointerGetDatum, and ResourceArrayAdd().

Referenced by CachedPlanAllowsSimpleValidityCheck(), CachedPlanIsSimplyValid(), and GetCachedPlan().

{
    ResourceArrayAdd(&(owner->planrefarr), PointerGetDatum(plan));
}

ResourceOwnerRememberRelationRef()

void ResourceOwnerRememberRelationRef	(	ResourceOwner	owner,
		Relation	rel
	)

Definition at line 1087 of file resowner.c.

References PointerGetDatum, ResourceOwnerData::relrefarr, and ResourceArrayAdd().

Referenced by RelationIncrementReferenceCount().

{
    ResourceArrayAdd(&(owner->relrefarr), PointerGetDatum(rel));
}

ResourceOwnerRememberSnapshot()

void ResourceOwnerRememberSnapshot	(	ResourceOwner	owner,
		Snapshot	snapshot
	)

Definition at line 1222 of file resowner.c.

References PointerGetDatum, ResourceArrayAdd(), and ResourceOwnerData::snapshotarr.

Referenced by RegisterSnapshotOnOwner().

{
    ResourceArrayAdd(&(owner->snapshotarr), PointerGetDatum(snapshot));
}

ResourceOwnerRememberTupleDesc()

void ResourceOwnerRememberTupleDesc	(	ResourceOwner	owner,
		TupleDesc	tupdesc
	)

Definition at line 1176 of file resowner.c.

References PointerGetDatum, ResourceArrayAdd(), and ResourceOwnerData::tupdescarr.

Referenced by IncrTupleDescRefCount().

{
    ResourceArrayAdd(&(owner->tupdescarr), PointerGetDatum(tupdesc));
}

UnregisterResourceReleaseCallback()

void UnregisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 834 of file resowner.c.

References ResourceReleaseCallbackItem::next, and pfree().

{
    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;
        }
    }
}

Variable Documentation

AuxProcessResourceOwner

ResourceOwner AuxProcessResourceOwner = NULL

Definition at line 145 of file resowner.c.

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

CurrentResourceOwner

ResourceOwner CurrentResourceOwner = NULL

Definition at line 142 of file resowner.c.

Referenced by AssignTransactionId(), AtAbort_ResourceOwner(), AtStart_ResourceOwner(), AtSubAbort_ResourceOwner(), AtSubStart_ResourceOwner(), BgBufferSync(), BufferSync(), cipher_free_callback(), CleanupSubTransaction(), CleanupTransaction(), close_lo_relation(), CommitSubTransaction(), CommitTransaction(), DecrTupleDescRefCount(), digest_free_callback(), dsm_create_descriptor(), dsm_unpin_mapping(), exec_eval_simple_expr(), exec_init_tuple_store(), exec_stmt_block(), extendBufFile(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetCachedPlan(), GetCurrentFDWTuplestore(), IncrBufferRefCount(), IncrTupleDescRefCount(), InitPostgres(), llvm_create_context(), LocalBufferAlloc(), lock_and_open_sequence(), LockAcquireExtended(), LockReassignCurrentOwner(), LockReassignOwner(), LockRelease(), makeBufFileCommon(), MakeTransitionCaptureState(), open_lo_relation(), OpenTemporaryFile(), PathNameCreateTemporaryFile(), PathNameOpenTemporaryFile(), perform_base_backup(), PersistHoldablePortal(), pg_logical_replication_slot_advance(), pg_logical_slot_get_changes_guts(), PinBuffer(), PinBuffer_Locked(), 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(), ReadBuffer_common(), RegisterSnapshot(), RegisterTemporaryFile(), RelationDecrementReferenceCount(), RelationIncrementReferenceCount(), ReleaseAndReadBuffer(), ReleaseBuffer(), ReleaseCachedPlan(), ReleaseCatCache(), ReleaseCatCacheList(), ReleaseLockIfHeld(), ResourceOwnerReleaseAllPlanCacheRefs(), ResourceOwnerReleaseInternal(), SearchCatCacheInternal(), SearchCatCacheList(), SearchCatCacheMiss(), ShutdownXLOG(), SnapBuildClearExportedSnapshot(), SnapBuildExportSnapshot(), StartupXLOG(), tuplestore_begin_common(), tuplestore_puttuple_common(), UnpinBuffer(), UnregisterSnapshot(), and WalSndResourceCleanup().

CurTransactionResourceOwner

ResourceOwner CurTransactionResourceOwner = NULL

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

Referenced by RegisterResourceReleaseCallback().

TopTransactionResourceOwner

ResourceOwner TopTransactionResourceOwner = NULL

Definition at line 144 of file resowner.c.

Referenced by AbortTransaction(), AtAbort_ResourceOwner(), AtStart_ResourceOwner(), CleanupTransaction(), close_lo_relation(), CommitTransaction(), inv_close(), inv_open(), lock_and_open_sequence(), open_lo_relation(), plpgsql_create_econtext(), PortalRun(), and PrepareTransaction().