This graph shows which files directly or indirectly include this file:

Typedefs
typedef struct ResourceOwnerData *	ResourceOwner
typedef void(*	ResourceReleaseCallback )(ResourceReleasePhase phase, bool isCommit, bool isTopLevel, void *arg)
Enumerations
enum	ResourceReleasePhase { RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, RESOURCE_RELEASE_AFTER_LOCKS }
Functions
ResourceOwner	ResourceOwnerCreate (ResourceOwner parent, const char *name)
void	ResourceOwnerRelease (ResourceOwner owner, ResourceReleasePhase phase, bool isCommit, bool isTopLevel)
void	ResourceOwnerDelete (ResourceOwner owner)
ResourceOwner	ResourceOwnerGetParent (ResourceOwner owner)
void	ResourceOwnerNewParent (ResourceOwner owner, ResourceOwner newparent)
void	RegisterResourceReleaseCallback (ResourceReleaseCallback callback, void *arg)
void	UnregisterResourceReleaseCallback (ResourceReleaseCallback callback, void *arg)
Variables
PGDLLIMPORT ResourceOwner	CurrentResourceOwner
PGDLLIMPORT ResourceOwner	CurTransactionResourceOwner
PGDLLIMPORT ResourceOwner	TopTransactionResourceOwner

Typedef Documentation

typedef struct ResourceOwnerData* ResourceOwner

Definition at line 27 of file resowner.h.

typedef void(* ResourceReleaseCallback)(ResourceReleasePhase phase, bool isCommit, bool isTopLevel, void *arg)

Definition at line 56 of file resowner.h.

Enumeration Type Documentation

enum ResourceReleasePhase

Enumerator:

RESOURCE_RELEASE_BEFORE_LOCKS
RESOURCE_RELEASE_LOCKS
RESOURCE_RELEASE_AFTER_LOCKS

Definition at line 45 of file resowner.h.

{
    RESOURCE_RELEASE_BEFORE_LOCKS,
    RESOURCE_RELEASE_LOCKS,
    RESOURCE_RELEASE_AFTER_LOCKS
} ResourceReleasePhase;

Function Documentation

void RegisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 506 of file resowner.c.

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

{
    ResourceReleaseCallbackItem *item;

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

ResourceOwner ResourceOwnerCreate	(	ResourceOwner	parent,
		const char *	name
	)

Definition at line 150 of file resowner.c.

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

Referenced by AtStart_ResourceOwner(), AtSubStart_ResourceOwner(), BackgroundWriterMain(), CheckpointerMain(), CreatePortal(), InitWalSender(), WalReceiverMain(), and WalWriterMain().

{
    ResourceOwner owner;

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

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

    return owner;
}

void ResourceOwnerDelete ( ResourceOwner owner )

Definition at line 394 of file resowner.c.

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

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

    /* And it better not own any resources, either */
    Assert(owner->nbuffers == 0);
    Assert(owner->nlocks == 0 || owner->nlocks == MAX_RESOWNER_LOCKS + 1);
    Assert(owner->ncatrefs == 0);
    Assert(owner->ncatlistrefs == 0);
    Assert(owner->nrelrefs == 0);
    Assert(owner->nplanrefs == 0);
    Assert(owner->ntupdescs == 0);
    Assert(owner->nsnapshots == 0);
    Assert(owner->nfiles == 0);

    /*
     * 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->buffers)
        pfree(owner->buffers);
    if (owner->catrefs)
        pfree(owner->catrefs);
    if (owner->catlistrefs)
        pfree(owner->catlistrefs);
    if (owner->relrefs)
        pfree(owner->relrefs);
    if (owner->planrefs)
        pfree(owner->planrefs);
    if (owner->tupdescs)
        pfree(owner->tupdescs);
    if (owner->snapshots)
        pfree(owner->snapshots);
    if (owner->files)
        pfree(owner->files);

    pfree(owner);
}

ResourceOwner ResourceOwnerGetParent ( ResourceOwner owner )

Definition at line 449 of file resowner.c.

References ResourceOwnerData::parent.

Referenced by LockReassignCurrentOwner().

{
    return owner->parent;
}

void ResourceOwnerNewParent	(	ResourceOwner	owner,
		ResourceOwner	newparent
	)

Definition at line 458 of file resowner.c.

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

Referenced by 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;
    }
}

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

Definition at line 195 of file resowner.c.

References PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, and ResourceOwnerReleaseInternal().

Referenced by AbortSubTransaction(), AbortTransaction(), BackgroundWriterMain(), CheckpointerMain(), CommitSubTransaction(), CommitTransaction(), PortalDrop(), PrepareTransaction(), and WalWriterMain().

{
    /* Rather than PG_TRY at every level of recursion, set it up once */
    ResourceOwner save;

    save = CurrentResourceOwner;
    PG_TRY();
    {
        ResourceOwnerReleaseInternal(owner, phase, isCommit, isTopLevel);
    }
    PG_CATCH();
    {
        CurrentResourceOwner = save;
        PG_RE_THROW();
    }
    PG_END_TRY();
    CurrentResourceOwner = save;
}

void UnregisterResourceReleaseCallback	(	ResourceReleaseCallback	callback,
		void *	arg
	)

Definition at line 520 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;
        }
    }
}