lockcmds.c File Reference

#include "postgres.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/namespace.h"
#include "catalog/pg_inherits.h"
#include "commands/lockcmds.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "rewrite/rewriteHandler.h"
#include "storage/lmgr.h"
#include "utils/acl.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"

Include dependency graph for lockcmds.c:

Go to the source code of this file.

Data Structures
struct	LockViewRecurse_context

Functions
static void	LockTableRecurse (Oid reloid, LOCKMODE lockmode, bool nowait)
static AclResult	LockTableAclCheck (Oid reloid, LOCKMODE lockmode, Oid userid)
static void	RangeVarCallbackForLockTable (const RangeVar *rv, Oid relid, Oid oldrelid, void *arg)
static void	LockViewRecurse (Oid reloid, LOCKMODE lockmode, bool nowait, List *ancestor_views)
void	LockTableCommand (LockStmt *lockstmt)
static bool	LockViewRecurse_walker (Node *node, LockViewRecurse_context *context)

Function Documentation

LockTableAclCheck()

static AclResult LockTableAclCheck ( Oid  reloid, LOCKMODE  lockmode, Oid  userid  )

static

Definition at line 302 of file lockcmds.c.

{
    AclResult   aclresult;
    AclMode     aclmask;
 
    /* any of these privileges permit any lock mode */
    aclmask = ACL_MAINTAIN | ACL_UPDATE | ACL_DELETE | ACL_TRUNCATE;
 
    /* SELECT privileges also permit ACCESS SHARE and below */
    if (lockmode <= AccessShareLock)
        aclmask |= ACL_SELECT;
 
    /* INSERT privileges also permit ROW EXCLUSIVE and below */
    if (lockmode <= RowExclusiveLock)
        aclmask |= ACL_INSERT;
 
    aclresult = pg_class_aclcheck(reloid, userid, aclmask);
 
    return aclresult;
}

References AccessShareLock, ACL_DELETE, ACL_INSERT, ACL_MAINTAIN, ACL_SELECT, ACL_TRUNCATE, ACL_UPDATE, aclmask(), fb(), pg_class_aclcheck(), and RowExclusiveLock.

Referenced by LockViewRecurse_walker(), and RangeVarCallbackForLockTable().

LockTableCommand()

void LockTableCommand

(

LockStmt *

lockstmt

)

Definition at line 41 of file lockcmds.c.

{
    ListCell   *p;
 
    /*
     * Iterate over the list and process the named relations one at a time
     */
    foreach(p, lockstmt->relations)
    {
        RangeVar   *rv = (RangeVar *) lfirst(p);
        bool        recurse = rv->inh;
        Oid         reloid;
 
        reloid = RangeVarGetRelidExtended(rv, lockstmt->mode,
                                          lockstmt->nowait ? RVR_NOWAIT : 0,
                                          RangeVarCallbackForLockTable,
                                          &lockstmt->mode);
 
        if (get_rel_relkind(reloid) == RELKIND_VIEW)
            LockViewRecurse(reloid, lockstmt->mode, lockstmt->nowait, NIL);
        else if (recurse)
            LockTableRecurse(reloid, lockstmt->mode, lockstmt->nowait);
    }
}

References fb(), get_rel_relkind(), RangeVar::inh, lfirst, LockTableRecurse(), LockViewRecurse(), NIL, RangeVarCallbackForLockTable(), RangeVarGetRelidExtended(), and RVR_NOWAIT.

Referenced by standard_ProcessUtility().

LockTableRecurse()

static void LockTableRecurse ( Oid  reloid, LOCKMODE  lockmode, bool  nowait  )

static

Definition at line 129 of file lockcmds.c.

