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

Commit4dab3d5

Browse files
committed
Change the autovacuum launcher to use WaitLatch instead of a poll loop.
In pursuit of this (and with the expectation that WaitLatch will be neededin more places), convert the latch field that was already added to PGPROCfor sync rep into a generic latch that is activated for all PGPROC-owningprocesses, and change many of the standard backend signal handlers to setthat latch when a signal happens. This will allow WaitLatch callers to bewakened properly by these signals.In passing, fix a whole bunch of signal handlers that had been hacked to dothings that might change errno, without adding the necessary save/restorelogic for errno. Also make some minor fixes in unix_latch.c, and cleanup bizarre and unsafe scheme for disowning the process's latch. Much ofthis has to be back-patched into 9.1.Peter Geoghegan, with additional work by Tom
1 parent1f1b70a commit4dab3d5

File tree

11 files changed

+186
-77
lines changed

11 files changed

+186
-77
lines changed

‎src/backend/access/transam/xlog.c‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9957,34 +9957,50 @@ startupproc_quickdie(SIGNAL_ARGS)
99579957
staticvoid
99589958
StartupProcSigUsr1Handler(SIGNAL_ARGS)
99599959
{
9960+
intsave_errno=errno;
9961+
99609962
latch_sigusr1_handler();
9963+
9964+
errno=save_errno;
99619965
}
99629966

99639967
/* SIGUSR2: set flag to finish recovery */
99649968
staticvoid
99659969
StartupProcTriggerHandler(SIGNAL_ARGS)
99669970
{
9971+
intsave_errno=errno;
9972+
99679973
promote_triggered= true;
99689974
WakeupRecovery();
9975+
9976+
errno=save_errno;
99699977
}
99709978

99719979
/* SIGHUP: set flag to re-read config file at next convenient time */
99729980
staticvoid
99739981
StartupProcSigHupHandler(SIGNAL_ARGS)
99749982
{
9983+
intsave_errno=errno;
9984+
99759985
got_SIGHUP= true;
99769986
WakeupRecovery();
9987+
9988+
errno=save_errno;
99779989
}
99789990

99799991
/* SIGTERM: set flag to abort redo and exit */
99809992
staticvoid
99819993
StartupProcShutdownHandler(SIGNAL_ARGS)
99829994
{
9995+
intsave_errno=errno;
9996+
99839997
if (in_restore_command)
99849998
proc_exit(1);
99859999
else
998610000
shutdown_requested= true;
998710001
WakeupRecovery();
10002+
10003+
errno=save_errno;
998810004
}
998910005

999010006
/* Handle SIGHUP and SIGTERM signals of startup process */

‎src/backend/port/unix_latch.c‎

