PostgreSQL Source Code: src/backend/utils/adt/lockfuncs.c Source File

PostgreSQL Source Code git master
lockfuncs.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * lockfuncs.c
4 * Functions for SQL access to various lock-manager capabilities.
5 *
6 * Copyright (c) 2002-2025, PostgreSQL Global Development Group
7 *
8 * IDENTIFICATION
9 * src/backend/utils/adt/lockfuncs.c
10 *
11 *-------------------------------------------------------------------------
12 */
13#include "postgres.h"
14
15#include "access/htup_details.h"
16#include "funcapi.h"
17#include "miscadmin.h"
18#include "storage/predicate_internals.h"
19#include "utils/array.h"
20#include "utils/builtins.h"
21
22
23/*
24 * This must match enum LockTagType! Also, be sure to document any changes
25 * in the docs for the pg_locks view and update the WaitEventLOCK section in
26 * src/backend/utils/activity/wait_event_names.txt.
27 */
28 const char *const LockTagTypeNames[] = {
29 "relation",
30 "extend",
31 "frozenid",
32 "page",
33 "tuple",
34 "transactionid",
35 "virtualxid",
36 "spectoken",
37 "object",
38 "userlock",
39 "advisory",
40 "applytransaction"
41};
42
43 StaticAssertDecl(lengthof(LockTagTypeNames) == (LOCKTAG_LAST_TYPE + 1),
44 "array length mismatch");
45
46/* This must match enum PredicateLockTargetType (predicate_internals.h) */
47 static const char *const PredicateLockTagTypeNames[] = {
48 "relation",
49 "page",
50 "tuple"
51};
52
53 StaticAssertDecl(lengthof(PredicateLockTagTypeNames) == (PREDLOCKTAG_TUPLE + 1),
54 "array length mismatch");
55
56/* Working status for pg_lock_status */
57 typedef struct
58{
59 LockData *lockData; /* state data from lmgr */
60 int currIdx; /* current PROCLOCK index */
61 PredicateLockData *predLockData; /* state data for pred locks */
62 int predLockIdx; /* current index for pred lock */
63} PG_Lock_Status;
64
65/* Number of columns in pg_locks output */
66 #define NUM_LOCK_STATUS_COLUMNS 16
67
68/*
69 * VXIDGetDatum - Construct a text representation of a VXID
70 *
71 * This is currently only used in pg_lock_status, so we put it here.
72 */
73static Datum
74 VXIDGetDatum(ProcNumber procNumber, LocalTransactionId lxid)
75{
76 /*
77 * The representation is "<procNumber>/<lxid>", decimal and unsigned
78 * decimal respectively. Note that elog.c also knows how to format a
79 * vxid.
80 */
81 char vxidstr[32];
82
83 snprintf(vxidstr, sizeof(vxidstr), "%d/%u", procNumber, lxid);
84
85 return CStringGetTextDatum(vxidstr);
86}
87
88
89/*
90 * pg_lock_status - produce a view with one row per held or awaited lock mode
91 */
92Datum
93 pg_lock_status(PG_FUNCTION_ARGS)
94{
95 FuncCallContext *funcctx;
96 PG_Lock_Status *mystatus;
97 LockData *lockData;
98 PredicateLockData *predLockData;
99
100 if (SRF_IS_FIRSTCALL())
101 {
102 TupleDesc tupdesc;
103 MemoryContext oldcontext;
104
105 /* create a function context for cross-call persistence */
106 funcctx = SRF_FIRSTCALL_INIT();
107
108 /*
109 * switch to memory context appropriate for multiple function calls
110 */
111 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
112
113 /* build tupdesc for result tuples */
114 /* this had better match function's declaration in pg_proc.h */
115 tupdesc = CreateTemplateTupleDesc(NUM_LOCK_STATUS_COLUMNS);
116 TupleDescInitEntry(tupdesc, (AttrNumber) 1, "locktype",
117 TEXTOID, -1, 0);
118 TupleDescInitEntry(tupdesc, (AttrNumber) 2, "database",
119 OIDOID, -1, 0);
120 TupleDescInitEntry(tupdesc, (AttrNumber) 3, "relation",
121 OIDOID, -1, 0);
122 TupleDescInitEntry(tupdesc, (AttrNumber) 4, "page",
123 INT4OID, -1, 0);
124 TupleDescInitEntry(tupdesc, (AttrNumber) 5, "tuple",
125 INT2OID, -1, 0);
126 TupleDescInitEntry(tupdesc, (AttrNumber) 6, "virtualxid",
127 TEXTOID, -1, 0);
128 TupleDescInitEntry(tupdesc, (AttrNumber) 7, "transactionid",
129 XIDOID, -1, 0);
130 TupleDescInitEntry(tupdesc, (AttrNumber) 8, "classid",
131 OIDOID, -1, 0);
132 TupleDescInitEntry(tupdesc, (AttrNumber) 9, "objid",
133 OIDOID, -1, 0);
134 TupleDescInitEntry(tupdesc, (AttrNumber) 10, "objsubid",
135 INT2OID, -1, 0);
136 TupleDescInitEntry(tupdesc, (AttrNumber) 11, "virtualtransaction",
137 TEXTOID, -1, 0);
138 TupleDescInitEntry(tupdesc, (AttrNumber) 12, "pid",
139 INT4OID, -1, 0);
140 TupleDescInitEntry(tupdesc, (AttrNumber) 13, "mode",
141 TEXTOID, -1, 0);
142 TupleDescInitEntry(tupdesc, (AttrNumber) 14, "granted",
143 BOOLOID, -1, 0);
144 TupleDescInitEntry(tupdesc, (AttrNumber) 15, "fastpath",
145 BOOLOID, -1, 0);
146 TupleDescInitEntry(tupdesc, (AttrNumber) 16, "waitstart",
147 TIMESTAMPTZOID, -1, 0);
148
149 funcctx->tuple_desc = BlessTupleDesc(tupdesc);
150
151 /*
152 * Collect all the locking information that we will format and send
153 * out as a result set.
154 */
155 mystatus = (PG_Lock_Status *) palloc(sizeof(PG_Lock_Status));
156 funcctx->user_fctx = mystatus;
157
158 mystatus->lockData = GetLockStatusData();
159 mystatus->currIdx = 0;
160 mystatus->predLockData = GetPredicateLockStatusData();
161 mystatus->predLockIdx = 0;
162
163 MemoryContextSwitchTo(oldcontext);
164 }
165
166 funcctx = SRF_PERCALL_SETUP();
167 mystatus = (PG_Lock_Status *) funcctx->user_fctx;
168 lockData = mystatus->lockData;
169
170 while (mystatus->currIdx < lockData->nelements)
171 {
172 bool granted;
173 LOCKMODE mode = 0;
174 const char *locktypename;
175 char tnbuf[32];
176 Datum values[NUM_LOCK_STATUS_COLUMNS] = {0};
177 bool nulls[NUM_LOCK_STATUS_COLUMNS] = {0};
178 HeapTuple tuple;
179 Datum result;
180 LockInstanceData *instance;
181
182 instance = &(lockData->locks[mystatus->currIdx]);
183
184 /*
185 * Look to see if there are any held lock modes in this PROCLOCK. If
186 * so, report, and destructively modify lockData so we don't report
187 * again.
188 */
189 granted = false;
190 if (instance->holdMask)
191 {
192 for (mode = 0; mode < MAX_LOCKMODES; mode++)
193 {
194 if (instance->holdMask & LOCKBIT_ON(mode))
195 {
196 granted = true;
197 instance->holdMask &= LOCKBIT_OFF(mode);
198 break;
199 }
200 }
201 }
202
203 /*
204 * If no (more) held modes to report, see if PROC is waiting for a
205 * lock on this lock.
206 */
207 if (!granted)
208 {
209 if (instance->waitLockMode != NoLock)
210 {
211 /* Yes, so report it with proper mode */
212 mode = instance->waitLockMode;
213
214 /*
215 * We are now done with this PROCLOCK, so advance pointer to
216 * continue with next one on next call.
217 */
218 mystatus->currIdx++;
219 }
220 else
221 {
222 /*
223 * Okay, we've displayed all the locks associated with this
224 * PROCLOCK, proceed to the next one.
225 */
226 mystatus->currIdx++;
227 continue;
228 }
229 }
230
231 /*
232 * Form tuple with appropriate data.
233 */
234
235 if (instance->locktag.locktag_type <= LOCKTAG_LAST_TYPE)
236 locktypename = LockTagTypeNames[instance->locktag.locktag_type];
237 else
238 {
239 snprintf(tnbuf, sizeof(tnbuf), "unknown %d",
240 (int) instance->locktag.locktag_type);
241 locktypename = tnbuf;
242 }
243 values[0] = CStringGetTextDatum(locktypename);
244
245 switch ((LockTagType) instance->locktag.locktag_type)
246 {
247 case LOCKTAG_RELATION:
248 case LOCKTAG_RELATION_EXTEND:
249 values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
250 values[2] = ObjectIdGetDatum(instance->locktag.locktag_field2);
251 nulls[3] = true;
252 nulls[4] = true;
253 nulls[5] = true;
254 nulls[6] = true;
255 nulls[7] = true;
256 nulls[8] = true;
257 nulls[9] = true;
258 break;
259 case LOCKTAG_DATABASE_FROZEN_IDS:
260 values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
261 nulls[2] = true;
262 nulls[3] = true;
263 nulls[4] = true;
264 nulls[5] = true;
265 nulls[6] = true;
266 nulls[7] = true;
267 nulls[8] = true;
268 nulls[9] = true;
269 break;
270 case LOCKTAG_PAGE:
271 values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
272 values[2] = ObjectIdGetDatum(instance->locktag.locktag_field2);
273 values[3] = UInt32GetDatum(instance->locktag.locktag_field3);
274 nulls[4] = true;
275 nulls[5] = true;
276 nulls[6] = true;
277 nulls[7] = true;
278 nulls[8] = true;
279 nulls[9] = true;
280 break;
281 case LOCKTAG_TUPLE:
282 values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
283 values[2] = ObjectIdGetDatum(instance->locktag.locktag_field2);
284 values[3] = UInt32GetDatum(instance->locktag.locktag_field3);
285 values[4] = UInt16GetDatum(instance->locktag.locktag_field4);
286 nulls[5] = true;
287 nulls[6] = true;
288 nulls[7] = true;
289 nulls[8] = true;
290 nulls[9] = true;
291 break;
292 case LOCKTAG_TRANSACTION:
293 values[6] =
294 TransactionIdGetDatum(instance->locktag.locktag_field1);
295 nulls[1] = true;
296 nulls[2] = true;
297 nulls[3] = true;
298 nulls[4] = true;
299 nulls[5] = true;
300 nulls[7] = true;
301 nulls[8] = true;
302 nulls[9] = true;
303 break;
304 case LOCKTAG_VIRTUALTRANSACTION:
305 values[5] = VXIDGetDatum(instance->locktag.locktag_field1,
306 instance->locktag.locktag_field2);
307 nulls[1] = true;
308 nulls[2] = true;
309 nulls[3] = true;
310 nulls[4] = true;
311 nulls[6] = true;
312 nulls[7] = true;
313 nulls[8] = true;
314 nulls[9] = true;
315 break;
316 case LOCKTAG_SPECULATIVE_TOKEN:
317 values[6] =
318 TransactionIdGetDatum(instance->locktag.locktag_field1);
319 values[8] = ObjectIdGetDatum(instance->locktag.locktag_field2);
320 nulls[1] = true;
321 nulls[2] = true;
322 nulls[3] = true;
323 nulls[4] = true;
324 nulls[5] = true;
325 nulls[7] = true;
326 nulls[9] = true;
327 break;
328 case LOCKTAG_APPLY_TRANSACTION:
329 values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
330 values[8] = ObjectIdGetDatum(instance->locktag.locktag_field2);
331 values[6] = ObjectIdGetDatum(instance->locktag.locktag_field3);
332 values[9] = Int16GetDatum(instance->locktag.locktag_field4);
333 nulls[2] = true;
334 nulls[3] = true;
335 nulls[4] = true;
336 nulls[5] = true;
337 nulls[7] = true;
338 break;
339 case LOCKTAG_OBJECT:
340 case LOCKTAG_USERLOCK:
341 case LOCKTAG_ADVISORY:
342 default: /* treat unknown locktags like OBJECT */
343 values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
344 values[7] = ObjectIdGetDatum(instance->locktag.locktag_field2);
345 values[8] = ObjectIdGetDatum(instance->locktag.locktag_field3);
346 values[9] = Int16GetDatum(instance->locktag.locktag_field4);
347 nulls[2] = true;
348 nulls[3] = true;
349 nulls[4] = true;
350 nulls[5] = true;
351 nulls[6] = true;
352 break;
353 }
354
355 values[10] = VXIDGetDatum(instance->vxid.procNumber, instance->vxid.localTransactionId);
356 if (instance->pid != 0)
357 values[11] = Int32GetDatum(instance->pid);
358 else
359 nulls[11] = true;
360 values[12] = CStringGetTextDatum(GetLockmodeName(instance->locktag.locktag_lockmethodid, mode));
361 values[13] = BoolGetDatum(granted);
362 values[14] = BoolGetDatum(instance->fastpath);
363 if (!granted && instance->waitStart != 0)
364 values[15] = TimestampTzGetDatum(instance->waitStart);
365 else
366 nulls[15] = true;
367
368 tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
369 result = HeapTupleGetDatum(tuple);
370 SRF_RETURN_NEXT(funcctx, result);
371 }
372
373 /*
374 * Have returned all regular locks. Now start on the SIREAD predicate
375 * locks.
376 */
377 predLockData = mystatus->predLockData;
378 if (mystatus->predLockIdx < predLockData->nelements)
379 {
380 PredicateLockTargetType lockType;
381
382 PREDICATELOCKTARGETTAG *predTag = &(predLockData->locktags[mystatus->predLockIdx]);
383 SERIALIZABLEXACT *xact = &(predLockData->xacts[mystatus->predLockIdx]);
384 Datum values[NUM_LOCK_STATUS_COLUMNS] = {0};
385 bool nulls[NUM_LOCK_STATUS_COLUMNS] = {0};
386 HeapTuple tuple;
387 Datum result;
388
389 mystatus->predLockIdx++;
390
391 /*
392 * Form tuple with appropriate data.
393 */
394
395 /* lock type */
396 lockType = GET_PREDICATELOCKTARGETTAG_TYPE(*predTag);
397
398 values[0] = CStringGetTextDatum(PredicateLockTagTypeNames[lockType]);
399
400 /* lock target */
401 values[1] = ObjectIdGetDatum(GET_PREDICATELOCKTARGETTAG_DB(*predTag));
402 values[2] = ObjectIdGetDatum(GET_PREDICATELOCKTARGETTAG_RELATION(*predTag));
403 if (lockType == PREDLOCKTAG_TUPLE)
404 values[4] = UInt16GetDatum(GET_PREDICATELOCKTARGETTAG_OFFSET(*predTag));
405 else
406 nulls[4] = true;
407 if ((lockType == PREDLOCKTAG_TUPLE) ||
408 (lockType == PREDLOCKTAG_PAGE))
409 values[3] = UInt32GetDatum(GET_PREDICATELOCKTARGETTAG_PAGE(*predTag));
410 else
411 nulls[3] = true;
412
413 /* these fields are targets for other types of locks */
414 nulls[5] = true; /* virtualxid */
415 nulls[6] = true; /* transactionid */
416 nulls[7] = true; /* classid */
417 nulls[8] = true; /* objid */
418 nulls[9] = true; /* objsubid */
419
420 /* lock holder */
421 values[10] = VXIDGetDatum(xact->vxid.procNumber,
422 xact->vxid.localTransactionId);
423 if (xact->pid != 0)
424 values[11] = Int32GetDatum(xact->pid);
425 else
426 nulls[11] = true;
427
428 /*
429 * Lock mode. Currently all predicate locks are SIReadLocks, which are
430 * always held (never waiting) and have no fast path
431 */
432 values[12] = CStringGetTextDatum("SIReadLock");
433 values[13] = BoolGetDatum(true);
434 values[14] = BoolGetDatum(false);
435 nulls[15] = true;
436
437 tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
438 result = HeapTupleGetDatum(tuple);
439 SRF_RETURN_NEXT(funcctx, result);
440 }
441
442 SRF_RETURN_DONE(funcctx);
443}
444
445
446/*
447 * pg_blocking_pids - produce an array of the PIDs blocking given PID
448 *
449 * The reported PIDs are those that hold a lock conflicting with blocked_pid's
450 * current request (hard block), or are requesting such a lock and are ahead
451 * of blocked_pid in the lock's wait queue (soft block).
452 *
453 * In parallel-query cases, we report all PIDs blocking any member of the
454 * given PID's lock group, and the reported PIDs are those of the blocking
455 * PIDs' lock group leaders. This allows callers to compare the result to
456 * lists of clients' pg_backend_pid() results even during a parallel query.
457 *
458 * Parallel query makes it possible for there to be duplicate PIDs in the
459 * result (either because multiple waiters are blocked by same PID, or
460 * because multiple blockers have same group leader PID). We do not bother
461 * to eliminate such duplicates from the result.
462 *
463 * We need not consider predicate locks here, since those don't block anything.
464 */
465Datum
466 pg_blocking_pids(PG_FUNCTION_ARGS)
467{
468 int blocked_pid = PG_GETARG_INT32(0);
469 Datum *arrayelems;
470 int narrayelems;
471 BlockedProcsData *lockData; /* state data from lmgr */
472 int i,
473 j;
474
475 /* Collect a snapshot of lock manager state */
476 lockData = GetBlockerStatusData(blocked_pid);
477
478 /* We can't need more output entries than there are reported PROCLOCKs */
479 arrayelems = (Datum *) palloc(lockData->nlocks * sizeof(Datum));
480 narrayelems = 0;
481
482 /* For each blocked proc in the lock group ... */
483 for (i = 0; i < lockData->nprocs; i++)
484 {
485 BlockedProcData *bproc = &lockData->procs[i];
486 LockInstanceData *instances = &lockData->locks[bproc->first_lock];
487 int *preceding_waiters = &lockData->waiter_pids[bproc->first_waiter];
488 LockInstanceData *blocked_instance;
489 LockMethod lockMethodTable;
490 int conflictMask;
491
492 /*
493 * Locate the blocked proc's own entry in the LockInstanceData array.
494 * There should be exactly one matching entry.
495 */
496 blocked_instance = NULL;
497 for (j = 0; j < bproc->num_locks; j++)
498 {
499 LockInstanceData *instance = &(instances[j]);
500
501 if (instance->pid == bproc->pid)
502 {
503 Assert(blocked_instance == NULL);
504 blocked_instance = instance;
505 }
506 }
507 Assert(blocked_instance != NULL);
508
509 lockMethodTable = GetLockTagsMethodTable(&(blocked_instance->locktag));
510 conflictMask = lockMethodTable->conflictTab[blocked_instance->waitLockMode];
511
512 /* Now scan the PROCLOCK data for conflicting procs */
513 for (j = 0; j < bproc->num_locks; j++)
514 {
515 LockInstanceData *instance = &(instances[j]);
516
517 /* A proc never blocks itself, so ignore that entry */
518 if (instance == blocked_instance)
519 continue;
520 /* Members of same lock group never block each other, either */
521 if (instance->leaderPid == blocked_instance->leaderPid)
522 continue;
523
524 if (conflictMask & instance->holdMask)
525 {
526 /* hard block: blocked by lock already held by this entry */
527 }
528 else if (instance->waitLockMode != NoLock &&
529 (conflictMask & LOCKBIT_ON(instance->waitLockMode)))
530 {
531 /* conflict in lock requests; who's in front in wait queue? */
532 bool ahead = false;
533 int k;
534
535 for (k = 0; k < bproc->num_waiters; k++)
536 {
537 if (preceding_waiters[k] == instance->pid)
538 {
539 /* soft block: this entry is ahead of blocked proc */
540 ahead = true;
541 break;
542 }
543 }
544 if (!ahead)
545 continue; /* not blocked by this entry */
546 }
547 else
548 {
549 /* not blocked by this entry */
550 continue;
551 }
552
553 /* blocked by this entry, so emit a record */
554 arrayelems[narrayelems++] = Int32GetDatum(instance->leaderPid);
555 }
556 }
557
558 /* Assert we didn't overrun arrayelems[] */
559 Assert(narrayelems <= lockData->nlocks);
560
561 PG_RETURN_ARRAYTYPE_P(construct_array_builtin(arrayelems, narrayelems, INT4OID));
562}
563
564
565/*
566 * pg_safe_snapshot_blocking_pids - produce an array of the PIDs blocking
567 * given PID from getting a safe snapshot
568 *
569 * XXX this does not consider parallel-query cases; not clear how big a
570 * problem that is in practice
571 */
572Datum
573 pg_safe_snapshot_blocking_pids(PG_FUNCTION_ARGS)
574{
575 int blocked_pid = PG_GETARG_INT32(0);
576 int *blockers;
577 int num_blockers;
578 Datum *blocker_datums;
579
580 /* A buffer big enough for any possible blocker list without truncation */
581 blockers = (int *) palloc(MaxBackends * sizeof(int));
582
583 /* Collect a snapshot of processes waited for by GetSafeSnapshot */
584 num_blockers =
585 GetSafeSnapshotBlockingPids(blocked_pid, blockers, MaxBackends);
586
587 /* Convert int array to Datum array */
588 if (num_blockers > 0)
589 {
590 int i;
591
592 blocker_datums = (Datum *) palloc(num_blockers * sizeof(Datum));
593 for (i = 0; i < num_blockers; ++i)
594 blocker_datums[i] = Int32GetDatum(blockers[i]);
595 }
596 else
597 blocker_datums = NULL;
598
599 PG_RETURN_ARRAYTYPE_P(construct_array_builtin(blocker_datums, num_blockers, INT4OID));
600}
601
602
603/*
604 * Functions for manipulating advisory locks
605 *
606 * We make use of the locktag fields as follows:
607 *
608 * field1: MyDatabaseId ... ensures locks are local to each database
609 * field2: first of 2 int4 keys, or high-order half of an int8 key
610 * field3: second of 2 int4 keys, or low-order half of an int8 key
611 * field4: 1 if using an int8 key, 2 if using 2 int4 keys
612 */
613 #define SET_LOCKTAG_INT64(tag, key64) \
614 SET_LOCKTAG_ADVISORY(tag, \
615 MyDatabaseId, \
616 (uint32) ((key64) >> 32), \
617 (uint32) (key64), \
618 1)
619 #define SET_LOCKTAG_INT32(tag, key1, key2) \
620 SET_LOCKTAG_ADVISORY(tag, MyDatabaseId, key1, key2, 2)
621
622/*
623 * pg_advisory_lock(int8) - acquire exclusive lock on an int8 key
624 */
625Datum
626 pg_advisory_lock_int8(PG_FUNCTION_ARGS)
627{
628 int64 key = PG_GETARG_INT64(0);
629 LOCKTAG tag;
630
631 SET_LOCKTAG_INT64(tag, key);
632
633 (void) LockAcquire(&tag, ExclusiveLock, true, false);
634
635 PG_RETURN_VOID();
636}
637
638/*
639 * pg_advisory_xact_lock(int8) - acquire xact scoped
640 * exclusive lock on an int8 key
641 */
642Datum
643 pg_advisory_xact_lock_int8(PG_FUNCTION_ARGS)
644{
645 int64 key = PG_GETARG_INT64(0);
646 LOCKTAG tag;
647
648 SET_LOCKTAG_INT64(tag, key);
649
650 (void) LockAcquire(&tag, ExclusiveLock, false, false);
651
652 PG_RETURN_VOID();
653}
654
655/*
656 * pg_advisory_lock_shared(int8) - acquire share lock on an int8 key
657 */
658Datum
659 pg_advisory_lock_shared_int8(PG_FUNCTION_ARGS)
660{
661 int64 key = PG_GETARG_INT64(0);
662 LOCKTAG tag;
663
664 SET_LOCKTAG_INT64(tag, key);
665
666 (void) LockAcquire(&tag, ShareLock, true, false);
667
668 PG_RETURN_VOID();
669}
670
671/*
672 * pg_advisory_xact_lock_shared(int8) - acquire xact scoped
673 * share lock on an int8 key
674 */
675Datum
676 pg_advisory_xact_lock_shared_int8(PG_FUNCTION_ARGS)
677{
678 int64 key = PG_GETARG_INT64(0);
679 LOCKTAG tag;
680
681 SET_LOCKTAG_INT64(tag, key);
682
683 (void) LockAcquire(&tag, ShareLock, false, false);
684
685 PG_RETURN_VOID();
686}
687
688/*
689 * pg_try_advisory_lock(int8) - acquire exclusive lock on an int8 key, no wait
690 *
691 * Returns true if successful, false if lock not available
692 */
693Datum
694 pg_try_advisory_lock_int8(PG_FUNCTION_ARGS)
695{
696 int64 key = PG_GETARG_INT64(0);
697 LOCKTAG tag;
698 LockAcquireResult res;
699
700 SET_LOCKTAG_INT64(tag, key);
701
702 res = LockAcquire(&tag, ExclusiveLock, true, true);
703
704 PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
705}
706
707/*
708 * pg_try_advisory_xact_lock(int8) - acquire xact scoped
709 * exclusive lock on an int8 key, no wait
710 *
711 * Returns true if successful, false if lock not available
712 */
713Datum
714 pg_try_advisory_xact_lock_int8(PG_FUNCTION_ARGS)
715{
716 int64 key = PG_GETARG_INT64(0);
717 LOCKTAG tag;
718 LockAcquireResult res;
719
720 SET_LOCKTAG_INT64(tag, key);
721
722 res = LockAcquire(&tag, ExclusiveLock, false, true);
723
724 PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
725}
726
727/*
728 * pg_try_advisory_lock_shared(int8) - acquire share lock on an int8 key, no wait
729 *
730 * Returns true if successful, false if lock not available
731 */
732Datum
733 pg_try_advisory_lock_shared_int8(PG_FUNCTION_ARGS)
734{
735 int64 key = PG_GETARG_INT64(0);
736 LOCKTAG tag;
737 LockAcquireResult res;
738
739 SET_LOCKTAG_INT64(tag, key);
740
741 res = LockAcquire(&tag, ShareLock, true, true);
742
743 PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
744}
745
746/*
747 * pg_try_advisory_xact_lock_shared(int8) - acquire xact scoped
748 * share lock on an int8 key, no wait
749 *
750 * Returns true if successful, false if lock not available
751 */
752Datum
753 pg_try_advisory_xact_lock_shared_int8(PG_FUNCTION_ARGS)
754{
755 int64 key = PG_GETARG_INT64(0);
756 LOCKTAG tag;
757 LockAcquireResult res;
758
759 SET_LOCKTAG_INT64(tag, key);
760
761 res = LockAcquire(&tag, ShareLock, false, true);
762
763 PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
764}
765
766/*
767 * pg_advisory_unlock(int8) - release exclusive lock on an int8 key
768 *
769 * Returns true if successful, false if lock was not held
770*/
771Datum
772 pg_advisory_unlock_int8(PG_FUNCTION_ARGS)
773{
774 int64 key = PG_GETARG_INT64(0);
775 LOCKTAG tag;
776 bool res;
777
778 SET_LOCKTAG_INT64(tag, key);
779
780 res = LockRelease(&tag, ExclusiveLock, true);
781
782 PG_RETURN_BOOL(res);
783}
784
785/*
786 * pg_advisory_unlock_shared(int8) - release share lock on an int8 key
787 *
788 * Returns true if successful, false if lock was not held
789 */
790Datum
791 pg_advisory_unlock_shared_int8(PG_FUNCTION_ARGS)
792{
793 int64 key = PG_GETARG_INT64(0);
794 LOCKTAG tag;
795 bool res;
796
797 SET_LOCKTAG_INT64(tag, key);
798
799 res = LockRelease(&tag, ShareLock, true);
800
801 PG_RETURN_BOOL(res);
802}
803
804/*
805 * pg_advisory_lock(int4, int4) - acquire exclusive lock on 2 int4 keys
806 */
807Datum
808 pg_advisory_lock_int4(PG_FUNCTION_ARGS)
809{
810 int32 key1 = PG_GETARG_INT32(0);
811 int32 key2 = PG_GETARG_INT32(1);
812 LOCKTAG tag;
813
814 SET_LOCKTAG_INT32(tag, key1, key2);
815
816 (void) LockAcquire(&tag, ExclusiveLock, true, false);
817
818 PG_RETURN_VOID();
819}
820
821/*
822 * pg_advisory_xact_lock(int4, int4) - acquire xact scoped
823 * exclusive lock on 2 int4 keys
824 */
825Datum
826 pg_advisory_xact_lock_int4(PG_FUNCTION_ARGS)
827{
828 int32 key1 = PG_GETARG_INT32(0);
829 int32 key2 = PG_GETARG_INT32(1);
830 LOCKTAG tag;
831
832 SET_LOCKTAG_INT32(tag, key1, key2);
833
834 (void) LockAcquire(&tag, ExclusiveLock, false, false);
835
836 PG_RETURN_VOID();
837}
838
839/*
840 * pg_advisory_lock_shared(int4, int4) - acquire share lock on 2 int4 keys
841 */
842Datum
843 pg_advisory_lock_shared_int4(PG_FUNCTION_ARGS)
844{
845 int32 key1 = PG_GETARG_INT32(0);
846 int32 key2 = PG_GETARG_INT32(1);
847 LOCKTAG tag;
848
849 SET_LOCKTAG_INT32(tag, key1, key2);
850
851 (void) LockAcquire(&tag, ShareLock, true, false);
852
853 PG_RETURN_VOID();
854}
855
856/*
857 * pg_advisory_xact_lock_shared(int4, int4) - acquire xact scoped
858 * share lock on 2 int4 keys
859 */
860Datum
861 pg_advisory_xact_lock_shared_int4(PG_FUNCTION_ARGS)
862{
863 int32 key1 = PG_GETARG_INT32(0);
864 int32 key2 = PG_GETARG_INT32(1);
865 LOCKTAG tag;
866
867 SET_LOCKTAG_INT32(tag, key1, key2);
868
869 (void) LockAcquire(&tag, ShareLock, false, false);
870
871 PG_RETURN_VOID();
872}
873
874/*
875 * pg_try_advisory_lock(int4, int4) - acquire exclusive lock on 2 int4 keys, no wait
876 *
877 * Returns true if successful, false if lock not available
878 */
879Datum
880 pg_try_advisory_lock_int4(PG_FUNCTION_ARGS)
881{
882 int32 key1 = PG_GETARG_INT32(0);
883 int32 key2 = PG_GETARG_INT32(1);
884 LOCKTAG tag;
885 LockAcquireResult res;
886
887 SET_LOCKTAG_INT32(tag, key1, key2);
888
889 res = LockAcquire(&tag, ExclusiveLock, true, true);
890
891 PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
892}
893
894/*
895 * pg_try_advisory_xact_lock(int4, int4) - acquire xact scoped
896 * exclusive lock on 2 int4 keys, no wait
897 *
898 * Returns true if successful, false if lock not available
899 */
900Datum
901 pg_try_advisory_xact_lock_int4(PG_FUNCTION_ARGS)
902{
903 int32 key1 = PG_GETARG_INT32(0);
904 int32 key2 = PG_GETARG_INT32(1);
905 LOCKTAG tag;
906 LockAcquireResult res;
907
908 SET_LOCKTAG_INT32(tag, key1, key2);
909
910 res = LockAcquire(&tag, ExclusiveLock, false, true);
911
912 PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
913}
914
915/*
916 * pg_try_advisory_lock_shared(int4, int4) - acquire share lock on 2 int4 keys, no wait
917 *
918 * Returns true if successful, false if lock not available
919 */
920Datum
921 pg_try_advisory_lock_shared_int4(PG_FUNCTION_ARGS)
922{
923 int32 key1 = PG_GETARG_INT32(0);
924 int32 key2 = PG_GETARG_INT32(1);
925 LOCKTAG tag;
926 LockAcquireResult res;
927
928 SET_LOCKTAG_INT32(tag, key1, key2);
929
930 res = LockAcquire(&tag, ShareLock, true, true);
931
932 PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
933}
934
935/*
936 * pg_try_advisory_xact_lock_shared(int4, int4) - acquire xact scoped
937 * share lock on 2 int4 keys, no wait
938 *
939 * Returns true if successful, false if lock not available
940 */
941Datum
942 pg_try_advisory_xact_lock_shared_int4(PG_FUNCTION_ARGS)
943{
944 int32 key1 = PG_GETARG_INT32(0);
945 int32 key2 = PG_GETARG_INT32(1);
946 LOCKTAG tag;
947 LockAcquireResult res;
948
949 SET_LOCKTAG_INT32(tag, key1, key2);
950
951 res = LockAcquire(&tag, ShareLock, false, true);
952
953 PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
954}
955
956/*
957 * pg_advisory_unlock(int4, int4) - release exclusive lock on 2 int4 keys
958 *
959 * Returns true if successful, false if lock was not held
960*/
961Datum
962 pg_advisory_unlock_int4(PG_FUNCTION_ARGS)
963{
964 int32 key1 = PG_GETARG_INT32(0);
965 int32 key2 = PG_GETARG_INT32(1);
966 LOCKTAG tag;
967 bool res;
968
969 SET_LOCKTAG_INT32(tag, key1, key2);
970
971 res = LockRelease(&tag, ExclusiveLock, true);
972
973 PG_RETURN_BOOL(res);
974}
975
976/*
977 * pg_advisory_unlock_shared(int4, int4) - release share lock on 2 int4 keys
978 *
979 * Returns true if successful, false if lock was not held
980 */
981Datum
982 pg_advisory_unlock_shared_int4(PG_FUNCTION_ARGS)
983{
984 int32 key1 = PG_GETARG_INT32(0);
985 int32 key2 = PG_GETARG_INT32(1);
986 LOCKTAG tag;
987 bool res;
988
989 SET_LOCKTAG_INT32(tag, key1, key2);
990
991 res = LockRelease(&tag, ShareLock, true);
992
993 PG_RETURN_BOOL(res);
994}
995
996/*
997 * pg_advisory_unlock_all() - release all advisory locks
998 */
999Datum
1000 pg_advisory_unlock_all(PG_FUNCTION_ARGS)
1001{
1002 LockReleaseSession(USER_LOCKMETHOD);
1003
1004 PG_RETURN_VOID();
1005}
#define PG_RETURN_ARRAYTYPE_P(x)
Definition: array.h:265
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3381
int16 AttrNumber
Definition: attnum.h:21
static Datum values[MAXATTR]
Definition: bootstrap.c:153
#define CStringGetTextDatum(s)
Definition: builtins.h:97
int64_t int64
Definition: c.h:535
int32_t int32
Definition: c.h:534
#define lengthof(array)
Definition: c.h:787
uint32 LocalTransactionId
Definition: c.h:659
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2260
#define PG_RETURN_VOID()
Definition: fmgr.h:349
#define PG_GETARG_INT64(n)
Definition: fmgr.h:283
#define PG_GETARG_INT32(n)
Definition: fmgr.h:269
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:304
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:308
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:310
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:306
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
Definition: funcapi.h:230
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:328
int MaxBackends
Definition: globals.c:146
Assert(PointerIsAligned(start, uint64))
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1117
j
int j
Definition: isn.c:78
i
int i
Definition: isn.c:77
LockAcquireResult LockAcquire(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait)
Definition: lock.c:809
bool LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
Definition: lock.c:2102
BlockedProcsData * GetBlockerStatusData(int blocked_pid)
Definition: lock.c:3998
const char * GetLockmodeName(LOCKMETHODID lockmethodid, LOCKMODE mode)
Definition: lock.c:4255
void LockReleaseSession(LOCKMETHODID lockmethodid)
Definition: lock.c:2581
LockData * GetLockStatusData(void)
Definition: lock.c:3795
LockMethod GetLockTagsMethodTable(const LOCKTAG *locktag)
Definition: lock.c:539
LockTagType
Definition: lock.h:138
@ LOCKTAG_OBJECT
Definition: lock.h:147
@ LOCKTAG_RELATION_EXTEND
Definition: lock.h:140
@ LOCKTAG_RELATION
Definition: lock.h:139
@ LOCKTAG_TUPLE
Definition: lock.h:143
@ LOCKTAG_SPECULATIVE_TOKEN
Definition: lock.h:146
@ LOCKTAG_APPLY_TRANSACTION
Definition: lock.h:150
@ LOCKTAG_USERLOCK
Definition: lock.h:148
@ LOCKTAG_DATABASE_FROZEN_IDS
Definition: lock.h:141
@ LOCKTAG_VIRTUALTRANSACTION
Definition: lock.h:145
@ LOCKTAG_TRANSACTION
Definition: lock.h:144
@ LOCKTAG_PAGE
Definition: lock.h:142
@ LOCKTAG_ADVISORY
Definition: lock.h:149
#define USER_LOCKMETHOD
Definition: lock.h:128
#define LOCKBIT_OFF(lockmode)
Definition: lock.h:87
#define LOCKTAG_LAST_TYPE
Definition: lock.h:154
#define MAX_LOCKMODES
Definition: lock.h:84
#define LOCKBIT_ON(lockmode)
Definition: lock.h:86
LockAcquireResult
Definition: lock.h:502
@ LOCKACQUIRE_NOT_AVAIL
Definition: lock.h:503
int LOCKMODE
Definition: lockdefs.h:26
#define NoLock
Definition: lockdefs.h:34
#define ExclusiveLock
Definition: lockdefs.h:42
#define ShareLock
Definition: lockdefs.h:40
Datum pg_advisory_lock_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:808
#define SET_LOCKTAG_INT64(tag, key64)
Definition: lockfuncs.c:613
Datum pg_try_advisory_xact_lock_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:901
Datum pg_advisory_unlock_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:772
Datum pg_advisory_lock_shared_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:843
Datum pg_safe_snapshot_blocking_pids(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:573
Datum pg_advisory_lock_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:626
Datum pg_try_advisory_xact_lock_shared_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:753
Datum pg_advisory_xact_lock_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:643
Datum pg_try_advisory_lock_shared_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:921
static Datum VXIDGetDatum(ProcNumber procNumber, LocalTransactionId lxid)
Definition: lockfuncs.c:74
Datum pg_try_advisory_lock_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:880
#define SET_LOCKTAG_INT32(tag, key1, key2)
Definition: lockfuncs.c:619
#define NUM_LOCK_STATUS_COLUMNS
Definition: lockfuncs.c:66
Datum pg_advisory_unlock_shared_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:982
Datum pg_advisory_unlock_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:962
static const char *const PredicateLockTagTypeNames[]
Definition: lockfuncs.c:47
Datum pg_try_advisory_lock_shared_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:733
Datum pg_lock_status(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:93
Datum pg_advisory_xact_lock_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:826
StaticAssertDecl(lengthof(LockTagTypeNames)==(LOCKTAG_LAST_TYPE+1), "array length mismatch")
Datum pg_try_advisory_xact_lock_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:714
Datum pg_blocking_pids(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:466
Datum pg_advisory_lock_shared_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:659
Datum pg_try_advisory_xact_lock_shared_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:942
Datum pg_advisory_xact_lock_shared_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:676
Datum pg_advisory_unlock_shared_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:791
Datum pg_try_advisory_lock_int8(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:694
Datum pg_advisory_unlock_all(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:1000
const char *const LockTagTypeNames[]
Definition: lockfuncs.c:28
Datum pg_advisory_xact_lock_shared_int4(PG_FUNCTION_ARGS)
Definition: lockfuncs.c:861
void * palloc(Size size)
Definition: mcxt.c:1365
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
static PgChecksumMode mode
Definition: pg_checksums.c:55
while(p+4<=pend)
#define snprintf
Definition: port.h:239
static Datum TransactionIdGetDatum(TransactionId X)
Definition: postgres.h:282
static Datum Int16GetDatum(int16 X)
Definition: postgres.h:182
static Datum UInt16GetDatum(uint16 X)
Definition: postgres.h:202
static Datum BoolGetDatum(bool X)
Definition: postgres.h:112
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
uint64_t Datum
Definition: postgres.h:70
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:222
static Datum UInt32GetDatum(uint32 X)
Definition: postgres.h:242
PredicateLockData * GetPredicateLockStatusData(void)
Definition: predicate.c:1445
int GetSafeSnapshotBlockingPids(int blocked_pid, int *output, int output_size)
Definition: predicate.c:1628
PredicateLockTargetType
@ PREDLOCKTAG_PAGE
@ PREDLOCKTAG_TUPLE
#define GET_PREDICATELOCKTARGETTAG_DB(locktag)
#define GET_PREDICATELOCKTARGETTAG_RELATION(locktag)
#define GET_PREDICATELOCKTARGETTAG_TYPE(locktag)
#define GET_PREDICATELOCKTARGETTAG_PAGE(locktag)
#define GET_PREDICATELOCKTARGETTAG_OFFSET(locktag)
int ProcNumber
Definition: procnumber.h:24
int first_lock
Definition: lock.h:478
int pid
Definition: lock.h:475
int first_waiter
Definition: lock.h:482
int num_waiters
Definition: lock.h:483
int num_locks
Definition: lock.h:479
int nprocs
Definition: lock.h:491
int nlocks
Definition: lock.h:493
LockInstanceData * locks
Definition: lock.h:489
int * waiter_pids
Definition: lock.h:490
BlockedProcData * procs
Definition: lock.h:488
void * user_fctx
Definition: funcapi.h:82
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
TupleDesc tuple_desc
Definition: funcapi.h:112
Definition: lock.h:167
uint8 locktag_type
Definition: lock.h:172
uint32 locktag_field3
Definition: lock.h:170
uint32 locktag_field1
Definition: lock.h:168
uint8 locktag_lockmethodid
Definition: lock.h:173
uint16 locktag_field4
Definition: lock.h:171
uint32 locktag_field2
Definition: lock.h:169
Definition: lock.h:468
LockInstanceData * locks
Definition: lock.h:470
int nelements
Definition: lock.h:469
LOCKMASK holdMask
Definition: lock.h:457
LOCKMODE waitLockMode
Definition: lock.h:458
bool fastpath
Definition: lock.h:464
LOCKTAG locktag
Definition: lock.h:456
TimestampTz waitStart
Definition: lock.h:460
int leaderPid
Definition: lock.h:463
int pid
Definition: lock.h:462
VirtualTransactionId vxid
Definition: lock.h:459
const LOCKMASK * conflictTab
Definition: lock.h:113
Definition: lockfuncs.c:58
PredicateLockData * predLockData
Definition: lockfuncs.c:61
int predLockIdx
Definition: lockfuncs.c:62
int currIdx
Definition: lockfuncs.c:60
LockData * lockData
Definition: lockfuncs.c:59
PREDICATELOCKTARGETTAG * locktags
SERIALIZABLEXACT * xacts
VirtualTransactionId vxid
LocalTransactionId localTransactionId
Definition: lock.h:64
ProcNumber procNumber
Definition: lock.h:63
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:182
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:842
static Datum TimestampTzGetDatum(TimestampTz X)
Definition: timestamp.h:52

AltStyle によって変換されたページ (->オリジナル) /