{
    List       *children;
    ListCell   *lc;
 
    children = find_all_inheritors(reloid, NoLock, NULL);
 
    foreach(lc, children)
    {
        Oid         childreloid = lfirst_oid(lc);
 
        /* Parent already locked. */
        if (childreloid == reloid)
            continue;
 
        if (!nowait)
            LockRelationOid(childreloid, lockmode);
        else if (!ConditionalLockRelationOid(childreloid, lockmode))
        {
            /* try to throw error by name; relation could be deleted... */
            char       *relname = get_rel_name(childreloid);
 
            if (!relname)
                continue;       /* child concurrently dropped, just skip it */
            ereport(ERROR,
                    (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                     errmsg("could not obtain lock on relation \"%s\"",
                            relname)));
        }
 
        /*
         * Even if we got the lock, child might have been concurrently
         * dropped. If so, we can skip it.
         */
        if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(childreloid)))
        {
            /* Release useless lock */
            UnlockRelationOid(childreloid, lockmode);
            continue;
        }
    }
}

References ConditionalLockRelationOid(), ereport, errcode(), errmsg, ERROR, fb(), find_all_inheritors(), get_rel_name(), lfirst_oid, LockRelationOid(), NoLock, ObjectIdGetDatum(), relname, SearchSysCacheExists1, and UnlockRelationOid().

Referenced by LockTableCommand(), and LockViewRecurse_walker().

LockViewRecurse()

static void LockViewRecurse ( Oid  reloid, LOCKMODE  lockmode, bool  nowait, List *  ancestor_views  )

static

Definition at line 267 of file lockcmds.c.

{
    LockViewRecurse_context context;
    Relation    view;
    Query      *viewquery;
 
    /* caller has already locked the view */
    view = table_open(reloid, NoLock);
    viewquery = get_view_query(view);
 
    /*
     * If the view has the security_invoker property set, check permissions as
     * the current user.  Otherwise, check permissions as the view owner.
     */
    context.lockmode = lockmode;
    context.nowait = nowait;
    if (RelationHasSecurityInvoker(view))
        context.check_as_user = GetUserId();
    else
        context.check_as_user = view->rd_rel->relowner;
    context.viewoid = reloid;
    context.ancestor_views = lappend_oid(ancestor_views, reloid);
 
    LockViewRecurse_walker((Node *) viewquery, &context);
 
    context.ancestor_views = list_delete_last(context.ancestor_views);
 
    table_close(view, NoLock);
}

References LockViewRecurse_context::ancestor_views, LockViewRecurse_context::check_as_user, fb(), get_view_query(), GetUserId(), lappend_oid(), list_delete_last(), LockViewRecurse_context::lockmode, LockViewRecurse_walker(), NoLock, LockViewRecurse_context::nowait, RelationData::rd_rel, RelationHasSecurityInvoker, table_close(), table_open(), and LockViewRecurse_context::viewoid.

Referenced by LockTableCommand(), and LockViewRecurse_walker().

LockViewRecurse_walker()

static bool LockViewRecurse_walker ( Node *  node, LockViewRecurse_context *  context  )

static

Definition at line 189 of file lockcmds.c.

{
    if (node == NULL)
        return false;
 
    if (IsA(node, Query))
    {
        Query      *query = (Query *) node;
        ListCell   *rtable;
 
        foreach(rtable, query->rtable)
        {
            RangeTblEntry *rte = lfirst(rtable);
            AclResult   aclresult;
 
            Oid         relid = rte->relid;
            char        relkind = rte->relkind;
            char       *relname = get_rel_name(relid);
 
            /* Currently, we only allow plain tables or views to be locked. */
            if (relkind != RELKIND_RELATION && relkind != RELKIND_PARTITIONED_TABLE &&
                relkind != RELKIND_VIEW)
                continue;
 
            /*
             * Conflict log tables only support SELECT, DELETE, and TRUNCATE.
             * A direct LOCK on them is permitted solely so that pg_dump can
             * lock them during a binary upgrade; locking one indirectly by
             * locking a view over it is not needed for that, so skip it here
             * rather than locking it.
             */
            if (IsConflictLogTableNamespace(get_rel_namespace(relid)))
                continue;
 
            /*
             * We might be dealing with a self-referential view.  If so, we
             * can just stop recursing, since we already locked it.
             */
            if (list_member_oid(context->ancestor_views, relid))
                continue;
 
            /*
             * Check permissions as the specified user.  This will either be
             * the view owner or the current user.
             */
            aclresult = LockTableAclCheck(relid, context->lockmode,
                                          context->check_as_user);
            if (aclresult != ACLCHECK_OK)
                aclcheck_error(aclresult, get_relkind_objtype(relkind), relname);
 
            /* We have enough rights to lock the relation; do so. */
            if (!context->nowait)
                LockRelationOid(relid, context->lockmode);
            else if (!ConditionalLockRelationOid(relid, context->lockmode))
                ereport(ERROR,
                        (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                         errmsg("could not obtain lock on relation \"%s\"",
                                relname)));
 
            if (relkind == RELKIND_VIEW)
                LockViewRecurse(relid, context->lockmode, context->nowait,
                                context->ancestor_views);
            else if (rte->inh)
                LockTableRecurse(relid, context->lockmode, context->nowait);
        }
 
        return query_tree_walker(query,
                                 LockViewRecurse_walker,
                                 context,
                                 QTW_IGNORE_JOINALIASES);
    }
 
    return expression_tree_walker(node,
                                  LockViewRecurse_walker,
                                  context);
}