Lines changed: 40 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -138,9 +138,12 @@ DisownLatch(volatile Latch *latch)
138138
* function returns immediately.
139139
*
140140
* The 'timeout' is given in milliseconds. It must be >= 0 if WL_TIMEOUT flag
141-
* is given. On some platforms, signals cause the timeout to be restarted,
142-
* so beware that the function can sleep for several times longer than the
143-
* specified timeout.
141+
* is given. On some platforms, signals do not interrupt the wait, or even
142+
* cause the timeout to be restarted, so beware that the function can sleep
143+
* for several times longer than the requested timeout. However, this
144+
* difficulty is not so great as it seems, because the signal handlers for any
145+
* signals that the caller should respond to ought to be programmed to end the
146+
* wait by calling SetLatch. Ideally, the timeout parameter is vestigial.
144147
*
145148
* The latch must be owned by the current process, ie. it must be a
146149
* backend-local latch initialized with InitLatch, or a shared latch
@@ -261,6 +264,7 @@ WaitLatchOrSocket(volatile Latch *latch, int wakeEvents, pgsocket sock,
261264
{
262265
if (errno==EINTR)
263266
continue;
267+
waiting= false;
264268
ereport(ERROR,
265269
(errcode_for_socket_access(),
266270
errmsg("select() failed: %m")));
@@ -294,6 +298,10 @@ WaitLatchOrSocket(volatile Latch *latch, int wakeEvents, pgsocket sock,
294298
* Sets a latch and wakes up anyone waiting on it.
295299
*
296300
* This is cheap if the latch is already set, otherwise not so much.
301+
*
302+
* NB: when calling this in a signal handler, be sure to save and restore
303+
* errno around it. (That's standard practice in most signal handlers, of
304+
* course, but we used to omit it in handlers that only set a flag.)
297305
*/
298306
void
299307
SetLatch(volatileLatch*latch)
@@ -339,7 +347,10 @@ SetLatch(volatile Latch *latch)
339347
if (owner_pid==0)
340348
return;
341349
elseif (owner_pid==MyProcPid)
342-
sendSelfPipeByte();
350+
{
351+
if (waiting)
352+
sendSelfPipeByte();
353+
}
343354
else
344355
kill(owner_pid,SIGUSR1);
345356
}
@@ -371,7 +382,11 @@ ResetLatch(volatile Latch *latch)
371382
* SetLatch uses SIGUSR1 to wake up the process waiting on the latch.
372383
*
373384
* Wake up WaitLatch, if we're waiting. (We might not be, since SIGUSR1 is
374-
* overloaded for multiple purposes.)
385+
* overloaded for multiple purposes; or we might not have reached WaitLatch
386+
* yet, in which case we don't need to fill the pipe either.)
387+
*
388+
* NB: when calling this in a signal handler, be sure to save and restore
389+
* errno around it.
375390
*/
376391
void
377392
latch_sigusr1_handler(void)
@@ -435,13 +450,19 @@ sendSelfPipeByte(void)
435450
}
436451
}
437452

438-
/* Read all available data from the self-pipe */
453+
/*
454+
* Read all available data from the self-pipe
455+
*
456+
* Note: this is only called when waiting = true. If it fails and doesn't
457+
* return, it must reset that flag first (though ideally, this will never
458+
* happen).
459+
*/
439460
staticvoid
440461
drainSelfPipe(void)
441462
{
442463
/*
443464
* There shouldn't normally be more than one byte in the pipe, or maybe a
444-
* fewmore if multiple processes run SetLatch at the same instant.
465+
* fewbytes if multiple processes run SetLatch at the same instant.
445466
*/
446467
charbuf[16];
447468
intrc;
@@ -456,9 +477,21 @@ drainSelfPipe(void)
456477
elseif (errno==EINTR)
457478
continue;/* retry */
458479
else
480+
{
481+
waiting= false;
459482
elog(ERROR,"read() on self-pipe failed: %m");
483+
}
460484
}
461485
elseif (rc==0)
486+
{
487+
waiting= false;
462488
elog(ERROR,"unexpected EOF on self-pipe");
489+
}
490+
elseif (rc<sizeof(buf))
491+
{
492+
/* we successfully drained the pipe; no need to read() again */
493+
break;
494+
}
495+
/* else buffer wasn't big enough, so read again */
463496
}
464497
}

‎src/backend/postmaster/autovacuum.c‎

Lines changed: 36 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,7 @@
8484
#include"postmaster/postmaster.h"
8585
#include"storage/bufmgr.h"
8686
#include"storage/ipc.h"
87+
#include"storage/latch.h"
8788
#include"storage/pmsignal.h"
8889
#include"storage/proc.h"
8990
#include"storage/procsignal.h"
@@ -553,11 +554,11 @@ AutoVacLauncherMain(int argc, char *argv[])
553554
Dlelem*elem;
554555

555556
/*
556-
* Emergency bailout if postmaster has died. This is to avoid the
557-
* necessity for manual cleanup of all postmaster children.
557+
* This loop is a bit different from the normal use of WaitLatch,
558+
* because we'd like to sleep before the first launch of a child
559+
* process. So it's WaitLatch, then ResetLatch, then check for
560+
* wakening conditions.
558561
*/
559-
if (!PostmasterIsAlive())
560-
proc_exit(1);
561562

562563
launcher_determine_sleep((AutoVacuumShmem->av_freeWorkers!=NULL),
563564
false,&nap);
@@ -566,42 +567,24 @@ AutoVacLauncherMain(int argc, char *argv[])
566567
EnableCatchupInterrupt();
567568

