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

Commitbd272ca

Browse files
committed
Mega-commit to make heap_open/heap_openr/heap_close take an
additional argument specifying the kind of lock to acquire/release (or'NoLock' to do no lock processing). Ensure that all relations are lockedwith some appropriate lock level before being examined --- this ensuresthat relevant shared-inval messages have been processed and should preventproblems caused by concurrent VACUUM. Fix several bugs having to do withmismatched increment/decrement of relation ref count and mismatchedheap_open/close (which amounts to the same thing). A bogus ref count ona relation doesn't matter much *unless* a SI Inval message happens toarrive at the wrong time, which is probably why we got away with thissloppiness for so long. Repair missing grab of AccessExclusiveLock inDROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi.Recommend 'make clean all' after pulling this update; I modified theRelation struct layout slightly.Will post further discussion to pghackers list shortly.
1 parent6c86fd5 commitbd272ca

File tree

70 files changed

+1095
-1216
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

70 files changed

+1095
-1216
lines changed

‎contrib/miscutil/misc_utils.c‎

Lines changed: 2 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -89,9 +89,8 @@ active_listeners(text *relname)
8989
intourpid=getpid();
9090
charlisten_name[NAMEDATALEN];
9191

92-
lRel=heap_openr(ListenerRelationName);
92+
lRel=heap_openr(ListenerRelationName,AccessShareLock);
9393
tdesc=RelationGetDescr(lRel);
94-
LockRelation(lRel,AccessShareLock);
9594

9695
if (relname&& (VARSIZE(relname)>VARHDRSZ)) {
9796
len=MIN(VARSIZE(relname)-VARHDRSZ,NAMEDATALEN-1);
@@ -110,19 +109,14 @@ active_listeners(text *relname)
110109
{
111110
d=heap_getattr(lTuple,Anum_pg_listener_pid,tdesc,&isnull);
112111
pid=DatumGetInt32(d);
113-
#ifdefHAVE_KILL
114112
if ((pid==ourpid)|| (kill(pid,SIGTSTP)==0)) {
115113
/* elog(NOTICE, "%d ok", pid); */
116114
count++;
117115
}
118-
#else
119-
count++;
120-
#endif
121116
}
122117
heap_endscan(sRel);
123118

124-
UnlockRelation(lRel,AccessShareLock);
125-
heap_close(lRel);
119+
heap_close(lRel,AccessShareLock);
126120

127121
returncount;
128122
}

‎src/backend/access/gist/gist.c‎

Lines changed: 25 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@
66
*
77
*
88
* IDENTIFICATION
9-
* $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.44 1999/07/19 02:06:15 tgl Exp $
9+
* $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.45 1999/09/18 19:05:46 tgl Exp $
1010
*
1111
*-------------------------------------------------------------------------
1212
*/
@@ -20,6 +20,7 @@
2020
#include"catalog/index.h"
2121
#include"catalog/pg_index.h"
2222
#include"executor/executor.h"
23+
#include"miscadmin.h"
2324
#include"utils/syscache.h"
2425

2526

