/* Also ensure XLogReceiptTime has a sane value */
XLogReceiptTime = GetCurrentTimestamp();
- /* Allow ProcSendSignal() to find us, for buffer pin wakeups. */
- PublishStartupProcessInformation();
-
/*
* Let postmaster know we've started redo now, so that it can launch
* the archiver if necessary.
#include "storage/buf_internals.h"
#include "storage/bufmgr.h"
+#include "storage/proc.h"
BufferDescPadded *BufferDescriptors;
char *BufferBlocks;
CLEAR_BUFFERTAG(buf->tag);
pg_atomic_init_u32(&buf->state, 0);
- buf->wait_backend_pid = 0;
+ buf->wait_backend_pgprocno = INVALID_PGPROCNO;
buf->buf_id = i;
BUF_STATE_GET_REFCOUNT(buf_state) == 1)
{
/* we just released the last pin other than the waiter's */
- int wait_backend_pid = buf->wait_backend_pid;
+ int wait_backend_pgprocno = buf->wait_backend_pgprocno;
buf_state &= ~BM_PIN_COUNT_WAITER;
UnlockBufHdr(buf, buf_state);
- ProcSendSignal(wait_backend_pid);
+ ProcSendSignal(wait_backend_pgprocno);
}
else
UnlockBufHdr(buf, buf_state);
* got a cancel/die interrupt before getting the signal.
*/
if ((buf_state & BM_PIN_COUNT_WAITER) != 0 &&
- buf->wait_backend_pid == MyProcPid)
+ buf->wait_backend_pgprocno == MyProc->pgprocno)
buf_state &= ~BM_PIN_COUNT_WAITER;
UnlockBufHdr(buf, buf_state);
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
elog(ERROR, "multiple backends attempting to wait for pincount 1");
}
- bufHdr->wait_backend_pid = MyProcPid;
+ bufHdr->wait_backend_pgprocno = MyProc->pgprocno;
PinCountWaitBuf = bufHdr;
buf_state |= BM_PIN_COUNT_WAITER;
UnlockBufHdr(bufHdr, buf_state);
*/
buf_state = LockBufHdr(bufHdr);
if ((buf_state & BM_PIN_COUNT_WAITER) != 0 &&
- bufHdr->wait_backend_pid == MyProcPid)
+ bufHdr->wait_backend_pgprocno == MyProc->pgprocno)
buf_state &= ~BM_PIN_COUNT_WAITER;
UnlockBufHdr(bufHdr, buf_state);
PredXact->OldCommittedSxact->xmin = InvalidTransactionId;
PredXact->OldCommittedSxact->flags = SXACT_FLAG_COMMITTED;
PredXact->OldCommittedSxact->pid = 0;
+ PredXact->OldCommittedSxact->pgprocno = INVALID_PGPROCNO;
}
/* This never changes, so let's keep a local copy. */
OldCommittedSxact = PredXact->OldCommittedSxact;
sxact->finishedBefore = InvalidTransactionId;
sxact->xmin = snapshot->xmin;
sxact->pid = MyProcPid;
+ sxact->pgprocno = MyProc->pgprocno;
SHMQueueInit(&(sxact->predicateLocks));
SHMQueueElemInit(&(sxact->finishedLink));
sxact->flags = 0;
*/
if (SxactIsDeferrableWaiting(roXact) &&
(SxactIsROUnsafe(roXact) || SxactIsROSafe(roXact)))
- ProcSendSignal(roXact->pid);
+ ProcSendSignal(roXact->pgprocno);
possibleUnsafeConflict = nextConflict;
}
Assert(SxactIsPrepared(MySerializableXact));
MySerializableXact->pid = 0;
+ MySerializableXact->pgprocno = INVALID_PGPROCNO;
hash_destroy(LocalPredicateLockHash);
LocalPredicateLockHash = NULL;
sxact->vxid.backendId = InvalidBackendId;
sxact->vxid.localTransactionId = (LocalTransactionId) xid;
sxact->pid = 0;
+ sxact->pgprocno = INVALID_PGPROCNO;
/* a prepared xact hasn't committed yet */
sxact->prepareSeqNo = RecoverySerCommitSeqNo;
ProcGlobal->autovacFreeProcs = NULL;
ProcGlobal->bgworkerFreeProcs = NULL;
ProcGlobal->walsenderFreeProcs = NULL;
- ProcGlobal->startupProc = NULL;
- ProcGlobal->startupProcPid = 0;
ProcGlobal->startupBufferPinWaitBufId = -1;
ProcGlobal->walwriterLatch = NULL;
ProcGlobal->checkpointerLatch = NULL;
on_shmem_exit(AuxiliaryProcKill, Int32GetDatum(proctype));
}
-/*
- * Record the PID and PGPROC structures for the Startup process, for use in
- * ProcSendSignal(). See comments there for further explanation.
- */
-void
-PublishStartupProcessInformation(void)
-{
- SpinLockAcquire(ProcStructLock);
-
- ProcGlobal->startupProc = MyProc;
- ProcGlobal->startupProcPid = MyProcPid;
-
- SpinLockRelease(ProcStructLock);
-}
-
/*
* Used from bufmgr to share the value of the buffer that Startup waits on,
* or to reset the value to "not waiting" (-1). This allows processing
}
/*
- * ProcSendSignal - send a signal to a backend identified by PID
+ * ProcSendSignal - set the latch of a backend identified by pgprocno
*/
void
-ProcSendSignal(int pid)
+ProcSendSignal(int pgprocno)
{
- PGPROC *proc = NULL;
+ if (pgprocno < 0 || pgprocno >= ProcGlobal->allProcCount)
+ elog(ERROR, "pgprocno out of range");
- if (RecoveryInProgress())
- {
- SpinLockAcquire(ProcStructLock);
-
- /*
- * Check to see whether it is the Startup process we wish to signal.
- * This call is made by the buffer manager when it wishes to wake up a
- * process that has been waiting for a pin in so it can obtain a
- * cleanup lock using LockBufferForCleanup(). Startup is not a normal
- * backend, so BackendPidGetProc() will not return any pid at all. So
- * we remember the information for this special case.
- */
- if (pid == ProcGlobal->startupProcPid)
- proc = ProcGlobal->startupProc;
-
- SpinLockRelease(ProcStructLock);
- }
-
- if (proc == NULL)
- proc = BackendPidGetProc(pid);
-
- if (proc != NULL)
- {
- SetLatch(&proc->procLatch);
- }
+ SetLatch(&ProcGlobal->allProcs[pgprocno].procLatch);
}
/*
* BufferDesc -- shared descriptor/state data for a single shared buffer.
*
* Note: Buffer header lock (BM_LOCKED flag) must be held to examine or change
- * the tag, state or wait_backend_pid fields. In general, buffer header lock
+ * tag, state or wait_backend_pgprocno fields. In general, buffer header lock
* is a spinlock which is combined with flags, refcount and usagecount into
* single atomic variable. This layout allow us to do some operations in a
* single atomic operation, without actually acquiring and releasing spinlock;
*
* We can't physically remove items from a disk page if another backend has
* the buffer pinned. Hence, a backend may need to wait for all other pins
- * to go away. This is signaled by storing its own PID into
- * wait_backend_pid and setting flag bit BM_PIN_COUNT_WAITER. At present,
+ * to go away. This is signaled by storing its own pgprocno into
+ * wait_backend_pgprocno and setting flag bit BM_PIN_COUNT_WAITER. At present,
* there can be only one such waiter per buffer.
*
* We use this same struct for local buffer headers, but the locks are not
/* state of the tag, containing flags, refcount and usagecount */
pg_atomic_uint32 state;
- int wait_backend_pid; /* backend PID of pin-count waiter */
+ int wait_backend_pgprocno; /* backend of pin-count waiter */
int freeNext; /* link in freelist chain */
LWLock content_lock; /* to lock access to buffer contents */
} BufferDesc;
TransactionId xmin; /* the transaction's snapshot xmin */
uint32 flags; /* OR'd combination of values defined below */
int pid; /* pid of associated process */
+ int pgprocno; /* pgprocno of associated process */
} SERIALIZABLEXACT;
#define SXACT_FLAG_COMMITTED 0x00000001 /* already committed */
Latch *checkpointerLatch;
/* Current shared estimate of appropriate spins_per_delay value */
int spins_per_delay;
- /* The proc of the Startup process, since not in ProcArray */
- PGPROC *startupProc;
- int startupProcPid;
/* Buffer id of the buffer that Startup process waits for pin on, or -1 */
int startupBufferPinWaitBufId;
} PROC_HDR;
extern void InitProcessPhase2(void);
extern void InitAuxiliaryProcess(void);
-extern void PublishStartupProcessInformation(void);
extern void SetStartupBufferPinWaitBufId(int bufid);
extern int GetStartupBufferPinWaitBufId(void);
extern void LockErrorCleanup(void);
extern void ProcWaitForSignal(uint32 wait_event_info);
-extern void ProcSendSignal(int pid);
+extern void ProcSendSignal(int pgprocno);
extern PGPROC *AuxiliaryPidGetProc(int pid);
projects / postgresql.git / commitdiff