1 /*------------------------------------------------------------------------- 2 * 3 * proc.h 4 * per-process shared memory data structures 5 * 6 * 7 * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group 8 * Portions Copyright (c) 1994, Regents of the University of California 9 * 10 * src/include/storage/proc.h 11 * 12 *------------------------------------------------------------------------- 13 */ 14 #ifndef _PROC_H_ 15 #define _PROC_H_ 16 17 #include "access/xlogdefs.h" 18 #include "lib/ilist.h" 19 #include "storage/latch.h" 20 #include "storage/lock.h" 21 #include "storage/pg_sema.h" 22 23 /* 24 * Each backend advertises up to PGPROC_MAX_CACHED_SUBXIDS TransactionIds 25 * for non-aborted subtransactions of its current top transaction. These 26 * have to be treated as running XIDs by other backends. 27 * 28 * We also keep track of whether the cache overflowed (ie, the transaction has 29 * generated at least one subtransaction that didn't fit in the cache). 30 * If none of the caches have overflowed, we can assume that an XID that's not 31 * listed anywhere in the PGPROC array is not a running transaction. Else we 32 * have to look at pg_subtrans. 33 */ 34 #define PGPROC_MAX_CACHED_SUBXIDS 64 /* XXX guessed-at value */ 35 36 struct XidCache 37 { 38 TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS]; 39 }; 40 41 /* Flags for PGXACT->vacuumFlags */ 42 #define PROC_IS_AUTOVACUUM 0x01 /* is it an autovac worker? */ 43 #define PROC_IN_VACUUM 0x02 /* currently running lazy vacuum */ 44 #define PROC_IN_ANALYZE 0x04 /* currently running analyze */ 45 #define PROC_VACUUM_FOR_WRAPAROUND 0x08 /* set by autovac only */ 46 #define PROC_IN_LOGICAL_DECODING 0x10 /* currently doing logical 47 * decoding outside xact */ 48 49 /* flags reset at EOXact */ 50 #define PROC_VACUUM_STATE_MASK \ 51 (PROC_IN_VACUUM | PROC_IN_ANALYZE | PROC_VACUUM_FOR_WRAPAROUND) 52 53 /* 54 * We allow a small number of "weak" relation locks (AccesShareLock, 55 * RowShareLock, RowExclusiveLock) to be recorded in the PGPROC structure 56 * rather than the main lock table. This eases contention on the lock 57 * manager LWLocks. See storage/lmgr/README for additional details. 58 */ 59 #define FP_LOCK_SLOTS_PER_BACKEND 16 60 61 /* 62 * An invalid pgprocno. Must be larger than the maximum number of PGPROC 63 * structures we could possibly have. See comments for MAX_BACKENDS. 64 */ 65 #define INVALID_PGPROCNO PG_INT32_MAX 66 67 /* 68 * Each backend has a PGPROC struct in shared memory. There is also a list of 69 * currently-unused PGPROC structs that will be reallocated to new backends. 70 * 71 * links: list link for any list the PGPROC is in. When waiting for a lock, 72 * the PGPROC is linked into that lock's waitProcs queue. A recycled PGPROC 73 * is linked into ProcGlobal's freeProcs list. 74 * 75 * Note: twophase.c also sets up a dummy PGPROC struct for each currently 76 * prepared transaction. These PGPROCs appear in the ProcArray data structure 77 * so that the prepared transactions appear to be still running and are 78 * correctly shown as holding locks. A prepared transaction PGPROC can be 79 * distinguished from a real one at need by the fact that it has pid == 0. 80 * The semaphore and lock-activity fields in a prepared-xact PGPROC are unused, 81 * but its myProcLocks[] lists are valid. 82 */ 83 struct PGPROC 84 { 85 /* proc->links MUST BE FIRST IN STRUCT (see ProcSleep,ProcWakeup,etc) */ 86 SHM_QUEUE links; /* list link if process is in a list */ 87 PGPROC **procgloballist; /* procglobal list that owns this PGPROC */ 88 89 PGSemaphoreData sem; /* ONE semaphore to sleep on */ 90 int waitStatus; /* STATUS_WAITING, STATUS_OK or STATUS_ERROR */ 91 92 Latch procLatch; /* generic latch for process */ 93 94 LocalTransactionId lxid; /* local id of top-level transaction currently 95 * being executed by this proc, if running; 96 * else InvalidLocalTransactionId */ 97 int pid; /* Backend's process ID; 0 if prepared xact */ 98 int pgprocno; 99 100 /* These fields are zero while a backend is still starting up: */ 101 BackendId backendId; /* This backend's backend ID (if assigned) */ 102 Oid databaseId; /* OID of database this backend is using */ 103 Oid roleId; /* OID of role using this backend */ 104 105 bool isBackgroundWorker; /* true if background worker. */ 106 107 /* 108 * While in hot standby mode, shows that a conflict signal has been sent 109 * for the current transaction. Set/cleared while holding ProcArrayLock, 110 * though not required. Accessed without lock, if needed. 111 */ 112 bool recoveryConflictPending; 113 114 /* Info about LWLock the process is currently waiting for, if any. */ 115 bool lwWaiting; /* true if waiting for an LW lock */ 116 uint8 lwWaitMode; /* lwlock mode being waited for */ 117 dlist_node lwWaitLink; /* position in LW lock wait list */ 118 119 /* Info about lock the process is currently waiting for, if any. */ 120 /* waitLock and waitProcLock are NULL if not currently waiting. */ 121 LOCK *waitLock; /* Lock object we're sleeping on ... */ 122 PROCLOCK *waitProcLock; /* Per-holder info for awaited lock */ 123 LOCKMODE waitLockMode; /* type of lock we're waiting for */ 124 LOCKMASK heldLocks; /* bitmask for lock types already held on this 125 * lock object by this backend */ 126 127 /* 128 * Info to allow us to wait for synchronous replication, if needed. 129 * waitLSN is InvalidXLogRecPtr if not waiting; set only by user backend. 130 * syncRepState must not be touched except by owning process or WALSender. 131 * syncRepLinks used only while holding SyncRepLock. 132 */ 133 XLogRecPtr waitLSN; /* waiting for this LSN or higher */ 134 int syncRepState; /* wait state for sync rep */ 135 SHM_QUEUE syncRepLinks; /* list link if process is in syncrep queue */ 136 137 /* 138 * All PROCLOCK objects for locks held or awaited by this backend are 139 * linked into one of these lists, according to the partition number of 140 * their lock. 141 */ 142 SHM_QUEUE myProcLocks[NUM_LOCK_PARTITIONS]; 143 144 struct XidCache subxids; /* cache for subtransaction XIDs */ 145 146 /* Support for group XID clearing. */ 147 /* true, if member of ProcArray group waiting for XID clear */ 148 bool procArrayGroupMember; 149 /* next ProcArray group member waiting for XID clear */ 150 pg_atomic_uint32 procArrayGroupNext; 151 152 /* 153 * latest transaction id among the transaction's main XID and 154 * subtransactions 155 */ 156 TransactionId procArrayGroupMemberXid; 157 158 uint32 wait_event_info; /* proc's wait information */ 159 160 /* Per-backend LWLock. Protects fields below (but not group fields). */ 161 LWLock backendLock; 162 163 /* Lock manager data, recording fast-path locks taken by this backend. */ 164 uint64 fpLockBits; /* lock modes held for each fast-path slot */ 165 Oid fpRelId[FP_LOCK_SLOTS_PER_BACKEND]; /* slots for rel oids */ 166 bool fpVXIDLock; /* are we holding a fast-path VXID lock? */ 167 LocalTransactionId fpLocalTransactionId; /* lxid for fast-path VXID 168 * lock */ 169 170 /* 171 * Support for lock groups. Use LockHashPartitionLockByProc on the group 172 * leader to get the LWLock protecting these fields. 173 */ 174 PGPROC *lockGroupLeader; /* lock group leader, if I'm a member */ 175 dlist_head lockGroupMembers; /* list of members, if I'm a leader */ 176 dlist_node lockGroupLink; /* my member link, if I'm a member */ 177 }; 178 179 /* NOTE: "typedef struct PGPROC PGPROC" appears in storage/lock.h. */ 180 181 182 extern PGDLLIMPORT PGPROC *MyProc; 183 extern PGDLLIMPORT struct PGXACT *MyPgXact; 184 185 /* 186 * Prior to PostgreSQL 9.2, the fields below were stored as part of the 187 * PGPROC. However, benchmarking revealed that packing these particular 188 * members into a separate array as tightly as possible sped up GetSnapshotData 189 * considerably on systems with many CPU cores, by reducing the number of 190 * cache lines needing to be fetched. Thus, think very carefully before adding 191 * anything else here. 192 */ 193 typedef struct PGXACT 194 { 195 TransactionId xid; /* id of top-level transaction currently being 196 * executed by this proc, if running and XID 197 * is assigned; else InvalidTransactionId */ 198 199 TransactionId xmin; /* minimal running XID as it was when we were 200 * starting our xact, excluding LAZY VACUUM: 201 * vacuum must not remove tuples deleted by 202 * xid >= xmin ! */ 203 204 uint8 vacuumFlags; /* vacuum-related flags, see above */ 205 bool overflowed; 206 bool delayChkpt; /* true if this proc delays checkpoint start; 207 * previously called InCommit */ 208 209 uint8 nxids; 210 } PGXACT; 211 212 /* 213 * There is one ProcGlobal struct for the whole database cluster. 214 */ 215 typedef struct PROC_HDR 216 { 217 /* Array of PGPROC structures (not including dummies for prepared txns) */ 218 PGPROC *allProcs; 219 /* Array of PGXACT structures (not including dummies for prepared txns) */ 220 PGXACT *allPgXact; 221 /* Length of allProcs array */ 222 uint32 allProcCount; 223 /* Head of list of free PGPROC structures */ 224 PGPROC *freeProcs; 225 /* Head of list of autovacuum's free PGPROC structures */ 226 PGPROC *autovacFreeProcs; 227 /* Head of list of bgworker free PGPROC structures */ 228 PGPROC *bgworkerFreeProcs; 229 /* First pgproc waiting for group XID clear */ 230 pg_atomic_uint32 procArrayGroupFirst; 231 /* WALWriter process's latch */ 232 Latch *walwriterLatch; 233 /* Checkpointer process's latch */ 234 Latch *checkpointerLatch; 235 /* Current shared estimate of appropriate spins_per_delay value */ 236 int spins_per_delay; 237 /* The proc of the Startup process, since not in ProcArray */ 238 PGPROC *startupProc; 239 int startupProcPid; 240 /* Buffer id of the buffer that Startup process waits for pin on, or -1 */ 241 int startupBufferPinWaitBufId; 242 } PROC_HDR; 243 244 extern PGDLLIMPORT PROC_HDR *ProcGlobal; 245 246 extern PGPROC *PreparedXactProcs; 247 248 /* 249 * We set aside some extra PGPROC structures for auxiliary processes, 250 * ie things that aren't full-fledged backends but need shmem access. 251 * 252 * Background writer, checkpointer and WAL writer run during normal operation. 253 * Startup process and WAL receiver also consume 2 slots, but WAL writer is 254 * launched only after startup has exited, so we only need 4 slots. 255 */ 256 #define NUM_AUXILIARY_PROCS 4 257 258 259 /* configurable options */ 260 extern PGDLLIMPORT int DeadlockTimeout; 261 extern PGDLLIMPORT int StatementTimeout; 262 extern PGDLLIMPORT int LockTimeout; 263 extern PGDLLIMPORT int IdleInTransactionSessionTimeout; 264 extern bool log_lock_waits; 265 266 267 /* 268 * Function Prototypes 269 */ 270 extern int ProcGlobalSemas(void); 271 extern Size ProcGlobalShmemSize(void); 272 extern void InitProcGlobal(void); 273 extern void InitProcess(void); 274 extern void InitProcessPhase2(void); 275 extern void InitAuxiliaryProcess(void); 276 277 extern void PublishStartupProcessInformation(void); 278 extern void SetStartupBufferPinWaitBufId(int bufid); 279 extern int GetStartupBufferPinWaitBufId(void); 280 281 extern bool HaveNFreeProcs(int n); 282 extern void ProcReleaseLocks(bool isCommit); 283 284 extern void ProcQueueInit(PROC_QUEUE *queue); 285 extern int ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable); 286 extern PGPROC *ProcWakeup(PGPROC *proc, int waitStatus); 287 extern void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock); 288 extern void CheckDeadLockAlert(void); 289 extern bool IsWaitingForLock(void); 290 extern void LockErrorCleanup(void); 291 292 extern void ProcWaitForSignal(void); 293 extern void ProcSendSignal(int pid); 294 295 extern void BecomeLockGroupLeader(void); 296 extern bool BecomeLockGroupMember(PGPROC *leader, int pid); 297 298 #endif /* PROC_H */ 299