@@ -88,8 +89,6 @@ gistbuild(Relation heap,
8889
TupleTableSlot*slot;
8990

9091
#endif
91-
Oidhrelid,
92-
irelid;
9392
Node*pred,
9493
*oldPred;
9594
GISTSTATEgiststate;
@@ -271,28 +270,31 @@ gistbuild(Relation heap,
271270
}
272271

273272
/*
274-
* Since we just inted the tuples in the heap, we update its stats in
275-
* pg_relation to guarantee that the planner takes advantage of the
276-
* index we just created. UpdateStats() does a
277-
* CommandinterIncrement(), which flushes changed entries from the
278-
* system relcache. The act of constructing an index changes these
279-
* heap and index tuples in the system catalogs, so they need to be
280-
* flushed. We close them to guarantee that they will be.
273+
* Since we just counted the tuples in the heap, we update its stats
274+
* in pg_class to guarantee that the planner takes advantage of the
275+
* index we just created. But, only update statistics during
276+
* normal index definitions, not for indices on system catalogs
277+
* created during bootstrap processing. We must close the relations
278+
* before updating statistics to guarantee that the relcache entries
279+
* are flushed when we increment the command counter in UpdateStats().
280+
* But we do not release any locks on the relations; those will be
281+
* held until end of transaction.
281282
*/
282-
283-
hrelid=RelationGetRelid(heap);
284-
irelid=RelationGetRelid(index);
285-
heap_close(heap);
286-
index_close(index);
287-
288-
UpdateStats(hrelid,nh, true);
289-
UpdateStats(irelid,ni, false);
290-
291-
if (oldPred!=NULL)
283+
if (IsNormalProcessingMode())
292284
{
293-
if (ni==nh)
294-
pred=NULL;
295-
UpdateIndexPredicate(irelid,oldPred,pred);
285+
Oidhrelid=RelationGetRelid(heap);
286+
Oidirelid=RelationGetRelid(index);
287+
288+
heap_close(heap,NoLock);
289+
index_close(index);
290+
UpdateStats(hrelid,nh, true);
291+
UpdateStats(irelid,ni, false);
292+
if (oldPred!=NULL)
293+
{
294+
if (ni==nh)
295+
pred=NULL;
296+
UpdateIndexPredicate(irelid,oldPred,pred);
297+
}
296298
}
297299

298300
/* be tidy */

‎src/backend/access/hash/hash.c‎

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
*
88
*
99
* IDENTIFICATION
10-
* $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.30 1999/07/17 20:16:38 momjian Exp $
10+
* $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.31 1999/09/18 19:05:52 tgl Exp $
1111
*
1212
* NOTES
1313
* This file contains only the public interface routines.
@@ -66,8 +66,6 @@ hashbuild(Relation heap,
6666
TupleTableSlot*slot;
6767

6868
#endif
69-
Oidhrelid,
70-
irelid;
7169
Node*pred,
7270
*oldPred;
7371

@@ -232,17 +230,20 @@ hashbuild(Relation heap,
232230
/*
233231
* Since we just counted the tuples in the heap, we update its stats
234232
* in pg_class to guarantee that the planner takes advantage of the
235-
* index we just created.Finally, only update statistics during
233+
* index we just created. But, only update statistics during
236234
* normal index definitions, not for indices on system catalogs
237235
* created during bootstrap processing. We must close the relations
238-
* beforeupdatings statistics to guarantee that the relcache entries
236+
* beforeupdating statistics to guarantee that the relcache entries
239237
* are flushed when we increment the command counter in UpdateStats().
238+
* But we do not release any locks on the relations; those will be
239+
* held until end of transaction.
240240
*/
241241
if (IsNormalProcessingMode())
242242
{
243-
hrelid=RelationGetRelid(heap);
244-
irelid=RelationGetRelid(index);
245-
heap_close(heap);
243+
Oidhrelid=RelationGetRelid(heap);
244+
Oidirelid=RelationGetRelid(index);
245+
246+
heap_close(heap,NoLock);
246247
index_close(index);
247248
UpdateStats(hrelid,nhtups, true);
248249
UpdateStats(irelid,nitups, false);

‎src/backend/access/heap/heapam.c‎

Lines changed: 70 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
*
88
*
99
* IDENTIFICATION
10-
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.53 1999/07/19 07:07:18 momjian Exp $
10+
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.54 1999/09/18 19:05:58 tgl Exp $
1111
*
1212
*
1313
* INTERFACE ROUTINES
@@ -486,74 +486,111 @@ heapgettup(Relation relation,
486486
/* ----------------
487487
*heap_open - open a heap relation by relationId
488488
*
489-
*presently the relcache routines do all the work we need
490-
*to open/close heap relations.
489+
*If lockmode is "NoLock", no lock is obtained on the relation,
490+
*and the caller must check for a NULL return value indicating
491+
*that no such relation exists.
492+
*Otherwise, an error is raised if the relation does not exist,
493+
*and the specified kind of lock is obtained on the relation.
491494
* ----------------
492495
*/
493496
Relation
494-
heap_open(OidrelationId)
497+
heap_open(OidrelationId,LOCKMODElockmode)
495498
{
496499
Relationr;
497500

501+
Assert(lockmode >=NoLock&&lockmode<MAX_LOCKMODES);
502+
498503
/* ----------------
499504
*increment access statistics
500505
* ----------------
501506
*/
502507
IncrHeapAccessStat(local_open);
503508
IncrHeapAccessStat(global_open);
504509

505-
r= (Relation)RelationIdGetRelation(relationId);
510+
/* The relcache does all the real work... */
511+
r=RelationIdGetRelation(relationId);
506512

513+
/* Under no circumstances will we return an index as a relation. */
507514
if (RelationIsValid(r)&&r->rd_rel->relkind==RELKIND_INDEX)
508515
elog(ERROR,"%s is an index relation",r->rd_rel->relname.data);
509516

517+
if (lockmode==NoLock)
518+
returnr;/* caller must check RelationIsValid! */
519+
520+
if (!RelationIsValid(r))
521+
elog(ERROR,"Relation %u does not exist",relationId);
522+
523+
LockRelation(r,lockmode);
524+
510525
returnr;
511526
}
512527

513528
/* ----------------
514529
*heap_openr - open a heap relation by name
515530
*
516-
*presently the relcache routines do all the work we need
517-
*to open/close heap relations.
531+
*If lockmode is "NoLock", no lock is obtained on the relation,
532+
*and the caller must check for a NULL return value indicating
533+
*that no such relation exists.
534+
*Otherwise, an error is raised if the relation does not exist,
535+
*and the specified kind of lock is obtained on the relation.
518536
* ----------------
519537
*/
520538
Relation
521-
heap_openr(char*relationName)
539+
heap_openr(char*relationName,LOCKMODElockmode)
522540
{
523541
Relationr;
524542

543+
Assert(lockmode >=NoLock&&lockmode<MAX_LOCKMODES);
544+
525545
/* ----------------
526546
*increment access statistics
527547
* ----------------
528548
*/
529549
IncrHeapAccessStat(local_openr);
530550
IncrHeapAccessStat(global_openr);
531551

552+
/* The relcache does all the real work... */
532553
r=RelationNameGetRelation(relationName);
533554

555+
/* Under no circumstances will we return an index as a relation. */
534556
if (RelationIsValid(r)&&r->rd_rel->relkind==RELKIND_INDEX)
535557
elog(ERROR,"%s is an index relation",r->rd_rel->relname.data);
536558

559+
if (lockmode==NoLock)
560+
returnr;/* caller must check RelationIsValid! */
561+
562+
if (!RelationIsValid(r))
563+
elog(ERROR,"Relation '%s' does not exist",relationName);
564+
565+
LockRelation(r,lockmode);
566+
537567
returnr;
538568
}
539569

540570
/* ----------------
541571
*heap_close - close a heap relation
542572
*
543-
*presently the relcache routines do all the work we need
544-
*to open/close heap relations.
573+
*If lockmode is not "NoLock", we first release the specified lock.
574+
*Note that it is often sensible to hold a lock beyond heap_close;
575+
*in that case, the lock is released automatically at xact end.
545576
* ----------------
546577
*/
547578
void
548-
heap_close(Relationrelation)
579+
heap_close(Relationrelation,LOCKMODElockmode)
549580
{
581+
Assert(lockmode >=NoLock&&lockmode<MAX_LOCKMODES);
582+
550583
/* ----------------
551584
*increment access statistics
552585
* ----------------
553586
*/
554587
IncrHeapAccessStat(local_close);
555588
IncrHeapAccessStat(global_close);
556589

590+
if (lockmode!=NoLock)
591+
UnlockRelation(relation,lockmode);
592+
593+
/* The relcache does the real work... */
557594
RelationClose(relation);
558595
}
559596

@@ -582,21 +619,29 @@ heap_beginscan(Relation relation,
582619
*sanity checks
583620
* ----------------
584621
*/
585-
if (RelationIsValid(relation)== false)
622+
if (!RelationIsValid(relation))
586623
elog(ERROR,"heap_beginscan: !RelationIsValid(relation)");
587624

588-
LockRelation(relation,AccessShareLock);
589-
590-
/* XXX someday assert SelfTimeQual if relkind == RELKIND_UNCATALOGED */
591-
if (relation->rd_rel->relkind==RELKIND_UNCATALOGED)
592-
snapshot=SnapshotSelf;
593-
594625
/* ----------------
595626
*increment relation ref count while scanning relation
596627
* ----------------
597628
*/
598629
RelationIncrementReferenceCount(relation);
599630

631+
/* ----------------
632+
*Acquire AccessShareLock for the duration of the scan
633+
*
634+
*Note: we could get an SI inval message here and consequently have
635+
*to rebuild the relcache entry. The refcount increment above
636+
*ensures that we will rebuild it and not just flush it...
637+
* ----------------
638+
*/
639+
LockRelation(relation,AccessShareLock);
640+
641+
/* XXX someday assert SelfTimeQual if relkind == RELKIND_UNCATALOGED */
642+
if (relation->rd_rel->relkind==RELKIND_UNCATALOGED)
643+
snapshot=SnapshotSelf;
644+
600645
/* ----------------
601646
*allocate and initialize scan descriptor
602647
* ----------------
@@ -683,15 +728,19 @@ heap_endscan(HeapScanDesc scan)
683728
*/
684729
unpinscan(scan);
685730

731+
/* ----------------
732+
*Release AccessShareLock acquired by heap_beginscan()
733+
* ----------------
734+
*/
735+
UnlockRelation(scan->rs_rd,AccessShareLock);
736+
686737
/* ----------------
687738
*decrement relation reference count and free scan descriptor storage
688739
* ----------------
689740
*/
690741
RelationDecrementReferenceCount(scan->rs_rd);
691742

692-
UnlockRelation(scan->rs_rd,AccessShareLock);
693-
694-
pfree(scan);/* XXX */
743+
pfree(scan);
695744
}
696745

697746
/* ----------------

0 commit comments

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