1
/*-------------------------------------------------------------------------
4
* per-process shared memory data structures
7
* Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
8
* Portions Copyright (c) 1994, Regents of the University of California
10
* src/include/storage/proc.h
12
*-------------------------------------------------------------------------
17
#include "access/xlog.h"
18
#include "replication/syncrep.h"
19
#include "storage/latch.h"
20
#include "storage/lock.h"
21
#include "storage/pg_sema.h"
22
#include "utils/timestamp.h"
25
* Each backend advertises up to PGPROC_MAX_CACHED_SUBXIDS TransactionIds
26
* for non-aborted subtransactions of its current top transaction. These
27
* have to be treated as running XIDs by other backends.
29
* We also keep track of whether the cache overflowed (ie, the transaction has
30
* generated at least one subtransaction that didn't fit in the cache).
31
* If none of the caches have overflowed, we can assume that an XID that's not
32
* listed anywhere in the PGPROC array is not a running transaction. Else we
33
* have to look at pg_subtrans.
35
#define PGPROC_MAX_CACHED_SUBXIDS 64 /* XXX guessed-at value */
41
TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS];
44
/* Flags for PGPROC->vacuumFlags */
45
#define PROC_IS_AUTOVACUUM 0x01 /* is it an autovac worker? */
46
#define PROC_IN_VACUUM 0x02 /* currently running lazy vacuum */
47
#define PROC_IN_ANALYZE 0x04 /* currently running analyze */
48
#define PROC_VACUUM_FOR_WRAPAROUND 0x08 /* set by autovac only */
50
/* flags reset at EOXact */
51
#define PROC_VACUUM_STATE_MASK (0x0E)
54
* Each backend has a PGPROC struct in shared memory. There is also a list of
55
* currently-unused PGPROC structs that will be reallocated to new backends.
57
* links: list link for any list the PGPROC is in. When waiting for a lock,
58
* the PGPROC is linked into that lock's waitProcs queue. A recycled PGPROC
59
* is linked into ProcGlobal's freeProcs list.
61
* Note: twophase.c also sets up a dummy PGPROC struct for each currently
62
* prepared transaction. These PGPROCs appear in the ProcArray data structure
63
* so that the prepared transactions appear to be still running and are
64
* correctly shown as holding locks. A prepared transaction PGPROC can be
65
* distinguished from a real one at need by the fact that it has pid == 0.
66
* The semaphore and lock-activity fields in a prepared-xact PGPROC are unused,
67
* but its myProcLocks[] lists are valid.
71
/* proc->links MUST BE FIRST IN STRUCT (see ProcSleep,ProcWakeup,etc) */
72
SHM_QUEUE links; /* list link if process is in a list */
74
PGSemaphoreData sem; /* ONE semaphore to sleep on */
75
int waitStatus; /* STATUS_WAITING, STATUS_OK or STATUS_ERROR */
77
LocalTransactionId lxid; /* local id of top-level transaction currently
78
* being executed by this proc, if running;
79
* else InvalidLocalTransactionId */
81
TransactionId xid; /* id of top-level transaction currently being
82
* executed by this proc, if running and XID
83
* is assigned; else InvalidTransactionId */
85
TransactionId xmin; /* minimal running XID as it was when we were
86
* starting our xact, excluding LAZY VACUUM:
87
* vacuum must not remove tuples deleted by
90
int pid; /* Backend's process ID; 0 if prepared xact */
92
/* These fields are zero while a backend is still starting up: */
93
BackendId backendId; /* This backend's backend ID (if assigned) */
94
Oid databaseId; /* OID of database this backend is using */
95
Oid roleId; /* OID of role using this backend */
97
bool inCommit; /* true if within commit critical section */
99
uint8 vacuumFlags; /* vacuum-related flags, see above */
102
* While in hot standby mode, shows that a conflict signal has been sent
103
* for the current transaction. Set/cleared while holding ProcArrayLock,
104
* though not required. Accessed without lock, if needed.
106
bool recoveryConflictPending;
108
/* Info about LWLock the process is currently waiting for, if any. */
109
bool lwWaiting; /* true if waiting for an LW lock */
110
bool lwExclusive; /* true if waiting for exclusive access */
111
struct PGPROC *lwWaitLink; /* next waiter for same LW lock */
113
/* Info about lock the process is currently waiting for, if any. */
114
/* waitLock and waitProcLock are NULL if not currently waiting. */
115
LOCK *waitLock; /* Lock object we're sleeping on ... */
116
PROCLOCK *waitProcLock; /* Per-holder info for awaited lock */
117
LOCKMODE waitLockMode; /* type of lock we're waiting for */
118
LOCKMASK heldLocks; /* bitmask for lock types already held on this
119
* lock object by this backend */
122
* Info to allow us to wait for synchronous replication, if needed.
123
* waitLSN is InvalidXLogRecPtr if not waiting; set only by user backend.
124
* syncRepState must not be touched except by owning process or WALSender.
125
* syncRepLinks used only while holding SyncRepLock.
127
Latch waitLatch; /* allow us to wait for sync rep */
128
XLogRecPtr waitLSN; /* waiting for this LSN or higher */
129
int syncRepState; /* wait state for sync rep */
130
SHM_QUEUE syncRepLinks; /* list link if process is in syncrep queue */
133
* All PROCLOCK objects for locks held or awaited by this backend are
134
* linked into one of these lists, according to the partition number of
137
SHM_QUEUE myProcLocks[NUM_LOCK_PARTITIONS];
139
struct XidCache subxids; /* cache for subtransaction XIDs */
142
/* NOTE: "typedef struct PGPROC PGPROC" appears in storage/lock.h. */
145
extern PGDLLIMPORT PGPROC *MyProc;
149
* There is one ProcGlobal struct for the whole database cluster.
151
typedef struct PROC_HDR
153
/* Head of list of free PGPROC structures */
155
/* Head of list of autovacuum's free PGPROC structures */
156
PGPROC *autovacFreeProcs;
157
/* Current shared estimate of appropriate spins_per_delay value */
159
/* The proc of the Startup process, since not in ProcArray */
162
/* Buffer id of the buffer that Startup process waits for pin on */
163
int startupBufferPinWaitBufId;
167
* We set aside some extra PGPROC structures for auxiliary processes,
168
* ie things that aren't full-fledged backends but need shmem access.
170
* Background writer and WAL writer run during normal operation. Startup
171
* process and WAL receiver also consume 2 slots, but WAL writer is
172
* launched only after startup has exited, so we only need 3 slots.
174
#define NUM_AUXILIARY_PROCS 3
177
/* configurable options */
178
extern int DeadlockTimeout;
179
extern int StatementTimeout;
180
extern bool log_lock_waits;
182
extern volatile bool cancel_from_timeout;
186
* Function Prototypes
188
extern int ProcGlobalSemas(void);
189
extern Size ProcGlobalShmemSize(void);
190
extern void InitProcGlobal(void);
191
extern void InitProcess(void);
192
extern void InitProcessPhase2(void);
193
extern void InitAuxiliaryProcess(void);
195
extern void PublishStartupProcessInformation(void);
196
extern void SetStartupBufferPinWaitBufId(int bufid);
197
extern int GetStartupBufferPinWaitBufId(void);
199
extern bool HaveNFreeProcs(int n);
200
extern void ProcReleaseLocks(bool isCommit);
202
extern void ProcQueueInit(PROC_QUEUE *queue);
203
extern int ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable);
204
extern PGPROC *ProcWakeup(PGPROC *proc, int waitStatus);
205
extern void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock);
206
extern bool IsWaitingForLock(void);
207
extern void LockWaitCancel(void);
209
extern void ProcWaitForSignal(void);
210
extern void ProcSendSignal(int pid);
212
extern bool enable_sig_alarm(int delayms, bool is_statement_timeout);
213
extern bool disable_sig_alarm(bool is_statement_timeout);
214
extern void handle_sig_alarm(SIGNAL_ARGS);
216
extern bool enable_standby_sig_alarm(TimestampTz now,
217
TimestampTz fin_time, bool deadlock_only);
218
extern bool disable_standby_sig_alarm(void);
219
extern void handle_standby_sig_alarm(SIGNAL_ARGS);