granicus.if.org Git - postgresql/blob - src/include/storage/proc.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * proc.h
   4  *        per-process shared memory data structures
   5  *
   6  *
   7  * Portions Copyright (c) 1996-2011, 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/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"
  23
  24 /*
  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.
  28  *
  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.
  34  */
  35 #define PGPROC_MAX_CACHED_SUBXIDS 64    /* XXX guessed-at value */
  36
  37 struct XidCache
  38 {
  39         bool            overflowed;
  40         int                     nxids;
  41         TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS];
  42 };
  43
  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 */
  49
  50 /* flags reset at EOXact */
  51 #define         PROC_VACUUM_STATE_MASK (0x0E)
  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  * Each backend has a PGPROC struct in shared memory.  There is also a list of
  63  * currently-unused PGPROC structs that will be reallocated to new backends.
  64  *
  65  * links: list link for any list the PGPROC is in.      When waiting for a lock,
  66  * the PGPROC is linked into that lock's waitProcs queue.  A recycled PGPROC
  67  * is linked into ProcGlobal's freeProcs list.
  68  *
  69  * Note: twophase.c also sets up a dummy PGPROC struct for each currently
  70  * prepared transaction.  These PGPROCs appear in the ProcArray data structure
  71  * so that the prepared transactions appear to be still running and are
  72  * correctly shown as holding locks.  A prepared transaction PGPROC can be
  73  * distinguished from a real one at need by the fact that it has pid == 0.
  74  * The semaphore and lock-activity fields in a prepared-xact PGPROC are unused,
  75  * but its myProcLocks[] lists are valid.
  76  */
  77 struct PGPROC
  78 {
  79         /* proc->links MUST BE FIRST IN STRUCT (see ProcSleep,ProcWakeup,etc) */
  80         SHM_QUEUE       links;                  /* list link if process is in a list */
  81
  82         PGSemaphoreData sem;            /* ONE semaphore to sleep on */
  83         int                     waitStatus;             /* STATUS_WAITING, STATUS_OK or STATUS_ERROR */
  84
  85         LocalTransactionId lxid;        /* local id of top-level transaction currently
  86                                                                  * being executed by this proc, if running;
  87                                                                  * else InvalidLocalTransactionId */
  88
  89         TransactionId xid;                      /* id of top-level transaction currently being
  90                                                                  * executed by this proc, if running and XID
  91                                                                  * is assigned; else InvalidTransactionId */
  92
  93         TransactionId xmin;                     /* minimal running XID as it was when we were
  94                                                                  * starting our xact, excluding LAZY VACUUM:
  95                                                                  * vacuum must not remove tuples deleted by
  96                                                                  * xid >= xmin ! */
  97
  98         int                     pid;                    /* Backend's process ID; 0 if prepared xact */
  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            inCommit;               /* true if within commit critical section */
 106
 107         uint8           vacuumFlags;    /* vacuum-related flags, see above */
 108
 109         /*
 110          * While in hot standby mode, shows that a conflict signal has been sent
 111          * for the current transaction. Set/cleared while holding ProcArrayLock,
 112          * though not required. Accessed without lock, if needed.
 113          */
 114         bool            recoveryConflictPending;
 115
 116         /* Info about LWLock the process is currently waiting for, if any. */
 117         bool            lwWaiting;              /* true if waiting for an LW lock */
 118         bool            lwExclusive;    /* true if waiting for exclusive access */
 119         struct PGPROC *lwWaitLink;      /* next waiter for same LW lock */
 120
 121         /* Info about lock the process is currently waiting for, if any. */
 122         /* waitLock and waitProcLock are NULL if not currently waiting. */
 123         LOCK       *waitLock;           /* Lock object we're sleeping on ... */
 124         PROCLOCK   *waitProcLock;       /* Per-holder info for awaited lock */
 125         LOCKMODE        waitLockMode;   /* type of lock we're waiting for */
 126         LOCKMASK        heldLocks;              /* bitmask for lock types already held on this
 127                                                                  * lock object by this backend */
 128
 129         /*
 130          * Info to allow us to wait for synchronous replication, if needed.
 131          * waitLSN is InvalidXLogRecPtr if not waiting; set only by user backend.
 132          * syncRepState must not be touched except by owning process or WALSender.
 133          * syncRepLinks used only while holding SyncRepLock.
 134          */
 135         Latch           waitLatch;              /* allow us to wait for sync rep */
 136         XLogRecPtr      waitLSN;                /* waiting for this LSN or higher */
 137         int                     syncRepState;   /* wait state for sync rep */
 138         SHM_QUEUE       syncRepLinks;   /* list link if process is in syncrep queue */
 139
 140         /*
 141          * All PROCLOCK objects for locks held or awaited by this backend are
 142          * linked into one of these lists, according to the partition number of
 143          * their lock.
 144          */
 145         SHM_QUEUE       myProcLocks[NUM_LOCK_PARTITIONS];
 146
 147         struct XidCache subxids;        /* cache for subtransaction XIDs */
 148
 149         /* Per-backend LWLock.  Protects fields below. */
 150         LWLockId        backendLock;    /* protects the fields below */
 151
 152         /* Lock manager data, recording fast-path locks taken by this backend. */
 153         uint64          fpLockBits;             /* lock modes held for each fast-path slot */
 154         Oid                     fpRelId[FP_LOCK_SLOTS_PER_BACKEND]; /* slots for rel oids */
 155 };
 156
 157 /* NOTE: "typedef struct PGPROC PGPROC" appears in storage/lock.h. */
 158
 159
 160 extern PGDLLIMPORT PGPROC *MyProc;
 161
 162
 163 /*
 164  * There is one ProcGlobal struct for the whole database cluster.
 165  */
 166 typedef struct PROC_HDR
 167 {
 168         /* Array of PGPROC structures (not including dummies for prepared txns) */
 169         PGPROC     *allProcs;
 170         /* Length of allProcs array */
 171         uint32          allProcCount;
 172         /* Head of list of free PGPROC structures */
 173         PGPROC     *freeProcs;
 174         /* Head of list of autovacuum's free PGPROC structures */
 175         PGPROC     *autovacFreeProcs;
 176         /* Current shared estimate of appropriate spins_per_delay value */
 177         int                     spins_per_delay;
 178         /* The proc of the Startup process, since not in ProcArray */
 179         PGPROC     *startupProc;
 180         int                     startupProcPid;
 181         /* Buffer id of the buffer that Startup process waits for pin on */
 182         int                     startupBufferPinWaitBufId;
 183 } PROC_HDR;
 184
 185 extern PROC_HDR *ProcGlobal;
 186
 187 /*
 188  * We set aside some extra PGPROC structures for auxiliary processes,
 189  * ie things that aren't full-fledged backends but need shmem access.
 190  *
 191  * Background writer and WAL writer run during normal operation. Startup
 192  * process and WAL receiver also consume 2 slots, but WAL writer is
 193  * launched only after startup has exited, so we only need 3 slots.
 194  */
 195 #define NUM_AUXILIARY_PROCS             3
 196
 197
 198 /* configurable options */
 199 extern int      DeadlockTimeout;
 200 extern int      StatementTimeout;
 201 extern bool log_lock_waits;
 202
 203 extern volatile bool cancel_from_timeout;
 204
 205
 206 /*
 207  * Function Prototypes
 208  */
 209 extern int      ProcGlobalSemas(void);
 210 extern Size ProcGlobalShmemSize(void);
 211 extern void InitProcGlobal(void);
 212 extern void InitProcess(void);
 213 extern void InitProcessPhase2(void);
 214 extern void InitAuxiliaryProcess(void);
 215
 216 extern void PublishStartupProcessInformation(void);
 217 extern void SetStartupBufferPinWaitBufId(int bufid);
 218 extern int      GetStartupBufferPinWaitBufId(void);
 219
 220 extern bool HaveNFreeProcs(int n);
 221 extern void ProcReleaseLocks(bool isCommit);
 222
 223 extern void ProcQueueInit(PROC_QUEUE *queue);
 224 extern int      ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable);
 225 extern PGPROC *ProcWakeup(PGPROC *proc, int waitStatus);
 226 extern void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock);
 227 extern bool IsWaitingForLock(void);
 228 extern void LockWaitCancel(void);
 229
 230 extern void ProcWaitForSignal(void);
 231 extern void ProcSendSignal(int pid);
 232
 233 extern bool enable_sig_alarm(int delayms, bool is_statement_timeout);
 234 extern bool disable_sig_alarm(bool is_statement_timeout);
 235 extern void handle_sig_alarm(SIGNAL_ARGS);
 236
 237 extern bool enable_standby_sig_alarm(TimestampTz now,
 238                                                  TimestampTz fin_time, bool deadlock_only);
 239 extern bool disable_standby_sig_alarm(void);
 240 extern void handle_standby_sig_alarm(SIGNAL_ARGS);
 241
 242 #endif   /* PROC_H */