References aclcheck_error(), ACLCHECK_OK, LockViewRecurse_context::ancestor_views, LockViewRecurse_context::check_as_user, ConditionalLockRelationOid(), ereport, errcode(), errmsg, ERROR, expression_tree_walker, fb(), get_rel_name(), get_rel_namespace(), get_relkind_objtype(), IsA, IsConflictLogTableNamespace(), lfirst, list_member_oid(), LockViewRecurse_context::lockmode, LockRelationOid(), LockTableAclCheck(), LockTableRecurse(), LockViewRecurse(), LockViewRecurse_walker(), LockViewRecurse_context::nowait, QTW_IGNORE_JOINALIASES, query_tree_walker, relname, and Query::rtable.

Referenced by LockViewRecurse(), and LockViewRecurse_walker().

RangeVarCallbackForLockTable()

static void RangeVarCallbackForLockTable ( const RangeVar *  rv, Oid  relid, Oid  oldrelid, void *  arg  )

static

Definition at line 71 of file lockcmds.c.

{
    LOCKMODE    lockmode = *(LOCKMODE *) arg;
    char        relkind;
    char        relpersistence;
    AclResult   aclresult;
 
    if (!OidIsValid(relid))
        return;                 /* doesn't exist, so no permissions check */
    relkind = get_rel_relkind(relid);
    if (!relkind)
        return;                 /* woops, concurrently dropped; no permissions
                                 * check */
 
    /*
     * Note: Conflict log tables are deliberately NOT blocked here, even
     * though other direct DDL on them is rejected elsewhere. pg_dump relies
     * on being able to take an ACCESS SHARE lock on these tables to safely
     * dump their definitions during a binary upgrade, so we permit LOCK
     * commands on them and treat them like ordinary tables here. It's true
     * that a strong lock (ShareLock or above) on such a table would conflict
     * with the RowExclusiveLock taken by the apply worker's inserts and could
     * stall conflict logging as well as the apply worker for as long as it is
     * held. But locking a system-managed conflict log table is an unusual
     * thing to do, and it doesn't seem worth the trouble of filtering by lock
     * mode here.
     */
    if (relkind != RELKIND_RELATION && relkind != RELKIND_PARTITIONED_TABLE &&
        relkind != RELKIND_VIEW)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot lock relation \"%s\"",
                        rv->relname),
                 errdetail_relkind_not_supported(relkind)));
 
    /*
     * Make note if a temporary relation has been accessed in this
     * transaction.
     */
    relpersistence = get_rel_persistence(relid);
    if (relpersistence == RELPERSISTENCE_TEMP)
        MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE;
 
    /* Check permissions. */
    aclresult = LockTableAclCheck(relid, lockmode, GetUserId());
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, get_relkind_objtype(get_rel_relkind(relid)), rv->relname);
}

References aclcheck_error(), ACLCHECK_OK, arg, ereport, errcode(), errdetail_relkind_not_supported(), errmsg, ERROR, fb(), get_rel_persistence(), get_rel_relkind(), get_relkind_objtype(), GetUserId(), LockTableAclCheck(), MyXactFlags, OidIsValid, RangeVar::relname, and XACT_FLAGS_ACCESSEDTEMPNAMESPACE.

Referenced by LockTableCommand().