568569
/*
569-
* Sleep for a while according to schedule.
570-
*
571-
* On some platforms, signals won't interrupt the sleep. To ensure we
572-
* respond reasonably promptly when someone signals us, break down the
573-
* sleep into 1-second increments, and check for interrupts after each
574-
* nap.
570+
* Wait until naptime expires or we get some type of signal (all the
571+
* signal handlers will wake us by calling SetLatch).
575572
*/
576-
while (nap.tv_sec>0||nap.tv_usec>0)
577-
{
578-
uint32sleeptime;
579-
580-
if (nap.tv_sec>0)
581-
{
582-
sleeptime=1000000;
583-
nap.tv_sec--;
584-
}
585-
else
586-
{
587-
sleeptime=nap.tv_usec;
588-
nap.tv_usec=0;
589-
}
590-
pg_usleep(sleeptime);
591-
592-
/*
593-
* Emergency bailout if postmaster has died. This is to avoid the
594-
* necessity for manual cleanup of all postmaster children.
595-
*/
596-
if (!PostmasterIsAlive())
597-
proc_exit(1);
573+
WaitLatch(&MyProc->procLatch,
574+
WL_LATCH_SET |WL_TIMEOUT |WL_POSTMASTER_DEATH,
575+
(nap.tv_sec*1000L)+ (nap.tv_usec /1000L));
598576

599-
if (got_SIGTERM||got_SIGHUP||got_SIGUSR2)
600-
break;
601-
}
577+
ResetLatch(&MyProc->procLatch);
602578

603579
DisableCatchupInterrupt();
604580

581+
/*
582+
* Emergency bailout if postmaster has died. This is to avoid the
583+
* necessity for manual cleanup of all postmaster children.
584+
*/
585+
if (!PostmasterIsAlive())
586+
proc_exit(1);
587+
605588
/* the normal shutdown case */
606589
if (got_SIGTERM)
607590
break;
@@ -1321,21 +1304,39 @@ AutoVacWorkerFailed(void)
13211304
staticvoid
13221305
avl_sighup_handler(SIGNAL_ARGS)
13231306
{
1307+
intsave_errno=errno;
1308+
13241309
got_SIGHUP= true;
1310+
if (MyProc)
1311+
SetLatch(&MyProc->procLatch);
1312+
1313+
errno=save_errno;
13251314
}
13261315

13271316
/* SIGUSR2: a worker is up and running, or just finished, or failed to fork */
13281317
staticvoid
13291318
avl_sigusr2_handler(SIGNAL_ARGS)
13301319
{
1320+
intsave_errno=errno;
1321+
13311322
got_SIGUSR2= true;
1323+
if (MyProc)
1324+
SetLatch(&MyProc->procLatch);
1325+
1326+
errno=save_errno;
13321327
}
13331328

13341329
/* SIGTERM: time to die */
13351330
staticvoid
13361331
avl_sigterm_handler(SIGNAL_ARGS)
13371332
{
1333+
intsave_errno=errno;
1334+
13381335
got_SIGTERM= true;
1336+
if (MyProc)
1337+
SetLatch(&MyProc->procLatch);
1338+
1339+
errno=save_errno;
13391340
}
13401341

13411342

‎src/backend/postmaster/pgarch.c‎

Lines changed: 16 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -288,45 +288,57 @@ pgarch_exit(SIGNAL_ARGS)
288288
staticvoid
289289
ArchSigHupHandler(SIGNAL_ARGS)
290290
{
291+
intsave_errno=errno;
292+
291293
/* set flag to re-read config file at next convenient time */
292294
got_SIGHUP= true;
293-
/* let the waiting loop iterate */
294295
SetLatch(&mainloop_latch);
296+
297+
errno=save_errno;
295298
}
296299

