PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
pgrowlocks.c
Go to the documentation of this file.
1 /*
2  * contrib/pgrowlocks/pgrowlocks.c
3  *
4  * Copyright (c) 2005-2006 Tatsuo Ishii
5  *
6  * Permission to use, copy, modify, and distribute this software and
7  * its documentation for any purpose, without fee, and without a
8  * written agreement is hereby granted, provided that the above
9  * copyright notice and this paragraph and the following two
10  * paragraphs appear in all copies.
11  *
12  * IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT,
13  * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
14  * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
15  * DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED
16  * OF THE POSSIBILITY OF SUCH DAMAGE.
17  *
18  * THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
19  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20  * A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS
21  * IS" BASIS, AND THE AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE,
22  * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
23  */
24 
25 #include "postgres.h"
26 
27 #include "access/multixact.h"
28 #include "access/relscan.h"
29 #include "access/xact.h"
30 #include "catalog/namespace.h"
31 #include "funcapi.h"
32 #include "miscadmin.h"
33 #include "storage/bufmgr.h"
34 #include "storage/procarray.h"
35 #include "utils/acl.h"
36 #include "utils/builtins.h"
37 #include "utils/rel.h"
38 #include "utils/snapmgr.h"
39 #include "utils/tqual.h"
40 #include "utils/varlena.h"
41 
43 
45 
46 /* ----------
47  * pgrowlocks:
48  * returns tids of rows being locked
49  * ----------
50  */
51 
52 #define NCHARS 32
53 
54 typedef struct
55 {
58  int ncolumns;
59 } MyData;
60 
61 #define Atnum_tid 0
62 #define Atnum_xmax 1
63 #define Atnum_ismulti 2
64 #define Atnum_xids 3
65 #define Atnum_modes 4
66 #define Atnum_pids 5
67 
68 Datum
70 {
71  FuncCallContext *funcctx;
72  HeapScanDesc scan;
73  HeapTuple tuple;
74  TupleDesc tupdesc;
75  AttInMetadata *attinmeta;
76  Datum result;
77  MyData *mydata;
78  Relation rel;
79 
80  if (SRF_IS_FIRSTCALL())
81  {
82  text *relname;
83  RangeVar *relrv;
84  MemoryContext oldcontext;
85  AclResult aclresult;
86 
87  funcctx = SRF_FIRSTCALL_INIT();
88  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
89 
90  /* Build a tuple descriptor for our result type */
91  if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
92  elog(ERROR, "return type must be a row type");
93 
94  attinmeta = TupleDescGetAttInMetadata(tupdesc);
95  funcctx->attinmeta = attinmeta;
96 
97  relname = PG_GETARG_TEXT_P(0);
99  rel = heap_openrv(relrv, AccessShareLock);
100 
101  /* check permissions: must have SELECT on table */
102  aclresult = pg_class_aclcheck(RelationGetRelid(rel), GetUserId(),
103  ACL_SELECT);
104  if (aclresult != ACLCHECK_OK)
105  aclcheck_error(aclresult, ACL_KIND_CLASS,
107 
108  scan = heap_beginscan(rel, GetActiveSnapshot(), 0, NULL);
109  mydata = palloc(sizeof(*mydata));
110  mydata->rel = rel;
111  mydata->scan = scan;
112  mydata->ncolumns = tupdesc->natts;
113  funcctx->user_fctx = mydata;
114 
115  MemoryContextSwitchTo(oldcontext);
116  }
117 
118  funcctx = SRF_PERCALL_SETUP();
119  attinmeta = funcctx->attinmeta;
120  mydata = (MyData *) funcctx->user_fctx;
121  scan = mydata->scan;
122 
123  /* scan the relation */
124  while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
125  {
126  HTSU_Result htsu;
127  TransactionId xmax;
128  uint16 infomask;
129 
130  /* must hold a buffer lock to call HeapTupleSatisfiesUpdate */
132 
133  htsu = HeapTupleSatisfiesUpdate(tuple,
134  GetCurrentCommandId(false),
135  scan->rs_cbuf);
136  xmax = HeapTupleHeaderGetRawXmax(tuple->t_data);
137  infomask = tuple->t_data->t_infomask;
138 
139  /*
140  * A tuple is locked if HTSU returns BeingUpdated.
141  */
142  if (htsu == HeapTupleBeingUpdated)
143  {
144  char **values;
145 
146  values = (char **) palloc(mydata->ncolumns * sizeof(char *));
147 
148  values[Atnum_tid] = (char *) DirectFunctionCall1(tidout,
149  PointerGetDatum(&tuple->t_self));
150 
151  values[Atnum_xmax] = palloc(NCHARS * sizeof(char));
152  snprintf(values[Atnum_xmax], NCHARS, "%d", xmax);
153  if (infomask & HEAP_XMAX_IS_MULTI)
154  {
155  MultiXactMember *members;
156  int nmembers;
157  bool first = true;
158  bool allow_old;
159 
160  values[Atnum_ismulti] = pstrdup("true");
161 
162  allow_old = HEAP_LOCKED_UPGRADED(infomask);
163  nmembers = GetMultiXactIdMembers(xmax, &members, allow_old,
164  false);
165  if (nmembers == -1)
166  {
167  values[Atnum_xids] = "{0}";
168  values[Atnum_modes] = "{transient upgrade status}";
169  values[Atnum_pids] = "{0}";
170  }
171  else
172  {
173  int j;
174 
175  values[Atnum_xids] = palloc(NCHARS * nmembers);
176  values[Atnum_modes] = palloc(NCHARS * nmembers);
177  values[Atnum_pids] = palloc(NCHARS * nmembers);
178 
179  strcpy(values[Atnum_xids], "{");
180  strcpy(values[Atnum_modes], "{");
181  strcpy(values[Atnum_pids], "{");
182 
183  for (j = 0; j < nmembers; j++)
184  {
185  char buf[NCHARS];
186 
187  if (!first)
188  {
189  strcat(values[Atnum_xids], ",");
190  strcat(values[Atnum_modes], ",");
191  strcat(values[Atnum_pids], ",");
192  }
193  snprintf(buf, NCHARS, "%d", members[j].xid);
194  strcat(values[Atnum_xids], buf);
195  switch (members[j].status)
196  {
198  snprintf(buf, NCHARS, "Update");
199  break;
201  snprintf(buf, NCHARS, "No Key Update");
202  break;
204  snprintf(buf, NCHARS, "For Update");
205  break;
207  snprintf(buf, NCHARS, "For No Key Update");
208  break;
210  snprintf(buf, NCHARS, "Share");
211  break;
213  snprintf(buf, NCHARS, "Key Share");
214  break;
215  }
216  strcat(values[Atnum_modes], buf);
217  snprintf(buf, NCHARS, "%d",
218  BackendXidGetPid(members[j].xid));
219  strcat(values[Atnum_pids], buf);
220 
221  first = false;
222  }
223 
224  strcat(values[Atnum_xids], "}");
225  strcat(values[Atnum_modes], "}");
226  strcat(values[Atnum_pids], "}");
227  }
228  }
229  else
230  {
231  values[Atnum_ismulti] = pstrdup("false");
232 
233  values[Atnum_xids] = palloc(NCHARS * sizeof(char));
234  snprintf(values[Atnum_xids], NCHARS, "{%d}", xmax);
235 
236  values[Atnum_modes] = palloc(NCHARS);
237  if (infomask & HEAP_XMAX_LOCK_ONLY)
238  {
239  if (HEAP_XMAX_IS_SHR_LOCKED(infomask))
240  snprintf(values[Atnum_modes], NCHARS, "{For Share}");
241  else if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask))
242  snprintf(values[Atnum_modes], NCHARS, "{For Key Share}");
243  else if (HEAP_XMAX_IS_EXCL_LOCKED(infomask))
244  {
245  if (tuple->t_data->t_infomask2 & HEAP_KEYS_UPDATED)
246  snprintf(values[Atnum_modes], NCHARS, "{For Update}");
247  else
248  snprintf(values[Atnum_modes], NCHARS, "{For No Key Update}");
249  }
250  else
251  /* neither keyshare nor exclusive bit it set */
252  snprintf(values[Atnum_modes], NCHARS,
253  "{transient upgrade status}");
254  }
255  else
256  {
257  if (tuple->t_data->t_infomask2 & HEAP_KEYS_UPDATED)
258  snprintf(values[Atnum_modes], NCHARS, "{Update}");
259  else
260  snprintf(values[Atnum_modes], NCHARS, "{No Key Update}");
261  }
262 
263  values[Atnum_pids] = palloc(NCHARS * sizeof(char));
264  snprintf(values[Atnum_pids], NCHARS, "{%d}",
265  BackendXidGetPid(xmax));
266  }
267 
269 
270  /* build a tuple */
271  tuple = BuildTupleFromCStrings(attinmeta, values);
272 
273  /* make the tuple into a datum */
274  result = HeapTupleGetDatum(tuple);
275 
276  /*
277  * no need to pfree what we allocated; it's on a short-lived
278  * memory context anyway
279  */
280 
281  SRF_RETURN_NEXT(funcctx, result);
282  }
283  else
284  {
286  }
287  }
288 
289  heap_endscan(scan);
290  heap_close(mydata->rel, AccessShareLock);
291 
292  SRF_RETURN_DONE(funcctx);
293 }
#define NCHARS
Definition: pgrowlocks.c:52
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:87
PG_FUNCTION_INFO_V1(pgrowlocks)
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:211
#define HEAP_XMAX_LOCK_ONLY
Definition: htup_details.h:182
void heap_endscan(HeapScanDesc scan)
Definition: heapam.c:1581
uint32 TransactionId
Definition: c.h:393
HTSU_Result HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid, Buffer buffer)
Definition: tqual.c:460
Oid GetUserId(void)
Definition: miscinit.c:283
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:285
#define PointerGetDatum(X)
Definition: postgres.h:564
char * pstrdup(const char *in)
Definition: mcxt.c:1165
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:834
#define HEAP_LOCKED_UPGRADED(infomask)
Definition: htup_details.h:238
#define AccessShareLock
Definition: lockdefs.h:36
Datum pgrowlocks(PG_FUNCTION_ARGS)
Definition: pgrowlocks.c:69
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
RangeVar * makeRangeVarFromNameList(List *names)
Definition: namespace.c:2857
#define heap_close(r, l)
Definition: heapam.h:97
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:555
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:289
int natts
Definition: tupdesc.h:73
HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
Definition: execTuples.c:1115
#define HEAP_XMAX_IS_SHR_LOCKED(infomask)
Definition: htup_details.h:248
HeapTupleHeader t_data
Definition: htup.h:67
#define Atnum_tid
Definition: pgrowlocks.c:61
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:291
Relation rel
Definition: pgrowlocks.c:56
PG_MODULE_MAGIC
Definition: pgrowlocks.c:42
#define HeapTupleHeaderGetRawXmax(tup)
Definition: htup_details.h:369
unsigned short uint16
Definition: c.h:264
#define ERROR
Definition: elog.h:43
ItemPointerData t_self
Definition: htup.h:65
static char * buf
Definition: pg_test_fsync.c:65
void aclcheck_error(AclResult aclerr, AclObjectKind objectkind, const char *objectname)
Definition: aclchk.c:3378
AttInMetadata * attinmeta
Definition: funcapi.h:99
HTSU_Result
Definition: snapshot.h:118
#define RelationGetRelationName(relation)
Definition: rel.h:433
List * textToQualifiedNameList(text *textval)
Definition: varlena.c:3071
int BackendXidGetPid(TransactionId xid)
Definition: procarray.c:2389
#define Atnum_modes
Definition: pgrowlocks.c:65
AclResult
Definition: acl.h:170
uintptr_t Datum
Definition: postgres.h:374
#define ACL_SELECT
Definition: parsenodes.h:66
AttInMetadata * TupleDescGetAttInMetadata(TupleDesc tupdesc)
Definition: execTuples.c:1068
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:3529
#define HEAP_KEYS_UPDATED
Definition: htup_details.h:264
HeapTuple heap_getnext(HeapScanDesc scan, ScanDirection direction)
Definition: heapam.c:1781
#define HEAP_XMAX_IS_MULTI
Definition: htup_details.h:194
Relation heap_openrv(const RangeVar *relation, LOCKMODE lockmode)
Definition: heapam.c:1315
Buffer rs_cbuf
Definition: relscan.h:70
#define NULL
Definition: c.h:226
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:109
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:222
HeapScanDesc scan
Definition: pgrowlocks.c:57
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4397
static Datum values[MAXATTR]
Definition: bootstrap.c:162
#define Atnum_xids
Definition: pgrowlocks.c:64
void * user_fctx
Definition: funcapi.h:90
void * palloc(Size size)
Definition: mcxt.c:891
#define PG_GETARG_TEXT_P(n)
Definition: fmgr.h:269
#define BUFFER_LOCK_SHARE
Definition: bufmgr.h:88
Definition: c.h:434
#define PG_FUNCTION_ARGS
Definition: fmgr.h:150
#define Atnum_pids
Definition: pgrowlocks.c:66
int ncolumns
Definition: pgrowlocks.c:58
#define HEAP_XMAX_IS_EXCL_LOCKED(infomask)
Definition: htup_details.h:250
CommandId GetCurrentCommandId(bool used)
Definition: xact.c:686
int GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members, bool from_pgupgrade, bool onlyLock)
Definition: multixact.c:1202
#define elog
Definition: elog.h:219
#define HEAP_XMAX_IS_KEYSHR_LOCKED(infomask)
Definition: htup_details.h:252
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:222
HeapScanDesc heap_beginscan(Relation relation, Snapshot snapshot, int nkeys, ScanKey key)
Definition: heapam.c:1394
Datum tidout(PG_FUNCTION_ARGS)
Definition: tid.c:105
#define RelationGetRelid(relation)
Definition: rel.h:413
#define Atnum_xmax
Definition: pgrowlocks.c:62
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:309
#define Atnum_ismulti
Definition: pgrowlocks.c:63
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:287