database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-28 23:42:10 +03:00
Code Activity

Revert SIGUSR1 multiplexing patch, per Tom's objection.

Browse Source
This commit is contained in:
Heikki Linnakangas
2008-12-09 15:59:39 +00:00
parent 7b05b3fa39
commit dea81a6cf6
10 changed files with 45 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/backend/storage/ipc/sinval.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/storage/ipc/sinval.c,v 1.87 2008/12/09 14:28:20 heikki Exp $
* $PostgreSQL: pgsql/src/backend/storage/ipc/sinval.c,v 1.88 2008/12/09 15:59:39 heikki Exp $
*
*-------------------------------------------------------------------------
*/
@ -26,8 +26,8 @@
* Because backends sitting idle will not be reading sinval events, we
* need a way to give an idle backend a swift kick in the rear and make
* it catch up before the sinval queue overflows and forces it to go
* through a cache reset exercise. This is done by sending
* PROCSIG_CATCHUP_INTERRUPT to any backend that gets too far behind.
* through a cache reset exercise. This is done by sending SIGUSR1
* to any backend that gets too far behind.
*
* State for catchup events consists of two flags: one saying whether
* the signal handler is currently allowed to call ProcessCatchupEvent
@ -144,9 +144,9 @@ ReceiveSharedInvalidMessages(
/*
* HandleCatchupInterrupt
* CatchupInterruptHandler
*
* This is called when PROCSIG_CATCHUP_INTERRUPT signal is received.
* This is the signal handler for SIGUSR1.
*
* If we are idle (catchupInterruptEnabled is set), we can safely
* invoke ProcessCatchupEvent directly. Otherwise, just set a flag
@ -156,11 +156,13 @@ ReceiveSharedInvalidMessages(
* since there's no longer any reason to do anything.)
*/
void
HandleCatchupInterrupt(void)
CatchupInterruptHandler(SIGNAL_ARGS)
{
int save_errno = errno;
/*
* Note: this is called by a SIGNAL HANDLER.
* You must be very wary what you do here.
* Note: this is a SIGNAL HANDLER. You must be very wary what you do
* here.
*/
/* Don't joggle the elbow of proc_exit */
@ -214,6 +216,8 @@ HandleCatchupInterrupt(void)
*/
catchupInterruptOccurred = 1;
}
errno = save_errno;
}
/*
@ -285,8 +289,7 @@ DisableCatchupInterrupt(void)
/*
* ProcessCatchupEvent
*
* Respond to a catchup event (PROCSIG_CATCHUP_INTERRUPT) from another
* backend.
* Respond to a catchup event (SIGUSR1) from another backend.
*
* This is called either directly from the SIGUSR1 signal handler,
* or the next time control reaches the outer idle loop (assuming

37
src/backend/storage/ipc/sinvaladt.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.75 2008/12/09 14:28:20 heikki Exp $
* $PostgreSQL: pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.76 2008/12/09 15:59:39 heikki Exp $
*
*-------------------------------------------------------------------------
*/
@ -21,7 +21,6 @@
#include "storage/backendid.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/shmem.h"
#include "storage/sinvaladt.h"
#include "storage/spin.h"
@ -137,9 +136,9 @@
/* Per-backend state in shared invalidation structure */
typedef struct ProcState
{
/* proc is NULL in an inactive ProcState array entry. */
PGPROC *proc; /* PGPROC entry of backend, for signaling */
/* nextMsgNum is meaningless if proc == NULL or resetState is true. */
/* procPid is zero in an inactive ProcState array entry. */
pid_t procPid; /* PID of backend, for signaling */
/* nextMsgNum is meaningless if procPid == 0 or resetState is true. */
int nextMsgNum; /* next message number to read */
bool resetState; /* backend needs to reset its state */
bool signaled; /* backend has been sent catchup signal */
@ -236,7 +235,7 @@ CreateSharedInvalidationState(void)
/* Mark all backends inactive, and initialize nextLXID */
for (i = 0; i < shmInvalBuffer->maxBackends; i++)
{
shmInvalBuffer->procState[i].proc = NULL; /* inactive */
shmInvalBuffer->procState[i].procPid = 0; /* inactive */
shmInvalBuffer->procState[i].nextMsgNum = 0; /* meaningless */
shmInvalBuffer->procState[i].resetState = false;
shmInvalBuffer->procState[i].signaled = false;
@ -267,7 +266,7 @@ SharedInvalBackendInit(void)
/* Look for a free entry in the procState array */
for (index = 0; index < segP->lastBackend; index++)
{
if (segP->procState[index].proc == NULL) /* inactive slot? */
if (segP->procState[index].procPid == 0) /* inactive slot? */
{
stateP = &segP->procState[index];
break;
@ -279,7 +278,7 @@ SharedInvalBackendInit(void)
if (segP->lastBackend < segP->maxBackends)
{
stateP = &segP->procState[segP->lastBackend];
Assert(stateP->proc == NULL);
Assert(stateP->procPid == 0);
segP->lastBackend++;
}
else
@ -304,7 +303,7 @@ SharedInvalBackendInit(void)
nextLocalTransactionId = stateP->nextLXID;
/* mark myself active, with all extant messages already read */
stateP->proc = MyProc;
stateP->procPid = MyProcPid;
stateP->nextMsgNum = segP->maxMsgNum;
stateP->resetState = false;
stateP->signaled = false;
@ -342,7 +341,7 @@ CleanupInvalidationState(int status, Datum arg)
stateP->nextLXID = nextLocalTransactionId;
/* Mark myself inactive */
stateP->proc = NULL;
stateP->procPid = 0;
stateP->nextMsgNum = 0;
stateP->resetState = false;
stateP->signaled = false;
@ -350,7 +349,7 @@ CleanupInvalidationState(int status, Datum arg)
/* Recompute index of last active backend */
for (i = segP->lastBackend; i > 0; i--)
{
if (segP->procState[i - 1].proc != NULL)
if (segP->procState[i - 1].procPid != 0)
break;
}
segP->lastBackend = i;
@ -375,7 +374,7 @@ BackendIdIsActive(int backendID)
{
ProcState *stateP = &segP->procState[backendID - 1];
result = (stateP->proc != NULL);
result = (stateP->procPid != 0);
}
else
result = false;
@ -591,7 +590,7 @@ SICleanupQueue(bool callerHasWriteLock, int minFree)
int n = stateP->nextMsgNum;
/* Ignore if inactive or already in reset state */
if (stateP->proc == NULL || stateP->resetState)
if (stateP->procPid == 0 || stateP->resetState)
continue;
/*
@ -645,20 +644,18 @@ SICleanupQueue(bool callerHasWriteLock, int minFree)
segP->nextThreshold = (numMsgs / CLEANUP_QUANTUM + 1) * CLEANUP_QUANTUM;
/*
* Lastly, signal anyone who needs a catchup interrupt. Since
* SendProcSignal() might not be fast, we don't want to hold locks while
* executing it.
* Lastly, signal anyone who needs a catchup interrupt. Since kill()
* might not be fast, we don't want to hold locks while executing it.
*/
if (needSig)
{
PGPROC *his_proc = needSig->proc;
pid_t his_pid = needSig->procPid;
needSig->signaled = true;
LWLockRelease(SInvalReadLock);
LWLockRelease(SInvalWriteLock);
elog(DEBUG4, "sending sinval catchup signal to PID %d",
(int) his_proc->pid);
SendProcSignal(his_proc, PROCSIG_CATCHUP_INTERRUPT);
elog(DEBUG4, "sending sinval catchup signal to PID %d", (int) his_pid);
kill(his_pid, SIGUSR1);
if (callerHasWriteLock)
LWLockAcquire(SInvalWriteLock, LW_EXCLUSIVE);
}

52
src/backend/storage/lmgr/proc.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/storage/lmgr/proc.c,v 1.203 2008/12/09 14:28:20 heikki Exp $
* $PostgreSQL: pgsql/src/backend/storage/lmgr/proc.c,v 1.204 2008/12/09 15:59:39 heikki Exp $
*
*-------------------------------------------------------------------------
*/
@ -289,7 +289,6 @@ InitProcess(void)
MyProc->databaseId = InvalidOid;
MyProc->roleId = InvalidOid;
MyProc->inCommit = false;
MemSet(MyProc->signalFlags, 0, NUM_PROCSIGNALS * sizeof(sig_atomic_t));
MyProc->vacuumFlags = 0;
if (IsAutoVacuumWorkerProcess())
MyProc->vacuumFlags |= PROC_IS_AUTOVACUUM;
@ -429,7 +428,6 @@ InitAuxiliaryProcess(void)
MyProc->databaseId = InvalidOid;
MyProc->roleId = InvalidOid;
MyProc->inCommit = false;
MemSet(MyProc->signalFlags, 0, NUM_PROCSIGNALS * sizeof(sig_atomic_t));
/* we don't set the "is autovacuum" flag in the launcher */
MyProc->vacuumFlags = 0;
MyProc->lwWaiting = false;
@ -1279,54 +1277,6 @@ ProcSendSignal(int pid)
PGSemaphoreUnlock(&proc->sem);
}
/*
* SendProcSignal - send the signal with the reason to a process.
*
* The process can be a backend or an auxiliary process that has a PGPROC
* entry, like an autovacuum worker.
*/
void
SendProcSignal(PGPROC *proc, ProcSignalReason reason)
{
pid_t pid;
/*
* If the process is gone, do nothing.
*
* Since there's no locking, it's possible that the process detaches
* from shared memory and exits right after this test, before we set
* the flag and send signal. And the PGPROC entry might even be recycled
* by a new process, so it's remotely possible that we signal a wrong
* process. That's OK, all the signals are such that no harm is done.
*/
pid = proc->pid;
if (pid == 0)
return;
/* Atomically set the proper flag */
proc->signalFlags[reason] = true;
/* Send SIGUSR1 to the process */
kill(pid, SIGUSR1);
}
/*
* CheckProcSignal - check to see if the particular reason has been
* signaled, and clear the signal flag. Should be called after
* receiving SIGUSR1.
*/
bool
CheckProcSignal(ProcSignalReason reason)
{
/* Careful here --- don't clear flag if we haven't seen it set */
if (MyProc->signalFlags[reason])
{
MyProc->signalFlags[reason] = false;
return true;
}
return false;
}
/*****************************************************************************
* SIGALRM interrupt support