297300
/* SIGTERM signal handler for archiver process */
298301
staticvoid
299302
ArchSigTermHandler(SIGNAL_ARGS)
300303
{
304+
intsave_errno=errno;
305+
301306
/*
302307
* The postmaster never sends us SIGTERM, so we assume that this means
303308
* that init is trying to shut down the whole system. If we hang around
304309
* too long we'll get SIGKILL'd. Set flag to prevent starting any more
305310
* archive commands.
306311
*/
307312
got_SIGTERM= true;
308-
/* let the waiting loop iterate */
309313
SetLatch(&mainloop_latch);
314+
315+
errno=save_errno;
310316
}
311317

312318
/* SIGUSR1 signal handler for archiver process */
313319
staticvoid
314320
pgarch_waken(SIGNAL_ARGS)
315321
{
322+
intsave_errno=errno;
323+
316324
/* set flag that there is work to be done */
317325
wakened= true;
318-
/* let the waiting loop iterate */
319326
SetLatch(&mainloop_latch);
327+
328+
errno=save_errno;
320329
}
321330

322331
/* SIGUSR2 signal handler for archiver process */
323332
staticvoid
324333
pgarch_waken_stop(SIGNAL_ARGS)
325334
{
335+
intsave_errno=errno;
336+
326337
/* set flag to do a final cycle and shut down afterwards */
327338
ready_to_stop= true;
328-
/* let the waiting loop iterate */
329339
SetLatch(&mainloop_latch);
340+
341+
errno=save_errno;
330342
}
331343

332344
/*

‎src/backend/replication/syncrep.c‎

Lines changed: 6 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -111,9 +111,6 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN)
111111
Assert(SHMQueueIsDetached(&(MyProc->syncRepLinks)));
112112
Assert(WalSndCtl!=NULL);
113113

114-
/* Reset the latch before adding ourselves to the queue. */
115-
ResetLatch(&MyProc->waitLatch);
116-
117114
LWLockAcquire(SyncRepLock,LW_EXCLUSIVE);
118115
Assert(MyProc->syncRepState==SYNC_REP_NOT_WAITING);
119116

@@ -167,7 +164,7 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN)
167164
intsyncRepState;
168165

169166
/* Must reset the latch before testing state. */
170-
ResetLatch(&MyProc->waitLatch);
167+
ResetLatch(&MyProc->procLatch);
171168

172169
/*
173170
* Try checking the state without the lock first. There's no
@@ -247,11 +244,10 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN)
247244
}
248245

249246
/*
250-
* Wait on latch for up to 60 seconds. This allows us to check for
251-
* cancel/die signal or postmaster death regularly while waiting. Note
252-
* that timeout here does not necessarily release from loop.
247+
* Wait on latch. Any condition that should wake us up will set
248+
* the latch, so no need for timeout.
253249
*/
254-
WaitLatch(&MyProc->waitLatch,WL_LATCH_SET |WL_TIMEOUT,60000L);
250+
WaitLatch(&MyProc->procLatch,WL_LATCH_SET |WL_POSTMASTER_DEATH,-1);
255251
}
256252

257253
/*
@@ -322,16 +318,14 @@ SyncRepCancelWait(void)
322318
}
323319

324320
void
325-
SyncRepCleanupAtProcExit(intcode,Datumarg)
321+
SyncRepCleanupAtProcExit(void)
326322
{
327323
if (!SHMQueueIsDetached(&(MyProc->syncRepLinks)))
328324
{
329325
LWLockAcquire(SyncRepLock,LW_EXCLUSIVE);
330326
SHMQueueDelete(&(MyProc->syncRepLinks));
331327
LWLockRelease(SyncRepLock);
332328
}
333-
334-
DisownLatch(&MyProc->waitLatch);
335329
}
336330

337331
/*
@@ -567,9 +561,7 @@ SyncRepWakeQueue(bool all)
567561
/*
568562
* Wake only when we have set state and removed from queue.
569563
*/
570-
Assert(SHMQueueIsDetached(&(thisproc->syncRepLinks)));
571-
Assert(thisproc->syncRepState==SYNC_REP_WAIT_COMPLETE);
572-
SetLatch(&(thisproc->waitLatch));
564+
SetLatch(&(thisproc->procLatch));
573565

574566
numprocs++;
575567
}

0 commit comments

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