Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit9b4cda0

Browse files
committed
Add built-in userlock manipulation functions to replace the former
contrib functionality. Along the way, remove the USER_LOCKS configurationsymbol, since it no longer makes any sense to try to compile that out.No user documentation yet ... mmoncure has promised to write some.Thanks to Abhijit Menon-Sen for creating a first draft to work from.
1 parentf7f308d commit9b4cda0

File tree

11 files changed

+336
-50
lines changed

11 files changed

+336
-50
lines changed

‎doc/src/sgml/catalogs.sgml

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
<!-- $PostgreSQL: pgsql/doc/src/sgml/catalogs.sgml,v 2.132 2006/09/16 20:14:32 tgl Exp $ -->
1+
<!-- $PostgreSQL: pgsql/doc/src/sgml/catalogs.sgml,v 2.133 2006/09/18 22:40:36 tgl Exp $ -->
22
<!--
33
Documentation of the system catalogs, directed toward PostgreSQL developers
44
-->
@@ -5029,9 +5029,14 @@
50295029
</para>
50305030

50315031
<para>
5032-
If user-defined locks are in use, they are displayed using the columns
5033-
for general database objects. However, the actual meaning of the lock
5034-
fields in such cases is up to the user.
5032+
User-defined locks can be acquired on keys consisting of either a single
5033+
bigint value or two integer values. A bigint key is displayed with its
5034+
high-order half in the <structfield>classid</> column, its low-order half
5035+
in the <structfield>objid</> column, and <structfield>objsubid</> equal
5036+
to 1. Integer keys are displayed with the first key in the
5037+
<structfield>classid</> column, the second key in the <structfield>objid</>
5038+
column, and <structfield>objsubid</> equal to 2. The actual meaning of
5039+
the keys is up to the user.
50355040
</para>
50365041

50375042
<para>

‎src/backend/storage/lmgr/README

Lines changed: 5 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
$PostgreSQL: pgsql/src/backend/storage/lmgr/README,v 1.20 2006/07/23 23:08:46 tgl Exp $
1+
$PostgreSQL: pgsql/src/backend/storage/lmgr/README,v 1.21 2006/09/18 22:40:36 tgl Exp $
22

33

44
LOCKING OVERVIEW
@@ -48,7 +48,7 @@ The rest of this README file discusses the regular lock manager in detail.
4848
LOCK DATA STRUCTURES
4949

5050
Lock methods describe the overall locking behavior. Currently there are
51-
two lock methods: DEFAULT and USER. (USER locks are non-blocking.)
51+
two lock methods: DEFAULT and USER.
5252

5353
Lock modes describe the type of the lock (read/write or shared/exclusive).
5454
In principle, each lock method can have its own set of lock modes with
@@ -502,11 +502,6 @@ level by someone.
502502
User locks and normal locks are completely orthogonal and they don't
503503
interfere with each other.
504504

505-
User locks are always non blocking, therefore they are never acquired if
506-
already held by another process. They must be released explicitly by the
507-
application but they are released automatically when a backend terminates.
508-
509-
The lockmode parameter can have the same values as for normal locks although
510-
probably only ExclusiveLock can have some practical use.
511-
512-
DZ - 22 Nov 1997
505+
User locks are always held as session locks, so that they are not released at
506+
transaction end. They must be released explicitly by the application --- but
507+
they are released automatically when a backend terminates.

