Add lock file.

diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c
new file mode 100644 (file)
index 0000000..0b1933a
--- /dev/null
+++ b/src/backend/utils/adt/lockfuncs.c
@@ -0,0 +1,146 @@
+/*
+ * lockfuncs.c
+ *     Set-returning functions to view the state of locks within the DB.
+ * 
+ * Copyright (c) 2002, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *     $Header: /cvsroot/pgsql/src/backend/utils/adt/lockfuncs.c,v 1.1 2002/08/17 13:11:43 momjian Exp $
+ */
+
+#include "postgres.h"
+#include "fmgr.h"
+#include "funcapi.h"
+#include "storage/lmgr.h"
+#include "storage/lock.h"
+#include "storage/lwlock.h"
+#include "storage/proc.h"
+
+Datum lock_status_srf(PG_FUNCTION_ARGS);
+
+static int next_lock(int locks[]);
+
+Datum
+lock_status_srf(PG_FUNCTION_ARGS)
+{
+   FuncCallContext     *funccxt;
+   LockData            *lockData;
+
+   if (SRF_IS_FIRSTCALL())
+   {
+       MemoryContext   oldcxt;
+       TupleDesc       tupdesc;
+
+       funccxt = SRF_FIRSTCALL_INIT();
+       tupdesc = RelationNameGetTupleDesc("pg_catalog.pg_locks_result");
+       funccxt->slot = TupleDescGetSlot(tupdesc);
+       funccxt->attinmeta = TupleDescGetAttInMetadata(tupdesc);
+
+       oldcxt = MemoryContextSwitchTo(funccxt->fmctx);
+
+       /*
+        * Preload all the locking information that we will eventually format
+        * and send out as a result set. This is palloc'ed, but since the
+        * MemoryContext is reset when the SRF finishes, we don't need to
+        * free it ourselves.
+        */
+       funccxt->user_fctx = (LockData *) palloc(sizeof(LockData));
+
+       GetLockStatusData(funccxt->user_fctx);
+
+       MemoryContextSwitchTo(oldcxt);
+   }
+
+   funccxt = SRF_PERCALL_SETUP();
+   lockData = (LockData *) funccxt->user_fctx;
+
+   while (lockData->currIdx < lockData->nelements)
+   {
+       PROCLOCK         *holder;
+       LOCK             *lock;
+       PGPROC           *proc;
+       HeapTuple         tuple;
+       Datum             result;
+       char            **values;
+       LOCKMODE          mode;
+       int               num_attrs;
+       int               i;
+       int               currIdx = lockData->currIdx;
+
+       holder      = &(lockData->holders[currIdx]);
+       lock        = &(lockData->locks[currIdx]);
+       proc        = &(lockData->procs[currIdx]);
+       num_attrs   = funccxt->attinmeta->tupdesc->natts;
+
+       values = (char **) palloc(sizeof(*values) * num_attrs);
+
+       for (i = 0; i < num_attrs; i++)
+           values[i] = (char *) palloc(32);
+
+       /* The OID of the locked relation */
+       snprintf(values[0], 32, "%u", lock->tag.relId);
+       /* The database the relation is in */
+       snprintf(values[1], 32, "%u", lock->tag.dbId);
+       /* The PID of the backend holding or waiting for the lock */
+       snprintf(values[2], 32, "%d", proc->pid);
+
+       /*
+        * We need to report both the locks held (i.e. successfully acquired)
+        * by this holder, as well as the locks upon which it is still
+        * waiting, if any. Since a single PROCLOCK struct may contain
+        * multiple locks, we may need to loop several times before we
+        * advance the array index and continue on.
+        */
+       if (holder->nHolding > 0)
+       {
+           /* Already held locks */
+           mode = next_lock(holder->holding);
+           holder->holding[mode]--;
+           holder->nHolding--;
+
+           strcpy(values[4], "t");
+       }
+       else if (proc->waitLock != NULL)
+       {
+           /* Lock that is still being waited on */
+           mode = proc->waitLockMode;
+           proc->waitLock = NULL;
+           proc->waitLockMode = NoLock;
+
+           strcpy(values[4], "f");
+       }
+       else
+       {
+           /*
+            * Okay, we've displayed all the lock's belonging to this PROCLOCK,
+            * procede to the next one.
+            */
+           lockData->currIdx++;
+           continue;
+       }
+
+       strncpy(values[3], GetLockmodeName(mode), 32);
+
+       tuple = BuildTupleFromCStrings(funccxt->attinmeta, values);
+       result = TupleGetDatum(funccxt->slot, tuple);
+       SRF_RETURN_NEXT(funccxt, result);
+   }
+
+   SRF_RETURN_DONE(funccxt);
+}
+
+static LOCKMODE
+next_lock(int locks[])
+{
+   LOCKMODE i;
+
+   for (i = 0; i < MAX_LOCKMODES; i++)
+   {
+       if (locks[i] != 0)
+           return i;
+   }
+
+   /* No locks found: this should not occur */
+   Assert(false);
+   return -1;
+}