src/include/storage/proc.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * proc.h
   4  *        per-process shared memory data structures
   5  *
   6  *
   7  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  * $PostgreSQL$
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #ifndef _PROC_H_
  15 #define _PROC_H_
  16
  17 #include "storage/lock.h"
  18 #include "storage/pg_sema.h"
  19
  20
  21 /*
  22  * Each backend advertises up to PGPROC_MAX_CACHED_SUBXIDS TransactionIds
  23  * for non-aborted subtransactions of its current top transaction.      These
  24  * have to be treated as running XIDs by other backends.
  25  *
  26  * We also keep track of whether the cache overflowed (ie, the transaction has
  27  * generated at least one subtransaction that didn't fit in the cache).
  28  * If none of the caches have overflowed, we can assume that an XID that's not
  29  * listed anywhere in the PGPROC array is not a running transaction.  Else we
  30  * have to look at pg_subtrans.
  31  */
  32 #define PGPROC_MAX_CACHED_SUBXIDS 64    /* XXX guessed-at value */
  33
  34 struct XidCache
  35 {
  36         bool            overflowed;
  37         int                     nxids;
  38         TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS];
  39 };
  40
  41 /* Flags for PGPROC->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
  47 /* flags reset at EOXact */
  48 #define         PROC_VACUUM_STATE_MASK (0x0E)
  49
  50 /*
  51  * Each backend has a PGPROC struct in shared memory.  There is also a list of
  52  * currently-unused PGPROC structs that will be reallocated to new backends.
  53  *
  54  * links: list link for any list the PGPROC is in.      When waiting for a lock,
  55  * the PGPROC is linked into that lock's waitProcs queue.  A recycled PGPROC
  56  * is linked into ProcGlobal's freeProcs list.
  57  *
  58  * Note: twophase.c also sets up a dummy PGPROC struct for each currently
  59  * prepared transaction.  These PGPROCs appear in the ProcArray data structure
  60  * so that the prepared transactions appear to be still running and are
  61  * correctly shown as holding locks.  A prepared transaction PGPROC can be
  62  * distinguished from a real one at need by the fact that it has pid == 0.
  63  * The semaphore and lock-activity fields in a prepared-xact PGPROC are unused,
  64  * but its myProcLocks[] lists are valid.
  65  */
  66 struct PGPROC
  67 {
  68         /* proc->links MUST BE FIRST IN STRUCT (see ProcSleep,ProcWakeup,etc) */
  69         SHM_QUEUE       links;                  /* list link if process is in a list */
  70
  71         PGSemaphoreData sem;            /* ONE semaphore to sleep on */
  72         int                     waitStatus;             /* STATUS_WAITING, STATUS_OK or STATUS_ERROR */
  73
  74         LocalTransactionId lxid;        /* local id of top-level transaction currently
  75                                                                  * being executed by this proc, if running;
  76                                                                  * else InvalidLocalTransactionId */
  77
  78         TransactionId xid;                      /* id of top-level transaction currently being
  79                                                                  * executed by this proc, if running and XID
  80                                                                  * is assigned; else InvalidTransactionId */
  81
  82         TransactionId xmin;                     /* minimal running XID as it was when we were
  83                                                                  * starting our xact, excluding LAZY VACUUM:
  84                                                                  * vacuum must not remove tuples deleted by
  85                                                                  * xid >= xmin ! */
  86
  87         int                     pid;                    /* This backend's process id, or 0 */
  88         BackendId       backendId;              /* This backend's backend ID (if assigned) */
  89         Oid                     databaseId;             /* OID of database this backend is using */
  90         Oid                     roleId;                 /* OID of role using this backend */
  91
  92         bool            inCommit;               /* true if within commit critical section */
  93
  94         uint8           vacuumFlags;    /* vacuum-related flags, see above */
  95
  96         /* Info about LWLock the process is currently waiting for, if any. */
  97         bool            lwWaiting;              /* true if waiting for an LW lock */
  98         bool            lwExclusive;    /* true if waiting for exclusive access */
  99         struct PGPROC *lwWaitLink;      /* next waiter for same LW lock */
 100
 101         /* Info about lock the process is currently waiting for, if any. */
 102         /* waitLock and waitProcLock are NULL if not currently waiting. */
 103         LOCK       *waitLock;           /* Lock object we're sleeping on ... */
 104         PROCLOCK   *waitProcLock;       /* Per-holder info for awaited lock */
 105         LOCKMODE        waitLockMode;   /* type of lock we're waiting for */
 106         LOCKMASK        heldLocks;              /* bitmask for lock types already held on this
 107                                                                  * lock object by this backend */
 108
 109         /*
 110          * All PROCLOCK objects for locks held or awaited by this backend are
 111          * linked into one of these lists, according to the partition number of
 112          * their lock.
 113          */
 114         SHM_QUEUE       myProcLocks[NUM_LOCK_PARTITIONS];
 115
 116         struct XidCache subxids;        /* cache for subtransaction XIDs */
 117 };
 118
 119 /* NOTE: "typedef struct PGPROC PGPROC" appears in storage/lock.h. */
 120
 121
 122 extern PGDLLIMPORT PGPROC *MyProc;
 123
 124
 125 /*
 126  * There is one ProcGlobal struct for the whole database cluster.
 127  */
 128 typedef struct PROC_HDR
 129 {
 130         /* Head of list of free PGPROC structures */
 131         PGPROC     *freeProcs;
 132         /* Head of list of autovacuum's free PGPROC structures */
 133         PGPROC     *autovacFreeProcs;
 134         /* Current shared estimate of appropriate spins_per_delay value */
 135         int                     spins_per_delay;
 136 } PROC_HDR;
 137
 138 /*
 139  * We set aside some extra PGPROC structures for auxiliary processes,
 140  * ie things that aren't full-fledged backends but need shmem access.
 141  *
 142  * Background writer, WAL writer, and autovacuum launcher run during
 143  * normal operation. When recovery has just finished, the startup
 144  * process can co-exist with them for a brief period before it exits.
 145  */
 146 #define NUM_AUXILIARY_PROCS             4
 147
 148
 149 /* configurable options */
 150 extern int      DeadlockTimeout;
 151 extern int      StatementTimeout;
 152 extern bool log_lock_waits;
 153
 154 extern volatile bool cancel_from_timeout;
 155
 156
 157 /*
 158  * Function Prototypes
 159  */
 160 extern int      ProcGlobalSemas(void);
 161 extern Size ProcGlobalShmemSize(void);
 162 extern void InitProcGlobal(void);
 163 extern void InitProcess(void);
 164 extern void InitProcessPhase2(void);
 165 extern void InitAuxiliaryProcess(void);
 166 extern bool HaveNFreeProcs(int n);
 167 extern void ProcReleaseLocks(bool isCommit);
 168
 169 extern void ProcQueueInit(PROC_QUEUE *queue);
 170 extern int      ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable);
 171 extern PGPROC *ProcWakeup(PGPROC *proc, int waitStatus);
 172 extern void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock);
 173 extern void LockWaitCancel(void);
 174
 175 extern void ProcWaitForSignal(void);
 176 extern void ProcSendSignal(int pid);
 177
 178 extern bool enable_sig_alarm(int delayms, bool is_statement_timeout);
 179 extern bool disable_sig_alarm(bool is_statement_timeout);
 180 extern void handle_sig_alarm(SIGNAL_ARGS);
 181
 182 #endif   /* PROC_H */