‎src/backend/storage/lmgr/deadlock.c

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@
1212
*
1313
*
1414
* IDENTIFICATION
15-
* $PostgreSQL: pgsql/src/backend/storage/lmgr/deadlock.c,v 1.41 2006/07/23 23:08:46 tgl Exp $
15+
* $PostgreSQL: pgsql/src/backend/storage/lmgr/deadlock.c,v 1.42 2006/09/18 22:40:36 tgl Exp $
1616
*
1717
*Interface:
1818
*
@@ -873,9 +873,11 @@ DescribeLockTag(StringInfo buf, const LOCKTAG *lock)
873873
break;
874874
caseLOCKTAG_USERLOCK:
875875
appendStringInfo(buf,
876-
_("user lock [%u,%u]"),
876+
_("user lock [%u,%u,%u,%u]"),
877877
lock->locktag_field1,
878-
lock->locktag_field2);
878+
lock->locktag_field2,
879+
lock->locktag_field3,
880+
lock->locktag_field4);
879881
break;
880882
default:
881883
appendStringInfo(buf,

‎src/backend/storage/lmgr/lock.c

Lines changed: 1 addition & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $PostgreSQL: pgsql/src/backend/storage/lmgr/lock.c,v 1.172 2006/08/27 19:14:34 tgl Exp $
11+
* $PostgreSQL: pgsql/src/backend/storage/lmgr/lock.c,v 1.173 2006/09/18 22:40:36 tgl Exp $
1212
*
1313
* NOTES
1414
* A lock table is a shared memory hash table. When
@@ -127,8 +127,6 @@ static const LockMethodData default_lockmethod = {
127127
#endif
128128
};
129129

130-
#ifdefUSER_LOCKS
131-
132130
staticconstLockMethodDatauser_lockmethod= {
133131
AccessExclusiveLock,/* highest valid lock mode number */
134132
false,
@@ -141,17 +139,13 @@ static const LockMethodData user_lockmethod = {
141139
#endif
142140
};
143141

144-
#endif/* USER_LOCKS */
145-
146142
/*
147143
* map from lock method id to the lock table data structures
148144
*/
149145
staticconstLockMethodLockMethods[]= {
150146
NULL,
151147
&default_lockmethod,
152-
#ifdefUSER_LOCKS
153148
&user_lockmethod
154-
#endif
155149
};
156150

157151

‎src/backend/utils/adt/lockfuncs.c

Lines changed: 257 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,21 @@
11
/*-------------------------------------------------------------------------
22
*
33
* lockfuncs.c
4-
*Set-returning functions to view the state of locks within the DB.
4+
*Functions for SQL access to various lock-manager capabilities.
55
*
66
* Copyright (c) 2002-2006, PostgreSQL Global Development Group
77
*
88
* IDENTIFICATION
9-
*$PostgreSQL: pgsql/src/backend/utils/adt/lockfuncs.c,v 1.24 2006/07/23 23:08:46 tgl Exp $
9+
*$PostgreSQL: pgsql/src/backend/utils/adt/lockfuncs.c,v 1.25 2006/09/18 22:40:37 tgl Exp $
1010
*
1111
*-------------------------------------------------------------------------
1212
*/
1313
#include"postgres.h"
1414

15-
#include"funcapi.h"
1615
#include"access/heapam.h"
1716
#include"catalog/pg_type.h"
17+
#include"funcapi.h"
18+
#include"miscadmin.h"
1819
#include"storage/proc.h"
1920
#include"utils/builtins.h"
2021

@@ -266,3 +267,256 @@ pg_lock_status(PG_FUNCTION_ARGS)
266267

267268
SRF_RETURN_DONE(funcctx);
268269
}
270+
271+
272+
/*
273+
* Functions for manipulating USERLOCK locks
274+
*
275+
* We make use of the locktag fields as follows:
276+
*
277+
*field1: MyDatabaseId ... ensures locks are local to each database
278+
*field2: first of 2 int4 keys, or high-order half of an int8 key
279+
*field3: second of 2 int4 keys, or low-order half of an int8 key
280+
*field4: 1 if using an int8 key, 2 if using 2 int4 keys
281+
*/
282+
#defineSET_LOCKTAG_INT64(tag,key64) \
283+
SET_LOCKTAG_USERLOCK(tag, \
284+
MyDatabaseId, \
285+
(uint32) ((key64) >> 32), \
286+
(uint32) (key64), \
287+
1)
288+
#defineSET_LOCKTAG_INT32(tag,key1,key2) \
289+
SET_LOCKTAG_USERLOCK(tag, MyDatabaseId, key1, key2, 2)
290+
291+
/*
292+
* pg_advisory_lock(int8) - acquire exclusive lock on an int8 key
293+
*/
294+
Datum
295+
pg_advisory_lock_int8(PG_FUNCTION_ARGS)
296+
{
297+
int64key=PG_GETARG_INT64(0);
298+
LOCKTAGtag;
299+
300+
SET_LOCKTAG_INT64(tag,key);
301+
302+
(void)LockAcquire(&tag,ExclusiveLock, true, false);
303+
304+
PG_RETURN_VOID();
305+
}
306+
307+
/*
308+
* pg_advisory_lock_shared(int8) - acquire share lock on an int8 key
309+
*/
310+
Datum
311+
pg_advisory_lock_shared_int8(PG_FUNCTION_ARGS)
312+
{
313+
int64key=PG_GETARG_INT64(0);
314+
LOCKTAGtag;
315+
316+
SET_LOCKTAG_INT64(tag,key);
317+
318+
(void)LockAcquire(&tag,ShareLock, true, false);
319+
320+
PG_RETURN_VOID();
321+
}
322+
323+
/*
324+
* pg_try_advisory_lock(int8) - acquire exclusive lock on an int8 key, no wait
325+
*
326+
* Returns true if successful, false if lock not available
327+
*/
328+
Datum
329+
pg_try_advisory_lock_int8(PG_FUNCTION_ARGS)
330+
{
331+
int64key=PG_GETARG_INT64(0);
332+
LOCKTAGtag;
333+
LockAcquireResultres;
334+
335+
SET_LOCKTAG_INT64(tag,key);
336+
337+
res=LockAcquire(&tag,ExclusiveLock, true, true);
338+
339+
PG_RETURN_BOOL(res!=LOCKACQUIRE_NOT_AVAIL);
340+
}
341+
342+
/*
343+
* pg_try_advisory_lock_shared(int8) - acquire share lock on an int8 key, no wait
344+
*
345+
* Returns true if successful, false if lock not available
346+
*/
347+
Datum
348+
pg_try_advisory_lock_shared_int8(PG_FUNCTION_ARGS)
349+
{
350+
int64key=PG_GETARG_INT64(0);
351+
LOCKTAGtag;
352+
LockAcquireResultres;
353+
354+
SET_LOCKTAG_INT64(tag,key);
355+
356+
res=LockAcquire(&tag,ShareLock, true, true);
357+
358+
PG_RETURN_BOOL(res!=LOCKACQUIRE_NOT_AVAIL);
359+
}
360+
361+
/*
362+
* pg_advisory_unlock(int8) - release exclusive lock on an int8 key
363+
*
364+
* Returns true if successful, false if lock was not held
365+
*/
366+
Datum
367+
pg_advisory_unlock_int8(PG_FUNCTION_ARGS)
368+
{
369+
int64key=PG_GETARG_INT64(0);
370+
LOCKTAGtag;
371+
boolres;
372+
373+
SET_LOCKTAG_INT64(tag,key);
374+
375+
res=LockRelease(&tag,ExclusiveLock, true);
376+
377+
PG_RETURN_BOOL(res);
378+
}
379+
380+
/*
381+
* pg_advisory_unlock_shared(int8) - release share lock on an int8 key
382+
*
383+
* Returns true if successful, false if lock was not held
384+
*/
385+
Datum
386+
pg_advisory_unlock_shared_int8(PG_FUNCTION_ARGS)
387+
{
388+
int64key=PG_GETARG_INT64(0);
389+
LOCKTAGtag;
390+
boolres;
391+
392+
SET_LOCKTAG_INT64(tag,key);
393+
394+
res=LockRelease(&tag,ShareLock, true);
395+
396+
PG_RETURN_BOOL(res);
397+
}
398+
399+
/*
400+
* pg_advisory_lock(int4, int4) - acquire exclusive lock on 2 int4 keys
401+
*/
402+
Datum
403+
pg_advisory_lock_int4(PG_FUNCTION_ARGS)
404+
{
405+
int32key1=PG_GETARG_INT32(0);
406+
int32key2=PG_GETARG_INT32(1);
407+
LOCKTAGtag;
408+
409+
SET_LOCKTAG_INT32(tag,key1,key2);
410+
411+
(void)LockAcquire(&tag,ExclusiveLock, true, false);
412+
413+
PG_RETURN_VOID();
414+
}
415+
416+
/*
417+
* pg_advisory_lock_shared(int4, int4) - acquire share lock on 2 int4 keys
418+
*/
419+
Datum
420+
pg_advisory_lock_shared_int4(PG_FUNCTION_ARGS)
421+
{
422+
int32key1=PG_GETARG_INT32(0);
423+
int32key2=PG_GETARG_INT32(1);
424+
LOCKTAGtag;
425+
426+
SET_LOCKTAG_INT32(tag,key1,key2);
427+
428+
(void)LockAcquire(&tag,ShareLock, true, false);
429+
430+
PG_RETURN_VOID();
431+
}
432+
433+
/*
434+
* pg_try_advisory_lock(int4, int4) - acquire exclusive lock on 2 int4 keys, no wait
435+
*
436+
* Returns true if successful, false if lock not available
437+
*/
438+
Datum
439+
pg_try_advisory_lock_int4(PG_FUNCTION_ARGS)
440+
{
441+
int32key1=PG_GETARG_INT32(0);
442+
int32key2=PG_GETARG_INT32(1);
443+
LOCKTAGtag;
444+
LockAcquireResultres;
445+
446+
SET_LOCKTAG_INT32(tag,key1,key2);
447+
448+
res=LockAcquire(&tag,ExclusiveLock, true, true);
449+
450+
PG_RETURN_BOOL(res!=LOCKACQUIRE_NOT_AVAIL);
451+
}
452+
453+
/*
454+
* pg_try_advisory_lock_shared(int4, int4) - acquire share lock on 2 int4 keys, no wait
455+
*
456+
* Returns true if successful, false if lock not available
457+
*/
458+
Datum
459+
pg_try_advisory_lock_shared_int4(PG_FUNCTION_ARGS)
460+
{
461+
int32key1=PG_GETARG_INT32(0);
462+
int32key2=PG_GETARG_INT32(1);
463+
LOCKTAGtag;
464+
LockAcquireResultres;
465+
466+
SET_LOCKTAG_INT32(tag,key1,key2);
467+
468+
res=LockAcquire(&tag,ShareLock, true, true);
469+
470+
PG_RETURN_BOOL(res!=LOCKACQUIRE_NOT_AVAIL);
471+
}
472+
473+
/*
474+
* pg_advisory_unlock(int4, int4) - release exclusive lock on 2 int4 keys
475+
*
476+
* Returns true if successful, false if lock was not held
477+
*/
478+
Datum
479+
pg_advisory_unlock_int4(PG_FUNCTION_ARGS)
480+
{
481+
int32key1=PG_GETARG_INT32(0);
482+
int32key2=PG_GETARG_INT32(1);
483+
LOCKTAGtag;
484+
boolres;
485+
486+
SET_LOCKTAG_INT32(tag,key1,key2);
487+
488+
res=LockRelease(&tag,ExclusiveLock, true);
489+
490+
PG_RETURN_BOOL(res);
491+
}
492+
493+
/*
494+
* pg_advisory_unlock_shared(int4, int4) - release share lock on 2 int4 keys
495+
*
496+
* Returns true if successful, false if lock was not held
497+
*/
498+
Datum
499+
pg_advisory_unlock_shared_int4(PG_FUNCTION_ARGS)
500+
{
501+
int32key1=PG_GETARG_INT32(0);
502+
int32key2=PG_GETARG_INT32(1);
503+
LOCKTAGtag;
504+
boolres;
505+
506+
SET_LOCKTAG_INT32(tag,key1,key2);
507+
508+
res=LockRelease(&tag,ShareLock, true);
509+
510+
PG_RETURN_BOOL(res);
511+
}
512+
513+
/*
514+
* pg_advisory_unlock_all() - release all userlocks
515+
*/
516+
Datum
517+
pg_advisory_unlock_all(PG_FUNCTION_ARGS)
518+
{
519+
LockReleaseAll(USER_LOCKMETHOD, true);
520+
521+
PG_RETURN_VOID();
522+
}

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp